O que são iteradores e geradores?

Question

Accepted Answer

Um **iterator** é um objeto com um método `next()` que retorna `{ value, done }`. Um objeto é **iterável** se tem um método `[Symbol.iterator]` — é isso que faz `for...of` e spread funcionarem. Um **generator** (`function*`) é uma forma conveniente de criar iteradores que podem **pausar e retomar** com `yield`.

## Geradores produzem valores preguiçosamente

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

A ideia principal: a execução **suspende** em cada `yield` e **retoma** no próximo `.next()`, preservando o estado local entre as chamadas. Nada é computado até que você peça.

## Por que isso importa

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

## Criando um iterável customizado

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

## Por que isso importa

Geradores permitem sequências preguiçosas/infinitas, iteração customizada, e streaming eficiente em memória.

Eles também foram a base de bibliotecas async iniciais (co) e sustentam iteração assíncrona (`for await...of`).

O protocolo de iterador é o que unifica `for...of`, spread e desestruturação em arrays, Maps, Sets, e strings.