Hva er iteratorer og generatorer?

Question

Accepted Answer

En **iterator** er et objekt med en `next()`-metode som returnerer `{ value, done }`. Et objekt er **itererbart** hvis det har en `[Symbol.iterator]`-metode — det er det som gjør at `for...of` og spread fungerer. En **generator** (`function*`) er en praktisk måte å lage iteratorer som kan **pausere og fortsette** med `yield`.

## Generatorer produserer verdier lat

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

Hovedideen: kjøringen **suspenderes** ved hver `yield` og **gjenopptas** på neste `.next()`, og bevarer lokal tilstand mellom kall. Ingenting beregnes før du ber om det.

## Hvorfor lathet betyr noe

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

## Lage en egendefinert itererbar

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

## Hvorfor det betyr noe

Generatorer muliggjør late/uendelige sekvenser, egendefinert iterasjon, og minneeffektiv streaming.

De var også grunnlaget for tidlige async-biblioteker (co) og ligger til grunn for async-iterasjon (`for await...of`).

Iterator-protokollen er det som forener `for...of`, spread, og destrukturering på tvers av arrays, Maps, Sets, og strings.