gossi对David Coallier方法的扩展：

检查这两行：

from = arguments[i];
Object.getOwnPropertyNames(from).forEach(function (name) {

需要针对空对象检查“from”。。。例如，如果合并以前在服务器上创建的来自Ajax响应的对象，则对象属性的值可以为“null”，在这种情况下，上述代码会生成一个错误消息：

“from”不是有效对象

因此，例如，将“…Object.getOwnPropertyNames（from）.forEach…”函数包装为“if（from！=null）｛…｝”将防止发生该错误。

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））;

我扩展了David Coallier的方法：

增加了合并多个对象的可能性支持深层对象override参数（如果最后一个参数是布尔值，则检测到）

如果覆盖为false，则不会覆盖任何属性，但会添加新的财产。

用法：obj.merge（合并…[，覆盖]）；

这是我的代码：

Object.defineProperty(Object.prototype, "merge", {
    enumerable: false,
    value: function () {
        var override = true,
            dest = this,
            len = arguments.length,
            props, merge, i, from;

        if (typeof(arguments[arguments.length - 1]) === "boolean") {
            override = arguments[arguments.length - 1];
            len = arguments.length - 1;
        }

        for (i = 0; i < len; i++) {
            from = arguments[i];
            if (from != null) {
                Object.getOwnPropertyNames(from).forEach(function (name) {
                    var descriptor;

                    // nesting
                    if ((typeof(dest[name]) === "object" || typeof(dest[name]) === "undefined")
                            && typeof(from[name]) === "object") {

                        // ensure proper types (Array rsp Object)
                        if (typeof(dest[name]) === "undefined") {
                            dest[name] = Array.isArray(from[name]) ? [] : {};
                        }
                        if (override) {
                            if (!Array.isArray(dest[name]) && Array.isArray(from[name])) {
                                dest[name] = [];
                            }
                            else if (Array.isArray(dest[name]) && !Array.isArray(from[name])) {
                                dest[name] = {};
                            }
                        }
                        dest[name].merge(from[name], override);
                    } 

                    // flat properties
                    else if ((name in dest && override) || !(name in dest)) {
                        descriptor = Object.getOwnPropertyDescriptor(from, name);
                        if (descriptor.configurable) {
                            Object.defineProperty(dest, name, descriptor);
                        }
                    }
                });
            }
        }
        return this;
    }
});

示例和测试用例：

function clone (obj) {
    return JSON.parse(JSON.stringify(obj));
}
var obj = {
    name : "trick",
    value : "value"
};

var mergeObj = {
    name : "truck",
    value2 : "value2"
};

var mergeObj2 = {
    name : "track",
    value : "mergeObj2",
    value2 : "value2-mergeObj2",
    value3 : "value3"
};

assertTrue("Standard", clone(obj).merge(mergeObj).equals({
    name : "truck",
    value : "value",
    value2 : "value2"
}));

assertTrue("Standard no Override", clone(obj).merge(mergeObj, false).equals({
    name : "trick",
    value : "value",
    value2 : "value2"
}));

assertTrue("Multiple", clone(obj).merge(mergeObj, mergeObj2).equals({
    name : "track",
    value : "mergeObj2",
    value2 : "value2-mergeObj2",
    value3 : "value3"
}));

assertTrue("Multiple no Override", clone(obj).merge(mergeObj, mergeObj2, false).equals({
    name : "trick",
    value : "value",
    value2 : "value2",
    value3 : "value3"
}));

var deep = {
    first : {
        name : "trick",
        val : "value"
    },
    second : {
        foo : "bar"
    }
};

var deepMerge = {
    first : {
        name : "track",
        anotherVal : "wohoo"
    },
    second : {
        foo : "baz",
        bar : "bam"
    },
    v : "on first layer"
};

assertTrue("Deep merges", clone(deep).merge(deepMerge).equals({
    first : {
        name : "track",
        val : "value",
        anotherVal : "wohoo"
    },
    second : {
        foo : "baz",
        bar : "bam"
    },
    v : "on first layer"
}));

assertTrue("Deep merges no override", clone(deep).merge(deepMerge, false).equals({
    first : {
        name : "trick",
        val : "value",
        anotherVal : "wohoo"
    },
    second : {
        foo : "bar",
        bar : "bam"
    },
    v : "on first layer"
}));

var obj1 = {a: 1, b: "hello"};
obj1.merge({c: 3});
assertTrue(obj1.equals({a: 1, b: "hello", c: 3}));

obj1.merge({a: 2, b: "mom", d: "new property"}, false);
assertTrue(obj1.equals({a: 1, b: "hello", c: 3, d: "new property"}));

var obj2 = {};
obj2.merge({a: 1}, {b: 2}, {a: 3});
assertTrue(obj2.equals({a: 3, b: 2}));

var a = [];
var b = [1, [2, 3], 4];
a.merge(b);
assertEquals(1, a[0]);
assertEquals([2, 3], a[1]);
assertEquals(4, a[2]);


var o1 = {};
var o2 = {a: 1, b: {c: 2}};
var o3 = {d: 3};
o1.merge(o2, o3);
assertTrue(o1.equals({a: 1, b: {c: 2}, d: 3}));
o1.b.c = 99;
assertTrue(o2.equals({a: 1, b: {c: 2}}));

// checking types with arrays and objects
var bo;
a = [];
bo = [1, {0:2, 1:3}, 4];
b = [1, [2, 3], 4];

a.merge(b);
assertTrue("Array stays Array?", Array.isArray(a[1]));

a = [];
a.merge(bo);
assertTrue("Object stays Object?", !Array.isArray(a[1]));

a = [];
a.merge(b);
a.merge(bo);
assertTrue("Object overrides Array", !Array.isArray(a[1]));

a = [];
a.merge(b);
a.merge(bo, false);
assertTrue("Object does not override Array", Array.isArray(a[1]));

a = [];
a.merge(bo);
a.merge(b);
assertTrue("Array overrides Object", Array.isArray(a[1]));

a = [];
a.merge(bo);
a.merge(b, false);
assertTrue("Array does not override Object", !Array.isArray(a[1]));

我的equals方法可以在这里找到：JavaScript中的对象比较

我使用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检查。

函数扩展（o，o1，o2）{如果（！（o instanceof Object））o=｛｝；副本（o，o1）；如果（o2）副本（o，o2）函数isObject（obj）{var type=Object.protype.toString.call（obj）；return obj===对象（obj）&&type！='[object Array]'&&type！='[object函数]'；};功能副本（a，b）{//将o2复制到ofor（b中的var键）if（b.hasOwnProperty（键））{if（isObject（b[key]））{if（！isObject（a[key]））a[key]=Object.assign（{}，b[key]）；其他副本（a[key]，b[key]）}其他的a[key]=b[key]；}}返回o；};变量o1＝｛a:｛foo:1｝，b:1｝，o2={a:{bar:2}，b:[1]，c:（）=>{}}，newMerged=扩展（{}，o1，o2）；console.log（newMerged）控制台日志（o1）控制台日志（o2）

ECMAScript 2018标准方法

您可以使用对象扩散：

let merged = {...obj1, ...obj2};

merged现在是obj1和obj2的并集。obj2中的财产将覆盖obj1中的属性。

/** There's no limit to the number of objects you can merge.
 *  Later properties overwrite earlier properties with the same name. */
const allRules = {...obj1, ...obj2, ...obj3};

这里还有此语法的MDN文档。如果您正在使用babel，则需要@babel/plugin提议对象rest spread插件才能工作（该插件包含在ES2018中的@babel/preset-env中）。

ECMAScript 2015（ES6）标准方法

/* For the case in question, you would do: */
Object.assign(obj1, obj2);

/** There's no limit to the number of objects you can merge.
 *  All objects get merged into the first object. 
 *  Only the object in the first argument is mutated and returned.
 *  Later properties overwrite earlier properties with the same name. */
const allRules = Object.assign({}, obj1, obj2, obj3, etc);

（参见MDN JavaScript参考）

ES5及更早版本的方法

for (var attrname in obj2) { obj1[attrname] = obj2[attrname]; }

请注意，这将简单地将obj2的所有属性添加到obj1中，如果您仍然希望使用未修改的obj1，那么这可能不是您想要的。

如果你使用的是一个在你的原型上到处都是垃圾的框架，那么你必须通过hasOwnProperty这样的检查来获得更高的效率，但这段代码在99%的情况下都是有效的。

示例函数：

/**
 * Overwrites obj1's values with obj2's and adds obj2's if non existent in obj1
 * @param obj1
 * @param obj2
 * @returns obj3 a new object based on obj1 and obj2
 */
function merge_options(obj1,obj2){
    var obj3 = {};
    for (var attrname in obj1) { obj3[attrname] = obj1[attrname]; }
    for (var attrname in obj2) { obj3[attrname] = obj2[attrname]; }
    return obj3;
}