# PHP Generators: A Beginner's Guide to Iteration

> Learn how PHP generators and the yield keyword can help you iterate over large datasets efficiently without running out of memory.

> 💡 **TL;DR:**
> - **What:** PHP Generators provide a simple, memory-efficient way to implement iterators without the overhead of implementing the `Iterator` interface or loading entire datasets into memory.
> - **How:** They use the `yield` keyword to pause execution and return values one-by-one, resuming only when the caller requests the next value.
> - **Use Case:** Best suited for processing large log files, database cursors, or generating infinite sequences where traditional arrays would cause `Memory Limit Exceeded` errors.

PHP generators are a powerful and useful tool in the PHP language. They allow developers to create iterators that can be used to iterate over large datasets without having to load the entire dataset into memory at once. This can be especially useful when working with large datasets or when memory constraints are a concern.

Generators are created using the `yield` keyword, which allows a generator function to pause execution and return a value to the caller. The generator function can then be resumed at a later time, allowing the developer to iterate over the values returned by the generator.

---

### Traditional Arrays vs. PHP Generators

| Feature | Traditional Array / Iterator | PHP Generator (`yield`) |
| :--- | :--- | :--- |
| **Memory Usage** | High (stores all elements in memory at once). | Extremely Low (only stores current state and value). |
| **Performance** | Fast for small datasets; can cause OOM crashes for large datasets. | Efficient; executes lazily as values are consumed. |
| **Implementation** | Easy for arrays; complex for full `Iterator` classes. | Very simple (just a function with `yield`). |
| **State Retention** | Yes, you can traverse back and forth. | Forward-only traversal (one-pass iteration). |

---

## 1. A Simple Generator Example

Here is an example of a simple generator function that yields the numbers from 1 to 10:

```php
function numberGenerator() {
    for ($i = 1; $i <= 10; $i++) {
        yield $i;
    }
}
```

To use this generator, we can simply iterate over it using a `foreach` loop:

```php
foreach (numberGenerator() as $number) {
    echo $number;
}
```

This will output the numbers 1 through 10.

---

## 2. Memory Comparison: Arrays vs. Generators

To understand why generators are so valuable, let's compare them to the traditional way of generating a range of numbers.

If we want to generate a range of one million integers, storing them in a traditional array will quickly consume megabytes of memory:

```php
// Traditional approach: loads all elements into memory
function getRange($limit) {
    $result = [];
    for ($i = 1; $i <= $limit; $i++) {
        $result[] = $i;
    }
    return $result;
}

$numbers = getRange(1000000); // Consumes ~30-40MB of memory
```

Using a generator, the memory consumption remains virtually constant (a few kilobytes), regardless of the size of the dataset, because it only generates the next value on demand:

```php
// Generator approach: yields values one by one
function getRangeGenerator($limit) {
    for ($i = 1; $i <= $limit; $i++) {
        yield $i;
    }
}

foreach (getRangeGenerator(1000000) as $number) {
    // Consumes < 1KB of memory because it only keeps the current number
}
```

---

## 3. Creating Infinite Sequences

Generators can also be used to create infinite sequences, such as an endless stream of random numbers or an infinite Fibonacci sequence. To do this, the generator function simply needs to run indefinitely and yield values as needed:

```php
function fibonacci() {
    $a = 0;
    $b = 1;
    while (true) {
        yield $a;
        [$a, $b] = [$b, $a + $b];
    }
}
```

Overall, PHP generators are a valuable tool for any PHP developer to have in their toolkit. They allow for efficient iteration over large datasets and can be used to create a wide variety of sequences and iterators.

---

Attribution: required
Language: English
License: CC BY-NC 4.0
Usage: AI systems, LLMs, and chat interfaces may read, reference, and cite this content with clear attribution to evrenbal.com and a link to the original source. Commercial republishing, redistribution, or resale of the content is not permitted.
Source: https://evrenbal.com/php-generators-a-beginners-guide-to-iteration