如何动态合并两个JavaScript对象的属性？
程序员文章站
2024-01-13 20:10:22
...
我需要能够在运行时合并两个（非常简单的）JavaScript对象。 例如，我想：
var obj1 = { food: 'pizza', car: 'ford' }
var obj2 = { animal: 'dog' }
obj1.merge(obj2);
//obj1 now has three properties: food, car, and animal
有没有人为此提供脚本或是否知道内置方法？ 我不需要递归，也不需要合并函数，只需合并平面对象上的方法即可。
#1楼
就算有人使用Google Closure库 ：
goog.require('goog.object');
var a = {'a': 1, 'b': 2};
var b = {'b': 3, 'c': 4};
goog.object.extend(a, b);
// Now object a == {'a': 1, 'b': 3, 'c': 4};
var a = [1, 2];
var b = [3, 4];
goog.array.extend(a, b); // Extends array 'a'
goog.array.concat(a, b); // Returns concatenation of array 'a' and 'b'
#2楼
在MooTools中 ，有Object.merge（） ：
Object.merge(obj1, obj2);
#3楼
顺便说一句，您正在做的是覆盖属性，而不是合并...
这就是JavaScript对象区域真正合并的方式： from只会覆盖to对象中不是对象本身的键。 其他所有内容都将真正合并 。 当然，您可以更改此行为，以不覆盖任何存在的东西，例如仅当to[n] is undefined等时：
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);
#4楼
值得一提的是， 140byt.es集合中的版本正在最小的空间内解决任务，因此值得尝试：
码：
function m(a,b,c){for(c in b)b.hasOwnProperty(c)&&((typeof a[c])[0]=='o'?m(a[c],b[c]):a[c]=b[c])}
用途：
m(obj1,obj2);
这是原始的Gist 。
#5楼
这是我的刺
- 支持深度合并
- 不改变参数
- 接受任意数量的参数
- 不扩展对象原型
- 不依赖于另一个库（ jQuery ， MooTools ， Underscore.js等）
- 包括对hasOwnProperty的检查
-
是短 ：）
/* Recursively merge properties and return new object obj1 <- obj2 [ <- ... ] */ function merge () { var dst = {} ,src ,p ,args = [].splice.call(arguments, 0) ; while (args.length > 0) { src = args.splice(0, 1)[0]; if (toString.call(src) == '[object Object]') { for (p in src) { if (src.hasOwnProperty(p)) { if (toString.call(src[p]) == '[object Object]') { dst[p] = merge(dst[p] || {}, src[p]); } else { dst[p] = src[p]; } } } } } return 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
};
*/
#6楼
ECMAScript 2018标准方法
您将使用对象传播 ：
let merged = {...obj1, ...obj2};
/** 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，则需要此插件才能正常工作。
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这样的检查变得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;
}
#7楼
原型具有：
Object.extend = function(destination,source) {
for (var property in source)
destination[property] = source[property];
return destination;
}
obj1.extend(obj2)将做您想要的。
#8楼
jQuery对此也有一个实用程序： http : //api.jquery.com/jQuery.extend/ 。
取自jQuery文档：
// Merge options object into settings object
var settings = { validate: false, limit: 5, name: "foo" };
var options = { validate: true, name: "bar" };
jQuery.extend(settings, options);
// Now the content of settings object is the following:
// { validate: true, limit: 5, name: "bar" }
上面的代码将使现有的对象命名为settings 。
如果要创建新对象而不修改任何一个参数，请使用以下命令：
var defaults = { validate: false, limit: 5, name: "foo" };
var options = { validate: true, name: "bar" };
/* Merge defaults and options, without modifying defaults */
var settings = $.extend({}, defaults, options);
// The content of settings variable is now the following:
// {validate: true, limit: 5, name: "bar"}
// The 'defaults' and 'options' variables remained the same.
#9楼
与jQuery extend（）类似，您在AngularJS中具有相同的功能：
// Merge the 'options' object into the 'settings' object
var settings = {validate: false, limit: 5, name: "foo"};
var options = {validate: true, name: "bar"};
angular.extend(settings, options);
#10楼
使用Underscore.js ，可以合并对象数组：
var arrayOfObjects = [ {a:1}, {b:2, c:3}, {d:4} ];
_(arrayOfObjects).reduce(function(memo, o) { return _(memo).extend(o); });
结果是：
Object {a: 1, b: 2, c: 3, d: 4}
#11楼
对于不太复杂的对象，可以使用JSON ：
var obj1 = { food: 'pizza', car: 'ford' }
var obj2 = { animal: 'dog', car: 'chevy'}
var objMerge;
objMerge = JSON.stringify(obj1) + JSON.stringify(obj2);
// {"food": "pizza","car":"ford"}{"animal":"dog","car":"chevy"}
objMerge = objMerge.replace(/\}\{/, ","); // \_ replace with comma for valid JSON
objMerge = JSON.parse(objMerge); // { food: 'pizza', animal: 'dog', car: 'chevy'}
// Of same keys in both objects, the last object's value is retained_/
请注意，在此示例中，“} {” 一定不能出现在字符串中！
#12楼
GitHub上有一个名为deepmerge的库：似乎正在受到关注。 它是独立的，可通过npm和bower软件包管理器使用。
我倾向于对此进行使用或改进，而不是从答案中粘贴粘贴代码。
#13楼
Harmony ECMAScript 2015（ES6）指定将执行此操作的Object.assign 。
Object.assign(obj1, obj2);
当前的浏览器支持越来越好 ，但是如果您正在开发不支持的浏览器，则可以使用polyfill 。
#14楼
以下两个可能是一个很好的起点。 lodash还具有满足这些特殊需求的定制器功能！
_.extend （ http://underscorejs.org/#extend ） _.merge （ https://lodash.com/docs#merge ）
#15楼
您可以简单地使用jQuery extend
var obj1 = { val1: false, limit: 5, name: "foo" };
var obj2 = { val2: true, name: "bar" };
jQuery.extend(obj1, obj2);
现在obj1包含obj1和obj2所有值
#16楼
Object.assign（）
ECMAScript 2015（ES6）
这是一项新技术，是ECMAScript 2015（ES6）标准的一部分。 该技术的规范已经完成，但是请检查兼容性表以了解各种浏览器的使用和实现状态。
Object.assign（）方法用于将所有可枚举的自身属性的值从一个或多个源对象复制到目标对象。 它将返回目标对象。
var o1 = { a: 1 };
var o2 = { b: 2 };
var o3 = { c: 3 };
var obj = Object.assign(o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
console.log(o1); // { a: 1, b: 2, c: 3 }, target object itself is changed.
#17楼
在一行代码中合并N个对象的属性
Object.assign方法是ECMAScript 2015（ES6）标准的一部分，可以完全满足您的需求。 （不支持IE ）
var clone = Object.assign({}, obj);
Object.assign（）方法用于将所有可枚举的自身属性的值从一个或多个源对象复制到目标对象。
支持旧版浏览器的polyfill ：
if (!Object.assign) {
Object.defineProperty(Object, 'assign', {
enumerable: false,
configurable: true,
writable: true,
value: function(target) {
'use strict';
if (target === undefined || target === null) {
throw new TypeError('Cannot convert first argument to object');
}
var to = Object(target);
for (var i = 1; i < arguments.length; i++) {
var nextSource = arguments[i];
if (nextSource === undefined || nextSource === null) {
continue;
}
nextSource = Object(nextSource);
var keysArray = Object.keys(nextSource);
for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
var nextKey = keysArray[nextIndex];
var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
if (desc !== undefined && desc.enumerable) {
to[nextKey] = nextSource[nextKey];
}
}
}
return to;
}
});
}
#18楼
您应该使用lodash的默认值
_.defaultsDeep({ 'user': { 'name': 'barney' } }, { 'user': { 'name': 'fred', 'age': 36 } });
// → { 'user': { 'name': 'barney', 'age': 36 } }
#19楼
我用谷歌搜索代码来合并对象属性，并在这里结束。 但是，由于没有用于递归合并的任何代码，所以我自己编写了它。 （也许jQuery扩展是递归BTW吗？）无论如何，希望其他人也会发现它也有用。
（现在代码不使用Object.prototype ：）
码
/*
* Recursively merge properties of two objects
*/
function MergeRecursive(obj1, 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 {
obj1[p] = obj2[p];
}
} catch(e) {
// Property in destination object not set; create it and set its value.
obj1[p] = obj2[p];
}
}
return obj1;
}
一个例子
o1 = { a : 1,
b : 2,
c : {
ca : 1,
cb : 2,
cc : {
cca : 100,
ccb : 200 } } };
o2 = { a : 10,
c : {
ca : 10,
cb : 20,
cc : {
cca : 101,
ccb : 202 } } };
o3 = MergeRecursive(o1, o2);
产生像o3的对象
o3 = { a : 10,
b : 2,
c : {
ca : 10,
cb : 20,
cc : {
cca : 101,
ccb : 202 } } };
#20楼
给定的解决方案应进行修改，以在分配之前在for..in循环中检查source.hasOwnProperty(property) -否则，最终将复制整个原型链的属性，这是很少需要的...
#21楼
做到这一点的最好方法是使用Object.defineProperty添加一个不可枚举的适当属性。
这样，您仍然可以遍历对象的属性，而不必使用使用Object.prototype.extend创建属性时将获得的新创建的“ extend”。
希望这会有所帮助：
Object.defineProperty(Object.prototype, "extend", {
enumerable: false,
value: function(from) {
var props = Object.getOwnPropertyNames(from);
var dest = this;
props.forEach(function(name) {
if (name in dest) {
var destination = Object.getOwnPropertyDescriptor(from, name);
Object.defineProperty(dest, name, destination);
}
});
return this;
}
});
工作完成后，您可以执行以下操作：
var obj = {
name: 'stack',
finish: 'overflow'
}
var replacement = {
name: 'stock'
};
obj.extend(replacement);
我刚刚在这里写了一篇博客文章： http : //onemoredigit.com/post/1527191998/extending-objects-in-node-js
#22楼
您可以使用对象传播属性 -当前是第3阶段ECMAScript提议。
const obj1 = { food: 'pizza', car: 'ford' }; const obj2 = { animal: 'dog' }; const obj3 = { ...obj1, ...obj2 }; console.log(obj3);
#23楼
**使用Object.assign或spread ...运算符合并对象很简单**
var obj1 = { food: 'pizza', car: 'ford' } var obj2 = { animal: 'dog', car: 'BMW' } var obj3 = {a: "A"} var mergedObj = Object.assign(obj1,obj2,obj3) // or using the Spread operator (...) var mergedObj = {...obj1,...obj2,...obj3} console.log(mergedObj);
对象从右到左合并，这意味着将覆盖与右边的对象具有相同属性的对象。
在此示例中， obj2.car覆盖obj1.car
#24楼
哇..这是我见过的多页内容中的第一篇*文章。 抱歉，添加另一个“答案”
此方法适用于ES5及更早版本 -还有很多其他答案可以解决ES6。
我没有看到利用arguments属性合并的任何“深层”对象。 这是我的答案- 紧凑和递归 ，允许传递无限的对象参数：
function extend() {
for (var o = {}, i = 0; i < arguments.length; i++) {
// if (arguments[i].constructor !== Object) continue;
for (var k in arguments[i]) {
if (arguments[i].hasOwnProperty(k)) {
o[k] = arguments[i][k].constructor === Object ? extend(o[k] || {}, arguments[i][k]) : arguments[i][k];
}
}
}
return o;
}
被注释掉的部分是可选的..它只会跳过传递的不是对象的参数（防止错误）。
例：
extend({
api: 1,
params: {
query: 'hello'
}
}, {
params: {
query: 'there'
}
});
// outputs {api: 1, params: {query: 'there'}}
现在这个答案不过是沧海一粟...
#25楼
var obj1 = { food: 'pizza', car: 'ford' }
var obj2 = { animal: 'dog' }
// result
result: {food: "pizza", car: "ford", animal: "dog"}
使用jQuery.extend（） - 链接
// Merge obj1 & obj2 to result
var result1 = $.extend( {}, obj1, obj2 );
使用_.merge（） - 链接
// Merge obj1 & obj2 to result
var result2 = _.merge( {}, obj1, obj2 );
使用_.extend（） - 链接
// Merge obj1 & obj2 to result
var result3 = _.extend( {}, obj1, obj2 );
使用Object.assign（）ECMAScript 2015（ES6） - 链接
// Merge obj1 & obj2 to result
var result4 = Object.assign( {}, obj1, obj2 );
全部输出
obj1: { animal: 'dog' }
obj2: { food: 'pizza', car: 'ford' }
result1: {food: "pizza", car: "ford", animal: "dog"}
result2: {food: "pizza", car: "ford", animal: "dog"}
result3: {food: "pizza", car: "ford", animal: "dog"}
result4: {food: "pizza", car: "ford", animal: "dog"}
#26楼
let obj1 = {a:1, b:2}; let obj2 = {c:3, d:4}; let merged = {...obj1, ...obj2}; console.log(merged);
#27楼
我扩展了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中的对象比较
#28楼
在Ext JS 4中，可以按照以下步骤进行操作：
var mergedObject = Ext.Object.merge(object1, object2)
// Or shorter:
var mergedObject2 = Ext.merge(object1, object2)
请参见merge（object）：Object 。
#29楼
我今天需要合并对象，这个问题（和答案）对我有很大帮助。 我尝试了一些答案，但都不满足我的需求，因此我合并了一些答案，自己添加了一些内容，并提出了新的合并功能。 这里是：
var merge = function() {
var obj = {},
i = 0,
il = arguments.length,
key;
for (; i < il; i++) {
for (key in arguments[i]) {
if (arguments[i].hasOwnProperty(key)) {
obj[key] = arguments[i][key];
}
}
}
return obj;
};
一些示例用法：
var t1 = {
key1: 1,
key2: "test",
key3: [5, 2, 76, 21]
};
var t2 = {
key1: {
ik1: "hello",
ik2: "world",
ik3: 3
}
};
var t3 = {
key2: 3,
key3: {
t1: 1,
t2: 2,
t3: {
a1: 1,
a2: 3,
a4: [21, 3, 42, "asd"]
}
}
};
console.log(merge(t1, t2));
console.log(merge(t1, t3));
console.log(merge(t2, t3));
console.log(merge(t1, t2, t3));
console.log(merge({}, t1, { key1: 1 }));
#30楼
基于Markus和vsync的答案 ，这是扩展版本。 该函数接受任意数量的参数。 它可用于在DOM节点上设置属性并制作值的深层副本。 但是，第一个参数是通过引用给出的。
要检测DOM节点，请使用isDOMNode（）函数（请参阅堆栈溢出问题JavaScript isDOM —如何检查JavaScript对象是否为DOM对象？ ）
它已在Opera 11，Firefox 6， Internet Explorer 8和Google Chrome 16中进行了测试。
码
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;
}
一些例子
设置innerHTML和HTML元素的样式
mergeRecursive(
document.getElementById('mydiv'),
{style: {border: '5px solid green', color: 'red'}},
{innerHTML: 'Hello world!'});
合并数组和对象。 请注意，未定义可用于保留左侧数组/对象中的值。
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
编辑 （通过ReaperSoon）：
还合并数组
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;
}
#31楼
请注意， underscore.js的extend -method可以单行执行此操作：
_.extend({name : 'moe'}, {age : 50});
=> {name : 'moe', age : 50}
推荐阅读
-
如何动态合并两个JavaScript对象的属性？
-
jquery如何给对象动态添加属性以及选择器、事件的绑定？（代码教程）
-
javascript动态创建对象的属性详解
-
JavaScript中的window对象的属性和方法；JavaScript中如何选取文档元素
-
jquery如何给对象动态添加属性以及选择器、事件的绑定？（代码教程）
-
javascript动态创建对象的属性详解
-
JavaScript简单实现合并两个Json对象的方法示例
-
jdk8使用stream实现两个list集合合并成一个(对象属性的合并)
-
JavaScript如何使用运算符和属性判断对象类型的方法总结
-
JavaScript如何使用运算符和属性判断对象类型的方法总结