Iterator.zip() — Methode · JavaScript-Referenz

Signatur

Iterator.zip(iterables, options)

Beschreibung

Iterator.zip() ist eine statische Methode des globalen Iterator-Objekts. Sie nimmt eine Sammlung von Iterables oder Iteratoren entgegen und liefert einen neuen Iterator. Dieser gibt bei jedem Schritt ein Array zurück, das an Position i den aktuellen Wert des i-ten Eingabe-Iterators enthält. Solche „Zip“-Funktionen kennt man aus Python, Lodash oder Rust. Mit Iterator.zip() gibt es das nun direkt in der Sprache.

Die Methode arbeitet lazy, also erst bei Bedarf: Die Eingaben werden nur so weit gelesen, wie der Ergebnis-Iterator abgefragt wird. Deshalb funktioniert sie auch mit unendlichen Generatoren. Weil das Ergebnis ein echtes Iterator-Objekt ist, kannst du direkt Iterator-Helfer wie .map(), .filter(), .take() oder .toArray() anhängen.

Über die Option mode legst du fest, was passiert, wenn die Eingaben unterschiedlich lang sind:

"shortest" (Standard): Die Iteration endet, sobald die erste Eingabe erschöpft ist.
"longest": Die Iteration läuft, bis alle Eingaben erschöpft sind. Fehlende Werte werden aus padding ergänzt, sonst mit undefined.
"strict": Alle Eingaben müssen gleich lang sein, sonst wird ein TypeError ausgelöst.

Für benannte statt positionsbasierte Ergebnisse gibt es die Schwestermethode Iterator.zipKeyed(). Sie nimmt ein Objekt mit Iterables entgegen und liefert Objekte mit denselben Schlüsseln.

Parameter

Name	Typ	Default	Beschreibung
$iterables Pflicht	Iterable<Iterable\|Iterator>		Ein Iterable, meist ein Array, dessen Elemente selbst Iterables oder Iteratoren sind. Jedes Element liefert eine „Spalte“ des Ergebnisses. Strings als Elemente werden abgelehnt (`TypeError`).
$options	object	{}	Optionales Konfigurationsobjekt mit folgenden Eigenschaften.
$options.mode	"shortest" \| "longest" \| "strict"	"shortest"	Legt fest, wie mit unterschiedlich langen Eingaben umgegangen wird. Jeder andere Wert löst einen `TypeError` aus.
$options.padding	Iterable	undefined	Wird nur bei `mode: "longest"` ausgewertet. Liefert die Füllwerte für jede Eingabe-Position in derselben Reihenfolge wie `iterables`. Fehlende Füllwerte gelten als `undefined`.

Rückgabewert

Typ

Iterator<Array>

Beschreibung

Ein neuer Iterator, der von Iterator.prototype erbt, also mit allen Iterator-Helfern. Er liefert bei jedem Schritt ein neues Array, dessen Länge der Anzahl der Eingaben entspricht.

Beispiele

Zwei Arrays paarweise kombinieren

const namen = ['Anna', 'Ben', 'Clara'];
const punkte = [87, 92, 78];

for (const [name, wert] of Iterator.zip([namen, punkte])) {
  console.log(`${name}: ${wert}`);
}

Anna: 87 Ben: 92 Clara: 78

Unterschiedliche Längen mit mode "longest" und padding

const ids = [1, 2, 3, 4];
const labels = ['Start', 'Mitte'];

const zeilen = Iterator.zip([ids, labels], {
  mode: 'longest',
  padding: [0, '(ohne Label)'],
}).toArray();

console.log(zeilen);

[[1, 'Start'], [2, 'Mitte'], [3, '(ohne Label)'], [4, '(ohne Label)']]

Lazy mit unendlichem Generator und Iterator-Helfern

function* zaehler(start = 1) {
  for (let i = start; ; i++) yield i;
}

const aufgaben = ['Einkaufen', 'Putzen', 'Code-Review'];

// "shortest" beendet die Iteration mit dem kürzesten Eingabe-Iterable
const liste = Iterator.zip([zaehler(), aufgaben])
  .map(([nr, text]) => `${nr}. ${text}`)
  .toArray();

console.log(liste.join('\n'));

1. Einkaufen 2. Putzen 3. Code-Review

Gleiche Länge erzwingen mit mode "strict"

const x = [1, 2, 3];
const y = [10, 20];

try {
  for (const [a, b] of Iterator.zip([x, y], { mode: 'strict' })) {
    console.log(a + b);
  }
} catch (err) {
  console.log(err instanceof TypeError, 'Längen stimmen nicht überein');
}

11 22 true Längen stimmen nicht überein

// Wichtig · Fallstricke

Kompatibilität: Iterator.zip() stammt aus dem TC39-Proposal „Joint Iteration“ und ist bisher nur in einzelnen, meist sehr aktuellen Engines verfügbar. Prüfe die Unterstützung vorher mit typeof Iterator?.zip === 'function' oder nutze ein Polyfill, z. B. core-js.
Strings werden abgelehnt: Iterator.zip(['abc', 'def']) löst einen TypeError aus. Wenn du Zeichen verarbeiten willst, zerlege den String vorher, z. B. mit [...'abc'].
Häufiger Fehler: Die Eingaben werden als ein Iterable übergeben, nicht als einzelne Argumente. Richtig ist Iterator.zip([a, b]), falsch ist Iterator.zip(a, b). Im falschen Fall wird b als options gelesen.
Mode „strict“: Der Fehler tritt erst auf, wenn während der Iteration eine Eingabe früher endet als die anderen. Alle Tupel bis dahin wurden also schon ausgegeben.
Ressourcen aufräumen: Wenn die Iteration vorzeitig endet, etwa durch break, einen Fehler oder das Ende im Mode „shortest“, ruft Iterator.zip() auf den noch offenen Eingabe-Iteratoren return() auf. Die finally-Blöcke von Generatoren laufen dann also.
Jedes Tupel ist ein neues Array: Bei sehr großen Datenmengen entstehen dadurch viele kurzlebige Objekte. Wenn es auf Leistung ankommt, ist eine einfache indexbasierte for-Schleife über Arrays schneller.

Siehe auch

Iterator.zipKeyed() Iterator Iterator.from() Iterator.prototype.map() Iterator.prototype.toArray() Array.prototype.entries() for...of