दिलचस्प पोस्ट
शब्दकोश बनाम ऑब्जेक्ट – जो अधिक कुशल है और क्यों? didFinishPickingMediaWithInfo वापसी शून्य तस्वीर एक्सप्रेस 4 में socket.io और एक्सप्रेस-जनरेटर / बिन / www का उपयोग करना जावा में पाश बनाम Iterator / foreach के लिए परंपरागत प्रदर्शन कैसे दिनांक समय। यूनिवर्सल टाइम () काम करता है? एक पृष्ठ पर सभी AJAX अनुरोधों के लिए "हुक" जोड़ें जावास्क्रिप्ट दिनांक टाइमज़ोन अंक शेल स्क्रिप्ट में `मार -0 $ pid 'क्या करता है? मैं दशमलव के रूप में एक इंट क्यों नहीं खुल सकता? असाइनमेंट पूर्णांक से बिना कलाकारों के सूचक बनाता है हैशसेट बनाम सूची प्रदर्शन स्थान विवरण प्राप्त करने के लिए प्लेस एटोकॉम्पलेट फ्रेग्मेंट और प्लेस एटोकॉम्पलेट एक्टिविटी कैसे कार्यान्वित करें जावा 8 में जेडीबीसी ओडीबीसी पुल का हटाया जाना आईओएस एप डीबगर में चल रहा है या नहीं, इसका पता लगाने कैसे jQuery .डेटा () काम करता है?

मैं गतिशील रूप से दो जावास्क्रिप्ट ऑब्जेक्ट के गुणों को कैसे मर्ज कर सकता हूं?

रनटाइम पर दो (बहुत सरल) जावास्क्रिप्ट ऑब्जेक्ट्स को मर्ज करने में सक्षम होने की आवश्यकता है I उदाहरण के लिए मैं चाहता हूं:

var obj1 = { food: 'pizza', car: 'ford' } var obj2 = { animal: 'dog' } obj1.merge(obj2); //obj1 now has three properties: food, car, and animal 

क्या किसी के पास इस के लिए एक स्क्रिप्ट है या यह करने के लिए बनाया गया है? मुझे रिकर्सन की आवश्यकता नहीं है, और मुझे फ़ंक्शन मर्ज करने की आवश्यकता नहीं है, बस फ्लैट वस्तुओं पर तरीकों

Solutions Collecting From Web of "मैं गतिशील रूप से दो जावास्क्रिप्ट ऑब्जेक्ट के गुणों को कैसे मर्ज कर सकता हूं?"

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

( एमडीएन जावास्क्रिप्ट संदर्भ देखें)


ES5 के लिए विधि और इससे पहले

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

ध्यान दें कि यह केवल obj2 सभी गुण obj1 को जोड़ देगा, जो कि आप क्या चाहते हैं, अगर आप अभी भी असम्बद्ध obj1 का उपयोग करना चाहते हैं

यदि आप एक ढांचा का उपयोग कर रहे हैं जो आपके सभी प्रोटोटाइपों पर hasOwnProperty तो आपको 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; } 

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. 

सद्भाव ECMAScript 2015 (ES6) Object.assign निर्दिष्ट करती है। Object.assign जो यह करेंगे।

 Object.assign(obj1, obj2); 

वर्तमान ब्राउज़र समर्थन बेहतर हो रहा है , लेकिन यदि आप ऐसे ब्राउज़रों के लिए विकास कर रहे हैं जिनका समर्थन नहीं है, तो आप एक polyfill का उपयोग कर सकते हैं।

मैं ऑब्जेक्ट गुणों को मर्ज करने के लिए कोड के लिए googled और यहाँ समाप्त हुआ। हालांकि, जब से रिकर्सिव मर्ज के लिए कोई कोड नहीं था, मैंने इसे स्वयं लिखा था। (शायद 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); 

ऑब्जेक्ट ओ 3 की तरह पैदा करता है

 o3 = { a : 10, b : 2, c : { ca : 10, cb : 20, cc : { cca : 101, ccb : 202 } } }; 

ध्यान दें कि underscore.js का extend -मैप यह एक-लाइनर में करता है:

 _.extend({name : 'moe'}, {age : 50}); => {name : 'moe', age : 50} 

JQuery के विस्तार के समान (), आपके पास 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); 

मुझे आज ऑब्जेक्ट मर्ज करने की आवश्यकता है, और इस सवाल (और उत्तर) ने मुझे बहुत मदद की है मैंने कुछ उत्तरों की कोशिश की, लेकिन उनमें से कोई भी मेरी आवश्यकताओं को ठीक नहीं करता, इसलिए मैंने कुछ जवाब जोड़ दिए, स्वयं कुछ जोड़ा और एक नया मर्ज फ़ंक्शन के साथ आया यह रहा:

 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) लिए source.hasOwnProperty(property) loops में source.hasOwnProperty(property) को जांचने के लिए संशोधित किया जाना चाहिए – अन्यथा, आप पूरी प्रोटोटाइप श्रृंखला के गुणों को कॉपी करते हैं, जो कि शायद ही कभी वांछित है …

कोड की एक पंक्ति में एन ऑब्जेक्ट के गुणों को मिलाएं

एक Object.assign पद्धति ECMAScript 2015 (ES6) मानक का हिस्सा है और ठीक उसी प्रकार करती है जो आपको चाहिए। ( IE समर्थित नहीं है)

 var clone = Object.assign({}, obj); 

ऑब्जेक्ट। सिग्नेन () विधि का उपयोग एक या अधिक स्रोत ऑब्जेक्ट्स से एक लक्ष्य ऑब्जेक्ट के लिए सभी गणनायोग्य स्वयं गुणों के मूल्यों की प्रतिलिपि बनाने के लिए किया जाता है।

और पढो…

पॉलीफिल पुराने ब्राउज़रों का समर्थन करने के लिए:

 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; } }); } 

निम्नलिखित दो शायद एक अच्छा प्रारंभिक बिंदु है। उन विशेष जरूरतों के लिए भी रद्दीश का अनुकूलन कार्य है!

_.extend ( http://underscorejs.org/#extend )
_.merge ( https://lodash.com/docs#merge )

आप ऑब्जेक्ट स्प्रेड प्रॉपर्टी का इस्तेमाल कर सकते हैं- वर्तमान में एक चरण 3 ECMAScript प्रस्ताव।

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

बस वैसे, आप सभी क्या कर रहे हैं गुणों को अधिलेखित कर रहे हैं, विलय नहीं कर रहा है …

यह कैसे जावास्क्रिप्ट ऑब्जेक्ट्स क्षेत्र सचमुच विलीन हो गया है: ऑब्जेक्ट में केवल चाबियाँ जो ऑब्जेक्ट्स नहीं हैं, इन्हें ओवरराइट किया जाएगा। बाकी सब कुछ वास्तव में विलय हो जाएगा। बेशक, आप इस व्यवहार को किसी भी चीज़ को अधिलेखित नहीं करने के लिए बदल सकते हैं, जैसे कि 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) मानक का हिस्सा है। इस तकनीक के विनिर्देश को अंतिम रूप दिया गया है, लेकिन विभिन्न ब्राउज़रों में उपयोग और कार्यान्वयन स्थिति के लिए संगतता तालिका देखें।

ऑब्जेक्ट.सेंगीन () विधि का उपयोग एक या अधिक स्रोत ऑब्जेक्ट्स से एक लक्ष्य ऑब्जेक्ट के लिए सभी गणक के गुणों के मूल्यों की प्रतिलिपि बनाने के लिए किया जाता है। यह लक्ष्य वस्तु वापस करेगा।

 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. 

यहाँ मेरा चाकू है जो

  1. गहरा विलय का समर्थन करता है
  2. तर्कों को बदलना नहीं है
  3. तर्क के किसी भी संख्या लेता है
  4. ऑब्जेक्ट प्रोटोटाइप का विस्तार नहीं करता है
  5. किसी अन्य पुस्तकालय ( jQuery , मूटो , अंडर्सकोर.जेएस , आदि) पर निर्भर नहीं है
  6. हैओवनप्रॉपर्टी के लिए जांच शामिल है
  7. छोटा है 🙂

     /* Recursively merge properties and return new object obj1 &lt;- obj2 [ &lt;- ... ] */ 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 }; */ 

बिना-बहुत जटिल वस्तुओं के लिए आप 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_/ 

ध्यान दें कि इस उदाहरण में "} {" स्ट्रिंग के भीतर नहीं होना चाहिए !

आपके लिए ऐसा करने का सबसे अच्छा तरीका ऑब्जेक्ट का उपयोग करने वाली गैर-गणना योग्य संपत्ति को उचित संपत्ति जोड़ना है। DEFINEProperty

इस तरह से आप अब भी अपने ऑब्जेक्ट गुणों को फिर से तैयार कर पाएंगे बिना नए बनाए गए "विस्तार" किए बिना, अगर आप ऑब्जेक्ट के साथ संपत्ति बनाने के लिए प्राप्त करेंगे। प्रोटोपीपी।

उम्मीद है कि यह मदद करता है:

 Object.defineProperty (ऑब्जेक्ट। प्रोटोटीप, "विस्तार", {
     गणनायोग्य: गलत,
     मूल्य: कार्य (से) {
         var प्रोप्स = ऑब्जेक्ट .getOwnPropertyNames (से);
         var dest = यह;
         props.for प्रत्येक (समारोह (नाम) {
             अगर (dest में नाम) {
                 var गंतव्य = ऑब्जेक्ट .getOpenPropertyDescriptor (से, नाम);
                 ऑब्जेक्ट। डेफ़िनप्रॉपर्टी (गंतव्य, नाम, गंतव्य);
             }
         });
         इसे वापस;
     }
 });

एक बार काम करने के बाद, आप यह कर सकते हैं:

 var obj = {
     नाम: 'स्टैक',
     खत्म: 'अतिप्रवाह'
 }
 var प्रतिस्थापन = {
     नाम: 'स्टॉक'
 };

 obj.extend (प्रतिस्थापन);

मैंने इसके बारे में यहां एक ब्लॉग पोस्ट लिखा है: http://onemoredigit.com/post/1527191998/extending-objects-in-node-js

आप बस jQuery extend उपयोग कर सकते extend

 var obj1 = { val1: false, limit: 5, name: "foo" }; var obj2 = { val2: true, name: "bar" }; jQuery.extend(obj1, obj2); 

अब obj1 में obj1 और obj2 सभी मान हैं

सिर्फ अगर कोई Google क्लोजर लायब्रेरी का उपयोग कर रहा है:

 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' 

deepmerge पर deepmerge बुलाया गया एक पुस्तकालय है : ऐसा लगता है कि कुछ कर्षण मिल रहा है यह एक स्टैंडअलोन है, एनपीएम और बोवर पैकेज प्रबंधक दोनों के माध्यम से उपलब्ध है।

जवाबों से प्रतिलिपि चिपकाने के बजाय मैं इसका उपयोग या सुधारना चाहता हूं।

प्रोटोटाइप में यह है:

 Object.extend = function(destination,source) { for (var property in source) destination[property] = source[property]; return destination; } 

obj1.extend(obj2) जो आप चाहते हैं वह करेंगे।

मुटो टूल्स में , ऑब्जेक्ट है। मेर्ज () :

 Object.merge(obj1, obj2); 

मैंने डेविड कोएलियर की विधि विस्तारित की:

  • कई ऑब्जेक्ट मर्ज करने की संभावना जोड़ा गया
  • गहरी वस्तुओं का समर्थन करता है
  • ओवरराइड पैरामीटर (यह पता चला है कि अंतिम पैरामीटर बुलियन है)

यदि ओवरराइड झूठ है, तो कोई भी संपत्ति अधिलेखित नहीं हो जाती, लेकिन नई संपत्तियां जोड़ दी जाएंगी।

उपयोग: 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.bc = 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])); 

My equals method can be found here: Object comparison in JavaScript

In Ext JS 4 it can be done as follows:

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

See merge( object ) : Object .

With Underscore.js , to merge an array of objects do:

 var arrayOfObjects = [ {a:1}, {b:2, c:3}, {d:4} ]; _(arrayOfObjects).reduce(function(memo, o) { return _(memo).extend(o); }); 

It results in:

 Object {a: 1, b: 2, c: 3, d: 4} 

You should use lodash's defaultsDeep

 _.defaultsDeep({ 'user': { 'name': 'barney' } }, { 'user': { 'name': 'fred', 'age': 36 } }); // → { 'user': { 'name': 'barney', 'age': 36 } } 

It's worth mentioning that the version from the 140byt.es collection is solving the task within minimum space and is worth a try for this purpose:

कोड:

 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])} 

Usage for your purpose:

 m(obj1,obj2); 

Here's the original Gist .

Based on Markus' and vsync' answer , this is an expanded version. The function takes any number of arguments. It can be used to set properties on DOM nodes and makes deep copies of values. However, the first argument is given by reference.

To detect a DOM node, the isDOMNode() function is used (see Stack Overflow question JavaScript isDOM — How do you check if a JavaScript Object is a DOM Object? )

It was tested in Opera 11, Firefox 6, Internet Explorer 8 and 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; } 

कुछ उदाहरण

Set innerHTML and style of a HTML Element

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

Merge arrays and objects. Note that undefined can be used to preserv values in the lefthand array/object.

 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'} 

Any argument not beeing a JavaScript object (including null) will be ignored. Except for the first argument, also DOM nodes are discarded. Beware that ie strings, created like new String() are in fact objects.

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

If you want to merge two objects into a new (without affecting any of the two) supply {} as first argument

 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 

Edit (by ReaperSoon):

To also merge arrays

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

I use the following which is in pure JavaScript. It starts from the right-most argument and combines them all the way up to the first argument. There is no return value, only the first argument is modified and the left-most parameter (except the first one) has the highest weight on properties.

 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]; } } } }; 

My way:

 function mergeObjects(defaults, settings) { Object.keys(defaults).forEach(function(key_default) { if (typeof settings[key_default] == "undefined") { settings[key_default] = defaults[key_default]; } else if (isObject(defaults[key_default]) && isObject(settings[key_default])) { mergeObjects(defaults[key_default], settings[key_default]); } }); function isObject(object) { return Object.prototype.toString.call(object) === '[object Object]'; } return settings; } 

🙂

You can merge objects through following my method

 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 {}; }