PHP Generators: Mastering Lazy Evaluation and Memory-Efficient Iteration

By Alessandro D.P. 4 min read February 4, 2026

Understanding Generator Fundamentals

Generators are functions that can be paused and resumed, allowing them to produce a sequence of values over time rather than computing them all at once. The yield keyword is the cornerstone of generator implementation, enabling functions to return values incrementally while maintaining their execution state.

function simpleGenerator() {
    yield 1;
    yield 2;
    yield 3;
}

foreach (simpleGenerator() as $value) {
    echo $value . "\n";
}
// Output: 1, 2, 3

A key advantage of generators is their ability to maintain local variables and execution state between yields. This means that variables declared within a generator function persist between calls, allowing for complex state management within iteration logic.

Generator Syntax and Control Flow

The basic syntax for generators follows a pattern similar to regular functions but with yield statements instead of return. When a generator function is called, it returns a Generator object rather than executing immediately.

function numberSequence($start, $end) {
    for ($i = $start; $i <= $end; $i++) {
        yield $i;
    }
}

$sequence = numberSequence(1, 5);
foreach ($sequence as $number) {
    echo $number . " ";
}
// Output: 1 2 3 4 5

Generators can also yield key-value pairs, making them suitable for associative data structures:

function keyValuePairs() {
    yield 'first' => 1;
    yield 'second' => 2;
    yield 'third' => 3;
}

foreach (keyValuePairs() as $key => $value) {
    echo "$key: $value\n";
}
// Output: first: 1
//         second: 2
//         third: 3

Advanced Generator Patterns

Generator Delegation with `yield from`

PHP 7.0 introduced the yield from syntax, which allows one generator to delegate to another, simplifying complex iteration logic:

function getFirstSet() {
    yield 1;
    yield 2;
    yield 3;
}

function getSecondSet() {
    yield 4;
    yield 5;
    yield 6;
}

function getAllNumbers() {
    yield from getFirstSet();
    yield from getSecondSet();
}

foreach (getAllNumbers() as $number) {
    echo $number . " ";
}
// Output: 1 2 3 4 5 6

Generator with Return Values

Generators can also return values using the return statement, which becomes accessible through the getReturn() method:

function processNumbers() {
    yield 1;
    yield 2;
    yield 3;
    return "Processing complete";
}

$generator = processNumbers();
foreach ($generator as $value) {
    echo $value . " ";
}
echo $generator->getReturn();
// Output: 1 2 3 Processing complete

Memory-Efficient Data Processing

One of the primary benefits of generators is their memory efficiency when processing large datasets. Consider a scenario where you need to process a massive file:

function processLargeFile($filename) {
    $file = fopen($filename, 'r');
    if ($file) {
        while (($line = fgets($file)) !== false) {
            yield trim($line);
        }
        fclose($file);
    }
}

// Process file line by line without loading entire file into memory
foreach (processLargeFile('huge_data.txt') as $line) {
    // Process each line individually
    echo $line . "\n";
}

Generator-Based Data Transformation

Generators excel at creating data transformation pipelines that process information incrementally:

function filterEvenNumbers($numbers) {
    foreach ($numbers as $number) {
        if ($number % 2 === 0) {
            yield $number;
        }
    }
}

function squareNumbers($numbers) {
    foreach ($numbers as $number) {
        yield $number * $number;
    }
}

function processNumbers($numbers) {
    yield from squareNumbers(filterEvenNumbers($numbers));
}

$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
foreach (processNumbers($numbers) as $result) {
    echo $result . " ";
}
// Output: 4 16 36 64 100

Generator Performance Comparison

Feature	Traditional Function	Generator
Memory Usage	High (all values in memory)	Low (lazy evaluation)
Execution	Immediate	On-demand
State Preservation	No	Yes
Return Values	Single	Multiple + final return
Error Handling	Standard	Exception-based
Use Case	Small datasets	Large datasets

Practical Applications

Generators are particularly useful in several real-world scenarios:

Database Query Processing: When dealing with large result sets, generators allow processing records one at a time without loading everything into memory.

File Processing: Reading large files line by line without storing entire contents in memory.

API Response Handling: Processing streaming API responses or pagination results efficiently.

Data Transformation Pipelines: Creating reusable, composable processing steps for complex data workflows.

Error Handling in Generators

Generators support proper error handling through exceptions, allowing for robust data processing:

function safeDataProcessor($data) {
    foreach ($data as $item) {
        try {
            if ($item === null) {
                throw new InvalidArgumentException("Null value encountered");
            }
            yield $item;
        } catch (InvalidArgumentException $e) {
            echo "Error processing item: " . $e->getMessage() . "\n";
            continue;
        }
    }
}

Generator State Management

Generators maintain their internal state between yields, enabling complex iteration patterns:

function fibonacciGenerator() {
    $a = 0;
    $b = 1;
    
    yield $a;
    yield $b;
    
    while (true) {
        $c = $a + $b;
        yield $c;
        $a = $b;
        $b = $c;
    }
}

$fib = fibonacciGenerator();
for ($i = 0; $i < 10; $i++) {
    echo $fib->current() . " ";
    $fib->next();
}
// Output: 0 1 1 2 3 5 8 13 21 34

Best Practices and Considerations

When working with generators, consider these best practices:

Avoid Multiple Iterations: Generators can only be iterated once. Create new instances for subsequent iterations.

Memory Management: While generators reduce memory usage, be mindful of the data structures they reference.

Exception Propagation: Exceptions thrown within generators propagate to the calling code.

Performance Testing: Profile generator-based solutions to ensure they meet performance requirements.