Mik az iterátorok és a generátorok?

Question

Accepted Answer

Az **iterátor** egy olyan objektum, amely rendelkezik egy `next()` metódussal, amely `{ value, done }` értéket ad vissza. Egy objektum **iterable**, ha van egy `[Symbol.iterator]` metódusa — ezt teszi lehetővé a `for...of` és a spread működését. A **generátor** (`function*`) egy kényelmes módja az iterátorok létrehozásának, amelyek `yield` segítségével **szüneteltethető és folytatható**.

## A generátorok lusta módon termelnek értékeket

```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 fő ötlet: a végrehajtás **felfüggesztődik** minden `yield`-nél és **folytatódik** a következő `.next()`-nél, megőrizve a helyi állapotot a hívások között. Semmi sem kerül kiszámításra, amíg nem kéri.

## Miért fontos a lustasag

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

## Egyéni iterálható létrehozása

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

## Miért fontos ez

A generátorok lusta/végtelen sorozatokat, egyéni iterációt és memóriahatékony streamingot tesznek lehetővé.

A korai aszinkron könyvtárak (co) alapja is voltak, és az aszinkron iterációt (`for await...of`) támogatják.

Az iterátor protokoll az, amely egyesíti a `for...of`, spread és destructuring műveletet tömbök, Maps, Sets és stringek között.