What is the difference between Object.is, ==, and ===?

Q: What is the difference between Object.is, ==, and ===?

**Target Audience:** Engineers preparing for JavaScript fundamentals and equality-semantics interview questions. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every result below was actually run on Node.js v24.19.0 — the printed output is real, captured output, not illustrative sample text. ## 1. Why This Even Matters — A Story First Picture three different security guards checking IDs at a door. Guard `==` is lenient -- if two different ID formats plausibly represent the same value, that guard converts one to match the other and waves them both through. Guard `===` is strict -- the types must already match exactly, no conversions performed. Guard `Object.is` is ALSO strict almost everywhere `===` is, with one important twist: for two bizarre floating-point edge cases, it applies a genuinely different rule than `===` -- it treats two NaN badges as the same person, where `===` refus

The problem

Question presented to candidate: "What is the actual difference between Object.is(a, b), a == b, and a === b? Walk me through where all three agree, and the specific cases where they disagree."

What a strong answer should cover:

== performs type coercion before comparing; === and Object.is never coerce types, so 1 === "1" and Object.is(1, "1") are both false while 1 == "1" is true.
=== and Object.is agree on almost everything, EXCEPT exactly two IEEE-754 floating point edge cases: NaN and negative zero.
NaN === NaN is false (the famous exception), but Object.is(NaN, NaN) is true -- Object.is exists partly to give a correct way to test NaN equality without that gotcha.
0 === -0 is true, but Object.is(0, -0) is false -- Object.is is actually STRICTER than === in this one specific case, not simply a safer alias for it.
None of the three perform structural/deep equality on objects or arrays -- two separately created array literals with identical contents are never equal under any of the three, since object comparison is always by reference.

Clarifying questions expected:

"Should I also cover Array.prototype.includes, since it uses a related but different algorithm called SameValueZero?"

Code / implementation expected: Yes -- a runnable truth table covering NaN, -0, type coercion, and reference equality.

equality
object-is
coercion

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals and equality-semantics interview questions. Difficulty: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every result below was actually run on Node.js v24.19.0 — the printed output is real, captured output, not illustrative sample text.

1. Why This Even Matters — A Story First

Picture three different security guards checking IDs at a door. Guard == is lenient -- if two different ID formats plausibly represent the same value, that guard converts one to match the other and waves them both through. Guard === is strict -- the types must already match exactly, no conversions performed. Guard Object.is is ALSO strict almost everywhere === is, with one important twist: for two bizarre floating-point edge cases, it applies a genuinely diff

The solution is hidden so you can try first

7 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptFull equality truth table: ==, ===, Object.is, and Array.includes (run directly)