Que signifie rendement en PHP?

yield Sert de mot-clé pour la définition de "générateurs" en PHP 5.5. Ok, alors qu'est ce qu'un générateur ?

de php.net:

Les générateurs

fournissent un moyen facile de mettre en œuvre des itérateurs simples sans frais généraux ou complexité de mise en œuvre d'une classe qui met en œuvre l'interface Itératrice.

Un générateur vous permet d'écrire du code qui utilise foreach pour parcourir un ensemble de données sans avoir besoin de construire un tableau en mémoire, ce qui peut vous amener à dépasser une limite de mémoire, ou nécessite une quantité considérable de temps de traitement pour générer. Au lieu de cela, vous pouvez écrire une fonction de générateur, qui est le même comme une fonction normale, sauf qu'au lieu de retourner une fois, un générateur peut produire autant de fois que nécessaire afin de fournir les valeurs pour être itéré.

de cet endroit: générateurs = générateurs, autres fonctions (juste un des fonctions simples) = fonctions.

donc, ils sont utiles quand:

• vous devez faire des choses simples (ou des choses simples);

  générateur est vraiment beaucoup plus simple que la mise en œuvre de l'interface Iterator. d'un autre côté, les générateurs sont souvent moins fonctionnels. comparez-les .

• vous avez besoin pour générer de grandes quantités de mémoire de sauvegarde de données;

  en fait pour sauver de la mémoire, nous pouvons juste générer des données nécessaires via des fonctions pour chaque itération de boucle, et après itération utiliser des déchets. donc voici les points principaux Est-code clair et probablement la performance. voir ce qui est mieux pour vos besoins.

• vous devez générer une séquence, qui dépend des valeurs intermédiaires;

  c'est l'extension de la précédente pensée. les générateurs peuvent rendre les choses plus facile en comparaison avec les fonctions. cochez Fibonacci exemple , et essayez de faire séquence sans générateur. Aussi les générateurs peuvent fonctionner plus rapidement est ce cas, au moins en raison de stocker des valeurs intermédiaires dans les variables locales;

• vous avez besoin pour améliorer les performances.

  ils peuvent travailler plus vite alors fonctions dans certains cas (voir prestation antérieure);

exemple simple

<?php
echo '#start main# ';
function a(){
    echo '{start[';
    for($i=1; $i<=9; $i++)
        yield $i;
    echo ']end} ';
}
foreach(a() as $v)
    echo $v.',';
echo '#end main#';
?>

sortie

#start main# {start[1,2,3,4,5,6,7,8,9,]end} #end main#

cette fonction utilise le rendement:

function a($items) {
    foreach ($items as $item) {
        yield $item + 1;
    }
}

est presque le même que celui sans:

function b($items) {
    $result = [];
    foreach ($items as $item) {
        $result[] = $item + 1;
    }
    return $result;
}

avec une seule différence que a() retourne un générateur et b() juste un tableau simple. Vous pouvez itérer sur les deux.

en outre, le premier n'alloue pas un tableau complet et est donc moins exigeant en mémoire.

avec yield vous pouvez facilement décrire les points de rupture entre plusieurs tâches dans une seule fonction. C'est tout, il n'y a rien de spécial à ce sujet.

$closure = function ($injected1, $injected2, ...){
    $returned = array();
    //task1 on $injected1
    $returned[] = $returned1;
//I need a breakpoint here!!!!!!!!!!!!!!!!!!!!!!!!!
    //task2 on $injected2
    $returned[] = $returned2;
    //...
    return $returned;
};
$returned = $closure($injected1, $injected2, ...);

si la tâche1 et la tâche2 sont fortement liées, mais vous avez besoin d'un point de rupture entre elles pour faire autre chose:

• libérer de la mémoire entre le traitement de base de données les lignes
• exécuter d'autres tâches qui fournissent la dépendance à la tâche suivante, mais qui sont non lié par la compréhension du code actuel
• faire des appels asynchrones et d'attendre les résultats
• et ainsi de suite ...

alors les générateurs sont la meilleure solution, parce que vous n'avez pas à diviser votre code en plusieurs fermetures ou le mélanger avec d'autres codes, ou utiliser des callbacks, etc... Vous utilisez juste yield pour ajouter un point de rupture, et vous pouvez continuer à partir de ce point de rupture si vous êtes prêt.

ajouter point de rupture sans générateur:

$closure1 = function ($injected1){
    //task1 on $injected1
    return $returned1;
};
$closure2 = function ($injected2){
    //task2 on $injected2
    return $returned1;
};
//...
$returned1 = $closure1($injected1);
//breakpoint between task1 and task2
$returned2 = $closure2($injected2);
//...

ajouter le point de rupture avec les générateurs

$closure = function (){
    $injected1 = yield;
    //task1 on $injected1
    $injected2 = (yield($returned1));
    //task2 on $injected2
    $injected3 = (yield($returned2));
    //...
    yield($returnedN);
};
$generator = $closure();
$returned1 = $generator->send($injected1);
//breakpoint between task1 and task2
$returned2 = $generator->send($injected2);
//...
$returnedN = $generator->send($injectedN);

note: il est facile de faire des erreurs avec les générateurs, donc toujours écrire des tests de l'unité avant de les mettre en œuvre! note2: utiliser des générateurs dans une boucle infinie est comme écrire une fermeture qui a une longueur infinie...