Detailed explanation of Generator in PHP

When it comes to driving, speed isn't everything. But on the web, speed makes all the difference. The faster your application is, the better the user experience is. This article is about PHP generators, so why are we talking about speed? You'll quickly discover that generators play a huge role in speed and memory management.

What is PHP Generator?

Generators were added in PHP 5.5 and provide an easy way to iterate over data without building arrays in memory. Are you a little confused? Then give an example to show that using generators is a good way.

First, create a generator.php file that will be used throughout our example. After creating the file, we add a piece of code.

<?php
function getRange ($max = 10) {
    $array = [];
    for ($i = 1; $i < $max; $i++) {
        $array[] = $i;
    }
    return $array;
}
foreach (getRange(15) as $range) {
    echo "Dataset {$range} <br>";
}

We can quickly start a built-in PHP server in the directory where the generator.php file is created:

php -S localhost:8000

If you use a browser to open http://localhost:8000/generator.php, We should see results like this:

#This code is not very self-explanatory. Let's change the code a little

<?php
foreach (getRange(PHP_INT_MAX) as $range) {
    echo "Dataset {$range} <br>";
}

Now, the maximum value that the above code can generate is PHP_INT_MAX (that is, the maximum value that PHP can generate). When we refresh the browser after this modification, we notice Something is different this time. This generator script throws a warning message.

#It’s a pity that PHP runs out of memory. Solutions you can think of might include increasing the upper limit of memory_limit in the php.ini file. But to be fair, this script is both inefficient and takes up memory. What we need is a script that is efficient and takes up low memory.

Using Generators

Let’s define the same function above, call it with the same value of PHP_INT_MAX and run it again. But this time we will create a generator function.

<?php
function getRange ($max = 10) {
    for ($i = 1; $i < $max; $i++) {
        yield $i;
    }
}
foreach (getRange(PHP_INT_MAX) as $range) {
    echo "Dataset {$range} <br>";
}

Parsing the getRange function, this time, we only loop through the values ​​and yield the output. yield is similar to return value in that it also returns a value from a function, but the only difference is that yield only returns a value when needed and does not try to keep the entire data set in memory.

If you go to your browser you should see the data displayed on the page. Given the appropriate time, the browser eventually displays the data.

Note: Generators can only be used within functions.

Why use generators

Sometimes, we may encounter a situation where we want to parse a huge data set (maybe a log file), It is also possible to perform calculations on the result set of a large database, etc. We don't want all this data to be loaded into memory. We should save the corresponding memory state as much as possible. The data doesn't have to be big - the generator is efficient no matter how small the data is. Don’t forget, our goal is to use less memory to process data as quickly as possible.

Return key-value pairs

Sometimes, our data is more convincing when it is based on key-value. When using a generator, we may generate key-value pairs like the following.

<?php
function getRange ($max = 10) {
    for ($i = 1; $i < $max; $i++) {
        $value = $i * mt_rand();
        yield $i => $value;
    }
}

Then, we can use this key-value pair just like any array.

<?php
foreach (getRange(PHP_INT_MAX) as $range => $value) {
    echo "Dataset {$range} has {$value} value<br>";
}

Pass parameters to the generator

The generator can also receive parameters. This means that the generator allows us to inject parameters into it, as a command or other functions. For example, we send a value to the generator to stop its execution or modify its output. Using the getRange function above, we can achieve this.

<?php
function getRange ($max = 10) {
    for ($i = 1; $i < $max; $i++) {
        $injected = yield $i;
        if ($injected === &#39;stop&#39;) return;
    }
}

To send injected this value, we can do this.

<?php
$generator = getRange(PHP_INT_MAX);
foreach ($generator as $range) {
    if ($range === 10000) {
        $generator->send(&#39;stop&#39;);
    }
    echo "Dataset {$range} <br>";
}

Note: Using return in a generator will jump out of the generator.

Don't abuse generators

Although using PHP_INT_MAX is a bit over the top. But for me, PHP_INT_MAX is 2147483647, which is:

two billion four thousand seven hundred and forty-four thousand eighty-three thousand six hundred and forty-seven

The generator makes the memory usage More efficient. But if abused, it can also cause memory-related problems.

Summary

Generators provide significant performance improvements that are hard to ignore. Most of the time, we don't need a high-configuration server to run the code. We just need to do a little refactoring, generators are very useful and we should use them more.

Recommended tutorials: "Laravel Tutorial" "PHP Tutorial" "PHP7"

The above is the detailed content of Detailed explanation of Generator in PHP. For more information, please follow other related articles on the PHP Chinese website!