Vous guide à travers une explication détaillée de l'utilisation du générateur PHP

Apprenez à utiliser les générateurs PHP

Qu'est-ce qu'un générateur ?

Le nom sophistiqué ressemble à une fonction permettant de créer quelque chose. En fait, le générateur est un itérateur pour l'itération. Il 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 considérablement réduites.

Recommandé : "Tutoriel vidéo PHP"

Après avoir longuement parlé, il est plus intuitif de regarder directement le code.

function test1()
{
    for ($i = 0; $i < 3; $i++) {
        yield $i + 1;
    }
    yield 1000;
    yield 1001;
}
foreach (test1() as $t) {
    echo $t, PHP_EOL;
}
// 1
// 2
// 3
// 1000
// 1001

C'est un morceau de code tellement simple. Premièrement, le générateur doit être dans la méthode et utiliser le mot clé rendement ; deuxièmement, chaque rendement peut être considéré comme un retour ; enfin, lorsque la boucle externe est utilisée, la valeur de retour d'un rendement est prise à la fois ; Dans cet exemple, la boucle renvoie trois fois les trois nombres 1, 2 et 3. Ensuite, écrivez deux autres lignes de rendement en dehors de la boucle pour afficher respectivement 1 000 et 1 001. Par conséquent, la boucle foreach externe génère un total de cinq fois.

C'est incroyable, c'est évidemment une méthode, pourquoi peut-on la boucler et c'est quand même un format très étrange pour renvoyer le corps de la boucle. Imprimons directement cette méthode test() pour voir ce qui est imprimé :

// 是一个生成器对象
var_dump(test1());
// Generator Object
// (
// )

Lorsque rendement est utilisé pour renvoyer du contenu, un objet Générateur est renvoyé. Cet objet est appelé objet générateur. Il ne peut pas être instancié directement par new et ne peut être renvoyé que via la fonction générateur. Cette classe contient des méthodes telles que current() et key(), et le plus important est que cette classe implémente l'interface Iterator, c'est donc une classe itérateur spéciale.

Generator implements Iterator {
    /* 方法 */
    public current ( void ) : mixed
    public key ( void ) : mixed
    public next ( void ) : void
    public rewind ( void ) : void
    public send ( mixed $value ) : mixed
    public throw ( Exception $exception ) : void
    public valid ( void ) : bool
    public __wakeup ( void ) : void
}

A quoi sert le générateur ?

N'est-ce pas juste un itérateur après avoir travaillé longtemps dessus ? Pourquoi se donner tant de mal ? Ne serait-il pas préférable d'utiliser simplement un itérateur ou de renvoyer directement un tableau dans la méthode ? Oui, ce n'est vraiment pas si gênant dans des circonstances normales, mais si la quantité de données est particulièrement importante, ce générateur peut exercer sa puissante puissance. La partie la plus puissante du générateur est qu’il ne nécessite aucun tableau ni aucune structure de données pour stocker cette série de données. Chaque itération est renvoyée dynamiquement lorsque le code est exécuté pour produire. Par conséquent, le générateur peut économiser considérablement de la mémoire.

// 内存占用测试
$start_time = microtime(true);
function test2($clear = false)
{
    $arr = [];
    if($clear){
        $arr = null;
        return;
    }
    for ($i = 0; $i < 1000000; $i++) {
        $arr[] = $i + 1;
    }
    return $arr;
}
$array = test2();
foreach ($array as $val) {
}
$end_time = microtime(true);
echo "time: ", bcsub($end_time, $start_time, 4), PHP_EOL;
echo "memory (byte): ", memory_get_usage(true), PHP_EOL;
// time: 0.0513
// memory (byte): 35655680
$start_time = microtime(true);
function test3()
{
    for ($i = 0; $i < 1000000; $i++) {
        yield $i + 1;
    }
}
$array = test3();
foreach ($array as $val) {
}
$end_time = microtime(true);
echo "time: ", bcsub($end_time, $start_time, 4), PHP_EOL;
echo "memory (byte): ", memory_get_usage(true), PHP_EOL;
// time: 0.0517
// memory (byte): 2097152

Le code ci-dessus obtient simplement le résultat après 1 000 000 de boucles, mais il peut aussi être vu intuitivement. La version utilisant le générateur ne consomme que 2 Mo de mémoire, tandis que la version sans générateur consomme 35 Mo de mémoire, soit plus de 10 fois la différence, et plus la différence est grande, plus la différence est évidente. Par conséquent, certains experts affirment que le générateur est la fonctionnalité la plus sous-estimée de PHP.

Applications des générateurs

Jetons ensuite un coup d'œil à quelques applications de base des générateurs.

Renvoyer une valeur nulle et interrompre

Bien sûr, le générateur peut également renvoyer une valeur nulle, il suffit de rendement sans aucune valeur pour renvoyer une valeur nulle ; L'utilisation de return; directement dans une méthode peut également être utilisée pour interrompre l'exécution continue du générateur. Dans le code suivant, nous renvoyons une valeur nulle lorsque $i = 4 ;, c'est-à-dire que 5 ne sera pas affiché (car nous renvoyons $i + 1). Ensuite, lorsque $i == 7

utilisez return; pour interrompre l'exécution continue du générateur, c'est-à-dire que la boucle ne produira que jusqu'à 7 et se terminera.

// 返回空值以及中断
function test4()
{
    for ($i = 0; $i < 10; $i++) {
        if ($i == 4) {
            yield; // 返回null值
        }
        if ($i == 7) {
            return; // 中断生成器执行
        }
        yield $i + 1;
    }
}
foreach (test4() as $t) {
    echo $t, PHP_EOL;
}
// 1
// 2
// 3
// 4
// 5
// 6
// 7

Renvoyer des paires clé-valeur

Ne soyez pas surpris, le générateur peut vraiment renvoyer un objet traversable sous la forme de paires clé-valeur à utiliser par foreach, et la syntaxe est très facile à retenir : rendement clé = > valeur ; Est-ce exactement la même chose que la forme de définition des éléments du tableau ? C'est très intuitif et facile à comprendre.

function test5()
{
    for ($i = 0; $i < 10; $i++) {
        yield &#39;key.&#39; . $i => $i + 1;
    }
}
foreach (test5() as $k=>$t) {
    echo $k . &#39;:&#39; . $t, PHP_EOL;
}
// key.0:1
// key.1:2
// key.2:3
// key.3:4
// key.4:5
// key.5:6
// key.6:7
// key.7:8
// key.8:9
// key.9:10

Transmission de données en externe

Nous pouvons transmettre une valeur au générateur via la méthode Generator::send. La valeur transmise sera traitée comme la valeur de retour du rendement actuel du générateur. Nous pouvons ensuite porter certains jugements basés sur cette valeur, comme interrompre l'exécution du générateur en fonction de conditions externes.

function test6()
{
    for ($i = 0; $i < 10; $i++) {
        // 正常获取循环值，当外部send过来值后，yield获取到的就是外部传来的值了
        $data = (yield $i + 1);
        if($data == &#39;stop&#39;){
            return;
        }
    }
}
$t6 = test6();
foreach($t6 as $t){
    if($t == 3){
        $t6->send(&#39;stop&#39;);
    }
    echo $t, PHP_EOL;
}
// 1
// 2
// 3

Le code ci-dessus peut être déroutant à comprendre, mais rappelez-vous simplement la ligne dans le commentaire (obtenez la valeur de la boucle normalement, lorsque la valeur est envoyée de l'extérieur, ce que le rendement obtient est la valeur de l'extérieur) . De plus, les variables doivent être mises entre parenthèses pour obtenir la valeur du rendement.

rendement de la syntaxe

rendement de la syntaxe fait en fait référence à l'obtention de données une par une à partir d'un autre objet itérable et à la formation d'un retour générateur. Regardez simplement le code.

function test7()
{
    yield from [1, 2, 3, 4];
    yield from new ArrayIterator([5, 6]);
    yield from test1();
}
foreach (test7() as $t) {
    echo 'test7：', $t, PHP_EOL;
}
// test7：1
// test7：2
// test7：3
// test7：4
// test7：5
// test7：6
// test7：1
// test7：2
// test7：3
// test7：1000

Dans la méthode test7(), nous utilisons le rendement de pour obtenir les données d'un tableau ordinaire, d'un objet itérateur et d'un autre générateur respectivement et les renvoyons comme contenu du générateur actuel.

Petite surprise

Le générateur peut-il utiliser le comptage pour obtenir la quantité ?

Désolé, le générateur ne peut pas utiliser le comptage pour obtenir sa quantité.

$c = count(test1()); // Warning: count(): Parameter must be an array or an object that implements Countable
// echo $c, PHP_EOL;

L'utilisation du nombre pour obtenir le nombre de générateurs signalera directement un avertissement d'avertissement. La sortie directe affichera toujours 1 en raison des caractéristiques du nombre (le forcer dans un tableau affichera 1).

Utilisez le générateur pour obtenir la séquence de Fibonacci

// 利用生成器生成斐波那契数列
function fibonacci($item)
{
    $a = 0;
    $b = 1;
    for ($i = 0; $i < $item; $i++) {
        yield $a;
        $a = $b - $a;
        $b = $a + $b;
    }
}
$fibo = fibonacci(10);
foreach ($fibo as $value) {
    echo "$value\n";
}

Ce code ne nécessite pas beaucoup d'explications, c'est un morceau de code très intuitif.

Résumé

Le générateur est définitivement un trésor caché en PHP, non seulement pour économiser de la mémoire, mais la syntaxe est en fait très concise et claire. Nous n'avons pas besoin de définir un tableau supplémentaire à l'intérieur de la méthode pour stocker la valeur de retour, nous pouvons simplement produire et renvoyer un par un. Cela vaut vraiment la peine de l'essayer dans des projets réels, mais n'oubliez pas de le partager avec vos amis après l'avoir essayé. La plupart des gens n'ont peut-être jamais été exposés à cette fonctionnalité ! !

Code de test : https://github.com/zhangyue0503/dev-blog/blob/master/php/202002/source/%E5%AD%A6%E4%B9%A0PHP%E7%94% 9F%E6%88%90%E5%99%A8%E7%9A%84%E4%BD%BF%E7%94%A8.php

Document de référence : https://www.php. net/manual/zh/langage.generators.overview.php https://www.php.net/manual/zh/class.generator.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!