In JavaScript, why should I usually prefer 'const' to 'let'?

Question

Why most of the time should I use const instead of let in JavaScript? As we know if we use const then we can't reassign value later. Then why not use let instead of const?

Answer 1

Basically,

• use let if the variable's value will change during the code
• use const if it won't and you / your team want to use const in those situations in the project you're working on; it's a matter of style

If you do use const, then it's surprising how often it turns out that the guidelines above mean you use const because you end up not needing to change a variable's value (if you're following the usual rules of keeping your functions of reasonable size and such). (Well, it surprised me, anyway...)

Using const when the variable's¹ value is not meant to change accomplishes a few things:

1. It tells others reading your code that you don't intend the value to change.

2. It gives you a nice proactive error if you change the code so it writes to that variable. (A decent IDE can flag this up proactively, but if not, you'll get the error when running the code.) You can then make an informed, intentional decision: Should you change it to let, or did you not mean to change that variable's value in the first place?

3. It gives a hint to the JavaScript engine's optimizer that you won't be changing that variable's value. While the engine can frequently work that out through code analysis, using const saves it the trouble. (Caveat: I have no idea whether this is actually useful to the JavaScript engine. It seems like it would be, but runtime code optimization is a very complicated and sometimes non-intuitive process.)

---

¹ Yes, it's funny to use the term "variable" to refer to something that by definition doesn't vary. :-) The specification's term is "binding," but I bet you won't hear people talking about "bindings" in everyday conversation anytime soon... So the aggregate term will probably remain "variable" except when we can specifically refer to something as a "constant."

Answer 2

Using const by default is essentially a matter of programming style. However there are pros and cons to each:

Arguments in favor of using const by default

The arguments in favor of using const by default are the following:

1. It avoids side effects caused by involuntary reassignments;
2. During a code review, it removes an uncertainty, because the developer who sees a const variable can count on the certainty that it will not be reassigned;
3. Maybe we could say it is more consistant with functional programming and immutable states.
4. With TypeScript, there are some cases with better inferences.

Here is an example of advantage when using const with TypeScript:

const hello = "Hello" as string | undefined
if (hello !== undefined) {
    ["A", "B"].forEach(
        name => console.log(`${hello.toUpperCase()}, ${name}`) // OK
    )
}

With let, in strict mode, TypeScript detects an error:

let hello = // …
// …
        name => console.log(`${hello.toUpperCase()}, ${name}`)
//                             ^__ error here: Object is possibly 'undefined'.

Arguments in favor of using let by default

I summarize here the article Use “let” by default, not “const” that gives arguments in favor of using let by default rather than const:

1. Re-assignment is not a dangerous thing, it is just... usual;
2. If a variable could be reassigned, then it should be declared with let, because it is more expressive to reserve const for real constants;
3. const is misleading because it doesn’t stop references being modified;
4. It is two more characters to write and to bundle;
5. Using const by default is inconsistant with function parameters;
6. There is no performance gain to use const.

Answer 3

You can use const when you want to declare a non-editable variable.

Meanwhile let is used when you have an editable variable.

It also can be used for variable scoping.

See : let and const

---

Why we use const most of the time?

Because the const declaration creates a read-only reference to a value (cannot be reassigned).

It prevents us to be confused with the value of the variable.

Answer 4

Using const instead of let has a few benefits:

• Readability: It signals to other developers that the value of the variable will not be changed once it's assigned. This makes the code easier to read and understand since the reader doesn't have to worry about the value being reassigned somewhere else in the code.

• Security: When you use const, the value cannot be accidentally or intentionally reassigned. This can help prevent bugs or malicious code from changing the value of the variable.

• Performance: const can also help the JavaScript engine optimize the code by knowing that the value will not change.

That being said, const should be used only for values that will not change throughout the execution of the program. If you need to reassign a variable later on, you should use let.

Answer 5

I use var for everything, can't see any benefit to let or const at all, except maybe let in rare cases when it comes to variable naming.

var can be re-assigned and hoisted, which is great if you're using callbacks.

The main reason though is flow:

• Using the same for everything reduces the cognitive load.
• Arguably more readable code.
• And you never have to go back and change your const to a let every time you change your mind about requirements.
• In the case of const, it's one character more, making your scripts slower and taking longer to type.
• var can be written with one hand, as opposed to let, but not sure if it's actually faster to type.

If I want something to be read as a constant, I use all caps:

var PI = 3.14

The over use of const is confusing as it's used when things are read only, but not necessarily constants. If I couldn't use var for some reason, I'd just go with let 100%.