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 +++++++++++++++++++++ .../global_objects/object/constructor/index.html | 49 ++++ .../global_objects/object/freeze/index.html | 201 ++++++++++++++ .../object/getownpropertydescriptor/index.html | 121 ++++++++ .../object/hasownproperty/index.html | 150 ++++++++++ .../reference/global_objects/object/index.html | 212 ++++++++++++++ .../global_objects/object/proto/index.html | 193 +++++++++++++ .../global_objects/object/seal/index.html | 165 +++++++++++ .../object/tolocalestring/index.html | 35 +++ .../global_objects/object/tosource/index.html | 73 +++++ .../global_objects/object/tostring/index.html | 98 +++++++ .../global_objects/object/valueof/index.html | 63 +++++ 12 files changed, 1667 insertions(+) create mode 100644 files/pl/web/javascript/reference/global_objects/object/assign/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/constructor/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/freeze/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/hasownproperty/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/proto/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/seal/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/tolocalestring/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/tosource/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/tostring/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/object/valueof/index.html (limited to 'files/pl/web/javascript/reference/global_objects/object') 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ż

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/constructor/index.html b/files/pl/web/javascript/reference/global_objects/object/constructor/index.html new file mode 100644 index 0000000000..3de20f1350 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/constructor/index.html @@ -0,0 +1,49 @@ +--- +title: Object.prototype.constructor +slug: Web/JavaScript/Referencje/Obiekty/Object/constructor +tags: + - JavaScript + - Object + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Object/constructor +--- +

{{JSRef}}

+ +

Podsumowanie

+ +

Określa funkcję tworzącą prototyp obiektu. Należy pamiętać, że wartość tej własności jest referencją do funkcji, a nie łańcuchem znaków zawierającym jej nazwę.

+ +

Opis

+ +

Wszystkie obiekty dziedziczą własność constructor z ich prototypu (prototype):

+ +
var o = {};
+o.constructor === Object; // true
+
+var a = [];
+a.constructor === Array; // true
+
+var n = new Number(3);
+n.constructor === Number; // true
+
+ +

Przykłady

+ +

Przykład: Wyświetlanie konstruktora obiektu

+ +

Poniższy przykład tworzy prototyp, Drzewo i obiekt tego typu sosna. Następnie wyświetlana jest własność constructor obiektu Drzewo.

+ +
function Drzewo(nazwa) {
+   this.nazwa=nazwa;
+}
+
+sosna = new Drzewo("sosna");
+console.log("sosna.constructor to " + sosna.constructor)
+
+ +

Przykład ten wyświetla:

+ +
sosna.constructor to function Drzewo(nazwa) {
+   this.nazwa = nazwa;
+}
+
diff --git a/files/pl/web/javascript/reference/global_objects/object/freeze/index.html b/files/pl/web/javascript/reference/global_objects/object/freeze/index.html new file mode 100644 index 0000000000..73e0139f31 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/freeze/index.html @@ -0,0 +1,201 @@ +--- +title: Object.freeze() +slug: Web/JavaScript/Referencje/Obiekty/Object/freeze +translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze +--- +
{{JSRef}}
+ +
Metoda Object.freeze() "zamraża" obiekt, tzn. uniemożliwia dodawania nowych właściwości do obiektu; uniemożliwia usuwanie istniejących właściwości; uniemożliwia zmianę istniejących właściwości; oraz uniemożliwia zmianę prototypu obiektu. W efekcie obiekt jest naprawdę stały. Metoda zwraca obiekt w stanie "zamrożonym".
+ +
 
+ +

Składnia

+ +
Object.freeze(obj)
+ +

Argumenty

+ +
+
obj
+
Obiekt który ma zostać "zamrożony".
+
+ +

Zwracana wartość

+ +

"Zamrożony" obiekt.

+ +

Opis

+ +

Nic nie może zostać dodane ani usunięte z "zamrożonego" obiektu. Każda próba tego wywoła błąd, albo po cichu, albo rzucając wyjątek {{jsxref("TypeError")}}(zawzwyczaj, choć nie zawsze, w przypadku używania {{jsxref("Strict_mode", "strict mode", "", 1)}}).

+ +

Nie ma możliwości zmiany wartości właściwości obiektu. Metody dostępu (gettery i settery) działają bez zmian (sprawiają wrażenie skutecznej zmiany właściwości obiektu). Zwróć uwagę na to, że wartości, które są obiektami w dalszym ciągu mogą być modyfikowane, chyba że również są "zamrożone". Z uwagi na to, że Tablica (Array) jest obiektem, również może zostać zamrożona co uniemożliwi zmianę jej elementów, ich usuwanie oraz dodawanie nowych. 

+ +

Przykłady

+ +

 

+ +

Zamrażanie Obiektów

+ +

 

+ +
var obj = {
+  prop: function() {},
+  foo: 'bar'
+};
+
+// Nowe właściwości mogą być dodawane, istniejące mogą być zmieniane oraz usuwane
+obj.foo = 'baz';
+obj.lumpy = 'woof';
+delete obj.prop;
+
+// Zarówno obiekt przekazywany w funkcji freeze() jak i obiekt zwracany bedą "zamrożone"
+// Nie ma potrzeby przypisywania zwracanego obiektu do zmiennej jeśli chcemy tylko "zamrozić" obiekt przekazywany w funkcji
+var o = Object.freeze(obj);
+
+o === obj; // true
+Object.isFrozen(obj); // === true
+
+// Teraz wszelkie zmiany są niemożliwe
+obj.foo = 'quux'; // brak rezultatu nieskutkujący wyświetleniem błędu
+obj.quaxxor = 'the friendly duck'; // brak rezultatu nieskutkujący wyświetleniem błędu
+
+// przy strict mode tego typu próby spowodują wyświetlenie komunikatu o błędzie
+function fail(){
+  'use strict';
+  obj.foo = 'sparky'; // TypeError
+  delete obj.quaxxor; // TypeError
+  obj.sparky = 'arf'; // TypeError
+}
+
+fail();
+
+// Próby zmian poprzez Object.defineProperty spowodują wyświetlenie komunikatu o błędzie
+Object.defineProperty(obj, 'ohai', { value: 17 }); // TypeError
+Object.defineProperty(obj, 'foo', { value: 'eit' }); // TypeError
+
+// Niemożliwa jest również zmiana prototypu obiektu. Obie instrukcje poniżej wygenerują błąd
+Object.setPrototypeOf(obj, { x: 20})
+obj.__proto__ = { x: 20}
+
+ +

Zamrażanie Tablic (Array)

+ +

 

+ +
let a = [0];
+Object.freeze(a); // Tablica nie może być teraz modyfikowana
+
+a[0]=1; // brak rezultatu nieskutkujący wyświetleniem błędu
+a.push(2); // brak rezultatu nieskutkujący wyświetleniem błędu
+
+// przy strict mode tego typu próby spowodują wyświetlenie komunikatu o błędzie TypeErrors
+function fail() {
+  "use strict"
+  a[0] = 1;
+  a.push(2);
+}
+
+fail();
+ +

"Zamrożony" obiekt jest niemutowalny. Nie jest on jednak stałą. Obrazuje to poniższy przykład.

+ +
obj1 = {
+  internal: {}
+};
+
+Object.freeze(obj1);
+obj1.internal.a = 'aValue';
+
+obj1.internal.a // 'aValue'
+
+ +

 

+ +

To be a constant object, the entire reference graph (direct and indirect references to other objects) must reference only immutable frozen objects.  The object being frozen is said to be immutable because the entire object state (values and references to other objects) within the whole object is fixed.  Note that strings, numbers, and booleans are always immutable and that Functions and Arrays are objects. 

+ +

To make an object constant, recursively freeze each property which is of type object (deep freeze).  Use the pattern on a case-by-case basis based on your design when you know the object contains no cycles in the reference graph, otherwise an endless loop will be triggered.   An enhancement to deepFreeze() would be to have an internal function that receives a path (e.g. an Array) argument so you can supress calling deepFreeze() recursively when an object is in the process of being made constant.  You still run a risk of freezing an object that shouldn't be frozen, such as [window].

+ +
// To do so, we use this function.
+function deepFreeze(obj) {
+
+  // Retrieve the property names defined on obj
+  var propNames = Object.getOwnPropertyNames(obj);
+
+  // Freeze properties before freezing self
+  propNames.forEach(function(name) {
+    var prop = obj[name];
+
+    // Freeze prop if it is an object
+    if (typeof prop == 'object' && prop !== null)
+      deepFreeze(prop);
+  });
+
+  // Freeze self (no-op if already frozen)
+  return Object.freeze(obj);
+}
+
+obj2 = {
+  internal: {}
+};
+
+deepFreeze(obj2);
+obj2.internal.a = 'anotherValue';
+obj2.internal.a; // unde
+ +

 

+ +

 

+ +

Notes

+ +

In ES5, if the argument to this method is not an object (a primitive), then it will cause a {{jsxref("TypeError")}}. In ES2015, a non-object argument will be treated as if it were a frozen ordinary object, and be simply returned.

+ +
> Object.freeze(1)
+TypeError: 1 is not an object // ES5 code
+
+> Object.freeze(1)
+1                             // ES2015 code
+
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES5.1', '#sec-15.2.3.9', 'Object.freeze')}}{{Spec2('ES5.1')}}Initial definition. Implemented in JavaScript 1.8.5.
{{SpecName('ES2015', '#sec-object.freeze', 'Object.freeze')}}{{Spec2('ES2015')}} 
{{SpecName('ESDraft', '#sec-object.freeze', 'Object.freeze')}}{{Spec2('ESDraft')}} 
+ +

Browser compatibility

+ +
+

{{Compat("javascript.builtins.Object.freeze")}}

+
+ +

See also

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html b/files/pl/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html new file mode 100644 index 0000000000..3f9498b26e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html @@ -0,0 +1,121 @@ +--- +title: Object.getOwnPropertyDescriptor() +slug: Web/JavaScript/Referencje/Obiekty/Object/getOwnPropertyDescriptor +translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor +--- +
{{JSRef}}
+ +

Metoda Object.getOwnPropertyDescriptor() zwraca deskryptor definiujący stan właściwości (właściwość musi być zdefiniowana bezpośrednio na obiekcie, ponieważ metoda nie sprawdza właściwości w łańcuchu prototypów obiektu) dla podanego obiektu.

+ +

Składnia

+ +
Object.getOwnPropertyDescriptor(obj, prop)
+ +

Argumenty

+ +
+
obj
+
Obiekt, w którym będzie poszukiwana właściwość.
+
prop
+
Nazwa właściwości, dla której będzie pobrany deskryptor.
+
+ +

Wartość zwracana

+ +

Jeżeli obiekt posiada podaną właściwość, wówczas zostanie zwrócony jej deskryptor, w przeciwnym razie zostanie zwrócony {{jsxref("undefined")}}.

+ +

Opis

+ +

Metoda ta pozwala na dokładne zbadanie stanu właściwości. W rzeczywistości właściwość obiektu w JavaScript to nie tylko jej nazwa oraz wartość ale również odpowiadający jej deskryptor. Więcej informacji o atrybutach deskryptora można znaleźć w {{jsxref("Object.defineProperty()")}}.

+ +

Deskryptor właściwości jest obiektem zawierającym poniższe atrybuty:

+ +
+
value
+
Wartość związana z odpowiadającą właściwością (tylko dla deskryptorów danych).
+
writable
+
Jeżeli true odpowiadająca wartość właściwości może być zmieniona (tylko dla deskryptorów danych).
+
get
+
Funkcja, która zwraca getter dla odpowiadającej właściwości lub {{jsxref("undefined")}} jeżeli getter nie występuje (tylko dla deskryptorów dostępowych).
+
set
+
Funkcja, która zwraca setter dla odpowiadającej właściwości lub {{jsxref("undefined")}} jeżeli setter nie występuje (tylko dla deskryptorów dostępowych).
+
configurable
+
Jeżeli true odpowiadająca wartość właściwości może być zmieniona (również ich rodzaj - z właściwości danych na właściwość funkcji dostępowych, i odwrotnie) oraz usunięta z odopowiadającego obiektu.
+
enumerable
+
Jeżeli true odpowiadająca wartość właściwości będzie dostępna podczas iteracji po właściwosciach odpowiadającego obiektu.
+
+ +

Przykłady

+ +
var o, d;
+
+o = { get foo() { return 17; } };
+d = Object.getOwnPropertyDescriptor(o, 'foo');
+// d is { configurable: true, enumerable: true, get: /*the getter function*/, set: undefined }
+
+o = { bar: 42 };
+d = Object.getOwnPropertyDescriptor(o, 'bar');
+// d is { configurable: true, enumerable: true, value: 42, writable: true }
+
+o = {};
+Object.defineProperty(o, 'baz', { value: 8675309, writable: false, enumerable: false });
+d = Object.getOwnPropertyDescriptor(o, 'baz');
+// d is { value: 8675309, writable: false, enumerable: false, configurable: false }
+
+ +

Uwagi

+ +

W ES5, jeżeli pierwszy argument dla podanej metody nie jest obiektem (jest typem prostym), wówczas zostanie wyrzucony wyjątek {{jsxref("TypeError")}}. Natomiast w ES2015, na typie prymitywnym najpierw zostanie wykonana koercja do obiektu.

+ +
Object.getOwnPropertyDescriptor('foo', 0);
+// TypeError: "foo" is not an object  // ES5 code
+
+Object.getOwnPropertyDescriptor('foo', 0);
+// {configurable:false, enumerable:true, value:"f", writable:false}  // ES2015 code
+
+ +

Specyfikacje

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES5.1', '#sec-15.2.3.3', 'Object.getOwnPropertyDescriptor')}}{{Spec2('ES5.1')}}Initial definition. Implemented in JavaScript 1.8.5.
{{SpecName('ES6', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}{{Spec2('ESDraft')}} 
+ +

Kompatybilność przeglądarkowa

+ +
+
+ + +

{{Compat("javascript.builtins.Object.getOwnPropertyDescriptor")}}

+
+
+ +

 

+ +

Zobacz również

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/hasownproperty/index.html b/files/pl/web/javascript/reference/global_objects/object/hasownproperty/index.html new file mode 100644 index 0000000000..42bb16783b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/hasownproperty/index.html @@ -0,0 +1,150 @@ +--- +title: Object.prototype.hasOwnProperty() +slug: Web/JavaScript/Referencje/Obiekty/Object/hasOwnProperty +translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty +--- +
{{JSRef("Global_Objects", "Object")}}
+ +

Wstęp

+ +

Metoda hasOwnProperty() zwraca wartość true jeśli obiekt, na którym została wywołana posiada konkretną własność.

+ +

Składnia

+ +
obj.hasOwnProperty(prop)
+ +

Parametry

+ +
+
prop
+
Nazwa ({{jsxref("String")}}) własności lub Symbol, do sprawdzenia.
+
+ +

Wartość zwracana

+ +

A {{jsxref ("Boolean")}} wskazujący, czy obiekt zawiera w sobie określoną właściwość.

+ +

Opis

+ +

Każdy obiekt pochodzący od {{jsxref("Global_Objects/Object", "Object")}} dziedziczy metodę hasOwnProperty. Może być ona użyta do stwierdzenia czy obiekt posiada określoną własność, jako bezpośrednią (direct) własność. W przeciwieństwie do  operatora {{jsxref("Operators/in", "in")}}, metoda hasOwnProperty nie sprawdza w głąb łańcucha własności obiektu.

+ +

Notatka

+ +

hasOwnProperty zwraca true, nawet jeśli wartość właściwości to null lub undefined.

+ +
o = new Object();
+o.propOne = null;
+o.hasOwnProperty('propOne');   // zwraca true
+o.propTwo = undefined;
+o.hasOwnProperty('propTwo');   // zwraca true
+
+ +

Przykłady

+ +

Użycie hasOwnProperty do testowania istnienia własności

+ +

Poniższy przykład określa czy obiekt o posiada własność o nazwie prop:

+ +
o = new Object();
+o.hasOwnProperty('prop');   // zwraca false
+o.prop = 'istnieje';
+o.hasOwnProperty('prop');   // zwraca true
+ +

Własności bezpośrednie kontra odziedziczone

+ +

Poniższy przykład rozróżnia bezpośrednie właściwości z właściwościami dziedziczonymi w łańcuchu prototypów:

+ +
o = new Object();
+o.prop = 'istnieje';
+o.hasOwnProperty('prop');             // zwraca true
+o.hasOwnProperty('toString');         // zwraca false
+o.hasOwnProperty('hasOwnProperty');   // zwraca false
+
+ +

Iterowanie przez właściwości obiektu

+ +

Poniższy przykład ilustruje sposób iteracji po właściwościach obiektu bez wykonywania iteracji na dziedziczonych właściwościach.

+ +
const obj = {
+  prop: 'Wartość',
+  secondProp: 'Wartość 2'
+}
+
+for (const name in obj) {
+  if (obj.hasOwnProperty(name)) {
+    console.log('Znaleziono własność ' + name + ' o wartości ' + obj[name])
+  } else {
+    console.log('Brak własności: ', name)
+  }
+}
+ +
+

Zwróć uwagę, że pętla {{jsxref("Statements/for...in", "for...in")}} tylko iteruje właściwości przeliczalne, a nieprzeliczanych nie zauważa.

+
+ +

Używanie hasOwnProperty jako nazwy właściwości

+ +

JavaScript nie chroni nazwy właściwości hasOwnProperty; tak więc, jeśli istnieje możliwość, że obiekt może mieć właściwość o tej nazwie, konieczne jest użycie zewnętrznej właściwości hasOwnProperty, aby uzyskać poprawne wyniki:

+ +
const obj = {
+  hasOwnProperty: function() {
+    return false;
+  },
+  prop: 'Kolejna właściwość'
+};
+
+obj.hasOwnProperty('prop'); // zawsze zwróci false
+
+// Użyj właściwości hasOwnProperty innego obiektu i wywołaj ją, ustawiając "this" na obj
+({}).hasOwnProperty.call(obj, 'prop'); // zwraca true
+
+// W tym celu można również użyć własności hasOwnProperty z prototypu Object
+Object.prototype.hasOwnProperty.call(obj, 'prop'); // zwraca true
+
+ +

Zwróć uwagę, że w ostatnim przypadku nie ma żadnych nowo utworzonych obiektów.

+ +

Specyfikacja

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
ECMAScript 3rd Edition.StandardInitial definition. Implemented in JavaScript 1.5.
{{SpecName('ES5.1', '#sec-15.2.4.5', 'Object.prototype.hasOwnProperty')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}}{{Spec2('ES6')}}
+ +

Wsparcie przeglądarek

+ + + +
{{Compat("javascript.builtins.Object.hasOwnProperty")}}
+ +

Zobacz także

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/index.html b/files/pl/web/javascript/reference/global_objects/object/index.html new file mode 100644 index 0000000000..88ed5060cb --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/index.html @@ -0,0 +1,212 @@ +--- +title: Object +slug: Web/JavaScript/Referencje/Obiekty/Object +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Object +--- +
{{JSRef}}
+ +

Konstruktor Object tworzy wrapper obiektu.

+ +

Składnia

+ +
// Notacja literałowa
+{ [ paraWartoscNazwa1[, paraWartoscNazwa2[, ...paraWartoscNazwaN] ] ] }
+
+// Wywoływany jako konstruktor
+new Object([wartosc])
+ +

Parametry

+ +
+
paraWartoscNazwa1, paraWartoscNazwa2, ... paraWartoscNazwaN
+
Pary nazw (string) oraz wartości (jakakolwiek wartość) przyczym nazwa oddzielona jest od wartości dwukropkiem.
+
wartosc
+
Jakakolwiek wartość.
+
+ +

Opis

+ +

Kostruktor obiektu tworzy wrapper dla danej wartości. Jeżeli podana wartość to {{jsxref("null")}} albo {{jsxref("undefined")}}, konstruktor stworzy i zwróci pusty obiekt. W przeciwnym razie stworzy i zwróci obiekt o takim samym typie jak podana wartość. Jeżeli podana wartość jest obiektem to konstruktor zwróci ten właśnie obiekt.

+ +

Zobacz również Inicjator obiektu / notacja literałowa.

+ +

Właściwości

+ +
+
Object.length
+
Przyjmuje wartość 1.
+
{{jsxref("Object.prototype")}}
+
Pozwala na dodawanie właściwości i metod do wszystkich obiektów typu Object.
+
+ +

Metody

+ +
+
{{jsxref("Object.assign()")}}
+
Kopiuje wszystkie własne właściwości z jednego lub więcej obiektów żródłowych do obiektu docelowego.
+
{{jsxref("Object.create()")}}
+
Tworzy nowy obiekt z podanym prototypem oraz właściwościami
+
{{jsxref("Object.defineProperty()")}}
+
Dodaje do obiektu wymienioną właściwość opisywaną przez podany deskryptor.
+
{{jsxref("Object.defineProperties()")}}
+
Dodaje do obiektu wymienione właściwości opisywane przez podane deskryptory.
+
{{jsxref("Object.freeze()")}}
+
Zamraża obiekt. Uniemożliwia usuwanie oraz modyfikowanie jego właściwości.
+
{{jsxref("Object.getOwnPropertyDescriptor()")}}
+
Zwraca z obiektu deskryptor dla wymienionej właściwości. 
+
{{jsxref("Object.getOwnPropertyNames()")}}
+
Zwraca tablicę zawierającą nazwy wszystkich własnych właściwości obiektu. (Zarówno przeliczalnych jak i nieprzeliczalnych)
+
{{jsxref("Object.getOwnPropertySymbols()")}}
+
Zwraca tablicę zawierającą wszystkie własne właściwości-symbole danego obiektu
+
{{jsxref("Object.getPrototypeOf()")}}
+
Zwraca prototyp określonego obiektu.
+
{{jsxref("Object.is()")}}
+
Sprawdza czy dwie podane wartości są takie same.
+
{{jsxref("Object.isExtensible()")}}
+
Sprawdza czy obiekt można rozszerzyć.
+
{{jsxref("Object.isFrozen()")}}
+
Sprawdza czy obiekt jest zamrożony.
+
{{jsxref("Object.isSealed()")}}
+
Sprawdza czy obiekt jest zapieczętowany.
+
{{jsxref("Object.keys()")}}
+
Zwraca tablicę zawierającą nazwy wszystkich własnych właściwości obiektu. (Tylko przeliczalnych)
+
{{jsxref("Object.preventExtensions()")}}
+
Zabopiega rozszerzaniu obiektu (tj. dodawaniu właściwości).
+
{{jsxref("Object.seal()")}}
+
Zapieczętowuje obiekt, zapobiegając dodawaniu oraz usuwaniu jego właściwości.
+
{{jsxref("Object.setPrototypeOf()")}}
+
Ustawia prototyp obiektu.
+
{{jsxref("Object.values()")}} {{experimental_inline}}
+
Zwraca tablicę zawierającą wszystkie własne, przeliczalne wartości obiektu.
+
+ +

Instancje i prototyp Object

+ +

W Javascript, wsyzstkie obiekty pochodzą od obiektu Object, tymsamym dziedziczą metody i właściwości z {{jsxref("Object.prototype")}}, jednak mogą być one nadpisane. Na przykład, prototypy innych konstruktorów nadpisują właściwość constructor oraz metody toString(). Wszelkie zmiany w prototypie Object są przekazywane do wszystkich obiektów, chyba że właściwości lub metody do których zmiany się odnośiły zostały gdzieś po drodze nadpisane.

+ +

Właściwości

+ +
{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Object/prototype', 'W.C5.82asno.C5.9Bci') }}
+ +

Metody

+ +
{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Object/prototype', 'Metody') }}
+ +

Przykłady

+ +

Używanie typów null i undefined

+ +

W poniższych przykładach zmienna o przechowuje pusty obiekt Object:

+ +
var o = new Object();
+
+ +
var o = new Object(undefined);
+
+ +
var o = new Object(null);
+
+ +

Tworzenie obiektu Boolean

+ +

W poniższych przykładach zmienna o przechowuje obiekty {{jsxref("Boolean")}}:

+ +
// równoznaczne z: o = new Boolean(true);
+var o = new Object(true);
+
+ +
// równoznaczne z: o = new Boolean(false);
+var o = new Object(Boolean());
+
+ +

Specyfikacje

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Początkowa definicja. Zaimplementowana w JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.2', 'Object')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-object-objects', 'Object')}}{{Spec2('ES6')}}Dodano Object.assign, Object.getOwnPropertySymbols, Object.setPrototypeOf, Object.is
{{SpecName('ESDraft', '#sec-object-objects', 'Object')}}{{Spec2('ESDraft')}}Dodano Object.entries, Object.values oraz Object.getOwnPropertyDescriptors.
+ +

Kompatybilność z przeglądarką

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Zobacz także

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/proto/index.html b/files/pl/web/javascript/reference/global_objects/object/proto/index.html new file mode 100644 index 0000000000..6d4dd4653e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/proto/index.html @@ -0,0 +1,193 @@ +--- +title: Object.prototype.__proto__ +slug: Web/JavaScript/Referencje/Obiekty/Object/proto +translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto +--- +
+

Ostrzeżenie: Zmiana [[Prototype]] obiektu, ze względu na sposób w jaki współczesny JavaScript optymalizuje dostęp do właściwości, jest bardzo powolną operacją (W każdej przeglądarce!). Efekty modyfikacji łańcucha dziedziczenia są rozległe, nie chodzi tu tylko o wydłużenie czasu potrzebnego na wykonanie operacji obj.__proto__ = ..., skutki wpływają na każdy fragment kodu który odwołuje się do jakiejkolwiek właściwości obiektu, którego [[Prototype]] został zmieniony. Dlatego jeżeli zależy ci na wydajności powinieneś unikać tej operacji. Zamiast tego, stwórz nowy obiekt z porządanym [[Prototype]] za pomocą {{jsxref("Object.create()")}}.

+
+ +
+

Ostrzeżenie: Mimo że w dzisiejszych czasach Object.prototype.__proto__ jest wspierany w niemal każdej przeglądarce, jego istnienie oraz zachowanie zostały ujednolicone w specyfikacji ECMAScript 2015 jedynie jako legacy feature aby zapewnić kompatybilność z przeglądarkami. Dla lepszego wsparcia rekomenduje się używanie {{jsxref("Object.getPrototypeOf()")}}.

+
+ +
{{JSRef}}
+ +

Właściwość __proto__ obiektu {{jsxref("Object.prototype")}} jest operatorem dostępu (metoda getter i setter) która operuje na wewnętrznym [[Prototype]] (na obiekcie lub na {{jsxref("Global_Objects/null", "null")}}) obiektu do którego się odnosi.

+ +

Użycie __proto__ jest kontrowersyjne i podchodzi się do niego z niechęcią. Oryginalnie nigdy nie pojawiło się w specyfikacji EcmaScript, ale nowoczesne przeglądarki postanowiły mimo wszystko to zaimplementować. Dopiero niedawno właściwość __proto__ znalazła swoje miejsce w specyfikacji ECMAScript 2015 aby zapewnić kompatybilność z tymi przeglądarkami. Jest ona jednak przestarzała ze względu na {{jsxref("Object.getPrototypeOf")}}/{{jsxref("Reflect.getPrototypeOf")}} oraz {{jsxref("Object.setPrototypeOf")}}/{{jsxref("Reflect.setPrototypeOf")}} (choć modyfikowanie [[Prototype]] wciąż jest operacją powolną, która powinna być unikana przez wzgląd na wydajność).

+ +

Właściwość __proto__ może być również używana w notacji literałowej aby ustawić [[Prototype]] tworzonego obiektu, jako alterantywa do {{jsxref("Object.create()")}}. Zobacz: inicjalizator obiektu / notacja literałowa.

+ +

Składnia

+ +
var Kolo = function () {};
+var ksztalt = {};
+var kolo = new Kolo();
+
+// Ustawianie prototypu obiektu
+// ZDEPRECJONOWANE. Używamy tego tylko dla przykładu. NIE RÓB TEGO w prawdziwym kodzie.
+ksztalt.__proto__ = kolo;
+
+// Sprawdzenie prototypu obiektu
+console.log(ksztalt.__proto__ === kolo); // true
+
+ +
var ksztalt = function () {};
+var p =
+{
+    a: function ()
+    {
+        console.log('aaa');
+    }
+};
+ksztalt.prototype.__proto__ = p;
+
+var kolo = new ksztalt();
+kolo.a(); // aaa
+
+console.log(ksztalt.prototype === kolo.__proto__); // true
+
+// albo
+
+var ksztalt = function () {};
+var p =
+{
+    a: function ()
+    {
+        console.log('aaa');
+    }
+};
+
+var kolo = new ksztalt();
+kolo.__proto__ = p;
+circle.a(); // aaa
+
+console.log(ksztalt.prototype === kolo.__proto__); // false
+
+// albo
+
+function ksztalt() {};
+ksztalt.prototype.a = function ()
+{
+    console.log('aaa');
+}
+var kolo = new ksztalt();
+kolo.a(); // aaa
+
+console.log(kolo.__proto__ === ksztalt.prototype); // true
+
+// albo
+
+var ksztalt = function () {};
+ksztalt.prototype.a = function ()
+{
+    console.log('aaa');
+}
+
+var kolo =
+{
+    __proto__: ksztalt.prototype
+};
+kolo.a(); // aaa
+
+console.log(kolo.__proto__ === ksztalt.prototype); // true
+
+ +

Uwaga: __proto__ zapisujemy jako dwie podłogi, następnie pięć liter "proto", następnie dwie kolejne podłogi.

+ +

Opis

+ +

Metoda getter właściwości __proto__ daje nam dostęp do wewnętrznej wartości [[Prototype]] obiektu. Dla obiektów stworzonych przy użyciu literału jest to {{jsxref("Object.prototype")}}. Dla tablic stworzonych przy użyciu literału jest to {{jsxref("Array.prototype")}}. Dla funkcji ta wartość to {{jsxref("Function.prototype")}}. Dla obiektów stworzonych przy użyciu new Funkcja, gdzie Funkcja to jeden z wbudowanych konstruktorów dostarczanych przez JavaScript ({{jsxref("Array")}}, {{jsxref("Boolean")}}, {{jsxref("Date")}}, {{jsxref("Number")}}, {{jsxref("Object")}}, {{jsxref("String")}}, i tak dalej — wliczając nowe konstrukotry, które mogą zostać dodane w przyszłości), ta wartość to zawsze Funkcja.prototype. Dla obiektów stworzonych przy użyciu new Funkcja, gdzie Funkcja to funkcja zdefiniowana w kodzie, wartość ta przyjmuje taką samą wartość jak Funkcja.prototype.

+ +

Metoda setter właściwości __proto__ umożliwia modyfikowanie [[Prototype]] obiektu. W tym celu obiekt musi być roszerzalny według funkcji {{jsxref("Object.isExtensible()")}}, jeżeli nie jest {{jsxref("Global_Objects/TypeError", "TypeError")}} zostanie wyrzucony. Dostarczana wartość musi być obiektem albo typem {{jsxref("Global_Objects/null", "null")}}. Podanie jakiejkolwiek innej wartości nie zrobi nic.

+ +

Aby zrozumieć w jaki sposób prototypy używane są do dziedziczenia, zobacz artykuł o dziedziczeniu oraz łańcuchu prototypów.

+ +

Właściwość __proto__ jest prostym operatorem pamięci na {{jsxref("Object.prototype")}} składającym się z metody getter i setter. Dostęp do właściwości __proto__ który ostatecznie konsultuje się z {{jsxref("Object.prototype")}} znajdzie tę właściwość, ale dostęp który nie konsultuje {{jsxref("Object.prototype")}} nie znajdzie jej. Jeżeli jakaś inna właściwość __proto__ zostanie znaleziona, zanim {{jsxref("Object.prototype")}} zostanie skonsultowany, to właściwość ta przesłoni tą znalezioną w {{jsxref("Object.prototype")}}.

+ +

Specyfikacje

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES2015', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}{{Spec2('ES2015')}}Dołączony (normatywnie) jako jeden z dodatkowych ECMAScript legacy features dla przeglądarek (zauważ że specyfikacja jedynie ujednoliciła coś, co było już zaimplementowane w przeglądarkach).
{{SpecName('ESDraft', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}{{Spec2('ESDraft')}} 
+ +

Kompatybilność z przeglądarką

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatIE("11")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Uwagi odnośnie kompatybilności

+ +

Mimo, że specyfikacja ECMAScript 2015 określa iż wsparcie dla __proto__ jest wymagane tylko dla przeglądarek internetowych (w zasadzie normatywnie), to inne środowiska równieź mogą wspierać tę funkcjonalność.

+ +

Zobacz również

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/seal/index.html b/files/pl/web/javascript/reference/global_objects/object/seal/index.html new file mode 100644 index 0000000000..ba52ba9665 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/seal/index.html @@ -0,0 +1,165 @@ +--- +title: Object.seal() +slug: Web/JavaScript/Referencje/Obiekty/Object/seal +translation_of: Web/JavaScript/Reference/Global_Objects/Object/seal +--- +
{{JSRef}}
+ +

Metoda Object.seal() "uszczelnia" obiekt, zabezpieczając przed dodaniem nowych właściwości oraz czyniąc wszystkie już istniejące jako niekonfigurowalne. Wartość znajdujące się już w obiekcie mogą być cały czas zmieniane tak długo dopóki posiadają atrybut writable.

+ +

Składnia

+ +
Object.seal(obj)
+ +

Parametry

+ +
+
obj
+
Obiekt który powinien zostać zamknięty.
+
+ +

Zwracana wartość

+ +

Uszczelniony obiekt.

+ +

Opis

+ +

Standardowo obiekty są {{jsxref("Object.isExtensible()", "extensible", "", 1)}} (nowe właściwości mogą być do nich dodawane). Zamknięcie obiektu zabezpiecza przed możliwością ich dodawania oraz oznacza wszystkie już obecne jako niekonfigurowalne. To skutkuje tym, że zestaw właściwości obiektu staje się niemutowalny. Sprawienie, że wszystkie właściwości są również niekonfigurowalne  zabezpiecza je przed byciem przekonwertowane na akcesory/mutatory i odwrotnie, jednak nie zapobiega to zmianie wartości. Próba usunięcia lub dodania nowych właściwości do uszczelnionego obiektu lub konwersja jakiejś właściwości do akcesorów/mutatorów zawiedzie bez wyjątku lub wywołując {{jsxref("TypeError")}} (tak jest najczęściej, choć nie całkowicie, kiedy skrypt jest w {{jsxref("Strict_mode", "strict mode", "", 1)}}).

+ +

Łancuch prototypów pozostaje nie zmieniony, jednakże właściwość {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}} jest również niemożliwa do zmiany.

+ +

Examples

+ +
var obj = {
+  prop: function() {},
+  foo: 'bar'
+};
+
+// Nowe właściwości mogą być dodane,
+// istniejące - zmienione lub usunięte.
+obj.foo = 'baz';
+obj.lumpy = 'woof';
+delete obj.prop;
+
+var o = Object.seal(obj);
+
+o === obj; // true
+Object.isSealed(obj); // === true
+
+// Zmiana wartości na zamkniętym obiekcie nadal działa.
+obj.foo = 'quux';
+
+// Jednak nie możesz zmienić właściwości obieku do akcesorów i odwrotnie
+Object.defineProperty(obj, 'foo', { get: function() { return 'g'; } }); // throws a TypeError
+
+// W tym momencie jakiekolwiek inne zmiany właściwości obiektu zawiodą
+obj.quaxxor = 'the friendly duck'; // nie doda właściwości, nie rzucając wyjątku
+delete obj.foo; // nie usunie właściwości, nie rzucając wyjątku
+
+// ...w trybie strict takie operacje będą rzucać wyjątkami.
+function fail() {
+  'use strict';
+  delete obj.foo; // rzuca TypeError
+  obj.sparky = 'arf'; // rzuca TypeError
+}
+fail();
+
+// Próba dodania właściwości przez Object.defineProperty zawiedzie
+Object.defineProperty(obj, 'ohai', { value: 17 }); // rzuca TypeError
+Object.defineProperty(obj, 'foo', { value: 'eit' }); // zmienia istniejącą wartość
+
+ +

Uwagi

+ +

W ES5, jeżeli argumentem metody nie jest obiekt (jest to prymitywna struktura), spowoduje to wywołanie {{jsxref("TypeError")}}. W ES6, argument nie będący obiektem zostanie potraktowany jakby już był uszczelnionym, zwykłym obiektem i będzie zwrócony.

+ +
Object.seal(1);
+// TypeError: 1 is not an object (ES5 code)
+
+Object.seal(1);
+// 1                             (ES6 code)
+
+ +

Specyfikacja

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES5.1', '#sec-15.2.3.8', 'Object.seal')}}{{Spec2('ES5.1')}}Wstępna definicja. Implementowano w  JavaScript 1.8.5.
{{SpecName('ES6', '#sec-object.seal', 'Object.seal')}}{{Spec2('ES6')}} 
+ +

Kompatybilność w przeglądarkach

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome("6")}}{{CompatGeckoDesktop("2.0")}}{{CompatIE("9")}}{{CompatOpera("12")}}{{CompatSafari("5.1")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Zobacz również

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/tolocalestring/index.html b/files/pl/web/javascript/reference/global_objects/object/tolocalestring/index.html new file mode 100644 index 0000000000..1cd0074d45 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/tolocalestring/index.html @@ -0,0 +1,35 @@ +--- +title: Object.prototype.toLocaleString() +slug: Web/JavaScript/Referencje/Obiekty/Object/toLocaleString +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString +--- +

{{JSRef}}

+ +

Podsumowanie

+ +

Zwraca łańcuch znaków reprezentujący obiekt. Ta metoda najczęściej jest przysłonięta przez pochodne obiekty.

+ +

Składnia

+ +
obj.toLocaleString();
+ +

Parametry

+ +

Brak.

+ +

Opis

+ +

Object toLocaleString zwraca rezultat, który nazywamy {{jsxref("Object.toString", "toString()")}}.

+ +

Ta metoda jest dostarczona dając obiektom generującą metodę toLocaleString(), nawet mimo to nie wszystkie go używają. Aktualnie, tylko Array, Number i Date nadpisują toLocaleString.

+ +

Zobacz także

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/tosource/index.html b/files/pl/web/javascript/reference/global_objects/object/tosource/index.html new file mode 100644 index 0000000000..4aa67db90c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/tosource/index.html @@ -0,0 +1,73 @@ +--- +title: Object.prototype.toSource() +slug: Web/JavaScript/Referencje/Obiekty/Object/toSource +tags: + - JavaScript + - Method + - Non-standard + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource +--- +
{{JSRef}} {{non-standard_header}}
+ +

Podsumowanie

+ +

Zwraca literał obiektowy reprezentujący kod źródłowy danego obiektu.

+ +

Składnia

+ +
Object.toSource();
+obj.toSource();
+
+ +

Parametry

+ +

Brak.

+ +

Opis

+ +

Metoda toSource() zwraca następujące wartości:

+ + + +

Metoda ta zazwyczaj jest używana wewnętrznie przez interpreter JavaScriptu, a nie bezpośrednio w kodzie. Można jednak wywołać toSource() podczas debugowania, by zbadać zawartość danego obiektu.

+ +

Przykłady

+ +

Przykład: Zastosowanie toSource()

+ +

Poniższy kod definiuje typ obiektowy Pies i tworzy instancję piesek jako obiekt typu Pies:

+ +
function Pies(nazwa) {
+  this.nazwa = nazwa;
+}
+
+Pies.prototype.toSource = function Pies_toSource() {
+  return 'new Pies(' + uneval(this.nazwa) + ')';
+};
+
+console.log(new Pies('Joe').toSource()); // ---> new  Pies("Joe")
+ +

Zobacz także

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/tostring/index.html b/files/pl/web/javascript/reference/global_objects/object/tostring/index.html new file mode 100644 index 0000000000..e18d93d79a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/tostring/index.html @@ -0,0 +1,98 @@ +--- +title: Object.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/Object/toString +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toString +--- +

{{JSRef}}

+ +

Podsumowanie

+ +

Zwraca łańcuch znaków reprezentujący dany obiekt.

+ +

Składnia

+ +
obj.toString()
+ +

Opis

+ +

Każdy obiekt posiada metodę toString, która jest wywoływana automatycznie, kiedy obiekt ma zostać przedstawiony jako wartość tekstowa, albo kiedy obiekt jest dołączany do ciągu znakowego. Poniższe przykłady wymagają, by jakisPies był reprezentowany jako łańcuch znaków:

+ +
console.log(jakisPies);
+console.log("jakisPies to " + jakisPies);
+
+ +

Domyślnie metoda toString jest dziedziczona przez każdy obiekt wyprowadzony z obiektu Object. Można przesłonić tę metodę dla własnych obiektów. Jeśli toString nie zostanie przesłonięta we własnych obiektach użytkownika, zwróci ona [object + typ + ], gdzie + typ + jest typem obiektu lub nazwą funkcji konstruktora, która utworzyła ten obiekt.

+ +

Na przykład:

+ +
var o = new Object()
+o.toString() // zwraca "[object Object]"
+
+ +

Przykłady

+ +

Przesłanianie domyślnej metody toString()

+ +

Można utworzyć funkcję, która będzie wywoływana zamiast domyślnej metody toString(). Metoda toString() nie pobiera żadnych argumentów i powinna zwrócić łańcuch znaków. Utworzona przez użytkownika metoda toString() może zwracać dowolną wartość, ale najlepiej, by przekazywała użyteczne informacje na temat obiektu.

+ +

Poniższy kod definiuje typ obiektowy Pies i tworzy obiekt jakisPies typu Pies:

+ +
function Pies(nazwa,rasa,wiek,plec) {
+   this.nazwa=nazwa;
+   this.rasa=rasa;
+   this.wiek=wiek;
+   this.plec=plec;
+}
+
+jakisPies = new Pies("Szarik","owczarek niemiecki","5","samiec");
+ +

Jeśli wywołana zostanie metoda toString tego obiektu, zwrócona zostanie domyślna wartość odziedziczona po Object:

+ +
jakisPies.toString(); // zwraca [object Object]
+
+ +

Poniższy kod tworzy funkcję piesToString, która to funkcja będzie przesłaniać domyślną metodę toString. Funkcja ta tworzy łańcuch znaków zawierający każdą własność; budowany łańcuch będzie postaci "własność = wartość;".

+ +
function piesToString() {
+   var ret = "Pies " + this.nazwa + " to: [\n";
+   for (var prop in this)
+      ret += " " + prop + " = " + this[prop] + ";\n";
+   return ret + "]";
+}
+
+ +

Poniższy kod przypisuje zdefiniowaną powyżej funkcję do metody toString obiektów typu obiektowego Pies:

+ +
Pies.prototype.toString = piesToString;
+
+ +

Dzięki powyższemu kodowi za każdym razem, kiedy jakisPies używany jest w kontekście łańcucha znaków, interpreter JavaScriptu automatycznie wywołuje funkcję piesToString, która zwraca poniższy łańcuch:

+ +
Pies Szarik to: [
+  nazwa = Szarik;
+  rasa = owczarek niemiecki;
+  wiek = 5;
+  plec = samiec;
+]
+
+ +

Metoda toString danego obiektu jest zazwyczaj wywoływana przez interpreter JavaScriptu, ale można ją wywołać samodzielnie, jak poniżej:

+ +
var piesString = jakisPies.toString();
+
+ +

Zobacz także

+ + diff --git a/files/pl/web/javascript/reference/global_objects/object/valueof/index.html b/files/pl/web/javascript/reference/global_objects/object/valueof/index.html new file mode 100644 index 0000000000..db3cf7a346 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/valueof/index.html @@ -0,0 +1,63 @@ +--- +title: Object.prototype.valueOf() +slug: Web/JavaScript/Referencje/Obiekty/Object/valueOf +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf +--- +

{{jsRef}}

+ +

Podsumowanie

+ +

Zwraca wartość podstawową danego obiektu.

+ +

Składnia

+ +
object.valueOf()
+ +

Parametry

+ +

Brak.

+ +

Opis

+ +

JavaScript wywołuje metodę valueOf() by przekonwertować obiekt do wartości podstawowej. Metodę valueOf rzadko wykorzystuje się w pisanych programach, zazwyczaj JavaScript wywołuje ją automatycznie, kiedy oczekując wartości podstawowej napotka obiekt.

+ +

Domyślnie metoda valueOf() jest dziedziczona przez każdy obiekt potomny obiektu {{jsxref("Object")}}. Każdy wbudowany obiekt jądra JavaScriptu przesłania tę metodą by zwracała właściwą wartość. Jeśli obiekt nie ma wartości podstawowej, valueOf() zwraca sam obiekt, który jest wyświetlany jako:

+ +
[object Object]
+
+ +

We własnych programach można oczywiście używać metody valueOf do konwersji obiektów na wartości podstawowe. Kiedy użytkownik tworzy własne obiekty, może przesłonić metodę valueOf() własną wersją.

+ +

Przesłanianie metody valueOf dla własnych obiektów

+ +

Można utworzyć funkcję, która będzie wywoływana zamiast domyślnej metody valueOf. Taka funkcja nie powinna mieć argumentów.

+ +

Załóżmy, że mamy typ obiektowy MojTypLiczbowy i chcemy utworzyć dla niego metodę valueOf. Poniższy kod przypisuje zdefiniowaną przez użytkownika funkcję do metody valueOf obiektu:

+ +
MojTypLiczbowy.prototype.valueOf = new Function(tekstFunkcji);
+
+ +

Dzięki powyższej instrukcji za każdym razem, kiedy obiekt typu MojTypLiczbowy jest używany w kontekście wartości prostej, JavaScript automatycznie wywoła funkcję zdefiniowaną powyżej.

+ +

Metoda valueOf obiektu jest zwykle wywoływana przez interpreter JavaScriptu, ale można ją wywołać samodzielnie:

+ +
mojaLiczba.valueOf();
+
+ +

Uwaga

+ +

Obiekty używane w kontekście łańcucha znaków konwertowane są przy użyciu metody toString, co różni się od konwertowania obiektów String do prostych łańcuchów znaków poprzez valueOf. Wszystkie obiekty posiadają konwersję do łańcucha znaków, choćby [object + typ + ]. Ale wiele obiektów nie posiada domyślnej konwersji do liczby, wartości logicznej lub funkcji.

+ +

Zobacz także

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