Iterators మరియు Generators అంటే ఏమిటి?

Question

Accepted Answer

**Iterator** అనేది `next()` పద్ధతిని కలిగిన ఒక వస్తువు `{ value, done }` ను చి609ందిస్తుంది. ఒక వస్తువు **iterable** అంటే అది `[Symbol.iterator]` పద్ధతిని కలిగి ఉంటే — అది `for...of` మరియు spread పని చేయడానికి చేస్తుంది. **Generator** (`function*`) అనేది iterators ను సృష్టించటానికి స편리మైన మార్గం ఇది `yield` ద్వారా **ఆపవచ్చు మరియు పునः ప్రారంభించవచ్చు**.

## Generators సక్రమంగా విలువలను ఉత్పత్తి చేస్తాయి

```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()` వద్ద **పునరారంభమవుతుంది**, కాల్‌ల మధ్య స్థానిక స్థితిని సంరక్షిస్తుంది. మీరు దాని కోసం అడిగే వరకు ఏమీ లెక్కించబడదు.

## సక్రమణ ఎందుకు ముఖ్యమైనది

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

## ఎందుకు ముఖ్యమైనది

Generators సక్రమ/అనంత సీక్వెన్సులు, ఆసక్తికరమైన iteration, మరియు మెమరీ-ప్రభావవంతమైన స్ట్రీమింగ్ ను ప్రారంభిస్తాయి.

వారు ఆర్లీ async లైబ్రరీల (co) ఆధారం కూడా ఉండేవారు మరియు async iteration (`for await...of`) ఆధారం కలిగి ఉన్నాయి.

Iterator protocol అనేది `for...of`, spread, మరియు destructuring లను arrays, Maps, Sets, మరియు strings లో ఏకీకృతం చేస్తుంది.