If you’re learning JavaScript, one of the first questions you’ll face is:
👉 Should I use const or let?
And what’s up with this old thing called var?
It sounds simple, right?
But trust me — as a senior dev who’s done countless code reviews and technical interviews, I can tell you:
this is one of those “obvious” things that many developers still get wrong. 😅
So let’s break it down — clearly, practically, and once and for all. 🚀
🔒 const — constant, but not always frozen
When you use const, you’re saying:
“This variable name will always refer to the same thing.”
Example:
const name = "Alice";
console.log(name); // Alice
name = "Bob"; // ❌ TypeError
You can’t reassign a const.
But here’s a fun twist: if it’s an object or array, you can still change its contents 👇
const numbers = [1, 2, 3];
numbers.push(4); // ✅ works
console.log(numbers); // [1, 2, 3, 4]
numbers = [0]; // ❌ can't reassign
💡 const doesn’t make the value itself immutable — only the reference (the “box label”) is fixed.
If you truly need immutability, use Object.freeze(), but note it’s shallow.
✅ Use const by default.
It keeps your code predictable and self-documenting — if something shouldn’t change, make it const.
🔁 let — for things that change
When you do need to reassign a variable, go for let:
let counter = 0;
counter = counter + 1;
console.log(counter); // 1
You can also use let inside blocks (if, for, {}):
if (true) {
let message = "Hello!";
console.log(message); // works here
}
console.log(message); // ❌ ReferenceError
That’s because let is block-scoped — it only exists inside the { } where it was declared.
🧩 Bonus fact:
Both let and const are hoisted, but they live in the Temporal Dead Zone (TDZ) until the code reaches their declaration.
That’s why accessing them too early throws a ReferenceError:
console.log(x); // ❌ ReferenceError
let x = 5;
🚫 var — the old-school way (for history lovers)
Before 2015, JavaScript only had var.
It kind of works like let, but with some weird, legacy behaviors.
Example:
if (true) {
var name = "Charlie";
}
console.log(name); // ✅ still works outside the block!
That’s because var has function scope, not block scope.
You can even access it before the declaration, due to hoisting:
console.log(a); // undefined
var a = 10;
And here’s what function scope really means:
function test() {
if (true) {
var greeting = "Hi!";
}
console.log(greeting); // ✅ "Hi!"
}
test();
console.log(greeting); // ❌ ReferenceError
🧓 Nowadays, we use let and const instead — but it’s still good to know what var does.
You’ll definitely encounter it in older codebases.
🧠 Quick Summary
| Keyword | Can Reassign? | Scope | Hoisted? | Use It? |
|---|---|---|---|---|
const | ❌ No | Block | ✅ (TDZ) | ✅ Default |
let | ✅ Yes | Block | ✅ (TDZ) | ✅ When value changes |
var | ✅ Yes | Function | ✅ (initialized as undefined) | 🚫 Avoid (legacy) |
💡 Pro Tip
In modern JavaScript projects (especially with ESLint), you’ll often see a rule that says:
“Use const wherever possible.”
That’s not dogma — it’s good hygiene.
It keeps your codebase more predictable and helps tools catch bugs early. 🧘♂️
🏁 Wrap Up
So, in short:
🟢 Use const most of the time
🟡 Use let if you really need to change the value
🔴 Avoid var unless you’re maintaining ancient code
Keep your variables tidy, your scope clear, and your code modern! ✨
💬 Your turn:
Do you ever still use var?
Or maybe you’ve seen a weird hoisting bug in the wild?
Drop it in the comments — let’s swap battle stories 👇