== vs === — what does coercion actually do?

== (Abstract Equality) coerces operands to a common type before comparing, following an explicit algorithm in the spec. === (Strict Equality) returns false if the types differ — no coercion. The interview question is: do you know why === is the default, and where == is actually defensible?

The == coercion algorithm (the parts that bite).

• null == undefined → true. They equal each other and only each other.
• NaN == NaN → false (use Number.isNaN or Object.is).
• number == string → string is coerced to number: "5" == 5 → true; "" == 0 → true; " " == 0 → true (whitespace coerces to 0).
• boolean == anything → boolean is coerced to number first: true == 1 (true), false == 0 (true), true == "1" (true), true == "true" (false because "true" → NaN).
• object == primitive → object is converted via ToPrimitive (calls valueOf then toString): [1] == 1 (true), [1, 2] == "1,2" (true).

These rules produce the famous wat-list: [] == false (true), [] == ![] (true), "0" == false (true) but "0" == "" (false).

=== rules (simple). Same type or false. Same value (with one exception: NaN === NaN is false). +0 === -0 is true. Object.is differs only on these two: Object.is(NaN, NaN) is true and Object.is(+0, -0) is false.

The one defensible == use. x == null is true for both null and undefined — the most concise way to check "is this nullish." Otherwise, ESLint rules (eqeqeq) ban == outright.

Modern alternatives to coercion-based checks.

• Nullish: x ?? default (null/undefined only) vs x || default (any falsy).
• Optional chaining: x?.foo short-circuits on null/undefined.
• Coercion: be explicit — Number(x), String(x), Boolean(x).
• NaN check: Number.isNaN(x). The global isNaN first coerces (isNaN("foo") → true, surprising).

Reference equality. Both == and === compare objects by reference, not contents: {a:1} === {a:1} is false. For deep equality use JSON.stringify (limited), Lodash _.isEqual, or roll your own.

Output puzzles you should be able to walk through.

[] == ![]      // true: ![] → false → 0; [] → "" → 0; 0 == 0
"" == 0        // true: "" → 0
" \t\n " == 0  // true: whitespace string → 0
null == 0      // false: null only equals undefined
null >= 0      // true: comparison operators coerce; null → 0
"0" == false   // true: false → 0; "0" → 0
0.1 + 0.2 === 0.3 // false: floating point

Bottom line. Use === everywhere except x == null. Prefer explicit conversion (Number(x)) over implicit coercion. ESLint's eqeqeq: ["error", "always", { null: "ignore" }] codifies this exactly.