const prevents rebinding a name but doesn't affect the variable's mutability.
const foo = {};
foo = 42; //not allowed
foo.bar = 'baz'; //this is fine const foo = {};
foo = 42; //not allowed
foo.bar = 'baz'; //this is fineIt’s the same behaviour in many other languages.
Why would rebinding variables ever be a good thing?
const fixed the pointer but don't prevent user change the value in the storage it point to.
It is possible to define a pointer to an object whose contents may not be changed. This is done with ‘const * type object’.
If you want a pointer whose value must not change, but do not care about the contents of the pointed to object, you would write ‘type * const object’.
Of course, in C++ there are const references as well, and in this case const also means you can't modify the referenced object (in any case in C++ you can never re-bind a reference).
This is a pointless discussion.
const x = {immutableValue}
That tells me the thing is fully immutable. Whether it’s a global variable or not, that’s still nice to know when reading the code! Likewise:
let x = {immutableValue}
const x = {mutableValue}
These tell me different things. The first tells me I should look out for re-assignment, the second that I should look out for mutation of the value.
In contrast, this:
let x = {mutableValue}
Clearly has the most cognitive load. Anything could happen with this. If it’s a bigger, more complex function/whatever, “what happens to x, it could be anything” is just one more thing to fit in my head as I try to figure out what this code does. Enough little uncertainties like this, and I have to give up understanding by reading entirely, and resort to a debugger. Had the author limited the scope of what was possible, it’d be a bit easier to understand, with really no drawbacks. It’s not the end of the world, but “small, simple, easy thing I can do to make the code easier to understand for future readers” ... why not do that?
Likewise, I'm saying that a minority is vocal because reading a rant from a OSS celebrity either reaffirms their preconceptions or sways them through aggressiveness (both of which are objectively true, as I have witnessed cases of both), but you're accusing me of projecting (presumably because you think that I'm making a claim about you personally - which is not true).
Consider that some of the words you use are weasel words ("overusing", "fad"), which, IMHO imply a tautology (i.e. "I think X, therefore X", as opposed to "The facts are X, therefore Y"). I originally said that the spec is clear about what const and let are. Implying that following the spec is a fad is needlessly derogatory and doesn't address the double standard with regards to the confusing-ness of const vs let.
const foo = #{};
foo = 42; //not allowed
foo.bar = 'baz'; //not allowed