Equality & sameness

Four sameness judges

JavaScript does not have one idea called equality. It has several sameness algorithms, each built for a different job. Earlier comparison lessons introduced ===, ==, NaN, and the null/undefined quirk. This lesson formalizes the rulebooks so you can predict them instead of memorizing a giant matrix.

The names you will see are IsStrictlyEqual for ===, IsLooselyEqual for ==, SameValue for Object.is, and SameValueZero for includes, Map, and Set. SameValueZero is SameValue except that it treats -0 and +0 as the same.

Strict equality is your default judge. It does not convert either side. If the types differ, the answer is immediately false. For primitives of the same type, it compares the value. For objects, arrays, and functions, the value is the reference: whether both sides point at the same object.

1const shared = { id: 1 };2const alsoShared = shared;3const twin = { id: 1 };4 5console.log(1 === "1");6console.log(shared === alsoShared);7console.log(shared === twin);8console.log(NaN === NaN);9console.log(-0 === +0);

The two historical exceptions are the ones professionals still trip over: NaN === NaN is false, and -0 === +0 is true. Use the playground to ask all four judges about those cases, plus strings, numbers, BigInts, arrays, and object references.

1const a = NaN;2const b = NaN;3console.log(a === b);4console.log(a == b);5console.log(Object.is(a, b));6console.log([a].includes(b));

Loose equality is not random. It is an algorithm that repeatedly asks, “Do these types already match? If not, is there a conversion rule for this pair?” The previous Type coercion lesson introduced ToPrimitive, ToNumber, and ToBoolean; == is one place those operations become visible.

The useful skeleton is:

1. Same type? Use strict equality.
2. null and undefined? They equal each other.
3. Number and string? Convert the string with ToNumber.
4. Boolean? Convert it to 1 or 0 first.
5. Object and primitive? Convert the object with ToPrimitive.
6. BigInt with string or number? Use the special safe rules.
7. No rule? The result is false.

1looseEquals(false, "");Run2// 1. If types match, use strict equality.3// 2. null and undefined equal only each other.4// 3. Strings, booleans, and objects may convert.5// 4. BigInt has careful string/number rules.6// 5. If no rule matches, return false.

Object.is(a, b) exposes the SameValue algorithm. It does not coerce, object references still matter, and it differs from === in exactly two numeric places: Object.is(NaN, NaN) is true, while Object.is(-0, +0) is false.

1const rounded = Math.round(-0.4);Run2console.log(rounded);3console.log(1 / rounded);4console.log(Object.is(rounded, -0));5console.log(JSON.parse(JSON.stringify(rounded)));6console.log(Number.isNaN(NaN));7console.log(NaN !== NaN);

Negative zero can appear from calculations such as Math.round(-0.4) or -1 * 0. Most UI text does not care, but numeric code sometimes does because 1 / -0 gives -Infinity. A JSON round trip erases the sign: JSON.stringify(-0) becomes "0".

SameValueZero is the practical collection judge. It is like Object.is for NaN, but like === for signed zero. That is why [NaN].includes(NaN) is true, [NaN].indexOf(NaN) is -1, and new Set([-0]).has(0) is true.

1console.log([NaN].includes(NaN));Run2console.log([NaN].indexOf(NaN));3const map = new Map([[NaN, "stored"]]);4console.log(map.get(NaN));5const set = new Set([-0]);6console.log(set.has(0));

1console.log([NaN].includes(NaN));2console.log([NaN].indexOf(NaN));3const map = new Map([[NaN, "stored"]]);4console.log(map.get(NaN));5const set = new Set([-0]);6console.log(set.has(0));

Where you'll use this

Most real code uses the same small set of choices. Use strict equality for ordinary comparisons. Use value == null when you intentionally mean “missing as null or undefined.” Use Object.is when your logic is sensitive to NaN or the sign of zero. React uses Object.is for some state comparisons, which is why this detail occasionally appears in UI debugging.

1if (user.middleName == null) {2  showOptionalNameField();3}4 5if (Object.is(nextTemperature, previousTemperature)) {6  skipChartUpdate();7}8 9const uniqueIds = new Set(idsFromSeveralLists);

Collections do another job for you. If you dedupe values with new Set(values), it uses SameValueZero, so duplicate NaN values collapse and -0/+0 count as one value.

Common misconceptions

Answer from the rulebook, not from vibes. Every option explains itself.

Key takeaways

• Default to ===: same type, same value, no conversion.
• == follows an ordered conversion algorithm; use it deliberately, especially for value == null.
• Object.is is SameValue: NaN matches itself, and -0 differs from +0.
• SameValueZero powers includes, Map, and Set: NaN matches and zero signs merge.
• Object equality is reference equality, not a deep comparison of properties.

Up next: Checking types reliably.