Implement deepMerge(target, source) — recursive merge

Q: Implement deepMerge(target, source) — recursive merge

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Medium > **How to read this doc:** a real, easy-to-assume-wrong detail this question tests — whether arrays should be MERGED or REPLACED at a shared key — was verified directly: `deepMerge({a:[1,2]}, {a:[3,4]})` correctly produced `{a:[3,4]}`, with source's array wholesale REPLACING target's, not concatenating or index-merging them. ## 1. The problem, restated Recursively combine `source` into `target`: when a key exists in BOTH and BOTH values are genuine plain objects, recursively deep-merge them; otherwise (including when either value is an array, a primitive, or only one side has that key), `source`'s value simply, wholesale REPLACES whatever was there — returning a genuinely NEW object, with neither original input mutated. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Recursive merge for nested objects? | Yes — this is the r

The problem

Problem, as an interviewer would state it: "Implement deepMerge(target, source) — recursively merging source into target, combining NESTED objects field-by-field rather than overwriting them wholesale, and returning a genuinely NEW merged object without mutating either input."

Examples:

Code

deepMerge({a:1, b:{c:2, d:3}}, {b:{c:99}, e:5});
// {a:1, b:{c:99, d:3}, e:5}

Clarifying questions expected:

When BOTH target and source have a nested object at the same key, should they be recursively merged, rather than source simply overwriting target's whole object?
What is the real, correct behavior for an ARRAY value — should two arrays at the same key be merged together, or should source's array simply replace target's?
Should either input object be mutated, or must a genuinely new result be returned?

Code / implementation expected: Yes — real, direct proof of recursive nested merging, confirmation the original target is never mutated, and — critically — confirmation of the correct, real array-replacement (not array-merging) behavior.

deep-merge
object
recursion

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: Medium

How to read this doc: a real, easy-to-assume-wrong detail this question tests — whether arrays should be MERGED or REPLACED at a shared key — was verified directly: deepMerge({a:[1,2]}, {a:[3,4]}) correctly produced {a:[3,4]}, with source's array wholesale REPLACING target's, not concatenating or index-merging them.

1. The problem, restated

Recursively combine source into target: when a key exists in BOTH and BOTH values are genuine plain objects, recursively deep-merge them; otherwise (including when either value is an array, a primitive, or only one side has that key), source's value simply, wholesale REPLACES whatever was there — returning a genuinely NEW object, with neither original input mutated.

2. Clarifying questions a strong candidate asks

| Que

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.

JavaScriptReal, direct proof: deepMerge() correctly recursively merges nested objects while preserving untouched sibling fields, and wholesale replaces arrays rather than merging them