From 4b1a9203c547c019fc5398082ae19a3f3d4c3efe Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:41:15 -0500 Subject: initial commit --- .../reference/statements/function_star_/index.html | 200 +++++++++++++++++++++ 1 file changed, 200 insertions(+) create mode 100644 files/de/web/javascript/reference/statements/function_star_/index.html (limited to 'files/de/web/javascript/reference/statements/function_star_') diff --git a/files/de/web/javascript/reference/statements/function_star_/index.html b/files/de/web/javascript/reference/statements/function_star_/index.html new file mode 100644 index 0000000000..a8b2982dce --- /dev/null +++ b/files/de/web/javascript/reference/statements/function_star_/index.html @@ -0,0 +1,200 @@ +--- +title: function* +slug: Web/JavaScript/Reference/Statements/function* +tags: + - ECMAScript 2015 + - Function + - Iterator + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/function* +--- +
{{jsSidebar("Statements")}}
+ +

Die function*-Deklaration ( Schlüsselwort function gefolgt von einem Stern) definiert eine Generatorfunktion, welche ein  {{jsxref("Global_Objects/Generator","Generator")}}-Objekt zurückgibt.

+ +
{{EmbedInteractiveExample("pages/js/statement-functionasterisk.html")}}
+ + + +
+

Eine Generatorfunktion kann auch mittels des {{jsxref("GeneratorFunction")}}-Konstruktors definiert werden.

+
+ +

Syntax

+ +
function* name([param[, param[, ... param]]]) {
+   statements
+}
+
+ +
+
name
+
Der Name der Funktion.
+
+ +
+
param
+
Der Name eines an die Funktion zu übergebenden Arguments. Eine Funktion kann bis zu 255 Argumente haben.
+
+ +
+
statements
+
Die den Körper der Funktion ergebenden Anweisungen.
+
+ +

Beschreibung

+ +

Generatoren sind Funktionen, die verlassen und später wieder betreten werden können. Ihr Kontext (Variablenbindung) bleibt über die Wiedereintritte hinweg erhalten.

+ +

Der Aufruf einer Generatorfunktion führt ihren Körper nicht sofort aus; stattdessen wird ein Iterator-Objekt einer Funktion zurückgegeben. Wenn die next()-Methode des Iterators aufgerufen wird, wird der Körper der Generatorfunktion bis zum ersten {{jsxref("Operators/yield", "yield")}}-Ausdruck ausgeführt, der den vom Iterator zurückzugebenden Wert spezifiziert oder mittels {{jsxref("Operators/yield*", "yield*")}} an eine andere Generatorfunktion weitergibt. Die Methode next() gibt ein Objekt mit einer value-Eigenschaft zurück, die den zurückgegebenen Wert enthält, und eine Eigenschaft done, die anzeigt, ob der Generator seinen letzten Wert zurückgegeben hat (boolescher Wert). Beim Aufrufen der next()-Methode mit einem Argument wird die Generatorfunktion weiter ausgeführt.

+ +

Ein return-Statement in einer Generatorfunktion sorgt dafür, dass der Generator fertig ist (Status done). Falls ein Wert zurückgegeben wird, dann wird dieser als value zurückgegeben. Anschließend wird kein weiterer Wert mehr zurückgegeben.

+ +

Beispiele

+ +

Einfaches Beispiel

+ +
function* idMaker(){
+  var index = 0;
+  while(index < index+1)
+    yield index++;
+}
+
+var 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;
+}
+
+var 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
+
+ +

Übergeben von Argumenten in Generatoren

+ +
function* logGenerator() {
+  console.log(0);
+  console.log(1, yield);
+  console.log(2, yield);
+  console.log(3, yield);
+}
+
+var 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 Statement in einem Generator

+ +
function* yieldAndReturn() {
+  yield "Y";
+  return "R";
+  yield "unreachable";
+}
+
+var 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 }
+
+ +

Generatoren haben keinen Konstruktor

+ +
function* f() {}
+var obj = new f; // throws "TypeError: f ist kein Konstruktor"
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#', 'function*')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ES2016', '#', 'function*')}}{{Spec2('ES2016')}}Änderung, dass Generatoren nicht über [[Construct]] trap verfügen und eine Ausnahme bei der Verwendung von new erzeugen.
{{SpecName('ESDraft', '#', 'function*')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.statements.generator_function")}}

+
+ +

Firefox-spezifische Hinweise

+ +

Generatoren und Iteratoren in Firefox-Versionen vor 26

+ +

Ältere Firefox-Versionen implementierten eine ältere Version des Generatorenentwurfs. In den älteren Versionen wurden Generatoren, neben anderen Abweichungen, mit dem normalen Schlüsselwort function (ohne den Stern) definiert. Siehe veraltete Generatorfunktion für weitere Informationen.

+ +

IteratorResult-Objekt zurückgegeben anstatt Ausnahme erzeugt

+ +

Beginnend mit Gecko 29 {{geckoRelease(29)}} erzeugt die ausgeführte Generatorfunktion keine {{jsxref("TypeError")}} "generator has already finished"-Ausnahme mehr. Stattdessen gibt sie ein IteratorResult-Objekt mit { value: undefined, done: true } ({{bug(958951)}}) zurück.

+ +

Siehe auch

+ + -- cgit v1.2.3-54-g00ecf