我知道这是一个老问题，但我能想到的 ES2015/ES6 中最简单的解决方案实际上非常简单，使用 Object.assign()，

希望这有帮助：

/**
 * 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);
}

用法示例：

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] } } }

你会在下面的答案中找到一个不可变的版本。

请注意，这将导致循环引用的无限递归。如果您认为自己会遇到这个问题，这里有一些关于如何检测循环引用的很好的答案。

您可以使用Lodash 合并：

var object = {
  'a': [{ 'b': 2 }, { 'd': 4 }]
};

var other = {
  'a': [{ 'c': 3 }, { 'e': 5 }]
};

_.merge(object, other);
// => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }

当涉及到宿主对象或任何比一袋值更复杂的对象时，这个问题并不重要

• 您是调用 getter 来获取值还是复制属性描述符？
• 如果合并目标有一个 setter（要么是自己的属性要么在它的原型链中）怎么办？你认为这个值已经存在还是调用 setter 来更新当前值？
• 你是调用自有属性函数还是复制它们？如果它们是绑定函数或箭头函数，取决于它们在定义时的作用域链中的某些内容怎么办？
• 如果它类似于 DOM 节点呢？你当然不想把它当作简单的对象，只是将它的所有属性深度合并到
• 如何处理像数组、映射或集合这样的“简单”结构？考虑它们已经存在还是也合并它们？
• 如何处理不可枚举的自身属性？
• 新的子树呢？简单地通过引用分配还是深度克隆？
• 如何处理冻结/密封/不可扩展的对象？

要记住的另一件事：包含循环的对象图。它通常不难处理——只需保留一个Set已经访问过的源对象——但经常被遗忘。

您可能应该编写一个深度合并函数，它只需要原始值和简单对象——最多是结构化克隆算法可以处理的那些类型——作为合并源。如果遇到任何它无法处理的东西或只是通过引用分配而不是深度合并，则抛出。

换句话说，没有一刀切的算法，您要么必须推出自己的算法，要么寻找恰好涵盖您的用例的库方法。

这是@Salakar 答案的不可变（不修改输入）版本。如果您正在做函数式编程类型的东西，则很有用。

export function isObject(item) {
  return (item && typeof item === 'object' && !Array.isArray(item));
}

export default function mergeDeep(target, source) {
  let output = Object.assign({}, target);
  if (isObject(target) && isObject(source)) {
    Object.keys(source).forEach(key => {
      if (isObject(source[key])) {
        if (!(key in target))
          Object.assign(output, { [key]: source[key] });
        else
          output[key] = mergeDeep(target[key], source[key]);
      } else {
        Object.assign(output, { [key]: source[key] });
      }
    });
  }
  return output;
}

由于这个问题仍然存在，这是另一种方法：

• ES6/2015
• 不可变（不修改原始对象）
• 处理数组（连接它们）

/**
* Performs a deep merge of objects and returns new object. Does not modify
* objects (immutable) and merges arrays via concatenation.
*
* @param {...object} objects - Objects to merge
* @returns {object} New object with merged key/values
*/
function mergeDeep(...objects) {
  const isObject = obj => obj && typeof obj === 'object';
  
  return objects.reduce((prev, obj) => {
    Object.keys(obj).forEach(key => {
      const pVal = prev[key];
      const oVal = obj[key];
      
      if (Array.isArray(pVal) && Array.isArray(oVal)) {
        prev[key] = pVal.concat(...oVal);
      }
      else if (isObject(pVal) && isObject(oVal)) {
        prev[key] = mergeDeep(pVal, oVal);
      }
      else {
        prev[key] = oVal;
      }
    });
    
    return prev;
  }, {});
}

// Test objects
const obj1 = {
  a: 1,
  b: 1, 
  c: { x: 1, y: 1 },
  d: [ 1, 1 ]
}
const obj2 = {
  b: 2, 
  c: { y: 2, z: 2 },
  d: [ 2, 2 ],
  e: 2
}
const obj3 = mergeDeep(obj1, obj2);

// Out
console.log(obj3);