Iterator và generator là gì?

Question

Accepted Answer

Một **iterator** là một object có method `next()` trả về `{ value, done }`. Một object là **iterable** nếu nó có method `[Symbol.iterator]` — đó là thứ làm cho `for...of` và spread hoạt động. Một **generator** (`function*`) là một cách tiện lợi để tạo các iterator có thể **tạm dừng và tiếp tục** với `yield`.

## Generator tạo ra giá trị một cách lười biếng (lazily)

```js
function* idGenerator() {
  let id = 1;
  while (true) {     // vô hạn, nhưng lazy — chỉ tính khi được yêu cầu
    yield id++;      // tạm dừng ở đây, trả về một giá trị, tiếp tục khi next()
  }
}
const gen = idGenerator();
gen.next().value; // 1
gen.next().value; // 2 — thực thi tiếp tục từ nơi nó tạm dừng
```

Ý tưởng then chốt: việc thực thi **tạm ngưng** tại mỗi `yield` và **tiếp tục** ở lần `.next()` kế, bảo toàn state cục bộ giữa các lần gọi. Không có gì được tính cho đến khi bạn yêu cầu.

## Tại sao tính lười biếng quan trọng

```js
// xử lý một chuỗi khổng lồ/vô hạn mà không xây toàn bộ nó trong bộ nhớ
function* take(iterable, n) {
  let i = 0;
  for (const x of iterable) {
    if (i++ >= n) return;
    yield x;
  }
}
[...take(idGenerator(), 3)]; // [1, 2, 3] — từ một generator vô hạn
```

## Tạo một iterable tùy chỉnh

```js
const range = {
  from: 1, to: 3,
  *[Symbol.iterator]() { for (let i = this.from; i <= this.to; i++) yield i; },
};
[...range]; // [1, 2, 3] — hoạt động với for...of và spread
```

## Tại sao điều này quan trọng

Generator cho phép các chuỗi lazy/vô hạn, lặp tùy chỉnh, và streaming tiết kiệm bộ nhớ.

Chúng cũng là nền tảng của các thư viện async thuở đầu (co) và là nền cho async iteration (`for await...of`).

Iterator protocol là thứ thống nhất `for...of`, spread, và destructuring qua các mảng, Map, Set, và chuỗi.