ධාවන වේලාවේදී (ඉතා සරල) ජාවාස්ක්‍රිප්ට් වස්තු දෙකක් ඒකාබද්ධ කිරීමට මට හැකියාව තිබිය යුතුය. උදාහරණයක් ලෙස මම කැමතියි:

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 ප්‍රලේඛනය . ඔබ බාබෙල් භාවිතා කරන්නේ නම් ඔබට බාබල්-ප්ලගීන-ට්‍රාන්ස්ෆෝමර්-වස්තු-විවේකය අවශ්‍ය වේ ප්ලගිනය අවශ්‍ය වේ.

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

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.

මෙම එකමුතු සම්මතයන් 2015 (ES6) නිශ්චිතව දක්වා Object.assignමේ වනු ඇත.

Object.assign(obj1, obj2);

වත්මන් බ්‍රව්සර් සහාය හොඳ අතට හැරෙමින් පවතී , නමුත් ඔබ සහාය නොමැති බ්‍රව්සර් සඳහා සංවර්ධනය කරන්නේ නම්, ඔබට පොලිෆිල් එකක් භාවිතා කළ හැකිය .

වස්තු ගුණාංග ඒකාබද්ධ කිරීම සඳහා මම කේතයක් ලබාගෙන මෙහි අවසන් වීමි. කෙසේ වෙතත් පුනරාවර්තන ඒකාබද්ධ කිරීම සඳහා කේතයක් නොතිබූ බැවින් මම එය ලියා තැබුවෙමි. (සමහර විට 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 } } };

බව සටහන underscore.jsගේ extend-method එක් නෞකාවක් මෙම කරන්නේ:

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

ඔබට වස්තු පැතිරීමේ ගුණාංග භාවිතා කළ හැකිය - වර්තමානයේ අදියර 3 ECMAScript යෝජනාව.

const obj1 = { food: 'pizza', car: 'ford' };
const obj2 = { animal: 'dog' };

const obj3 = { ...obj1, ...obj2 };
console.log(obj3);

මෙම විසඳුම් ලබා පරීක්ෂා කිරීමට වෙනස් විය යුතුය source.hasOwnProperty(property)තුළ for..inපැවරීම පෙර වළළු - එසේ නැත්නම්, ඔබ කලාතුරකින් අපේක්ෂිත වන මුළු මූලාකෘති දාම, ගුණ පිටපත් අවසන් ...

කේතයේ එක් පේළියක N වස්තු වල ගුණාංග ඒකාබද්ධ කරන්න

ක Object.assignක්රමය සම්මතයන් 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;
    }
  });
}

පහත දැක්වෙන දෙක හොඳ ආරම්භක ලක්ෂ්‍යයක් විය හැකිය. එම විශේෂ අවශ්‍යතා සඳහා ලොඩාෂ් හි අභිරුචිකරණ ශ්‍රිතයක් ද ඇත!

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

මාර්ගය වන විට, ඔබ සියල්ලන්ම කරන්නේ දේපල නැවත ලිවීම මිස ඒකාබද්ධ කිරීම නොවේ ...

ජාවාස්ක්‍රිප්ට් වස්තු ප්‍රදේශය සැබවින්ම ඒකාබද්ධ වූයේ එලෙස ය: toවස්තූන් නොවන වස්තූන්ගේ යතුරු පමණක් නැවත ලියනු ලැබේ from. අනෙක් සියල්ල සැබවින්ම ඒකාබද්ධ වනු ඇත . ඇත්ත වශයෙන්ම ඔබට මෙම හැසිරීම වෙනස් කළ හැක්කේ එසේ නම් පමණක් පවතින කිසිවක් නැවත ලිවීමට නොවේ 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);

මෙන්න මගේ පිහිය

1. ගැඹුරු ඒකාබද්ධ කිරීම සඳහා සහය දක්වයි
2. තර්ක විකෘති නොකරයි
3. ඕනෑම තර්ක ගණනක් ගනී
4. වස්තු මූලාකෘතිය දිගු නොකරයි
5. වෙනත් පුස්තකාලයක් මත රඳා නොපවතී ( jQuery , MooTools , Underscore.js , ආදිය)
6. HasOwnProperty සඳහා චෙක්පත ඇතුළත් වේ

7. කෙටි වේ :)

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

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.

එතරම් සංකීර්ණ නොවන වස්තු සඳහා ඔබට 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_/

මෙම උදාහරණයේ දී "} {" නූලක් තුළ නොවිය යුතු බව මතක තබා ගන්න!

GitHub හි පුස්තකාලයක් deepmergeඇත : එය යම් කම්පනයකට ලක්වන බවක් පෙනේ. එය තනිවම, එන්පීඑම් දෙකම හරහා ලබා ගත හැකිය සහ බෝවර් පැකේජ කළමණාකරුවන් .

පිළිතුරු වලින් කේත පිටපත් කිරීම වෙනුවට මෙය භාවිතා කිරීමට හෝ වැඩිදියුණු කිරීමට මම නැඹුරු වෙමි.

මෙය කිරීමට ඔබට ඇති හොඳම ක්‍රමය නම් Object.defineProperty භාවිතා කර ගණනය කළ නොහැකි නිසි දේපලක් එක් කිරීමයි.

මේ ආකාරයට ඔබ Object.prototype.extend සමඟ දේපල නිර්මාණය කරන්නේ නම් ඔබට ලැබෙනු ඇති අලුතින් නිර්මාණය කරන ලද "විස්තාරණය" නොකර ඔබේ වස්තු ගුණාංග නැවත කියවීමට ඔබට හැකි වේ.

මෙය උපකාරී වේ යැයි බලාපොරොත්තු වෙමු:

Object.defineProperty (Object.prototype, "දිගු", {
    ගණන් කළ නොහැකි: අසත්‍ය,
    අගය: ශ්‍රිතය (සිට) {
        var props = Object.getOwnPropertyNames (වෙතින්);
        var dest = මෙය;
        props.forEach (ශ්‍රිතය (නම) {
            if (නමෙහි නම) {
                var destination = Object.getOwnPropertyDescriptor (සිට, නම);
                Object.defineProperty (dest, name, destination);
            }
        });
        මෙය ආපසු දෙන්න;
    }
});

ඔබට එය ක්‍රියාත්මක වූ පසු, ඔබට කළ හැක්කේ:

var obj = {
    නම: 'සිරස්',
    අවසන්: 'පිටාර ගැලීම'
}
var replace = {
    නම: 'තොගය'
};

obj.extend (ප්‍රතිස්ථාපනය);

මම මේ ගැන බ්ලොග් සටහනක් මෙහි ලියා ඇත: http://onemoredigit.com/post/1527191998/extending-objects-in-node-js

ඔබට සරලව jQuery භාවිතා කළ හැකිය extend

var obj1 = { val1: false, limit: 5, name: "foo" };
var obj2 = { val2: true, name: "bar" };

jQuery.extend(obj1, obj2);

දැන් obj1සියලු වටිනාකම් අඩංගු obj1හාobj2

මූලාකෘතියට මෙය තිබේ:

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

obj1.extend(obj2) ඔබට අවශ්‍ය දේ කරනු ඇත.

** වස්තු ඒකාබද්ධ කිරීම සරල Object.assignහෝ පැතිරීමේ ...ක්‍රියාකරු **

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

යමෙක් ගූගල් වැසීමේ පුස්තකාලය භාවිතා කරන්නේ නම් :

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'

මම ඩේවිඩ් කොලියර්ගේ ක්‍රමය දීර් extended කළෙමි:

• බහු වස්තු ඒකාබද්ධ කිරීමේ හැකියාව එකතු කරන ලදි
• ගැඹුරු වස්තූන් සඳහා සහාය වේ
• අභිබවා යන පරාමිතිය (අවසාන පරාමිතිය බූලියන් නම් එය අනාවරණය වේ)

අභිබවා යාම අසත්‍ය නම්, කිසිදු දේපලක් අභිබවා නොයන නමුත් නව දේපල එකතු වේ.

භාවිතය: 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]));

මගේ සමානාත්මතා ක්‍රමය මෙතැනින් සොයාගත හැකිය: ජාවාස්ක්‍රිප්ට් හි වස්තු සංසන්දනය

දී MooTools , තියෙනවා Object.merge () :

Object.merge(obj1, obj2);

දී දිගුව JS 4 එය පහත සඳහන් පරිදි සිදු කළ හැක:

var mergedObject = Ext.Object.merge(object1, object2)

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

ඒකාබද්ධ කිරීම (වස්තුව) බලන්න : වස්තුව .

වාව් .. මෙය මම පිටු කිහිපයකින් දුටු පළමු ස්ටැක් ඕවර්ෆ්ලෝ පෝස්ට් එකයි. තවත් "පිළිතුරක්" එකතු කිරීම ගැන සමාව ඉල්ලන්න

මෙම ක්රමය සඳහා වේ 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'}}

මෙම පිළිතුර දැන් සාගරයේ බින්දුවක් ...

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

මාකස්ගේ සහ vsync පිළිතුර මත පදනම්ව මෙය පුළුල් කළ අනුවාදයකි. ශ්‍රිතය ඕනෑම තර්ක ගණනක් ගනී. DOM හි ගුණාංග සැකසීමට එය භාවිතා කළ හැකිය නෝඩ් වල අතර අගයන්හි ගැඹුරු පිටපත් සාදයි. කෙසේ වෙතත්, පළමු තර්කය යොමු කිරීම මගින් දෙනු ලැබේ.

DOM නෝඩයක් හඳුනා ගැනීම සඳහා, isDOMNode () ශ්‍රිතය භාවිතා කරයි (Stack Overflow ප්‍රශ්නය බලන්න JavaScript isDOM - JavaScript වස්තුව DOM වස්තුවක් දැයි ඔබ පරීක්ෂා කරන්නේ කෙසේද? )

එය ඔපෙරා 11, ෆයර්ෆොක්ස් 6, ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 8 සහ ගූගල් ක්‍රෝම් 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;
}

උදාහරණ කිහිපයක්

HTML මූලද්‍රව්‍යයක අභ්‍යන්තර 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'}

ජාවාස්ක්‍රිප්ට් වස්තුවකට නොගැලපෙන ඕනෑම තර්කයක් (ශූන්‍යය ඇතුළුව) නොසලකා හරිනු ඇත. පළමු තර්කය හැරුණු විට DOM නෝඩ් ද ඉවතලනු ලැබේ. අළුත් නූල් () මෙන් නිර්මාණය කරන ලද නූල් ඇත්ත වශයෙන්ම වස්තූන් බව පරෙස්සම් වන්න.

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

ඔබට වස්තු දෙකක් නවයකට ඒකාබද්ධ කිරීමට අවශ්‍ය නම් (මේ දෙකෙන් එකකටවත් බලපෑමක් නොකර) පළමු තර්කය ලෙස supply} සැපයුම සපයන්න

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

ඔබ ලොඩාෂ් හි පෙරනිමි ඩීප් භාවිතා කළ යුතුය

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

Underscore.js සමඟ , වස්තු සමූහයක් ඒකාබද්ධ කිරීම සඳහා කරන්නේ:

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

එහි ප්‍රති results ලය:

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