If you’ve ever written JavaScript, you’ve probably encountered the whole “var, let, or const?” dilemma, which is basically JavaScript’s way of saying, “You can do it three different ways, but only one of them is the cool way.” It’s kind of like going to a family reunion where three cousins show up: var, the old and quirky one; let, the cool, modern cousin who’s still figuring out life; and const, the one who’s got it all together but doesn’t let you forget it.

The funny part is that JavaScript isn’t the only language out there, and when you look at how other languages handle variables, you realize JavaScript is throwing a party while the others are just, like, sitting in the corner and quietly doing their homework.

So, let’s explore why JavaScript has three different ways to declare a variable, and compare it to how other languages (like Java, Python, and C++) handle their business. Spoiler alert: JavaScript is like the wild, rebellious teenager of the programming world.

var – The Grandpa of JavaScript

Before the cool kids came along, there was var. Imagine it as your programming grandparent. Sure, it’s been around for ages, but it’s kind of forgotten how to behave in the modern world. var was the original variable declaration in JavaScript, and it has a few odd quirks that make you raise an eyebrow:

  • Function-scoped: var only cares about functions, not the fancy new blocks like loops or if statements. It’s the type of person who refuses to leave the living room and just ignores everything happening outside.
  • Hoisting: Ah, the mysterious concept of hoisting. Variables declared with var get hoisted to the top of their scope, which means they exist before you even declare them. It’s like showing up to a party before the host, sitting on the couch, and waiting for everyone to notice you.
function testVar() {
  console.log(a); // undefined, it’s already at the party, but no one knows it yet
  var a = 5;
  console.log(a); // 5, now that we’ve officially met
}
testVar();

In this example, a is like the invisible guest at a party who’s technically there, but only after everyone finally acknowledges it.

let – The Cool, Modern Cousin

Then came let, the shiny new cousin that arrived in JavaScript with ES6. It’s the one who understands boundaries and rules (sort of). let is block-scoped, which means it behaves like a normal person who stays in their lane, respecting loops, conditionals, and other code blocks.

  • Block-scoped: let doesn’t just wander around aimlessly. It respects the boundaries of where it’s declared. It’s the cousin who knows when to leave the party when things get too weird.
  • No hoisting (well, sort of): While let is technically hoisted to the top of its block, it’s not initialized until the code hits that line. If you try to use it before then, JavaScript gives you the dreaded ReferenceError — like being told, “You can’t sit here!” at a party.
function testLet() {
  // console.log(a); // Uncaught ReferenceError: Cannot access 'a' before initialization
  let a = 5;
  console.log(a); // 5, because now it’s officially been introduced
}
testLet();

Here, trying to access a before its declaration results in an error. This behavior ensures that variables are declared and initialized in a predictable manner.

const - A Constant Value (Introduced in ES6)

const is used to declare variables that should not be reassigned. It provides the same block-scoping behavior as let, but with the added restriction that the variable's value cannot be changed after initialization.

  • Block-scoped: Like let, const is scoped to the nearest block.
  • Constant: Once assigned, a const variable cannot be reassigned to a different value. However, if the variable holds an object, the object’s properties can still be modified.
function testConst() {
  const a = 5;
  console.log(a); // 5
  
  // a = 10; // Uncaught TypeError: Assignment to constant variable.
  
  const obj = { name: 'John' };
  obj.name = 'Jane'; // This is allowed
  console.log(obj.name); // Jane
}
testConst();

In the example, trying to reassign a results in an error, but modifying the properties of the object obj is allowed, demonstrating that const applies to reassignments, not the mutability of objects.

Java, Python, and C++ – The More “Traditional” Cousins

Okay, so now that you’ve met JavaScript’s quirky family, let’s compare them to other languages, which are much more serious about their variable declarations. They’re like that super disciplined cousin who follows the rules a little too closely.

Java

Java is like the well-dressed, high-maintenance cousin who insists on having everything in order. In Java, you must always declare the type of your variables (i.e., int, String, etc.), and there’s no real equivalent to let or const. It’s all about being explicit:

  • Explicit Typing: Java makes you declare exactly what kind of variable you’re working with. No "just throw anything into the box" for them.
  • final for Constants: Java doesn’t have const, but it has final, which does a similar job of making variables unchangeable.

public class Main {
    public static void main(String[] args) {
        int a = 5;
        final int b = 10;

        // b = 15; // Compilation error, 'b' cannot be reassigned
        System.out.println(a); // 5
        System.out.println(b); // 10
    }
}

Python

Python’s like the “go with the flow” cousin who doesn’t really care about type and doesn’t ask questions. You don’t need to declare the type of your variables, and it’s all very dynamic and chill.

  • No type declarations: You just assign a value, and Python figures out the rest.
  • No block-scoping: Python doesn’t worry about your loops or conditionals — if you declare a variable, it’s in the global scope.
a = 5
print(a)  # 5

a = 10
print(a)  # 10

C++

C++ is like Java’s more rebellious cousin — still statically typed, but with a bit more flexibility. You must specify the type of your variables, and it has a const keyword, which is pretty similar to JavaScript’s, though it has a stricter stance.

#include <iostream>
using namespace std;

int main() {
    int a = 5;
    const int b = 10;

    // b = 15; // Compilation error, 'b' cannot be reassigned
    cout << a << endl;  // 5
    cout << b << endl;  // 10

    return 0;
}

Why Does JavaScript Have Three Ways to Declare Variables?

Well, JavaScript is a little... complicated. It’s like that person who has three jobs, five hobbies, and is always on the phone with someone. JavaScript’s var, let, and const exist because it’s a dynamic, unpredictable language that loves options. It’s offering you a buffet of choices so you can do things your way (as long as you’re not using var).

  • Backward Compatibility: var is for the old-school folks who just want to get things done without caring too much about boundaries.
  • Modern Scoping: let and const introduced better scoping rules to avoid all the embarrassing moments var brought to the party.
  • Immutability: const is the programming equivalent of saying, “Don’t touch my stuff!”

Conclusion

In the end, JavaScript is like that quirky, unpredictable cousin who’s always throwing parties and dragging you into the weirdest adventures. It’s got three ways to declare variables because it loves choices and isn’t afraid to shake things up. Meanwhile, languages like Java, Python, and C++ have their own way of getting things done — which might not always be as fun, but it sure is organized.

So, next time you’re staring at var, let, or const, just remember: JavaScript might have a few more options, but at least it’s never boring.

Tagged in:

Javascript

Last Update: April 22, 2025