Exemples pour expliquer l'itérateur et le générateur en PHP

Itérateur et générateur en PHP

Avant d'expliquer le générateur, commençons par présenter les itérateurs :

En PHP, utilisez généralement foreach pour parcourir un tableau.

Et si nous voulons rendre un objet traversable ?

PHP nous fournit l'interface Iterator. Tant que cette interface est implémentée, cet objet peut être itéré via foreach.

L'exemple est le suivant :

class myIterator implements Iterator {
    private $index = 0;
    private $data = '';

    public function __construct($data) {
        $this->index = 0;
        $this->data = $data;
    }

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

    function current() {
        return $this->data[$this->index];
    }

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

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

    function valid() {
        return isset($this->data[$this->index]);
    }
}

$it = new myIterator(array(
    "hello",
    "php",
    "iterator",
));
foreach($it as $key => $value) {
    echo "$key : $value<br>";
}

Lorsque nous parcourons $it via foreach, PHP s'appellera dans l'ordre :

rewind() Réinitialise le premier élément
valid() Vérifiez si la position actuelle est valide
current() Renvoie l'élément actuel
key()   Renvoie la clé de l'élément actuel
next() Pointe vers l'élément suivant

Le générateur est une nouvelle fonctionnalité introduite dans PHP 5.5, mais peu de gens semblent l'utiliser présent.

Ce qui suit est une explication du générateur dans la documentation officielle PHP :

Le générateur fournit un moyen plus simple d'implémenter une itération d'objet simple. Par rapport à la manière de définir une classe pour implémenter l'interface Iterator, la surcharge de performances et la complexité sont. grandement réduit.

Les générateurs vous permettent d'écrire du code dans un bloc foreach pour parcourir un ensemble de données sans créer de tableau en mémoire, ce qui atteindrait votre limite de mémoire ou prendrait un temps de traitement considérable.

Au lieu de cela, vous pouvez écrire une fonction génératrice comme une fonction personnalisée normale. Contrairement à une fonction normale qui ne renvoie qu'une seule fois, un générateur peut produire autant de fois que nécessaire pour générer des valeurs qui doivent être itérées.

Afin de refléter les avantages du générateur, définissons une fonction de comparaison :

function func1()
{
    foreach (range(0, 1000000) as $value){
        echo $value;
    }
}

func1();
// ( ! ) Fatal error: Allowed memory size of 134217728 bytes exhausted (tried to allocate 402653192 bytes) in xxx.php on line 5

Parce qu'un si grand tableau est créé et itéré en mémoire, PHP indique directement que la limite de mémoire d'un seul processus est dépassée.

Utilisons maintenant un générateur pour le gérer :

function func1()
{
    foreach (range(0, 1000000) as $value){
        yield $value;
    }
}

var_dump(func1()); // object(Generator)[1]
foreach (func1() as $value){
    echo $value;
}

Vous pouvez voir que nous avons appelé func1() et renvoyé un objet Generator. Cet objet peut être itéré en utilisant foreach. Pour chaque itération, PHP demandera à l'instance Generator de calculer et. fournissez la valeur A suivante sur laquelle parcourir.

L'élégance du générateur se reflète dans le fait que chaque fois qu'une valeur est produite, l'état interne du générateur se mettra en pause.

L'état interne sera restauré lorsque la valeur suivante sera demandée au générateur ; L'état interne du générateur continuera de basculer entre pause et reprise jusqu'à ce que la fin du corps de définition de la fonction soit atteinte ou qu'une instruction return vide soit rencontrée.

【Apprentissage recommandé : Tutoriel vidéo PHP】

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!