What is the difference between var, let and const? Explain hoisting and the temporal dead zone.

Think of a classroom attendance register. Before the class starts, the teacher writes every student's name in the register. That is hoisting: JavaScript reads your code first and notes every variable name in the scope before running a single line.

What happens if someone calls a name early is different:

• With var, the name is in the register with a blank next to it. Asking for it early gives you undefined, with no error.
• With let and const, the name is in the register but marked "not arrived yet". Asking for it early is an error. The time between the start of the scope and the line where the variable is declared is called the temporal dead zone (TDZ).

The other big difference is scope. var belongs to the whole function. let and const belong to the nearest pair of curly braces { }, such as an if block or a loop.

Hoisting, side by side:

console.log(price); // prints undefined (var is hoisted with undefined)
var price = 100;

console.log(total); // ReferenceError: Cannot access 'total' before initialization
let total = 200;

Block scope, the TDZ and const, checked by running:

if (true) {
  var fromVar = 1;
  let fromLet = 2;
}
console.log(typeof fromVar, typeof fromLet); // Output: number undefined

try {
  console.log(score);
  let score = 10;
} catch (e) {
  console.log(e.name); // Output: ReferenceError
}

const user = { name: "Asha" };
user.name = "Ravi"; // allowed: we change the object, not the variable
console.log(user.name); // Output: Ravi

try {
  user = { name: "Kiran" }; // not allowed: reassigning a const
} catch (e) {
  console.log(e.name); // Output: TypeError
}

Function declarations are hoisted completely, body included, which is why you can call them above the line where they are written. Function expressions assigned to let or const follow the TDZ rules.

Modern style is: use const by default, let when the value must change (a loop counter, a running total), and avoid var. This makes code easier to read, because a reader knows a const binding never points to something else.

• Believing const makes an object or array frozen. It only stops reassignment. Use Object.freeze for a shallow freeze.
• Saying let and const are "not hoisted". They are hoisted; the TDZ is what stops early access.
• Using var in a loop with callbacks, so every callback sees the final value.
• Thinking typeof is always safe. typeof x on a variable in its TDZ still throws.

• Why does a for loop with var and setTimeout print the same number three times?
• Is const arr = []; arr.push(1) valid?
• Are function declarations and function expressions hoisted the same way?