Le générateur PHP résout le problème de consommation de mémoire lors du traitement de grands ensembles de données en générant des valeurs une par une plut?t que de charger toutes les données à la fois. 1. Le générateur utilise le mot clé de rendement pour renvoyer les valeurs dans la fonction l'une après l'autre, en évitant de stocker l'ensemble de données entier dans un tableau; 2. 3. Bien que le générateur enregistre de la mémoire, il traverse irréversiblement et doit être réin-instifié une fois qu'il est épuisé. De plus, les performances peuvent être affectées par les frais généraux d'appel de fonction dans certaines boucles.

Les générateurs de PHP sont un moyen intéressant d'implémenter des itérateurs simples sans la surcharge de la maintenance de l'ensemble de données complet en mémoire. Au lieu de construire et de retourner un tableau entier, un générateur donne des valeurs une à la fois lorsque vous les itérez. Cela rend les générateurs particulièrement utiles pour gérer de grands ensembles de données ou des séquences infinies, car vous ne stockez pas tout en mémoire à la fois.

Quel problème les générateurs résolvent-ils?

Lorsque vous travaillez avec de grands ensembles de données, comme lire un énorme fichier ligne par ligne ou récupérer des milliers d'enregistrements de base de données - vous pouvez courir des problèmes de mémoire si vous chargez tout en même temps. Par exemple:

 fonction getNumbers () {
    $ nombres = [];
    pour ($ i = 0; $ i <1000000; $ i) {
        $ nombres [] = $ i;
    }
    retourner $ numéros;
}

Si vous boucez sur le résultat de getNumbers() , ce tableau est entièrement construit en mémoire avant le début de l'itération. Cela peut être lourd.

Un générateur évite cela en produisant chaque valeur à la demande.

Comment fonctionnent les générateurs en php

Vous définissez un générateur en utilisant le mot clé yield dans une fonction. Chaque fois que vous itérez sur le générateur, il exécute la fonction jusqu'à l'instruction yield suivante et ne fait pas partie de l'exécution jusqu'à la prochaine itération.

Voici un exemple de base:

 fonction NumberGenerator ($ limit) {
    pour ($ i = 0; $ i <$ limit; $ i) {
        rendement $ i;
    }
}

foreach (NumberGenerator (1000000) As $ numéro) {
    Echo Numéro $. "\ n";
}

Dans ce cas:

• Les chiffres de 0 à 999 999 ne sont jamais stockés dans un tableau.
• Chaque numéro est généré uniquement en cas de besoin.
• L'utilisation de la mémoire reste faible, même pour les grandes gammes.

Cette approche fonctionne très bien pour:

• Lire les gros fichiers ligne par ligne
• Réponses API en streaming
• Traitement des journaux ou des résultats de la base de données séquentiellement

Cas d'utilisation pratiques pour les générateurs

Lire les grands fichiers ligne par ligne

La lecture d'un fichier journal massif avec file() charge d'abord toutes les lignes dans un tableau, ce qui pourrait utiliser beaucoup de mémoire. Une solution basée sur un générateur lit une ligne à la fois:

 Fonction Readlines ($ nom de fichier) {
    $ handle = fopen ($ filename, 'r');
    while (($ line = fgets ($ handle))! == false) {
        rendement $ ligne;
    }
    fclose ($ manche);
}

foreach (readlines ('immense_log_file.log') comme $ line) {
    // traite chaque ligne sans charger le fichier entier
}

Cela maintient l'utilisation de la mémoire minimum et vous permet de traiter les fichiers plus grands que la RAM disponible.

Séquences infinies

Les générateurs peuvent également représenter des séquences théoriquement infinies car ils ne précomptent rien:

 fonction FindlessCounter () {
    $ i = 0;
    while (true) {
        rendement $ i;
    }
}

$ compter = EndlessCounter ();
echo $ compter-> current (); // 0
$ Counter-> Next ();
echo $ compter-> current (); // 1

Utile pour des choses comme des identifiants uniques ou des sorties de style ticker - assurez-vous de casser votre boucle quelque part!

Base de données paresseuse Récupération

Au lieu de tirer toutes les lignes dans un tableau, récupérez-les un par un:

 fonction getDatabaserows ($ pdostatement) {
    while ($ row = $ pdostation-> fetch (pdo :: fetch_assoc)) {
        rendement $ Row;
    }
}

$ stmt = $ pDo-> query ("SELECT * FROM BLET_TABLE");
foreach (getDatabaserows ($ stmt) comme $ row) {
    // traite chaque ligne
}

Cela réduit mieux la pression de la mémoire et l'échelle avec les grandes tables.

Limitations du générateur pour être conscient de

• Impossible de chercher en arrière : une fois qu'un générateur a donné une valeur et avancé, vous ne pouvez pas revenir en arrière. Vous ne pouvez pas rembobiner à moins d'explicitement géré.
• Non réutilisable : une fois qu'un générateur est épuisé (fait de céder), il ne peut pas être réutilisé. Vous devrez créer une nouvelle instance.
• Compromis des performances : bien que économe en mémoire, les générateurs peuvent être plus lents que les tableaux traditionnels dans certaines boucles serrées en raison des frais généraux d'appel de fonction.

L'utilisation de générateurs en PHP est simple et puissante lorsqu'il s'agit de flux de données importants ou continus. Ils gardent une utilisation de la mémoire faible et simplifient la structure du code en abstraction du suivi de l'état manuel à l'extérieur. Si vous itérez à travers de nombreuses données, envisagez de remplacer les tableaux par des générateurs, cela pourrait simplement empêcher votre serveur de manquer de mémoire.

Fondamentalement, c'est tout.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!