Set Semantics and Uniqueness

## The idiom, piece by piece `[...new Set(myArray)]` is three separate language features cooperating. 1. **`new Set(iterable)`** — the `Set` constructor accepts any iterable and calls `add` for every element it yields. `add` is a no-op when the value is already present, so the resulting Set holds each distinct value exactly once. 2. **A Set is itself iterable** — it has a `Symbol.iterator` that yields its values, so it can be spread. 3. **Array spread `[...]`** — drains that iterator into a fresh array. ```js const arr = [3, 1, 3, 2, 1]; const set = new Set(arr); // Set(3) { 3, 1, 2 } const out = [...set]; // [3, 1, 2] ``` `Array.from(new Set(arr))` is the identical operation with a different spelling, and it is the one to reach for when you also want a mapping function: `Array.from(new Set(arr), n => n * 2)`. ## Order is insertion order, not sorted order A `Set` iterates in the order values were first inserted. That makes the idiom **stable and first-wins**: the earliest occurrence of each value determines its position, and later duplicates are silently dropped. This surprises people who expect a sorted result — `[...new Set([3,1,2])]` is `[3,1,2]`. If you want sorted output you must sort afterwards, and if you want *last*-wins you cannot use this idiom directly, because a Set has no way to "re-add" a value at the end (`add` on an existing value leaves its position alone). ## Which values actually collapse A Set decides membership with SameValueZero, which behaves like `===` with one deliberate change: `NaN` is equal to itself. That makes the idiom stronger than the hand-rolled alternative: ```js [...new Set([NaN, NaN])]; // [NaN] — deduped [NaN].indexOf(NaN); // -1 — indexOf uses === [NaN].includes(NaN); // true — includes uses SameValueZero ``` `+0` and `-0` are also treated as the same value, so `[...new Set([0, -0])]` has length 1. Different types never collapse: `1` and `'1'` are two values, because no coercion happens anywhere in a Set. ## The hard limit: objects are compared by reference ```js const users = [{ id: 1 }, { id: 1 }]; [...new Set(users)].length; // 2 — nothing removed ``` Each object literal creates a distinct object, and the Set sees two distinct references. The idiom removes duplicates only when the *same* object appears more than once in the array: ```js const u = { id: 1 }; [...new Set([u, u])].length; // 1 ``` Deduplicating objects by content therefore needs a derived primitive key rather than the objects themselves. ## Other things worth knowing before you use it - **Any iterable works, not just arrays.** `new Set('aabbc')` iterates the string and gives `Set { 'a', 'b', 'c' }`, because strings are iterable. - **It is a copy.** The original array is untouched; the elements themselves are not cloned, so the new array holds the same object references. - **Sparse arrays are densified.** Array iteration yields `undefined` for holes, so `[...new Set([1, , 1])]` is `[1, undefined]`. - **A Set holds strong references** to whatever you put in it, so a long-lived Set used as a "seen" ledger keeps its entries alive; bound it or clear it if it grows without limit. - **`add` returns the Set itself**, which is why `set.add(1).add(2)` chains; `delete` returns a boolean saying whether something was removed; `size` is a property, not a method (`set.size`, never `set.size()`). ## When to reach for something else Use a plain filter when the notion of duplicate is not raw value equality — for example, "same `id`" or "same normalized email". Use a `Map` when you want to keep one representative object per key rather than a bare list of keys. Keep the Set idiom for the case it is genuinely perfect at: collapsing a list of primitives while preserving the order in which they first appeared.