const, let or var: Which should I use?
Last updated: September 18, 2021.
Javascript provides three different ways to declare a variable: const
, let
and var
.
A quick spoiler: there is no correct answer here. Each one functions differently and can thus be used in a different context. But, in general, const
and let
, which were introduced with in ES6 (2015), are preferred over var
in modern scripts where possible.
Once upon a time, there was only ‘var’
Prior to the introduction of const
and let
with ES6 in 2015, it was only possible to create a new variable using var
.
var
is in fact very flexible. For example, unlike const
and let
, it can be redeclared and Javascript will not throw and error. The second declaration simply overwrites the first.
var testVariable = "Some text" alert(testVariable) var testVariable = "Some other text" alert(testVariable)
A second important difference is scope. A variable declared outside a function with var
has global scope. This includes inside a for
loop or a conditional if
statement:
if (true) { var message = "Message from inside a function"; } alert(message) // Message from inside a function
for (var i = 0; i < 10; i++) { var message = "Message from inside a for loop"; } alert(i); // 10 alert(message); // "Message from inside the for loop"
Only inside a function is var
variable restricted in scope:
function sendMessage() { var message = "Message from within the function" } alert(message) // Undefined
At first glance, the flexibility of redeclaring variables and global scope outside of functions can seem to be an advantage. However, it also creates the possibility of errors and bugs in our code. For example, we may want Javascript to throw an error to alert us to the fact that we are about the overwrite a varibable. And though variables with global scope are accessible, we may not always need this. And when we don’t, using var
creates an unnecessary clutter of globally available variables, creating the risk of bugs due to scope leakage.
Using ‘let’ and ‘const’
let
and const
were introduced with ES6 (2015) to overcome this issue.
Once a variable is declared with let or const, it cannot be declared again. If we try this with either, Javascript will throw an error:
const testVariable = "First declaration" const testVariable = "Second declaration" // Error is thrown alert(testVariable) // Not read
And both have block scope. For example, if we use them inside a for loop, they are not available then outside of it:
for (let i = 0; i < 10; i++) { const message = "Message from inside a for loop"; } alert(i) // Undefined, stops code alert(message) // Also undefined, would stop code
They are also not available outside a conditional if statement:
if (true) { const message = "Message from inside a function"; } alert(message) // Message not defined
When used in a function, they are also, like var, limited to use within the function.
The difference between ‘let’ and ‘const’
As a rule of thumb, let
is used when the values inside it are expected to change. For example, we use let
when declaring a looping variable. If we tried this using const
, Javascript would throw an error:
for (const i = 0; i < 10; i++) { // fails on the first line! const message = "Message from inside a for loop"; } alert(message)
In this way, let
is much more flexible as it is possible to reassign its values. This makes a little bit like the modern equivalent of var
, though with more limited scope and the throwing of an error when trying to overwrite a previously declared variable.
On the other hand, const
should be used when variable values are not expected to change. Though this is possible to a limited extent, the values of the const
variable cannot be reassigned. Thus, a good rule of thumb is to use const when we want values to remain the same:
let days = ["Mon", "Tue", "Wed", "Thu", "Fri"] alert(days) // "Mon,Tue,Wed,Thu,Fri" days = ["Sat", "Sun"] alert(days) // "Sat,Sun"
const days = ["Mon", "Tue", "Wed", "Thu", "Fri"] alert(days) // "Mon,Tue,Wed,Thu,Fri" days = ["Sat", "Sun"] // Error occurs here. Code stops executing alert(days)
Conclusion
There is no ‘correct’ answer to the question of when one should use let
, const
and var
. However, it is increasingly considered best practice to use let
and const
over var
in modern scripting due to their strict behavioural properties and thus potential to catch bugs in longer scripts. However, var
still remains a popular choice amongst some developers due to its flexibility.
So, when writing new scripts for scratch, we recommend let
and const
. But it is still important to be familiar with var and its behaviour, especially when working with older scripts.