(PHP 5 >= 5.5.0, PHP 7, PHP 8)
Les générateurs fournissent une façon simple de mettre en place des itérateurs sans le coût ni la complexité du développement d'une classe qui implémente l'interface Iterator.
Un générateur offre un moyen pratique de fournir des données aux boucles foreach sans
avoir à construire un tableau en mémoire à l'avance, ce qui pourrait amener le programme
à dépasser une limite de mémoire ou nécessiter un temps de traitement considérable pour les générer.
À la place, une fonction générateur peut être utilisée,
qui est identique à une
fonction normale,
mis à part le fait qu'au lieu de retourner
une seule fois, un générateur peut utiliser yield autant de fois que nécessaire, afin de
fournir les valeurs à parcourir.
Comme avec les itérateurs, l'accès aléatoire aux données n'est pas possible.
Un exemple simple de ce mécanisme est la ré-implémentation de la fonction range() sous la forme d'un générateur. La fonction standard range() doit générer un tableau contenant chaque valeur, et le retourner, ce qui peut conduire à des tableaux de taille importante : par exemple, l'appel du code range(0, 1000000) peut consommer nettement plus de 100 Mo de mémoire.
Comme alternative, nous pouvons implémenter un générateur
xrange(), qui n'aura en besoin mémoire que la seule
création d'un objet Iterator, et devra garder trace
en interne du statut courant du générateur, ce qui revient à une
consommation mémoire inférieure à 1 Ko.
Exemple #1 Implémentation de la fonction range() sous la forme d'un générateur
<?php
function xrange($start, $limit, $step = 1) {
if ($start <= $limit) {
if ($step <= 0) {
throw new LogicException('Step must be positive');
}
for ($i = $start; $i <= $limit; $i += $step) {
yield $i;
}
} else {
if ($step >= 0) {
throw new LogicException('Step must be negative');
}
for ($i = $start; $i >= $limit; $i += $step) {
yield $i;
}
}
}
/*
* Il est à noter que les fonctions range() et xrange() produisent le
* même affichage, ci-dessous.
*/
echo 'Nombres impairs à un seul chiffre depuis range() : ';
foreach (range(1, 9, 2) as $number) {
echo "$number ";
}
echo "\n";
echo 'Nombres impairs à un seul chiffre depuis xrange() : ';
foreach (xrange(1, 9, 2) as $number) {
echo "$number ";
}
?>L'exemple ci-dessus va afficher :
Nombres impairs à un seul chiffre depuis range() : 1 3 5 7 9 Nombres impairs à un seul chiffre depuis xrange() : 1 3 5 7 9
Lorsqu'une fonction générateur est appelée, un objet de la classe interne Generator est retournée. Cet objet implémente l'interface Iterator de la même façon qu'un objet itérateur, qui avance uniquement, le ferait, et fournit les méthodes qui peuvent être appelées pour manipuler le statut du générateur, y compris l'envoi des valeurs et leurs retours.
for the protection from the leaking of resources
see RFC https://wiki.php.net/rfc/generators#closing_a_generator
and use finnaly
sample code
function getLines($file) {
$f = fopen($file, 'r');
try {
while ($line = fgets($f)) {
yield $line;
}
} finally {
fclose($f);
}
}
foreach (getLines("file.txt") as $n => $line) {
if ($n > 5) break;
echo $line;
}Bear in mind that execution of a generator function is postponed until iteration over its result (the Generator object) begins. This might confuse one if the result of a generator is assigned to a variable instead of immediate iteration.
<?php
$some_state = 'initial';
function gen() {
global $some_state;
echo "gen() execution start\n";
$some_state = "changed";
yield 1;
yield 2;
}
function peek_state() {
global $some_state;
echo "\$some_state = $some_state\n";
}
echo "calling gen()...\n";
$result = gen();
echo "gen() was called\n";
peek_state();
echo "iterating...\n";
foreach ($result as $val) {
echo "iteration: $val\n";
peek_state();
}
?>
If you need to perform some action when the function is called and before the result is used, you'll have to wrap your generator in another function.
<?php
/**
* @return Generator
*/
function some_generator() {
global $some_state;
$some_state = "changed";
return gen();
}
?>In addition to the note of "montoriusz at gmail dot com": https://www.php.net/manual/en/language.generators.overview.php#119275
"If you need to perform some action when the function is called and before the result is used, you'll have to wrap your generator in another function."
You can use Generator::rewind instead (https://www.php.net/manual/en/generator.rewind.php)
Sample code:
<?php
/** function/generator definition **/
echo "calling gen()...\n";
$result = gen();
$result->rewind();
echo "gen() was called\n";
/** iteration **/
?>Here's how to detect loop breaks, and how to handle or cleanup after an interruption.
<?php
function generator()
{
$complete = false;
try {
while (($result = some_function())) {
yield $result;
}
$complete = true;
} finally {
if (!$complete) {
// cleanup when loop breaks
} else {
// cleanup when loop completes
}
}
// Do something only after loop completes
}
?>Abstract test.
<?php
$start_time=microtime(true);
$array = array();
$result = '';
for($count=1000000; $count--;)
{
$array[]=$count/2;
}
foreach($array as $val)
{
$val += 145.56;
$result .= $val;
}
$end_time=microtime(true);
echo "time: ", bcsub($end_time, $start_time, 4), "\n";
echo "memory (byte): ", memory_get_peak_usage(true), "\n";
?>
<?php
$start_time=microtime(true);
$result = '';
function it()
{
for($count=1000000; $count--;)
{
yield $count/2;
}
}
foreach(it() as $val)
{
$val += 145.56;
$result .= $val;
}
$end_time=microtime(true);
echo "time: ", bcsub($end_time, $start_time, 4), "\n";
echo "memory (byte): ", memory_get_peak_usage(true), "\n";
?>
Result:
----------------------------------
| time | memory, mb |
----------------------------------
| not gen | 2.1216 | 89.25 |
|---------------------------------
| with gen | 6.1963 | 8.75 |
|---------------------------------
| diff | < 192% | > 90% |
----------------------------------Same example, different results:
----------------------------------
| time | memory, mb |
----------------------------------
| not gen | 0.7589 | 146.75 |
|---------------------------------
| with gen | 0.7469 | 8.75 |
|---------------------------------
Time in results varying from 6.5 to 7.8 on both examples.
So no real drawbacks concerning processing speed.