Ce sunt iteratorii și generatorii?

Question

Accepted Answer

Un **iterator** este un obiect cu o metodă `next()` care returnează `{ value, done }`. Un obiect este **iterabil** dacă are o metodă `[Symbol.iterator]` — asta face ca `for...of` și spread să funcționeze. Un **generator** (`function*`) este o modalitate convenabilă de a crea iteratori care pot **pauzează și se reiau** cu `yield`.

## Generatorii produc valori leneș

```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
```

Idee-cheie: execuția **se suspendă** la fiecare `yield` și **se reia** la următorul `.next()`, păstrând starea locală între apeluri. Nimic nu este calculat până nu-l cereți.

## De ce este 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
```

## Realizarea unui iterabil personalizat

```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
```

## De ce este important

Generatorii permit secvențe leneșe/infinite, iterație personalizată și streaming eficient din punct de vedere al memoriei.

Au fost, de asemenea, baza bibliotecilor async timpurii (co) și stau la baza iterației asincrone (`for await...of`).

Protocolul iterator este ceea ce unifică `for...of`, spread și destructuring pe arrays, Maps, Sets și strings.