Itérateurs et générateurs en TypeScript

Les itérateurs et les générateurs sont des motifs importants en JavaScript/TypeScript pour manipuler des collections.

Ils offrent une manière unifiée de parcourir les données, ce qui facilite la gestion de grands flux de données, de séquences infinies, etc.


Diagramme SVG : itérateurs et générateurs Background Title Iterator and Generator Workflow Iterator Protocol Iterator Protocol Implement Symbol.iterator Return next() method { done, value } Arrow for...of loop for...of loop Automatically calls next() Iterates over all elements Stops when done=true Arrow Generator Generator function* yield pauses Lazy evaluation Bottom section: Generator characteristics Generator Characteristics Feature 1 Lazy evaluation - generates on demand Feature 2 State preservation - pause position Feature 3 Composable - yield* delegation Arrow marker

Pourquoi avons-nous besoin d'itérateurs et de générateurs

Lorsque nous travaillons avec des données de type collection, nous devons souvent parcourir des structures de données telles que les tableaux et les objets.

Les itérateurs fournissent une interface d'itération unifiée et personnalisable, permettant d'itérer sur n'importe quel objet.

Les générateurs sont un moyen concis de créer des itérateurs. Ils permettent de suspendre et de reprendre l'exécution à l'aide de fonctions, ce qui les rend idéaux pour gérer de grands flux de données ou des séquences infinies.

Explication du concept :Un itérateur est un objet qui fournit une méthode next() pour parcourir des données. Un générateur est une fonction spéciale qui peut suspendre son exécution et renvoyer une valeur.


Protocole d'itération

Les objets qui implémentent la méthode Symbol.iterator peuvent être parcourus avec une boucle for...of.

Exemple

// Les tableaux sont itérables par défaut
var arr = [1, 2, 3];
for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
    var item = arr_1[_i];
    console.log("Éléments du tableau : " + item);
}

// Les chaînes de caractères sont itérables par défaut
var str = "hello";
for (var _i = 0, str_1 = str; _i < str_1.length; _i++) {
    var char = str_1[_i];
    console.log("Caractères : " + char);
}

Sortie :

数组元素: 1
数组元素: 2
数组元素: 3
字符: h
字符: e
字符: l
字符: l
字符: o

Explication :Les tableaux et les chaînes de caractères ont tous deux des implémentations intégrées de Symbol.iterator, ils peuvent donc être parcourus directement avec for...of.


Objets itérables personnalisés

Faites en sorte que des objets ordinaires implémentent l'interface Symbol.iterator afin qu'ils puissent être parcourus.

Exemple

// Créer un objet itérable personnalisé : range
var range = {
    from: 1,
    à: 5,
    // Implémenter la méthode Symbol.iterator
    [Symbol.iterator]: function() {
        return {
            current: this.from,
            last: this.to,
            // La méthode next renvoie le résultat de l'itération
            next: function() {
                if (this.current <= this.last) {
                    // Pas terminé, renvoyer la valeur actuelle et incrémenter
                    return { done: false, value: this.current++ };
                }
                // Terminé
                return { done: true, value: undefined };
            }
        };
    }
};

// Itérer avec for...of
for (var _i = 0, range_1 = range; _i < range_1.length; _i++) {
    var num = range_1[_i];
    console.log("Plage : " + num);
}

Protocole d'itérateur :Un itérateur doit avoir une méthode next() qui renvoie un objet au format { done: boolean, value: any }.


Fonctions génératrices

Utilisez la syntaxe function* pour créer des générateurs, et utilisez yield pour suspendre l'exécution et renvoyer une valeur.

Exemple

// Fonction génératrice : utilise la syntaxe function*
function* numberGenerator() {
    yield 1;  // Met en pause et renvoie 1
    yield 2;  // Met en pause et renvoie 2
    yield 3;  // Met en pause et renvoie 3
}

// Créer une instance de générateur
var gen = numberGenerator();

// Chaque appel à next() s'exécute jusqu'au prochain yield
console.log("Premier : " + gen.next().value);
console.log("Deuxième : " + gen.next().value);
console.log("Troisième : " + gen.next().value);
console.log("Terminé : " + gen.next().done);

Sortie :

第一个: 1
第二个: 2
第三个: 3
完成: true

Générateur :Une fonction génératrice renvoie un itérateur, et chaque appel à next() s'exécute jusqu'à la prochaine instruction yield.


Générateurs infinis

Les générateurs peuvent produire des séquences infinies. Comme ils utilisent l'évaluation paresseuse, ils ne consomment pas une mémoire infinie.

Exemple

// Générateur de nombres infinis
// Chaque appel génère un seul nombre, pas tous les nombres à la fois
function* infiniteNumbers() {
    var n = 1;
    while (true) {  // Boucle infinie
        yield n++;   // Suspendre et renvoyer la valeur actuelle, puis incrémenter
    }
}

var gen = infiniteNumbers();
console.log("1er : " + gen.next().value);
console.log("2e : " + gen.next().value);
console.log("3e : " + gen.next().value);

// Obtenir uniquement les 5 premiers nombres
var nums = [];
var iter = infiniteNumbers();
for (var i = 0; i < 5; i++) {
    nums.push(iter.next().value);
}
console.log("5 premiers : " + nums);

Sortie :

第1个: 1
第2个: 2
第3个: 3
前5个: 1,2,3,4,5

Évaluation paresseuse :Le plus grand avantage des générateurs est l'évaluation paresseuse : la valeur suivante n'est calculée que lorsque next() est appelé, ce qui les rend idéaux pour gérer des séquences infinies.


Générateurs délégués

Utilisez yield* pour déléguer à un autre générateur ou objet itérable.

Exemple

// Premier générateur
function* gen1() {
    yield 1;
    yield 2;
}

// Deuxième générateur
function* gen2() {
    yield 3;
    yield 4;
}

// Générateur combiné : utilise la délégation yield*
function* combined() {
    yield* gen1();  // Déléguer à gen1
    yield* gen2();  // Déléguer à gen2
}

// Parcourir le générateur combiné
for (var _i = 0, combined_1 = combined(); _i < combined_1.length; _i++) {
    var num = combined_1[_i];
    console.log("Value: " + num);
}

Sortie :

值: 1
值: 2
值: 3
值: 4

yield*:Les générateurs délégués peuvent combiner plusieurs générateurs ou objets itérables, ce qui les rend bien adaptés à la construction de flux de données réutilisables.


Types de générateur TypeScript

Les annotations de type de générateur utilisent le type Generator.

Exemple

// Type Generator : Generator<type de yield, type de retour, type du paramètre next>
function* idGenerator(): Generator<number, void, unknown> {
    var i = 1;
    while (i <= 3) {
        yield i++;  // type number de yield
    }
    // retourne void
}

var gen = idGenerator();
console.log(Array.from(gen));

Explication du type :Generator<T, R, N> signifie : T est le type de yield, R est le type de retour final, et N est le type du paramètre de next().


Notes

  • Protocole d'itérateur :Implémentez Symbol.iterator pour retourner un objet avec une méthode next()
  • Syntaxe de générateur :Utilisez function* au lieu de function
  • Mot-clé yield :Met en pause l'exécution et renvoie une valeur
  • Évaluation paresseuse :Les générateurs calculent à la demande et ne génèrent pas toutes les valeurs en même temps
Bonnes pratiques :Utilisez des générateurs lors de la gestion de grands flux de données, de séquences infinies ou de scénarios nécessitant une pause/reprise.

Résumé

Les itérateurs et les générateurs sont des outils puissants de traitement de données en TypeScript.

  • Objets itérables :Implémentez l'interface Symbol.iterator
  • Générateurs :Créés avec function* et yield
  • yield:Suspendre l'exécution et renvoyer des valeurs
  • Délégation :Utilisez yield* pour combiner plusieurs générateurs

Recommandation :Utilisez des itérateurs et des générateurs lorsque vous devez parcourir des objets personnalisés, traiter des flux de données ou créer des séquences infinies.

Autres extensions