Generators bieden een geheugenefficiënte manier om grote datasets te itereren door waarden één tegelijk (lui) te produceren met behulp van het yield sleutelwoord, in plaats van een hele array tegelijk in het geheugen op te bouwen. Ze zijn ideaal voor grote of streamingdata.
{
= [];
( = ; < ; ++) { [] = ; }
;
}
{
( = ; < ; ++) {
;
}
}
(() ) {
();
}
yield maakt van een functie een generator: het produceert waarden lui, één per iteratie, en behoudt zijn status daartussen — dus het geheugen blijft constant ongeacht hoeveel waarden het produceert.
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);
}
Een enorm bestand regel voor regel lezen met een generator gebruikt constant geheugen — onmogelijk met file() (die het hele bestand in een array laadt).
function fetchRows(PDOStatement $stmt): Generator {
while ($row = $stmt->fetch()) {
yield $row['id'] => $row; // yield key => value, streaming DB rows
}
}
Generators zijn geweldig voor streamingdatabaseresultaten — verwerk rijen één tegelijk in plaats van een enorme resultaatset in het geheugen te laden.
Generators zijn een belangrijk PHP-kenmerk voor geheugenefficiënte verwerking van grote datasets — en het begrijpen ervan is waardevol voor het bouwen van applicaties die gegevens op schaal kunnen verwerken zonder het geheugen uit te putten.
Het kernprobleem dat ze oplossen is dat het bouwen van een volledige array van grote gegevens (miljoenen records, de regels van een enorm bestand, een grote databaseresultaatset) enorm veel geheugen kan verbruiken en de applicatie kan laten crashen, terwijl generators waarden lui, één tegelijk produceren, waardoor het geheugen constant blijft ongeacht de grootte van de dataset.
De meest impactvolle use cases zijn praktisch en algemeen: grote bestanden regel voor regel lezen (een multi-gigabyte CSV of log verwerken met minimaal geheugen, onmogelijk met functies die alles laden), streamingdatabaseresultaten (grote queryresultaten rij voor rij afhandelen), en verwerking van grote of zelfs oneindige reeksen.
Inzicht in yield, lui evaluatie, en wanneer je naar generators moet grijpen (altijd wanneer je anders een grote array in het geheugen zou bouwen) stelt je in staat schaalbare gegevensverwerkingscode te schrijven die grote volumes elegant afhandelt — een veelvoorkomende praktische behoefte in batchjobs, imports/exports, rapportgeneratie en datapijplijnen.
Hoewel niet nodig voor kleine datasets, zijn generators essentiële kennis voor geheugengebruik-bewuste PHP die grote hoeveelheden gegevens verwerkt, onderscheidend voor ontwikkelaars die schaalbare gegevensverwerkingscode kunnen bouwen van degenen wiens applicaties falen of vertragen onder grote workloads, waardoor het waardevol senior-level-kennis is voor performance-gevoelige, data-intensieve PHP-applicaties.