undefined or null in JavaScript: How to Check a Variable in 2025

"Variable is not defined": why does this question torment everyone?

If you've ever written in JavaScript, you've definitely encountered this situation: you run the code, and in the console there's a red message Uncaught TypeError: Cannot read properties of undefined. Or even worse — null is not an object. Sound familiar? This is one of the most common errors that plagues developers of all levels.

The question "How can I determine if a variable is 'undefined' or 'null'?" on Stack Overflow has gathered thousands of views and hundreds of answers. And for good reason: in JavaScript, these two values are similar but behave differently. In 2025, when code becomes more complex and projects become larger, the ability to correctly check for undefined and null transforms from "good to know" to "must know".

In this article, we'll break down all the checking methods, from simple to advanced, and show which methods are worth using in modern development. Let's go!

undefined vs null: what's the difference?

Before checking, let's understand what we're dealing with. In JavaScript, undefined and null are two different primitive values, each with its own type.

undefined

undefined is a value that is automatically assigned to a variable if you declared it but didn't assign a value. Also, a function returns undefined if it doesn't have an explicit return.

let myVar;\nconsole.log(myVar); // undefined\n\nfunction doNothing() {}\nconsole.log(doNothing()); // undefined\n\nconsole.log(someNonExistentVariable); // ReferenceError, but if accessing an object property:\nconst obj = {};\nconsole.log(obj.prop); // undefined\n

null

null is a value that a developer assigns intentionally. It means "empty", "nothing", "value is absent". null is an object from the typeof perspective (yes, this is a historical bug, but it has already become a feature).

let myVar = null;\nconsole.log(myVar); // null\nconsole.log(typeof myVar); // "object" — yes, that's right!\n

The main difference: undefined is "not yet assigned", while null is "intentionally empty". But with loose comparison, they are equal:

console.log(null == undefined); // true\nconsole.log(null === undefined); // false\n

It is precisely because of this loose equality that confusion arises. Therefore, the best practices of 2025 recommend using strict comparison (===).

Top 5 ways to check for undefined and null

Let's break down all the popular methods, from the simplest to the most modern. We'll evaluate each by three criteria: readability, reliability, and performance.

1. Strict comparison (===) — the gold standard

The most direct and understandable way is to compare the variable directly with undefined or null using ===.

let value = null;\n\n// Check for null\nif (value === null) {\n    console.log('This is null');\n}\n\n// Check for undefined\nif (value === undefined) {\n    console.log('This is undefined');\n}\n\n// Check for null OR undefined (separately)\nif (value === null || value === undefined) {\n    console.log('Value is absent');\n}\n

Why is this the best practice?

\n
• Maximally readable — any developer will understand what you are checking.
\n
• No unexpected type coercions.
\n
• Works in all versions of JavaScript, including the oldest ones.
\n

Drawback: If you need to check both values at once, you have to write two conditions. But this is solved with the || operator, as in the example above.

2. Nullish coalescing operator (??) — a new feature that has caught on

Starting from ES2020, JavaScript introduced the ?? operator (nu