undefined in JavaScript: 5 Ways to Check (and Which One to Choose)

«Uncaught ReferenceError» — Your First Enemy? Learning to Properly Check for undefined in JavaScript

Everyone who has written even a couple of lines in JavaScript has encountered the mysterious undefined. It's not just an "empty space" — it's a full-fledged data type with its own value. But how do you catch it correctly? If you've Googled "How can I check for undefined in JavaScript", you're not alone: this question on Stack Overflow has gathered hundreds of thousands of views. The problem is that in JS there are several ways to check, and each has its pitfalls.

In this article, we'll break down 5 approaches, from simple to complex, compare their performance and reliability, and figure out which method to use in 2025. Let's go!

What is undefined Really?

Before checking, let's agree on terms. undefined is a primitive value that is assigned to a variable if it has been declared but not initialized:

let a;\nconsole.log(a); // undefined\n

Important: undefined ≠ null ≠ not defined. null is an intentional "nothing", while not defined (ReferenceError) is when a variable hasn't been declared at all. These nuances are critical for choosing the right check.

Method #1: The typeof Operator — The Gold Standard?

The most popular and safe way is to use typeof:

if (typeof x === 'undefined') {\n  console.log('x is not defined');\n}\n

Why does this work even for undeclared variables? typeof never throws a ReferenceError. If the variable doesn't exist, it simply returns the string "undefined".

Pros:

\n
• Safe for undeclared variables
\n
• Readable and understandable code
\n
• Works in all browsers and environments (Node.js, Deno)
\n

Cons:

\n
• A bit verbose for frequent use
\n
• Can be misleading for beginners (string comparison)
\n

Verdict: The best choice for global checks and cases where a variable might not be declared.

Method #2: Strict Comparison with undefined (===)

The second most popular way is to compare the value directly:

if (x === undefined) {\n  console.log('x is equal to undefined');\n}\n

There's a nuance here: the variable must be declared. If x doesn't exist, you'll get a ReferenceError. Therefore, this code is only safe for:

\n
• Object properties (obj.prop === undefined)
\n
• Function parameters
\n
• Variables declared with let, const, or var
\n

Pitfall: The Global undefined

In older browsers (IE 8 and below), undefined could be overwritten:

undefined = 'now I am a string'; // Nightmare!\n

This is now impossible (in strict mode), but if you support legacy code — better use typeof.

Verdict: An excellent method for local variables and object properties. Fast and concise.

Method #3: The void Operator

A little-known but elegant way is void 0:

if (x === void 0) {\n  console.log('x undefined');\n}\n

The void operator evaluates an expression and returns undefined. void 0 is the shortest way to get a pure undefined, independent of the global variable.

When is this useful?

\n
• In minified code (saves bytes)
\n
• In libraries where protection from undefined overriding is important
\n
• In functional programming (e.g., in promise chains)
\n

Con: Looks strange