How to deep merge instead of shallow merge?

Question

Both Object.assign and Object spread only do a shallow merge.

An example of the problem:

// No object nesting const x = { a: 1 } const y = { b: 1 } const z = { ...x, ...y } // { a: 1, b: 1 } 

The output is what you'd expect. However if I try this:

// Object nesting const x = { a: { a: 1 } } const y = { a: { b: 1 } } const z = { ...x, ...y } // { a: { b: 1 } } 

Instead of

{ a: { a: 1, b: 1 } } 

you get

{ a: { b: 1 } } 

x is completely overwritten because the spread syntax only goes one level deep. This is the same with Object.assign().

Is there a way to do this?

Answer 1

I know this is a bit of an old issue but the easiest solution in ES2015/ES6 I could come up with was actually quite simple, using Object.assign(),

Hopefully this helps:

/**  * Simple object check.  * @param item  * @returns {boolean}  */ export function isObject(item) {   return (item && typeof item === 'object' && !Array.isArray(item)); }  /**  * Deep merge two objects.  * @param target  * @param ...sources  */ export function mergeDeep(target, ...sources) {   if (!sources.length) return target;   const source = sources.shift();    if (isObject(target) && isObject(source)) {     for (const key in source) {       if (isObject(source[key])) {         if (!target[key]) Object.assign(target, { [key]: {} });         mergeDeep(target[key], source[key]);       } else {         Object.assign(target, { [key]: source[key] });       }     }   }    return mergeDeep(target, ...sources); } 

Example usage:

mergeDeep(this, { a: { b: { c: 123 } } }); // or const merged = mergeDeep({a: 1}, { b : { c: { d: { e: 12345}}}});   console.dir(merged); // { a: 1, b: { c: { d: [Object] } } } 

You'll find an immutable version of this in the answer below.

Note that this will lead to infinite recursion on circular references. There's some great answers on here on how to detect circular references if you think you'd face this issue.