How to Check for undefined or null in JavaScript

By the end of this page, you will understand the difference between undefined and null in JavaScript, how to test for each one correctly, when to use == null, when to use strict checks, and why comparing to the string "undefined" is incorrect.

In JavaScript, undefined and null are special values that both represent “no useful value,” but they are not the same thing.

• undefined usually means a value was not assigned or does not exist.
• null usually means a value was intentionally set to “nothing.”

In your example, this line:

var EmpName = $("div#esd-names div#name").attr("class");

asks jQuery for the class attribute of the #name element. Since the element exists but has no class attribute, jQuery returns undefined.

The important detail is this:

if (EmpName == "undefined")

checks whether EmpName is equal to the string "undefined", not the special JavaScript value undefined.

Think of JavaScript values like items in storage boxes:

• A normal value like "Alice" means the box contains something useful.
• null means the box is there, but someone deliberately left it empty.
• undefined means the box was never filled, or maybe it was never set up at all.

Now imagine writing a label check:

• Checking for undefined means: “Was nothing ever put here?”
• Checking for null means: “Was this intentionally emptied?”
• Checking == null means: “Is this missing in either of those two common ways?”

Comparing to "undefined" is like checking whether the box contains a note that literally says undefined, instead of checking whether the box is actually empty.

Core syntax

Check only for undefined

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

Check only for null

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

Check for either null or undefined

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

This is one of the few common cases where loose equality == is intentionally useful, because:

null == undefined // true

but it does not match other falsy values like:

Consider this example:

var empName = $("#esd-names #name").attr("class");

if (empName == null) {
  console.log("Missing class");
} else {
  console.log("Class is:", empName);
}

Step-by-step

1. JavaScript selects the element with id name inside #esd-names.
2. jQuery tries to read its class attribute.
3. The element exists, but no class attribute is present.
4. jQuery returns undefined.
5. The condition empName == null is evaluated.
6. In JavaScript, undefined == null is true.
7. The first branch runs and prints:

Missing class

Trace with a class present

Checking for undefined and null is common in many practical situations.

1. Reading optional object properties

if (user.middleName == null) {
  console.log("No middle name provided");
}

2. Handling API data

APIs may omit a field entirely (undefined) or send it as null.

if (response.data.address == null) {
  console.log("Address is unavailable");
}

3. Validating function arguments

function greet(name) {
  if (name == null) {
    name = "Guest";
  }
  console.log("Hello, " + name);
}

4. Checking DOM attributes

In real codebases, developers usually do not check for undefined and null randomly. They use them as part of clear patterns.

Guard clauses

Stop early if required data is missing.

function renderUser(user) {
  if (user == null) {
    return;
  }

  console.log(user.name);
}

Default values

Provide a fallback when a value is missing.

function getDisplayName(name) {
  return name == null ? "Anonymous" : name;
}

Validation before using data

function saveEmail(email) {
  if (email == null) {
    throw new Error("Email is required");
  }

  console.(, email);
}

1. Comparing to the string "undefined"

This is the mistake from the original question.

Broken

if (empName == "undefined") {
  // wrong
}

Correct

if (empName === undefined) {
  // correct
}

2. Using a falsy check when you only mean nullish values

Problem

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

This also matches:

• 0
• false
• ""
• NaN

That may be wrong.

Better

if (value == null) {
  .();
}

// exact checks
value === undefined
value === null

// check for either null or undefined
value == null

// avoid if you only mean null/undefined
!value

Quick rules

• undefined is a value, not a string.
• "undefined" is text, not the same thing.
• Use === undefined to check only for undefined.
• Use === null to check only for null.
• Use == null to check for both null and undefined.
• Do not use !value unless you also want to catch 0, false, and empty strings.

jQuery example

var cls = $("#name").attr("class");

if (cls === undefined) {
  console.log("No class attribute");
}

Safe default pattern

What is the difference between undefined and null in JavaScript?

undefined usually means a value is missing or was never assigned. null usually means a value was intentionally set to empty.

Should I use === undefined or == null?

Use === undefined if you want only undefined. Use == null if you want both null and undefined.

Why is "undefined" wrong?

Because it is a string. JavaScript's undefined is a special value, not text.

Does !value mean the same as value == null?

No. !value also matches 0, false, "", and .

• strict equality (===) - Important for exact comparisons without type coercion.
• loose equality (==) - Relevant because value == null intentionally matches both null and undefined.
• truthy and falsy values - Helps explain why !value is broader than a null check.
• optional chaining - Useful for safely reading nested properties that may be missing.
• default values - Often used after null or undefined checks.
• object properties - Missing properties commonly evaluate to undefined.
• DOM attribute access - DOM and jQuery methods often return missing values that need checking.