JavaScript Interview Guide: Core Concepts and Questions

Everything in JavaScript happens inside an execution context. How the global one is created — memory phase first, then code phase — and why that order explains almost everything that follows.

JavaScript can only ever do one thing at a time. This is the structure that decides exactly what runs right now, what's paused and waiting its turn, and what happens the moment a function calls itself one time too many.

Lesson 4 showed one function looking outward to Global. This lesson extends that into a full chain — as many levels deep as your code is nested — and gives it a proper name: lexical scope, decided entirely by where you physically wrote your code, never by which function called which.

The full picture of the three declaration keywords: every axis they differ on, function scope versus block scope (and what loops do), exactly where the TDZ starts and ends and why it is temporal rather than positional, the places it hides, redeclaration, errors that stop your file before it runs, and the one exception to "typeof is always safe".

Parser, interpreter (Ignition), compiler (TurboFan), memory heap and garbage collection — what the engine does between your file and the CPU. Watch a function climb V8's tiers and fall back on a deopt, and step through mark-and-sweep.

A function that remembers where it was born — even after the place it was born in is gone. This is the one exception to "popped execution context = memory freed" that Lesson 2 promised we'd come back to.

One loop, one setTimeout, one wrong answer almost everyone gives the first time. This lesson is dedicated entirely to the single most-asked closures question in JavaScript interviews — and four different, genuinely correct ways to fix it.

Functions as values: passing them as arguments, returning them from other functions, sync vs async callbacks stepped side by side, and attaching and removing event listeners without leaking memory.

Call stack, Web APIs, callback queue, microtask queue and the event loop that ties them together, stepped tick by tick — plus async/await, where rendering fits, starvation, and why setTimeout(0) is not 0.

Promise states, microtask order, a promise built by hand, async/await, the combinators and AbortController.

Order puzzles in the browser and Node, promise rules, combinators, concurrency limits, cancellation, race conditions and async memory leaks.

Property descriptors, how lookup walks the prototype chain, new traced step by step, shadowing, freeze and seal.

The four rules for this, arrow functions, call, apply and bind, and classes shown as sugar over prototypes.

Live bindings versus copies, Node's module rules, circular imports, and a real bundle built with esbuild.

The iteration protocol, writing iterators and generators by hand, lazy sequences, async iterators and symbols.

Throwing and catching, Proxy traps with Reflect, shallow versus deep copies, structuredClone and immutable updates.

IEEE 754 doubles with bit-level demos, rounding, safe integers, comparing floats and handling money.

Code points, UTF-16 code units, bytes and grapheme clusters, why emoji lengths surprise you, normalisation and safe truncation.

Reachability, five usual leaks measured, WeakMap and WeakRef, typed arrays and how to find a leak with heap snapshots.

All 14 lessons, compressed into one read for the morning of an interview — concept, a runnable example with its real output, and a ready-made spoken answer for each, plus an output-prediction drill and rapid-fire Q&A.

Types and coercion, prototypes, classes, this, copying, Map and Set, iterators, modules, newer array methods and “what does this print” puzzles.

Tested solutions for debounce, throttle, curry, memoize, deep clone, promise polyfills, a pool, an event emitter, an LRU cache and live-coding tips.