Iterator

Beschreibung

Die folgenden sind alle eingebauten JavaScript-Iteratoren:

• Der Array Iterator, der von Array.prototype.values(), Array.prototype.keys(), Array.prototype.entries(), Array.prototype[Symbol.iterator](), TypedArray.prototype.values(), TypedArray.prototype.keys(), TypedArray.prototype.entries(), TypedArray.prototype[Symbol.iterator]() und arguments[Symbol.iterator]() zurückgegeben wird.
• Der String Iterator, der von String.prototype[Symbol.iterator]() zurückgegeben wird.
• Der Map Iterator, der von Map.prototype.values(), Map.prototype.keys(), Map.prototype.entries() und Map.prototype[Symbol.iterator]() zurückgegeben wird.
• Der Set Iterator, der von Set.prototype.values(), Set.prototype.keys(), Set.prototype.entries() und Set.prototype[Symbol.iterator]() zurückgegeben wird.
• Der RegExp String Iterator, der von RegExp.prototype[Symbol.matchAll]() und String.prototype.matchAll() zurückgegeben wird.
• Das Generator-Objekt, das von generierenden Funktionen zurückgegeben wird.
• Der Segments Iterator, der von der [Symbol.iterator]()-Methode des Segments-Objekts zurückgegeben wird, das von Intl.Segmenter.prototype.segment() zurückgegeben wird.
• Der Iterator Helper, der von Iterator-Hilfsmethoden wie Iterator.prototype.filter() und Iterator.prototype.map() zurückgegeben wird.

Web-APIs können ebenfalls Iteratoren zurückgeben. Einige verwenden die Kern-JavaScript-Iteratoren wieder, während andere ihre eigenen Iteratoren definieren. Zum Beispiel:

• Array-ähnliche Objekte wie NodeList geben einen Array Iterator von ihren jeweiligen Methoden keys(), values(), entries() und [Symbol.iterator]() zurück.
• Map-ähnliche Objekte von Web-APIs wie Headers geben ihren eigenen Iteratortyp wie Headers Iterator von ihren jeweiligen Methoden keys(), values(), entries() und [Symbol.iterator]() zurück.
• Set-ähnliche Objekte von Web-APIs wie FontFaceSet geben ihren eigenen Iteratortyp wie FontFaceSet Iterator von ihren jeweiligen Methoden keys(), values(), entries() und [Symbol.iterator]() zurück.

Jeder dieser Iteratoren hat ein eigenes Prototyp-Objekt, das die next()-Methode definiert, die von dem jeweiligen Iterator verwendet wird. Zum Beispiel erben alle String-Iterator-Objekte von einem versteckten Objekt StringIteratorPrototype, das eine next()-Methode besitzt, die diesen String durch Codepunkte iteriert. StringIteratorPrototype hat auch eine [Symbol.toStringTag]-Eigenschaft, deren Anfangswert der String "String Iterator" ist. Diese Eigenschaft wird in Object.prototype.toString() verwendet. Ähnlich haben andere Iterator-Prototypen auch ihre eigenen [Symbol.toStringTag]-Werte, die mit den oben genannten Namen identisch sind.

Alle diese Prototyp-Objekte erben von Iterator.prototype, das eine [Symbol.iterator]()-Methode bereitstellt, die das Iterator-Objekt selbst zurückgibt und den Iterator dadurch ebenfalls iterierbar macht.

Iterator-Hilfsmethoden

Die Iterator-Klasse selbst bietet einige Hilfsmethoden für die Arbeit mit Iteratoren an. Zum Beispiel könnten Sie versucht sein, Folgendes zu tun:

const nameToDeposit = new Map([
  ["Anne", 1000],
  ["Bert", 1500],
  ["Carl", 2000],
]);

const totalDeposit = [...nameToDeposit.values()].reduce((a, b) => a + b);

Dies konvertiert zuerst den von Map.prototype.values() zurückgegebenen Iterator in ein Array und verwendet dann die Array.prototype.reduce()-Methode, um die Summe zu berechnen. Dies erzeugt jedoch sowohl ein Zwischen-Array als auch iteriert das Array zweimal. Stattdessen können Sie die reduce()-Methode des Iterators selbst verwenden:

const totalDeposit = nameToDeposit.values().reduce((a, b) => a + b);

Diese Methode kann möglicherweise effizienter sein, insbesondere speichermäßig, da sie den Iterator nur einmal iteriert, ohne irgendwelche Zwischenergebnisse zu speichern. Iterator-Hilfsmethoden sind notwendig, um mit unendlichen Iteratoren zu arbeiten:

function* fibonacci() {
  let current = 1;
  let next = 1;
  while (true) {
    yield current;
    [current, next] = [next, current + next];
  }
}

const seq = fibonacci();
const firstThreeDigitTerm = seq.find((n) => n >= 100);

Sie können seq nicht in ein Array konvertieren, da es unendlich ist. Stattdessen können Sie die find()-Methode des Iterators selbst verwenden, die seq nur so weit iteriert, wie es notwendig ist, um den ersten Wert zu finden, der die Bedingung erfüllt.

Sie werden viele Iterator-Methoden finden, die Analogien zu Array-Methoden aufweisen, wie zum Beispiel:

Iterator.prototype.drop() und Iterator.prototype.take() zusammen sind einigermaßen analog zu Array.prototype.slice().

Iterator-Hilfsobjekte

Unter den Iterator-Hilfsmethoden erzeugen filter(), flatMap(), map(), drop(), und take() ein neues Iterator-Hilfsobjekt. Der Iterator-Hilfsobjekt ist ebenfalls eine Instanz von Iterator, was diese Hilfsmethoden kettefähig macht. Alle Iterator-Hilfsobjekte erben von einem gemeinsamen Prototyp-Objekt, das das Iterator-Protokoll implementiert:

next()

Ruft die next()-Methode des zugrunde liegenden Iterators auf, wendet die Hilfsmethode auf das Ergebnis an und gibt das Ergebnis zurück.

return()

Ruft die return()-Methode des zugrunde liegenden Iterators auf und gibt das Ergebnis zurück.

Der Iterator-Hilfsobjekt teilt die gleiche Datenquelle wie der zugrunde liegende Iterator, sodass die Iteration des Iterator-Hilfsobjekts auch den zugrunde liegenden Iterator iteriert. Es gibt keine Möglichkeit, einen Iterator "aufzuteilen", um ihn mehrmals zu iterieren.

const it = [1, 2, 3].values();
const it2 = it.drop(0); // Essentially a copy
console.log(it.next().value); // 1
console.log(it2.next().value); // 2
console.log(it.next().value); // 3

Richtige Iteratoren

Es gibt zwei Arten von "Iteratoren": Objekte, die dem Iterator-Protokoll entsprechen (was im Minimalfall nur das Vorhandensein einer next()-Methode erfordert), und Objekte, die von der Iterator-Klasse erben und die Hilfsmethoden nutzen. Sie bedingen einander nicht — Objekte, die von Iterator erben, werden nicht automatisch zu Iteratoren, da die Iterator-Klasse keine next()-Methode definiert. Stattdessen muss das Objekt selbst eine next()-Methode definieren. Ein richtiger Iterator ist einer, der sowohl dem Iterator-Protokoll entspricht als auch von Iterator erbt, und die meisten Codes erwarten, dass Iteratoren richtige Iteratoren sind und Iterables richtige Iteratoren zurückgeben. Um richtige Iteratoren zu erstellen, definieren Sie eine Klasse, die Iterator erweitert, oder verwenden Sie die Iterator.from()-Methode.

class MyIterator extends Iterator {
  next() {
    // …
  }
}

const myIterator = Iterator.from({
  next() {
    // …
  },
});

Konstruktor

Iterator()

Soll von anderen Klassen erweitert werden, die Iteratoren erstellen. Löst einen Fehler aus, wenn er selbst konstruiert wird.

Statische Methoden

Iterator.concat()

Erzeugt ein neues Iterator-Objekt aus einer Liste von iterierbaren Objekten. Der neue Iterator liefert die Werte aus jedem der Eingabe-Iterables nacheinander.

Iterator.from()

Erzeugt ein neues Iterator-Objekt aus einem Iterator oder einem iterierbaren Objekt.

Iterator.zip()

Erzeugt ein neues Iterator-Objekt, das Elemente aus mehreren iterierbaren Objekten aggregiert, indem es Arrays bereitstellt, die Elemente an der gleichen Position enthalten.

Iterator.zipKeyed()

Erzeugt ein neues Iterator-Objekt, das Elemente aus mehreren iterierbaren Objekten aggregiert, indem es Objekte bereitstellt, die Elemente an der gleichen Position enthalten, mit Schlüsseln, die durch die Eingabe angegeben sind.

Instanz-Eigenschaften

Diese Eigenschaften sind auf Iterator.prototype definiert und werden von allen Iterator-Instanzen geteilt.

Iterator.prototype.constructor

Die Konstrukturfunktion, die das Instanz-Objekt erstellt hat. Für Iterator-Instanzen ist der Anfangswert der Iterator-Konstruktor.

Iterator.prototype[Symbol.toStringTag]

Der Anfangswert der [Symbol.toStringTag]-Eigenschaft ist der String "Iterator". Diese Eigenschaft wird in Object.prototype.toString() verwendet.

Hinweis: Im Gegensatz zum [Symbol.toStringTag] bei den meisten eingebauten Klassen ist Iterator.prototype[Symbol.toStringTag] aus Gründen der Web-Kompatibilität beschreibbar.

Instanz-Methoden

Iterator.prototype.drop()

Gibt ein neues Iterator-Hilfsobjekt zurück, das die gegebene Anzahl von Elementen am Anfang dieses Iterators überspringt.

Iterator.prototype.every()

Gibt false zurück, wenn es ein Element findet, das die gegebene Testfunktion nicht erfüllt. Andernfalls, wenn der Iterator erschöpft ist, ohne ein solches Element zu finden, gibt er true zurück.

Iterator.prototype.filter()

Gibt ein neues Iterator-Hilfsobjekt zurück, das nur jene Elemente des Iterators liefert, für die die gegebene Callback-Funktion true zurückgibt.

Iterator.prototype.find()

Gibt das erste vom Iterator produzierte Element zurück, das die gegebene Testfunktion erfüllt. Wenn keine Werte die Testfunktion erfüllen, wird undefined zurückgegeben.

Iterator.prototype.flatMap()

Gibt ein neues Iterator-Hilfsobjekt zurück, das jedes Element im ursprünglichen Iterator nimmt, es durch eine Abbildungsfunktion leitet und die von der Abbildungsfunktion zurückgegebenen Elemente liefert (die sich in einem anderen Iterator oder iterierbaren Objekt befinden).

Iterator.prototype.forEach()

Führt eine gegebene Funktion einmal für jedes vom Iterator produzierte Element aus.

Iterator.prototype.includes()

Gibt true zurück, wenn ein vom Iterator produziertes Element gleich dem angegebenen Wert ist. Andernfalls, wenn der Iterator erschöpft ist, ohne ein solches Element zu finden, gibt er false zurück.

Iterator.prototype.map()

Gibt ein neues Iterator-Hilfsobjekt zurück, das Elemente des Iterators liefert, die jeweils durch eine Abbildungsfunktion transformiert werden.

Iterator.prototype.reduce()

Führt eine vom Benutzer gelieferte "Reducer"-Callback-Funktion auf jedem vom Iterator produzierten Element aus, wobei der Rückgabewert aus der Berechnung des vorhergehenden Elements übergeben wird. Das endgültige Ergebnis des Ausführens des Reducers über alle Elemente ist ein einzelner Wert.

Iterator.prototype.some()

Gibt true zurück, wenn es ein Element findet, das die gegebene Testfunktion erfüllt. Andernfalls, wenn der Iterator erschöpft ist, ohne ein solches Element zu finden, gibt er false zurück.

Iterator.prototype.take()

Gibt ein neues Iterator-Hilfsobjekt zurück, das die gegebene Anzahl von Elementen in diesem Iterator liefert und dann beendet.

Iterator.prototype.toArray()

Erzeugt eine neue Array-Instanz, die mit den vom Iterator gelieferten Elementen gefüllt ist.

Iterator.prototype[Symbol.dispose]()

Ruft die return()-Methode von this auf, falls vorhanden. Dies implementiert das disposable Protocol und erlaubt es, entsorgt zu werden, wenn es mit using oder await using verwendet wird.

Iterator.prototype[Symbol.iterator]()

Gibt das Iterator-Objekt selbst zurück. Dies ermöglicht es Iterator-Objekten, ebenfalls iterierbar zu sein.

Beispiele

Verwenden eines Iterators als Iterable

Alle eingebauten Iteratoren sind ebenfalls iterierbar, sodass Sie sie in einer for...of-Schleife verwenden können:

const arrIterator = [1, 2, 3].values();
for (const value of arrIterator) {
  console.log(value);
}
// Logs: 1, 2, 3

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Polyfill von Iterator in core-js
• es-shims Polyfill von Iterator und zugehörigen Helfern
• function*
• Iterationsprotokolle