HardDSA13 min read

Implement deepEqual(a, b) handling NaN, -0, Dates, RegExp & circular refs

Q: Implement deepEqual(a, b) handling NaN, -0, Dates, RegExp & circular refs

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Hard > **How to read this doc:** equality has no single right answer, so this doc first pins the semantics down, then checks them. `deepEqual` was compared with Node's `util.isDeepStrictEqual` on 240,000 pairs (each of 60,000 random graphs compared with itself, with its clone, with a clone that had exactly one change, and with an unrelated graph): 148,923 equal, 91,077 unequal, and ONE disagreement, where `deepEqual` gave the correct answer and `isDeepStrictEqual` did not. A second, memoised version fixes an exponential-time problem that both implementations have on shared structure. ## 1. The problem, restated Write `deepEqual(a, b)` that decides whether two values are structurally the same. It must treat `NaN` as equal to `NaN`, tell `+0` from `-0`, compare `Date` by time, `RegExp` by pattern and flags, compare arrays, plain objects, `Map` and `Set`, and terminate on circular refer

586 views

150 of 154

The problem

Problem, as an interviewer would state it: "Create isEqual (deep equality) that correctly handles NaN === NaN, -0 versus +0, Dates, RegExps, arrays, plain objects, and circular references. Discuss edge cases, runtime, and alternatives."

Examples:

Code

deepEqual(NaN, NaN);                        // true   (=== says false)
deepEqual(0, -0);                           // false  (=== says true)
deepEqual({ a: [1, new Date(0)] }, { a: [1, new Date(0)] });   // true
const x = { v: 1 }; x.self = x;  const y = { v: 1 }; y.self = y;
deepEqual(x, y);                            // true, and it terminates

Clarifying questions expected:

Which equality for primitives (Object.is), and do prototypes and key order matter?
Should Map and Set ignore order, and how are object members matched?
What should two circular structures do, and how much data will it see?

Code / implementation expected: Yes — real code, checked against a trusted implementation and on cycles and shared structure.

deep-equal
NaN
-0
edge-cases

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 practical JavaScript coding interviews. Difficulty: Hard

How to read this doc: equality has no single right answer, so this doc first pins the semantics down, then checks them. deepEqual was compared with Node's util.isDeepStrictEqual on 240,000 pairs (each of 60,000 random graphs compared with itself, with its clone, with a clone that had exactly one change, and with an unrelated graph): 148,923 equal, 91,077 unequal, and ONE disagreement, where deepEqual gave the correct answer and isDeepStrictEqual did not. A second, memoised version fixes an exponential-time problem that both implementations have on shared structure.

1. The problem, restated

Write deepEqual(a, b) that decides whether two values are structurally the same. It must treat NaN as equal to NaN, tell +0 from -0, compare Date by time, RegExp b

The solution is hidden so you can try first

13 min read · 9 sections

Run the code

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

JavaScriptReal, direct proof: deepEqual settles every semantic question, survives cycles, passes property tests, and the memoised version removes the exponential blow-up

Practice

Discussion

Other approaches, follow-ups and how it went in real interviews.

No comments yet. Share how you would answer it.

Question 150 of 154 in JavaScript coding

Keep your momentum going.

Mark this question solved to track your progress, then take the next one while it is fresh.

All JavaScript coding questions

Up nextHard→

Graph dfs traversal

Continue