Why does the JavaScript expression [] == ![] evaluate to true? Derive it from the loose-equality algorithm.

## The famous line, unpacked `[] == ![]` is the party trick of JavaScript coercion. It is worth knowing not because the expression appears in real code — it does not — but because deriving it end to end proves you can run the loose-equality algorithm on operands you have never seen before, instead of recalling a table. ## Step 0: precedence Before any comparison happens, `![]` is evaluated. Unary `!` binds tighter than `==`, so the expression is `[] == (![])`, never `([] == []) !`. An array is an object, all objects are truthy, so `![]` is `false`. The expression is now `[] == false`. This first step catches a surprising number of candidates, who assume both sides are arrays and answer "false, because two arrays are different objects". That answer is correct for `[] == []`, which really is `false` — but that is a different expression. ## Step 1: the boolean rule The operands are an object and a boolean. The types differ, neither is null or undefined, and this is not a Number-vs-String pair, so the boolean rule fires: the boolean is converted with ToNumber. `false` becomes `0`. Retry with `[] == 0`. Note what did **not** happen: the array was not converted to a boolean. Loose equality removes the boolean rather than producing one, which is why this is not a truthiness comparison. ## Step 2: object versus primitive Now an object is compared with a number. The rule for that case converts the object to a primitive value and retries. For an array, that conversion ends up calling `toString()`, which joins the elements with commas. An empty array joins to the empty string. Retry with `'' == 0`. The same rule explains the family of results around it: ```js console.log([] == 0); // true - '' then 0 console.log([0] == 0); // true - '0' then 0 console.log([1] == 1); // true - '1' then 1 console.log([1, 2] == '1,2'); // true - joined string, no further conversion console.log([1, 2] == 12); // false - '1,2' is NaN as a number ``` ## Step 3: string versus number `'' == 0` is a string against a number, so the string is converted: `ToNumber('')` is `0`. Retry with `0 == 0`. ## Step 4: same type Two numbers now, so the algorithm delegates to strict equality, and `0 === 0` is `true`. Final answer: `[] == ![]` is `true`. ```js console.log(![]); // false console.log([] == false); // true console.log([].toString()); // '' (empty string) console.log('' == 0); // true console.log([] == ![]); // true ``` ## The contrast worth pairing it with `[] == []` is `false`. Two array literals are two distinct objects; the operands share a type, so the algorithm's first rule applies and compares references, which differ. Coercion of an object happens **only** when the other operand is a primitive. Being able to state both results and explain why they differ is the real signal here — one expression exercises four coercion rules, the other exercises none. The same holds for `{} == {}`, `[] == {}` (false — two objects, different references) and `[] == '0'` (false — the array becomes `''`, and `'' === '0'` is false since both are then strings). ## What this tells you about writing code The practical takeaway is not a rule about arrays; it is that `==` with an object operand triggers a user-visible conversion step. If the object has a custom conversion, that code runs during a comparison — an equality check can execute arbitrary logic, which is a genuinely surprising property for an operator. Comparing objects with `==` against primitives is therefore something to avoid outright: use `===` for reference identity, or extract the field you actually mean to compare (`arr.length === 0`, `arr[0] === 1`) so the comparison names its own subject. When you need to know whether an array is empty, `arr.length === 0` says so directly. When you need to know whether a value is an array at all, `Array.isArray(value)` answers it without any coercion. Neither of those can be derailed by a conversion you did not intend to trigger. ## How to answer under pressure Say the steps out loud in order and do not skip precedence: `![]` is false; boolean becomes 0; array becomes `''`; `''` becomes 0; `0 == 0` is true. Then volunteer `[] == []` being false as the contrast. That sequence takes fifteen seconds and demonstrates exactly what the question is testing.