In JavaScript, what happens when you call a generator function declared with `function*` — does its body run, and what do you get back?

## What `function*` declares A function written with an asterisk — `function* gen() { … }` — is a **generator function**. The asterisk is part of the syntax, not the name, and it may sit on either side of the space (`function* gen`, `function *gen`); the first form is the house style. Object and class methods can be generators with the shorthand `*name() { … }`. Arrow functions cannot: there is no `async`-style `*=>` form. Generator functions also have no construct behaviour, so `new gen()` throws a `TypeError`. What makes a generator function different is that calling it does **not** run it. It is a factory: each call builds a fresh **generator object** whose body is suspended before the first statement. ## Calling produces an object, not a result ```javascript function* counter() { console.log('body starts'); yield 1; console.log('between yields'); yield 2; return 'done'; } const g = counter(); // nothing is logged — the body has not begun ``` Arguments are evaluated and bound to parameters at call time, but nothing in the body executes. This is a genuine source of bugs: argument validation written at the top of a generator (`if (!id) throw new TypeError(…)`) does not fire when the caller calls the generator — it fires later, when somebody first pulls from it, often in a completely different stack frame. If you want eager validation, wrap the generator in a plain function that checks arguments and then returns `inner(id)`. ## `next()` drives the body `gen.next()` resumes the body and lets it run until it hits a `yield` expression or finishes. It returns a fresh plain object each time: ```javascript console.log(g.next()); // logs 'body starts', then { value: 1, done: false } console.log(g.next()); // logs 'between yields', then { value: 2, done: false } console.log(g.next()); // { value: 'done', done: true } console.log(g.next()); // { value: undefined, done: true } ``` `value` is the operand of the `yield` that was reached; on completion it is whatever the body returned (`undefined` if it just fell off the end). `done` is `false` while the generator is suspended mid-body and `true` once it has finished. One trap worth memorising: the completion `value` is **not** part of the sequence. `for...of` and spread stop as soon as they see `done: true` and throw that value away, so `[...counter()]` is `[1, 2]`, never `[1, 2, 'done']`. If a caller needs the final result it must drive `next()` by hand and read the result object. ## What "suspended" means When a generator yields, its execution context — parameters, local variables, the position inside loops and `switch` statements, and any `try` blocks currently entered — is preserved on the generator object and taken off the call stack. The caller's stack unwinds normally; the generator is not a thread and nothing runs in the background. On the next `next()`, that context is pushed back and execution continues from the exact point of the `yield`. That retained state is the whole appeal. A hand-rolled iterator has to hoist every piece of progress into object fields and rebuild the position on every `next()`; a generator just writes the loop and lets the pause do the bookkeeping: ```javascript function* pairs(obj) { for (const key of Object.keys(obj)) { yield [key, obj[key]]; // the loop variable survives the pause } } ``` ## One-shot, and one per call A generator object is consumed as it advances. Once it reports `done: true`, it stays finished: further `next()` calls return `{ value: undefined, done: true }` rather than restarting. Each **call** of the generator function, however, produces an independent generator with its own state — so `counter()` twice gives two objects that advance separately. That is why iterable helpers usually store the generator *function* (or an object whose `[Symbol.iterator]` calls it) rather than a single generator object: the function can be called again, the object cannot be rewound. ## Why laziness is the point Because nothing runs until it is pulled, work is done per consumed item rather than up front. A generator that reads records and yields them does the read for item three only when item three is requested, and if the consumer stops early the remaining work simply never happens. That is the practical difference from a function that builds and returns an array: the array pays for everything before the caller looks at anything.