Why is `if (items)` a broken way to check that a JavaScript array has elements, and what does ToBoolean do with objects in general?

## The rule for objects is unconditional The specification's ToBoolean operation is a table lookup on the value's *type*, not its contents. For the Object type there is a single row, and it says `true`. There is no escape hatch: no `Symbol.toPrimitive`, no `valueOf`, no `toString`, no length property is consulted. This is different from almost every other coercion in JavaScript — `+obj`, `` `${obj}` `` and `obj == 1` all invoke ToPrimitive and can run user code — and it is why truthiness is the one conversion that never throws and never has side effects. ```js Boolean([]); // true Boolean({}); // true Boolean(new Map()); // true Boolean(() => {}); // true Boolean(new Boolean(false)); // true — the wrapper is an object Boolean(new Number(0)); // true — likewise ``` The last two are the sharpest illustration. `new Boolean(false)` wraps the falsy primitive `false` in an object, and the object is truthy — so `if (new Boolean(false))` runs its block. That, more than anything, is why the wrapper constructors should never be called with `new`. ## What `if (items)` actually asks Since every object is truthy, the only way `if (items)` takes the false branch is if `items` holds a falsy **primitive** — in practice `undefined` (never assigned, missing property, function returned nothing) or `null`. So the check means "`items` is not nullish", plus an accidental extra branch if `items` could ever be `0` or `''`. That is a perfectly reasonable check, and often it is the one you want after an API call that may return nothing. The defect is only in *believing* it also covers emptiness. Code like ```js if (results) { render(results); } else { showEmptyState(); } ``` never shows the empty state for `results = []`; it renders an empty list instead. ## Asking the container instead Emptiness is a per-type question, so use the type's own answer: ```js arr.length === 0; // Array (and String) map.size === 0; // Map, Set, WeakMap has no size at all Object.keys(obj).length === 0; // plain object, own enumerable string keys ``` For plain objects, be aware that `Object.keys` reports own enumerable string-keyed properties only — symbol keys and inherited properties are not counted — so "empty" means "empty by that definition", which is usually what you mean but is worth saying out loud. Combining the two questions is the common real requirement: ```js if (!items?.length) showEmptyState(); // covers null, undefined, and [] ``` `?.` yields `undefined` when `items` is nullish, `undefined` is falsy, and `0` is falsy — so the single expression means "missing or empty". It is compact, but it is also implicit; in code where the two cases deserve different handling (an error state versus an empty state) write them as two branches. ## Related traps in the same family - **Boxed primitives.** Anything produced by `new Number(...)`, `new String(...)` or `new Boolean(...)` is an object and therefore truthy. Called *without* `new`, those same functions return primitives and behave normally. - **`document.all`** is the one specified falsy object, a browser legacy exception that no code you write can reproduce. - **Arrays and loose comparison.** Trying to fix the check with `items == false` looks tempting because `[] == false` really is `true`, but that comparison coerces both sides to numbers, so `[0] == false` is also `true` — it is not an emptiness test at all. - **`items === []`** is always `false`, since it compares two distinct object references rather than contents. ## What a strong answer sounds like State the mechanism first — ToBoolean maps the entire Object type to `true` with no inspection — then draw the two conclusions: `if (obj)` is a nullish check, and emptiness must come from the container's own `length`, `size` or key count. Finish with the practical form you would actually write, `if (!items?.length)`, and note when you would split it into two explicit branches instead.