Iterators & Generators

The Iteration Protocols

ES6 introduced two complementary iteration protocols that standardize traversal across JavaScript data structures:

1. The Iterable Protocol:
   • An object is iterable if it implements a method with key [Symbol.iterator].
   • This method must return an iterator object.
   • Built-in iterables include Array, String, Map, Set, TypedArray, and NodeList.
2. The Iterator Protocol:
   • An object is an iterator if it implements a .next() method.
   • .next() returns an object with { value: any, done: boolean }.
   • Once done: true is reached, subsequent .next() calls should continue returning { value: undefined, done: true }.

Generator Functions & yield

Generators (function*) are special functions that can pause and resume execution:

• yield expr: Suspends the generator's execution context and sends expr out to the caller.
• gen.next(arg): Resumes the generator. The paused yield expression inside the generator evaluates to arg! This enables two-way communication between caller and callee.
• First next() Call Rule: Any argument passed to the initial .next(arg) call is ignored by the JavaScript engine because no yield expression is currently waiting to receive a value.

for...of vs Generator Return

A critical interview nuance: for...of loops discard the return value of a generator!

function* demo() {
  yield 1;
  yield 2;
  return 3;
}

for (const val of demo()) {
  console.log(val); // Logs: 1, then 2 (3 is NEVER logged!)
}

Because for...of terminates the loop immediately upon seeing { done: true }, any value attached to the closing object is ignored. If you want a value consumed by for...of, you must yield it.

Custom Iterable Example

const range = {
  from: 1,
  to: 3,
  [Symbol.iterator]() {
    let current = this.from;
    const last = this.to;
    return {
      next() {
        return current <= last
          ? { value: current++, done: false }
          : { value: undefined, done: true };
      }
    };
  }
};

console.log([...range]); // [1, 2, 3]

Generator Methods: return() and throw()

• gen.return(val): Forces the generator to terminate immediately, executing any active finally blocks and returning { value: val, done: true }.
• gen.throw(err): Injects an exception into the generator at the current yield pause point, allowing try...catch inside the generator to intercept it.