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.

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.