Iterator : méthode take() - JavaScript | MDN

Basculer la barre latérale

Thème

Automatique
Clair
Sombre

Français

Se souvenir de la langue En savoir plus

Iterator : méthode take()

Baseline 2025

Nouvellement disponible

Depuis March 2025, cette fonctionnalité fonctionne sur les appareils et les versions de navigateur les plus récents. Elle peut ne pas fonctionner sur les appareils ou navigateurs plus anciens.

La méthode take() des instances de Iterator retourne un nouvel objet d'aide à l'itérateur qui produit le nombre donné d'éléments dans cet itérateur, puis se termine.

Dans cet article

Syntaxe

take(limit)

Paramètres

limit

Le nombre d'éléments à prendre depuis le début de l'itération.

Un nouvel objet d'aide à l'itérateur. L'objet d'aide à l'itérateur retourné produit les éléments de l'itérateur original un par un, puis se termine (la méthode next() produit { value: undefined, done: true }) une fois que limit éléments ont été produits, ou lorsque l'itérateur original est épuisé, selon ce qui se produit en premier.

Exceptions

RangeError

Levée si limit devient NaN ou négatif lorsqu'il est converti en entier.

Exemples

Utiliser la méthode take()

L'exemple suivant crée un itérateur qui produit les termes de la suite de Fibonacci, puis affiche les trois premiers termes :

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

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

Utiliser la méthode take() avec une boucle for...of

take() est plus pratique lorsque vous ne créez pas manuellement l'itérateur. Comme les itérateurs sont également itérables, vous pouvez parcourir l'objet d'aide retourné avec une boucle for...of :

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

// Affiche :
// 1
// 1
// 2
// 3
// 5

Comme fibonacci() est un itérateur infini, utiliser une boucle for pour l'itérer sans aucune logique pour sortir tôt (comme une instruction break) entraînerait une boucle infinie.

Combiner drop() avec take()

Vous pouvez combiner take() avec Iterator.prototype.drop() pour obtenir une tranche d'un itérateur :

js
for (const n of fibonacci().drop(2).take(5)) {
  // Supprime les deux premiers éléments, puis prend les cinq suivants
  console.log(n);
}
// Affiche :
// 2
// 3
// 5
// 8
// 13

for (const n of fibonacci().take(5).drop(2)) {
  // Prend les cinq premiers éléments, puis supprime les deux premiers
  console.log(n);
}
// Affiche :
// 2
// 3
// 5

Limites inférieure et supérieure du nombre d'éléments à prendre

Lorsque limit est négatif ou NaN, une RangeError est levée :

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

Lorsque limit est supérieur au nombre total d'éléments que l'itérateur peut produire (comme Infinity), l'objet d'aide à l'itérateur retourné a essentiellement le même comportement que l'itérateur original :

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

// Affiche :
// 1
// 2
// 3

Aider à améliorer MDN

Cette page vous a-t-elle été utile ?

Oui Non

Apprendre à contribuer

Cette page a été modifiée le 2 mars 2026 par les contributeur·ice·s du MDN.

Voir cette page sur GitHub • Signaler un problème avec ce contenu

Objets natifs standards
Iterator
Constructeur
1. Iterator()
Méthodes statiques
Méthodes d'instance
Héritage
Object/Function
Méthodes statiques
Propriétés statiques
Méthodes d'instance
Propriétés d'instance
1. Object.prototype.__proto__
2. Object.prototype.constructor