Use the PHP generator and yield keywords to effectively process large data sets to avoid memory overflow; 1. The generator realizes lazy evaluation by yield value, leaving only one value in memory at a time; 2. It is suitable for scenarios such as reading large files line by line, such as using fgets combined with yield line by line, and processing logs or CSV files line by line; 3. It supports key-value pair output, and can explicitly specify key names; 4. It has the advantages of low memory footprint, concise code, and seamless integration with foreach; 5. However, there are restrictions such as inability to rewind, do not support random access, and cannot be reused, and it needs to be recreated before iteration is performed; therefore, when it is necessary to traverse a large amount of data, the use of generators should be given priority.

When dealing with large datasets in PHP, memory usage can quickly become a bottleneck—especially when you're loading thousands or even millions of records into arrays before processing them. This is where PHP generators and the yield keyword come in, offering a powerful way to iterate over data without loading everything into memory at once .

A generator is a special kind of function that allows you to iterate over a set of data without needing to build and store the entire dataset in memory. Instead of return ing a value and ending execution, a generator yields values one at a time, pausing execution between each yield and recovering when the next value is requested.

How yield Works: A Simple Example

Instead of this memory-heavy approach:

 function getNumbers($n) {
    $numbers = [];
    for ($i = 1; $i <= $n; $i ) {
        $numbers[] = $i;
    }
    return $numbers;
}

foreach (getNumbers(1000000) as $num) {
    echo "$num\n";
}

This creates an array with 1 million integers in memory—expensive and unnecessary.

With a generator, you can do:

 function getNumbers($n) {
    for ($i = 1; $i <= $n; $i ) {
        yield $i;
    }
}

foreach (getNumbers(1000000) as $num) {
    echo "$num\n";
}

Now, only one value exists in memory at a time. The function pauses after each yield , waits for the next iteration, and then continues— massively reducing memory usage .

Real-World Use Case: Processing Large Files

One of the most practical applications of generators is reading large files (like CSVs or logs) line by line.

 function readLines($file) {
    $handle = fopen($file, 'r');
    if (!$handle) {
        throw new Exception("Cannot open file: $file");
    }

    while (($line = fgets($handle)) !== false) {
        yield $line;
    }

    fclose($handle);
}

// Usage
foreach (readLines('huge-log-file.txt') as $line) {
    echo "Processing: " . trim($line) . "\n";
}

Without a generator, you might use file() to load all lines into an array—but that could crash with a large file. With yield , you process one line at a time, keeping memory usage low and predictable.

Key Benefits of Generators

• Low memory footprint : Only one item is processed at a time.
• Clean, readable code : Looks like a regular loop but behaves lazily.
• Lazy evaluation : Values are generated only when needed.
• Seamless integration with foreach : Generators return an object implementing the Iterator interface.

Advanced: Yielding Keys and Values

You can also specify keys explicitly:

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

foreach (getKeyValuePairs() as $key => $value) {
    echo "$key: $value\n";
}

Or yield null keys when you want to filter or transform data on the fly.

Limitations to Keep in Mind

• Cannot rewind after iteration : Once a generator is consumed, it's done (unless you recreate it).
• No random access : You can't jump to the 100th item directly.
• Not reusable : Generators are single-use unless wrapped or reinitialized.

For example:

 $gen = getNumbers(3);
foreach ($gen as $n) { echo "$n "; } // 1 2 3
foreach ($gen as $n) { echo "$n "; } // Nothing—generator is already exhausted

Conclusion

Generators with yield are ideal for handling large datasets efficiently—whether you're reading files, querying databases, or processing streams of data. By producing values lazily, they help keep memory usage low and performance high.

Use them whenever you're tempted to build a big array just to loop over it once. In many cases, you don't need the whole dataset in memory—just one item at a time.

Basically: if you're looping, consider yielding.

The above is the detailed content of Memory-Efficient Iteration with PHP Generators and the `yield` Keyword. For more information, please follow other related articles on the PHP Chinese website!