This content originally appeared on DEV Community and was authored by Sylwia Laskowska
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
This content originally appeared on DEV Community and was authored by Sylwia Laskowska