Hoisting

The plain-language idea

Before running any code in a scope, the JS engine does a quick pass over it and registers every declaration it finds — var, function, let, const, class. That registration step is hoisting. It's not that your code physically moves to the top; the name is known early, but what happens if you use it early depends entirely on which keyword declared it.

Three different early-use behaviours

console.log(a); // undefined — declared AND initialized to undefined
var a = 1;

console.log(b); // ReferenceError — "Cannot access 'b' before initialization"
let b = 2;

console.log(sayHi()); // works — function declarations hoist fully, body included
function sayHi() {
  return "hi";
}

var is hoisted and pre-initialized to undefined. let/const are hoisted too — the name is reserved — but they sit in the temporal dead zone (TDZ) until their declaration line actually runs, so touching them early throws instead of silently returning undefined. Function declarations hoist their entire body, which is why you can call one before its line in the file.

Before running a single line, the engine scans the scope and registers every declaration it finds.

BackNext

What people usually miss

Watch out

• let/const are hoisted too. The common shorthand "let and const aren't hoisted" is wrong — they're hoisted but land in the TDZ, which is a different failure mode (throw) than var's (undefined), not an absence of hoisting.
• Function expressions don't hoist like declarations. const sayHi = function () {} hoists the const binding (into the TDZ), not the function body — calling it early throws, unlike a plain function sayHi() {}.
• Class declarations are hoisted into the TDZ too, same as let/const — using a class before its line throws, it doesn't silently work.

Why this matters in interviews

"What does this log?" snippets mixing var/let/function calls above their declaration are a standard warm-up question — they're really testing whether you know hoisting has three distinct behaviours, not one.