How to check for an undefined or null variable in JavaScript?

Question

We are frequently using the following code pattern in our JavaScript code

if (typeof(some_variable) != 'undefined' && some_variable != null)
{
    // Do something with some_variable
}

Is there a less verbose way of checking that has the same effect?

According to some forums and literature saying simply the following should have the same effect.

if (some_variable)
{
    // Do something with some_variable
}

Unfortunately, Firebug evaluates such a statement as error on runtime when some_variable is undefined, whereas the first one is just fine for it. Is this only an (unwanted) behavior of Firebug or is there really some difference between those two ways?

Beltran

if(some_variable) { ... } will not execute if some_variable is false or 0 or ... – Critter

good point ;) But let's say I know it can't be false or 0 and I just want to check whether I can use it in some logic (as a string, array, etc.) – Beltran

Related: #28009 – Yetah

...or an empty string. – Zitella

Possible duplicate of How do you check for an empty string in JavaScript? – Laurelaureano

2nd solution will be executed if some_variable is 0, False, or any other kind of falsy variable. This is very different from checking if something is undefined or null – Gargantua

Answer 1

You have to differentiate between cases:

1. Variables can be undefined or undeclared. You'll get an error if you access an undeclared variable in any context other than typeof.

if(typeof someUndeclaredVar == whatever) // works
if(someUndeclaredVar) // throws error

A variable that has been declared but not initialized is undefined.

let foo;
if (foo) //evaluates to false because foo === undefined

2. Undefined properties , like someExistingObj.someUndefProperty. An undefined property doesn't yield an error and simply returns undefined, which, when converted to a boolean, evaluates to false. So, if you don't care about 0 and false, using if(obj.undefProp) is ok. There's a common idiom based on this fact:

   value = obj.prop || defaultValue
   

   which means "if obj has the property prop, assign it to value, otherwise assign the default value defautValue".

   Some people consider this behavior confusing, arguing that it leads to hard-to-find errors and recommend using the in operator instead

   value = ('prop' in obj) ? obj.prop : defaultValue
   

Disraeli

Then you could talk about hasOwnProperty and prototypes. 'indexOf' in [] !== [].hasOwnProperty('indexOf') – Muffler

Yes, i thought about adding this, but decided to sacrifice completeness for brevity. ;) – Disraeli

you do not address the problem of 0 and false – Cumulonimbus

You mean undeclared variables. A variable can be declared but still have a value of undefined. – Hydrolyze

And also note that typeof returns a string. So var myVar; typeof(myVar)==undefined returns false not true. – Vestry

@Disraeli Why would if(someUndefVar) throw an error? is this outdated? – Carabin

foo == null (double equals intended) is my favorite check as it is falsey for 0 & false but truthy for both undefined & null. – Bullard

obj.prop: to only test a property for null|undefined (or property not declared), do obj.prop == null. This works because undefined == null is true, but other "falsy" values (0 etc) are not: 0 == null is false. Property tests do not result in reference error for missing property (assuming obj is an object). – Kuo

Answer 2

I think the most efficient way to test for "value is null or undefined" is

if ( some_variable == null ){
  // some_variable is either null or undefined
}

So these two lines are equivalent:

if ( typeof(some_variable) !== "undefined" && some_variable !== null ) {}
if ( some_variable != null ) {}

Note 1

As mentioned in the question, the short variant requires that some_variable has been declared, otherwise a ReferenceError will be thrown. However in many use cases you can assume that this is safe:

check for optional arguments:

function(foo){
    if( foo == null ) {...}

check for properties on an existing object

if(my_obj.foo == null) {...}

On the other hand typeof can deal with undeclared global variables (simply returns undefined). Yet these cases should be reduced to a minimum for good reasons, as Alsciende explained.

Note 2

This - even shorter - variant is not equivalent:

if ( !some_variable ) {
  // some_variable is either null, undefined, 0, NaN, false, or an empty string
}

so

if ( some_variable ) {
  // we don't get here if some_variable is null, undefined, 0, NaN, false, or ""
}

Note 3

In general it is recommended to use === instead of ==. The proposed solution is an exception to this rule. The JSHint syntax checker even provides the eqnull option for this reason.

From the jQuery style guide:

Strict equality checks (===) should be used in favor of ==. The only exception is when checking for undefined and null by way of null.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

EDIT 2021-03:

Nowadays most browsers support the Nullish coalescing operator (??) and the Logical nullish assignment (??=), which allows a more concise way to assign a default value if a variable is null or undefined, for example:

if (a.speed == null) {
  // Set default if null or undefined
  a.speed = 42;
}

can be written as any of these forms

a.speed ??= 42;
a.speed ?? a.speed = 42;
a.speed = a.speed ?? 42;

Dandify

Very important difference (which was already mentioned in the question btw). That's why everyone uses typeof. Sorry but I don't get where your answer is useful, you just state what was said in the question and in the first few lines you state it even wrong. – Cumulonimbus

Sorry, but I have to disagree ;-) Using == null is imho the most efficient to test for 'null or undefined' (which is the questions topic). It is by no means uncommon (used 43 times in jQuery 1.9.1), since very often you know that the variable was declared - or you test for an property of an existing object like if( o.foo == null). – Dandify

@Dandify (aUndefinedVar == null) gives you a "aUndefinedVar is not defined" error not true. – Nicoline

@Rannnn: this is discussed in 'Note 1' – Dandify

== behavior in Javascript is extremely confusing. You should spell out v !== null && v !== undefined to improve code readability, unless you are writing some very low level library code where the extra operation matters to performance (in which case you should test which version is faster, and my bet is still on with the longer one - type coercion is slow). – Hydrolyze

Thanks for this succinct option. In 99% of my code there is no need to distinguish between null and undefined, therefore the brevity of this check results in less cluttered code. – Craniate

To prevent a ReferenceError when checking a global variable, use window.someProperty == null. For local variables, you can easily make sure they are declared: instead of writing if (...) {var local = ""} write var local; if (...) { local = ""; } – Accomplice

"Strict equality checks (===) should be used in favor of ==. The only exception is when checking for undefined and null by way of null." I usually do == for boolean values too ("true" vs true). Thoughts? Is that bad practice? – Parsley

@Parsley I personally think so, yes. I'd use if ( val ) to test for truthy or if ( val === true ) for explicit tests. – Dandify

Wish Visual Studio's IntelliSense would like this (it complains when you further use the variable after this check that it could be null or undefined) – Fechner

I'm with @IanLovejoy. Almost always simplicity (not necessarily brevity) of code is more important than speed (who's doing compute intensive work in JavaScript?) This answer very explicitly answers the original question – Jiujitsu

Hey wait!! I got an error when using if ( some_variable == null ), where some_variable is not defined. A simple example is here: jsfiddle.net/q20sx6o4 . See error message in the console. Does this method really work for now? – Skyway

@Skyway this is discussed in „Note 1“ – Dandify

I cannot believe that the comments that recommend using == null are praised / upvoted so highly. This is a complete hack and you should NOT do this in production code. I asked around almost all our frontend devs and none of them knew (for certain) that only undefined/null pass this check. This kills readability and it smells of someone just wanting to prove they're especially smart. Any sane developer who reads this will get confused one way or the other, this is a very JS-specific quirk. TL;DR: Do Not Employ == null checks in your code if other people are going to use this code. – Chrissychrist

@Chrissychrist - the behavior is in the spec. And can easily be found by googling. If in doubt, a short comment \\ null or undefined on each usage would clarify for devs who lack this knowledge. I'd rather do that, than use a verbose equivalent every time. OTOH, if this might be an undeclared variable, to avoid an error it is unfortunately necessary to do typeof(some_variable) !== "undefined" && .... – Kuo

x == null is also true if x is an object with [[IsHTMLDDA]]: document.all == null, but document.all !== undefined && document.all !== null. This may be desired behaviour. – Cozenage

Answer 3

Checking null with normal equality will also return true for undefined.

if (window.variable == null) alert('variable is null or undefined');

Lieutenancy

NaN not equal to Nan? – Freewill

@monotheist NaN is not equal to NaN (see MDN's NaN page). Javascript uses IEEE-754 for their floating point which specifies this behaviors. There are some thoughts to this, see https://mcmap.net/q/24484/-why-is-nan-not-equal-to-nan-duplicate – Spectacle

@SharjeelAhmed It is mathematically corrected. NaN from difference equation can never expected to be equal – Sherise

Answer 4

This is the only case in which == and != should be used:

if (val == null) console.log('val is null or undefined')

if (val != null) console.log('val is neither null nor undefined')

For any other comparisons, the strict comparators (=== and !==) should be used.

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness
• https://2ality.com/2011/12/strict-equality-exemptions.html

Meyerbeer

this answer being circa 2019 has a dearth of upvotes but it's the KISS one for this use case. Also val != null for the opposite, just one = and since per @Yukulele it's the ONLY one to use == you'll know what is does when you see it. – Ischia

@Ischia I changed my answer according to your comment. – Youthful

This answer is like one of those pro tip! – Artistry

ha so this is why my IDE only complains about certain uses of == ... wow I hate javascript! – Geometry

Answer 5

In newer JavaScript standards like ES5 and ES6 you can just say

> Boolean(0) //false
> Boolean(null)  //false
> Boolean(undefined) //false

all return false, which is similar to Python's check of empty variables. So if you want to write conditional logic around a variable, just say

if (Boolean(myvar)){
   // Do something
}

here "null" or "empty string" or "undefined" will be handled efficiently.

Clydesdale

supported down to like ie5, why is this not more well known!? – Shiksa

OP just wanted test different of null and undefined, other falsy values should return true! – Jane

It adds no value in a conditional. The condition evaluates exactly the same and still returns false for 0, NaN. This is for when you want to capture the truthiness of an object without keeping a reference to the object so you can store that rather than some potentially large object. FYI this is also equivalent to !!value, which the first ! negates the truthiness, and the second negates it again. – Bodice

> FYI this is also equivalent to !!value, which the first ! negates the truthiness. Which FYI is also equivalent to if (var) which will be cast to boolean, so basically completely useless... – Wojcik

While literally using the keyword undefined, Boolean(undefined) works, trying that with an undefined variable doesn't work, and that is the whole point of doing the check for null or undefined. This: if (Boolean(undeclareVarName)) { console.log('yes'); } else { console.log('no'); } throws a ReferenceError saying "ReferenceError: undeclareVarName is not defined" – Gilus

Boolean({}) returns true – Kerge

@DmitryS, Yes it returns true for empty list and object. But the question here asked is for null or undefined. – Clydesdale

@NarenYellavula - I disagree. The question asks for a solution that is equivalent to a code snippet they show, which tests for null or undefined. Your answer is not equivalent to that test. This propagates a bad habit that many JavaScript programmers have, and may confuse people just learning JavaScript. – Kuo

Answer 6

If you try and reference an undeclared variable, an error will be thrown in all JavaScript implementations.

Properties of objects aren't subject to the same conditions. If an object property hasn't been defined, an error won't be thrown if you try and access it. So in this situation you could shorten:

 if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null)

to

if (myObj.some_property != null)

With this in mind, and the fact that global variables are accessible as properties of the global object (window in the case of a browser), you can use the following for global variables:

if (window.some_variable != null) {
    // Do something with some_variable
}

In local scopes, it always useful to make sure variables are declared at the top of your code block, this will save on recurring uses of typeof.

Yiddish

You will miss NaN, 0, "" and false cause they are not null nor undefined but false as well. – Madalena

@Andreas Köberle is right. Even the non-strict equality operator says that null is different from NaN, 0, "", and false. You'd have to do if (myObj.some_property != null) to get equivalent behavior. – Desensitize

Answer 7

Firstly you have to be very clear about what you test. JavaScript has all sorts of implicit conversions to trip you up, and two different types of equality comparator: == and ===.

A function, test(val) that tests for null or undefined should have the following characteristics:

 test(null)         => true
 test(undefined)    => true
 test(0)            => false
 test(1)            => false
 test(true)         => false
 test(false)        => false
 test('s')          => false
 test([])           => false

Let's see which of the ideas here actually pass our test.

These work:

val == null
val === null || val === undefined
typeof(val) == 'undefined' || val == null
typeof(val) === 'undefined' || val === null

These do not work:

typeof(val) === 'undefined'
!!val

I created a jsperf entry to compare the correctness and performance of these approaches. Results are inconclusive for the time being as there haven't been enough runs across different browsers/platforms. Please take a minute to run the test on your computer!

At present, it seems that the simple val == null test gives the best performance. It's also pretty much the shortest. The test may be negated to val != null if you want the complement.

Ap

Answer 8

here's another way using the Array includes() method:

[undefined, null].includes(value)

Ethaethan

It doesn't work! ReferenceError: value is not defined – Cheekpiece

It should be the value you want to check. – Escallop

Only works if you can do without typeof. Besides that, it's nice and short. Like it. – Ousel

@qräbnö - it is equivalent to the even shorter value != null. The one benefit I can see is that it does not require knowing that == null and != null treat a declared variable with value undefined as equal to null. IMHO, that isn't reason enough to use this unfamiliar (and inefficent - creates an array every time) syntax. – Kuo

I like it anyway. You can add more checks, like empty string for example. – Ousel

Answer 9

Since there is no single complete and correct answer, I will try to summarize:

In general, the expression:

if (typeof(variable) != "undefined" && variable != null)

cannot be simplified, because the variable might be undeclared so omitting the typeof(variable) != "undefined" would result in ReferenceError. But, you can simplify the expression according to the context:

If the variable is global, you can simplify to:

if (window.variable != null)

If it is local, you can probably avoid situations when this variable is undeclared, and also simplify to:

if (variable != null)

If it is object property, you don't have to worry about ReferenceError:

if (obj.property != null)

Cumulonimbus

Is navigator part of window? When we get an exception for navigator is not defined, can we use the window.navigator != null test? – Brewing

Re If it is local, you can probably avoid situations when this variable is undeclared,. Indeed, if it is local, it cannot be undeclared - so this is a non-problem. Your code snippet is always good. [If there is no local declaration of the variable, then it is - by definition - a reference to a global variable - which presumably is a programming mistake if you thought it was local, so having that result in a run-time error is a good thing. Reinforcing the value of using that shorter code snippet.] – Kuo

Answer 10

This is an example of a very rare occasion where it is recommended to use == instead of ===. Expression somevar == null will return true for undefined and null, but false for everything else (an error if variable is undeclared).

Using the != will flip the result, as expected.

Modern editors will not warn for using == or != operator with null, as this is almost always the desired behavior.

Most common comparisions:

undeffinedVar == null     // true
obj.undefinedProp == null // true
null == null              // true
0 == null                 // false
'0' == null               // false
'' == null                // false

Try it yourself:

let undefinedVar;
console.table([
    { test : undefinedVar,     result: undefinedVar     == null },
    { test : {}.undefinedProp, result: {}.undefinedProp == null },
    { test : null,             result: null             == null },
    { test : false,            result: false            == null },
    { test : 0,                result: 0                == null },
    { test : '',               result: ''               == null },
    { test : '0',              result: '0'              == null },
]);

Agma

Answer 11

This is also a nice (but verbose) way of doing it:

if((someObject.someMember ?? null) === null) {
  // bladiebla
}

It's very clear what's happening and hard to misunderstand. And that can be VERY important! :-)

This uses the ?? operator (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator). If the value of someObject.someMember is null or undefined, the ?? operator kicks in and will make the value null.

TBH, I like the explicitness of this thing, but I usualle prefer someObject.someMember == null, it's more readable and skilled JS developers probably know what's going on here.

Hawkinson

This is not clear to me at all. I don't understand this syntax. Could you please explain? – Multiflorous

@matt Its shorthand. It basically means if the value before the ?? is null or undefined, then default to the value after the ??. In this case, if someObject.someMember doesn't hold a value, then it will be assigned the value of null. And then we're checking the value is exactly equal to null. If it is, then we step inside the code block. – Artist

I independently thought of this solution, however yours has a bug: Due to the operator precedence it is actually equivalent to if (someObject.someMember). You have to wrap the first part in parens like this: if ((someObject.someMember ?? null) === null). You can test what I'm saying by running for example false ?? null === null in the console. Notice that it is false – Stauder

You are right! Updated the example – Hawkinson

Answer 12

You can just check if the variable has a value or not. Meaning,

if( myVariable ) {
//mayVariable is not :
//null
//undefined
//NaN
//empty string ("")
//0
//false

}

If you do not know whether a variable exists (that means, if it was declared) you should check with the typeof operator. e.g.

if( typeof myVariable !== 'undefined' ) {
    // myVariable will get resolved and it is defined
}

Cene

Answer 13

Similar to what you have, you could do something like

if (some_variable === undefined || some_variable === null) { do stuff }

Mahlstick

Very obvious and easy to maintain code. Wish there was a specific operator for this (apart from '==') - something like '??some_variable' (akin to the Nullish coalescing operator, that groups 'null' and 'undefined' as falsy, but considers 0 as truthy). – Enough

Answer 14

whatever yyy is undefined or null, it will return true

if (typeof yyy == 'undefined' || !yyy) {
    console.log('yes');
} else {
    console.log('no');
}

yes

if (!(typeof yyy == 'undefined' || !yyy)) {
    console.log('yes');
} else {
    console.log('no');
}

no

Duotone

Answer 15

Open the Developer tools in your browser and just try the code shown in the below image.

Obstruent

Answer 16

If the purpose of the if statement is to check for null or undefined values before assigning a value to a variable, you can make use of the Nullish Coalescing Operator. According to the data from caniuse, it should be supported by around 85% of the browsers(as of January 2021). An example of the operator is shown below:

const a = some_variable ?? '';

This will ensure that the variable will be assigned to an empty string (or any other default value) if some_variable is null or undefined.

This operator is most suited for your use case, as it does not return the default value for other types of falsy value such as 0 and ''.

Legatee

Answer 17

As mentioned in one of the answers, you can be in luck if you are talking about a variable that has a global scope. As you might know, the variables that you define globally tend to get added to the windows object. You can take advantage of this fact so lets say you are accessing a variable called bleh, just use the double inverted operator (!!)

!!window['bleh'];

This would return a false while bleh has not been declared AND assigned a value.

Trimer

However, it will also return false for any falsey value: the question asks for a test that is equivalent to typeof(some_variable) != 'undefined' && some_variable != null. This answer is not equivalent to that. – Kuo

Answer 18

In order to understand, Let's analyze what will be the value return by the Javascript Engine when converting undefined , null and ''(An empty string also). You can directly check the same on your developer console.

You can see all are converting to false , means All these three are assuming ‘lack of existence’ by javascript. So you no need to explicitly check all the three in your code like below.

if (a === undefined || a === null || a==='') {
    console.log("Nothing");
} else {
    console.log("Something");
}

Also I want to point out one more thing.

What will be the result of Boolean(0)?

Of course false. This will create a bug in your code when 0 is a valid value in your expected result. So please make sure you check for this when you write the code.

Frank

Answer 19

With Ramda, you can simply do R.isNil(yourValue) Lodash and other helper libraries have the same function.

Showily

Answer 20

You can check with this value is present or not.

if(value){
    // True Condition
}else{
// False Condition
}

Above code will evaluate to true if value is not:

1. null
2. undefined
3. NaN
4. empty string ("")
5. 0
6. false

Whitver

Answer 21

I have done this using this method

save the id in some variable

var someVariable = document.getElementById("someId");

then use if condition

if(someVariable === ""){
 //logic
} else if(someVariable !== ""){
 //logic
}

Georgettageorgette

Answer 22

In ES5 or ES6 if you need check it several times you cand do:

const excluded = [null, undefined, ''];

if (!exluded.includes(varToCheck) {
  // it will bee not null, not undefined and not void string
}

Sonority

Answer 23

let varToCheck = ""; //U have to define variable firstly ,or it throw error
const excluded = [null, undefined, ""];

if (!excluded.includes(varToCheck)) {
  // it will bee not null, not undefined and not void string
  console.log("pass");
} else {
  console.log("fail");
}

for example I copy vladernn's answer to test, u can just click button "Copy snippets to answer" to test too .

Fritzsche

Answer 24

You can make use of lodash library.

_.isNil(value) gives true for both null and undefined

Test on - https://bazinga.tools/lodash

Federalize

Answer 25

Testing nullity (if (value == null)) or non-nullity (if (value != null)) is less verbose than testing the definition status of a variable.

Moreover, testing if (value) (or if( obj.property)) to ensure the existence of your variable (or object property) fails if it is defined with a boolean false value. Caveat emptor :)

Nucleolated

Answer 26

Best way to compare undefined or null or 0 with ES5 and ES6 standards

 if ((Boolean(some_variable_1) && Boolean(some_variable_2)) === false) {
    // do something
    }

Mogerly

Answer 27

you could use the following with nullish coalescing

//if statement evaluates to true only for null and undefined falsy values, false for others)

const val = ''; 

if(typeof val !== typeof(val ?? 1)) {
    console.log('Matches only null or undefined');
}else {
    console.log('Any other value');
}

Ellene

Answer 28

You must define a function of this form:

validate = function(some_variable){
    return(typeof(some_variable) != 'undefined' && some_variable != null)
}

Kathikathiawar

That will generate the same ReferenceError if the variable is undeclared. – Cloison

Answer 29

Both values can be easily distinguished by using the strict comparison operator.

Sample Code:

function compare(){
    var a = null; //variable assigned null value
    var b;  // undefined
    if (a === b){
        document.write("a and b have same datatype.");
    }
    else{
        document.write("a and b have different datatype.");
    }   
}

Shun