What is the use case for var in ES6?

Question

If the let keyword introduces a proper implementation of block scope, does var any longer have a use case? I am looking at this from a software design standpoint rather than a syntactical, "well you could" standpoint.

Answer 1

If the let keyword introduces a proper implementation of block scope, does var any longer have a use case?

There could be one use case: let declarations in global scope don't create a property on the global object. Example:

"use strict"; // for chrome
var foo = 42;
let bar = 21;
console.log('window.foo (var)', window.foo); // 42
console.log('window.bar (let)', window.bar); // undefined

From 8.1.1.4 Global Environment Records

The object Environment Record component of a global Environment Record contains the bindings for all built-in globals (clause 18) and all bindings introduced by a FunctionDeclaration, GeneratorDeclaration, or VariableStatement contained in global code. The bindings for all other ECMAScript declarations in global code are contained in the declarative Environment Record component of the global Environment Record.

However, this can also easily be solved by creating an explicit global variable using by assigning to the global object directly:

window.foo = 42;

This would also be the only way to create global classes btw, because the class declaration has the same behavior.

(Note: I'm not advocating the use of global variables)

---

There are syntax constructs where you can only use var, but that's more a consequence of the how the spec evolved and doesn't really serve any practical purpose. For example:

if (true)
  var foo = 42; // valid but kind of useless or bad design

// vs

if (true)
  let foo = 42; // invalid

---

Block scope is not the only useful feature though. The temporal dead zone is another handy feature to find bugs more easily. Compare:

var foo = 42;
function bar() {
  console.log(foo); // undefined
  var foo = 21;
}
bar();

// vs

var foo = 42; // or `let`, doesn't matter
function bar() {
  console.log(foo); // ReferenceError, temporal dead zone
  let foo = 21;
}
bar();

You get a reference error when trying to access a let variable that wasn't initialized yet.

Answer 2

let can't be used in global scope yet. var can.

This is what you get from Chrome when you try a global let outside of strict mode:

Block-scoped declarations (let, const, function, class) not yet supported outside strict mode

Answer 3

Practically there may be some use-cases.

1. Declare variable in try-catch like so:

try {
    //inits/checks code etc
    let id = getId(obj);

    var result = getResult(id);
} catch (e) {
    handleException(e);
}

//use `result`

With let the result declaration would be before try, - a bit early and out of context.

2. Same for conditional declarations:

if (opts.re) {
    var re = new RegExp(opts.re);
    var result = match(re);
    if (!result) return false;
}

// result is available here

With let this code would be forced to complain "good style", though that might be impractical.

3. Loop block:

for (var x = 0; x < data.width; x++) {
    if (data[x] == null) break;
    //some drawing/other code
}

//`x` pointing to the end of data

Some may consider that untidy, I myself prefer lets, but if code I already has vars - that's natural to keep using them.

Answer 4

You can use var if you want to deconstruct something into the function scope, for example a conditional:

if (Math.random() > 0.5)
  var {a,b} = {a: 1, b: 2}
else 
  var {a,b} = {a: 10, b: 20}

// Some common logic on a and b
console.log(a, b)

With let you would have to write something like

let result;

if (Math.random() > 0.5)
  result = {a: 'foo', b: 'bar'}
else 
  result = {a: 'baz', b: 'qux'}

// Using const might make more sense here
let {a, b} = result; 
// Some common logic on a and b
console.log(a,b)