PHP introduit les générateurs

Par un mécanisme similaire à celui de Python avec le mot-clé yield

Les rubriques (actu, forums, tutos) de Développez

Réseaux sociaux

Sur le même sujet

19/11/2012 - PHP 5.5 sort en Alpha1 et introduit les générateurs, le block Finally ainsi qu'une API de hachage des mots de passe

26/10/2012 - Comment produisez-vous votre HTML ? Avec un moteur de template? Avec echo ? A votre manière ?

Le 04/09/2012, par tarikbenmerar, Chroniqueur Actualités

Les générateurs sont un moyen simple et puissant de créer des itérateurs dans des langages tels que Python. Maintenant, c'est PHP qui fait le pas et s'approprie ce concept.

Pour comprendre l'utilité et la puissance de ce dernier, on revoit l'exemple typique de lecture d'un fichier en entier :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function getLinesFromFile($fileName) {
    if (!$fileHandle = fopen($fileName, 'r')) {
        return;
    }

    $lines = [];
    while (false !== $line = fgets($fileHandle)) {
        $lines[] = $line;
    }

    fclose($fileHandle);

    return $lines;
}

$lines = getLinesFromFile($fileName);
foreach ($lines as $line) {
    // do something with $line
}

Le point faible de ce code est le fait qu'il copie tout le fichier dans un grand tableau. Ainsi, plus le fichier est grand, plus le besoin en mémoire s'accroît, avec un risque imminent d'atteindre les limites. Il faut toujours se rappeler qu'un script PHP doit respecter une limite de mémoire spécifiée par l'administrateur.

On peut certainement éviter ce comportement et récupérer les données ligne par ligne, en utilisant les itérateurs qui sont parfaits pour ce cas d'utilisation. Malheureusement, en PHP il n'existait jusque-là aucune manière simple d'implémenter les itérateurs. Pour y arriver, on est amené à créer une classe complexe implémentant une interface Iterator comme suit :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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);
    }
}

$lines = new LineIterator($fileName);
foreach ($lines as $line) {
    // do something with $line
}

Pour un cas aussi simple que notre exemple, le code est déjà complexe. Avec les générateurs, on peut considérablement réduire le nombre de lignes de code de manière directe à partir de la première version du code :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function getLinesFromFile($fileName) {
    if (!$fileHandle = fopen($fileName, 'r')) {
        return;
    }

    while (false !== $line = fgets($fileHandle)) {
        //c'est ici la différence
        yield $line;
    }

    fclose($fileHandle);
}

$lines = getLinesFromFile($fileName);
foreach ($lines as $line) {
    // do something with $line
}

La toute petite différence réside dans l'utilisation du mot clé yield, qui génère une nouvelle donnée dans l'itération.

En effet, l'instruction $lines = getLinesFromFile($fileName) ne renvoie aucune donnée, c'est simplement un générateur qui implémente l'itérateur qui vient d'être créé.

Après, pendant l'exécution de la boucle foreach ($lines as $line), chaque itération génère les données renvoyées par yield, qui seront stockées dans $line. En fait, cette génération implémente un objet Iterator et des appels à Iterator::next() seront effectués. L'exécution s'arrête jusqu'à la rencontre du prochain yield, qui renvoie la prochaine donnée, et ainsi de suite...

Quelques jours après l'introduction du mot clé Finally, se succèdent donc pour PHP les bonnes nouvelles. Ou les emprunts d’autres langages, diront certains.

Source : détails du mot clé yield dans le site de PHP

Et vous ?

Quelle impression vous laisse cette annonce ?

Pouvez-vous trouver d'autres cas d'utilisation intéressants ?

Quelle autre approche de simplification des itérateurs auriez-vous préférée pour PHP ?

123456789101112131415

function forEachLineFromFile($fileName, $f) {
    if (!$fileHandle = fopen($fileName, 'r')) {
        return;
    }
 
    while (false !== $line = fgets($fileHandle)) {
        $f($line);
    }
 
    fclose($fileHandle);
}
 
forEachLineFromFile($filename, function($line) {
    // do something with $line
});

public class Resultat extends Exception {
    var $resultat;
    public function __constructor($resultat) {
        $this->resultat = $resultat;
    }
    
    public function getResultat() {
        return $this->resultat;
    }
}

function monIterateur() {
     $resultat = calculs();
     throw new Resultat($resultat);
}

function utilisation() {
     do {
         try {
               monIterateur();
         } catch (Resultat $r) {
               $line = $r.getResultat();
               $continue = $line === FALSE; //On suppose que nos calculs nous retournent FALSE à la fin de lecture.
               if ($continue !== FALSE) {
                    doStuff($line);
               }
         }
     } while ($continue);
     
}

function echoLogger() {
    while (true) {
        echo 'Log: ' . yield . "\n";
    }
}
 
function fileLogger($fileName) {
    $fileHandle = fopen($fileName, 'a');
    while (true) {
        fwrite($fileHandle, yield . "\n");
    }
}
 
$logger = echoLogger();
// or
$logger = fileLogger(__DIR__ . '/log');
 
$logger->send('Foo');
$logger->send('Bar');

PHP introduit les générateurs Par un mécanisme similaire à celui de Python avec le mot-clé yield

PHP introduit les générateurs

Par un mécanisme similaire à celui de Python avec le mot-clé yield