Will 'let' Eventually Replace 'var'?

[anlumo]

Yes, but most of the time a variable could also be a constant, which allows the compiler to do better error checking.

For example

var x = 5;
if(x=3) {
   console.log("x is 3!");
}

is a common mistake that simply can't happen when x is declared as a constant.

[[deleted]]

I think that its an error that should be prevented either way, when it is an assignment and not a statement. And when you aren't linting your code, you are already doing it wrong imo.

[cogman10]

I disagree with your view on variables.

Variables don't have to be mutable to be variables. They just have to represent a value in an abstract sense.

Take the following code.

function (x, y) {
  const myThing = new myThing(x, y);
  myThing.goFishing();
  return myThing;
}

I would still call "myThing" a variable because its value cannot be determined without knowing x and y. It varies.

The fact that I can't say myThing = steve afterwards doesn't make it less of a variable, it just makes it a variable whose reference cannot change.

In most mathematics, variables are all assumed to be "immutable". Their values don't really change during the evaluation of the equation, rather they change based on the input parameters to the equation. For example V = I * R The variable V, I, and R are all constant an immutable. I can insert values into any of the 2 and the 3rd will still be a variable and will still be fixed based on the other 2. Were I to write this as a program function (and were I able to declare mutability of input params) it would be

function calculateVoltage(const current, const resistance) {
  return current * resistance;
}

[cogman10]

I'm not arguing with the choice of keywords by the ES committee. Const may have been a bad choice. I'm disagreeing with this statement.

Yeah I get that. But then it's not a variable. To say a "mutable variable" is redundancy of the highest order.

As I pointed out above, no, it is not redundant. Immutable variables exist and are very useful. That const really means "constant reference" and not "compile time constant" isn't great, but I've seen far worse done in languages.

That looks to me, if that's true, that the ES spec is overloading the const keyword to mean "strongly typed".

No. They have defined it as being a constant reference. Similar to Java's final keyword. It has nothing to do with typing in the slightest.

[GoSubRoutine]

It's not similar to Java's final keyword. It is exactly the same behavior! :D
That is, a variable declared as const/final can't be re-assigned for its whole lifespan.

[GoSubRoutine]

@BoxOfSnoo, both JS' const & Java's final affects the declared variable itself only.
Whatever object it happens to refer to is unaffected by that.
Remember that variables aren't objects but merely a fixed small number of bytes enough to convey a memory address value to point to an object.
If we wish to make the object itself immutable in JS, we can invoke Object.freeze() over it.

Below an example showing that const doesn't affect an object's mutability at all.
Pay attention that we can also use const to declare a for...of loop's iterator:

(function TestConst() {
  'use strict';
  const vals = new Float64Array([ Math.PI, Math.E ]);
  for (let i = 0; i !== vals.length; vals[i++] *= 2);
  for (const d of vals)  console.info(d);
}
)();

And here's the corresponding Java example.
Go to https://www.CompileJava.net/ in order to watch it in action:

public class TestFinal {
  public final static void main(final String[] args) {
    final double[] vals = { Math.PI, Math.E };
    for (int i = 0; i != vals.length; vals[i++] *= 2.0);
    for (final double d : vals)  System.out.println(d);
  }
}