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

Signatur

Iterator.prototype.take(limit)

Beschreibung

take() gehört zu den Iterator Helpers und begrenzt einen Iterator auf eine bestimmte Anzahl von Elementen. Das Ergebnis ist ein neuer Iterator, der verzögert (lazy) arbeitet: Ein Element wird erst dann aus dem Quell-Iterator gelesen, wenn beim Ergebnis next() aufgerufen wird.

Besonders nützlich ist die Methode bei unendlichen oder sehr großen Folgen, etwa Generatoren für Zahlenfolgen, IDs oder paginierte Datenquellen. Statt eine Schleife mit Zähler und break zu schreiben, lässt sich die Begrenzung direkt in eine Kette aus filter(), map() und toArray() einbauen.

Wenn das Limit erreicht ist, ruft take() die Methode return() des zugrunde liegenden Iterators auf und schließt ihn damit. Bei Generatoren laufen dadurch finally-Blöcke, sodass Ressourcen sauber freigegeben werden. Endet die Quelle schon vor dem Limit, endet auch der Ergebnis-Iterator entsprechend früher.

Parameter

Name	Typ	Default	Beschreibung
$limit Pflicht	number		Maximale Anzahl zu liefernder Elemente. Wird zu einer Ganzzahl umgewandelt (Nachkommastellen werden abgeschnitten). `Infinity` ist erlaubt. Negative Werte oder `NaN` lösen einen `RangeError` aus.

Rückgabewert

Typ

Iterator

Beschreibung

Ein neues Iterator-Hilfsobjekt, das die ersten limit Elemente des ursprünglichen Iterators liefert und danach { value: undefined, done: true } zurückgibt.

Beispiele

Unendlichen Generator begrenzen

function* fibonacci() {
  let [a, b] = [0, 1];
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

// Nur die ersten 10 Fibonacci-Zahlen
const ersteZehn = fibonacci().take(10).toArray();
console.log(ersteZehn);

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

In einer Kette mit filter() und map()

const obst = ["apfel", "Birne", "kiwi", "Banane", "mango"];

// Arrays haben kein take() – daher über values() einen Iterator holen
const ergebnis = obst.values()
  .filter((w) => w.length > 4)
  .map((w) => w.toUpperCase())
  .take(2)
  .toArray();

console.log(ergebnis);

["APFEL", "BIRNE"]

Quell-Iterator wird automatisch geschlossen

function* zaehler() {
  try {
    let i = 0;
    while (true) yield i++;
  } finally {
    console.log("Ressource geschlossen");
  }
}

for (const n of zaehler().take(3)) {
  console.log(n);
}

0 1 2 Ressource geschlossen

Ungültiges Limit abfangen

const it = [1, 2, 3].values();

try {
  it.take(-1);
} catch (err) {
  console.log(err.name, err.message);
}

// Limit größer als die Quelle: endet einfach früher
console.log([...[1, 2, 3].values().take(10)]);

RangeError <browserabhängige Meldung> [1, 2, 3]

// Wichtig · Fallstricke

Kein Array-Methode: [1, 2, 3].take(2) schlägt mit TypeError fehl. Erst mit values(), entries(), keys() oder Iterator.from() einen Iterator erzeugen. Für Arrays ist slice(0, n) meist die einfachere Wahl.
Fehler beim Aufruf: Negative Werte oder NaN (z. B. take(\"abc\") oder take() ohne Argument) werfen sofort einen RangeError, nicht erst bei next().
Verzögerte Auswertung: Der Quell-Iterator wird erst bei next() weitergeschaltet. Auch take(0) schließt die Quelle erst beim ersten next()-Aufruf.
Einmal verbraucht: Iteratoren lassen sich nicht zurücksetzen. Nach dem Durchlaufen der Ergebnisse ist der Quell-Iterator geschlossen und kann nicht weiter genutzt werden.
Kompatibilität: Iterator Helpers sind relativ neu (Baseline 2025). In älteren Browsern und Node.js-Versionen unter 22 ist ein Polyfill nötig, z. B. aus core-js. Für asynchrone Iteratoren gibt es take() noch nicht standardisiert (Proposal „Async Iterator Helpers“).

Siehe auch

Iterator Iterator.prototype.drop() Iterator.prototype.filter() Iterator.prototype.map() Iterator.from() Array.prototype.slice()