Node.js Generators et comparer avec les rappels

Dans ce tutoriel, nous allons découvrir Generators et leurs différences avec les rappels

Quels sont generators?

Generators sont devenus assez célèbres dans Node.js ces derniers temps et cela est probablement dû à ce dont ils sont capables de faire.

  • GeneratorLes s sont des exécutions de fonctions qui peuvent être suspendues et reprises à un moment donné. later point.
  • GeneratorLes s sont utiles lors de la mise en œuvre de concepts tels que «l'exécution paresseuse». Cela signifie essentiellement qu'en suspendant l'exécution et en reprenant à volonté, nous sommes en mesure d'extraire des valeurs uniquement lorsque nous en avons besoin.

Generators ont les 2 méthodes clés ci-dessous.

  1. Méthode de rendement – La méthode Yield est appelée dans une fonction pour arrêter l'exécution de la fonction à la ligne spécifique où la méthode Yield est appelée.
  2. Méthode suivante – Cette méthode est appelée depuis l’application principale pour reprendre l’exécution d’une fonction qui possède une méthode rendement. L'exécution de la fonction se poursuivra jusqu'à la prochaine méthode rendement ou jusqu'à la fin de la méthode.

Regardons un exemple de la façon dont generators peut être utilisé.

Dans notre exemple, nous allons avoir une simple fonction Add qui ajoutera 2 nombres, mais nous continuerons à arrêter l'exécution de la méthode à différents moments pour montrer comment generators peut être utilisé.

Node.js Generators

function* Add(x) {
   yield x + 1;
   var y = yield(null);
   y = 6
   return x + y;
}

var gen = Add(5);

gen.next();

gen.next(); 

Explication du code

  1. La première étape consiste à définir notre generator "fonction". Notez que cela se fait en ajoutant un « * » au mot-clé function. Nous définissons ensuite une fonction appelée Add qui prend un paramètre de x.
  2. Le mot clé rendement est spécifique à generators. Cela en fait une construction puissante pour suspendre une fonction au milieu de n'importe quoi. Donc ici, l'exécution de la fonction sera interrompue jusqu'à ce que nous invoquions la fonction next(), ce qui sera effectué à l'étape 4. À ce stade, la valeur de x deviendra 6 et l’exécution de la fonction sera arrêtée.
  3. C'est là que nous appelons pour la première fois le generator fonction et envoyez la valeur de 5 à notre fonction Ajouter. Cette valeur sera substituée dans le paramètre x de notre fonction Add.
  4. Une fois que nous appellerons la fonction next(), la fonction Add() reprendra l'exécution. Lorsque la prochaine instruction var y= rendement(null) sera exécutée, la fonction Add() cessera à nouveau de s'exécuter.
  5. Maintenant, après avoir appelé à nouveau la fonction next(), les instructions suivantes seront exécutées et la valeur combinée de x=5 et y=6 sera ajoutée et renvoyée.

Rappels vs. generators

GeneratorLes s sont utilisés pour résoudre le problème de ce que l’on appelle l’enfer des rappels. Parfois, les fonctions de rappel deviennent tellement imbriquées lors du développement d'une application Node.js qu'il devient tout simplement trop compliqué d'utiliser des fonctions de rappel.

C'est ici que generatorles s sont utiles. L’un des exemples les plus courants est celui de la création de fonctions de minuterie.

Voyons l'exemple ci-dessous de la façon dont generatorLes s peuvent s'avérer utiles lors des rappels.

Notre exemple va simplement créer une simple fonction de temporisation. On voudrait alors appeler cette fonction intégrant un retard de 1000, 2000 et 3000 ms.

Étape 1) Définissez notre fonction de rappel avec le code de temporisation nécessaire.

Rappels vs. Generators

function Timedelay(ptime, callback) {

setTimeout(function() {
  
    callback("Pausing for " + ptime);
    
  }, time);
}

Explication du code

  1. Ici, nous créons une fonction appelée Timedelay avec un paramètre appelé ptime. Cela prendra le délai nécessaire que nous souhaitons introduire dans notre application.
  2. L'étape suivante consiste simplement à créer un message qui sera affiché à l'utilisateur indiquant que l'application va être en pause pendant plusieurs millisecondes.

Étape 2) Regardons maintenant le code si nous incorporions des rappels. Supposons que nous voulions incorporer des rappels basés sur la valeur de 1000 2000, 3000 et millisecondes, le code ci-dessous montre comment nous aurions besoin de les implémenter à l'aide de rappels.

Rappels vs. Generators

Timedelay(1000, function(message) {
  
  console.log(msg);
  Timedelay(2000, function(message) {
    
    console.log(msg);
    Timedelay(3000, function(message) {
      
      console.log(msg);
  })
  })
})

Explication du code

  1. Nous appelons le Timedelay comme un rappel avec 1000 comme valeur.
  2. Ensuite, nous voulons appeler à nouveau la fonction Timedelay avec 2000 comme valeur.
  3. Enfin, nous souhaitons appeler à nouveau la fonction Timedelay avec 3000 comme valeur.

À partir du code ci-dessus, vous pouvez voir que cela devient plus compliqué car nous voulons commencer à appeler la fonction plusieurs fois.

Étape 3) Voyons maintenant comment implémenter le même code en utilisant generators. À partir du code ci-dessous, vous pouvez maintenant voir à quel point il est devenu simple d'implémenter la fonction Timedelay en utilisant generators.

Rappels vs. Generators

function* Messages() {
  console,log(yield(Timedelay(1000, function(){})));
  console,log(yield(Timedelay(2000, function(){})));
  console,log(yield(Timedelay(3000, function(){})));
}

Explication du code

  1. Nous définissons d'abord un generator fonction qui sera utilisée pour appeler notre fonction Timedelay.
  2. Nous appelons la fonction Yield avec la fonction Timedelay avec 1000 comme valeur de paramètre.
  3. Nous appelons ensuite la fonction Yield avec la fonction Timedelay avec 2000 comme valeur de paramètre.
  4. Enfin, nous appelons la fonction Yield avec la fonction Timedelay avec 3000 comme valeur de paramètre.

Résumé

Generators peuvent également être utilisés pour atténuer les problèmes liés aux rappels imbriqués et aider à supprimer ce que l'on appelle l'enfer des rappels. Generators sont utilisés pour arrêter le traitement d’une fonction. Ceci est accompli par l'utilisation de la méthode « rendement » dans le cadre d'unsyncfonction hroneuse.