PHP 5.4.33 Released

Syntaxe d'un Générateur

Une fonction générateur ressemble à une fonction normale, sauf qu'au lieu de retourner une valeur, un générateur yield retourne autant de valeurs que nécessaire.

Lorsqu'une fonction générateur est appelée, elle retourne un objet que l'on peut parcourir. Lorsque vous parcourez cet objet (par exemple, via une boucle foreach), PHP appelle la fonction générateur à chaque fois qu'il a besoin d'une valeur, puis sauvegarde le statut du générateur lorsqu'il génère une valeur, pour qu'il puisse être repris lorsque la prochaine valeur sera requise.

Lorsqu'il n'y a plus de valeur à fournir, la fonction générateur peut simplement sortir, et le code appelant continuera comme si un tableau n'avait plus de valeur.

Note:

Un générateur ne peut pas retourner de valeur : si vous tentez de retourner une valeur depuis un générateur, une erreur de compilation sera émise. Une structure return vide est une syntaxe valide dans un générateur et fera terminer le générateur.

Le mot-clé yield

Le mot clé yield est le cœur d'une fonction générateur. Dans sa forme la plus simple, une instruction yield ressemble à une instruction return, excepté qu'au lieu de stopper l'exécution de la fonction et de retourner, yield fournit une valeur au code parcourant le générateur, et met en pause l'exécution de la fonction générateur.

Exemple #1 Un exemple simple de production de valeurs

<?php
function gen_one_to_three() {
    for (
$i 1$i <= 3$i++) {
        
// Notez que $i est préservé entre chaque production de valeur.
        
yield $i;
    }
}

$generator gen_one_to_three();
foreach (
$generator as $value) {
    echo 
"$value\n";
}
?>

L'exemple ci-dessus va afficher :

1
2
3

Note:

En interne, des clés séquentielles entières seront associées avec les valeurs produites, de la même manière que pour un tableau non-associatif.

Attention

Si vous utilisez yield dans un contexte d'expression (par exemple, à droite d'un assignement), vous devez entourer l'instruction yield avec des parenthèses. Par exemple, ceci est valide :

$data = (yield $value);

Mais ceci ne l'est pas, et entrainera une erreur d'analyse :

$data = yield $value;

Cette syntaxe peut être utilisée en conjonction de la méthode Generator::send() sur les objets Générateur.

Fourniture de valeurs avec des clés

PHP supporte également les tableaux associatifs, et les générateurs ne sont pas différents. En plus de fournir des valeurs simples, comme nous l'avons vu plus haut, vous pouvez aussi, en même temps, fournir une clé.

La syntaxe permettant de produire une paire clé/valeur est similaire à celle utilisée pour définir un tableau associatif ; comme ceci :

Exemple #2 Production d'une paire clé/valeur

<?php
/*
 * L'entrée est constituée de champs séparés par un point-virgule,
 * et le premier champ est un ID à utiliser comme clé.
 */

$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";
}
?>

L'exemple ci-dessus va afficher :

1:
    PHP
    Likes dollar signs
2:
    Python
    Likes whitespace
3:
    Ruby
    Likes blocks
Attention

Comme dans le cas de production de valeurs simples, la fourniture d'une paire clé/valeur dans un contexte d'expression requiert que la structure yield soit entre parenthèses :

$data = (yield $key => $value);

Production de valeurs nulles

Yield peut être appelé sans argument pour fournir une valeur nulle avec une clé automatique.

Exemple #3 Production de valeurs nulles

<?php
function gen_three_nulls() {
    foreach (
range(13) as $i) {
        
yield;
    }
}

var_dump(iterator_to_array(gen_three_nulls()));
?>

L'exemple ci-dessus va afficher :

array(3) {
  [0]=>
  NULL
  [1]=>
  NULL
  [2]=>
  NULL
}

Production de valeurs par référence

Les fonctions générateur peuvent produire des valeurs par référence. Ceci se fait de la même façon que le retour par référence depuis des fonctions : en ajoutant un ET commercial (&) au nom de la fonction.

Exemple #4 Production de valeurs par référence

<?php
function &gen_reference() {
    
$value 3;

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

/*
 * Notez qu'il est possible de changer $number dans la boucle,
 * et, du fait que le générateur fournit des références, $value
 * dans gen_reference() change aussi.
 */
foreach (gen_reference() as &$number) {
    echo (--
$number).'... ';
}
?>

L'exemple ci-dessus va afficher :

2... 1... 0... 

Objets Generator

Lorsqu'une fonction générateur est appelée pour la première fois, un objet de la classe interne Generator est retourné. Cet objet implémente l'interface Iterator de la même façon qu'un objet itérateur ne fonctionnant qu'en avançant le ferait.

add a note add a note

User Contributed Notes 4 notes

up
31
Adil lhan (adilmedya at gmail dot com)
1 year ago
For example yield keyword with Fibonacci:

function getFibonacci()
{
    $i = 0;
    $k = 1; //first fibonacci value
    yield $k;
    while(true)
    {
        $k = $i + $k;
        $i = $k - $i;
        yield $k;       
    }
}

$y = 0;

foreach(getFibonacci() as $fibonacci)
{
    echo $fibonacci . "\n";
    $y++;   
    if($y > 30)
    {
        break; // infinite loop prevent
    }
}
up
3
Shumeyko Dmitriy
10 months ago
This is little example of using generators with recursion. Used version of php is 5.5.5
[php]
<?php
define
("DS", DIRECTORY_SEPARATOR);
define ("ZERO_DEPTH", 0);
define ("DEPTHLESS", -1);
define ("OPEN_SUCCESS", True);
define ("END_OF_LIST", False);
define ("CURRENT_DIR", ".");
define ("PARENT_DIR", "..");

function
DirTreeTraversal($DirName, $MaxDepth = DEPTHLESS, $CurrDepth = ZERO_DEPTH)
{
  if ((
$MaxDepth === DEPTHLESS) || ($CurrDepth < $MaxDepth)) {
   
$DirHandle = opendir($DirName);
    if (
$DirHandle !== OPEN_SUCCESS) {
      try{
        while ((
$FileName = readdir($DirHandle)) !== END_OF_LIST) { //read all file in directory
         
if (($FileName != CURRENT_DIR) && ($FileName != PARENT_DIR)) {
           
$FullName = $DirName.$FileName;
           
yield $FullName;
            if(
is_dir($FullName)) { //include sub files and directories
             
$SubTrav = DirTreeTraversal($FullName.DS, $MaxDepth, ($CurrDepth + 1));
              foreach(
$SubTrav as $SubItem) yield $SubItem;
            }
          }
        }
      }
finally {
       
closedir($DirHandle);
      }
    }
  }
}

$PathTrav = DirTreeTraversal("C:".DS, 2);
print
"<pre>";
foreach(
$PathTrav as $FileName) printf("%s\n", $FileName);
print
"</pre>";
[/
php]
up
0
christophe dot maymard at gmail dot com
9 days ago
<?php
//Example of class implementing IteratorAggregate using generator

class ValueCollection implements IteratorAggregate
{
    private
$items = array();
   
    public function
addValue($item)
    {
       
$this->items[] = $item;
        return
$this;
    }
   
    public function
getIterator()
    {
        foreach (
$this->items as $item) {
           
yield $item;
        }
    }
}

//Initializes a collection
$collection = new ValueCollection();
$collection
       
->addValue('A string')
        ->
addValue(new stdClass())
        ->
addValue(NULL);

foreach (
$collection as $item) {
   
var_dump($item);
}
up
-7
denshadewillspam at HOTMAIL dot com
5 months ago
Note that you can't use count() on generators.

/**
* @return integer[]
*/
function xrange() {
    for ($a = 0; $a < 10; $a++)
    {
        yield $a;
    }
}

function mycount(Traversable $traversable)
{
    $skip = 0;
    foreach($traversable as $skip)
    {
        $skip++;
    }
    return $skip;
}
echo "Count:" . count(xrange()). PHP_EOL;
echo "Count:" . mycount(xrange()). PHP_EOL;
To Top