03-iterators-generators.js

/**
 * 03 — ITERATORS AND GENERATORS
 * -------------------------------
 * An ITERATOR is any object with a `.next()` method that returns
 * `{ value, done }`. An ITERABLE is any object with a `Symbol.iterator`
 * method that returns an iterator — this is what `for...of` and spread
 * rely on. A GENERATOR is a special function (`function*`) that makes
 * writing iterators far easier: calling it returns an iterator automatically.
 */

// ── 1. The iterator protocol, built by hand ──────────────────────────────
function makeCounterIterator(max) {
  let current = 0;
  return {
    next() {
      if (current < max) {
        return { value: current++, done: false };
      }
      return { value: undefined, done: true };
    },
  };
}

const counter = makeCounterIterator(3);
console.log(counter.next()); // { value: 0, done: false }
console.log(counter.next()); // { value: 1, done: false }
console.log(counter.next()); // { value: 2, done: false }
console.log(counter.next()); // { value: undefined, done: true }

// ── 2. Making an object ITERABLE with Symbol.iterator ────────────────────
const range = {
  from: 1,
  to: 5,
  [Symbol.iterator]() {
    let current = this.from;
    const last = this.to;
    return {
      next() {
        return current <= last
          ? { value: current++, done: false }
          : { value: undefined, done: true };
      },
    };
  },
};

// Because `range` implements Symbol.iterator, for...of and spread work on it:
for (const n of range) console.log(n); // 1 2 3 4 5
console.log([...range]); // [1, 2, 3, 4, 5]

// ── 3. Generators — the easy way to write the same thing ────────────────
function* rangeGenerator(from, to) {
  for (let i = from; i <= to; i++) {
    yield i; // pauses execution here, returns the value, resumes on next `.next()`
  }
}

for (const n of rangeGenerator(1, 5)) console.log(n); // 1 2 3 4 5

const gen = rangeGenerator(1, 3);
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: false }
console.log(gen.next()); // { value: undefined, done: true }

// ── 4. Generators can receive values back through .next(arg) ────────────
function* conversation() {
  const name = yield "What's your name?";
  const age = yield `Hi ${name}, how old are you?`;
  return `${name} is ${age} years old.`;
}

const convo = conversation();
console.log(convo.next().value);           // "What's your name?"
console.log(convo.next("Abdul").value);    // "Hi Abdul, how old are you?"
console.log(convo.next(21).value);         // "Abdul is 21 years old."

// ── 5. yield* — delegating to another generator/iterable ────────────────
function* inner() {
  yield "a";
  yield "b";
}
function* outer() {
  yield 1;
  yield* inner(); // delegates — yields each value from `inner()` in turn
  yield 2;
}
console.log([...outer()]); // [1, 'a', 'b', 2]

// ── 6. Infinite generators — only possible because generators are LAZY ──
function* naturalNumbers() {
  let n = 1;
  while (true) yield n++;
}
function take(iterable, count) {
  const result = [];
  for (const value of iterable) {
    if (result.length >= count) break;
    result.push(value);
  }
  return result;
}
console.log(take(naturalNumbers(), 5)); // [1, 2, 3, 4, 5] — never actually runs forever