Nonsense. Revisionism at its finest.
But that's an argument I made in a different blog post: http://davidwalsh.name/for-and-against-let
> It would be nicer to have real, deep immutability, but `const` isn't it.
Yep, agree with you on that. That was one of the main points of my post.
> Because `const` requires to be initialized at the time of definition, you know the variable is valid for its entire lifetime.
No, that's where you're mistaken. All you really know is that the variable assignment is reliable. If the assignment happens to be of an immutable value, great.
But given the choice between these two guarantees:
1. The assignment is immutable
2. The value is immutable
(1) is almost pointless -- and a quick scan of your small block where it's scoped will verify that or not.
(2) is the absolute important one.
`const` masquerades as (2) when it's really only (1). That's what I don't like about it.
Well you didn't really succeed. Your argument against using const comes down to "someone might violate expectations or remove the word const, so let's not even try". I don't agree with that.
Traditional constants are used to show that nothing changes in large swaths of code; showing how much benefit you get in a standalone 12 line function is not meaningful.
Also, calling function scoping bad is not revisionism. That is not a new idea, and does not depend on 'let' existing.
Edit: And the the article you linked about let is saying so many ridiculous things I won't even try to respond to it, but jeez. 'implicit'
You did an absolutely horrible job of summarizing even remotely what my argument was, so I guess "I won't even try to respond to" this, since you either can't critically read or didn't care to this time. jeez.
I don't care to argue about 'let' because this is a post about 'const'. I was writing a rebuttal in the previous comment but realized it was way too off-topic. But your definition and reasoning for "implicit scope" hurts me to read.
If before ES6, then if you could explain your reasoning more I'd be interested to hear it. I use var regularly, but would be happy to be re-educated.
`var` is broken. Don't try to find a use-case for it. Just don't use it.
It would be nicer to have real, deep immutability, but `const` isn't it. Therefore, use it for what it actually is, not what you wish it was. If you don't intend to reassign a reference, then mark the reference constant. That's it.
It may be surprising, but it's quite easy to write JS where almost every declaration is `const`. When every mundane variable is `const`, then the more complex initializations/data flows/accumulators really requiring `let` stand out, which is very useful for reviewing code ("let" = "warning: there may be an `else` or missing `switch` case that will leave that undefined").
Because `const` requires to be initialized at the time of definition, you know the variable is valid for its entire lifetime. When you find its value was wrong, there's only one place where the value could have come from (you don't need to comb the function to look for reassignments).