Explication détaillée de l'utilisation des générateurs Javascript dans les astuces Node.js_javascript

Les générateurs sont un style coroutine (coroutine en abrégé : coroutine) de Javascript. Ils font référence à des fonctions qui peuvent être mises en pause puis reprises pendant l'exécution. La fonction est dans les fonctions avec un astérisque tel que fonction*, fonction Il y a. quelques mots-clés caractéristiques tels que rendement et rendement*.

function* generatorFn () {

 console.log('look ma I was suspended')

}

var generator = generatorFn() // [1]

setTimeout(function () {

 generator.next() // [2]

}, 2000)

Les [1] et [2] marqués dans le code sont expliqués comme suit :

1. Il s'agit d'un générateur démarré en mode pause. Il n'y a pas de sortie de console pour le moment.

2. En appelant sa méthode next(), ce générateur s'exécutera et s'exécutera jusqu'à ce qu'il rencontre le prochain mot-clé rendement ou retour. Nous avons maintenant la sortie de la console.

Regardez un autre cas :

function *generator() {

 console.log('Start!');

 var i = 0;

 while (true) {

  if (i < 3)

   yield i++;

 }

}
var gen = generator();

Le code ci-dessus est similaire au premier, sauf que le mot-clé rendement est ajouté à la fonction du générateur. Lorsque le code ci-dessus est appelé, il ne sera pas exécuté immédiatement, mais sera suspendu et en veille, donc il y en aura. il n'y aura pas de sortie de démarrage. Il n’est exécuté qu’à son appel next().

var ret = gen.next();

// Start!

console.log(ret);

// {value: 0, done: false}

Le ret ci-dessus est le résultat du générateur. Il a deux attributs :

■valeur, la valeur de rendement dans la fonction génératrice,

■ terminé, il s'agit d'un indicateur indiquant si la fonction génératrice revient.

Le code de suite est le suivant :

console.log(gen.next());

// {value: 1, done: false}

console.log(gen.next());

// {value: 2, done: false}

console.log(gen.next());

// {value: undefined, done: true}

Generator n'a pas de mystère dans la programmation synchrone et est particulièrement adapté à la programmation asynchrone.

Le

le générateur a deux caractéristiques :

1. Vous pouvez choisir de quitter une fonction et laisser le code externe décider quand revenir à cette fonction pour continuer l'exécution.
2. Possibilité d'effectuer un contrôle asynchrone.

Regardez le code d'exécution asynchrone ci-dessous :

var gen = generator();

console.log(gen.next().value);

setTimeout(function() {

 console.log(gen.next().value);

 console.log('第一步');

}, 1000);

console.log('第二步');

Le résultat est :

0
Étape 2
1
La première étape

En d'autres termes, vous n'attendrez pas la fin du timer dans setTimeout, mais passerez directement à la "deuxième étape" et ne serez pas bloqué dans setTimeout.

Regardez un autre morceau de code :

function* channel () {

 var name = yield 'hello, what is your name?' // [1]

 return 'well hi there ' + name

}

var gen = channel()

console.log(gen.next().value) // hello, what is your name? [2]

console.log(gen.next('billy')) // well hi there billy [3]

Vous pouvez également utiliser *:
lors de la traversée

function* iter () {

 for (var i = 0; i < 10; i++) yield i

}

for (var val of iter()) {

 console.log(val) // outputs 1&#63;—&#63;9

}

Malentendus courants

Puisque je peux suspendre l'exécution d'une fonction, dois-je les laisser s'exécuter en parallèle ? Non, car Javascript est monothread et si vous cherchez à améliorer les performances, les générateurs ne sont pas votre tasse de thé.

Par exemple, le code suivant exécute respectivement les nombres de Fibonacci :

function fib (n) {

 var current = 0, next = 1, swap

 for (var i = 0; i < n; i++) {

  swap = current, current = next

  next = swap + next

 }

 return current

}

 

function* fibGen (n) {

 var current = 0, next = 1, swap

 for (var i = 0; i < n; i++) {

  swap = current, current = next

  next = swap + next

  yield current

 }

}

Les résultats de performance sont les suivants : (plus il est élevé, mieux c'est)

résultats :
régulier 1263899
générateur 37541

Les générateurs brillent

Les générateurs peuvent simplifier la complexité des fonctions en JavaScript.

Tâche paresseuse

Bien que l'affectation paresseuse puisse être implémentée à l'aide des fermetures JS, l'utilisation de rendement la simplifiera grandement. En faisant une pause et en reprenant, nous pouvons obtenir la valeur lorsque nous en avons besoin. Par exemple, la fonction fibGen ci-dessus peut l'extraire lorsque nous en avons besoin. Nouvelle valeur :

var fibIter = fibGen(20)

var next = fibIter.next()

console.log(next.value)

setTimeout(function () {

 var next = fibIter.next()

 console.log(next.value)

},2000)

当然还使用for循环：依然是懒赋值

for (var n of fibGen(20) {

 console.log(n)

}

Séquence infinie

Comme l'affectation paresseuse est possible, il est possible d'effectuer certaines astuces Haskell, similaires aux séquences infinies. Ici, vous pouvez produire un nombre infini de séquences.

function* fibGen () {

 var current = 0, next = 1, swap

 while (true) {

  swap = current, current = next

  next = swap + next

  yield current

 }

}

Regardons l'affectation paresseuse d'un flux de nombres de Fibonacci et demandons-lui de renvoyer le premier nombre de Fibonacci après 5000 :

for (var num of fibGen()) {

 if (num > 5000) break

}

console.log(num) // 6765

Contrôle de processus asynchrone

Utilisez des générateurs pour implémenter un contrôle de processus asynchrone. Les plus courants sont divers packages de bibliothèques de promesses. Alors, comment ça marche ?

Dans le domaine de Node, tout est lié aux rappels, qui sont nos fonctions asynchrones de bas niveau. Nous pouvons utiliser des générateurs pour établir un canal de communication et écrire du code asynchrone en utilisant un style de programmation synchrone.

run(function* () {

 console.log("Starting")

 var file = yield readFile("./async.js") // [1]

 console.log(file.toString())

})

Le commentaire 1 indique que le programme attendra qu'async.js renvoie le résultat avant de continuer.

Genify est un framework qui introduit les générateurs dans l'environnement de programmation normal. Il est utilisé comme suit :

npm install genify pour installer, le code est le suivant :

var Q = require('q');

var fs = require('fs');

var genify = require('genify');

 

// wrap your object into genify function

var object = genify({

 concatFiles: function * (file1, file2, outFile) {

  file1 = yield Q.nfcall(fs.readFile, file1);

  file2 = yield Q.nfcall(fs.readFile, file2);

  var concated = file1 + file2;

 

  yield Q.nfcall(fs.writeFile, outFile, concated);

 

  return concated;

 }

});

 

// concatFiles是一个generator函数，它使用generator强大能力。

object.concatFiles('./somefile1.txt', './somefile2.txt', './concated.txt').then(function (res) {

 // do something with result

}, function (err) {

 // do something with error

});

L'explication détaillée ci-dessus de l'utilisation des générateurs Javascript dans Node.js est tout le contenu partagé par l'éditeur. J'espère qu'elle pourra vous donner une référence et j'espère que vous soutiendrez Script Home.