❯ Types, Coercion & Equality

Roughly 15% of a typical loop — and 15% of the mock exam here.

The seven primitives, and the one that lies

JavaScript has seven primitives — string, number, boolean, null, undefined, symbol, bigint — plus objects. typeof reports all of them honestly except null, which returns 'object' because of how values were tagged in the first release. Test for it with value === null; nothing else distinguishes it.

Two more typeof results earn their own mention: typeof NaN is 'number', since NaN is an IEEE-754 double, and typeof function () {} is 'function', the only non-primitive with its own tag. Classes report 'function' too, because class is sugar over a constructor.

For everything else typeof is too coarse. Array.isArray(value) is the array check that survives iframes and workers, where instanceof Array fails because the other realm has its own Array constructor.

Truthiness: memorize the falsy list

Exactly eight values are falsy: false, 0, -0, 0n, '', null, undefined, NaN — plus the legacy document.all. Everything else is truthy, including [] and {}, which is why if (arr) never tells you whether an array has elements.

The practical consequence is the || default bug:

const shown = total || 'none';   // a legitimate 0 becomes 'none'
const fixed = total ?? 'none';   // only null/undefined become 'none'

?? tests nullishness, not truthiness. The same split applies to ||= versus ??=.

== versus ===, without hand-waving

=== returns false whenever the types differ. == converts first, following rules worth knowing rather than memorizing case by case:

• null == undefined is true, and both are loosely equal to nothing else — not 0, not false, not ''.
• Object versus primitive: the object is converted with ToPrimitive first. [] == false is true because [] becomes '' becomes 0, and false becomes 0.
• Two objects compare by reference. { a: 1 } === { a: 1 } is false for both operators.

Use === everywhere except the idiomatic x == null, which is a compact “null or undefined” test.

The relational operators follow different rules, which produces a classic puzzle: null >= 0 is true while null > 0 and null == 0 are both false. Relational comparison converts null to 0; loose equality has a special case that refuses to.

ToPrimitive: valueOf, toString, and Date

Converting an object to a primitive runs with a hint. For hints "default" and "number", valueOf is tried first, then toString; for hint "string" the order reverses. A Symbol.toPrimitive method, when present, replaces the whole lookup.

Date is the built-in that treats the default hint as "string", which is why date + 1 concatenates while +date yields epoch milliseconds.

Numbers: floating point, NaN, and -0

0.1 + 0.2 === 0.3 is false because binary64 doubles cannot represent either operand exactly; the sum is 0.30000000000000004. Compare with Math.abs(a - b) < Number.EPSILON for small magnitudes, and store money as integer cents or BigInt.

NaN is the only value not equal to itself, so x !== x detects it — as does Number.isNaN(x), which, unlike the global isNaN, does not coerce its argument first. Object.is differs from === in exactly two cases: it treats NaN as equal to NaN, and +0 as distinct from -0.

That distinction matters for collections. Array.prototype.includes, Map keys and Set members all use SameValueZero — NaN matches NaN — while indexOf, which uses strict equality, never finds it.

Parsing and serialization traps

Number('') is 0 but Number(undefined) is NaN; Number('0x1f') is 31 while Number('1_000') is NaN, because numeric separators are a source-code feature only. parseInt is a prefix parser, so parseInt('1e3') is 1 where Number('1e3') is 1000.

JSON.stringify drops undefined and functions from objects (turning them into null inside arrays), serializes NaN and Infinity as null, and throws on BigInt. structuredClone handles Date, Map, Set, typed arrays and cycles, but throws on functions and DOM nodes and drops class prototypes — it clones data, never behavior.