JavaScript Generators: Große Datenmengen schrittweise verarbeiten

Von function* und yield über Lazy Evaluation bis zu asynchronen Generatoren und den Iterator-Helfern aus ES2025
Aktualisiert:
Abstract
- #JavaScript
- #Generators
- #Performance
- #Entwicklung
- #Web Development
- #Iteratoren
- #Lazy Evaluation
- #async/await
Warum eine Funktion, die mittendrin anhalten kann, bei großen Datenmengen vor allem Speicher spart
Angenommen, ein Node.js-Skript soll jede Nacht den Umsatzexport eines Webshops auswerten: eine CSV-Datei mit einigen Millionen Zeilen. Die naheliegende Lösung liest die Datei komplett ein, zerlegt sie in ein Array und rechnet dann. Das funktioniert, bis die Datei größer wird als der Arbeitsspeicher, den der Prozess bekommt. Dann bricht das Skript ab, oft mitten in der Nacht.
Die Alternative ist, die Daten wie auf einem Fließband zu behandeln: eine Zeile lesen, verarbeiten, vergessen, die nächste holen. Genau dafür hat JavaScript Generatoren, Funktionen, die mittendrin anhalten und später an derselben Stelle weitermachen. Sie gehören seit ECMAScript 2015 zur Sprache, werden aber im Alltag selten genutzt. Mit den Iterator-Helfern aus ECMAScript 2025 sind sie deutlich bequemer geworden. Dieser Beitrag erklärt die Mechanik, zeigt typische Einsatzfälle und sagt auch, wo Generatoren nichts bringen.
Was eine Generatorfunktion anders macht
Eine normale Funktion läuft von oben nach unten durch und gibt einmal etwas zurück. Eine Generatorfunktion, erkennbar am Stern in function*, liefert beim Aufruf zunächst gar kein Ergebnis. Sie gibt ein Generatorobjekt zurück, und ihr Rumpf hat noch keine einzige Zeile ausgeführt. Erst der Aufruf von next() startet den Code, und zwar bis zum nächsten yield. Dort hält die Funktion an, reicht den Wert nach außen und wartet.
function* zaehler() {
console.log('Start');
yield 1;
console.log('nach dem ersten yield');
yield 2;
return 'fertig';
}
const it = zaehler(); // noch keine Ausgabe
console.log(it.next()); // "Start", dann { value: 1, done: false }
console.log(it.next()); // "nach dem ersten yield", dann { value: 2, done: false }
console.log(it.next()); // { value: 'fertig', done: true }
console.log(it.next()); // { value: undefined, done: true }
Jeder Aufruf von next() liefert ein kleines Objekt mit zwei Feldern: value enthält den Wert, done sagt, ob die Funktion zu Ende ist. Lokale Variablen bleiben zwischen den Aufrufen erhalten, weil der Generator seinen Zustand behält. Ein beendeter Generator lässt sich nicht neu starten. Wer die Folge noch einmal braucht, ruft die Generatorfunktion erneut auf und bekommt ein frisches Objekt.
Das Iterator-Protokoll als gemeinsame Sprache
Dass Generatoren so gut in die Sprache passen, liegt am Iterator-Protokoll. Ein Iterator ist jedes Objekt mit einer next()-Methode, die solche value/done-Objekte liefert. Iterierbar ist ein Objekt, das auf Nachfrage einen Iterator herausgibt. Arrays, Strings, Map und Set sind iterierbar, und Generatorobjekte sind beides zugleich.
Deshalb funktionieren Generatoren überall, wo JavaScript eine Folge von Werten erwartet: in for...of-Schleifen, beim Spread-Operator [...gen], bei der Destrukturierung oder in Array.from(). Mit yield* reicht ein Generator alle Werte eines anderen iterierbaren Objekts weiter, etwa eines Arrays oder eines zweiten Generators. Wie for...of sich von den klassischen Schleifen unterscheidet, zeigt der Beitrag zum Vergleich der Schleifen in JavaScript.
Lazy Evaluation: Werte erst berechnen, wenn jemand fragt
Das zentrale Prinzip heißt Lazy Evaluation, auf Deutsch etwa „verzögerte Auswertung“. Ein Generator berechnet einen Wert erst, wenn er angefordert wird. Das erlaubt sogar unendliche Folgen, denn es wird nie mehr erzeugt, als der Aufrufer abholt:
function* rechnungsnummern(start = 1) {
let n = start;
while (true) {
yield `RE-2026-${String(n).padStart(5, '0')}`;
n += 1;
}
}
const nummern = rechnungsnummern(42);
console.log(nummern.next().value); // RE-2026-00042
console.log(nummern.next().value); // RE-2026-00043
Die Endlosschleife ist hier kein Fehler. Sie läuft immer nur bis zum nächsten yield und wartet dann, bis jemand die nächste Nummer braucht.
Seine Stärke spielt das Prinzip bei Verarbeitungsketten aus. Angenommen, aus einem Strom von Bestellungen sollen die ersten drei mit einem Betrag über 400 Euro herausgesucht werden. Mit Array-Methoden wie filter() und map() entsteht bei jedem Schritt ein vollständiges Zwischenarray. Generatoren reichen dagegen jeden Datensatz einzeln durch die ganze Kette und hören auf, sobald das Ergebnis feststeht:
function* filtern(quelle, bedingung) {
for (const wert of quelle) {
if (bedingung(wert)) yield wert;
}
}
function* abbilden(quelle, umwandeln) {
for (const wert of quelle) yield umwandeln(wert);
}
function* nehmen(quelle, anzahl) {
if (anzahl <= 0) return;
for (const wert of quelle) {
yield wert;
if (--anzahl === 0) return;
}
}
// Beispieldaten: ein endloser Strom von Bestellungen
function* bestellungen() {
let id = 1;
while (true) {
yield { id, betrag: (id * 37) % 500 };
id += 1;
}
}
const grosse = nehmen(
abbilden(
filtern(bestellungen(), (b) => b.betrag > 400),
(b) => `#${b.id}: ${b.betrag} Euro`,
),
3,
);
console.log([...grosse]);
// [ '#11: 407 Euro', '#12: 444 Euro', '#13: 481 Euro' ]
Obwohl die Quelle unendlich ist, erzeugt das Programm genau 13 Bestellungen und hält dann an. Im Speicher liegt zu jedem Zeitpunkt nur ein einziger Datensatz. Mit Arrays wäre dieselbe Aufgabe gar nicht lösbar, weil die Quelle nie vollständig vorläge.
Iterator-Helfer seit ECMAScript 2025
Die verschachtelten Aufrufe im letzten Beispiel lesen sich von innen nach außen und sind entsprechend mühsam. Seit ECMAScript 2025 gibt es dafür eingebaute Methoden direkt am Iterator: map(), filter(), take(), drop(), flatMap(), reduce(), toArray(), forEach(), some(), every() und find(). Sie arbeiten ebenfalls verzögert. Dieselbe Kette sieht damit so aus:
const ergebnis = bestellungen()
.filter((b) => b.betrag > 400)
.map((b) => `#${b.id}: ${b.betrag} Euro`)
.take(3)
.toArray();
console.log(ergebnis);
// [ '#11: 407 Euro', '#12: 444 Euro', '#13: 481 Euro' ]
Das liest sich wie eine Array-Kette, verhält sich aber anders: filter() und map() laufen erst los, wenn toArray() am Ende Werte anfordert, und take(3) beendet die Kette nach drei Treffern. Mit Iterator.from() lassen sich auch andere iterierbare Objekte in einen Iterator mit diesen Methoden verwandeln:
const summe = Iterator.from([5, 10, 15])
.map((x) => x * 2)
.reduce((a, b) => a + b, 0);
console.log(summe); // 60
Die Iterator-Helfer stecken in aktuellen Versionen von Chrome, Edge, Firefox und Safari sowie in Node.js ab Version 22. Wer ältere Browser unterstützen muss, braucht ein Polyfill, etwa aus core-js, oder bleibt bei eigenen Generatorfunktionen wie oben. Für asynchrone Iteratoren gibt es solche Helfer noch nicht im Standard, ein entsprechender Vorschlag ist in Arbeit. Einen Überblick über weitere neue Sprachfunktionen gibt der Beitrag zu den JavaScript-Neuerungen 2025.
Asynchrone Generatoren und for await
Daten kommen selten fertig aus dem Speicher. Meist stammen sie aus einer Datei, einer Datenbank oder einer API, und jedes Stück muss erst abgewartet werden. Dafür gibt es seit ECMAScript 2018 asynchrone Generatoren, geschrieben als async function*. In ihnen darf await stehen, und verbraucht werden sie mit der Schleife for await...of. Wie await grundsätzlich funktioniert, erklärt der Beitrag zu Promises und async/await.
Beispiel: Eine paginierte API Seite für Seite lesen
Viele Schnittstellen liefern große Ergebnismengen in Seiten aus, etwa 100 Kunden pro Abruf und einen Verweis auf die nächste Seite. Ein asynchroner Generator versteckt dieses Blättern vor dem aufrufenden Code:
async function* alleKunden(startUrl) {
let url = startUrl;
while (url) {
const antwort = await fetch(url);
if (!antwort.ok) {
throw new Error(`HTTP ${antwort.status} bei ${url}`);
}
const { items, next } = await antwort.json();
yield* items; // jeden Kunden einzeln weiterreichen
url = next; // null, wenn es keine weitere Seite gibt
}
}
for await (const kunde of alleKunden('https://api.example.com/kunden?page=1')) {
if (kunde.id === 120) {
console.log('Gefunden:', kunde);
break; // weitere Seiten werden nicht mehr geladen
}
}
Die Schleife sieht aus, als liefe sie über ein gewöhnliches Array. Tatsächlich lädt der Generator die zweite Seite erst, wenn die erste abgearbeitet ist, und nach dem break gar keine mehr. Das spart Anfragen und schont die API. Die Adresse und das Antwortformat mit items und next sind dabei nur ein Beispiel, echte Schnittstellen benennen die Felder unterschiedlich.
Beispiel: Eine große CSV-Datei zeilenweise auswerten
Zurück zum nächtlichen Umsatzexport. In Node.js sind lesbare Streams asynchron iterierbar, und das Modul readline zerlegt einen Stream in Zeilen. Zusammen mit einem asynchronen Generator entsteht eine Auswertung, deren Speicherbedarf nicht mit der Dateigröße wächst:
import { createReadStream } from 'node:fs';
import { createInterface } from 'node:readline';
async function* csvZeilen(pfad) {
const zeilen = createInterface({
input: createReadStream(pfad, { encoding: 'utf8' }),
crlfDelay: Infinity,
});
let kopf;
for await (const zeile of zeilen) {
if (!zeile.trim()) continue;
const felder = zeile.split(';');
if (!kopf) {
kopf = felder;
continue;
}
yield Object.fromEntries(kopf.map((name, i) => [name, felder[i]]));
}
}
let umsatz = 0;
for await (const zeile of csvZeilen('umsaetze.csv')) {
umsatz += Number(zeile.betrag);
}
console.log(`Umsatz gesamt: ${umsatz.toFixed(2)} Euro`);
Das einfache split(';') genügt für Exporte ohne Trennzeichen in den Feldern. Enthalten Felder Anführungszeichen oder Semikolons, gehört ein richtiger CSV-Parser in die Kette, der Generator-Ansatz bleibt derselbe.
Aufräumen und Fehler behandeln
Wenn eine for...of-Schleife mit break endet oder eine Ausnahme wirft, ruft JavaScript automatisch die Methode return() des Generators auf. Ein finally-Block im Generator läuft dann trotzdem. Das ist der richtige Ort, um Dateien, Verbindungen oder Cursor einer Datenbank zu schließen:
function* zeilenAusDatei() {
console.log('Datei geöffnet');
try {
yield 'Zeile 1';
yield 'Zeile 2';
yield 'Zeile 3';
} finally {
console.log('Datei geschlossen');
}
}
for (const zeile of zeilenAusDatei()) {
console.log(zeile);
if (zeile === 'Zeile 2') break;
}
// Datei geöffnet, Zeile 1, Zeile 2, Datei geschlossen
Fehler aus dem Inneren eines Generators kommen beim Aufrufer an der Stelle an, an der er next() aufruft, bei Schleifen also in der Schleife. Ein try/catch um die Schleife fängt sie ab. Umgekehrt kann der Aufrufer mit throw() einen Fehler in den Generator hineinwerfen, der dann am wartenden yield auftaucht. Das wird selten gebraucht. Ein Muster aus dem ursprünglichen Beitrag sollten Sie dagegen meiden: Fehler im Generator abzufangen und als gewöhnlichen Wert wie { error: true } weiterzureichen. Der Aufrufer muss dann jeden Wert prüfen, und vergisst er es, rechnet er mit einem Fehlerobjekt weiter. Ausnahmen bis zum Aufrufer durchzulassen, ist in den meisten Fällen klarer.
Was Generatoren bei der Performance bringen und was nicht
Hier lohnt ein nüchterner Blick. Generatoren machen Code nicht schneller im Sinne von mehr Rechenoperationen pro Sekunde. Jeder Wert läuft durch einen Aufruf von next() und ein neues Ergebnisobjekt. Ob und wie stark das gegenüber einer schlichten for-Schleife über ein Array, das ohnehin im Speicher liegt, ins Gewicht fällt, hängt von JavaScript-Engine, Datenmenge und Code ab und lässt sich nur messen, nicht pauschal angeben.
Der Gewinn liegt woanders:
- Speicher: Es liegt nur der gerade bearbeitete Datensatz im Speicher, nicht die ganze Menge und keine Zwischenarrays.
- Früher Abbruch: Ketten mit
take(),find()oderbreakhören auf, sobald das Ergebnis feststeht. Bei teuren Quellen wie API-Aufrufen ist das die größte Ersparnis. - Frühe Ergebnisse: Der erste Datensatz kann verarbeitet oder angezeigt werden, bevor der letzte geladen ist.
- Lesbarkeit: Blättern, Puffern und Aufräumen stecken an einer Stelle statt verstreut im aufrufenden Code.
Für Arrays mit einigen Hundert oder Tausend Einträgen, die ohnehin vollständig vorliegen, sind die gewohnten Array-Methoden meist die einfachere Wahl. Wie Sie Engpässe im Browser messen, statt sie zu vermuten, und welche Maßnahmen dort tatsächlich wirken, zeigt der Beitrag JavaScript-Performance optimieren: messen, verstehen, verbessern.
Wann sich Generatoren für Ihr Team lohnen
Unsere Einschätzung: Generatoren sind kein Werkzeug für jede Schleife, aber ein sehr gutes für drei wiederkehrende Aufgaben. Erstens Datenmengen, die nicht sicher in den Speicher passen, wie Exporte, Logdateien oder Datenbankabfragen mit Cursor. Zweitens Quellen, die Stück für Stück ankommen, wie paginierte APIs oder Streams. Drittens Folgen, die theoretisch unendlich sind oder bei denen meist nur der Anfang gebraucht wird.
Mit den Iterator-Helfern ist die größte Hürde gefallen, die umständliche Schreibweise. Teams, die vor allem für aktuelle Browser und Node.js ab Version 22 entwickeln, können verzögerte Verarbeitungsketten heute ohne Bibliothek schreiben. Wichtig ist, die Eigenheiten zu kennen: Ein Generator lässt sich nur einmal durchlaufen, Fehler sollten als Ausnahmen weitergereicht werden, und Aufräumarbeiten gehören in finally. Wer Node.js-Dienste mit großen Datenströmen plant oder ein Team in modernem JavaScript und TypeScript schulen möchte, findet dazu unser Angebot zu TypeScript und Node.js: Beratung, Coaching und Seminare.
Häufige Fragen zu JavaScript Generators
Wie verhalten sich Generatoren zu async/await?
Sie lösen verschiedene Aufgaben. async/await wartet auf einen einzelnen Wert, der später kommt. Ein Generator liefert viele Werte nacheinander. Asynchrone Generatoren verbinden beides: viele Werte, die jeweils abgewartet werden. Bevor es async/await gab, haben Bibliotheken Generatoren genutzt, um asynchronen Code linear zu schreiben. Dafür ist heute async/await die richtige Wahl.
Lässt sich ein Generator zweimal durchlaufen?
Nein. Ein Generatorobjekt ist nach dem ersten Durchlauf erschöpft, ein zweites for...of findet keine Werte mehr. Brauchen Sie die Folge mehrfach, rufen Sie die Generatorfunktion erneut auf oder sammeln die Werte mit toArray() einmalig in einem Array.
Funktionieren Generatoren auch in TypeScript?
Ja. TypeScript kennt die Typen Generator und AsyncGenerator und leitet sie aus Generatorfunktionen meist selbst ab. Für die Iterator-Helfer muss die Konfiguration die passenden Typbibliotheken einbinden, sonst meldet der Compiler die Methoden als unbekannt.
Sind die Iterator-Helfer dasselbe wie Array-Methoden?
Sie heißen ähnlich, arbeiten aber verzögert und ohne Zwischenarrays. Außerdem fehlen einige Array-Methoden, etwa sort() oder reverse(), die naturgemäß alle Werte kennen müssen. Dafür gibt es take() und drop(), die bei Arrays keine Entsprechung haben.
Kategorien
Schlagworte