Is there any reason to use the “var” keyword in ES6?
https://softwareengineering.stackexchange.com/questions/274342
-
07-10-2020 - |
Question
Babel's guide to ES6 says:
let
is the newvar
.
Apparently the only difference is that var
gets scoped to the current function, while let
gets scoped to the current block. There are some good examples in this answer.
I can't see any reason to use var
in ES6 code. Even if you want to scope a given variable to the whole function, you can do so with let
by putting the declaration at the top of the function block, which is what you should be doing with var
anyway to indicate the actual scope. And if you want to scope something more finely in an for
block or something, then you can do that too.
So my instinct is to stop using var
altogether when writing ES6 code.
My question is, am I wrong about this? Is there any legitimate case where var
would be preferable over let
?
Solution
Doug Crockford discusses let
at this point in his talk, "The Better Parts".
The point is, let
avoids a source of misunderstanding, esp. for programmers with expectations set by languages with block-scope. A var
has function scope (it declares a variable that's visible throughout the function) even though it looks like it has block scope.
var
might possibly still be useful in an extreme case like machine-generated code, but I'm stretching hard there.
(const
is also new and has block scope. After let x = {'hi': 'SE'}
you can reassign to x
, while after const y = x
you cannot reassign to y
. That's often preferrable since it keeps something from accidentally changing out from under you. But to be clear, you can still modify the object y.hi = 'SO'
unless you freeze it.)
Realistically, your impression is right on for ES6: Adopt let
and const
. Stop using var
.
(In another performance of "The Better Parts", Doug says why ===
was added rather than fixing the problems of ==
. ==
produces some "surprising" results, so just adopt ===
.)
A Revealing Example
Mozilla Developer Network gives an example where var
does not work as intended. Their example is a realistic one that sets onclick
handlers in a web page. Here's a smaller test case:
var a = [];
(function () {
'use strict';
for (let i = 0; i < 5; ++i) { // *** `let` works as expected ***
a.push( function() {return i;} );
}
} ());
console.log(a.map( function(f) {return f();} ));
// prints [0, 1, 2, 3, 4]
// Start over, but change `let` to `var`.
// prints [5, 5, 5, 5, 5]
var
trips us up because all loop iterations share the same function-scoped i
variable, which has the value 5
after the loop finishes.
Another Telling Example
function f(x) {
let y = 1;
if (x > 0) {
let y = 2; // `let` declares a variable in this block
}
return y;
}
[f(1), f(-1)] // --> [1, 1]
// Start over, but change `let` to `var`.
// --> [2, 1]
let
declares block-scoped variables.
var
confuses us by referring to the same variable throughout the function.
OTHER TIPS
If you have been writing correct code, you will probably be able to turn all var
statements into let
statements without any semantic changes.
let
is preferable to var
because it reduces the scope in which an identifier is visible. It allows us to safely declare variables at the site of first use.
const
is preferable to let
. Unless you need to mutate a reference, use a const
declaration. This has all the benefits of let
, along with reducing the presence of uninitialized variables and making code generally easier to reason about. If you aren't sure if you will need to mutate a reference, declare it const
until you find yourself explicitly needing to mutate it, then declare it as let
.
I don't necessarily think you're wrong but there are caveats to using var. Essentially, let
should help developers get around JavaScript's stupidity, particularly with naming conflicts. var
, it seems, has a larger scope since it wants to go to the closes function scope. There will be times when you need var, like when you need a temp variable to be available within the scope of a block inside of a function, otherwise, preferring let
over var will help developers with naming conflicts. On a lighter note, it's about time that ES6 introduced let
.
I tend to agree that only "let" should be used in es6. AFIK, redeclaring a "let" generates an error (which is good), while with "var", you simply override the value (though "strict mode" in es5 takes care of that too).
let
means "let variable equal". It's a declaration, in other words, an initialization and assignment.
It exists in contrast to const
which of course means "constant" -- which is the opposite of variable.
Some other languages use a prefix to the actual object instead of the object when declaring it (e.g. def
is a shorthand for "define function" -- completely missing the point of what is being "def".
Let
adds this semantic inconsistency to Javascript.
Logically, you could let a constant equal something as well, since the job of the "let" keyword is to assign memory.
The problem arises because the var
keyword was introduced before const
was supported, so backwards compatibility dictates that var
doesn't necessary mean a variable. (It could also be used to assign a constant value.)
Hence, the introduction of let
in the wrong position. To make sure that we remember that lexically, this is wrong, they also decided to change the lexical scope of let
vs var
, so the inconsistency is foremost in our minds when debugging.
In other words, let
exists because people (meaning the language maintainers) thought that Javascript was too consistent, having mastered all it's idioms and idiosyncrasies, desire more.
Side note, var
does not work in "arrow" blocks if you want to treat said blocks as closures (because var
was introduced before treating blocks as closures), but let
does.