Object.assign()

Metoda Object.assign() kopiuje wszystkie wartości wyliczalnych własnych właściwości z jednego lub więcej obiektów źródłowych do obiektu docelowego. Zwraca obiekt docelowy.

Składnia

Object.assign(cel, ...zrodla)

Parameters

cel

Obiekt docelowy.

zrodla

Obiekt(y) żródłowe.

Zwracana wartość

Obiekt docelowy.

Opis

Właściwości w obiekcie docelowym zostaną nadpisane właściwościami obiektów źródłowych, jeśli właściwości te mają takie same nazwy. Właściwości obiektów źródłowych występujących później na liście argumentów, podobnie, nadpiszą właściwości obiektów występujących wcześniej.

Metoda Object.assign() jedynie kopiuje wyliczalne i własne właściwości z obiektów źródłowych do obiektu docelowego. Używa do tego [[Get]] na źródle oraz [[Set]] na obiekcie docelowym, więc wywołuje gettery i settery odpowiednich obiektów. Dlatego też mowa tu o przypisaniu właściwości, a nie o ich kopiowaniu czy tworzeniu nowych. Metoda ta może być więc nieodpowiednia do przyłączania nowych właściwości do prototypu, w przypadku gdy źródła przyłączenia zawierają gettery. Do kopiowania definicji właściwości, wliczając ich wyliczalność, do prototypów należy użyć Object.getOwnPropertyDescriptor() oraz Object.defineProperty().

Obie właściwości String jak i Symbol są kopiowane.

W przypadku błędu, na przykład gdy wartość jest zabezpieczona przed zapisem, zostanie rzucony błąd TypeError, a obiekt docelowy może zostać zmieniony, jeśli jakieś właściwości zostały do niego dodane przed wystąpieniem błędu.

Zauważ, że Object.assign() nie rzuci błędu, gdy źródłem jest null lub undefined.

Przykłady

Klonowanie obiektu

var obiekt = { a: 1 };
var kopia = Object.assign({}, obiekt);
console.log(kopia); // { a: 1 }

Ostrzeżenie przed Głębokim Klonowaniem

W przypadku głębokiego klonowania musimy użyć innych sposóbów, ponieważ Object.assign() kopiuje jedynie wartości przechowywane we właściwościach. Jeżeli właściwość źródłowa jest referencją do obiektu, to skopiowana zostanie jedynie ta referencja (wówczas zarówno źródło jak i cel będą posiadać referencję do tego samego obiektu, a nie osobne kopie tych obiektów).

function test() {
  'use strict';

  let obj1 = { a: 0 , b: { c: 0}};   // a: wartość, b: referencja, c: wartość
  let obj2 = Object.assign({}, obj1);
  console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}
  
  obj1.a = 1; // zmiana wartości, dotyczy tylko obj1
  console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}
  console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}
  
  obj2.a = 2; // zmiana wartości, dotyczy tylko obj2
  console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}
  console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 0}}
  
  obj2.b.c = 3; // zmiana wartości w obiekcie o współdzielonej referencji
  console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 3}} // teraz b.c == 3
  console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 3}} // i tu też b.c == 3, bo obj1.b === obj2.b
  
  // Klonowanie głębokie
  obj1 = { a: 0 , b: { c: 0}};
  let obj3 = JSON.parse(JSON.stringify(obj1));
  obj1.a = 4;
  obj1.b.c = 4;
  console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}} // obj1.b !== obj2.b
}

test();

Łączenie obiektów

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 }, sam obiekt docelowy został zmieniony.

Łączenie obiektów z tymi samymi właściowściami

var o1 = { a: 1, b: 1, c: 1 };
var o2 = { b: 2, c: 2 };
var o3 = { c: 3 };

var obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }

Właściwość jest nadpisywana przez ostatni obiekt w liście parametrów, który ma taką samą właściwość.

Kopiowanie właściwości-symboli

var o1 = { a: 1 };
var o2 = { [Symbol('foo')]: 2 };

var obj = Object.assign({}, o1, o2);
console.log(obj); // { a : 1, [Symbol("foo")]: 2 } (cf. bug 1207182 on Firefox)
Object.getOwnPropertySymbols(obj); // [Symbol(foo)]

Właściwości nieprzeliczalne oraz te z łańcucha prototypów nie są kopiowane

var obj = Object.create({ foo: 1 }, { // foo jest właściwością prototypu obiektu obj
  bar: {
    value: 2  // bar jest nieprzeliczalną właściwością
  },
  baz: {
    value: 3,
    enumerable: true  // baz jest własną, przeliczalną właściwością obiektu obj
  }
});

var kopia = Object.assign({}, obj);
console.log(kopia); // { baz: 3 }

Wartości podstawowe zostaną włożone do ich wrapperów

var v1 = 'abc';
var v2 = true;
var v3 = 10;
var v4 = Symbol('foo');

var obj = Object.assign({}, v1, null, v2, undefined, v3, v4); 
// Wartości podstawowe będą we wrapperach, null i undefined zostaną zignorowane.
// Zauważ, że jedynie wrapper string'a ma przeliczalne właściwości:
console.log(obj); // { "0": "a", "1": "b", "2": "c" }

Wyjątki przerwą wykonywanie kopiowania

var cel = Object.defineProperty({}, 'foo', {
  value: 1,
  writable: false
}); // cel.foo jest właściwością tylko do odczytu

Object.assign(cel, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 });
// TypeError: "foo" is read-only
// Wyjątek został wyrzucony podczas próby zapisania cel.foo

console.log(cel.bar);  // 2, pierwsze źródło zostało skopiowane pomyślnie
console.log(cel.foo2); // 3, pierwsza właściwość drugiego źródła zostało skopiowana pomyślnie
console.log(cel.foo);  // 1, tutaj został wyrzucony wyjątek
console.log(cel.foo3); // undefined, kopiowanie dobiegło końca, foo3 nie zostanie skopiowane
console.log(cel.baz);  // undefined, trzecie źródło również nie zostanie skopiowane

Kopiowanie operatorów pamięci

var obj = {
  foo: 1,
  get bar() {
    return 2;
  }
};

var kopia = Object.assign({}, obj); 
console.log(kopia); 
// { foo: 1, bar: 2 }, wartość kopia.bar jest wartością zwracaną przez metodę getter właściwości obj.bar

// Funkcja przypisania kopiująca całe deskryptory:
function completeAssign(cel, ...zrodla) {
  zrodla.forEach(zrodlo => {
    let deskryptory = Object.keys(zrodlo).reduce((deskryptory, klucz) => {
      deskryptory[klucz] = Object.getOwnPropertyDescriptor(zrodlo, klucz);
      return deskryptory;
    }, {});
    // domyślnie Object.assign kopiuje również przeliczalne symbole
    Object.getOwnPropertySymbols(zrodlo).forEach(sym => {
      let deskryptor = Object.getOwnPropertyDescriptor(zrodlo, sym);
      if (deskryptor.enumerable) {
        deskryptory[sym] = deskryptor;
      }
    });
    Object.defineProperties(cel, deskryptory);
  });
  return target;
}

var kopia = completeAssign({}, obj);
console.log(kopia);
// { foo:1, get bar() { return 2 } }

Polyfill

Ten polyfill nie wspiera właściwości-symboli, ponieważ ES5 i tak ich nie ma.

if (typeof Object.assign != 'function') {
  Object.assign = function(target, varArgs) { // .length of function is 2
    'use strict';
    if (target == null) { // TypeError if undefined or null
      throw new TypeError('Cannot convert undefined or null to object');
    }

    var to = Object(target);

    for (var index = 1; index < arguments.length; index++) {
      var nextSource = arguments[index];

      if (nextSource != null) { // Skip over if undefined or null
        for (var nextKey in nextSource) {
          // Avoid bugs when hasOwnProperty is shadowed
          if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
            to[nextKey] = nextSource[nextKey];
          }
        }
      }
    }
    return to;
  };
}

Specyfikacje

Kompatybilność z przeglądarką

Zobacz również

• Object.defineProperties()
• Przeliczalność i własność właściwości