ES6 führte Generator-Funktionen ein, die den Ausführungsfluss einer Funktion durch das Schlüsselwort `yield` anhalten können, wodurch es möglich wird, den Ausführungsfluss zu ändern und somit eine Lösung für asynchrone Programmierung bereitzustellen. Grundlegende Verwendung

Generator-Funktionskomposition

Der Generator hat zwei Teile, die ihn von gewöhnlichen Funktionen unterscheiden:

  • Einer davon ist, dass nach `function` und vor dem Funktionsnamen ein `*` steht;

  • Innerhalb der Funktion gibt es einen `yield`-Ausdruck.

Dabei wird `*` verwendet, um anzuzeigen, dass die Funktion eine Generator-Funktion ist, und `yield` wird verwendet, um den internen Zustand der Funktion zu definieren.

function* func(){ console.log("one"); yield '1'; console.log("two"); yield '2'; console.log("three"); return '3'; }

Ausführungsmechanismus

Das Aufrufen einer Generator-Funktion ist dasselbe wie das Aufrufen einer regulären Funktion: Fügen Sie einfach Klammern nach dem Funktionsnamen hinzu. Eine Generator-Funktion wird jedoch nicht sofort wie eine reguläre Funktion ausgeführt; stattdessen gibt sie einen Zeiger auf ein internes Zustandsobjekt zurück. Um die `next`-Methode des Iterator-Objekts aufzurufen, beginnt der Zeiger daher mit der Ausführung am Anfang der Funktion oder an der Stelle, an der er zuletzt angehalten wurde.

f.next(); // one // {value: "1", done: false} f.next(); // two // {value: "2", done: false} f.next(); // three // {value: "3", done: true} f.next(); // {value: undefined, done: true}

Beim ersten Aufruf der `next`-Methode beginnt die Ausführung am Anfang der Generator-Funktion. Zuerst wird `one` ausgegeben, dann wird beim Erreichen von `yield` angehalten und der Wert des Ausdrucks nach `yield`, `'1'`, als `value`-Eigenschaft des zurückgegebenen Objekts verwendet. Zu diesem Zeitpunkt ist die Funktion noch nicht vollständig ausgeführt, daher ist die `done`-Eigenschaft des zurückgegebenen Objekts `false`.

Beim zweiten Aufruf der `next`-Methode ist es dasselbe wie im vorherigen Schritt.

Beim dritten Aufruf der `next`-Methode wird zuerst `three` ausgegeben, dann wird die return-Operation der Funktion ausgeführt und der Wert des Ausdrucks nach `return` als `value`-Eigenschaft des zurückgegebenen Objekts verwendet. Zu diesem Zeitpunkt ist die Funktion beendet, daher ist der Wert der `done`-Eigenschaft `true`.

Beim vierten Aufruf der `next`-Methode wurde die Funktion bereits vollständig ausgeführt, daher gibt sie `undefined` als Wert der `value`-Eigenschaft und `true` als Wert der `done`-Eigenschaft zurück. Wenn es im dritten Schritt keine `return`-Anweisung gegeben hätte, würde sie direkt `{value: undefined, done: true}` zurückgeben.

Methoden des von der Funktion zurückgegebenen Iterator-Objekts

`next`-Methode

Im Allgemeinen ist der Rückgabewert des `yield`-Ausdrucks `undefined`, wenn die `next`-Methode ohne Argumente aufgerufen wird. Wenn `next` ein Argument übergeben wird, dient dieses Argument als Rückgabewert des vorherigen `yield`.

function* sendParameter(){ console.log("start"); var x = yield '2'; console.log("one:" + x); var y = yield '3'; console.log("two:" + y); console.log("total:" + (x + y)); }

Aufruf von `next` ohne Argumente

var sendp1 = sendParameter(); sendp1.next(); // start // {value: "2", done: false} sendp1.next(); // one:undefined // {value: "3", done: false} sendp1.next(); // two:undefined // total:NaN // {value: undefined, done: true} nextArgumente übergebenvar sendp2 = sendParameter(); sendp2.next(10); // start // {value: "2", done: false} sendp2.next(20); // one:20 // {value: "3", done: false} sendp2.next(30); // two:30 // total:50 // {value: undefined, done: true}

Zusätzlich zur Verwendung von `next` können Sie auch eine `for...of`-Schleife verwenden, um über das von einer Generatorfunktion erzeugte Iterator-Objekt zu iterieren.

`return`-Methode

Die `return`-Methode gibt den angegebenen Wert zurück und beendet die Iteration der Generatorfunktion.

Wenn der `return`-Methode ein Argument übergeben wird, gibt sie dieses Argument zurück; wenn kein Argument übergeben wird, gibt sie `undefined` zurück.

function* foo(){ yield 1; yield 2; yield 3; } var f = foo(); f.next(); // {value: 1, done: false} f.return("foo"); // {value: "foo", done: true} f.next(); // {value: undefined, done: true} throwMethodthrowDie Methode kannGeneratoreine Ausnahme außerhalb des Funktionskörpers auslösen und sie innerhalb des Funktionskörpers abfangen.var g = function* () { try { yield; } catch (e) { console.log('catch inner', e); } }; var i = g(); i.next(); try { i.throw('a'); i.throw('b'); } catch (e) { console.log('catch outside', e); } // catch inner a // catch outside b

Das Iterator-Objekt wirft zwei Fehler. Der erste wird innerhalb der Generator-Funktion abgefangen. Der zweite, weil das `catch` innerhalb des Funktionskörpers bereits ausgeführt wurde, wird nicht erneut abgefangen, daher wird dieser Fehler aus dem Generator-Funktionskörper herausgeworfen und vom `catch` außerhalb des Funktionskörpers abgefangen.

`yield*`-Ausdruck

Der `yield*`-Ausdruck bedeutet, dass `yield` ein Iterator-Objekt zurückgibt, das verwendet wird, um eine andere Generator-Funktion innerhalb einer Generator-Funktion aufzurufen.

function* callee() { console.log('callee: ' + (yield)); } function* caller() { while (true) { yield* callee(); } } const callerObj = caller(); callerObj.next(); // {value: undefined, done: false} callerObj.next("a"); // callee: a // {value: undefined, done: false} callerObj.next("b"); // callee: b // {value: undefined, done: false} //Äquivalent zu function* caller() { while (true) { for (var value of callee) { yield value; } } }

Anwendungsfälle

Iterator implementieren

Bietet eine Traversierungsmethode für Objekte, die keine Iterator-Schnittstelle haben.

function* objectEntries(obj) { const propKeys = Reflect.ownKeys(obj); for (const propKey of propKeys) { yield [propKey, obj[propKey]]; } } const jane = { first: 'Jane', last: 'Doe' }; for (const [key,value] of objectEntries(jane)) { console.log(`${Schlüssel}: ${Wert}`); } // first: Jane // last: Doe

`Reflect.ownKeys()` gibt alle Eigenschaften eines Objekts zurück, unabhängig davon, ob die Eigenschaften aufzählbar sind, einschließlich Symbols.

`jane` besitzt nativ keine Iterator-Schnittstelle und kann nicht mit `for...of` durchlaufen werden. Hier wird eine Generator-Funktion verwendet, um eine Iterator-Schnittstelle hinzuzufügen, sodass das `jane`-Objekt durchlaufen werden kann.