Iterator.prototype.windows() — Methode · JavaScript-Referenz

Signatur

Iterator.prototype.windows(windowSize, undersized)

Beschreibung

windows() erzeugt aus einem beliebigen Iterator eine Folge überlappender Teilstücke. Jedes gelieferte Array enthält windowSize aufeinanderfolgende Elemente, und das Fenster rückt bei jedem Schritt um genau ein Element weiter. Aus 1, 2, 3, 4 werden mit Fenstergröße 2 also [1, 2], [2, 3] und [3, 4].

Typische Anwendungsfälle sind gleitende Durchschnitte, der Vergleich benachbarter Werte (Differenzen, Trenderkennung), N-Gramme in der Textverarbeitung oder das Prüfen, ob eine Folge sortiert ist. Im Gegensatz zu chunks(), das die Elemente in nicht überlappende Blöcke aufteilt, teilen sich benachbarte Fenster bei windows() jeweils windowSize - 1 Elemente.

Wie alle Iterator-Helfer arbeitet windows() verzögert (lazy): Elemente werden erst beim Abrufen des nächsten Fensters aus der Quelle gelesen, und intern werden nur windowSize Elemente gepuffert. Deshalb funktioniert die Methode auch mit unendlichen Iteratoren wie Generatoren. Jedes gelieferte Fenster ist ein neues Array, das man gefahrlos verändern oder aufbewahren kann.

Liefert die Quelle weniger Elemente als windowSize, hängt das Verhalten vom zweiten Argument ab: Mit "only-full" (Standard) wird gar kein Fenster ausgegeben, mit "allow-partial" genau ein verkürztes Fenster mit allen vorhandenen Elementen.

Parameter

Name	Typ	Default	Beschreibung
$windowSize Pflicht	number		Anzahl der Elemente pro Fenster. Muss eine ganze Zahl zwischen `1` und `2³² - 1` sein, sonst wird ein `RangeError` geworfen.
$undersized	"only-full" \| "allow-partial"	"only-full"	Legt fest, was passiert, wenn die Quelle insgesamt weniger als `windowSize` Elemente liefert. `"only-full"`: kein Fenster; `"allow-partial"`: ein einzelnes, kürzeres Fenster. Andere Werte führen zu einem `TypeError`.

Rückgabewert

Typ

Iterator<Array>

Beschreibung

Ein neues Iterator-Hilfsobjekt, das bei jedem next()-Aufruf ein neues Array mit dem aktuellen Fenster liefert.

Beispiele

Grundprinzip: überlappende Paare

const werte = [1, 2, 3, 4, 5].values();

for (const fenster of werte.windows(3)) {
  console.log(fenster);
}

[1, 2, 3] [2, 3, 4] [3, 4, 5]

Gleitender Durchschnitt über Messwerte

const temperaturen = [18.2, 19.0, 21.4, 22.8, 20.6, 19.9];

const mittelwerte = temperaturen
  .values()
  .windows(3)
  .map((f) => (f.reduce((a, b) => a + b, 0) / f.length).toFixed(2))
  .toArray();

console.log(mittelwerte);

['19.53', '21.07', '21.60', '21.10']

Prüfen, ob eine Folge aufsteigend sortiert ist

const istSortiert = (iterable) =>
  Iterator.from(iterable)
    .windows(2)
    .every(([a, b]) => a <= b);

console.log(istSortiert([1, 3, 3, 7]));
console.log(istSortiert(new Set([5, 2, 9])));

true false

Zu kurze Quelle: only-full vs. allow-partial

const kurz = () => ['a', 'b'].values();

console.log(kurz().windows(3).toArray());
console.log(kurz().windows(3, 'allow-partial').toArray());

// Unendlicher Generator – funktioniert dank Lazy Evaluation
function* zaehler() {
  let i = 0;
  while (true) yield i++;
}
console.log(zaehler().windows(2).take(3).toArray());

[] [['a', 'b']] [[0, 1], [1, 2], [2, 3]]

// Wichtig · Fallstricke

Experimentell: windows() stammt aus dem TC39-Proposal Iterator Chunking und ist weder Teil von ECMAScript 2024 noch überall verfügbar. Browser liefern die Methode erst nach und nach aus (teilweise nur hinter Flags), daher vor der Nutzung per typeof Iterator.prototype.windows === "function" prüfen oder ein Polyfill (z. B. core-js) einsetzen. Die Basis-Iterator-Helfer (map, take, toArray …) gehören zu ES2025.

Die Methode existiert nur auf Iteratoren, nicht auf Arrays: [1, 2].windows(2) wirft einen TypeError. Vorher .values() oder Iterator.from() aufrufen.
windowSize wird nicht gerundet: 0, negative Werte, NaN oder Kommazahlen wie 2.5 lösen einen RangeError aus.
Standardmäßig ("only-full") liefert eine zu kurze Quelle gar kein Fenster – eine häufige Ursache für unerwartet leere Ergebnisse.
Jedes Fenster ist ein neu erzeugtes Array; bei sehr großen Fenstern und langen Folgen entsteht dadurch spürbare Speicher-/GC-Last (Aufwand pro Schritt O(windowSize)).
Der Quell-Iterator wird verbraucht; wird der Helfer vorzeitig beendet (z. B. break, take()), ruft er return() der Quelle auf.
Nicht verwechseln mit chunks(): Dort überlappen sich die Blöcke nicht.

Siehe auch

Iterator.prototype.chunks() Iterator Iterator.from() Iterator.prototype.map() Iterator.prototype.take() Iterator.prototype.toArray() Array.prototype.values()