function*
Baseline
Weitgehend verfügbar
Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit September 2016 browserübergreifend verfügbar.
Die function*-Deklaration erstellt eine Bindung einer neuen Generatorfunktion an einen angegebenen Namen. Eine Generatorfunktion kann verlassen und später wieder aufgenommen werden. Dabei bleibt ihr Kontext (die Bindungen ihrer Variablen) zwischen den Aufrufen erhalten.
Sie können Generatorfunktionen auch mit dem function*-Ausdruck definieren.
Probieren Sie es aus
function* generator(i) {
yield i;
yield i + 10;
}
const gen = generator(10);
console.log(gen.next().value);
// Expected output: 10
console.log(gen.next().value);
// Expected output: 20
Syntax
function* name(param0) {
statements
}
function* name(param0, param1) {
statements
}
function* name(param0, param1, /* …, */ paramN) {
statements
}
Hinweis: Für Generatorfunktionen gibt es keine Entsprechung als Arrow Function.
Hinweis:
function und * sind separate Tokens und können daher durch Leerzeichen oder Zeilenumbrüche getrennt werden.
Parameter
name-
Der Name der Funktion.
paramOptional-
Der Name eines formalen Parameters der Funktion. Informationen zur Syntax von Parametern finden Sie in der Referenz zu Funktionen.
statementsOptional-
Die Anweisungen, aus denen der Funktionskörper besteht.
Beschreibung
Eine function*-Deklaration erstellt ein GeneratorFunction-Objekt. Bei jedem Aufruf einer Generatorfunktion gibt sie ein neues Generator-Objekt zurück, das dem Iterator-Protokoll entspricht. Die Ausführung der Generatorfunktion ist an einer bestimmten Stelle angehalten, zunächst ganz am Anfang des Funktionskörpers. Die Generatorfunktion kann mehrfach aufgerufen werden, um mehrere Generatoren gleichzeitig zu erstellen. Jeder Generator verwaltet seinen eigenen Ausführungskontext der Generatorfunktion und kann unabhängig von den anderen fortgesetzt werden.
Der Generator ermöglicht einen bidirektionalen Kontrollfluss: Die Kontrolle kann beliebig oft zwischen der Generatorfunktion (dem Aufgerufenen) und ihrem Aufrufer wechseln. Vom Aufrufer zur Generatorfunktion wechselt sie durch Aufrufe der Generatormethoden next(), throw() und return(). Von der Generatorfunktion zum Aufrufer wechselt sie, wenn die Funktion durch return oder throw beendet wird, alle Anweisungen ausgeführt wurden oder yield- und yield*-Ausdrücke verwendet werden.
Wenn die Methode next() des Generators aufgerufen wird, wird der Körper der Generatorfunktion bis zu einem der folgenden Punkte ausgeführt:
- Ein
yield-Ausdruck. In diesem Fall gibt die Methodenext()ein Objekt zurück, dessen Eigenschaftvalueden mityieldgelieferten Wert enthält und dessen Eigenschaftdoneimmerfalseist. Beim nächsten Aufruf vonnext()wird deryield-Ausdruck zu dem annext()übergebenen Wert ausgewertet. - Ein
yield*-Ausdruck, der an einen anderen Iterator delegiert. In diesem Fall entspricht dieser Aufruf – ebenso wie alle weiteren Aufrufe vonnext()am Generator – einem Aufruf vonnext()am Iterator, an den delegiert wurde, bis dieser beendet ist. - Eine
return-Anweisung (die nicht durchtry...catch...finallyabgefangen wird) oder das Ende des Kontrollflusses, das implizitreturn undefinedbedeutet. In diesem Fall ist der Generator beendet, und die Methodenext()gibt ein Objekt zurück, dessen Eigenschaftvalueden Rückgabewert enthält und dessen Eigenschaftdoneimmertrueist. Weitere Aufrufe vonnext()haben keine Wirkung und geben immer{ value: undefined, done: true }zurück. - Ein Fehler, der innerhalb der Funktion ausgelöst wird, entweder durch eine
throw-Anweisung oder durch eine nicht behandelte Ausnahme. Die Methodenext()löst diesen Fehler aus, und der Generator ist beendet. Weitere Aufrufe vonnext()haben keine Wirkung und geben immer{ value: undefined, done: true }zurück.
Wenn die Methode throw() des Generators aufgerufen wird, verhält sich dies so, als würde an der aktuellen Unterbrechungsstelle eine throw-Anweisung in den Generatorkörper eingefügt. Entsprechend verhält sich ein Aufruf der Methode return() so, als würde dort eine return-Anweisung eingefügt. Beide Methoden beenden den Generator normalerweise, sofern die Generatorfunktion den Abschluss nicht durch try...catch...finally abfängt.
Generatoren waren früher ein Paradigma für die asynchrone Programmierung: Durch Inversion of Control ließ sich Callback Hell vermeiden. Heute wird dieser Anwendungsfall durch das einfachere Modell der async-Funktionen und das Promise-Objekt abgedeckt. Generatoren sind jedoch weiterhin für viele andere Aufgaben nützlich, etwa um Iteratoren auf einfache Weise zu definieren.
function*-Deklarationen verhalten sich ähnlich wie function-Deklarationen: Sie werden an den Anfang ihres Gültigkeitsbereichs verschoben und können überall innerhalb dieses Gültigkeitsbereichs aufgerufen werden. Außerdem können sie nur in bestimmten Kontexten erneut deklariert werden.
Beispiele
>Einfaches Beispiel
function* idMaker() {
let index = 0;
while (true) {
yield index++;
}
}
const gen = idMaker();
console.log(gen.next().value); // 0
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // 3
// …
Beispiel mit yield*
function* anotherGenerator(i) {
yield i + 1;
yield i + 2;
yield i + 3;
}
function* generator(i) {
yield i;
yield* anotherGenerator(i);
yield i + 10;
}
const gen = generator(10);
console.log(gen.next().value); // 10
console.log(gen.next().value); // 11
console.log(gen.next().value); // 12
console.log(gen.next().value); // 13
console.log(gen.next().value); // 20
Argumente an Generatoren übergeben
function* logGenerator() {
console.log(0);
console.log(1, yield);
console.log(2, yield);
console.log(3, yield);
}
const gen = logGenerator();
// the first call of next executes from the start of the function
// until the first yield statement
gen.next(); // 0
gen.next("pretzel"); // 1 pretzel
gen.next("california"); // 2 california
gen.next("mayonnaise"); // 3 mayonnaise
Return-Anweisung in einem Generator
function* yieldAndReturn() {
yield "Y";
return "R";
yield "unreachable";
}
const gen = yieldAndReturn();
console.log(gen.next()); // { value: "Y", done: false }
console.log(gen.next()); // { value: "R", done: true }
console.log(gen.next()); // { value: undefined, done: true }
Generator als Objekteigenschaft
const someObj = {
*generator() {
yield "a";
yield "b";
},
};
const gen = someObj.generator();
console.log(gen.next()); // { value: 'a', done: false }
console.log(gen.next()); // { value: 'b', done: false }
console.log(gen.next()); // { value: undefined, done: true }
Generator als Objektmethode
class Foo {
*generator() {
yield 1;
yield 2;
yield 3;
}
}
const f = new Foo();
const gen = f.generator();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: false }
console.log(gen.next()); // { value: undefined, done: true }
Generator als berechnete Eigenschaft
class Foo {
*[Symbol.iterator]() {
yield 1;
yield 2;
}
}
const SomeObj = {
*[Symbol.iterator]() {
yield "a";
yield "b";
},
};
console.log(Array.from(new Foo())); // [ 1, 2 ]
console.log(Array.from(SomeObj)); // [ 'a', 'b' ]
Generatoren können nicht mit new aufgerufen werden
function* f() {}
const obj = new f(); // throws TypeError: f is not a constructor
Generatorbeispiel
function* powers(n) {
// Endless loop to generate
for (let current = n; ; current *= n) {
yield current;
}
}
for (const power of powers(2)) {
// Controlling generator
if (power > 32) {
break;
}
console.log(power);
// 2
// 4
// 8
// 16
// 32
}
Spezifikationen
| Spezifikation |
|---|
| ECMAScript® 2027 Language Specification> # sec-generator-function-definitions> |
Browser-Kompatibilität
Siehe auch
- Funktionen – Leitfaden
- Iteratoren und Generatoren – Leitfaden
- Funktionen
GeneratorFunctionfunction*-Ausdruckfunctionasync functionasync function*- Iterationsprotokolle
yieldyield*Generator- Promises and Generators: control flow utopia – Vortrag von Forbes Lindesay auf der JSConf (2013)
- Task.js auf GitHub
- You Don't Know JS: Async & Performance, Ch.4: Generators von Kyle Simpson