Despite ES6, are there instances when var is the most appropriate keyword to use?

Question

I'll try to make this concise...

With all the ES6 hype, I feel like using the var keyword is becoming more and more frowned upon by the JS community at large. Due to this (perceived) general consensus, I've been getting in the habit of avoiding using var in lieu of the newer const and let keywords for creating variables.

Below is an example of a block of code I wrote where I couldn't use const because I wanted to redefine a variable. I was also using async / await so all the code was in the same block-level scope, which apparently prevents you from redefining let variables either. So my only option was to use var (or create yet another let variable).

Here's the code. Saving a new user account to a MongoDB via Mongoose...

router.post('/signup', async (req, res, next) => {
  const { email, password } = req.body;

  const user = await userModel.findOne({ email });
  if (user) { res.send('Email already in use.'); return; }

  // here is where the issue occurs - use var instead?
  let newUser = new userModel({ email, password });
  let newUser = await newUser.save();

  console.log(newUser); // just checking everything works

  res.send({ message: 'New user account created!' });
});

MDN mentions this behavior... with just ONE SENTENCE! That's not helpful. :( And then they go on to discuss hoisting behavior, which isn't my issue, or at least I don't see how that's related. MDN Source Here.

So in conclusion...

• Is this an example of an instance when var would be the most appropriate keyword to use?

• If this isn't a time for using var, is there any instance when var is the most appropriate keyword to use, even in the age of ES6 (7, 8, etc)?

Disclaimer: I know I don't absolutely need to save those variables, but in my opinion, it's worth the trade off to write slightly more verbose code that's also more readable and understandable. I'm fine with using var, I just though this was an interesting case.

Answer 1

There is no reason to ever use var in ES6. const should be your default. The only reason to use let over const is when you want to reassign the variable later in the same block. In that case you don't declare it again, just assign the new value to it:

let newUser = new userModel({ email, password });
newUser = await newUser.save();
// allowed to reassign because `newUser` is not `const`

Depending on what save does, I suspect you could just do:

const newUser = new userModel({ email, password });
await newUser.save();

newUser.save(); should reject the Promise it returns if the save failed, which await will convert to a thrown error. So there should be no question about whether or not the save succeeded in the code after that await. If those lines are reached, the save succeeded.

Answer 2

This is not the matter of using let , var, or const.
Within the same scope a variable name cannot be declared more than one time, or you will get the following Error; SyntaxError: Identifier 'newUser' has already been declared
You can declare once and assign value as many as you want.
let newUser = new userModel({ email, password }); newUser = await newUser.save();

Answer 3

var usage is often restricted in linter rules because it's prone to be misused in ES6. This isn't a valid case for var. As another answer mentions, the variable should be reassigned, not redeclared:

  let newUser = new userModel({ email, password });
  newUser = await newUser.save();

The only valid case for var in ES6 is to define a global in top-level scope:

<script>var FOO = 1;</script>

let and const will result in Identifier has already been declared error if a variable was defined multiple times for some reason:

<script>let FOO = 1;</script>
...
<script>let FOO = 1;</script>

And if (typeof FOO === 'undefined) safeguard isn't applicable because it creates block scope.

This is applicable to browser scripts only. Node.js scripts are evaluated in module scope.

Alternatives may involve referring this (in loose mode) or window properties.