Check if a Variable is Not NULL in JavaScript

Check if a Variable is Not NULL in JavaScript #

Use the strict inequality (!==) operator to check if a variable is not null, e.g. myVar !== null.

The strict inequality operator will return true if the variable is not equal to null and false otherwise.

Copied!
const a = 'hello';

// ✅ check if a variable is NOT null
if (a !== null) {
  // 👇️ this runs
  console.log('the variable is NOT null');
} else {
  console.log('the variable is null');
}

// -------------------------------------

// ✅ check if a variable is NOT null and undefined
if (a != null) {
  // 👇️ this runs
  console.log('the variable is NOT null and undefined');
} else {
  console.log('The variable is null or undefined');
}

// -------------------------------------

// ✅ check if a variable has been declared (without errors)

if (typeof abcd !== 'undefined') {
  console.log('The variable has been declared');
} else {
  // 👇️ this runs
  console.log('The variable is undeclared or set to undefined');
}

We used the strict inequality (!==) operator to check if the value stored in a variable is not equal to null.

The operator returns a boolean result:

• true if the values are not equal
• false if the values are equal

Copied!
console.log(null !== null); // 👉️ false
console.log('hello' !== null); // 👉️ true

The strict inequality (!==) operator considers two values of different types to be different, as opposed to the loose inequality (!=) operator.

This means that if you compare null with any other type, the strict inequality (!==) operator will always return false.

Copied!
const a = 'hello';

if (a) {
  console.log(`🚨 a is NOT
       false, 0, empty string, null, undefined, NaN`);
} else {
  console.log(`⛔️️ a is ONE OF
       false, 0, empty string, null, undefined, NaN`);
}

In this example, we check if the value stored in the variable a is truthy. Truthy are all values that are not falsy.

The falsy values in JavaScript are: false, 0, "", null, undefined, NaN.

Things could go wrong in many different ways when doing this. For example, if the value of a is equal to 0, the else block would run.

Copied!
const a = 0;

if (a) {
  console.log("⛔️ This doesn't run");
} else {
  console.log('✅ This runs');
}

Even if this is what you want, it is better to be explicit.

Copied!
const a = 0;

if (a === 0) {
  console.log('✅ This runs');
} else {
  console.log("⛔️ This doesn't run");
}

It's always recommended to explicitly use the strict operators (!==, ===) when making equality comparisons. They make your code more readable, explicit and less prone to errors.

One exception is when you need to check if a variable is not nullish.

Check if a variable is NOT nullish in JavaScript #

Here are 2 examples of checking if a variable is not nullish (null and undefined).

Copied!
const a = 'hello';

// ✅ check if a variable is NOT null and undefined
if (a != null) {
  // 👇️ this runs
  console.log('the variable is NOT null and undefined');
} else {
  console.log('The variable is null or undefined');
}

// -------------------------------------

// ✅ check if a variable is NOT nullish (null and undefined)

if (a !== null && a !== undefined) {
  // 👇️ this runs
  console.log('the variable is NOT null and undefined');
} else {
  console.log('The variable is null or undefined');
}

The first example uses the loose inequality (!=) operator.

Copied!
const a = 'hello';

if (a != null) {
  // 👇️ this runs
  console.log('the variable is NOT null and undefined');
} else {
  console.log('The variable is null or undefined');
}

The expression a != null checks if the variable a is not equal to both null and undefined.

When using the loose equality (==) operator, null is equal to undefined.

Copied!
// 👇️ loose equality
console.log(null == undefined); // 👉️ true

// 👇️ strict equality
console.log(null === undefined); // 👉️ false

An alternative approach to check if a variable is not nullish (null and undefined) is to be explicit and use the logical AND (&&) operator.

Copied!
const a = 'hello';

if (a !== null && a !== undefined) {
  // 👇️ this runs
  console.log('the variable is NOT null and undefined');
} else {
  console.log('The variable is null or undefined');
}

We used the logical AND (&&) operator, so for the if block to run, both conditions have to be met.

The first condition checks if the variable is not equal to null and the second checks if the variable is not equal to undefined.

Check if a variable has been declared in JavaScript #

Use the typeof operator to check if a variable has been declared, e.g. if (typeof abcd !== 'undefined') {}.

The typeof operator won't throw an error even if the variable has not been declared.

Copied!
if (typeof abcd !== 'undefined') {
  console.log('The variable has been declared');
} else {
  // 👇️ this runs
  console.log('The variable is undeclared or set to undefined');
}

Notice that the abcd variable has not been declared, but no error occurs when running the code sample.

The typeof operator returns a string that indicates the type of a value.

Once you find that the variable has been declared, you can check if the variable is not null.

Copied!
if (typeof abcd !== 'undefined') {
  console.log('The variable has been declared');

  if (abc !== null) {
    console.log('The variable is not null');
  } else {
    console.log('The variable is null');
  }
} else {
  // 👇️ this runs
  console.log('The variable is undeclared or set to undefined');
}

Once we enter the if block, we know that the variable has been declared and we can safely access it.

The inner if statement checks if the variable is not null.

Which approach you pick is a matter of personal preference. I always use the direct not null check - if (a !== null) {}.

In my experience, it's better to be explicit even if it makes your code more verbose.

Getting an error is not necessarily a bad thing because most of the time, it surfaces a bug in your application.