Iterator.prototype.take() - JavaScript | MDN

Seitenleiste umschalten

Farbschema

Systemeinstellung
Hell
Dunkel

Deutsch

Sprache merken Mehr erfahren

Iterator.prototype.take()

Baseline 2025

Neu verfügbar

Seit March 2025 funktioniert diese Funktion auf aktuellen Geräten und in aktuellen Browserversionen. Auf älteren Geräten oder in älteren Browsern funktioniert sie möglicherweise nicht.

Die take() Methode von Iterator Instanzen gibt ein neues Iterator-Hilfsobjekt zurück, das die gegebene Anzahl von Elementen in diesem Iterator liefert und dann beendet.

In diesem Artikel

Syntax

take(limit)

Parameter

limit

Die Anzahl von Elementen, die vom Beginn der Iteration an übernommen werden sollen.

Ein neues Iterator-Hilfsobjekt. Der zurückgegebene Iteratoren-Helfer liefert die Elemente im ursprünglichen Iterator einzeln und endet dann (die next() Methode erzeugt { value: undefined, done: true }), nachdem limit Elemente geliefert wurden oder wenn der ursprüngliche Iterator erschöpft ist, je nachdem, was zuerst eintritt.

Ausnahmen

RangeError

Wird ausgelöst, wenn limit zu NaN oder negativ wird, wenn es in eine Ganzzahl konvertiert wird.

Beispiele

Verwendung von take()

Das folgende Beispiel erstellt einen Iterator, der Begriffe in der Fibonacci-Sequenz liefert, und protokolliert dann die ersten drei Begriffe:

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

const seq = fibonacci().take(3);
console.log(seq.next().value); // 1
console.log(seq.next().value); // 1
console.log(seq.next().value); // 2
console.log(seq.next().value); // undefined

Verwendung von take() mit einer for...of Schleife

take() ist am bequemsten, wenn Sie den Iterator nicht manuell erstellen. Da Iteratoren auch iterierbar sind, können Sie den zurückgegebenen Helfer mit einer for...of Schleife durchlaufen:

js
for (const n of fibonacci().take(5)) {
  console.log(n);
}

// Logs:
// 1
// 1
// 2
// 3
// 5

Da fibonacci() ein unendlicher Iterator ist, würde die Verwendung einer for Schleife, um ihn zu durchlaufen, ohne eine Logik zum vorzeitigen Beenden (wie eine break Anweisung), zu einer Endlosschleife führen.

Kombination von drop() mit take()

Sie können take() mit Iterator.prototype.drop() kombinieren, um einen Ausschnitt eines Iterators zu erhalten:

js
for (const n of fibonacci().drop(2).take(5)) {
  // Drops the first two elements, then takes the next five
  console.log(n);
}
// Logs:
// 2
// 3
// 5
// 8
// 13

for (const n of fibonacci().take(5).drop(2)) {
  // Takes the first five elements, then drops the first two
  console.log(n);
}
// Logs:
// 2
// 3
// 5

Untere und obere Grenzen der Übernahmeanzahl

Wenn das limit negativ oder NaN ist, wird ein RangeError ausgelöst:

js
fibonacci().take(-1); // RangeError: -1 must be positive
fibonacci().take(undefined); // RangeError: undefined must be positive

Wenn das limit größer ist als die Gesamtzahl der Elemente, die der Iterator erzeugen kann (wie Infinity), hat der zurückgegebene Iteratoren-Helfer im Wesentlichen dasselbe Verhalten wie der ursprüngliche Iterator:

js
for (const n of new Set([1, 2, 3]).values().take(Infinity)) {
  console.log(n);
}

// Logs:
// 1
// 2
// 3

Help improve MDN

War diese Übersetzung hilfreich?

Ja Nein

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden

Eingebaute Standardobjekte
Iterator
Konstruktor
1. Iterator()
Statische Methoden
Instanzmethoden
Vererbung
Object/Function
Statische Methoden
Statische Eigenschaften
Instanzmethoden
Instanzeigenschaften
1. __proto__
2. constructor