From de5c456ebded0e038adbf23db34cc290c8829180 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:49:24 +0100 Subject: unslug pl: move --- .../global_objects/object/assign/index.html | 307 +++++++++++++++++++++ 1 file changed, 307 insertions(+) create mode 100644 files/pl/web/javascript/reference/global_objects/object/assign/index.html (limited to 'files/pl/web/javascript/reference/global_objects/object/assign/index.html') diff --git a/files/pl/web/javascript/reference/global_objects/object/assign/index.html b/files/pl/web/javascript/reference/global_objects/object/assign/index.html new file mode 100644 index 0000000000..81e764456a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/assign/index.html @@ -0,0 +1,307 @@ +--- +title: Object.assign() +slug: Web/JavaScript/Referencje/Obiekty/Object/assign +translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign +--- +
{{JSRef}}
+ +

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ć {{jsxref("Object.getOwnPropertyDescriptor()")}} oraz {{jsxref("Object.defineProperty()")}}.

+ +

Obie właściwości {{jsxref("String")}} jak i {{jsxref("Symbol")}} są kopiowane.

+ +

W przypadku błędu, na przykład gdy wartość jest zabezpieczona przed zapisem, zostanie rzucony błąd {{jsxref("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 {{jsxref("null")}} lub {{jsxref("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 {{Glossary("Polyfill","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

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES2015', '#sec-object.assign', 'Object.assign')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-object.assign', 'Object.assign')}}{{Spec2('ESDraft')}}
+ +

Kompatybilność z przeglądarką

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerEdgeOperaSafari
Basic support{{CompatChrome("45")}}{{CompatGeckoDesktop("34")}}{{CompatNo}}{{CompatVersionUnknown}}{{CompatOpera("32")}}{{CompatSafari("9")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatChrome("45")}}{{CompatGeckoMobile("34")}}{{CompatNo}}{{CompatNo}}{{CompatVersionUnknown}}
+
+ +

Zobacz również

+ + -- cgit v1.2.3-54-g00ecf