Scope & Hoisting

Scope is the set of rules by which the engine decides where a name is available and which variable it points at. JavaScript has three scope levels — global, function, and block — and they behave differently for var versus let/const. On top of that runs the lexical model: a name's scope is fixed by where the code is written, not where it is called — which is exactly what closures rest on.

The second pillar is hoisting: the engine registers declarations before running the code, in the creation phase of the execution context. Every "oddity" grows from here: var reads as undefined before its line, a function can be called above its declaration, and let/const fall into a temporal dead zone. Each layer below dissects one part of this machine.

Topic map

• Global scope — the top-level scope and how to create a global variable accidentally by assigning without a keyword.
• Function scope — why var is visible throughout the function regardless of nested blocks.
• Block scope — how let and const are bounded by the nearest {} while var ignores them.
• Lexical scope — how the scope chain resolves a name outward and why scope is fixed where the code is written.
• var, let, const — a summary table of the differences by scope, hoisting, reassignment, and redeclaration.
• Hoisting — registering declarations before execution and the difference between hoisting var, functions, and let/const.
• Temporal dead zone (TDZ) — the span where a let/const name already exists but reading it throws a ReferenceError.
• Variable shadowing — how an inner name hides an outer one and what illegal shadowing is.
• Execution context — the creation and execution phases where hoisting, the TDZ, the scope chain, and this are born.

Common traps

Interview relevance

Scope and hoisting are a favorite way to test whether you understand the execution model, not just the syntax. The classic question is "what does reading a variable before its declaration print": the right answer depends on the keyword (undefined for var, ReferenceError for let) and requires explaining the creation-phase mechanism.

Typical checks:

• The three scopes and which declaration respects which.
• What hoisting is and how hoisting var, a function, and let/const differ.
• What the TDZ is and why let before its line is an error, not undefined.
• The lexical model and the scope chain as the foundation of closures.

Common wrong answer: "hoisting physically moves the code to the top". In fact the code moves nowhere — the engine merely registers declarations in the context creation phase, binding var to undefined and leaving let/const uninitialized until their line.