const by default, let when you must reassign, var never — and know why: scope, hoisting and the temporal dead zone.

The three declarations

	`var`	`let`	`const`
Scope	Function	Block `{ }`	Block `{ }`
Hoisted?	Yes, initialised to `undefined`	Yes, but uninitialised (TDZ)	Yes, but uninitialised (TDZ)
Re-declare in same scope	Allowed	SyntaxError	SyntaxError
Reassign	Yes	Yes	No — TypeError
Creates `globalThis` property (scripts)	Yes	No	No

Block scope vs function scope

JavaScript

function demo() {
  if (true) {
    var a = "var leaks out of the block";
    let b = "let stays inside";
  }
  console.log(a);
  console.log(typeof b);
}
demo();

Output

var leaks out of the block
undefined

`const` means constant binding, not immutable value

JavaScript

const user = { name: "Asha" };
user.name = "Ravi";          // fine: mutating the object
user.age = 30;               // fine
console.log(user);
try {
  user = {};                 // not fine: rebinding the name
} catch (e) {
  console.log(e.name + ": " + e.message);
}

Output

{ name: 'Ravi', age: 30 }
TypeError: Assignment to constant variable.

Hoisting and the Temporal Dead Zone

JavaScript

console.log(x);        // var is hoisted and set to undefined
var x = 5;

try {
  console.log(y);      // y exists but is in the TDZ
} catch (e) {
  console.log(e.name + ": " + e.message);
}
let y = 10;

Output

undefined
ReferenceError: Cannot access 'y' before initialization

The TDZ is temporal (about time, not position): a function that reads the variable is fine as long as it is called after the declaration runs.

JavaScript

function read() { return value; }  // refers to value declared below
let value = 42;
console.log(read());               // called after initialisation → OK

Output

The classic loop bug

JavaScript

const withVar = [];
for (var i = 0; i < 3; i++) withVar.push(() => i);
console.log(withVar.map((f) => f()));

const withLet = [];
for (let j = 0; j < 3; j++) withLet.push(() => j);
console.log(withLet.map((f) => f()));

Output

[ 3, 3, 3 ]
[ 0, 1, 2 ]

var i is one variable shared by every closure (it is 3 when they run). let j creates a fresh binding per iteration, so each closure captures its own value.

Naming rules

Letters, digits, _ and $; cannot start with a digit; case-sensitive (name ≠ Name).
Reserved words (class, return, new…) cannot be names.
Conventions: camelCase for variables/functions, PascalCase for classes, UPPER_SNAKE_CASE for true constants.

What is the difference between var, let and const?

Are let and const hoisted?

The three declarations

Block scope vs function scope

const means constant binding, not immutable value

Hoisting and the Temporal Dead Zone

The classic loop bug

Naming rules

`const` means constant binding, not immutable value