JavaScript check if variable exists (is defined/initialized)

Asked 2023-09-20 20:32:20 View 339,053

Which method of checking if a variable has been initialized is better/correct? (Assuming the variable could hold anything (string, int, object, function, etc.))

if (elem) { // or !elem

or

if (typeof elem !== 'undefined') {

or

if (elem != null) {
  • if you want to know whether foo is declared, either typeof foo === 'undefined' or typeof foo === typeof undefined - anyone
  • The highly upvoted answers don't work for variables that are declared but have the value undefined. The correct answer is this one: stackoverflow.com/a/36432729/772035 - anyone
  • @Paulpro, the version using hasOwnProperty('bar') doesn't have the same deficiencies as the others, but would require some adjustment for Node (replace window with global). - anyone
  • @Paulpro Indeed, but as I was pondering that before you replied, I came to the conclusion that it's not really a practical problem. When you are dealing with block or function scoped variables, it's usually code you own or have write access to, so you'll have a runtime error in any case which is fixable. Whereas the usual problem with variables that has not beed defined (doesn't exist) usually lies in code outside of your control, so you need a way of detecting it. So it's the 80/20 solution. - anyone
  • @Paul that's not the best answer. You compare to Undefined (without quotes). It's checking the stored value if you use quotes, and checks if you've ever declared it at all if you don't use them. See the actual correct answer below, stackoverflow.com/a/63459003/9008140 - anyone

Answers

You want the typeof operator. Specifically:

if (typeof variable !== 'undefined') {
    // the variable is defined
}

Answered   2023-09-20 20:32:20

  • This looks a good solution, but can you explain why this works? - anyone
  • Actually, you should check that the object is what you need it to be. So that would be if( typeof console == 'object' ) { // variable is what I need it to be } - anyone
  • @George IV: "just do `if( variable ) " -- um, no, that fails for false and 0. - anyone
  • 'if( variable )' also fails for testing for the existence of object properties. - anyone
  • "if (typeof variable !== 'undefined') { // variable is not undefined }" is working for me too... thanks! - anyone

The typeof operator will check if the variable is really undefined.

if (typeof variable === 'undefined') {
    // variable is undefined
}

The typeof operator, unlike the other operators, doesn't throw a ReferenceError exception when used with an undeclared variable.

However, do note that typeof null will return "object". We have to be careful to avoid the mistake of initializing a variable to null. To be safe, this is what we could use instead:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

For more info on using strict comparison === instead of simple equality ==, see:
Which equals operator (== vs ===) should be used in JavaScript comparisons?

Answered   2023-09-20 20:32:20

  • Warning: This does not work for members of objects, if you try to access them using the dot notation as in some_object.a_member. - anyone
  • this doesn't check if a variable exists, it checks its value type. You want to check if a variable it's been declared. @BrianKelley's answer is the right one. - anyone
  • why not just variable != null it seems to catch "undefined" variables just as well - anyone
  • If you wanted to catch if a variable was uninitialized or null, couldn't you use simple equality? ie: if (typeof variable == 'undefined') - anyone

In many cases, using:

if (elem) { // or !elem

will do the job for you!... this will check these below cases:

  1. undefined: if the value is not defined and it's undefined
  2. null: if it's null, for example, if a DOM element not exists...
  3. empty string: ''
  4. 0: number zero
  5. NaN: not a number
  6. false

So it will cover off kind of all cases, but there are always weird cases which we'd like to cover as well, for example, a string with spaces, like this ' ' one, this will be defined in javascript as it has spaces inside string... for example in this case you add one more check using trim(), like:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Also, these checks are for values only, as objects and arrays work differently in Javascript, empty array [] and empty object {} are always true.

I create the image below to show a quick brief of the answer:

undefined, null, etc

Answered   2023-09-20 20:32:20

  • @Alireza, nice! Your answer will help a lot of people out there. I already memorized these falsy values, the only thing that I wasn't sure was about []. - anyone
  • I get a "ReferenceError: elem is not defined" - anyone
  • @ropo, it's because you even didn't define the elem to check what it's , if it's your case, you need to check it with typeof(elem)==="string" which is mentioned already... - anyone
  • Then the answer is misleading when it says if(elem) checks for undefined (while it returns not defined error), isn't it? - anyone
  • Surprised my the number of upvotes. The answer is simply wrong. As mentioned in comments above, "if (elem) {}" does not check for undefined, it will throw an error if the variable is not defined. However, "if (window.elem) {}" will not throw an error if elem is undefined. - anyone

In JavaScript, a variable can be defined, but hold the value undefined, so the most common answer is not technically correct, and instead performs the following:

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

That may suffice for your purposes. The following test has simpler semantics, which makes it easier to precisely describe your code's behavior and understand it yourself (if you care about such things):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

This, of course, assumes you are running in a browser (where window is a name for the global object). But if you're mucking around with globals like this you're probably in a browser. Subjectively, using 'name' in window is stylistically consistent with using window.name to refer to globals. Accessing globals as properties of window rather than as variables allows you to minimize the number of undeclared variables you reference in your code (for the benefit of linting), and avoids the possibility of your global being shadowed by a local variable. Also, if globals make your skin crawl you might feel more comfortable touching them only with this relatively long stick.

Answered   2023-09-20 20:32:20

  • This only checks if the variable was declared globally. If you are coding properly, then you are limiting your global vars. It will report false for local vars: (function() { var sdfsfs = 10; console.log( "sdfsfs" in window); })() ` - anyone
  • This is the best f$#^%ing answer. I was at wit's end on this trying to figure out how to account for exactly this corner case. Brilliant. Had no idea you could do this. - anyone
  • Heads-up: your answer has been migrated here from stackoverflow.com/questions/519145/… - anyone
  • For Angular users: Unfortunately, it doesn't seem to be allowed in an ng-if statement. - anyone
  • This doesn't work for const or let variables - anyone

In the majority of cases you would use:

elem != null

Unlike a simple if (elem), it allows 0, false, NaN and '', but rejects null or undefined, making it a good, general test for the presence of an argument, or property of an object.


The other checks are not incorrect either, they just have different uses:

  • if (elem): can be used if elem is guaranteed to be an object, or if false, 0, etc. are considered "default" values (hence equivalent to undefined or null).

  • typeof elem == 'undefined' can be used in cases where a specified null has a distinct meaning to an uninitialised variable or property.

    • This is the only check that won't throw an error if elem is not declared (i.e. no var statement, not a property of window, or not a function argument). This is, in my opinion, rather dangerous as it allows typos to slip by unnoticed. To avoid this, see the below method.

Also useful is a strict comparison against undefined:

if (elem === undefined) ...

However, because the global undefined can be overridden with another value, it is best to declare the variable undefined in the current scope before using it:

var undefined; // really undefined
if (elem === undefined) ...

Or:

(function (undefined) {
    if (elem === undefined) ...
})();

A secondary advantage of this method is that JS minifiers can reduce the undefined variable to a single character, saving you a few bytes every time.

Answered   2023-09-20 20:32:20

  • I'm shocked that you can override undefined. I don't even think that's worth mentioning in the answer. Probably the single worst acceptable variable name in all of Javascript. - anyone
  • This causes an exception and requires you to use window. before the variable if used in the global context...this is not the best way. - anyone
  • Because of this overriding issue you should ALWAYS use void(0) instead of undefined. - anyone
  • +1 since this answer points out that sometimes you may actually want to identify false, 0, etc. as invalid values. - anyone

Check if window.hasOwnProperty("varname")

An alternative to the plethora of typeof answers;

Global variables declared with a var varname = value; statement in the global scope

can be accessed as properties of the window object.

As such, the hasOwnProperty() method, which

returns a boolean indicating whether the object has the specified property as its own property (as opposed to inheriting it)

can be used to determine whether

a var of "varname" has been declared globally i.e. is a property of the window.

// Globally established, therefore, properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
//  window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ), // true
    window.hasOwnProperty( "bar" ), // true
    window.hasOwnProperty( "baz" ), // true
    window.hasOwnProperty( "qux" )  // false
] );

What's great about hasOwnProperty() is that in calling it, we don't use a variable that might as yet be undeclared - which of course is half the problem in the first place.

Although not always the perfect or ideal solution, in certain circumstances, it's just the job!

Notes

The above is true when using var to define a variable, as opposed to let which:

declares a block scope local variable, optionally initializing it to a value.

is unlike the var keyword, which defines a variable globally, or locally to an entire function regardless of block scope.

At the top level of programs and functions, let, unlike var, does not create a property on the global object.

For completeness: const constants are, by definition, not actually variable (although their content can be); more relevantly:

Global constants do not become properties of the window object, unlike var variables. An initializer for a constant is required; that is, you must specify its value in the same statement in which it's declared.

The value of a constant cannot change through reassignment, and it can't be redeclared.

The const declaration creates a read-only reference to a value. It does not mean the value it holds is immutable, just that the variable identifier cannot be reassigned.

Since let variables or const constants are never properties of any object which has inherited the hasOwnProperty() method, it cannot be used to check for their existence.

Regarding the availability and use of hasOwnProperty():

Every object descended from Object inherits the hasOwnProperty() method. [...] unlike the in operator, this method does not check down the object's prototype chain.

Answered   2023-09-20 20:32:20

  • This an awesome alternative and should be on the top upvoted of this question. Please simplify the answer headline with a working example that returns true (e.g. window.hasOwnProperty('console') or var hop = "p";window.hasOwnProperty('hop')). - anyone
  • Finally something that does not throw an error because of accessing a member which does not exist … Something all the typeof answers simply overlook. - anyone
  • This answer is outdated -- per standard ECMAScript you can define variables with let where these variables aren't available as properties of the window [or any other available] object. hasOwnProperty tests for presence of properties, not variables and thus cannot be used to detect variables defined by let. - anyone
  • @amn The answer remains true regarding the use of var and is in that regard not outdated. I have however added a note outlining how the use of let and const differs from that of var. Thanks for your inspiration; together we rise :) - anyone
  • @amn I have rewritten the answer (hopefully for the last time) to make more clear that hasOwnProperty can only be used in the prescribed manner to check for the existence of var variables. It reads okay to me. - anyone

How to check if a variable exists

This is a pretty bulletproof solution for testing if a variable exists and has been initialized :

var setOrNot = typeof variable !== typeof undefined;

It is most commonly used in combination with a ternary operator to set a default in case a certain variable has not been initialized :

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

Problems with encapsulation

Unfortunately, you cannot simply encapsulate your check in a function.

You might think of doing something like this :

function isset(variable) {
    return typeof variable !== typeof undefined;
}

However, this will produce a reference error if you're calling eg. isset(foo) and variable foo has not been defined, because you cannot pass along a non-existing variable to a function :

Uncaught ReferenceError: foo is not defined


Testing whether function parameters are undefined

While our isset function cannot be used to test whether a variable exists or not (for reasons explained hereabove), it does allow us to test whether the parameters of a function are undefined :

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Even though no value for y is passed along to function test, our isset function works perfectly in this context, because y is known in function test as an undefined value.

Answered   2023-09-20 20:32:20

Short way to test a variable is not declared (not undefined) is

if (typeof variable === "undefined") {
  ...
}

I found it useful for detecting script running outside a browser (not having declared window variable).

Answered   2023-09-20 20:32:20

  • is this the "canonical way" that is portable? - anyone
  • This is wrong. window.bar=undefined is defined and set to a value. Your answer fails to detect the difference between this and if the variable does not exist. If you did this.hasOwnProperty('bar') it might have worked. - anyone
  • this code doesn't work and you can verify this by using any browser console - anyone
  • Consider const x = 0; (() => console.log(x, this.hasOwnProperty('x')))();. Variable x is defined but false is returned... - anyone

Try-catch

If variable was not defined at all (for instance: external library which define global variable is not yet loaded - e.g. google maps), you can check this without break code execution using try-catch block as follows (you don't need to use strict mode)

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

BONUS: (referring to other answers) Why === is more clear than == (source)

if( a == b )

Enter image description here

if( a === b )

Enter image description here

Answered   2023-09-20 20:32:20

  • FYI, (a == b) placed onto Game of Life grid was not all that exciting. - anyone

There is another short hand way to check this, when you perform simple assignments and related checks. Simply use Conditional (Ternary) Operator.

var values = typeof variable !== 'undefined' ? variable : '';

Also this will be helpful, when you try to declare the Global variable with instance assignment of the reference variable.

If you wanted to check variable shouldn't be undefined or null. Then perform below check.

When the variable is declared, and if you want to check the value, this is even Simple: and it would perform undefined and null checks together.

var values = variable ? variable : '';

Answered   2023-09-20 20:32:20

  • the answer as it is flat out wrong. typeof variable always returns a string, thus is never false. e.g. if typeof(booooo) is "undefined" then typeof(typeof boooooo) is "string" and typeof boooooo && true is always true. @John-Slegers' answer is about as abbreviated as you can get with typeof. - anyone
  • Its absolutely correct answer. Here is an working Fiddle. And i don't know which scenario you are talking about. The questions is about checking variable existence. - anyone
  • @mpag Don't Say Flat wrong. Prove It. Finding a mistake is real easy, instead you can provide Good answers here!!!. If the answer is flat wrong 28 programmers wouldn't have up-voted without checking my answer. Since there are many reputed answers here they could have up-voted that, not this. - anyone
  • Actually the second piece of code, is not to check same as above condition. I thought people would understand by this line If you wanted to check variable shouldn't be undefined or null., By this comment, its clearly stating, its not to perform the variable declaration check. that's to check variable value. - anyone
  • your 2nd check will fail with 0 value - anyone

It depends if you just care that the variable has been defined or if you want it to have a meaningful value.

Checking if the type is undefined will check if the variable has been defined yet.

=== null or !== null will only check if the value of the variable is exactly null.

== null or != null will check if the value is undefined or null.

if(value) will check if the variable is undefined, null, 0, or an empty string.

Answered   2023-09-20 20:32:20

The highest answer is correct, use typeof.

However, what I wanted to point out was that in JavaScript undefined is mutable (for some ungodly reason). So simply doing a check for varName !== undefined has the potential to not always return as you expect it to, because other libs could have changed undefined. A few answers (@skalee's, for one), seem to prefer not using typeof, and that could get one into trouble.

The "old" way to handle this was declaring undefined as a var to offset any potential muting/over-riding of undefined. However, the best way is still to use typeof because it will ignore any overriding of undefined from other code. Especially if you are writing code for use in the wild where who knows what else could be running on the page...

Answered   2023-09-20 20:32:20

  • The point is moot, because if varName is undefined then varName !== undefined will just cause a ReferenceError. The mutability of undefined won't matter. - anyone
  • Heads-up: your answer has been migrated here from stackoverflow.com/questions/519145/… - anyone
  • In newer Javascript versions undefined is an read only property. However to be bulletproof you can use typeof mvVar === typeof void 0. void 0 returns undefined always. - anyone
if (typeof console != "undefined") {    
   ...
}

Or better

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

Works in all browsers

Answered   2023-09-20 20:32:20

To check if a variable has been declared/set I did this dirty trick.

I haven't found a way to extract the code to a function, even with eval. Se this comment below for an explanation about why.

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}

Answered   2023-09-20 20:32:20

  • What do you mean by "extract the code to a function"? - anyone
  • @Melab Ideally you could have function isDefined(x){...} and then call isDefined(myVar). But there is no way to safely pass a potentially undefined variable to isDefined because before the variable can be passed to the function, it must be evaluated, and if it doesn't already exist, then at that point it will throw (outside of the try/catch block, which is in the function). You have to evaluate the variable directly inside a try/catch block, so you cannot wrap the test in a function. - anyone
  • While this is a good answer technically, it would be evidence of bad design if you truly require this. - anyone
  • @aross You're right actually, in my code it seemed like there was an error from it, but there must've been some other error, because going back to it now a few days later it does work. - anyone
  • This is the only correct answer here. I absolutely needed this just now, and could not for the life of me figure out how to test for it. Checking if a variable exists accesses a non-existent variable, which is an error only some of the time, depending on what mode your browser decides to be running your JavaScript in, which you cannot detect from your code. :-/ - anyone

To contribute to the debate, if I know the variable should be a string or an object I always prefer if (!variable), so checking if its falsy. This can bring to more clean code so that, for example:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

..could be reduced to:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 

Answered   2023-09-20 20:32:20

  • This is not what the OP asked. If data.url is equal to '' your solution would consider it undefined, when it is in fact defined as containing an empty string. - anyone
  • I agree is not what has been asked, and you are right: the empty string '' would be considered undefined. But I posted this because I thought it could be useful on the debate that has been created among different answers. And in the example, as well as in many other cases, you just want to print a string if there is actually content, so it's ok to take advantage of the fact the javascript considers falsy both empty string and undefined - anyone

In the particular situation outlined in the question,

typeof window.console === "undefined"

is identical to

window.console === undefined

I prefer the latter since it's shorter.

Please note that we look up for console only in global scope (which is a window object in all browsers). In this particular situation it's desirable. We don't want console defined elsewhere.

@BrianKelley in his great answer explains technical details. I've only added lacking conclusion and digested it into something easier to read.

Answered   2023-09-20 20:32:20

The most robust 'is it defined' check is with typeof

if (typeof elem === 'undefined')

If you are just checking for a defined variable to assign a default, for an easy to read one liner you can often do this:

elem = elem || defaultElem;

It's often fine to use, see: Idiomatic way to set default value in javascript

There is also this one liner using the typeof keyword:

elem = (typeof elem === 'undefined') ? defaultElem : elem;

Answered   2023-09-20 20:32:20

Null is a value in JavaScript and typeof null returns "object"

Therefore, accepted answer will not work if you pass null values. If you pass null values, you need to add an extra check for null values:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

Answered   2023-09-20 20:32:20

It is difficult to distinguish between undefined and null. Null is a value you can assign to a variable when you want to indicate that the variable has no particular value. Undefined is a special value which will be the default value of unassigned variables.


var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

Answered   2023-09-20 20:32:20

  • Would be helpful to show inline the output of each alert. - anyone
  • @demisx Agreed, but instead of suggesting the edit, why not just make it? The option is there for a reason. Some may consider it rude; I consider it efficient - so edited the answer myself (pending review). - anyone
  • @Fred - I looked at the edit history and can guess why your edits were rejected... rather than just adding lines to show what the output would be, as demisx suggested, you significantly changed what Jith had posted. - anyone

you can use the typeof operator.

For example,

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

Above code snippet will return the output like

variable dataSet is : undefined.

Answered   2023-09-20 20:32:20

I use two different ways depending on the object.

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

Sometimes I do not want to evaluate an empty string as falsey, so then I use this case

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

If you need the opposite, then in the first instance !variable becomes !!variable, and in the invalid function === become != and the function names changes to notInvalid.

Answered   2023-09-20 20:32:20

My preference is typeof(elem) != 'undefined' && elem != null.

However you choose, consider putting the check in a function like so

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

If you don't know the variable is declared then continue with typeof (x) != 'undefined' && x != null;

Where you know the variable is declared but may not be existy, you could use

existy(elem) && doSomething(elem);

The variable you are checking may be a nested property sometimes. You can use prop || {} to go down the line checking existance to the property in question:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

After each property use (...' || {}').nextProp so that a missing property won't throw an error.

Or you could use existy like existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Answered   2023-09-20 20:32:20

  • If you put it in a function, it’s redundant. typeof (x) != 'undefined' && x != null is equivalent to x != null when x is declared. - anyone

These answers (aside from the Fred Gandt solution ) are all either incorrect or incomplete.

Suppose I need my variableName; to carry an undefined value, and therefore it has been declared in a manner such as var variableName; which means it's already initialized; - How do I check if it's already declared?

Or even better - how do I immediately check if "Book1.chapter22.paragraph37" exists with a single call, but not rise a reference error?

We do it by using the most powerful JasvaScript operator, the in operator.:

"[variable||property]" in [context||root] 
>> true||false

Answered   2023-09-20 20:32:20

  • if ( ("url" in req.body) == false && req.body.url.length > 1 - anyone
  • This is not true for variables declared with let and const instead of var. See: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… - anyone
  • @catwith, thanks for your input however you should take into account when publicly commenting, that analogous things are not the same thing. A var is a variable; a let is a proposition; and a const is the exact opposite and antinomy of var's. That solution is written to exactly address the question in its explicit request. Thanks! - anyone
  • could you explain "a let is a proposition"? In fact, could you perhaps explain why W3Schools calls all three of them variables with different levels of restriction? Example: Var declares a variable. Let declares a variable with scope. Const declares a variable with scope and prevents re-assignment. How do you think they are somehow completely different things, when the creators of the script (oracle) say they aren't? - anyone

It depends on the situation. If you're checking for something that may or may not have been defined globally outside your code (like jQuery perhaps) you want:

if (typeof(jQuery) != "undefined")

(No need for strict equality there, typeof always returns a string.) But if you have arguments to a function that may or may not have been passed, they'll always be defined, but null if omitted.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"

Answered   2023-09-20 20:32:20

  • I agree here. I don't know why everyone is using strict equality when it's not necessary. - anyone
if (variable === undefined) {}

works just fine, and only checks for undefined.

Answered   2023-09-20 20:32:20

You could use a try...catch block like the following:

var status = 'Variable exists'

try {
  myVar
} catch (ReferenceError) {
  status = 'Variable does not exist'
}

console.log(status)

A disadvantage is you cannot put it in a function as it would throw a ReferenceError

function variableExists(x) {
  var status = true
  try {
    x
  } catch (ReferenceError) {
    status = false
  }
  
  return status
}

console.log(variableExists(x))

Edit:

If you were working in front-end Javascript and you needed to check if a variable was not initialized (var x = undefined would count as not initialized), you could use:

function globalVariableExists(variable) {
  if (window[variable] != undefined) {
    return true
  }
  
  return false
}

var x = undefined

console.log(globalVariableExists("x"))

console.log(globalVariableExists("y"))

var z = 123

console.log(globalVariableExists("z"))

Edit 2:

If you needed to check if a variable existed in the current scope, you could simply pass this to the function, along with the name of the variable contained in a string:

function variableExists(variable, thisObj) {
  if (thisObj[variable] !== undefined) {
    return true
  }
  
  return false
}

class someClass {
  constructor(name) { 
    this.x = 99
    this.y = 99
    this.z = 99
    this.v = 99
    
    console.log(variableExists(name, this))
  }
}

new someClass('x')
new someClass('y')
new someClass('z')
new someClass('v')
new someClass('doesNotExist')

Answered   2023-09-20 20:32:20

I prefer this method for it's accuracy and succinctness:

var x
if (x === void 0) {
  console.log(`x is undefined`)
} else {
  console.log(`x is defined`)
}

As has been mentioned in other comments and answers, undefined isn't guaranteed to be undefined. Because it's not a keyword, it can be redefined as a variable in scopes other than the global scope. Here's little example that demonstrates this nuance:

var undefined = 'bar'
console.log(`In the global scope: ${undefined}`)

function foo() {
  var undefined = 'defined'
  var x
  if (x === undefined) {
    console.log(`x === undefined`)
  } else {
    console.log(`x !== undefined`)
  }
  if (x === void 0) {
    console.log(`x === void 0`)
  } else {
    console.log(`x !== void 0`)
  }
}

foo()

See void for compatibility (supported in IE5!?!! Wow!).

Answered   2023-09-20 20:32:20

  • Does this have any advantage over typeof x === 'undefined'? Redefining undefined doesn't affect that does it? - anyone
  • I don't think redefining undefined as any affect on typeof x === 'undefined', since you're not actually referencing the undefined keyword. - anyone

I'm surprised this wasn't mentioned yet...

here are a couple of additional variations using this['var_name']

the benefit of using this method that it can be used before a variable is defined.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

Answered   2023-09-20 20:32:20

  • This is wrong. window.bar=undefined is defined and set to a value. Your answer fails to detect the difference between this and if the variable does not exist. If you did this.hasOwnProperty('bar') it might have worked. - anyone

I wanted something similar: A function to check if a variable had a useful value, where 0 is useful, but empty strings, arrays, and objects are not (for my application). Based on the various answers and comments, I came up with the isSet() function defined and tested below; it returns true for the first half of the test values and false for the second, which is what I wanted and needed:

let fn = [1234, "1234", 0, "0", [1,2], {name: "number"}, "", [], {}, null, NaN, undefined]

console.log(fn)
const isSet = (val) => {
    switch (typeof val) {
        case 'number': return !isNaN(val); break; // as long as it is a number other than NaN....
        case 'string': return val.length > 0; break;
        case 'undefined': return false; break;
        case 'object':
            if (val === null) return false;
            else return Object.keys(val).length > 0;
            break;
    }
}

for (index in fn) {
    const item = fn[index];
    console.log(`ind: ${index}; ${typeof item}; ${isSet(item)}`)
}

Results (under node v16.16.0):

[
  1234,
  '1234',
  0,
  '0',
  [ 1, 2 ],
  { name: 'number' },
  '',
  [],
  {},
  null,
  NaN,
  undefined
]
ind: 0; number; true
ind: 1; string; true
ind: 2; number; true
ind: 3; string; true
ind: 4; object; true
ind: 5; object; true
ind: 6; string; false
ind: 7; object; false
ind: 8; object; false
ind: 9; object; false
ind: 10; number; false
ind: 11; undefined; false

Answered   2023-09-20 20:32:20

In ReactJS, things are a bit more complicated! This is because it is a compiled environment, which follows ESLint's no-undef rule since react-scripts@2.0.3 (released Oct. 1st, 2018). The documentation here is helpful to anyone interested in this problem...

In JavaScript, prior to ES6, variable and function declarations are hoisted to the top of a scope, so it's possible to use identifiers before their formal declarations in code....

This [new] rule [of ES6] will warn when it encounters a reference to an identifier that has not yet been declared.

So, while it's possible to have an undefined (or "uninitialized") variable, it is not possible to have an undeclared variable in ReactJS without turning off the eslint rules.

This can be very frustrating -- there are so many projects on GitHub that simply take advantage of the pre-ES6 standards; and directly compiling these without any adjustments is basically impossible.

But, for ReactJS, you can use eval(). If you have an undeclared variable like...

if(undeclaredvar) {...}

You can simply rewrite this part as...

if(eval('typeof undeclaredvar !== "undefined"')) {...}

For instance...

if(eval("false")) {
  console.log("NO!");
}
if(eval("true")) {
  console.log("YEAH!");
}

For those importing GitHub repositories into a ReactJS project, this is simply the only way to check if a variable is declared. Before closing, I'd like to remind you that there are security issues with eval() if use incorrectly.

Answered   2023-09-20 20:32:20