Generators provide a memory-efficient way to iterate over large datasets by producing values one at a time (lazily) using the yield keyword, instead of building an entire array in memory at once. They're ideal for large or streaming data.
{
= [];
( = ; < ; ++) { [] = ; }
;
}
{
( = ; < ; ++) {
;
}
}
(() ) {
();
}
yield makes a function a generator: it produces values lazily, one per iteration, keeping its state between them — so memory stays constant regardless of how many values it produces.
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);
}
Reading a huge file line by line with a generator uses constant memory — impossible with file() (which loads the entire file into an array).
function fetchRows(PDOStatement $stmt): Generator {
while ($row = $stmt->fetch()) {
yield $row['id'] => $row; // yield key => value, streaming DB rows
}
}
Generators are great for streaming database results — process rows one at a time instead of loading a huge result set into memory.
Generators are an important PHP feature for memory-efficient processing of large datasets — and understanding them is valuable for building applications that handle data at scale without exhausting memory.
The core problem they solve is that building a full array of large data (millions of records, a huge file's lines, a big database result set) can consume enormous memory and crash the application, whereas generators produce values lazily, one at a time, keeping memory constant regardless of dataset size.
The most impactful use cases are practical and common: reading large files line by line (processing a multi-gigabyte CSV or log with tiny memory, impossible with functions that load everything), streaming database results (handling large query results row by row), and processing large or even infinite sequences.
Understanding yield, lazy evaluation, and when to reach for generators (any time you'd otherwise build a large array in memory) lets you write scalable data-processing code that handles large volumes gracefully — a frequent real-world need in batch jobs, imports/exports, report generation, and data pipelines.
While not needed for small datasets, generators are essential knowledge for memory-conscious PHP that processes large amounts of data, distinguishing developers who can build scalable data-handling code from those whose applications fail or slow under large workloads, making it valuable senior-level knowledge for performance-sensitive, data-intensive PHP applications.