Amusant avec des interfaces de tableau

points clés

• L'interface de tableau de PHP permet aux programmeurs de simuler les caractéristiques des types de données natifs dans des classes personnalisées, similaires aux méthodes de Python. Cela permet aux classes personnalisées de fonctionner comme des tableaux et permet des opérations de tableau communes telles que le comptage des éléments, la boucle à travers des éléments et l'accès aux éléments via des index.
Les interfaces
• sont comme des contrats pour les classes, spécifiant les méthodes que les classes doivent contenir. Ils permettent l'encapsulation des détails de la mise en œuvre et fournissent du sucre de syntaxe, améliorant ainsi la lisibilité et la maintenabilité du code. PHP fournit une bibliothèque d'interfaces prédéfinies qui peuvent implémenter ces interfaces pour fabriquer des objets similaires aux tableaux.
Les interfaces
• , Countable et ArrayAccess dans Iterator php permettent aux objets de passer les méthodes count(), d'accès comme des cartes et d'itérer les ensembles, respectivement. Ces interfaces peuvent être utilisées pour créer des objets plus dynamiques et interactifs, tels que les classes de chronologie Twitter qui peuvent compter leur nombre de tweets, faire des boucles à travers eux et accéder aux tweets via leur identifiant.

En tant que programmeur qui utilise différents langages de programmation chaque jour, j'aime vraiment apprendre différentes choses dans d'autres langages et essayer d'implémenter les mêmes fonctionnalités en PHP. J'aime particulièrement la fonctionnalité de Python comment simuler les types de données natifs dans les classes personnalisées.

par exemple, cette classe de liste de membres:

<code class="language-php">class Members {
    public function __construct(array $members) {
        $this->members = $members;
    }

    // 其他方法
}</code>

En implémentant la méthode __iter__, vous pouvez itérer les données dans des cas tels que l'itération d'une liste (tableau en php):

<code class="language-php">class Members implements Iterator {
    private $members;
    private $position = 0;

    public function __construct(array $members) {
        $this->members = $members;
    }

    public function current() {
        return $this->members[$this->position];
    }

    public function key() {
        return $this->position;
    }

    public function next() {
        $this->position++;
    }

    public function rewind() {
        $this->position = 0;
    }

    public function valid() {
        return isset($this->members[$this->position]);
    }
}

$ls = new Members(["你", "我"]);

foreach ($ls as $member) {
    echo $member . "\n";
}</code>

Le test d'adhésion doit uniquement être mis en œuvre __contains__ Méthode:

<code class="language-php">class Members {
    public function __construct(array $members) {
        $this->members = $members;
    }

    public function contains($member) {
        return in_array($member, $this->members);
    }
}

$members = new Members(["你", "我"]);

if ($members->contains("我")) {
    echo "我是一个成员！\n";
}</code>

Je pense que ce serait formidable si je pouvais faire ce qui suit en PHP dans un cas d'une classe personnalisée (pas seulement un tableau):

<code class="language-php">isset($myObject["test"]);</code>

PHP nous permet d'y parvenir à l'aide d'une interface de tableau.

Brève description de l'interface

Traitez une interface comme un contrat pour que la classe spécifiée contienne des méthodes.

<code class="language-php">interface Multiplier {
    public function multiply($num1, $num2);
}</code>

Toute classe utilisant cette interface doit avoir cette méthode multiply. Il existe un mot-clé qui indique que la classe satisfait ce contrat: implements.

<code class="language-php">class SmartMultiplier implements Multiplier {
    public function multiply($num1, $num2) {
        return $num1 * $num2;
    }
}</code>

Tant que le contrat est satisfait, la méthode de mise en œuvre n'est pas pertinente. Une autre façon d'implémenter la méthode multiply est la suivante:

<code class="language-php">class NotSoSmartMultiplier implements Multiplier {
    public function multiply($num1, $num2) {
        $product = $num1;
        for ($i = 1; $i < $num2; $i++) {
            $product += $num1;
        }
        return $product;
    }
}</code>

interfaces SPL et PHP

PHP fournit une bibliothèque d'interfaces prédéfinies qui peuvent rendre nos objets similaires aux tableaux en implémentant ces interfaces dans une classe.

Certaines de ces interfaces sont incluses dans les interfaces et les listes de classes prédéfinies, et certaines sont incluses dans la bibliothèque PHP standard (SPL).

Si ces termes semblent intimidants, ne vous inquiétez pas. Vous avez déjà utilisé $_GET. $_GET est une structure linguistique appelée prédéfinie .

En revanche, selon la documentation, SPL est juste

Une collection d'interfaces et de classes conçues pour résoudre des problèmes communs.

Ce que nous devons faire maintenant, c'est voir l'application réelle de ces interfaces. Discutons-y!

Nous créerons une classe Twitter Timeline,

<code class="language-php">class Members {
    public function __construct(array $members) {
        $this->members = $members;
    }

    // 其他方法
}</code>

peut être capable de calculer le nombre de tweets,

<code class="language-php">class Members implements Iterator {
    private $members;
    private $position = 0;

    public function __construct(array $members) {
        $this->members = $members;
    }

    public function current() {
        return $this->members[$this->position];
    }

    public function key() {
        return $this->position;
    }

    public function next() {
        $this->position++;
    }

    public function rewind() {
        $this->position = 0;
    }

    public function valid() {
        return isset($this->members[$this->position]);
    }
}

$ls = new Members(["你", "我"]);

foreach ($ls as $member) {
    echo $member . "\n";
}</code>

boucle à travers eux,

<code class="language-php">class Members {
    public function __construct(array $members) {
        $this->members = $members;
    }

    public function contains($member) {
        return in_array($member, $this->members);
    }
}

$members = new Members(["你", "我"]);

if ($members->contains("我")) {
    echo "我是一个成员！\n";
}</code>

et obtenez le tweet via l'ID de tweet,

<code class="language-php">isset($myObject["test"]);</code>

comme nous sommes dans un tableau normal!

Cependant, nous devons d'abord résoudre certains problèmes. Si vous n'avez pas encore de compte Twitter, créez-en un en premier. Enregistrez un compte de développeur maintenant et générez un jeton d'accès et une clé.

Ensuite, téléchargez ou clonez le code de GitHub et exécutez composer install dans le dossier source. Si vous n'êtes pas familier avec Composer, consultez les articles précédents de SitePoint. Ouvrez le fichier index.php et ajoutez les données OAuth nécessaires.

Countable Interface

Countable L'interface est probablement la plus explicite. Implémentez simplement la méthode count et vous pouvez transmettre l'objet à la méthode count().

Nous pouvons obtenir le nombre de tweets d'utilisateurs en effectuant une demande GET sur "/ utilisateurs / show".

<code class="language-php">interface Multiplier {
    public function multiply($num1, $num2);
}</code>

ArrayAccess Interface

Nous allons maintenant augmenter la difficulté en apprenant une interface plus intéressante.

Après l'implémentation,

permettra à nos objets d'accéder comme des cartes, ce qui est exactement leur essence. La méthode à réaliser est ArrayAccess

<code class="language-php">class SmartMultiplier implements Multiplier {
    public function multiply($num1, $num2) {
        return $num1 * $num2;
    }
}</code>

C'est très pratique dans nos objets Twitter Timeline. Tester si un tweet existe dans la chronologie peut être effectué en transmettant notre objet à

comme indiqué ci-dessous: isset

<code class="language-php">class NotSoSmartMultiplier implements Multiplier {
    public function multiply($num1, $num2) {
        $product = $num1;
        for ($i = 1; $i < $num2; $i++) {
            $product += $num1;
        }
        return $product;
    }
}</code>

Pour ce faire, nous avons juste besoin d'effectuer une demande GET à l'ID de tweet.

<code class="language-php">$tweets = new Timeline("jeunito");</code>

Mieux encore, nous pouvons également utiliser ce qui précède pour

et laisser offsetGet appeler offsetExists à son tour. offsetGet

En utilisant

, nous pouvons également le supprimer avec l'ID de tweet, mais je vais vous laisser cela pour implémenter. offsetUnset

Malheureusement, atteindre

n'a pas beaucoup de sens. Pour quelque chose comme ça, la solution simple consiste à lancer une exception personnalisée, comme offsetSet. Mais d'un autre côté, cela peut également dépendre des règles commerciales spécifiques de votre application. UnsupportedOperationException

Interface Iterator

J'ai enregistré mon interface préférée pour le dernier! L'interface

est très utile ici, car je ne pense pas qu'il y ait une meilleure façon de résumer les détails de la pagination de la collection distante que d'itérer sur des objets de la chronologie comme itération sur les tableaux normaux. Iterator

Tout d'abord, la méthode suivante doit être mise en œuvre:

<code class="language-php">count($tweets);</code>

Nous pouvons utiliser explicitement la méthode ci-dessus pour parcourir notre chronologie, comme indiqué ci-dessous:

<code class="language-php">foreach ($tweets as $tweet) {
    echo $tweet;
}</code>

Mais pourquoi faire cela, quand vous pouvez:

<code class="language-php">// 获取
if (isset($tweets["some tweet id"])) {
    echo $tweets["some tweet id"];
}</code>

Dans notre exemple, nous traverserons les tweets dans la chronologie en récupérant des blocs de tweet dans l'ordre chronologique et en les stockant dans un tampon. Nous allons itérer ce tampon jusqu'à ce qu'il s'épuise, puis nous utilisons l'ID du dernier tweet comme décalage pour obtenir un autre lot de tweets.

Au début, nous n'avions pas de tweets, et c'est là que la méthode rewind est intervenue: obtenez les 10 derniers tweets pour commencer le décalage de l'endroit où nous pouvons obtenir les 10 prochains tweets.

<code class="language-php">class Members {
    public function __construct(array $members) {
        $this->members = $members;
    }

    // 其他方法
}</code>

La méthode

valid() est uniquement utilisée pour indiquer si la boucle continue. Cela peut être fait en vérifiant si notre tweet est vide:

<code class="language-php">class Members implements Iterator {
    private $members;
    private $position = 0;

    public function __construct(array $members) {
        $this->members = $members;
    }

    public function current() {
        return $this->members[$this->position];
    }

    public function key() {
        return $this->position;
    }

    public function next() {
        $this->position++;
    }

    public function rewind() {
        $this->position = 0;
    }

    public function valid() {
        return isset($this->members[$this->position]);
    }
}

$ls = new Members(["你", "我"]);

foreach ($ls as $member) {
    echo $member . "\n";
}</code>

Les méthodes

key() et current() renvoient simplement les clés et les valeurs du tweet actuel dans notre itération. Pour nos besoins, nous obtiendrons simplement l'ID de tweet et le texte du dernier tweet du tampon.

<code class="language-php">class Members {
    public function __construct(array $members) {
        $this->members = $members;
    }

    public function contains($member) {
        return in_array($member, $this->members);
    }
}

$members = new Members(["你", "我"]);

if ($members->contains("我")) {
    echo "我是一个成员！\n";
}</code>

Enfin Méthode next. Ici, nous nous déshabillons de la tête du tampon pour obtenir le prochain élément à itérer. Ensuite, si nous sommes sur le dernier élément du tampon, nous nous assurerons d'obtenir le prochain ensemble de tweets.

<code class="language-php">isset($myObject["test"]);</code>

Nous avons terminé! Il s'agit d'une implémentation très basique de la boucle via des tweets utilisateur. Il y a plus de choses qui peuvent être faites, comme le cache local pour enregistrer les appels d'API, mais c'est la beauté de l'utilisation d'interfaces: ils nous permettent de changer nos politiques en arrière-plan, et tant que notre implémentation est toujours correcte, nous pouvons nous attendre Il fonctionne toujours.

Mais maintenant, vous pouvez observer comment nos objets de chronologie fonctionnent en exécutant php index.php sur la ligne de commande.

Conclusion

Les avantages de l'interface sont doubles. Ils nous permettent d'encapsuler les détails de l'implémentation et de nous fournir du sucre syntaxique, qui sont tous deux très utiles dans toute application qui nécessite une interopérabilité. Si vous avez des questions ou des commentaires, veuillez les laisser dans la section des commentaires ci-dessous!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!