Iterator và generator là gì?

Question

IT Interview Practice · 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.

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

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

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

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

Câu hỏi liên quan