How do I check for null values in JavaScript?

Question

How can I check for null values in JavaScript? I wrote the code below but it didn't work.

if (pass == null || cpass == null || email == null || cemail == null || user == null) {
  alert("fill all columns");
  return false;
}

Torrietorrin

Are you sure the values you are testing are actually null and not just empty string? – Laurelaureano

testing null in js should be done with the strict operator === – Aplanospore

@Hogan, I meant strict, and I assume by the upvotes that the readers interpreted it that way... – Aplanospore

@Aplanospore - true, but not the problem here since if it were the statement would still work. – Babbling

@cwolves, if I thought it were the problem I would have made that comment an answer. Check out my wording, I'm clearly making a general statement about the language in reference to the OP's practise, and not proposing that this solves his problem. – Aplanospore

@ic3b3rg I think I agree with your rollbacks, but I'd be happier if you explained them. – Weatherman

@Weatherman the proposed changes fundamentally alter the nature of the question to the point where the answers (not just mine) lose context and don't make sense. The edit should just be a comment. – Cornela

Answer 1

JavaScript is very flexible with regards to checking for "null" values. I'm guessing you're actually looking for empty strings, in which case this simpler code will work:

if(!pass || !cpass || !email || !cemail || !user){

Which will check for empty strings (""), null, undefined, false and the numbers 0 and NaN.

Please note that if you are specifically checking for numbers, it is a common mistake to miss 0 with this method, and num !== 0 is preferred (or num !== -1 or ~num (hacky code that also checks against -1)) for functions that return -1, e.g. indexOf).

Babbling

It would be very useful to know which parts of this test for which values. Sometimes you're looking for one in particular. – Therefor

Somewhat of a late statement, but yes, you can perform test against each one @Therefor , see my answer below – Tuyettv

Readers, please be careful when using this type of test on numeric data. Do not use ! or !! to test for null or undefined on typically-numeric data unless you also want to throw away values of 0. – Innermost

Have to agree with NickS. If you're specifically testing for null, it's possible to get false positives with this type of boolean NOT test. This is an overbroad solution to a specific question. – Formic

The answer itself states this: "...and the numbers 0...". I believe this answer is perfectly appropriate for the question as given the context (which I'm inferring is "username, password, email"), they're not checking for 0 values. Given the popularity of this question and answer, however, I agree that it's worth mentioning in the answer itself. – Babbling

@zyklus Even if he is asking about usernames and passwords, it's possible that functions could be gathering the data from the forms and returning null if an empty string is found. But much more importantly, Stack Overflow questions come up as google results all the time, so many people who are curious how to check for a null value will be directed here and will see your answer first. It probably would have been best to answer the question that was asked and then address the specifics of this code. Sorry if that upsets you, SO asks me to comment when I downvote an answer so I am doing that. – Westland

@Westland - The context of answering a question for the 420,000 people that have seen this question is very different than the context of answering it for the OP. I'll consider re-wording the answer. – Babbling

Answer 2

To check for null SPECIFICALLY you would use this:

if (variable === null)

This test will ONLY pass for null and will not pass for "", undefined, false, 0, or NaN.

Additionally, I've provided absolute checks for each "false-like" value (one that would return true for !variable).

Note, for some of the absolute checks, you will need to implement use of the absolutely equals: === and typeof.

I've created a JSFiddle here to show all of the individual tests working

Here is the output of each check:

Null Test:

if (variable === null)

- variable = ""; (false) typeof variable = string

- variable = null; (true) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Empty String Test:

if (variable === '')

- variable = ''; (true) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number




Undefined Test:

if (typeof variable == "undefined")

-- or --

if (variable === undefined)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (true) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



False Test:

if (variable === false)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (true) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Zero Test:

if (variable === 0)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (true) typeof variable = number

- variable = NaN; (false) typeof variable = number



NaN Test:

if (typeof variable == 'number' && !parseFloat(variable) && variable !== 0)

-- or --

if (isNaN(variable))

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (true) typeof variable = number

As you can see, it's a little more difficult to test against NaN;

Tuyettv

What is the purpose of type checking if you use === strict equality? Thanks. Also for NaN test you can use isNaN(value) that will return true only if variable equals NaN. – Shrive

Is there a case where variable === null but is not of type "object"? If there is not, why not simplify the check to variable === null, throwing out the second conjunct? Thanks. – Pardoes

@HunanRostomyan Good question, and honestly, no, I do not think that there is. You are most likely safe enough using variable === null which I just tested here in this JSFiddle. The reason I also used ` && typeof variable === 'object'` was not only to illustrate the interesting fact that a null value is a typeof object, but also to keep with the flow of the other checks. But yes, in conclusion, you are safe to use simply variable === null. – Tuyettv

jsfiddle.net/neoaptt/avt1cgem/1 Here is this answer broken out into functions. Not very usefull, but I did it anyways. – Assets

I'm going to do something that is almost never a good idea: change the code in this answer. Specifically, remove the totally unnecessary test for type object, when checking for null. This is a fundamental code snippet: not a good idea to have even a single beginner mis-learn that they need to do that verbose test. – Verdi

@Verdi Yea, I think it's time to remove that, and to possibly clean this up. It is not necessary as part of the test, but was provided to note that null is typeof Object. It should be a comment instead. +1 – Tuyettv

Readers: Disregard my previous statements about isNaN. This is a perfectly fine way to test for the existence of NaN in JavaScript. – Tuyettv

Let me share a very interesting review I found about how null was erroneously typed as object: alexanderell.is/posts/typeof-null – Outsell

Answer 3

just replace the == with === in all places.

== is a loose or abstract equality comparison

=== is a strict equality comparison

See the MDN article on Equality comparisons and sameness for more detail.

Cornela

This only works if you consider undefined to be not null. Otherwise it will lead to a lot of unexpected behavior. Generally if you're interested in both null/undefined but not falsy values, then use == (one of the few cases when you should do so). – Socioeconomic

@AndrewMao undefined is not null: https://mcmap.net/q/20915/-what-is-the-difference-between-null-and-undefined-in-javascript – Cornela

I believe that's what @AndrewMao was saying, really. His first sentence might be rewritten "This only works in situations where undefined and null are not practical equivalents." – Glaring

@Glaring Thanks for clarifying my poor writing, I appreciate it :) – Socioeconomic

@AndrewMao You are very welcome. And I wouldn't call your writing poor, personally; I'd say it's a good deal better than average. :) – Glaring

Answer 4

You can check if some value is null as follows

[pass,cpass,email,cemail,user].some(x=> x===null) 

let pass=1;
let cpass=2;
let email=3;
let cemail=null;
let user=5;

if ( [pass,cpass,email,cemail,user].some(x=> x===null) ) {     
    alert("fill all columns");
    //return false;  
}   

BONUS: Why === is more clear than == (source)

a == b

a === b

Cynical

great 2 diagrams, I took the liberty of merging them both: docs.google.com/drawings/d/… – Hydrobomb

In addition to the 2 diagrams above. While if ([] == false) is true (as shown in your diagram), if ([]) also evaluates to true. – Japanese

In fact, they now have a merged table at dorey.github.io/JavaScript-Equality-Table/unified – Debbradebby

Answer 5

Strict equality operator:-

We can check null by ===

if ( value === null ){

}

Just by using if

if( value ) {

}

will evaluate to true if value is not:

• null
• undefined
• NaN
• empty string ("")
• false
• 0

Antenna

Answer 6

At first sight, it looks like a simple trade-off between coverage and strictness.

• == covers multiple values, can handle more scenarios in less code.
• === is the most strict, and that makes it predictable.

Predictability always wins, and that appears to make === a one-fits-all solution.

But it is wrong. Even though === is predictable, it does not always result in predictable code, because it overlooks scenarios.

const options = { };
if (options.callback !== null) {
  options.callback();      // error --> callback is undefined.
}

In general == does a more predictable job for null checks:

• In general, null and undefined both mean the same thing: "something's missing". For predictability, you need to check both values. And then == null does a perfect job, because it covers exactly those 2 values. (i.e. == null is equivalent to === null && === undefined)

• In exceptional cases you do want a clear distinction between null and undefined. And in those cases you're better of with a strict === undefined or === null. (e.g. a distinction between missing/ignore/skip and empty/clear/remove.) But it is rare.

It is not only rare, it's something to avoid. You can't store undefined in a traditional database. And you shouldn't rely on undefined values in your API designs neither, due to interopability reasons. But even when you don't make a distinction at all, you can't assume that undefined won't happen. People all around us indirectly take actions that generalize null/undefined (which is why questions like this are closed as "opinionated".).

So, to get back to your question. There's nothing wrong with using == null. It does exactly what it should do.

// FIX 1 --> yes === is very explicit
const options = { };
if (options.callback !== null && 
    options.callback !== undefined) {
  options.callback();
}


// FIX 2 --> but == covers both
const options = { };
if (options.callback != null) {
  options.callback();
}

// FIX 3 --> optional chaining also covers both.
const options = { };
options.callback?.();

Japanese

Answer 7

Improvement over the accepted answer by explicitly checking for null but with a simplified syntax:

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
}

// Test
let pass=1, cpass=1, email=1, cemail=1, user=1; // just to test

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
    console.log ("Yayy! None of them are null");
} else {
    console.log ("Oops! At-lease one of them is null");
}

Gast

Answer 8

Firstly, you have a return statement without a function body. Chances are that that will throw an error.

A cleaner way to do your check would be to simply use the ! operator:

if (!pass || !cpass || !email || !cemail || !user) {

    alert("fill all columns");

}

Whitney

That code is probably in a function, he just didn't show it ;) – Babbling

Answer 9

you can use try catch finally

 try {
     document.getElementById("mydiv").innerHTML = 'Success' //assuming "mydiv" is undefined
 } catch (e) {

     if (e.name.toString() == "TypeError") //evals to true in this case
     //do something

 } finally {}   

you can also throw your own errors. See this.

Pol

i think this qualifies as 'paranoid' code. if you really wrote something like this, it would be with an understanding that "mydiv" couldn't possibly not exist. we shouldn't reach this code unless we're confident that's the case, and we'd have plenty of avenues such as response codes to make sure we're confident before attempting such a line. – Maffa

Do not use try and catch for flow of control. This is not a good solution. – Braces

Up voting since this solution that was perfect for me to manipulate dynamically built DOM in four steps and on each step existed different set of elements. try {} catch {} solution prevent the script from error state on non existing elements and beautifully passed through and did the job. Thanks for the idea, @Pol – Biagio

Answer 10

to check for undefined and null in javascript you need just to write the following :

if (!var) {
        console.log("var IS null or undefined");
} else {
        console.log("var is NOT null or undefined");
}

Plantation

!var is true with 0, "", NaN, and false, too. – Shredding

Answer 11

In JavaScript, no string is equal to null.

Maybe you expected pass == null to be true when pass is an empty string because you're aware that the loose equality operator == performs certain kinds of type coercion.

For example, this expression is true:

'' == 0

In contrast, the strict equality operator === says that this is false:

'' === 0

Given that '' and 0 are loosely equal, you might reasonably conjecture that '' and null are loosely equal. However, they are not.

This expression is false:

'' == null

The result of comparing any string to null is false. Therefore, pass == null and all your other tests are always false, and the user never gets the alert.

To fix your code, compare each value to the empty string:

pass === ''

If you're certain that pass is a string, pass == '' will also work because only an empty string is loosely equal to the empty string. On the other hand, some experts say that it's a good practice to always use strict equality in JavaScript unless you specifically want to do the type coercion that the loose equality operator performs.

If you want to know what pairs of values are loosely equal, see the table "Sameness comparisons" in the Mozilla article on this topic.

Tripartite

Answer 12

Actually I think you may need to use if (value !== null && value !== undefined) because if you use if (value) you may also filter 0 or false values.

Consider these two functions:

const firstTest = value => {
    if (value) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}
const secondTest = value => {
    if (value !== null && value !== undefined) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}

firstTest(0);            // result: failed
secondTest(0);           // result: passed

firstTest(false);        // result: failed
secondTest(false);       // result: passed

firstTest('');           // result: failed
secondTest('');          // result: passed

firstTest(null);         // result: failed
secondTest(null);        // result: failed

firstTest(undefined);    // result: failed
secondTest(undefined);   // result: failed

In my situation, I just needed to check if the value is null and undefined and I did not want to filter 0 or false or '' values. so I used the second test, but you may need to filter them too which may cause you to use first test.

Albaugh

value !== null || value !== undefined is always true. I think you meant value !== null && value !== undefined. That's actually the same as value != null (which checks exactly for null and undefined.) – Japanese

@Japanese Sorry, in the code I used the correct expression, but up there I forgot :-D I fixed it, thank you. – Albaugh

Answer 13

The 'Object.is()' method can be used to determine if two values are the same value. So, you can use it to check whether the object is null or not.

Check for null values

let testA = null; //null
//console.log(Object.is(testA, null)); //true //null === null

if(Object.is(testA, null)) {
  console.log("This is a Null Value");
}

Output:
This is a Null Value

let x = null;
if (x === null) {
  console.log("x is null");
}

Output:
x is null

Check for undefined values (A variable has been declared, but a value has not been assigned.)

let testB; //undefined
//console.log(Object.is(testB, undefined)); //true //undefined === undefined

if(Object.is(testB, undefined)) {
  console.log("This is an undefined Value");
}

Output:
This is an undefined Value

If the object has not been declared, this cannot be used. As an alternative, you may try this:

if (typeof x === "undefined") {
  console.log("x is undefined");
}

Output:
The value is either undefined or null

---

Mozilla Object.is(): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is

Peria

Note by "undefined" here you mean that the variable is created/initialized but a value is just not assigned to it. "Undefined" typically means that the variable doesn't exist at all, and in that case your code wouldn't be applicable. – Irinairis

Answer 14

This is a comment on WebWanderer's solution regarding checking for NaN (I don't have enough rep yet to leave a formal comment). The solution reads as

if(!parseInt(variable) && variable != 0 && typeof variable === "number")

but this will fail for rational numbers which would round to 0, such as variable = 0.1. A better test would be:

if(isNaN(variable) && typeof variable === "number")

Shaina

Thanks for pointing out the bug Gabriel, I've put the fix into my answer. Aside from that, I was able to fix the test by changing parseInt to parseFloat (which should have been obvious to me in the first place). I avoided using the isNan function because I feel as if many developers view functions such as isNaN as some sort of "magic box" that values go into and booleans come out of, and I wanted to should the test a little more in depth. But yes, your suggested test will work and is perfectly fine to use. Sorry I didn't notice your post until now. – Tuyettv

Great, that seems to work. Thanks for the comment on why you avoided isNaN as well, I can get behind that logic. There's also the Underscore.js method, which seems even more confusing/blackbox, but worth noting anyway because it takes advantage of NaN !== NaN. Object.prototype.toString.call(variable) === '[object Number]' && variable !== +variable – Shaina

Answer 15

You can use lodash module to check value is null or undefined

_.isNil(value)
Example 

 country= "Abc"
    _.isNil(country)
    //false

   state= null
    _.isNil(state)
    //true

city= undefined
    _.isNil(state)
    //true

   pin= true
    _.isNil(pin)
    // false   

Reference link: https://lodash.com/docs/#isNil

Leesaleese

Answer 16

AFAIK in JAVASCRIPT when a variable is declared but has not assigned value, its type is undefined. so we can check variable even if it would be an object holding some instance in place of value.

create a helper method for checking nullity that returns true and use it in your API.

helper function to check if variable is empty:

function isEmpty(item){
    if(item){
        return false;
    }else{
        return true;
    }
}

try-catch exceptional API call:

try {

    var pass, cpass, email, cemail, user; // only declared but contains nothing.

    // parametrs checking
    if(isEmpty(pass) || isEmpty(cpass) || isEmpty(email) || isEmpty(cemail) || isEmpty(user)){
        console.log("One or More of these parameter contains no vlaue. [pass] and-or [cpass] and-or [email] and-or [cemail] and-or [user]");
    }else{
        // do stuff
    }

} catch (e) {
    if (e instanceof ReferenceError) {
        console.log(e.message); // debugging purpose
        return true;
    } else {
        console.log(e.message); // debugging purpose
        return true;
    }
}

some test cases:

var item = ""; // isEmpty? true
var item = " "; // isEmpty? false
var item; // isEmpty? true
var item = 0; // isEmpty? true
var item = 1; // isEmpty? false
var item = "AAAAA"; // isEmpty? false
var item = NaN; // isEmpty? true
var item = null; // isEmpty? true
var item = undefined; // isEmpty? true

console.log("isEmpty? "+isEmpty(item));

Berkly

What? This answer has nothing to do with this post. Did you post this answer on this thread by accident? – Tuyettv

This isEmpty function behaves exactly like !. No need to invent a function. Just do if (!pass || !cpass || !email ...). (Which is already shown in the accepted answer.) And per WebWanderer's comment, the middle part of this post, "try-catch exceptional API call", does not appear to be relevant to this question. Please explain your intent - when is that useful? How does that relate to the question? – Verdi

Answer 17

I found a another way to test if the value is null:

if(variable >= 0 && typeof variable === "object")

null acts as a number and object at the same time. Comparing null >= 0 or null <= 0 results in true. Comparing null === 0 or null > 0 or null < 0 will result in false. But as null is also an object we can detect it as a null.

I made a more complex function natureof witch will do better than typeof and can be told what types to include or keep grouped

/* function natureof(variable, [included types])
included types are 
    null - null will result in "undefined" or if included, will result in "null"
    NaN - NaN will result in "undefined" or if included, will result in "NaN"
    -infinity - will separate negative -Inifity from "Infinity"
    number - will split number into "int" or "double"
    array - will separate "array" from "object"
    empty - empty "string" will result in "empty" or
    empty=undefined - empty "string" will result in "undefined"
*/
function natureof(v, ...types){
/*null*/            if(v === null) return types.includes('null') ? "null" : "undefined";
/*NaN*/             if(typeof v == "number") return (isNaN(v)) ? types.includes('NaN') ? "NaN" : "undefined" : 
/*-infinity*/       (v+1 === v) ? (types.includes('-infinity') && v === Number.NEGATIVE_INFINITY) ? "-infinity" : "infinity" : 
/*number*/          (types.includes('number')) ? (Number.isInteger(v)) ? "int" : "double" : "number";
/*array*/           if(typeof v == "object") return (types.includes('array') && Array.isArray(v)) ? "array" : "object";
/*empty*/           if(typeof v == "string") return (v == "") ? types.includes('empty') ? "empty" : 
/*empty=undefined*/ types.includes('empty=undefined') ? "undefined" : "string" : "string";
                    else return typeof v
}

// DEMO
let types = [null, "", "string", undefined, NaN, Infinity, -Infinity, false, "false", true, "true", 0, 1, -1, 0.1, "test", {var:1}, [1,2], {0: 1, 1: 2, length: 2}]

for(i in types){
console.log("natureof ", types[i], " = ", natureof(types[i], "null", "NaN", "-infinity", "number", "array", "empty=undefined")) 
}

Stigma

Answer 18

I made this very simple function that works wonders:

function safeOrZero(route) {
  try {
    Function(`return (${route})`)();
  } catch (error) {
    return 0;
  }
  return Function(`return (${route})`)();
}

The route is whatever chain of values that can blow up. I use it for jQuery/cheerio and objects and such.

Examples 1: a simple object such as this const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};.

But it could be a very large object that we haven't even made. So I pass it through:

let value1 = testobj.items[2].val;  // "hum!"
let value2 = testobj.items[3].val;  // Uncaught TypeError: Cannot read property 'val' of undefined

let svalue1 = safeOrZero(`testobj.items[2].val`)  // "hum!"
let svalue2 = safeOrZero(`testobj.items[3].val`)  // 0

Of course if you prefer you can use null or 'No value'... Whatever suit your needs.

Usually a DOM query or a jQuery selector may throw an error if it's not found. But using something like:

const bookLink = safeOrZero($('span.guidebook > a')[0].href);
if(bookLink){
  [...]
}

Tug

Answer 19

Simple Solution for empty values:

function isEmpty(value) {
        return (
            value === null || value === undefined || value === '' ||
            (Array.isArray(value) && value.length === 0) ||
            (!(value instanceof Date) && typeof value === 'object' && Object.keys(value).length === 0)
        );
    }

Sidewalk

Answer 20

This is a very non-human code. But works:

if((pass, cpass, email, cemail, user !== null)){

Just try it out and help the answer

Airsick

it is simple and it works , so if (xxxx==null) {xxxx'} – Ryeland

Answer 21

What about optional check with operator ?

for example:

// check mother for null or undefined and 
// then if mother exist check her children also
// this 100% sure it support and valid in JS today.
// Apart of that C# have almost the same operator using the same way
if (mother?.children) {

}
else {
 // it is null, undefined, etc...

}

Centum

Answer 22

Try this:

if (!variable && typeof variable === "object") {
    // variable is null
}

Motteo

null is only thing that is "falsy" and typeof returns "object". – Motteo

How is that better than if (variable === null)? Also someone already provided that answer last year: https://mcmap.net/q/53557/-how-do-i-check-for-null-values-in-javascript . – Katiekatina

Answer 23

This will not work in case of Boolean values coming from DB for ex:

 value = false

 if(!value) {
   // it will change all false values to not available
   return "not available"
 }

Intuitionism

Answer 24

Checking error conditions:

// Typical API response data
let data = {
  status: true,
  user: [],
  total: 0,
  activity: {sports: 1}
}

// A flag that checks whether all conditions were met or not
var passed = true;

// Boolean check
if (data['status'] === undefined || data['status'] == false){
  console.log("Undefined / no `status` data");
  passed = false;
}

// Array/dict check
if (data['user'] === undefined || !data['user'].length){
  console.log("Undefined / no `user` data");
  passed = false;
}

// Checking a key in a dictionary
if (data['activity'] === undefined || data['activity']['time'] === undefined){
   console.log("Undefined / no `time` data");
   passed = false;
}

// Other values check
if (data['total'] === undefined || !data['total']){
  console.log("Undefined / no `total` data");
  passed = false;
}

// Passed all tests?
if (passed){
  console.log("Passed all tests");
}

Royalroyalist