How to check if a variable is undefined versus it is undeclared in javascript?

Question

I know that to find if a variable is undeclared in javascript, I can use if (typeof variable === 'undefined'). If I declare a variable as undefined (var variable = undefined), the if statement still returns true. Is it possible, in JavaScript, to find the difference between undeclared variables and variables with a value of undefined? I know that they are similar, but doing const variable = undefined and then variable = "something else" will throw an error, so they must be different.

const variable = undefined

if (typeof variable === 'undefined') {
  console.log('"variable" is undefined')
}

if (typeof undeclaredVariable === 'undefined') {
  console.log('"undeclaredVariable" is undefined')
}

I wouldn't like to use a try catch block because I want to be able to assign another constant based on this. I would like a solution like this: const isVariableDeclared = variable === undeclared, except undeclared does not exist in javascript. I know I can use let with a try catch block but am looking for something more elegant.

Embrangle

It's not totally clear what you're asking. But what you call undefinedVariable in your example is better described as undeclared rather than undefined. You can tell these, in a sense, because any reference to them except for the typeof operator will throw a ReferenceError. – Succotash

it is not possible. it exists only one undefined. – Miliaria

Does this answer your question? How to unset a JavaScript variable? – Bourgeon

Use a 'try catch' to reference the variable. I think that's the only way to check if a variable is declared. – Busyness

There isn't one, except that if you use a variable you haven't declared in anything other than an assignment expression or the typeof operator your code won't run and you will get a ReferenceError. – Farber

Using typeof vs === to check undeclared variable produces different result – Vetter

From the example you shown, did you mean undeclared? – Atrabilious

@Ava I mean undeclared and have edited the question. – Embrangle

@ThomasSablik No, I am asking what is the difference instead of how to change a variable to undeclared. – Embrangle

@nthnchu ... regarding the last sentence within the OP's explanation ... "... but doing const variable = undefined and then variable = "something else" will throw an error, so they must be different" .. one can not reassign a constant in JavaScript . – Squatter

@PeterSeliger I know, I was trying to show that it wasn't the same as undeclared. – Embrangle

@ThomasSablik I already knew how to delete a variable. Is there something I don't understand about the other question that relates it to this one? – Embrangle

Use an object to define it and check if the object has the own property inside, maybe that's the only way if try catch does not satisfy you – Sibeal

I think I see what you're saying (window.hasOwnProperty("variableName")). That only works for variables declared with var, however. You should promote that to an answer, though. – Embrangle

@nthnchu Not quite. This may be a purely theoretical question; but in real code, you should always know if a variable is declared or not. It should never be unknown; it should never be a surprise whether a variable is declared or not. The suggestion was to use an object instead, i.e. const object = {}; and set properties on it, e.g. object.var1 = "something"; Checking whether var1 and var2 exist looks like this: object.hasOwnProperty("var1") and object.hasOwnProperty("var2"), which yield true and false, respectively. – Facient

Answer 1

At least in the time of writing... No, it does not seem that you can do something like this:

var a = undeclared(var) ? 'undeclared' : 'undefined'

The reason is that you cannot pass an undeclared variable to a function; It raises an error, even in non-strict mode.

The best we can do, is this:

var barIsDeclared = true;

try { bar; }
catch (e) {
  if (e.name == "ReferenceError") {
    barIsDeclared = false;
  }
}

console.log(barIsDeclared);

Why?

Undefined: It occurs when a variable has been declared but has not been assigned with any value. Undefined is not a keyword.

Undeclared: It occurs when we try to access any variable that is not initialized or declared earlier using var or const keyword. If we use ‘typeof’ operator to get the value of an undeclared variable, we will face the runtime error with return value as “undefined”. The scope of the undeclared variables is always global.

For example:

• Undefined:

var a;
undefined
console.log(a) // Success!

• Undeclared:

console.log(myVariable) // ReferenceError: myVariable is not defined

When we try to log an undeclared variable, it raises an error. Trying to log an undefined variable does not. We make a try catch to check for just that.

'use strict'

Worth mentioning that adding 'use strict' in your code verifies that no undeclared variable is present, and raises an error if one is present.

function define() {
 //'use strict' verifies that no undeclared variable is present in our code     
 'use strict';     
 x = "Defined";  
}

define();

ReferenceError: x is not defined

Further reading:

• Checking if a variable exists in javascript
• What are undeclared and undefined variables in JavaScript?
• JS Interview Question: What’s the difference between a variable that is: null, undefined or undeclared?
• JavaScript check if variable exists (is defined/initialized)
• Strict mode

Teador

Good answer, and while it's not exactly an ideal solution it helped me come up with one that worked for my purposes. – Embrangle

Answer 2

As others already did point to, the OP might want to distinguish between declared but undefined references and undeclared reference names ...

let declaredButUnassignedAndStrictlyEqualToUndefinedValue;
const declaredAndHavingAssignedTheUndefinedValue = undefined;

// There is no way of telling the above two (un/)assignements appart.

console.log(
  '(declaredButUnassignedAndStrictlyEqualToUndefinedValue === declaredAndHavingAssignedTheUndefinedValue) ?',
  (declaredButUnassignedAndStrictlyEqualToUndefinedValue === declaredAndHavingAssignedTheUndefinedValue)
);


// the `typeof` operator is of no help
// if it comes to distinguish between
// declared but undefined references
// and undeclared reference names ...

console.log(
  'typeof notDeclaredWithinScope :', typeof notDeclaredWithinScope
);

// ... just a try catch can do that.

try {
  notDeclaredWithinScope;
} catch (err) {
  // console.log(err.message);

  console.log('`notDeclaredWithinScope` does not exist within this scope.')
}

.as-console-wrapper { min-height: 100%!important; top: 0; }

Squatter

I'm looking for another way different than try catch. Good answer though, and I'll accept it if no one has another way. – Embrangle

@nthnchu ... As long as one is dealing with variable names as described by the original Q there will hardly be another approach. There are other, more elegant, solutions if one was allowed to only focus on property names and context. – Squatter

Answer 3

I understood what your saying. There is no defined way to get the exact answer but there is a way to find whether it is defined or not. It is possible only if it referenced somewhere.

Eg: // Lets think x is not defined

x.substring(1);

Output: ReferenceError: "x" is not defined

So if you use try catch block method, with the help of catch error message you can identify whether it is defined or not!

Byrdie