実行時に 2 つの (非常に単純な) JavaScript オブジェクトをマージできる必要があります。たとえば、私はしたい：
var obj1 = { food: 'pizza', car: 'ford' }
var obj2 = { animal: 'dog' }
obj1.merge(obj2);
//obj1 now has three properties: food, car, and animal
これを行うための組み込みの方法はありますか？再帰は必要ありません。関数をマージする必要もありません。フラット オブジェクトのメソッドだけです。
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-transform-object-rest-spreadプラグインが必要です。
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]; }
unmodifiedを引き続き使用したい場合、これは単にすべての属性を追加することに注意してobj2ください。obj1obj1
プロトタイプ全体をクラップするフレームワークを使用している場合は、 のようなチェックでより洗練されたものにする必要があります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;
}
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.
Harmony ECMAScript 2015 (ES6)は、Object.assignこれを行うものを指定します。
Object.assign(obj1, obj2);
現在のブラウザのサポートは改善されていますが、サポートされていないブラウザ向けに開発している場合は、ポリフィルを使用できます。
オブジェクトのプロパティをマージするコードをグーグルで検索して、ここに行き着きました。ただし、再帰マージのコードがなかったので、自分で作成しました。（多分jQuery拡張は再帰的ですが？）とにかく、うまくいけば、他の誰かがそれも役立つと思うでしょう。
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 } } };
underscore.jsのextend-methodはワンライナーでこれを行うことに注意してください:
_.extend({name : 'moe'}, {age : 50});
=> {name : 'moe', age : 50}
今日はオブジェクトをマージする必要があり、この質問 (および回答) は私を大いに助けてくれました。いくつかの回答を試してみましたが、どれも私のニーズに合っていなかったので、いくつかの回答を組み合わせ、自分で何かを追加して、新しいマージ機能を思いつきました。ここにあります：
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 }));
指定されたソリューションは、割り当ての前にループをチェックインするように変更する必要がsource.hasOwnProperty(property)ありfor..inます。そうしないと、プロトタイプ チェーン全体のプロパティをコピーすることになり、これはほとんど望まれません...
Object.assignメソッドは ECMAScript 2015 (ES6) 標準の一部であり、必要なことを正確に実行します。(IEサポートされていません)
var clone = Object.assign({}, obj);
Object.assign() メソッドは、列挙可能なすべての独自のプロパティの値を 1 つ以上のソース オブジェクトからターゲット オブジェクトにコピーするために使用されます。
古いブラウザーをサポートするポリフィル:
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;
}
});
}
これが私の刺し傷です
短いです ：）
/*
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
};
*/
ところで、皆さんが行っているのはプロパティの上書きであり、マージではありません...
これは、JavaScript オブジェクト領域が実際にマージされる方法です。toオブジェクト自体ではないオブジェクト内のキーのみが によって上書きされfromます。他のすべては実際にマージされます。もちろん、この動作を変更して、 if のみのように存在するものを上書きしないようにすることもできます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);
Object.assign()
ECMAScript 2015 (ES6)
これは、ECMAScript 2015 (ES6) 標準の一部である新しいテクノロジです。この技術の仕様は確定していますが、各種ブラウザでの使用状況や実装状況については対応表をご確認ください。
Object.assign() メソッドは、列挙可能なすべての独自のプロパティの値を 1 つ以上のソース オブジェクトからターゲット オブジェクトにコピーするために使用されます。対象のオブジェクトを返します。
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.
あまり複雑でないオブジェクトの場合は、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_/
この例では、"}{"が文字列内に出現してはならないことに注意してください。
これを行う最善の方法は、Object.defineProperty を使用して列挙できない適切なプロパティを追加することです。
このようにして、Object.prototype.extend を使用してプロパティを作成した場合に得られる、新しく作成された「拡張」を使用せずに、オブジェクトのプロパティを反復処理することができます。
うまくいけば、これが役立ちます：
Object.defineProperty(Object.prototype, "extend", {
列挙可能: false,
値: 関数 (から) {
var props = Object.getOwnPropertyNames(from);
var dest = this;
props.forEach(関数(名前) {
if (宛先の名前) {
var destination = Object.getOwnPropertyDescriptor(from, name);
Object.defineProperty(宛先、名前、宛先);
}
});
これを返します。
}
});
それが機能したら、次のことができます。
var obj = {
名前: 'スタック',
仕上げ：「オーバーフロー」
}
var 置換 = {
名前：「ストック」
};
obj.extend(置換);
ここにブログ記事を書きました: http://onemoredigit.com/post/1527191998/extending-objects-in-node-js
プロトタイプには次のものがあります。
Object.extend = function(destination,source) {
for (var property in source)
destination[property] = source[property];
return destination;
}
obj1.extend(obj2)あなたが望むことをします。
うわー..これは、複数のページで見た最初の StackOverflow 投稿です。別の「回答」を追加するための謝罪
この方法はES5以前用です-ES6に対処する他の回答がたくさんあります。
プロパティを利用してマージする「深い」オブジェクトは見当たりませんでした。argumentsこれが私の答えです-コンパクトで再帰的で、無制限のオブジェクト引数を渡すことができます：
function extend() {
for (var o = {}, i = 0; i < arguments.length; i++) {
// Uncomment to skip arguments that are not objects (to prevent errors)
// 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 objects
*/
function extend() {
for (var o = {}, i = 0; i < arguments.length; i++) {
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;
}
/**
* Example
*/
document.write(JSON.stringify(extend({
api: 1,
params: {
query: 'hello'
}
}, {
params: {
query: 'there'
}
})));
// outputs {"api": 1, "params": {"query": "there"}}この答えは今では大海の一滴に過ぎません...
誰かがGoogle Closure Libraryを使用している場合:
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'
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}
lodash のdefaultsDeepを使用する必要があります
_.defaultsDeep({ 'user': { 'name': 'barney' } }, { 'user': { 'name': 'fred', 'age': 36 } });
// → { 'user': { 'name': 'barney', 'age': 36 } }
140byte.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です。
使用する：
//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 }
function extend(o, o1, o2){
if( !(o instanceof Object) ) o = {};
copy(o, o1);
if( o2 )
copy(o, o2)
function isObject(obj) {
var type = Object.prototype.toString.call(obj);
return obj === Object(obj) && type != '[object Array]' && type != '[object Function]';
};
function copy(a,b){
// copy o2 to o
for( var key in b )
if( b.hasOwnProperty(key) ){
if( isObject(b[key]) ){
if( !isObject(a[key]) )
a[key] = Object.assign({}, b[key]);
else copy(a[key], b[key])
}
else
a[key] = b[key];
}
}
return o;
};
var o1 = {a:{foo:1}, b:1},
o2 = {a:{bar:2}, b:[1], c:()=>{}},
newMerged = extend({}, o1, o2);
console.log( newMerged )
console.log( o1 )
console.log( o2 )David Coallier の方法を gossi が拡張したもの:
次の 2 行を確認します。
from = arguments[i];
Object.getOwnPropertyNames(from).forEach(function (name) {
「from」をnullオブジェクトに対してチェックする必要があります...たとえば、サーバーで以前に作成されたAjax応答からのオブジェクトをマージする場合、オブジェクトプロパティは「null」の値を持つことができ、その場合は上記のコードは次のエラーを生成します。
「から」は有効なオブジェクトではありません
したがって、たとえば、「...Object.getOwnPropertyNames(from).forEach...」関数を「if (from != null) { ... }」でラップすると、そのエラーの発生を防ぐことができます。
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 チェックを行う必要があります。
私は JavaScript を使い始めたばかりなので、間違っていたら訂正してください。
しかし、任意の数のオブジェクトをマージできればもっと良いと思いませんか? ネイティブArgumentsオブジェクトを使用してそれを行う方法は次のとおりです。
重要なのは、関数宣言で引数を定義しなくても、JavaScript 関数に任意の数の引数を実際に渡すことができるということです。Arguments オブジェクトを使用しないとアクセスできません。
function mergeObjects() (
var tmpObj = {};
for(var o in arguments) {
for(var m in arguments[o]) {
tmpObj[m] = arguments[o][m];
}
}
return tmpObj;
}
私の方法に従ってオブジェクトをマージできます
var obj1 = { food: 'pizza', car: 'ford' };
var obj2 = { animal: 'dog' };
var result = mergeObjects([obj1, obj2]);
console.log(result);
document.write("result: <pre>" + JSON.stringify(result, 0, 3) + "</pre>");
function mergeObjects(objectArray) {
if (objectArray.length) {
var b = "", i = -1;
while (objectArray[++i]) {
var str = JSON.stringify(objectArray[i]);
b += str.slice(1, str.length - 1);
if (objectArray[i + 1]) b += ",";
}
return JSON.parse("{" + b + "}");
}
return {};
}ES5 互換のネイティブ ワンライナー:
var merged = [obj1, obj2].reduce(function(a, o) { for(k in o) a[k] = o[k]; return a; }, {})
objこれは「デフォルト」にマージされますdef。にコピーされるobjため、両方に存在するすべてのものが優先されます。これは再帰的であることに注意してください。objdef
function mergeObjs(def, obj) {
if (typeof obj == 'undefined') {
return def;
} else if (typeof def == 'undefined') {
return obj;
}
for (var i in obj) {
if (obj[i] != null && obj[i].constructor == Object) {
def[i] = mergeObjs(def[i], obj[i]);
} else {
def[i] = obj[i];
}
}
return def;
}
a = {x : {y : [123]}}
b = {x : {z : 123}}
console.log(mergeObjs(a, b));
// {x: {y : [123], z : 123}}
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()}
これを達成するための可能な方法は次のとおりです。
if (!Object.prototype.merge){
Object.prototype.merge = function(obj){
var self = this;
Object.keys(obj).forEach(function(key){
self[key] = obj[key]
});
}
};
他の回答よりも優れているかどうかはわかりません。このメソッドでは、merge functionをObjectsプロトタイプに追加します。この方法で呼び出すことができます obj1.merge(obj2);
注：引数を検証して、それがオブジェクトであるかどうかを確認し、適切なものを「スロー」する必要がありますError。そうでない場合はObject.keys、「エラー」を「スロー」します
すべてのオブジェクトにデフォルトのマージ (おそらく、より適切な名前を「継承」) メソッドを割り当てることができます。
オブジェクトまたはインスタンス化された関数のいずれかで動作する必要があります。
以下のコードは、必要に応じてマージされた値のオーバーライドを処理します。
Object.prototype.merge = function(obj, override) {
// Don't override by default
for (var key in obj) {
var n = obj[key];
var t = this[key];
this[key] = (override && t) ? n : t;
};
};
テストデータは以下です。
var Mammal = function () {
this.eyes = 2;
this.thinking_brain = false;
this.say = function () {
console.log('screaming like a mammal')};
}
var Human = function () {
this.thinking_brain = true;
this.say = function() {console.log('shouting like a human')};
}
john = new Human();
// Extend mammal, but do not override from mammal
john.merge(new Mammal());
john.say();
// Extend mammal and override from mammal
john.merge(new Mammal(), true);
john.say();
このソリューションは、新しいオブジェクトを作成し、複数のオブジェクトを処理できます。
さらに、再帰的で、値とオブジェクトを上書きする天気を選択できます。
function extendObjects() {
var newObject = {};
var overwriteValues = false;
var overwriteObjects = false;
for ( var indexArgument = 0; indexArgument < arguments.length; indexArgument++ ) {
if ( typeof arguments[indexArgument] !== 'object' ) {
if ( arguments[indexArgument] == 'overwriteValues_True' ) {
overwriteValues = true;
} else if ( arguments[indexArgument] == 'overwriteValues_False' ) {
overwriteValues = false;
} else if ( arguments[indexArgument] == 'overwriteObjects_True' ) {
overwriteObjects = true;
} else if ( arguments[indexArgument] == 'overwriteObjects_False' ) {
overwriteObjects = false;
}
} else {
extendObject( arguments[indexArgument], newObject, overwriteValues, overwriteObjects );
}
}
function extendObject( object, extendedObject, overwriteValues, overwriteObjects ) {
for ( var indexObject in object ) {
if ( typeof object[indexObject] === 'object' ) {
if ( typeof extendedObject[indexObject] === "undefined" || overwriteObjects ) {
extendedObject[indexObject] = object[indexObject];
}
extendObject( object[indexObject], extendedObject[indexObject], overwriteValues, overwriteObjects );
} else {
if ( typeof extendedObject[indexObject] === "undefined" || overwriteValues ) {
extendedObject[indexObject] = object[indexObject];
}
}
}
return extendedObject;
}
return newObject;
}
var object1 = { a : 1, b : 2, testArr : [888, { innArr : 1 }, 777 ], data : { e : 12, c : { lol : 1 }, rofl : { O : 3 } } };
var object2 = { a : 6, b : 9, data : { a : 17, b : 18, e : 13, rofl : { O : 99, copter : { mao : 1 } } }, hexa : { tetra : 66 } };
var object3 = { f : 13, g : 666, a : 333, data : { c : { xD : 45 } }, testArr : [888, { innArr : 3 }, 555 ] };
var newExtendedObject = extendObjects( 'overwriteValues_False', 'overwriteObjects_False', object1, object2, object3 );
newExtendedObject の内容:
{"a":1,"b":2,"testArr":[888,{"innArr":1},777],"data":{"e":12,"c":{"lol":1,"xD":45},"rofl":{"O":3,"copter":{"mao":1}},"a":17,"b":18},"hexa":{"tetra":66},"f":13,"g":666}
function extend()
{
var o = {};
for (var i in arguments)
{
var s = arguments[i];
for (var i in s)
{
o[i] = s[i];
}
}
return o;
}
結果で配列を連結して配列を「マージ」する深いマージが必要な場合は、次の ES6 関数が必要になる可能性があります。
function deepMerge(a, b) {
// If neither is an object, return one of them:
if (Object(a) !== a && Object(b) !== b) return b || a;
// Replace remaining primitive by empty object/array
if (Object(a) !== a) a = Array.isArray(b) ? [] : {};
if (Object(b) !== b) b = Array.isArray(a) ? [] : {};
// Treat arrays differently:
if (Array.isArray(a) && Array.isArray(b)) {
// Merging arrays is interpreted as concatenation of their deep clones:
return [...a.map(v => deepMerge(v)), ...b.map(v => deepMerge(v))];
} else {
// Get the keys that exist in either object
var keys = new Set([...Object.keys(a),...Object.keys(b)]);
// Recurse and assign to new object
return Object.assign({}, ...Array.from(keys,
key => ({ [key]: deepMerge(a[key], b[key]) }) ));
}
}
// Sample data for demo:
var a = {
groups: [{
group: [{
name: 'John',
age: 12
},{
name: 'Mary',
age: 20
}],
groupName: 'Pair'
}],
config: {
color: 'blue',
range: 'far'
}
};
var b = {
groups: [{
group: [{
name: 'Bill',
age: 15
}],
groupName: 'Loner'
}],
config: {
range: 'close',
strength: 'average'
}
};
var merged = deepMerge(a, b);
console.log(merged);.as-console-wrapper { max-height: 100% !important; top: 0; }この関数に引数が 1 つしか渡されない場合は、ディープ クローン関数として機能することに注意してください。