JQuery ma również narzędzie do tego: http://api.jquery.com/jQuery.extend/.

Zaczerpnięte z dokumentacji 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" }

Powyższy kod zmutuje istniejący obiekt o nazwie settings.

Jeśli chcesz utworzyć nowy obiekt bez modyfikowania żadnego z argumentów, użyj tego:

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.

The Harmony ECMAScript 2015 (ES6) określa Object.assign co zrobi to.

Object.assign(obj1, obj2);

Aktualne wsparcie dla przeglądarki jest coraz lepsze , ale jeśli tworzysz dla przeglądarek, które nie mają wsparcia, możesz użyć polyfill .

Wygooglowałem kod do scalania właściwości obiektu i wylądowałem tutaj. Ponieważ jednak nie było kodu do rekurencyjnego scalania, sam go napisałem. (Może jQuery extend jest rekurencyjny BTW?) W każdym razie, mam nadzieję, że ktoś inny uzna to za przydatne, jak również.

(Teraz kod nie używa Object.prototype :)

Kod

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

Przykład

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

Tworzy obiekt O3 jak

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

Zauważ, że underscore.js's extend-metoda robi to w jednoliniowej:

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

Podobnie jak jQuery extend (), masz tę samą funkcję w 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);

Muszę dziś scalić obiekty i to pytanie (i odpowiedzi) Bardzo mi pomogło. Wypróbowałem niektóre odpowiedzi, ale żadna nie pasowała do moich potrzeb, więc połączyłem niektóre odpowiedzi, sam coś dodałem i wymyśliłem nową funkcję scalania. Tutaj jest:

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

Niektóre przykładowe zastosowania:

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

Możesz użyć właściwości rozprzestrzeniania obiektów - obecnie propozycja ECMAScript etapu 3.

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

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

Podane rozwiązania należy zmodyfikować tak, aby sprawdzały source.hasOwnProperty(property) w pętlach for..in przed przypisaniem - w przeciwnym razie kopiujemy właściwości całego łańcucha prototypów, co jest rzadko pożądane...

Scalanie właściwości N obiektów w jednej linii kodu

Metoda Object.assign jest częścią standardu ECMAScript 2015 (ES6) i robi dokładnie to, czego potrzebujesz. (IE nie obsługiwane)

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

Obiekt.metoda assign () służy do kopiowania wartości wszystkich wyliczalnych właściwości własnych z jednego lub więcej obiektów źródłowych do obiektu docelowego.

Czytaj więcej...

The polyfill do obsługi starszych przeglądarek:

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

Poniższe dwa są prawdopodobnie dobrym punktem wyjścia. lodash ma również funkcję dostosowywania dla tych specjalnych potrzeb!

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

Przy okazji, to co robicie to nadpisywanie właściwości, a nie scalanie...

W ten sposób obszar obiektów JavaScript naprawdę się połączył: tylko klucze w obiekcie to, które same nie są obiektami, zostaną nadpisane przez from. Wszystko inne będzie naprawdę połączone. Oczywiście można zmienić to zachowanie, aby nie nadpisywać niczego, co istnieje jak tylko to[n] is undefined, itp...:

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

Użycie:

var merged = realMerge(obj1, obj2);

Oto moje pchnięcie, które

1. Obsługuje deep merge
2. nie mutuje argumentów
3. pobiera dowolną liczbę argumentów
4. nie rozszerza prototypu obiektu
5. nie zależy od innej biblioteki (jQuery, MooTools, podkreślam.js , itp.)
6. Zawiera sprawdzenie hasOwnProperty

7. Jest krótki:)

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

Przykład:

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

Obiekt.Przypisz()

ECMAScript 2015 (ES6)

Jest to nowa technologia, część standardu ECMAScript 2015 (ES6). Specyfikacja tej technologii została sfinalizowana, ale sprawdź tabelę zgodności pod kątem użycia i statusu implementacji w różnych przeglądarkach.

Obiekt.metoda assign () służy do kopiowania wartości wszystkich wyliczalnych właściwości własnych z jednego lub więcej obiektów źródłowych do obiektu docelowego. Zwróci obiekt docelowy.

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.

Do niezbyt skomplikowanych obiektów można użyć 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_/

Pamiętaj, że w tym przykładzie "}{" nie może wystąpić w ciągu!

Najlepszym sposobem, aby to zrobić, jest dodanie odpowiedniej właściwości, której nie można wyliczyć za pomocą obiektu.defineProperty.

W ten sposób nadal będziesz mógł iterować nad właściwościami obiektów bez nowo utworzonego "rozszerzenia", które otrzymałbyś, gdyby utworzyć właściwość z obiektem.prototyp.rozszerz.

Mam nadzieję, że to pomoże:

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

Kiedy już to działa, możesz zrobić:

var obj = {
    name: 'stack',
    finish: 'overflow'
}
var replacement = {
    name: 'stock'
};

obj.extend(replacement);

Właśnie napisałem o tym blogu tutaj: http://onemoredigit.com/post/1527191998/extending-objects-in-node-js

Możesz po prostu użyć jQuery extend

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

jQuery.extend(obj1, obj2);

Teraz obj1 zawiera wszystkie wartości obj1 i obj2

Istnieje Biblioteka o nazwie deepmerge na GitHub : to wydaje się być coraz trakcja. Jest to samodzielny, dostępny zarówno za pośrednictwem npm, jak i menedżerów pakietów bower.

Byłbym skłonny użyć lub poprawić w tym celu zamiast kopiować-wklejać kod z odpowiedzi.

Jeśli ktoś używa biblioteki 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};

Podobna funkcja pomocnicza istnieje dla tablicy :

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'

Prototype ma to:

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

obj1.extend(obj2) zrobię, co zechcesz.

Rozszerzyłem metodę Davida Coalliera:

• Dodano możliwość scalania wielu obiektów
• Obsługuje Głębokie obiekty
• zastąp parametr (wykrywany, jeśli ostatni parametr jest logiczny)

Jeśli nadpisanie jest false, Żadna właściwość nie zostanie nadpisana, ale zostaną dodane nowe właściwości.

Użycie: obj.merge (merges... [, override]);

Oto Mój kod:

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

Przykłady i testy:

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

Moją metodę equals można znaleźć tutaj: porównanie obiektów w JavaScript

W MooTools znajduje się obiekt.merge():

Object.merge(obj1, obj2);

Łączenie obiektów jest proste.

var obj1 = { food: 'pizza', car: 'ford' }
var obj2 = { animal: 'dog', car: 'BMW' }
var obj3 = {a: "A"}


var mergedObj = Object.assign(obj1,obj2,obj3)

console.log(mergedObj);

Obiekty są scalane od prawej do lewej, co oznacza, że obiekty, które mają identyczne właściwości jak obiekty po prawej stronie, zostaną nadpisane.

W tym przykładzie obj2.car nadpisuje obj1.car

W Ext JS 4 można to zrobić w następujący sposób:

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

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

Zobacz merge ( obiekt): obiekt.

Z Podkreśleniem.js , aby scalić tablicę obiektów wykonaj:

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

Daje:

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

Na podstawieMarkus' iVsync' odpowiedzi , jest to wersja rozszerzona. Funkcja przyjmuje dowolną liczbę argumentów. Może być używany do ustawiania właściwości na węzłach DOM i tworzenia głębokich kopii wartości. Jednak pierwszy argument jest podany przez odniesienie.

Aby wykryć węzeł DOM, używana jest funkcja isDOMNode () (zobacz pytanie o przepełnienie stosuJavaScript isDOM-Jak sprawdzić, czy obiekt JavaScript jest obiektem DOM?)

Został przetestowany w Opera 11, Firefox 6, Internet Explorer 8 i Google Chrome 16.

Kod

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

Niektóre przykłady

Set innerHTML and style of a HTML Element

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

Scalanie tablic i obiektów. Zauważ, że undefined może być użyty do wartości preserv w tablicy/obiekcie lefthand.

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

Każdy argument nie będący obiektem JavaScript (włącznie z null) będzie ignorowany. Oprócz pierwszego argumentu, również węzły DOM są odrzucane. Strzeżcie się, że tj. łańcuchy, utworzone jak nowa metoda String (), są w rzeczywistości obiektami.

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

Jeśli chcesz połączyć dwa obiekty w Nowy (bez wpływu na żaden z nich) supply {} jako pierwszy 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):

Aby również scalać tablice

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

Powinieneś użyć lodash ' s defaultsDeep

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

Warto wspomnieć, że wersja z 140byt.es zbiór jest rozwiązaniem zadania w minimalnej przestrzeni i warto spróbować w tym celu:

Kod:

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

Użycie dla Twojego celu:

m(obj1,obj2);

Oto oryginalny Gist .

Używam następujących, które są w czystym JavaScript. Zaczyna się od najbardziej prawego argumentu i łączy je aż do pierwszego argumentu. Nie ma zwracanej wartości, modyfikowany jest tylko pierwszy argument i parametr lewy (poza pierwszym) ma największą wagę właściwości.

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

Wow.. jest to pierwszy post StackOverflow, który widziałem z wieloma stronami. Przepraszamy za dodanie kolejnej "odpowiedzi"

Ta metoda jest dla ES5 i wcześniej - istnieje wiele innych odpowiedzi dotyczących ES6.

Nie widziałem żadnego"głębokiego" scalania obiektów z wykorzystaniem arguments własność. Oto moja odpowiedź - compact & rekurencyjny , pozwalający na przekazywanie nieograniczonych argumentów obiektu:

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

Część komentowana wyjście jest opcjonalne .. po prostu pomija przekazane argumenty, które nie są obiektami (zapobieganie błędom).

Przykład:

extend({
    api: 1,
    params: {
        query: 'hello'
    }
}, {
    params: {
        query: 'there'
    }
});

// outputs {api: 1, params: {query: 'there'}}

Ta odpowiedź jest teraz tylko kroplą w oceanie ...