Ausführliche Erläuterung der Verwendung von Javascript-Generatoren in Node.js_Javascript-Tipps

Generatoren sind ein Coroutine-Stil (kurz: Coroutine) von Javascript. Sie beziehen sich auf Funktionen, die während der Ausführung angehalten und dann fortgesetzt werden können. Die Funktion ist mit einem Sternchensymbol versehen, z. B. Funktion*, Funktion einige charakteristische Schlüsselwörter wie yield und yield*.

function* generatorFn () {

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

}

var generator = generatorFn() // [1]

setTimeout(function () {

 generator.next() // [2]

}, 2000)

Die im Code markierten [1] und [2] werden wie folgt erklärt:

1. Dies ist ein Generator, der im Pausenmodus gestartet wird. Derzeit erfolgt keine Konsolenausgabe.

2. Durch Aufrufen seiner next()-Methode wird dieser Generator ausgeführt und ausgeführt, bis er auf das nächste yield-Schlüsselwort trifft oder zurückkehrt. Jetzt haben wir eine Konsolenausgabe.

Schauen Sie sich einen anderen Fall an:

function *generator() {

 console.log('Start!');

 var i = 0;

 while (true) {

  if (i < 3)

   yield i++;

 }

}
var gen = generator();

Der obige Code ähnelt dem ersten, außer dass das Schlüsselwort yield zur Generatorfunktion hinzugefügt wird. Wenn der obige Code aufgerufen wird, wird er nicht sofort ausgeführt, sondern angehalten und im Standby-Modus keine Startausgabe sein. Es wird erst bei seinem next()-Aufruf ausgeführt.

var ret = gen.next();

// Start!

console.log(ret);

// {value: 0, done: false}

Das obige ret ist das Generatorergebnis. Es hat zwei Attribute:

■Wert, der Ertragswert in der Generatorfunktion,

■Fertig, dies ist ein Flag, das angibt, ob die Generatorfunktion zurückkehrt.

Der Fortsetzungscode lautet wie folgt:

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 ist kein Geheimnis in der synchronen Programmierung und eignet sich besonders für die asynchrone Programmierung.

Generator hat zwei Eigenschaften:

1. Sie können eine Funktion verlassen und den externen Code entscheiden lassen, wann zu dieser Funktion zurückgesprungen werden soll, um die Ausführung fortzusetzen.
2. Fähigkeit zur asynchronen Steuerung.

Sehen Sie sich den asynchronen Ausführungscode unten an:

var gen = generator();

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

setTimeout(function() {

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

 console.log('第一步');

}, 1000);

console.log('第二步');

Die Ausgabe ist:

0
Schritt 2
1
Der erste Schritt

Mit anderen Worten, Sie warten nicht auf das Ende des Timers in setTimeout, sondern fahren direkt mit dem „zweiten Schritt“ fort und werden in setTimeout nicht blockiert.

Sehen Sie sich einen anderen Code an:

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]

Sie können beim Traversieren auch *:
verwenden

function* iter () {

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

}

for (var val of iter()) {

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

}

Häufige Missverständnisse

Da ich die Ausführung einer Funktion anhalten kann, sollte ich sie dann parallel ausführen lassen? Nein, denn Javascript ist ein einzelner Thread und wenn Sie die Leistung verbessern möchten, sind Generatoren nicht Ihr Ding.

Zum Beispiel führt der folgende Code jeweils Fibonacci-Zahlen aus:

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

 }

}

Die Leistungsergebnisse sind wie folgt: (je höher, desto besser)

Ergebnisse:
regulär 1263899
Generator 37541

Generatoren leuchten

Generatoren können die Komplexität von Funktionen in JavaScript vereinfachen.

Faule Aufgabe

Obwohl eine verzögerte Zuweisung mithilfe von JS-Verschlüssen implementiert werden kann, wird die Verwendung von yield dies erheblich vereinfachen. Durch Anhalten und Fortsetzen können wir den Wert abrufen, wenn wir ihn benötigen. Die obige fibGen-Funktion kann ihn beispielsweise abrufen, wenn wir ihn benötigen. Neuer Wert:

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)

}

Unendliche Sequenz

Da eine verzögerte Zuweisung möglich ist, ist es möglich, einige Haskell-Tricks durchzuführen, ähnlich wie bei unendlichen Sequenzen. Hier können Sie eine unendliche Anzahl von Sequenzen erhalten.

function* fibGen () {

 var current = 0, next = 1, swap

 while (true) {

  swap = current, current = next

  next = swap + next

  yield current

 }

}

Sehen wir uns die verzögerte Zuweisung eines Fibonacci-Zahlenstroms an und bitten ihn, die erste Fibonacci-Zahl nach 5000 zurückzugeben:

for (var num of fibGen()) {

 if (num > 5000) break

}

console.log(num) // 6765

Asynchrone Prozesssteuerung

Verwenden Sie Generatoren, um eine asynchrone Prozesssteuerung zu implementieren. Wie funktioniert das?

Im Bereich Node hängt alles mit Rückrufen zusammen, bei denen es sich um unsere asynchronen Funktionen auf niedriger Ebene handelt. Wir können Generatoren verwenden, um einen Kommunikationskanal einzurichten und asynchronen Code im synchronen Programmierstil zu schreiben.

run(function* () {

 console.log("Starting")

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

 console.log(file.toString())

})

Kommentar 1 gibt an, dass das Programm darauf wartet, dass async.js das Ergebnis zurückgibt, bevor es fortfährt.

Genify ist ein Framework, das Generatoren in die normale Programmierumgebung integriert. Es wird wie folgt verwendet:

npm install genify zum Installieren lautet der Code wie folgt:

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

});

Die obige detaillierte Erklärung zur Verwendung von Javascript-Generatoren in Node.js ist der gesamte vom Herausgeber geteilte Inhalt. Ich hoffe, dass er Ihnen eine Referenz geben kann, und ich hoffe, dass Sie Script Home unterstützen.