=== vs Object.is vs SameValueZero — which comparison does each API use?

None of the three coerces types: different types are never equal. They differ on exactly two inputs.

Everything else matches: two Strings are equal when their code units match, two BigInts when their values match, and objects, symbols, null, undefined and Booleans compare by identity or value as you would expect.

Practical consequences:

• [NaN].indexOf(NaN) is -1 but [NaN].includes(NaN) is true.
• A Map or Set treats NaN as one key. It also treats -0 and +0 as the same key (the spec's key canonicalization turns -0 into +0 first).
• Object.is(0, -0) is false; use it when the sign matters (for example, detecting -0 from Math.round(-0.4)).
• Use Number.isNaN(x) or Object.is(x, NaN) to test for NaN, never x === NaN.

=== stays the default for application code. Reach for Object.is when you need a precise "same value" test and for includes when searching arrays that may contain NaN.

console.log(NaN === NaN, Object.is(NaN, NaN)); // → false true
console.log(0 === -0, Object.is(0, -0)); // → true false

const list = [NaN, -0];
console.log(list.indexOf(NaN), list.includes(NaN)); // → -1 true
console.log(list.indexOf(0), list.includes(0)); // → 1 true

const map = new Map([[NaN, "nan"], [-0, "zero"]]);
console.log(map.get(NaN), map.get(0)); // → nan zero
console.log([...map.keys()].map((k) => Object.is(k, -0))); // → [ false, false ]

console.log(new Set([0, -0, NaN, NaN]).size); // → 2

• Writing x === NaN. It is always false. Use Number.isNaN(x).
• Using indexOf(x) !== -1 to test for membership when NaN is possible. Use includes.
• Expecting a Map to preserve -0 as a key. The stored key is +0; Object.is(k, -0) fails for every key.
• Assuming Object.is is a stricter === for objects. For objects, strings and other non-Number types the three algorithms agree.