You don't usually have to create undefined yourself, JavaScript hands it to you automatically in a few very specific situations.

A variable that's declared but never given a value:

let name;
console.log(name); // undefined

function greet() {
  console.log("Hello!");
}

let result = greet(); // logs "Hello!"
console.log(result);  // undefined

let user = { name: "Vi" };
console.log(user.age); // undefined

function sayHi(name) {
  console.log(name);
}

sayHi(); // undefined

The most reliable way to check for undefined is a direct comparison.

let value;

if (value === undefined) {
  console.log("Nothing here yet");
}

Using typeof works too, and it has one specific advantage, it won't throw an error even if the variable was never declared at all.

console.log(typeof someRandomVariable); // "undefined"

Comparing directly with === against a variable that was never declared, on the other hand, throws a real error, so typeof is the safer option when you're not sure if something exists at all.
 

Undefined vs Null: The Classic Mix-Up

This is genuinely one of the most common points of confusion in JavaScript. Both feel like they mean "nothing," but they represent two different kinds of nothing.

let notSet;
let empty = null;

console.log(notSet); // undefined, JavaScript set this automatically
console.log(empty);  // null, a developer set this on purpose

Think of it this way: undefined usually means "this hasn't been given a value yet," while null means "this was intentionally set to have no value." One happens by accident of omission, the other is a deliberate choice.

There's one genuinely odd historical quirk worth knowing here too:

console.log(typeof null); // "object"

That's a long-standing bug baked into the language from its early days. It's been there so long that fixing it would break too much existing code, so it just stays as one of JavaScript's well-known oddities.
 

Loose vs Strict Equality Between the Two

This trips people up regularly, so it's worth seeing directly.

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

Loose equality (==) treats them as equivalent, since they both represent an absence of value. Strict equality (===) checks the actual type too, and since they're different types, it correctly says they're not equal.

Conclusion

undefined isn't really something to be afraid of once you know its handful of triggers, an unset variable, a function with no explicit return, a missing property, or a missing argument. The real trick is just telling it apart from null when you see one of them, remembering that undefined is JavaScript's own default, while null is something a developer actually chose to set. Once that distinction clicks, a lot of confusing debugging moments stop being confusing at all.
 

Frequently Asked Questions (FAQs)

1.Should I ever manually set a variable to undefined?

Generally no, it's better practice to use null if you want to intentionally represent an empty value. undefined is meant to be JavaScript's own signal that something was never set in the first place.

2.Why does typeof null return "object" instead of "null"?

It's a long-standing bug from JavaScript's very first version, kept around because fixing it now would break too much existing code across the web.

3.Is checking if (!value) a safe way to check for undefined?

Not entirely, since that same condition is also true for null, 0, an empty string, and a few other falsy values. If you specifically need to check for undefined, use === undefined or typeof value === "undefined" instead.