Examples to explain Iterator and Generator in PHP

Before explaining the generator, let’s introduce the iterator:

In PHP , usually use foreach to traverse the array.

What if we want to make an object traversable?

PHP provides us with the Iterator interface. As long as this interface is implemented, this object can be iterated through foreach.

The example is as follows:

class myIterator implements Iterator {
    private $index = 0;
    private $data = '';

    public function __construct($data) {
        $this->index = 0;
        $this->data = $data;
    }

    function rewind() {
        $this->index = 0;
    }

    function current() {
        return $this->data[$this->index];
    }

    function key() {
        return $this->index;
    }

    function next() {
        ++$this->index;
    }

    function valid() {
        return isset($this->data[$this->index]);
    }
}

$it = new myIterator(array(
    "hello",
    "php",
    "iterator",
));
foreach($it as $key => $value) {
    echo "$key : $value
";
}

When we traverse $it through foreach, PHP will call itself in sequence:

rewind() Reset Go to the first element
valid() Check whether the current position is valid
current() Return the current element
key() Return the key of the current element
next() Point to the next element

The generator is a new feature introduced in PHP 5.5, but few people seem to use it currently.

The following is an explanation of the generator in the PHP official documentation:

The generator provides an easier way to implement simple object iteration, compared to the way of defining a class to implement the Iterator interface , the performance overhead and complexity are greatly reduced.

Generators allow you to write code in a foreach block to iterate over a set of data without creating an array in memory, which would hit your memory limit or take up considerable processing time.

Instead, you can write a generator function, just like an ordinary custom function. Unlike ordinary functions that only return once, the generator can yield as many times as needed to generate the iteration that needs to be value.

In order to reflect the advantages of the generator, let's define a function for comparison:

function func1()
{
    foreach (range(0, 1000000) as $value){
        echo $value;
    }
}

func1();
// ( ! ) Fatal error: Allowed memory size of 134217728 bytes exhausted (tried to allocate 402653192 bytes) in xxx.php on line 5

Because such a large array is created into memory for iteration, PHP directly prompts that it exceeds the limit of a single process. Memory limit.

Let’s switch to the generator method:

function func1()
{
    foreach (range(0, 1000000) as $value){
        yield $value;
    }
}

var_dump(func1()); // object(Generator)[1]
foreach (func1() as $value){
    echo $value;
}

You can see that we call func1() and return a Generator object. This object can be iterated using foreach. Each iteration, PHP The Generator instance is asked to calculate and provide the next value to iterate over.

The elegance of the generator is reflected in the fact that each time a value is produced, the internal state of the generator will pause;

The internal state will be restored when the next value is requested from the generator. The internal state of the generator will continue to switch between pause and resume until the end of the function definition body is reached or an empty return statement is encountered.

【Recommended learning: PHP video tutorial】