基于Markus和vsync的回答，这是一个扩展版本。该函数接受任意数量的参数。它可以用于设置DOM节点上的财产，并对值进行深度复制。然而，第一个论点是通过引用给出的。

要检测DOM节点，使用isDOMNode（）函数（请参阅堆栈溢出问题JavaScript isDOM-如何检查JavaScript对象是否为DOM对象？）

它在Opera 11、Firefox 6、Internet Explorer 8和Google Chrome 16中进行了测试。

Code

function mergeRecursive() {

  // _mergeRecursive does the actual job with two arguments.
  var _mergeRecursive = function (dst, src) {
    if (isDOMNode(src) || typeof src !== 'object' || src === null) {
      return dst;
    }

    for (var p in src) {
      if (!src.hasOwnProperty(p))
        continue;
      if (src[p] === undefined)
        continue;
      if ( typeof src[p] !== 'object' || src[p] === null) {
        dst[p] = src[p];
      } else if (typeof dst[p]!=='object' || dst[p] === null) {
        dst[p] = _mergeRecursive(src[p].constructor===Array ? [] : {}, src[p]);
      } else {
        _mergeRecursive(dst[p], src[p]);
      }
    }
    return dst;
  }

  // Loop through arguments and merge them into the first argument.
  var out = arguments[0];
  if (typeof out !== 'object' || out === null)
    return out;
  for (var i = 1, il = arguments.length; i < il; i++) {
    _mergeRecursive(out, arguments[i]);
  }
  return out;
}

一些示例

设置HTML元素的innerHTML和样式

mergeRecursive(
  document.getElementById('mydiv'),
  {style: {border: '5px solid green', color: 'red'}},
  {innerHTML: 'Hello world!'});

合并数组和对象。请注意，undefined可用于保存左侧数组/对象中的值。

o = mergeRecursive({a:'a'}, [1,2,3], [undefined, null, [30,31]], {a:undefined, b:'b'});
// o = {0:1, 1:null, 2:[30,31], a:'a', b:'b'}

任何非JavaScript对象的参数（包括null）都将被忽略。除了第一个参数之外，也会丢弃DOM节点。注意，像new String（）这样创建的字符串实际上是对象。

o = mergeRecursive({a:'a'}, 1, true, null, undefined, [1,2,3], 'bc', new String('de'));
// o = {0:'d', 1:'e', 2:3, a:'a'}

如果要将两个对象合并为一个新对象（不影响其中任何一个），请提供｛｝作为第一个参数

var a={}, b={b:'abc'}, c={c:'cde'}, o;
o = mergeRecursive(a, b, c);
// o===a is true, o===b is false, o===c is false

编辑（由收割者很快）：

还要合并阵列

function mergeRecursive(obj1, obj2) {
  if (Array.isArray(obj2)) { return obj1.concat(obj2); }
  for (var p in obj2) {
    try {
      // Property in destination object set; update its value.
      if ( obj2[p].constructor==Object ) {
        obj1[p] = mergeRecursive(obj1[p], obj2[p]);
      } else if (Array.isArray(obj2[p])) {
        obj1[p] = obj1[p].concat(obj2[p]);
      } else {
        obj1[p] = obj2[p];
      }
    } catch(e) {
      // Property in destination object not set; create it and set its value.
      obj1[p] = obj2[p];
    }
  }
  return obj1;
}

使用object.assign和spread运算符合并两个对象。

错误的方式（修改原始对象，因为目标是o1）

var o1 = { X: 10 };
var o2 = { Y: 20 };
var o3 = { Z: 30 };
var merge = Object.assign(o1, o2, o3);
console.log(merge)  // {X:10, Y:20, Z:30}
console.log(o1)     // {X:10, Y:20, Z:30}

正确的方式

Object.assign（{}，o1，o2，o3）==>以新对象为目标｛…o1，…o2，…o3｝==>扩展对象

变量o1＝{X:10}；var o2＝{Y:20}；var o3＝{Z:30}；console.log（'不修改原始对象，因为目标｛｝'）；var merge=对象赋值（｛｝，o1，o2，o3）；console.log（合并）；//{X:10，Y:20，Z:30}控制台日志（o1）console.log（'不修改原始对象'）var spreadMerge＝{…o1，…o2，…o3}；console.log（spreadMerge）；控制台日志（o1）；

我使用Object.create（）来保持默认设置（使用__proto__或Object.getPrototypeOf（））。

function myPlugin( settings ){
    var defaults = {
        "keyName": [ "string 1", "string 2" ]
    }
    var options = Object.create( defaults );
    for (var key in settings) { options[key] = settings[key]; }
}
myPlugin( { "keyName": ["string 3", "string 4" ] } );

这样我以后就可以一直使用“concat（）”或“push（）”。

var newArray = options['keyName'].concat( options.__proto__['keyName'] );

注意：为了避免重复，需要在连接之前进行hasOwnProperty检查。

在Ext JS 4中，可以如下所示：

var mergedObject = Ext.Object.merge(object1, object2)

// Or shorter:
var mergedObject2 = Ext.merge(object1, object2)

请参见合并（对象）：对象。

A={a:1,b:function(){alert(9)}}
B={a:2,c:3}
A.merge = function(){for(var i in B){A[i]=B[i]}}
A.merge()

结果是：｛a:2，c:3，b:function（）｝

Use:

//Takes any number of objects and returns one merged object
var objectMerge = function(){
    var out = {};
    if(!arguments.length)
        return out;
    for(var i=0; i<arguments.length; i++) {
        for(var key in arguments[i]){
            out[key] = arguments[i][key];
        }
    }
    return out;
}

测试方法：

console.log(objectMerge({a:1, b:2}, {a:2, c:4}));

结果是：

{ a: 2, b: 2, c: 4 }