Qu'est-ce que les iterators et generators ?

Question

Accepted Answer

Un **iterator** est un objet avec une méthode `next()` retournant `{ value, done }`. Un objet est **iterable** s'il possède une méthode `[Symbol.iterator]` — c'est ce qui rend `for...of` et spread possibles. Un **generator** (`function*`) est un moyen pratique de créer des iterators qui peuvent **s'interrompre et reprendre** avec `yield`.

## Les generators produisent les valeurs de manière paresseuse

```js
function* idGenerator() {
  let id = 1;
  while (true) {     // infinite, but lazy — only computes on demand
    yield id++;      // pause here, return a value, resume on next()
  }
}
const gen = idGenerator();
gen.next().value; // 1
gen.next().value; // 2 — execution resumed where it paused
```

L'idée clé : l'exécution **s'interrompt** à chaque `yield` et **reprend** au `.next()` suivant, en préservant l'état local entre les appels. Rien n'est calculé tant que vous ne le demandez pas.

## Pourquoi c'est important

```js
// process a huge/infinite sequence without building it all in memory
function* take(iterable, n) {
  let i = 0;
  for (const x of iterable) {
    if (i++ >= n) return;
    yield x;
  }
}
[...take(idGenerator(), 3)]; // [1, 2, 3] — from an infinite generator
```

## Créer un iterable personnalisé

```js
const range = {
  from: 1, to: 3,
  *[Symbol.iterator]() { for (let i = this.from; i <= this.to; i++) yield i; },
};
[...range]; // [1, 2, 3] — works with for...of and spread
```

## Pourquoi c'est important

Les generators permettent des séquences paresseuses/infinies, une itération personnalisée et un streaming efficace en mémoire.

Ils ont également été la base des premières bibliothèques async (co) et sont à l'origine de l'itération async (`for await...of`).

Le protocole iterator est ce qui unifie `for...of`, spread et destructuring sur les arrays, Maps, Sets et chaînes de caractères.