Truthy, Falsy, and ToBoolean

## What "truthy" actually means JavaScript never asks whether a value *is* a boolean when you write a condition. It applies an internal conversion the specification calls **ToBoolean** — an abstract operation, not a function you can call directly, though `Boolean(x)` and `!!x` expose it exactly. ToBoolean is total: it accepts any value and returns `true` or `false`, and it never throws, never calls user code, and never looks at an object's contents. The rule is defined by a short table of values that map to `false`. Everything else maps to `true`. "Falsy" and "truthy" are just the informal names for those two groups. ## The falsy set There are eight falsy values in the language: - `false` — the boolean itself - `0` — positive zero - `-0` — negative zero (a distinct numeric value, but equally falsy) - `0n` — the BigInt zero - `''` — the empty string (identical for `""` and an empty template literal) - `null` - `undefined` - `NaN` That is the whole list. It is worth memorising verbatim, because interviewers ask for it directly and because every truthiness bug you will ever debug comes from a value on this list arriving where you expected "nothing". ```js for (const v of [false, 0, -0, 0n, '', null, undefined, NaN]) { console.log(Boolean(v)); // false, eight times } ``` ## Everything else is truthy — including the empty-looking things Because the falsy list is closed, the interesting half of the answer is what *isn't* on it: ```js Boolean('0'); // true — a non-empty string Boolean('false'); // true — still just characters Boolean(' '); // true — a space is a character Boolean([]); // true — an object Boolean({}); // true — an object Boolean(function () {}); // true — functions are objects Boolean(Infinity); // true Boolean(-1); // true — only zero is falsy, not "negative" ``` The single most useful generalisation: **every object is truthy**, no matter what it holds. An empty array, an empty object, an empty `Map`, and even a wrapper object like `new Boolean(false)` are all truthy, because ToBoolean stops at "is this an object?" and answers `true` without inspecting anything inside. It does not call `valueOf`, `toString`, or any conversion hook. That is why `if (list)` can never tell you whether a list has elements. One exception exists, and it is a host quirk rather than a language rule: in browsers, `document.all` is specified to be falsy, a deliberate web-compatibility hack so that old feature-detection code takes the modern branch. It is the only falsy object you will meet, and no other value behaves that way. ## Where ToBoolean is invoked The same conversion runs in more places than people realise: - `if (x)`, `while (x)`, `do…while (x)`, the middle clause of `for (;x;)` - `!x` (and therefore `!!x`) - the condition of the conditional operator `x ? a : b` - the left operand test of `&&` and `||` - `Boolean(x)` called as a function - `Array.prototype.filter(Boolean)`, which simply passes each element through it Notably, `??` does **not** use ToBoolean — it tests only for `null` and `undefined` — and `if (x)` is therefore a strictly wider test than "is it missing". ## The bugs this causes The classic failure is treating truthiness as a presence check for a value whose valid domain includes a falsy member: ```js function render(count) { if (!count) return 'nothing to show'; // wrong when count === 0 return `${count} items`; } ``` Zero is a perfectly good count, an empty string is a perfectly good name, and `false` is a perfectly good setting — but all three take the "missing" branch. The fix is to say what you actually mean: `count === undefined`, `count == null` (which matches both `null` and `undefined`), or `Number.isFinite(count)`. Truthiness is a convenience for the common case where every falsy value really is invalid; it is not a substitute for a domain check. The mirror-image bug is assuming an empty container is falsy: `if (results)` is always true for an array, so emptiness needs `results.length === 0`. ## How to talk about it A strong answer recites the eight values without hesitation, adds the generalisation that everything else — objects above all — is truthy, and then immediately names the practical consequence: truthiness conflates "absent" with "zero, empty, or false", so any code path where `0` or `''` is legal needs an explicit comparison rather than a bare `if`.