When null Pretends to Be an Object

There’s a moment in learning JavaScript where something small breaks your mental model.

You write:

typeof null

And JavaScript calmly replies:

"object"

At first, it feels like you misunderstood something. Maybe null is an object? Maybe there’s some hidden structure behind it?

But the truth is much simpler—and stranger.

It’s a mistake.

null Was Meant to Mean “Nothing”

Conceptually, null represents the absence of a value.

It’s JavaScript’s way of saying:

“This variable intentionally points to nothing.”

So if you think in terms of meaning:

null → no value

It is not an object. It doesn’t contain properties. It doesn’t behave like {}.

It’s just… empty.

So Why Does typeof null Return "object"?

To understand this, we need to go back to the early days of JavaScript.

In its first implementation, JavaScript represented values internally using a system of type tags. Each value stored in memory had a small identifier that told the engine what kind of value it was.

Objects were tagged in a particular way, often using a bit pattern like:

000

Unfortunately, null was represented as a null pointer, which also ended up looking like:

000

So when the engine checked the type tag, it couldn’t distinguish between:

• an actual object
• the null value

And it reported both as:

"object"

Why This Was Never Fixed

At this point, you might wonder:

“Why not just fix it?”

The problem is that JavaScript became widely used very quickly. By the time this behavior was recognized as a mistake, real-world code already depended on it.

Changing it would break existing applications.

So the language kept the behavior.

What started as a low-level implementation detail became a permanent part of JavaScript.

A Language Shaped by History

This is one of the clearest examples of how JavaScript is shaped not just by design decisions, but by historical constraints.

Unlike newer languages that can refine their type systems over time, JavaScript must remain compatible with decades of existing code.

So instead of being corrected, this behavior was effectively “locked in.”

What This Means in Practice

Because of this quirk, typeof is not always reliable for distinguishing values.

For example:

typeof {}   // "object"
typeof []   // "object"
typeof null // "object"

These three values are completely different in meaning, but typeof groups them together.

So if you need to specifically check for null, you should do:

value === null

Rather than relying on typeof.

A Small Window Into JavaScript’s Internals

This behavior might feel like a flaw, but it also reveals something deeper.

JavaScript is not a perfectly clean system built from scratch. It’s a language that evolved under real-world constraints, carrying decisions made in its earliest days.

The fact that typeof null === "object" is not just a quirk to memorize. It’s a reminder that behind the syntax and abstractions, there’s an implementation history shaping everything.

And sometimes, that history leaks through in surprising ways.