What equality rule does a JavaScript Set use to decide whether a value is already present, and what surprising results does it produce for NaN, -0, and objects?

## The rule Every membership decision a `Set` makes — inside `add`, `has` and `delete` — uses the SameValueZero comparison. It is easiest to describe by difference: - It behaves like `===` for every ordinary value. - Unlike `===`, `NaN` is equal to `NaN`. - Unlike `Object.is`, `+0` and `-0` are equal. Nothing else is special. In particular there is **no coercion**: a Set never turns `1` into `'1'`, never calls `valueOf` or `toString`, and never looks inside an object. ```js const s = new Set([1, '1', true, 'true']); s.size; // 4 — four distinct values of three types ``` ## NaN deduplicates This is the headline case, because it contradicts the first fact everyone learns about `NaN`: ```js NaN === NaN; // false new Set([NaN, NaN]).size; // 1 new Set([NaN]).has(NaN); // true ``` The motivation is practical: a collection whose `has` could never find a value you had just inserted would be broken. `Array.prototype.includes` was given the same rule for the same reason, which is why `[NaN].includes(NaN)` is `true` while `[NaN].indexOf(NaN)` is `-1`. ## +0 and -0 collapse, and -0 is normalized away ```js new Set([0, -0]).size; // 1 new Set([-0]).has(0); // true ``` There is an extra detail most candidates miss. `Set.prototype.add` explicitly converts `-0` to `+0` before storing, so a Set never *contains* a negative zero at all: ```js const s = new Set([-0]); Object.is([...s][0], -0); // false Object.is([...s][0], 0); // true ``` So the sign of zero survives neither membership nor iteration. If you genuinely need to distinguish `-0` — rare, but it happens in numeric code that tracks direction of underflow — a Set is the wrong container; store a tagged string or use `Object.is` in a manual scan. ## Objects are matched by reference For object values, SameValueZero is just reference identity, and this is where the rule bites in real code: ```js const s = new Set(); s.add({ id: 1 }); s.has({ id: 1 }); // false — a different object s.size; // 1 const u = { id: 1 }; s.add(u); s.add(u); s.size; // 2 — the literal above, plus u once ``` Every object literal, every `JSON.parse` result, every row mapped out of an API response is a fresh reference. A Set of such objects deduplicates nothing. The fix is always the same shape: derive a primitive identity — an id, a normalized string — and put *that* in the Set, or key a `Map` by it if you also want to keep one object per identity. The same reasoning applies to values that merely *look* primitive. A boxed `new String('a')` is an object, so `new Set(['a', new String('a')]).size` is 2. Symbols, by contrast, are primitives but every `Symbol('x')` call creates a distinct one, so two symbols with the same description are two entries — while `Symbol.for('x')` returns the same registered symbol every time and therefore deduplicates. ## The surrounding API, and what it returns - `add(value)` returns the **Set**, so calls chain; adding a present value changes nothing, including the value's position in iteration order. - `has(value)` returns a boolean and does the SameValueZero lookup described above. - `delete(value)` returns `true` if something was removed, `false` otherwise — that boolean is a handy "was it there?" test that also removes. - `clear()` empties the Set and returns `undefined`. - `size` is an accessor **property**, not a method. - `forEach(cb)` calls back with `(value, value, set)` — the value appears twice so the signature matches `Map.prototype.forEach`, where those two slots are key and value. ## Why the rule matters in interviews It is the difference between a candidate who has memorized `[...new Set(arr)]` and one who knows what "unique" means here. Two sentences carry it: `NaN` is equal to itself so it dedupes, and objects are compared by reference so structurally identical ones do not. Everything else — the zero normalization, boxed primitives, the `delete` return value — is detail you can add when probed.