Generatoren bieten eine speichereffiziente Möglichkeit, über große Datenmengen zu iterieren, indem sie Werte einzeln nacheinander (lazy) mit dem yield-Schlüsselwort produzieren, anstatt ein komplettes Array auf einmal im Speicher zu erstellen. Sie sind ideal für große oder Streaming-Daten.
{
= [];
( = ; < ; ++) { [] = ; }
;
}
{
( = ; < ; ++) {
;
}
}
(() ) {
();
}
yield macht eine Funktion zu einem Generator: Sie produziert Werte lazy, einer pro Iteration, und behält ihren Zustand zwischen den Iterationen — daher bleibt der Speicher konstant, egal wie viele Werte sie produziert.
function readLines(string $file): Generator {
$handle = fopen($file, 'r');
while (($line = fgets($handle)) !== false) {
yield $line; // yield one line at a time — never load the whole file
}
fclose($handle);
}
foreach (readLines('huge-10gb.csv') as $line) { // processes a 10GB file with tiny memory
process($line);
}
Eine riesige Datei mit einem Generator Zeile für Zeile zu lesen, verbraucht konstanten Speicher — unmöglich mit file() (die die gesamte Datei in ein Array laden würde).
function fetchRows(PDOStatement $stmt): Generator {
while ($row = $stmt->fetch()) {
yield $row['id'] => $row; // yield key => value, streaming DB rows
}
}
Generatoren sind großartig für Streaming von Datenbankergebnissen — verarbeite Reihen einzeln nacheinander, anstatt ein riesiges Resultset in den Speicher zu laden.
Generatoren sind ein wichtiges PHP-Feature für speichereffiziente Verarbeitung großer Datenmengen — und das Verständnis dafür ist wertvoll beim Aufbau von Anwendungen, die Daten in großem Maßstab verarbeiten, ohne den Speicher zu überlasten.
Das Kernproblem, das sie lösen: Das Erstellen eines vollständigen Arrays aus großen Daten (Millionen von Datensätzen, Millionen von Zeilen einer riesigen Datei, ein großes Datenbankergebnis) kann enormen Speicher verbrauchen und die Anwendung zum Abstürz bringen, während Generatoren Werte lazy, einzeln nacheinander produzieren und den Speicher konstant halten, egal wie groß der Datensatz ist.
Die impactreichsten Use Cases sind praktisch und verbreitet: Lesen großer Dateien Zeile für Zeile (Verarbeitung einer Multi-Gigabyte-CSV oder eines Logs mit minimalem Speicher, unmöglich mit Funktionen, die alles auf einmal laden), Streaming von Datenbankergebnissen (Verarbeitung großer Abfrageergebnisse Reihe für Reihe) und Verarbeitung großer oder sogar unendlicher Sequenzen.
Das Verständnis von yield, Lazy Evaluation und wann man zu Generatoren greifen sollte (jedes Mal, wenn man sonst ein großes Array im Speicher erstellen würde), ermöglicht es dir, skalierbaren Code zur Datenverarbeitung zu schreiben, der große Datenmengen elegant verarbeitet — ein häufiges echtes Bedürfnis in Batch-Jobs, Importen/Exporten, Report-Generierung und Data Pipelines.
Zwar nicht notwendig für kleine Datenmengen, aber Generatoren sind essentielles Wissen für speicherbewusste PHP, die große Datenmengen verarbeitet, und unterscheiden Entwickler, die skalierbaren Code zur Datenverwaltung bauen können, von denjenigen, deren Anwendungen unter großen Lasten fehlschlagen oder verlangsamen — was es zu wertvollen Wissen auf Senior-Level für performanceempfindliche, datenintensive PHP-Anwendungen macht.