Event Loop & Iteration

JavaScript runs on a single thread with one call stack. Async work (timers, I/O, events) is handed to the host, whose callbacks land in a task queue. The event loop repeatedly waits for the stack to empty, then dequeues one task and runs it to completion. This keeps the thread non-blocking: long-running async work happens off-thread, never freezing the stack.

Promise callbacks (.then/.catch/.finally, await continuations) and queueMicrotask go on the microtask queue; setTimeout/setInterval and I/O callbacks are macrotasks. After each macrotask (and the initial script), the loop drains the entire microtask queue before the next macrotask. So microtasks always run before the next setTimeout, and a microtask queued by another microtask runs in the same drain.

An object is iterable if it has a [Symbol.iterator]() method returning an iterator — an object with a next() method that yields { value, done }. for...of calls [Symbol.iterator](), then repeatedly calls next() until done is true, binding each value. Arrays, strings, Map, and Set are built-in iterables; plain objects are not.

A generator is a function declared with function* that can pause and resume. Each yield produces a value and suspends execution until the next next() call. Calling a generator returns an iterator (also iterable), so it works directly with for...of and spread. Values are produced lazily on demand, letting generators model infinite or expensive sequences without computing them all up front.

Per turn: run synchronous code, then drain the entire microtask queue (promises), then run one macrotask (setTimeout, I/O), then drain microtasks again. Endlessly re-queuing microtasks starves macrotasks and blocks rendering. In Node, process.nextTick runs before promise microtasks; setImmediate fires in the check phase after I/O, while a setTimeout(fn, 0) runs in the earlier timers phase — so their order depends on context.

RxJS is a library that implements observables for composing asynchronous and event-based streams. Operators like map, filter, and debounceTime are pure functions that take a source stream and return a new derived one, chained via pipe. A subscribe call starts the stream and returns a subscription whose unsubscribe tears it down and stops emissions.

An async generator (async function*) yields values whose readiness is itself asynchronous: each next() returns a promise of { value, done }, and you consume it with for await...of, which awaits each step. It can both await inside and yield out, making it ideal for streaming async data. Conceptually async/await is generators plus promises: await is a yield of a promise that a driver resolves and feeds back via next().

A cold observable starts a fresh producer per subscriber (unicast); a hot one shares a single already-running producer, so late subscribers miss earlier emissions (multicast). Backpressure is a fast push producer outpacing a slow consumer; RxJS lacks built-in flow control, so you buffer, throttle, or sample. Async iterators are pull-based — for await requests one value at a time — giving natural backpressure, unlike a push observable.