इटरेटर्स और जनरेटर्स क्या हैं?

Question

Accepted Answer

एक **इटरेटर** एक object है जिसमें `next()` method है जो `{ value, done }` रिटर्न करता है। एक object **iterable** है अगर इसमें `[Symbol.iterator]` method है — यही वह है जो `for...of` और spread को काम करता है। एक **जनरेटर** (`function*`) इटरेटर्स बनाने का एक सुविधाजनक तरीका है जो `yield` के साथ **रुक और फिर से शुरू** कर सकते हैं।

## जनरेटर्स आलसी तरीके से मान पैदा करते हैं

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

मुख्य विचार: निष्पादन हर `yield` पर **रुकता है** और अगले `.next()` पर **फिर से शुरू** होता है, कॉल के बीच local state को संरक्षित करता है। जब तक आप न पूछें तब तक कुछ भी compute नहीं होता।

## आलसीपन क्यों महत्वपूर्ण है

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

## कस्टम iterable बनाना

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

## यह क्यों महत्वपूर्ण है

जनरेटर्स आलसी/अनंत sequences, कस्टम iteration, और memory-efficient streaming को सक्षम करते हैं।

वे शुरुआती async libraries (co) का भी आधार थे और async iteration (`for await...of`) को शक्ति देते हैं।

इटरेटर protocol वह है जो arrays, Maps, Sets, और strings में `for...of`, spread, और destructuring को एकीभूत करता है।