function*

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
}

Parameter

name

Der Funktionsname.

param Optional

Der Name eines formalen Parameters der Funktion. Fr die Syntax der Parameter siehe die Funktionen Referenz.

statements Optional

Die Anweisungen, die den Krper der Funktion bilden.

Beschreibung

Eine function*-Deklaration erstellt ein GeneratorFunction-Objekt. Jedes Mal, wenn eine Generatorfunktion aufgerufen wird, gibt sie ein neues Generator-Objekt zurck, das dem Iterator-Protokoll entspricht. Die Ausfhrung der Generatorfunktion wird bei einem bestimmten Punkt suspendiert, der anfangs am Beginn des Funktionskrpers liegt. Die Generatorfunktion kann mehrfach aufgerufen werden, um mehrere Generatoren gleichzeitig zu erzeugen; jeder Generator behlt seinen eigenen Ausfhrungskontext der Generatorfunktion und kann unabhngig betreten werden.

Der Generator erlaubt eine bidirektionale Steuerung des Programmflusses: Der Steuerfluss kann beliebig oft zwischen der Generatorfunktion (Callee) und ihrem Aufrufer bertragen werden, solange beide Parteien dies wnschen. Der Steuerfluss kann vom Aufrufer zum Callee ber die Methoden des Generators bertragen werden: next(), throw() und return(). Der Steuerfluss kann vom Callee zum Aufrufer bertragen werden, indem die Funktion normal beendet wird, entweder durch return, throw, durch Abarbeitung aller Anweisungen, oder durch Nutzung der Ausdrcke yield und yield*.

Wenn die Methode next() des Generators aufgerufen wird, wird der Krper der Generatorfunktion ausgefhrt bis zu einem der folgenden Flle:

• Ein yield-Ausdruck. In diesem Fall gibt die next()-Methode ein Objekt mit einer value-Eigenschaft, die den ausgegebenen Wert enthlt, und einer done-Eigenschaft, die immer false ist, zurck. Beim nchsten Aufruf von next() ergibt der yield-Ausdruck den Wert, der an next() bergeben wurde.
• Ein yield*, der die Kontrolle an einen anderen Iterator delegiert. In diesem Fall ist dieser Aufruf sowie alle zuknftigen next()-Aufrufe auf den Generator identisch mit Aufrufen von next() auf den delegierten Iterator, bis der delegierte Iterator fertig ist.
• Eine return-Anweisung (die nicht von einem try...catch...finally abgefangen wird), oder das Ende des Steuerflusses, was implizit return undefined bedeutet. In diesem Fall ist der Generator abgeschlossen, und die next()-Methode gibt ein Objekt mit einer value-Eigenschaft, die den zurckgegebenen Wert enthlt, und einer done-Eigenschaft, die immer true ist, zurck. Weitere next()-Aufrufe haben keinen Effekt und geben stets { value: undefined, done: true } zurck.
• Ein Fehler, der innerhalb der Funktion geworfen wird, entweder durch eine throw-Anweisung oder eine unbehandelte Ausnahme. Die next()-Methode wirft diesen Fehler und der Generator ist abgeschlossen. Weitere next()-Aufrufe haben keinen Effekt und geben immer { value: undefined, done: true } zurck.

Wenn die Methode throw() des Generators aufgerufen wird, wirkt es so, als ob eine throw-Anweisung an der aktuellen suspendierten Position in den Krper des Generators eingefgt wird. Similarly, when the generator's return() method is called, it acts as if a return statement is inserted in the generator's body at the current suspended position. Beide Methoden beenden in der Regel den Generator, es sei denn, die Generatorfunktion fngt den Abschluss ber try...catch...finally ab.

Generatoren wurden frher als Paradigma fr asynchrone Programmierung verwendet, um Callback Hell zu vermeiden, indem Inversion of Control erreicht wurde. Heute wird dieser Anwendungsfall durch das einfachere async functions-Modell und das Promise-Objekt gelst. Dennoch sind Generatoren weiterhin fr viele andere Aufgaben ntzlich, wie etwa das Definieren von Iteratoren auf eine unkomplizierte Weise.

function*-Deklarationen verhalten sich hnlich wie function-Deklarationen sie werden gehoistet an den Anfang ihres Geltungsbereichs und knnen berall in ihrem Geltungsbereich aufgerufen werden, und sie knnen nur in bestimmten Kontexten neu 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

bergabe von Argumenten an Generatoren

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

Rckgabeanweisung 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 Objekt-Eigenschaft

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 Objekt-Methode

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 sind nicht konstruierbar

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

Browser-Kompatibilitt

Siehe auch

• Leitfaden zu Funktionen
• Leitfaden zu Iteratoren und Generatoren
• Funktionen
• GeneratorFunction
• function* Ausdruck
• function
• async function
• async function*
• Iterationsprotokolle
• yield
• yield*
• Generator
• Regenerator auf GitHub
• Promises and Generators: control flow utopia Vortrag von Forbes Lindesay bei JSConf (2013)
• Task.js auf GitHub
• You Don't Know JS: Async & Performance, Ch.4: Generators von Kyle Simpson