Expliquer les différents types de générateurs en JavaScript

Comme nous le savons tous, JavaScript est un langage de programmation léger et les générateurs ont été introduits dans ECMAScript 2015. Un générateur est un processus qui a de nombreuses valeurs de sortie et qui peut être arrêté et démarré. En JavaScript, les générateurs sont constitués de fonctions génératrices qui produisent un itérable d'objets générateurs.

Dans cet article, nous discuterons en détail des générateurs en JavaScript et des différents types de générateurs en JavaScript avec la syntaxe et des exemples.

Introduction aux générateurs en JavaScript

La fonction du générateur est la même que la fonction normale, mais avec une différence, la fonction du générateur peut être reprise et mise en pause. De manière générale, en JavaScript, les fonctions ne s'arrêtent pas une fois appelées. Typiquement, la notion de générateurs apparaît dans la programmation asynchrone.

Syntaxe des fonctions génératrices en JavaScript

Nous allons maintenant discuter de la syntaxe des fonctions génératrices en JavaScript et la comparer avec les fonctions régulières.

La syntaxe

function * est utilisée pour créer des fonctions génératrices et le mot-clé rendement est utilisé pour les mettre en pause.

function * genFunc() {
   yield 'Hello';
   yield 'World';
}
const g = genFunc(); // g is a generator
g.next(); // { value: 'Hello', done: false }
g.next(); // { value: 'World', done: false }
g.next(); // { value: undefined, done: true }
…

Lorsqu'une fonction génératrice est appelée pour la première fois, aucun de son code n'est exécuté, mais un objet générateur est renvoyé. Les valeurs sont consommées en appelant la méthode next() du générateur, qui exécute le code jusqu'à ce qu'il rencontre le mot-clé rendement, auquel cas il fait une pause et attend que next() soit à nouveau appelé.

Dans le code ci-dessus, après notre instruction finale, les appels successifs à g.next() produiront simplement le même objet de retour : {value : undefined, did : true}, car nous sommes dans le 'monde' de notre code 'Rien est défini après cela. Fonction genFunc().

Le mot-clé

yield met en pause l'exécution d'une fonction génératrice et fournit la valeur de l'expression qui la suit à l'appelant du générateur. Elle est comparable à la version basée sur un générateur du mot-clé return. Ne peut être appelé que directement depuis une fonction génératrice contenant rendement.

Comparez avec les fonctions régulières

function regFunc() {
   console.log("Hello World");
}
// Hello World

Dans les fonctions régulières, nous n'utilisons pas la fonction "*" et comme vous pouvez le voir dans l'exemple ci-dessus, elle n'utilise pas non plus la fonction rendement. Comme nous l'avons vu ci-dessus, la principale différence entre les fonctions normales et les fonctions de générateur est que les fonctions de générateur peuvent être arrêtées et mises en pause. Ainsi, à partir de l'exemple ci-dessus, vous pouvez voir que nous n'avons pas choisi de l'arrêter, mais que nous avons directement imprimé l'intégralité de la déclaration, qui est "Bonjour tout le monde".

Comme nous avons compris les bases des fonctions génératrices, passons maintenant aux différents types de fonctions génératrices -

Générateur Normal

Dans un générateur normal, le générateur agit comme un itérateur, générant la valeur suivante après chaque appel de méthode next() pour générer la fonction. Regardons un exemple où nous générerons des nombres un par un jusqu'à la fin de la liste.

function* generator_function(){
   for(var cur = 0 ; cur<7; cur++){
      yield cur;
   }
}
var object_generator = generator_function();
console.log(object_generator.next().value);
console.log(object_generator.next().value);
console.log(object_generator.next().value);
console.log(object_generator.next().value);
console.log(object_generator.next().value);
console.log(object_generator.next().value);
console.log(object_generator.next().value);

Dans le code ci-dessus, nous avons créé une fonction générique normale contenant le mot-clé rendement et l'avons appelée plusieurs fois à l'aide de la fonction next().

Générateur avec paramètres

Les générateurs avec paramètres sont un peu différents des générateurs normaux, cette fois nous devons passer un paramètre en utilisant la fonction next() pour l'envoyer à la fonction générateur. De plus, chaque fois que nous passons un paramètre, il sera stocké après le mot clé rendement et pas avant, nous comprendrons ce concept dans les exemples suivants -

function* generator_function(){
   console.log("start of the function")
   temp = yield;
   console.log("This is the first value passed: " + temp)
   temp = yield;
   console.log("This is the second value passed: " + temp)
}
var object_generator = generator_function();
object_generator.next("This is not the first ");
object_generator.next("this is first");
object_generator.next("this is second");
object_generator.next();

Dans le code ci-dessus, nous avons défini la fonction du générateur et cette fois nous lui avons transmis les paramètres. Lorsque nous appelons l'objet pour la première fois, les paramètres donnés ne sont pas imprimés car ils sont envoyés avant le mot-clé "yield" puis après que la valeur envoyée soit stockée dans la variable et imprimée, la valeur est imprimée une deuxième fois. Après cela, rien ne se passe car il n'y a actuellement aucune sortie.

Générateurs avec propriétés d'objet

Les générateurs peuvent être utilisés comme objets et lorsque nous les appelons, ils renvoient simplement la valeur qui leur est attribuée et peuvent être imprimés. Pour comprendre ce concept, regardons un exemple.

function* generator_function(){
   yield "First value"
   yield "Second value"
   yield "Third value"
}
var object_generator = generator_function();
console.log(object_generator.next().value);
console.log(object_generator.next().value);
console.log(object_generator.next().value);

Dans le code ci-dessus, nous définissons d'abord trois expressions de rendement, et il y a une chaîne après elles. Lorsque nous appelons le générateur, la chaîne qui les suit sera renvoyée.

Il existe également d'autres types de générateurs, tels que les types de retour, certains générateurs contiennent un autre générateur à l'intérieur, etc.

Conclusion

Dans l'article, nous avons appris que la fonction du générateur est la même que la fonction normale, mais avec une différence, la fonction du générateur peut être reprise et mise en pause. De manière générale, en JavaScript, les fonctions ne s'arrêtent pas une fois appelées. Typiquement, la notion de générateurs apparaît dans la programmation asynchrone. Il existe de nombreux types de générateurs, tels que les générateurs ordinaires avec des objets tels que des paramètres et des propriétés, les générateurs contenant un autre générateur, etc.

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!