How can I check for "undefined" in JavaScript?

Checks and (possibly) imbalances

While the above solutions are handy for most cases, surviving in the wild of JavaScript requires deeper insights to evade typical pitfalls.

Direct match-up with undefined

In the modern worlds of JavaScript (from ECMAScript 5 onwards), undefined has a steady personality - it's immutable. This heightens the trustworthiness of direct comparisons:

if (myVar === undefined) {
  // myVar is as 'undefined' as a ghost in broad daylight
}


But, always remember: You better have introduced myVar before; else, this method will throw a ReferenceError in strict mode scripts.

Trusty sidekick: typeof

The typeof operator backs you up, guarding you from ReferenceErrors, even if your variable is hanging out in the twilight zone of undeclared:

if (typeof myVar === "undefined") {
  // No ReferenceError. Yes, we got your back!
}


This road is far from the fears of undefined being messed with and doesn't tremble with errors if the variable hasn't been welcomed globally yet.

Global variables: Closer than you think

The plot thickens when global variables try to sneak around. if (window.myVar) can misunderstand and fail for falsy values, not just undefined. The '"theVar" in window' check slyly verifies:

if ("myVar" in window) {
  // The name's Var, myVar. I exist on a global scale.
}


Heads up! window.myVar might have getters that unexpectedly explode, making typeof myVar !== 'undefined' the hero saving your day (check) for globals.

Don't let unchecked conditions catch you off guard

An unchecked condition (if (myVariable)) is like a boobytrap that throws ReferenceError if myVariable has not been declared. Always make your declaration first, then walk into the line of fire:

let myVariable;
if (myVariable) {
  // Walk in like a pro; myVariable is ready and waiting
}


Going with typeof is like wearing an invisibility cloak against these issues and prevents getter tantrums.

Player 'void 0' joins the game

There's another player in the game to verify undefined consistently — void 0. It's the shadowy figure in the corner that always amounts to undefined:

if (myVar === void 0) {
  // We've achieved peak 'undefined'-ness!
}


Although it's more of a secret handshake than an open-door policy, it's just as legit.

Modern JavaScript to the rescue

Nowadays, we need not fear any undefined monsters under our beds. Direct comparisons have our back:

if (myVariable === undefined) {
  // Aha! So, we meet again, 'undefined'
}


Lint tools, like the trusty aides they are, will sound the alarm if undefined has been meddled with.

Defensiveness isn’t always the best policy

Forget overthinking when you are master of your environment, especially in the heavenly gardens of modern JavaScript. Extra checks are like those uninvited plus ones—crowding your code, tarnishing readability, and offering no real advantage.

Stay alert with prototype inheritance

Keep in mind, typeof isn't a fan of venturing into the realms of prototype chains. For objects flaunting inherited properties, you might need a different suit of armor.

Performance: The phantom menace?

In the agile world of modern JavaScript engines, performance differences between ways of checking undefined are about as significant as a hiccup. Put your priority points on clarity and dodging errors, not chasing after elusive performance ghost gains.

The art of survival

Declare your variables before checking, or face the wrath of ReferenceError. Always use === for comparisons to ward off the evil spirit of type coercion. Never forget to check for a variable's existence before daring to compare it to anything, or else errors lurk in the shadows.

Polishing your undefined inspection skills

Simplicity scores points

Adhere to standard constructs and show favor to direct checks where feasible. Your code will breathe more freely in modern or known realms.

Tool up or step down

Lean on linting tools to catch the whiff of undefined getting tangoed with or play the accidental global usage card.

Context is the key

The best practices read like fairy tales but remember to play according to your surroundings and situation. JavaScript in your favorite web browser might dance differently than the server-side Node.js code.