PHP Master | Generators in PHP

Core points

• PHP generator provides an easy way to implement an iterator without the need for a complex Iterator interface, but instead use the yield keyword instead of return to save its state and continue from the interrupt when called again .
• Generators are very memory-saving when working with large datasets, because they only need to allocate memory for the current result, without storing all values ​​in memory at once like an array.
• Although the generator works like an iterator, it is essentially a function that returns and receives external values ​​by calling the send() method of the generator object. It can also be used in another generator, which is called a generator delegate.

If you followed my previous article on iterators, you will know that iteration is an important programming concept, but implementing the necessary interface to create iterable objects is a hassle at best because it requires a lot of boilerplate code. With the release of PHP 5.5, we finally have a generator! In this article, we will learn about the generator, which provides an easy way to implement a simple iterator without the overhead or complexity of the Iterator interface.

How the generator works

According to Wikipedia's definition, the generator is "very similar to a function that returns an array, because the generator has parameters that can be called and generates a series of values". The generator is basically a normal function, but instead of returning a value, it produces as many values ​​as needed. It looks like a function, but behaves like an iterator. The generator uses the yield keyword instead of return. It works similar to return because it returns the value to the caller of the function, but yield does not remove the function from the stack, but saves its state. This allows the function to continue execution from the interrupt. In fact, you cannot return a value from the generator, although you can terminate its execution with return without a value. The PHP manual states: "When a generator function is called, it returns an object that can be iterated." This is an object of the internal Generator class that implements the Iterator interface in the same way as a forward-iter object only. When you iterate over the object, PHP calls the generator every time a value is needed. When the generator generates a value, the state is saved so that it can be restored when the next value is needed.

<code class="language-php"><?php
function nums() {
    echo "The generator has started\n";
    for ($i = 0; $i < 5; $i++) {
        yield $i;
        echo "Yielded $i\n";
    }
    echo "The generator has ended\n";
}

foreach (nums() as $v);
?></code>

The output of the above code will be:

<code>The generator has started
Yielded 0
Yielded 1
Yielded 2
Yielded 3
Yielded 4
The generator has ended</code>

Our first generator

Generator is not a new concept. It already exists in languages ​​such as C#, Python, JavaScript, and Ruby (enumerator), and is usually recognized by using the yield keyword. Here is a Python example:

<code class="language-python">def file_lines(filename):
    file = open(filename)
    for line in file:
        yield line
    file.close()

for line in file_lines('somefile'):
    #do some work here</code>

Let's rewrite the Python generator example in PHP. (Note that neither of these code snippets perform any error checking.)

<code class="language-php"><?php
function nums() {
    echo "The generator has started\n";
    for ($i = 0; $i < 5; $i++) {
        yield $i;
        echo "Yielded $i\n";
    }
    echo "The generator has ended\n";
}

foreach (nums() as $v);
?></code>

The generator function opens a file and then generates each line of the file as needed. Each time the generator is called, it continues to execute from the interrupt. It does not start from scratch because when the yield statement is executed, its state is saved. Once all rows are read, the generator simply terminates and the loop ends.

Return key

PHP iterator consists of key/value pairs. In our example, only one value is returned, so the key is a number (by default the key is a number). If you want to return an associated pair, just change the yield statement to include the keys using the array syntax.

<code>The generator has started
Yielded 0
Yielded 1
Yielded 2
Yielded 3
Yielded 4
The generator has ended</code>

Injection value

yield not only returns a value; it can also receive external values. This is done by calling the send() method of the generator object with the value you want to pass. This value can then be used to calculate or perform other operations. This method sends the value as a result of the yield expression to the generator and resumes execution.

<code class="language-python">def file_lines(filename):
    file = open(filename)
    for line in file:
        yield line
    file.close()

for line in file_lines('somefile'):
    #do some work here</code>

The output will be:

<code class="language-php"><?php
function file_lines($filename) {
    $file = fopen($filename, 'r');
    while (($line = fgets($file)) !== false) {
        yield $line;
    }
    fclose($file);
}

foreach (file_lines('somefile') as $line) {
    // do some work here
}
?></code>

Save memory using generator

Generator is useful when you calculate large collections and don't want to allocate memory for all results at the same time, or when you don't know if all results are needed. Due to the way the results are processed, memory usage can be reduced to very low levels by allocating memory only for the current results. Imagine the file() function, which returns all lines in the file as an array. Run a simple benchmark for the file() function and our demo file_lines() function, each using the same random 100-segment text file generated using Lipsum, and the result shows that the file function uses at most a generator 110 times the

<code class="language-php"><?php
function file_lines($filename) {
    // ...
        yield $key => $line;
    // ...
}

foreach (file_lines('somefile') as $key => $line) {
    // do some work here
}
?></code>

Conclusion

With the introduction of generators, PHP provides developers with a powerful tool. We can now write iterators quickly while saving a lot of memory. Through this tutorial, I hope you have gained enough knowledge to start using them yourself in your project. Personally, I have already thought of a lot of objects to rewrite. If you have any ideas or comments, please leave your comment.

FAQs for PHP generator

(The FAQs listed in the original text should be included here, and due to space limitations, it is omitted here.)

The above is the detailed content of PHP Master | Generators in PHP. For more information, please follow other related articles on the PHP Chinese website!