顺便说一句，你们正在做的是覆盖财产，而不是合并。。。

这就是JavaScript对象区域真正合并的方式：只有to对象中不是对象本身的键才会被from覆盖。其他一切都将被真正合并。当然，您可以将此行为更改为不覆盖任何存在的内容，例如仅当to[n]未定义时，等等…：

var realMerge = function (to, from) {

    for (n in from) {

        if (typeof to[n] != 'object') {
            to[n] = from[n];
        } else if (typeof from[n] == 'object') {
            to[n] = realMerge(to[n], from[n]);
        }
    }
    return to;
};

用法：

var merged = realMerge(obj1, obj2);

JSON兼容JavaScript对象的合并

我鼓励使用和利用不修改原始源代码的非破坏性方法，“Object.assign”是一种破坏性的方法，而且它也不太适合生产，因为它在早期浏览器上停止工作，而且你没有办法用其他方法对它进行干净的修补。

无论采用何种解决方案，合并JS对象都将永远无法实现或不完整。但是，合并JSON兼容的兼容对象离能够编写一段简单且可移植的代码只有一步之遥。该代码是一种非破坏性方法，将一系列JS对象合并到一个返回的主对象中，该主对象包含所有唯一的属性名及其对应的值，这些属性名合成在一个主对象中用于预期目的。

考虑到MSIE8是第一个为JSON对象添加本地支持的浏览器，这是一种极大的解脱，重用现有技术始终是一个受欢迎的机会。

将代码限制为JSON兼容的标准对象，与其说是限制，不如说是优势，因为这些对象也可以通过互联网传输。当然，对于那些想要更深入的向后兼容性的人来说，总是有一个json插件。，其方法可以很容易地分配给外部代码中的JSON变量，而无需修改或重写正在使用的方法。

function Merge( ){
    var a = [].slice.call( arguments ), i = 0;
        while( a[i] )a[i] = JSON.stringify( a[i++] ).slice( 1,-1 );
        return JSON.parse( "{"+ a.join() +"}" );
    }

（当然，人们总是可以给它取一个更有意义的名字，我还没有决定；应该把它命名为JSONmerge）

用例：

var master = Merge( obj1, obj2, obj3, ...objn );

现在，与Object.assign相反，这将使所有对象保持不变，并保持其原始状态（以防您做错了什么，需要重新排序合并对象，或者在再次合并之前能够将它们单独用于其他操作）。

Merge参数的数量也仅受参数长度限制[这是巨大的]的限制。本机支持的JSON parse/stringify已经进行了机器优化，这意味着：它应该比任何脚本形式的JS循环都快。对给定参数的迭代是使用while完成的，while被证明是JS中最快的循环。

简单地提一下我们已经知道的事实，即唯一对象标签（键）的重复财产将被包含相同键标签的后一个对象覆盖，这并不有害，这意味着您可以通过简单地对参数列表进行排序或重新排序来控制哪个属性将取代前一个属性。以及获得一个干净且更新的主对象而无重复作为最终输出的好处。

;var obj1=｛a:1｝，obj2=｛b:2｝，obj3=｛c:3｝;函数合并（）{var a=[].slice.call（参数），i=0；而（a[i]）a[i]=JSON.stringify（a[i++]）.slice（1，-1）；return JSON.parse（“｛”+a.join（）+“｝”）；};var master=合并（obj1、obj2、obj3）;console.log（JSON.stringify（master））;

我使用纯JavaScript中的以下内容。它从最右边的参数开始，并将它们组合到第一个参数。没有返回值，只修改了第一个参数，最左边的参数（第一个除外）在财产上具有最高的权重。

var merge = function() {
  var il = arguments.length;

  for (var i = il - 1; i > 0; --i) {
    for (var key in arguments[i]) {
      if (arguments[i].hasOwnProperty(key)) {
        arguments[0][key] = arguments[i][key];
      }
    }
  }
};

使用ES6版本之后的Spread运算符

var obj1 = { food: 'pizza', car: 'ford' }
var obj2 = { animal: 'dog' }
let result = {...obj1,...obj2};
console.log(result)

output { food: 'pizza', car: 'ford', animal: 'dog' }

在MooTools中，有Object.merge（）：

Object.merge(obj1, obj2);

这是我的刺

支持深度合并不改变参数采用任意数量的参数不扩展对象原型不依赖于其他库（jQuery、MooTools、Undercore.js等）包括检查hasOwnProperty短：）/*递归合并财产并返回新对象对象1&lt；-对象2[&lt；-…]*/函数合并（）{变量dst=｛｝，srcp，args=[].splice.call（参数，0）;while（参数长度>0）{src=参数拼接（0，1）[0]；if（toString.call（src）=='[object object]'）{for（src中的p）{if（src.hasOwnProperty（p））{if（toString.call（src[p]）=='[object object]'）{dst[p]=合并（dst[p]||{}，src[p]）；}其他{dst[p]=src[p]；}}}}}返回dst；}

例子：

a = {
    "p1": "p1a",
    "p2": [
        "a",
        "b",
        "c"
    ],
    "p3": true,
    "p5": null,
    "p6": {
        "p61": "p61a",
        "p62": "p62a",
        "p63": [
            "aa",
            "bb",
            "cc"
        ],
        "p64": {
            "p641": "p641a"
        }
    }
};

b = {
    "p1": "p1b",
    "p2": [
        "d",
        "e",
        "f"
    ],
    "p3": false,
    "p4": true,
    "p6": {
        "p61": "p61b",
        "p64": {
            "p642": "p642b"
        }
    }
};

c = {
    "p1": "p1c",
    "p3": null,
    "p6": {
        "p62": "p62c",
        "p64": {
            "p643": "p641c"
        }
    }
};

d = merge(a, b, c);


/*
    d = {
        "p1": "p1c",
        "p2": [
            "d",
            "e",
            "f"
        ],
        "p3": null,
        "p5": null,
        "p6": {
            "p61": "p61b",
            "p62": "p62c",
            "p63": [
                "aa",
                "bb",
                "cc"
            ],
            "p64": {
                "p641": "p641a",
                "p642": "p642b",
                "p643": "p641c"
            }
        },
        "p4": true
    };
*/