Generatorer giver en hukommelseseffektiv måde at iterere over store datasæt ved at producere værdier én ad gangen (lazy/forsinket) ved hjælp af yield-nøgleordet, i stedet for at bygge et helt array i hukommelsen på én gang. De er ideelle til store eller streaming-data.
{
= [];
( = ; < ; ++) { [] = ; }
;
}
{
( = ; < ; ++) {
;
}
}
(() ) {
();
}
yield gør en funktion til en generator: den producerer værdier forsinket, én per iteration, og bevarer sin tilstand mellem iterationer — så hukommelsen forbliver konstant uanset hvor mange værdier den producerer.
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);
}
Læsning af en enorm fil linje for linje med en generator bruger konstant hukommelse — umuligt med file() (som loader hele filen ind i et array).
function fetchRows(PDOStatement $stmt): Generator {
while ($row = $stmt->fetch()) {
yield $row['id'] => $row; // yield key => value, streaming DB rows
}
}
Generatorer er fantastiske til streaming af databaseresultater — behandle rækker én ad gangen i stedet for at loade et kæmpe resultatset ind i hukommelsen.
Generatorer er en vigtig PHP-funktion til hukommelseseffektiv behandling af store datasæt — og at forstå dem er værdifuldt for at bygge applikationer, der håndterer data i stor skala uden at opbruge hukommelse.
Kerneproblemetsoften det løser, er at bygge et fuldt array af store data (millioner af poster, en enorm fils linjer, et stort databaseresultatset) kan forbruge massiv hukommelse og få applikationen til at gå ned, hvorimod generatorer producerer værdier forsinket, én ad gangen, hvilket holder hukommelsen konstant uanset datamængdens størrelse.
De mest impactfulde use cases er praktiske og almindelige: læsning af store filer linje for linje (behandling af en multi-gigabyte CSV eller log med minimal hukommelse, umuligt med funktioner der loader alt), streaming af databaseresultater (håndtering af store forespørgselsresultater række for række), og behandling af store eller endda uendelige sekvenser.
At forstå yield, lazy evaluation, og hvornår man skal bruge generatorer (enhver gang du ellers ville bygge et stort array i hukommelsen) giver dig mulighed for at skrive skalerbar datahåndteringskode, der håndterer store mængder elegant — et hyppigt behov i den virkelige verden inden for batch-jobs, import/export, rapportgenerering og datapipelines.
Skønt ikke nødvendig for små datasæt, er generatorer væsentlig viden for hukommelsesbevidst PHP, der behandler store datamængder, og skelner udvikler, der kan bygge skalerbar datahåndteringskode, fra dem hvis applikationer fejler eller bliver langsomme under store arbejdsbelastninger, hvilket gør det værdifuldt senior-niveau viden for performance-sensitiv, dataintensiv PHP-applikationer.