Values, types, and the equality trap

JavaScript has seven primitive types: string, number, boolean, undefined, null, symbol, and bigint. Everything else — arrays, functions, dates, plain objects — is an object. There is no separate integer type: 1 and 1.5 are both a number (bigint, written 10n, is a separate type for integers of any size).

typeof "hi";          // "string"
typeof 42;             // "number"
typeof undefined;      // "undefined"
typeof null;           // "object" — an old bug nobody can fix now
typeof [];               // "object"
typeof (() => {});       // "function"

typeof null returning "object" is not a design choice; it is a bug from JavaScript's first implementation that shipped before anyone could fix it without breaking the web. Comparing value === null directly is the reliable way to ask.

Truthy and falsy

Every value is truthy in a boolean context except a short, fixed list: false, 0, -0, 0n (the bigint zero), "", null, undefined, and NaN. Everything else — including "0", [], and {} — is truthy.

if ("0") console.log("truthy");   // runs: a non-empty string
if ([]) console.log("truthy");    // runs: an object, always truthy

Try it

== against ===

== compares after converting both sides to a common type. === compares without converting anything. The conversion rules for == are a genuine, memorised list of special cases:

0 == "0";           // true  — the string converts to a number
0 == "";            // true  — empty string converts to 0
0 == false;         // true  — false converts to 0
null == undefined;  // true  — the one pair == treats as equal to each other
null == 0;          // false — == never converts null: it equals only null and undefined
"" == "0";          // false — neither side is a number here, plain string compare

Nobody has that table memorised reliably, which is why the convention is: use === and !== everywhere, and reach for == only for the one legitimate case — value == null, which is true for both null and undefined and nothing else.

NaN is never equal to anything, including itself

NaN === NaN;         // false
Number.isNaN(NaN);   // true — the reliable check

isNaN(x) (the global, not Number.isNaN) first converts x to a number, so isNaN("hello") is also true. Use , which never converts its argument. Every comparison in this lesson, run:

Common mistakes

• if (value) to mean "was something supplied". It also rejects 0 and "", which are often valid input — a quantity of zero, an empty search box. Compare against null and undefined instead.
• typeof x === "object" to mean "x is an object". It is also true for null, so the next x.prop throws. Add x !== null.
• x === NaN. Always false, even when x is NaN. Use Number.isNaN(x).
• Comparing form input with ==. 0 == "" is true, so an empty field quietly equals zero.

What interviewers ask

• What does typeof null return, and why? — : a bug from the first implementation, kept so old pages keep working. Test with .