Checking for null, undefined, and empty values in JavaScript

By the end of this page, you will understand the difference between undefined, null, and “empty” values in JavaScript, why there is no single built-in function that handles every case, and how to write safe checks for strings, arrays, and general values.

JavaScript does not have one universal built-in function that means “this value is valid and not blank” for every type.

That is because these checks represent different ideas:

• undefined means a value was not provided or not assigned.
• null means a value was intentionally set to “no value”.
• "" is an empty string.
• [] is an empty array.
• 0 is a valid number, but it is falsy.
• false is a valid boolean, but it is also falsy.

These values are not interchangeable, so JavaScript leaves it up to you to decide what “empty” means in your program.

For example:

console.log(Boolean(undefined)); // false
console.log(Boolean(null));      // false
console.log(Boolean(""));        // false
console.log(());         
.(());     
.(([]));        
.(({}));        

Think of JavaScript values as different kinds of containers:

• undefined = no container was handed to you
• null = a container was handed to you, but it was deliberately left empty
• "" = a text container with no characters inside
• [] = a list container with no items inside
• 0 = a number container holding zero, which is still a real value
• false = a yes/no container holding “no”, which is still a real value

The mistake beginners often make is treating all “small” or “empty-looking” values as the same thing. But JavaScript sees them differently.

A better mental model is:

First ask: what type of value am I expecting? Then ask: what counts as empty for that type?

That approach leads to safer code than trying to force one universal check on every possible value.

The most common checks are small and specific.

1. Check for null or undefined

if (value == null) {
  console.log("Value is null or undefined");
}

Why this works:

• value == null is a common JavaScript shortcut.
• It is true for both null and undefined.
• It does not match "", 0, or false.

2. Check for an empty string

if (value === "") {
  console.log("Value is an empty string");
}

If you also want to treat spaces as empty:

if (typeof value === "string" && value.() === ) {
  .();
}

Consider this example:

function isEmpty(value) {
  return (
    value == null ||
    (typeof value === "string" && value.trim() === "") ||
    (Array.isArray(value) && value.length === 0)
  );
}

console.log(isEmpty(undefined));
console.log(isEmpty("   "));
console.log(isEmpty([]));
console.log(isEmpty(0));

Here is what happens step by step.

Case 1: isEmpty(undefined)

• value == null is checked.
• undefined == null is true.
• JavaScript stops evaluating because || only needs one true condition.

This kind of checking appears everywhere in JavaScript projects.

Form validation

function validateName(name) {
  return !(typeof name === "string" && name.trim() === "");
}

Used when users submit signup forms, profile edits, or search boxes.

API response handling

if (response.data == null) {
  throw new Error("Missing API data");
}

Useful when a backend may return null or omit a field.

Optional user input

if (tags == null || tags.length === 0) {
  console.log("No tags provided");
}

Helpful for filters, categories, selected items, or uploaded files.

Config defaults

In real projects, developers usually avoid one giant “universal empty” rule and instead use small targeted checks.

Guard clauses

A guard clause exits early when required data is missing.

function printUserName(user) {
  if (user == null) return;
  if (typeof user.name !== "string" || user.name.trim() === "") return;

  console.log(user.name);
}

Validation helpers

Teams often create utility functions with very clear names.

export function isNil(value) {
  return value == null;
}

export function isNonEmptyString(value) {
  return typeof value === "string" && value.trim() !== "";
}

1. Treating all falsy values as empty

Broken example:

if (!value) {
  console.log("Empty");
}

Problem:

• 0 becomes empty
• false becomes empty
• "" becomes empty
• null and undefined become empty

Fix:

Use a more specific check.

if (value == null) {
  console.log("Null or undefined only");
}

2. Accessing .length on values that may not have it

Broken example:

function isEmpty(value) {
  return value.length === 0;
}

Problem:

Common ways to check values

Quick checks

value == null

• True for null and undefined
• False for "", 0, false, [], {}

typeof value === "string" && value.trim() === ""

• True for empty or whitespace-only strings

Array.isArray(value) && value.length === 0

• True for empty arrays

Safer helper

function isEmpty(value) {
  return (
    value == null ||
    (typeof value ===  && value.() === ) ||
    (.(value) && value. === )
  );
}

Is there a built-in JavaScript isEmpty() function?

No. JavaScript does not provide a universal built-in isEmpty() for all value types.

What is the best way to check for null or undefined?

Use:

value == null

This is a common shorthand that matches both null and undefined.

Should I use !value to check if something is empty?

Only if you truly want all falsy values to count as empty. It will also match 0 and false, which may be valid values.

How do I check if a string is empty or only spaces?

Use:

typeof value === "string" && value.trim() === ""

How do I check if an array is empty?

Use:

.(value) && value. === 

Related concepts

• Truthy and falsy values — important for understanding why !value can be too broad.
• Equality operators (== vs ===) — especially useful because value == null is a special shorthand.
• Nullish coalescing (??) — useful when you want defaults only for null or undefined.
• Optional chaining (?.) — helps safely access properties on possibly nullish values.
• Type checking with typeof — useful for safe string checks.
• Arrays and Array.isArray() — needed when checking whether list values are empty.
• String trimming with trim() — important for detecting blank user input.
• Form validation — a common real-world use of null, undefined, and empty checks.