Home >Backend Development >PHP Tutorial >PHP learning--generatorsGenerators,--generatorsgenerators_PHP tutorial

PHP learning--generatorsGenerators,--generatorsgenerators_PHP tutorial

WBOYOriginal: 2016-07-12 09:00:52851browse

Learning of PHP--Generators,--generators

Overview of generators

(PHP 5 >= 5.5.0, PHP 7)

Generators provide an easier way to implement simple object iteration. Compared with 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 a normal custom function, and instead of a normal function returning only once, the generator can yield as many times as needed in order to generate values that need to be iterated over.

A simple example is to use a generator to reimplement the range() function. The standard range() function needs to generate an array in memory containing every value within its range, and then return the array, resulting in multiple large arrays. For example, calling range(0, 1000000) will cause the memory usage to exceed 100 MB.

As an alternative, we can implement a xrange() generator that only requires enough memory to create an Iterator object and internally track the current state of the generator, so that only Requires less than 1K bytes of memory.

Example #1 Implement range() as a generator

<?<span>php
</span><span>function</span> xrange(<span>$start</span>, <span>$limit</span>, <span>$step</span> = 1<span>) {
    </span><span>if</span> (<span>$start</span> < <span>$limit</span><span>) {
        </span><span>if</span> (<span>$step</span> <= 0<span>) {
            </span><span>throw</span> <span>new</span> LogicException('Step must be +ve'<span>);
        }

        </span><span>for</span> (<span>$i</span> = <span>$start</span>; <span>$i</span> <= <span>$limit</span>; <span>$i</span> += <span>$step</span><span>) {
            yield </span><span>$i</span><span>;
        }
    } </span><span>else</span><span> {
        </span><span>if</span> (<span>$step</span> >= 0<span>) {
            </span><span>throw</span> <span>new</span> LogicException('Step must be -ve'<span>);
        }

        </span><span>for</span> (<span>$i</span> = <span>$start</span>; <span>$i</span> >= <span>$limit</span>; <span>$i</span> += <span>$step</span><span>) {
            yield </span><span>$i</span><span>;
        }
    }
}

</span><span>/*</span><span> 
 * 注意下面range()和xrange()输出的结果是一样的。
 </span><span>*/</span>

<span>echo</span> 'Single digit odd numbers from range():  '<span>;
</span><span>foreach</span> (<span>range</span>(1, 9, 2) <span>as</span> <span>$number</span><span>) {
    </span><span>echo</span> "<span>$number</span> "<span>;
}
</span><span>echo</span> "\n"<span>;

</span><span>echo</span> 'Single digit odd numbers from xrange(): '<span>;
</span><span>foreach</span> (xrange(1, 9, 2) <span>as</span> <span>$number</span><span>) {
    </span><span>echo</span> "<span>$number</span> "<span>;
}
</span>?>

The above routine will output:

Single digit odd numbers from range():  <span>1</span> <span>3</span> <span>5</span> <span>7</span> <span>9</span><span> 
Single digit odd numbers from xrange(): </span><span>1</span> <span>3</span> <span>5</span> <span>7</span> <span>9</span>

Generator objects

When a generator function is called for the first time, an object of the internal Generator class is returned. This object implements the Iterator interface in much the same way as a forward-only iterator object would, and provides methods that can be called to manipulate the state of the generator, including sending values to and returning values from it.

Generator syntax

A generator function looks like an ordinary function, except that an ordinary function returns a value, while a generator can yield as many values as it needs.

When a generator is called, it returns an object that can be iterated over. When you iterate over the object (such as through a foreach loop), PHP will call the generator function each time a value is needed. , and save the generator's state after producing a value, so that it can restore the calling state when it needs to produce the next value.

Once no more values need to be produced, the generator function can simply exit, and the code that called the generator can continue executing as if an array had been iterated over.

Note:

A generator cannot return a value: doing so will generate a compilation error. However, return null is valid syntax and will terminate the generator and continue execution.

yield keyword
The core of the
generator function is the yield keyword. In its simplest form, it looks like a return statement. The difference is that a normal return returns a value and terminates the execution of the function, while yield returns a value to the code that loops through the generator and simply pauses the execution of the generator function.

Example #1 A simple example of generating values
<?php
function gen_one_to_three() {
 for ($i = 1; $i <= 3; $i++) {
 //注意变量$i的值在不同的yield之间是保持传递的。
 yield $i;
 }
}

$generator = gen_one_to_three();
foreach ($generator as $value) {
 echo "$value\n";
}
?>
The above routine will output:
1
2
3
Note:

Internally the generated values are paired with consecutive integer indices, just like a non-associative array.

If you use yield in an expression context (such as on the right side of an assignment expression), you must use parentheses to surround the yield declaration. For example this is valid:
$data = (yield $value);
This is illegal and will generate a compilation error in PHP5:
$data = yield $value;
The parenthetical restrictions do not apply in PHP 7.

This syntax can be used in conjunction with the Generator::send() method of the generator object.

Specify the key name to generate the value

PHP’s array supports associated key-value pair arrays, and generators also support it. So in addition to generating simple values, you can also specify key names when generating values.

As shown below, generating a key-value pair is very similar to defining an associative array.

Example #2 Generate a key-value pair
<?php
/* 
 * 下面每一行是用分号分割的字段组合，第一个字段将被用作键名。
 */

$input = <<<'EOF'
1;PHP;Likes dollar signs
2;Python;Likes whitespace
3;Ruby;Likes blocks
EOF;

function input_parser($input) {
 foreach (explode("\n", $input) as $line) {
 $fields = explode(';', $line);
 $id = array_shift($fields);

 yield $id => $fields;
 }
}

foreach (input_parser($input) as $id => $fields) {
 echo "$id:\n";
 echo " $fields[0]\n";
 echo " $fields[1]\n";
}
?>
以上例程会输出：
1:
 PHP
 Likes dollar signs
2:
 Python
 Likes whitespace
3:
 Ruby
 Likes blocks
和之前生成简单值类型一样，在一个表达式上下文中生成键值对也需要使用圆括号进行包围：
$data = (yield $key => $value);
生成null值

Yield可以在没有参数传入的情况下被调用来生成一个 NULL值并配对一个自动的键名。

Example #3 生成NULLs
<?php
function gen_three_nulls() {
 foreach (range(1, 3) as $i) {
 yield;
 }
}

var_dump(iterator_to_array(gen_three_nulls()));
?>
以上例程会输出：
array(3) {
 [0]=>
 NULL
 [1]=>
 NULL
 [2]=>
 NULL
}
使用引用来生成值

生成函数可以像使用值一样来使用引用生成。这个和returning references from functions（从函数返回一个引用）一样：通过在函数名前面加一个引用符号。

Example #4 使用引用来生成值
<?php
function &gen_reference() {
 $value = 3;

 while ($value > 0) {
 yield $value;
 }
}

/* 
 * 我们可以在循环中修改$number的值，而生成器是使用的引用值来生成，所以gen_reference()内部的$value值也会跟着变化。
 */
foreach (gen_reference() as &$number) {
 echo (--$number).'... ';
}
?>
以上例程会输出：
2... 1... 0... 
Generator delegation via yield from ¶

In PHP 7, generator delegation allows you to yield values from another generator, Traversable object, or array by using the yield from keyword. The outer generator will then yield all values from the inner generator, object, or array until that is no longer valid, after which execution will continue in the outer generator.

If a generator is used with yield from, the yield from expression will also return any value returned by the inner generator.

Example #5 Basic use of yield from
<?php
function count_to_ten() {
 yield 1;
 yield 2;
 yield from [3, 4];
 yield from new ArrayIterator([5, 6]);
 yield from seven_eight();
 yield 9;
 yield 10;
}

function seven_eight() {
 yield 7;
 yield from eight();
}

function eight() {
 yield 8;
}

foreach (count_to_ten() as $num) {
 echo "$num ";
}
?>
以上例程会输出：
1 2 3 4 5 6 7 8 9 10 
Example #6 yield from and return values
<?php
function count_to_ten() {
 yield 1;
 yield 2;
 yield from [3, 4];
 yield from new ArrayIterator([5, 6]);
 yield from seven_eight();
 return yield from nine_ten();
}

function seven_eight() {
 yield 7;
 yield from eight();
}

function eight() {
 yield 8;
}

function nine_ten() {
 yield 9;
 return 10;
}

$gen = count_to_ten();
foreach ($gen as $num) {
 echo "$num ";
}
echo $gen->getReturn();
?>
以上例程会输出：
1 2 3 4 5 6 7 8 9 10
Comparing generators with Iterator objects

The primary advantage of generators is their simplicity. Much less boilerplate code has to be written compared to implementing an Iterator class, and the code is generally much more readable. For example, the following function and class are equivalent:
<?php
function getLinesFromFile($fileName) {
 if (!$fileHandle = fopen($fileName, 'r')) {
 return;
 }
 
 while (false !== $line = fgets($fileHandle)) {
 yield $line;
 }
 
 fclose($fileHandle);
}

// versus...

class LineIterator implements Iterator {
 protected $fileHandle;
 
 protected $line;
 protected $i;
 
 public function __construct($fileName) {
 if (!$this->fileHandle = fopen($fileName, 'r')) {
 throw new RuntimeException('Couldn\'t open file "' . $fileName . '"');
 }
 }
 
 public function rewind() {
 fseek($this->fileHandle, 0);
 $this->line = fgets($this->fileHandle);
 $this->i = 0;
 }
 
 public function valid() {
 return false !== $this->line;
 }
 
 public function current() {
 return $this->line;
 }
 
 public function key() {
 return $this->i;
 }
 
 public function next() {
 if (false !== $this->line) {
 $this->line = fgets($this->fileHandle);
 $this->i++;
 }
 }
 
 public function __destruct() {
 fclose($this->fileHandle);
 }
}
?>
This flexibility does come at a cost, however: generators are forward-only iterators, and cannot be rewound once iteration has started. This also means that the same generator can't be iterated over multiple times: the generator will need to either be rebuilt by calling the generator function again, or cloned via the clone keyword.

摘自：http://php.net/manual/zh/language.generators.php

http://www.bkjia.com/PHPjc/1091267.htmlwww.bkjia.comtruehttp://www.bkjia.com/PHPjc/1091267.htmlTechArticlePHP的学习--生成器Generators，--生成器generators 生成器总览 (PHP 5 = 5.5.0, PHP 7) 生成器提供了一种更容易的方法来实现简单的对象迭代，相比较定...

Statement：

The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Previous article：Briefly understand the usage of update_option() function in WordPress development, wordpressgetoption_PHP tutorialNext article：Briefly understand the usage of update_option() function in WordPress development, wordpressgetoption_PHP tutorial

See more

PHP learning--generatorsGenerators,--generatorsgenerators_PHP tutorial

Learning of PHP--Generators,--generators

Overview of generators

Generator objects

Generator syntax

yield keyword

Specify the key name to generate the value

生成null值

使用引用来生成值

Generator delegation via yield from ¶

Comparing generators with Iterator objects

Related articles