2.1 Syntaxe des générateurs
Les générateurs en JavaScript sont des fonctions spéciales qui permettent de contrôler l'exécution du code. Ils peuvent suspendre leur exécution et la reprendre plus tard, ce qui en fait un outil puissant pour travailler avec du code asynchrone, des itérateurs et d'autres tâches complexes.
Les générateurs sont définis à l'aide de la fonction function* (note bien l'étoile).
À l'intérieur d'un générateur, on utilise l'opérateur yield pour suspendre l'exécution et retourner une valeur.
Déclaration d'un générateur :
function* generatorFunction() {
yield 1;
yield 2;
yield 3;
}
Création d'un objet générateur
Appeler un générateur ne l'exécute pas immédiatement. À la place, ça retourne un objet générateur, que tu peux utiliser pour itérer sur les valeurs :
const gen = generatorFunction();
2.2 Utilisation des générateurs
Méthode next()
La méthode next() est utilisée pour reprendre l'exécution du générateur jusqu'au prochain opérateur yield.
Elle retourne un objet avec deux propriétés :
value: la valeur retournée par l'opérateuryielddone: un booléen qui indique si le générateur est terminé (true) ou non (false)
Exemple d'utilisation de la méthode next() :
function* generatorFunction() {
yield 1;
yield 2;
yield 3;
}
const gen = generatorFunction();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: false }
console.log(gen.next()); // { value: undefined, done: true }
Itération sur un générateur
Les générateurs peuvent être utilisés avec la boucle for...of pour itérer sur les valeurs.
Exemple d'itération sur un générateur :
function* generatorFunction() {
yield 1;
yield 2;
yield 3;
}
const gen = generatorFunction();
for (const value of gen) {
console.log(value);
}
// Affichera : 1
// Affichera : 2
// Affichera : 3
Exemple de retour de valeurs
Les générateurs peuvent retourner une valeur en utilisant l'opérateur return :
function* generatorFunction() {
yield 1;
yield 2;
return 3;
yield 4; // Ce yield ne sera jamais exécuté
}
const gen = generatorFunction();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: true }
console.log(gen.next()); // { value: undefined, done: true }
2.3 Utilisation avancée des générateurs
Interaction avec un générateur
La méthode next() peut prendre un argument qui est passé dans le générateur et peut être utilisé à l'intérieur.
Exemple de passage de valeurs dans un générateur :
function* generatorFunction() {
const value1 = yield 1;
const value2 = yield value1 + 2;
yield value2 + 3;
}
const gen = generatorFunction();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next(10)); // { value: 12, done: false }
console.log(gen.next(20)); // { value: 23, done: false }
console.log(gen.next()); // { value: undefined, done: true }
Gestion des erreurs
Les générateurs permettent de gérer les erreurs à l'aide du bloc try...catch.
Exemple de gestion des erreurs :
function* generatorFunction() {
try {
yield 1;
yield 2;
} catch (error) {
console.log('Erreur capturée :', error);
}
}
const gen = generatorFunction();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.throw(new Error('Something went wrong'))); // Erreur capturée : Error: Something went wrong
// { value: undefined, done: true }
Exemple de générateur pour créer une séquence infinie
Les générateurs peuvent être utilisés pour créer des séquences infinies de valeurs :
function* infiniteSequence() {
let i = 0;
while (true) {
yield i++;
}
}
const gen = infiniteSequence();
console.log(gen.next().value); // 0
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
// et ainsi de suite
2.4 Exemples d'utilisation pratique
Exemple 1 : Générateur pour itérer sur un objet
function* objectEntries(obj) {
const keys = Object.keys(obj);
for (const key of keys) {
yield [key, obj[key]];
}
}
const obj = { a: 1, b: 2, c: 3 };
const gen = objectEntries(obj);
for (const [key, value] of gen) {
console.log(`${key}: ${value}`);
}
// Affichera :
// a: 1
// b: 2
// c: 3
Exemple 2 : Générateur pour implémenter un itérateur simple
const myIterable = {
*[Symbol.iterator]() {
yield 1;
yield 2;
yield 3;
}
};
for (const value of myIterable) {
console.log(value);
}
// Affichera : 1
// Affichera : 2
// Affichera : 3
Les générateurs en JavaScript sont un outil puissant pour contrôler l'exécution du code, créer des itérateurs et travailler avec des opérations asynchrones. Comprendre la syntaxe et l'utilisation des générateurs aide à créer du code plus flexible et lisible, surtout lorsqu'on traite des séquences de données et des tâches asynchrones.
GO TO FULL VERSION