Hoisting

Hoisting is the JavaScript engine's behavior during the compilation phase where variable and function declarations are processed before any code executes. The declarations appear to be "moved" to the top of their containing scope, though the code itself doesn't physically move — the engine simply allocates memory for them first.

var Hoisting

• var declarations are hoisted and immediately initialized to undefined. This means accessing a var variable before its declaration line returns undefined instead of throwing an error.
• var is function-scoped (or globally scoped if declared outside a function). It ignores block scope entirely — a var declared inside an if or for block is accessible outside that block.
• Only the declaration is hoisted, not the assignment. var x = 5 is split into var x (hoisted, initialized to undefined) and x = 5 (stays in place).

let and const Hoisting (Temporal Dead Zone)

• let and const are technically hoisted — the engine knows about them at the top of their block scope — but they are not initialized. They enter the Temporal Dead Zone (TDZ).
• The TDZ starts at the beginning of the enclosing block and ends when the declaration line is executed. Any access during the TDZ throws a ReferenceError.
• This is why let and const are practically described as "not hoisted" — from a developer's perspective, you cannot use them before their declaration.
• Proof that they are hoisted: if let x inside a block weren't hoisted, console.log(x) before it would read x from an outer scope. Instead, it throws a ReferenceError, proving the inner let x has already "claimed" the identifier.

Function Declaration Hoisting

• Function declarations are fully hoisted — both the name and the entire function body are available before the declaration line. You can call a function declaration anywhere in its scope, even before it appears in the code.
• This is unique to function declarations (function foo() {}). Function expressions (const foo = function() {}) and arrow functions (const foo = () => {}) follow the hoisting rules of their variable keyword (var, let, or const).

Function Expressions and Arrow Functions

• A function expression assigned to var is hoisted as undefined — calling it before assignment throws TypeError: foo is not a function (because undefined is not callable).
• A function expression assigned to let or const is in the TDZ — calling it before assignment throws ReferenceError.

Class Hoisting

• Classes are hoisted like let and const — they exist in the TDZ and cannot be used before their declaration.

Key Interview Distinction: undefined vs ReferenceError Accessing a var before its declaration returns undefined (hoisted and initialized). Accessing a let/const before its declaration throws ReferenceError (hoisted but in TDZ). This distinction is one of the most commonly tested hoisting questions in interviews.