ઇટરેટર્સ અને જનરેટર્સ શું છે?

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

મુખ્ય વિચાર: execution દરેક `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
```

## શા માટે તે મહત્વપૂર્ણ છે

જનરેટર્સ આલસી/અનંત સિક્વન્સ, કસ્ટમ ઇટરેશન, અને મેમોરી-કુશળ streaming સક્ષમ કરે છે.

તેઓ પ્રાથમિક async libraries (co) નો પણ આધાર હતા અને async ઇટરેશન (`for await...of`) ને આધાર આપે છે.

ઇટરેટર protocol એ છે જે arrays, Maps, Sets, અને strings માટે `for...of`, spread, અને destructuring એક કરે છે.