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 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";
}
?>$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";
}
?>$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(1, 3) as $i) {
yield;
}
}
var_dump(iterator_to_array(gen_three_nulls()));
?><?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...
