2.1 Syntax von Generatoren
Generatoren in JavaScript sind spezielle Funktionen, die die Ausführung des Codes steuern. Sie können ihre Ausführung pausieren und später fortsetzen, was sie zu einem leistungsstarken Tool für den Umgang mit asynchronem Code, Iteratoren und anderen komplexen Aufgaben macht.
Generatoren werden mit der Funktion function* (beachte den Stern) definiert.
Innerhalb des Generators wird der Operator yield genutzt, um die Ausführung zu pausieren und einen Wert zurückzugeben.
Generator-Deklaration:
function* generatorFunction() {
yield 1;
yield 2;
yield 3;
}
Erstellen eines Generator-Objekts
Der Aufruf eines Generators führt seinen Körper nicht sofort aus. Stattdessen gibt er ein Generator-Objekt zurück, das zur Iteration über die Werte verwendet werden kann:
const gen = generatorFunction();
2.2 Verwendung von Generatoren
Die Methode next()
Die Methode next() wird benutzt, um die Ausführung des Generators bis zum nächsten yield-Operator fortzusetzen.
Sie gibt ein Objekt mit zwei Eigenschaften zurück:
value: der Wert, der vomyield-Operator übergeben wurdedone: ein boolescher Wert, der angibt, ob der Generator abgeschlossen ist (true) oder nicht (false)
Beispiel für die Verwendung der Methode next():
function* generatorFunction() {
yield 1;
yield 2;
yield 3;
}
const gen = generatorFunction();
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 }
Iteration über einen Generator
Generatoren können mit der Schleife for...of zur Iteration über die Werte genutzt werden.
Beispiel für die Iteration über einen Generator:
function* generatorFunction() {
yield 1;
yield 2;
yield 3;
}
const gen = generatorFunction();
for (const value of gen) {
console.log(value);
}
// Gibt aus: 1
// Gibt aus: 2
// Gibt aus: 3
Beispiel für die Rückgabe von Werten
Generatoren können Werte mit dem Operator return zurückgeben:
function* generatorFunction() {
yield 1;
yield 2;
return 3;
yield 4; // Dieses yield wird nie ausgeführt
}
const gen = generatorFunction();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: true }
console.log(gen.next()); // { value: undefined, done: true }
2.3 Komplexe Nutzung von Generatoren
Interaktion mit einem Generator
Die Methode next() kann ein Argument annehmen, das an den Generator übergeben und innerhalb von diesem verwendet werden kann.
Beispiel zur Übergabe von Werten an einen Generator:
function* generatorFunction() {
const value1 = yield 1;
const value2 = yield value1 + 2;
yield value2 + 3;
}
const gen = generatorFunction();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next(10)); // { value: 12, done: false }
console.log(gen.next(20)); // { value: 23, done: false }
console.log(gen.next()); // { value: undefined, done: true }
Fehlerbehandlung
Generatoren ermöglichen das Behandeln von Fehlern mit einem try...catch-Block.
Beispiel für Fehlerbehandlung:
function* generatorFunction() {
try {
yield 1;
yield 2;
} catch (error) {
console.log('Fehler abgefangen:', error);
}
}
const gen = generatorFunction();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.throw(new Error('Etwas ist schief gelaufen'))); // Fehler abgefangen: Error: Etwas ist schief gelaufen
// { value: undefined, done: true }
Beispiel für einen Generator zur Erstellung einer unendlichen Sequenz
Generatoren können verwendet werden, um unendliche Sequenzen von Werten zu erzeugen:
function* infiniteSequence() {
let i = 0;
while (true) {
yield i++;
}
}
const gen = infiniteSequence();
console.log(gen.next().value); // 0
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
// und so weiter
2.4 Praktische Verwendungsbeispiele
Beispiel 1: Generator zur Iteration über ein Objekt
function* objectEntries(obj) {
const keys = Object.keys(obj);
for (const key of keys) {
yield [key, obj[key]];
}
}
const obj = { a: 1, b: 2, c: 3 };
const gen = objectEntries(obj);
for (const [key, value] of gen) {
console.log(`${key}: ${value}`);
}
// Gibt aus:
// a: 1
// b: 2
// c: 3
Beispiel 2: Generator zur Umsetzung eines einfachen Iterators
const myIterable = {
*[Symbol.iterator]() {
yield 1;
yield 2;
yield 3;
}
};
for (const value of myIterable) {
console.log(value);
}
// Gibt aus: 1
// Gibt aus: 2
// Gibt aus: 3
Generatoren in JavaScript sind ein leistungsstarkes Werkzeug zur Steuerung der Codeausführung, zum Erstellen von Iteratoren und zur Arbeit mit asynchronen Operationen. Das Verständnis der Syntax und der Nutzung von Generatoren hilft dabei, flexibleren und lesbareren Code zu schreiben, insbesondere beim Umgang mit Datenfolgen und asynchronen Aufgaben.
GO TO FULL VERSION