3 reasons to use 'var' in JavaScript

Nonsense! github.com/getify/You-Dont-Know-JS...

And yet I keep seeing it time and time again in tutorials. Sad.

I don't think I hardly ever would take advantage of variable hoisting in this way:

x = 2;

// later:
var x;

I agree that's problematic. But I don't want the language to complain at me, I want a configurable linter to complain at me. That's my objection to these errors. The language doesn't need to be my nanny. I am perfectly capable of choosing what rules I want enforced or not. And if it's a configurable and extensible tool, I can extend it to understand more nuances to when I want to allow disallow things. Once you bake an error enforcement into the language, you force that opinion on everyone, forever.

Moreover, there's many other ways that hoisting (and var) ARE helpful. For example:

try {
   var x = whatever(42);
}
catch (err) {
   var x = "oops";
}

console.log(x);

Here, the try..catch construct is an "accidental" scope... IOW, I never intended it to be a scope. If I use let inside it, it becomes a scope when I don't want it to be. If I use let outside the block statement, I have to separate my declarations from my initial assignments, which I rarely like to do.

Another example:

do {
   var x = whatever(42);
}
while (x < 100);

I generally prefer the loop to be treated like its own scope, but unfortunately, the while condition is not inside that scope, so I need the x to be in an outer scope. But it doesn't make any sense semantically to declare it there, since it belongs to the loop.

And also "function hoisting" is useful, for example in cases like this:

fn = wrapWithSomeBehavior(fn);

// later:
function fn(whatever) {
  // ..
}

There are a variety of other edge cases and uses. But in summary: there are perfectly valid uses of var (or hoisting in general) that are not just stylistic preference or semantic in nature, but also functionally more desired.

We should use var when it's helpful, use let when it's helpful, and (occasionally) use const if we really must.

I teach var first because:

1. It's still out there and I don't want my students seeing it at work and thinking "why didn't my teacher tell me about something so basic?"
2. It behaves differently from let and const and it's completely different to have a pure academic or a "theoretical" understanding of something and having real hands-on (for more than an hour or some tweet's worth of words) experience with something.
3. Knowing about and being competent when dealing with all three is better than knowing about and being competent when dealing with only two of the three (66% is a D, great job).
4. Block scoping is a good transform output to demonstrate when teaching Babel.
5. I ask for let and const to be used later in my curriculum where appropriate.

I don't really know who this article is for, but sadly it seems to encourage ignorance in exchange for cool coins.

Ufff.... I came here hoping that the title was sarcastic, but for a moment in the first paragraph I worried that you were REALLY to defend VAR.... 🤣. Nice writing 👍 and let's all chant "die VAR, die...."

lmaoo your explanation is more complete than the actual article

disclaimer: let me start by saying that this is a very highly contested topic in JS.. with many different people throwing many different reasons for different using any one of these three over the others...

I would put myself quite firmly on the "var is dead! long live var!" bandwagon here... and not just because it leaks out of the current block scope. :p

however, to actually consider the full value of var, you need to keep in mind that it came about long before "block scoping". even just variable hoisting itself was not just one of those weird situations you needed to be aware of, it could be explicitly (ab)used to do some interesting things.. even if these were not considered "good practice", either way-back-when or in the current day.

the most annoying part of many blog posts on this topic, has to be the nature of the coding examples given: where something will be shown leveraging the default behaviour of let (with it's block scoping restriction), then followed up with an overly verbose and borderline hacky implementation of the same final result using var... and to top it off, this is all this before we even start on the accompanying changes introduced in ES6, since that is the real core of this eternal var vs let/const debate..

--

topics like this feel akin to comparing a water bottle with a water tanker; they both hold liquid, they can both be opened and closed, they can both be moved, etc. etc., but they do so at different levels, in different ways, for different reasons.. so can we really compare them directly?

for variable assingment, we now have three different ways to assign something to a variable name. use the one that fits your needs, change it if you need to, and carry on with life. that's all there is to it.

at the end of the day, I would not recommend that anybody entirely abandons var, or even avoids let/const... my suggestion is to work at understanding the quirks and gotchas of each, and to use whatever is most appropriate for your current requirements.

@paritho I would suggest you amend your post a little, if for no other reason that to change the last sentence to read:

So please, please, do not use var without carefully considering your current unique use case.

this did make me chuckle, quite loudly if I'm being honest:

var isn't just the parent misunderstanding their teen, it's the great grandparent everyone loves but no one invites to the fun parties.

Two "good" reasons I still use var:

• ~Old projects that need to support IE11 and isnt transpiled.~ Oh, right, even IE11 supports let and const. Well almost, it still have a few gotchas that will never be fixed.
• I'm also writing C# and var is stuck in my fingers. Sometimes I even miss the eslint warnings about it. Darn muscle memory.