Les générateurs offrent un moyen efficace en mémoire d'itérer sur de grands ensembles de données en produisant des valeurs une à la fois (paresseusement) en utilisant le mot-clé yield, au lieu de construire un tableau entier en mémoire à la fois. Ils sont idéaux pour les données volumineuses ou en continu.
{
= [];
( = ; < ; ++) { [] = ; }
;
}
{
( = ; < ; ++) {
;
}
}
(() ) {
();
}
yield fait d'une fonction un générateur : il produit des valeurs paresseusement, une par itération, en conservant son état entre elles — donc la mémoire reste constante quel que soit le nombre de valeurs qu'il produit.
function readLines(string $file): Generator {
$handle = fopen($file, 'r');
while (($line = fgets($handle)) !== false) {
yield $line; // yield one line at a time — never load the whole file
}
fclose($handle);
}
foreach (readLines('huge-10gb.csv') as $line) { // processes a 10GB file with tiny memory
process($line);
}
Lire un énorme fichier ligne par ligne avec un générateur utilise une mémoire constante — impossible avec file() (qui charge le fichier entier dans un tableau).
function fetchRows(PDOStatement $stmt): Generator {
while ($row = $stmt->fetch()) {
yield $row['id'] => $row; // yield key => value, streaming DB rows
}
}
Les générateurs sont excellents pour traiter les résultats de base de données en continu — traiter les lignes une à la fois au lieu de charger un énorme ensemble de résultats en mémoire.
Les générateurs sont une fonctionnalité PHP importante pour le traitement efficace en mémoire des grands ensembles de données — et les comprendre est précieux pour construire des applications qui traitent les données à grande échelle sans épuiser la mémoire.
Le problème fondamental qu'ils résolvent est que construire un tableau complet de grandes données (des millions d'enregistrements, les lignes d'un énorme fichier, un gros ensemble de résultats de base de données) peut consommer une mémoire énorme et faire planter l'application, tandis que les générateurs produisent des valeurs paresseusement, une à la fois, en gardant la mémoire constante quel que soit la taille de l'ensemble de données.
Les cas d'usage les plus impactants sont pratiques et courants : lire les gros fichiers ligne par ligne (traiter un CSV ou un journal de plusieurs gigaoctets avec peu de mémoire, impossible avec des fonctions qui chargent tout), traiter les résultats de base de données en continu (gérer les gros résultats de requête ligne par ligne), et traiter les grandes séquences ou même infinies.
Comprendre yield, l'évaluation paresseuse, et quand utiliser les générateurs (chaque fois que vous construiriez autrement un grand tableau en mémoire) vous permet d'écrire du code de traitement de données évolutif qui gère de gros volumes gracieusement — un besoin très fréquent dans les travaux par lots, les importations/exportations, la génération de rapports, et les pipelines de données.
Bien qu'ils ne soient pas nécessaires pour de petits ensembles de données, les générateurs sont des connaissances essentielles pour le PHP conscient de la mémoire qui traite de grandes quantités de données, distinguant les développeurs qui peuvent construire du code de gestion de données évolutif de ceux dont les applications échouent ou ralentissent sous de gros volumes de travail, ce qui en fait une connaissance précieuse au niveau senior pour les applications PHP sensibles aux performances et intensives en données.