Was bedeutet Ertrag in PHP?

Diese Funktion mit Ausbeute:

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

ist fast das gleiche wie dieses ohne:

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

Mit nur einem Unterschied, dass a() ein generator und b() nur ein einfaches Array zurückgibt. Sie können auf beiden iterieren.

Außerdem weist der erste keine vollständige Anordnung zu und ist daher weniger speicherintensiv.

einfaches Beispiel

<?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#';
?>

Ausgabe

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

yield Schlüsselwort dient zur Definition von "Generatoren" in PHP 5.5. Ok, was ist dann ein Generator ?

Von php.net:

Generatoren bieten eine einfache Möglichkeit, einfache Iteratoren zu implementieren, ohne den Aufwand oder die Komplexität der Implementierung einer Klasse, die die Iterator-Schnittstelle implementiert.

Mit einem Generator können Sie Code schreiben, der mit foreach einen Datensatz durchläuft, ohne ein Array im Speicher erstellen zu müssen. Dies kann dazu führen, dass Sie ein Speicherlimit überschreiten oder eine erhebliche Verarbeitungszeit für die Generierung benötigen. Stattdessen können Sie eine Generatorfunktion schreiben, die mit einer normalen Funktion identisch ist, mit der Ausnahme, dass ein Generator nicht nur einmal zurückgegeben wird, sondern auch so oft liefert, wie es erforderlich ist, um die Werte bereitzustellen, über die iteriert werden soll.

Von diesem Ort: Generatoren = Generatoren, andere Funktionen (nur einfache Funktionen) = Funktionen.

Sie sind also nützlich, wenn:

• Sie müssen die Dinge einfach (oder einfach) machen;

  generator ist wirklich viel einfacher als die Implementierung der Iterator-Schnittstelle. Andererseits sind Generatoren natürlich weniger funktionsfähig. vergleiche sie .

• Sie müssen große Datenmengen erzeugen - Speicher sparen;

  um Speicherplatz zu sparen, können wir einfach die benötigten Daten über Funktionen für jede Schleifeniteration generieren und nach der Iteration Garbage verwenden. Hier geht es also vor allem um eindeutigen Code und wahrscheinlich um Leistung. sehen Sie, was für Ihre Bedürfnisse besser ist.

• Sie müssen eine Sequenz generieren, die von Zwischenwerten abhängt;

  dies erweitert den vorherigen Gedanken. Generatoren können es im Vergleich zu Funktionen einfacher machen. überprüfen Sie Fibonacci-Beispiel und versuchen Sie, eine Sequenz ohne Generator zu erstellen. Auch Generatoren können in diesem Fall schneller arbeiten, zumindest weil Zwischenwerte in lokalen Variablen gespeichert werden.

• Sie müssen die Leistung verbessern.

  sie können in einigen Fällen schneller arbeiten als sie funktionieren (siehe vorheriger Nutzen).

Mit yield können Sie auf einfache Weise die Haltepunkte zwischen mehreren Aufgaben in einer einzigen Funktion beschreiben. Das ist alles, es gibt nichts Besonderes.

$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, ...);

Wenn task1 und task2 eng miteinander verbunden sind, Sie jedoch einen Haltepunkt zwischen ihnen benötigen, um etwas anderes zu tun:

• freier Speicher zwischen der Verarbeitung von Datenbankzeilen
• führen Sie andere Tasks aus, die eine Abhängigkeit von der nächsten Task bieten, für die jedoch keine Beziehung zum aktuellen Code besteht
• asynchrone Anrufe tätigen und auf die Ergebnisse warten
• und so weiter ...

dann sind Generatoren die beste Lösung, da Sie Ihren Code nicht in viele Closures aufteilen oder mit anderem Code mischen oder Rückrufe usw. verwenden müssen. Sie verwenden einfach yield, um einen Haltepunkt hinzuzufügen. und Sie können von diesem Haltepunkt aus fortfahren, wenn Sie bereit sind.

Haltepunkt ohne Generatoren hinzufügen:

$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);
//...

Haltepunkt mit Generatoren hinzufügen

$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);

Hinweis: Es ist leicht, Fehler mit Generatoren zu machen. Schreiben Sie daher immer Unit-Tests, bevor Sie sie implementieren!Hinweis 2: Die Verwendung von Generatoren in einer Endlosschleife ist wie das Schreiben eines Verschlusses mit unendlicher Länge. ..

Ein interessanter Aspekt, der hier diskutiert werden sollte, ist nter Bezugnahme. Jedes Mal, wenn wir einen Parameter so ändern müssen, dass er außerhalb der Funktion angezeigt wird, müssen wir diesen Parameter als Referenz übergeben. Um dies auf Generatoren anzuwenden, stellen wir dem Namen des Generators und der in der Iteration verwendeten Variablen einfach ein kaufmännisches Und & Voran:

 <?php 
 /**
 * Yields by reference.
 * @param int $from
 */
function &counter($from) {
    while ($from > 0) {
        yield $from;
    }
}

foreach (counter(100) as &$value) {
    $value--;
    echo $value . '...';
}

// Output: 99...98...97...96...95...

Das obige Beispiel zeigt, wie durch Ändern der iterierten Werte in der foreach -Schleife die Variable $from Im Generator geändert wird. Dies liegt daran, dass $from Aufgrund des kaufmännischen Und-Zeichens vor dem Namen des Generators als Referenz angegeben ist. Aus diesem Grund ist die Variable $value In der foreach -Schleife eine Referenz auf die Variable $from In der Generatorfunktion.