diff options
Diffstat (limited to 'files/pl/web/javascript/reference/global_objects/object')
12 files changed, 1667 insertions, 0 deletions
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 +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>Object.assign()</code></strong> 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.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">Object.assign(<var>cel</var>, ...<var>zrodla</var>)</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>cel</code></dt> + <dd>Obiekt docelowy.</dd> + <dt><code>zrodla</code></dt> + <dd>Obiekt(y) żródłowe.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Obiekt docelowy.</p> + +<h2 id="Opis">Opis</h2> + +<p>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.</p> + +<p>Metoda <code>Object.assign()</code> jedynie kopiuje <em>wyliczalne</em> i <em>własne</em> właściwości z obiektów źródłowych do obiektu docelowego. Używa do tego <code>[[Get]]</code> na źródle oraz <code>[[Set]]</code> na obiekcie docelowym, więc wywołuje gettery i settery odpowiednich obiektów. Dlatego też mowa tu o <em>przypisaniu</em> 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()")}}.</p> + +<p>Obie właściwości {{jsxref("String")}} jak i {{jsxref("Symbol")}} są kopiowane.</p> + +<p>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.</p> + +<p>Zauważ, że <code>Object.assign()</code> nie rzuci błędu, gdy źródłem jest {{jsxref("null")}} lub {{jsxref("undefined")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Klonowanie_obiektu">Klonowanie obiektu</h3> + +<pre class="brush: js">var obiekt = { a: 1 }; +var kopia = Object.assign({}, obiekt); +console.log(kopia); // { a: 1 } +</pre> + +<h3 id="Deep_Clone" name="Deep_Clone">Ostrzeżenie przed Głębokim Klonowaniem</h3> + +<p>W przypadku głębokiego klonowania musimy użyć innych sposóbów, ponieważ <code>Object.assign()</code> 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).</p> + +<pre><code>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();</code></pre> + +<h3 id="Łączenie_obiektów">Łączenie obiektów</h3> + +<pre class="brush: js">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.</pre> + +<h3 id="Łączenie_obiektów_z_tymi_samymi_właściowściami">Łączenie obiektów z tymi samymi właściowściami</h3> + +<pre class="brush: js">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 }</pre> + +<p>Właściwość jest nadpisywana przez ostatni obiekt w liście parametrów, który ma taką samą właściwość.</p> + +<h3 id="Kopiowanie_właściwości-symboli">Kopiowanie właściwości-symboli</h3> + +<pre class="brush: js">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)] +</pre> + +<h3 id="Właściwości_nieprzeliczalne_oraz_te_z_łańcucha_prototypów_nie_są_kopiowane">Właściwości nieprzeliczalne oraz te z łańcucha prototypów nie są kopiowane</h3> + +<pre class="brush: js">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 } +</pre> + +<h3 id="Wartości_podstawowe_zostaną_włożone_do_ich_wrapperów">Wartości podstawowe zostaną włożone do ich wrapperów</h3> + +<pre class="brush: js">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" } +</pre> + +<h3 id="Wyjątki_przerwą_wykonywanie_kopiowania">Wyjątki przerwą wykonywanie kopiowania</h3> + +<pre class="brush: js">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 +</pre> + +<h3 id="Kopiowanie_operatorów_pamięci">Kopiowanie operatorów pamięci</h3> + +<pre class="brush: js">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 } } +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Ten {{Glossary("Polyfill","polyfill")}} nie wspiera właściwości-symboli, ponieważ ES5 i tak ich nie ma.</p> + +<pre class="brush: js">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; + }; +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-object.assign', 'Object.assign')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.assign', 'Object.assign')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Edge</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("45")}}</td> + <td>{{CompatGeckoDesktop("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatOpera("32")}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("45")}}</td> + <td>{{CompatGeckoMobile("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Object.defineProperties()")}}</li> + <li><a href="/pl/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Przeliczalność i własność właściwości</a></li> +</ul> 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 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>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ę.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wszystkie obiekty dziedziczą własność <code>constructor</code> z ich prototypu (<code>prototype</code>):</p> + +<pre class="brush: js">var o = {}; +o.constructor === Object; // true + +var a = []; +a.constructor === Array; // true + +var n = new Number(3); +n.constructor === Number; // true +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_konstruktora_obiektu" name="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_konstruktora_obiektu">Przykład: Wyświetlanie konstruktora obiektu</h3> + +<p>Poniższy przykład tworzy prototyp, <code>Drzewo</code> i obiekt tego typu <code>sosna</code>. Następnie wyświetlana jest własność <code>constructor</code> obiektu <code>Drzewo</code>.</p> + +<pre class="brush: js">function Drzewo(nazwa) { + this.nazwa=nazwa; +} + +sosna = new Drzewo("sosna"); +console.log("sosna.constructor to " + sosna.constructor) +</pre> + +<p>Przykład ten wyświetla:</p> + +<pre>sosna.constructor to function Drzewo(nazwa) { + this.nazwa = nazwa; +} +</pre> 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 +--- +<div>{{JSRef}}</div> + +<div>Metoda <code><strong>Object.freeze()</strong> </code>"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".</div> + +<div> </div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Object.freeze(<var>obj</var>)</code></pre> + +<h3 id="Argumenty">Argumenty</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Obiekt który ma zostać "zamrożony".</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>"Zamrożony" obiekt.</p> + +<h2 id="Opis">Opis</h2> + +<p>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)}}).</p> + +<p>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. </p> + +<h2 id="Przykłady">Przykłady</h2> + +<p> </p> + +<h3 id="Zamrażanie_Obiektów">Zamrażanie Obiektów</h3> + +<p> </p> + +<pre class="brush: js">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} +</pre> + +<h3 id="Zamrażanie_Tablic_(Array)">Zamrażanie Tablic (Array)</h3> + +<p> </p> + +<pre class="brush: js"><code>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 + +// </code>przy strict mode tego typu próby spowodują wyświetlenie komunikatu o błędzie<code> TypeErrors +function fail() { + "use strict" + a[0] = 1; + a.push(2); +} + +fail();</code></pre> + +<p>"Zamrożony" obiekt jest <em>niemutowalny</em>. Nie jest on jednak <em>stałą</em>. Obrazuje to poniższy przykład.</p> + +<pre class="brush: js"><code>obj1 = { + internal: {} +}; + +Object.freeze(obj1); +obj1.internal.a = 'aValue'; + +obj1.internal.a // 'aValue'</code> +</pre> + +<p> </p> + +<p>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 <em>state </em>(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. </p> + +<p>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 <em><a href="https://en.wikipedia.org/wiki/Cycle_(graph_theory)">cycles</a> </em>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].</p> + +<pre class="brush: js"><code>// 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</code></pre> + +<p> </p> + +<p> </p> + +<h2 id="Notes">Notes</h2> + +<p>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.</p> + +<pre class="brush: js">> Object.freeze(1) +TypeError: 1 is not an object // ES5 code + +> Object.freeze(1) +1 // ES2015 code +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.9', 'Object.freeze')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-object.freeze', 'Object.freeze')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.freeze', 'Object.freeze')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> +<p>{{Compat("javascript.builtins.Object.freeze")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Object.isFrozen()")}}</li> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> + <li>{{jsxref("Object.seal()")}}</li> + <li>{{jsxref("Object.isSealed()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>Object.getOwnPropertyDescriptor()</strong></code> 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.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Object.getOwnPropertyDescriptor(<var>obj</var>, <var>prop</var>)</code></pre> + +<h3 id="Argumenty">Argumenty</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Obiekt, w którym będzie poszukiwana właściwość.</dd> + <dt><code>prop</code></dt> + <dd>Nazwa właściwości, dla której będzie pobrany deskryptor.</dd> +</dl> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p>Jeżeli obiekt posiada podaną właściwość, wówczas zostanie zwrócony jej deskryptor, w przeciwnym razie zostanie zwrócony {{jsxref("undefined")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>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()")}}.</p> + +<p>Deskryptor właściwości jest obiektem zawierającym poniższe atrybuty:</p> + +<dl> + <dt><code>value</code></dt> + <dd>Wartość związana z odpowiadającą właściwością (tylko dla deskryptorów danych).</dd> + <dt><code><strong>writable</strong></code></dt> + <dd>Jeżeli <code>true</code> odpowiadająca wartość właściwości może być zmieniona (tylko dla deskryptorów danych).</dd> + <dt><code>get</code></dt> + <dd>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).</dd> + <dt><code>set</code></dt> + <dd>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).</dd> + <dt><code>configurable</code></dt> + <dd>Jeżeli <code>true</code> 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.</dd> + <dt><code>enumerable</code></dt> + <dd>Jeżeli <code>true</code> odpowiadająca wartość właściwości będzie dostępna podczas iteracji po właściwosciach odpowiadającego obiektu.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">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 } +</pre> + +<h2 id="Uwagi">Uwagi</h2> + +<p>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.</p> + +<pre class="brush: js">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 +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.3', 'Object.getOwnPropertyDescriptor')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarkowa">Kompatybilność przeglądarkowa</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Object.getOwnPropertyDescriptor")}}</p> +</div> +</div> + +<p> </p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</li> +</ul> 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 +--- +<div>{{JSRef("Global_Objects", "Object")}}</div> + +<h2 id="Summary" name="Summary">Wstęp</h2> + +<p>Metoda <code><strong>hasOwnProperty()</strong></code> zwraca wartość <code>true</code> jeśli obiekt, na którym została wywołana posiada konkretną własność.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox notranslate"><code><var>obj</var>.hasOwnProperty(<var>prop</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><code>prop</code></dt> + <dd>Nazwa ({{jsxref("String")}}) własności lub <a href="https://developer.mozilla.org/en-US/docs/Glossary/Symbol">Symbol</a>, do sprawdzenia.</dd> +</dl> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p><span class="tlid-translation translation"><span class="alt-edited">A {{jsxref ("Boolean")}} wskazujący, czy obiekt zawiera w sobie określoną właściwość.</span></span></p> + +<h2 id="Description" name="Description">Opis</h2> + +<p>Każdy obiekt pochodzący od {{jsxref("Global_Objects/Object", "Object")}} dziedziczy metodę <code>hasOwnProperty</code>. 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 <code style="font-style: normal;">hasOwnProperty</code> nie sprawdza <u>w głąb łańcucha</u> własności obiektu.</p> + +<h2 id="Examples" name="Examples">Notatka</h2> + +<p><span class="tlid-translation translation"><span title=""><code>hasOwnProperty</code> zwraca <code>true</code>, nawet jeśli wartość właściwości to <code>null</code> lub <code>undefined</code>.</span></span></p> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">o <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Object</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +o<span class="punctuation token">.</span>propOne <span class="operator token">=</span> <span class="keyword token">null</span><span class="punctuation token">;</span> +o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'propOne'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// zwraca true</span> +o<span class="punctuation token">.</span>propTwo <span class="operator token">=</span> undefined<span class="punctuation token">;</span> +o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'propTwo'</span><span class="punctuation token">)</span><span class="punctuation token">; // zwraca true</span></code> +</pre> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<h3 id="Example_Using_hasOwnProperty_to_test_for_a_property.27s_existence" name="Example:_Using_hasOwnProperty_to_test_for_a_property.27s_existence">Użycie <code>hasOwnProperty</code> do testowania istnienia własności</h3> + +<p>Poniższy przykład określa czy obiekt <code>o</code> posiada własność o nazwie <code>prop</code>:</p> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">o <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Object</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'prop'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// zwraca false</span> +o<span class="punctuation token">.</span>prop <span class="operator token">=</span> <span class="string token">'istnieje'</span><span class="punctuation token">;</span> +o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'prop'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// zwraca true</span></code></pre> + +<h3 id="Example_Direct_versus_inherited_properties" name="Example:_Direct_versus_inherited_properties">Własności bezpośrednie kontra odziedziczone</h3> + +<p>Poniższy przykład rozróżnia bezpośrednie właściwości z właściwościami dziedziczonymi w łańcuchu prototypów:</p> + +<pre class="brush: js notranslate">o = new Object(); +o.prop = 'istnieje'; +o.hasOwnProperty('prop'); // zwraca true +o.hasOwnProperty('toString'); // zwraca false +o.hasOwnProperty('hasOwnProperty'); // zwraca false +</pre> + +<h3 id="Example_Itarate_over_properties_not_considering_inherited_properties" name="Example:_Itarate_over_properties_not_considering_inherited_properties">Iterowanie przez właściwości obiektu</h3> + +<p><span class="tlid-translation translation"><span title="">Poniższy przykład ilustruje sposób iteracji po właściwościach obiektu bez wykonywania iteracji na dziedziczonych właściwościach.</span></span></p> + +<pre class="notranslate">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) + } +}</pre> + +<div class="blockIndicator warning"> +<p><span class="tlid-translation translation"><span title="">Zwróć uwagę, że pętla </span></span>{{jsxref("Statements/for...in", "for...in")}}<span class="tlid-translation translation"><span title=""> tylko iteruje właściwości przeliczalne</span></span>, a <a href="http://zduck.com/2013/non-enumerable-properties-in-javascript/">nieprzeliczanych</a> nie zauważa.</p> +</div> + +<h3 id="Używanie_hasOwnProperty_jako_nazwy_właściwości"><span class="tlid-translation translation"><span title="">Używanie <code>hasOwnProperty</code> jako nazwy właściwości</span></span></h3> + +<p><span class="tlid-translation translation"><span title="">JavaScript nie chroni nazwy właściwości <code>hasOwnProperty</code>;</span> <span title="">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 <code>hasOwnProperty</code>, aby uzyskać poprawne wyniki:</span></span></p> + +<pre class="brush: js notranslate">const obj = { + hasOwnProperty: function() { + return false; + }, + prop: 'Kolejna właściwość' +}; + +obj.hasOwnProperty('prop'); // zawsze zwróci false + +// <span class="tlid-translation translation"><span class="alt-edited">Użyj właściwości hasOwnProperty innego obiektu i wywołaj ją, ustawiając "this" na obj</span></span> +({}).hasOwnProperty.call(obj, 'prop'); // zwraca true + +// <span class="tlid-translation translation"><span title="">W tym celu można również użyć własności hasOwnProperty z prototypu Object</span></span> +Object.prototype.hasOwnProperty.call(obj, 'prop'); // zwraca true +</pre> + +<p><span class="tlid-translation translation"><span title="">Zwróć uwagę, że w ostatnim przypadku nie ma żadnych nowo utworzonych obiektów.</span></span></p> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 3rd Edition.</td> + <td>Standard</td> + <td>Initial definition. Implemented in JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.4.5', 'Object.prototype.hasOwnProperty')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div class="hidden"> +<p><span class="tlid-translation translation"><span title="">Tabela zgodności na tej stronie jest generowana na podstawie danych strukturalnych.</span> <span title="">Jeśli chcesz przyczynić się do danych, sprawdź <a href="/pl/docs/">https://github.com/mdn/browser-compat-data</a> i wyślij nam pull request'a.</span></span></p> +</div> + +<div>{{Compat("javascript.builtins.Object.hasOwnProperty")}}</div> + +<h2 id="See_also" name="See_also">Zobacz także</h2> + +<ul> + <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li> + <li>{{jsxref("Object.getOwnPropertyNames()")}}</li> + <li>{{jsxref("Statements/for...in", "for...in")}}</li> + <li>{{jsxref("Operators/in", "in")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_Revisited">JavaScript Guide: Inheritance revisited</a></li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>Konstruktor <strong>Object</strong> tworzy wrapper obiektu.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia</h2> + +<pre class="syntaxbox"><code>// Notacja literałowa +{ [ <var>paraWartoscNazwa1</var>[, <var>paraWartoscNazwa2</var>[, ...<var>paraWartoscNazwaN</var>] ] ] } + +// Wywoływany jako konstruktor +new Object([<var>wartosc</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code><var>paraWartoscNazwa1</var>, <var>paraWartoscNazwa2</var>, ... <var>paraWartoscNazwaN</var></code></dt> + <dd>Pary nazw (string) oraz wartości (jakakolwiek wartość) przyczym nazwa oddzielona jest od wartości dwukropkiem.</dd> + <dt><code><var>wartosc</var></code></dt> + <dd>Jakakolwiek wartość.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>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.</p> + +<p>Zobacz również <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">Inicjator obiektu / notacja literałowa</a>.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Właściwości</h2> + +<dl> + <dt><code>Object.length</code></dt> + <dd>Przyjmuje wartość 1.</dd> + <dt>{{jsxref("Object.prototype")}}</dt> + <dd>Pozwala na dodawanie właściwości i metod do wszystkich obiektów typu Object.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Object.assign()")}}</dt> + <dd>Kopiuje wszystkie <strong>własne </strong>właściwości z jednego lub więcej obiektów żródłowych do obiektu docelowego.</dd> + <dt>{{jsxref("Object.create()")}}</dt> + <dd>Tworzy nowy obiekt z podanym prototypem oraz właściwościami</dd> + <dt>{{jsxref("Object.defineProperty()")}}</dt> + <dd>Dodaje do obiektu wymienioną właściwość opisywaną przez podany deskryptor.</dd> + <dt>{{jsxref("Object.defineProperties()")}}</dt> + <dd>Dodaje do obiektu wymienione właściwości opisywane przez podane deskryptory.</dd> + <dt>{{jsxref("Object.freeze()")}}</dt> + <dd>Zamraża obiekt. Uniemożliwia usuwanie oraz modyfikowanie jego właściwości.</dd> + <dt>{{jsxref("Object.getOwnPropertyDescriptor()")}}</dt> + <dd>Zwraca z obiektu deskryptor dla wymienionej właściwości. </dd> + <dt>{{jsxref("Object.getOwnPropertyNames()")}}</dt> + <dd>Zwraca tablicę zawierającą nazwy wszystkich <strong>własnych</strong> właściwości obiektu. (Zarówno przeliczalnych jak i nieprzeliczalnych)</dd> + <dt>{{jsxref("Object.getOwnPropertySymbols()")}}</dt> + <dd>Zwraca tablicę zawierającą wszystkie <strong>własne</strong> właściwości-symbole danego obiektu</dd> + <dt>{{jsxref("Object.getPrototypeOf()")}}</dt> + <dd>Zwraca prototyp określonego obiektu.</dd> + <dt>{{jsxref("Object.is()")}}</dt> + <dd>Sprawdza czy dwie podane wartości są takie same.</dd> + <dt>{{jsxref("Object.isExtensible()")}}</dt> + <dd>Sprawdza czy obiekt można rozszerzyć.</dd> + <dt>{{jsxref("Object.isFrozen()")}}</dt> + <dd>Sprawdza czy obiekt jest zamrożony.</dd> + <dt>{{jsxref("Object.isSealed()")}}</dt> + <dd>Sprawdza czy obiekt jest zapieczętowany.</dd> + <dt>{{jsxref("Object.keys()")}}</dt> + <dd>Zwraca tablicę zawierającą nazwy wszystkich <strong>własnych</strong> właściwości obiektu. (Tylko przeliczalnych)</dd> + <dt>{{jsxref("Object.preventExtensions()")}}</dt> + <dd>Zabopiega rozszerzaniu obiektu (tj. dodawaniu właściwości).</dd> + <dt>{{jsxref("Object.seal()")}}</dt> + <dd>Zapieczętowuje obiekt, zapobiegając dodawaniu oraz usuwaniu jego właściwości.</dd> + <dt>{{jsxref("Object.setPrototypeOf()")}}</dt> + <dd>Ustawia prototyp obiektu.</dd> + <dt>{{jsxref("Object.values()")}} {{experimental_inline}}</dt> + <dd>Zwraca tablicę zawierającą wszystkie <strong>własne</strong>, przeliczalne wartości obiektu.</dd> +</dl> + +<h2 id="Instancje_i_prototyp_Object">Instancje i prototyp <code>Object</code></h2> + +<p>W Javascript, wsyzstkie obiekty pochodzą od obiektu <code>Object</code>, 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ść <code>constructor</code> oraz metody <code>toString</code><code>()</code>. Wszelkie zmiany w prototypie <code>Object</code> 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.</p> + +<h3 id="Właściwości">Właściwości</h3> + +<div>{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Object/prototype', 'W.C5.82asno.C5.9Bci') }}</div> + +<h3 id="Metody_2">Metody</h3> + +<div>{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Object/prototype', 'Metody') }}</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_typów_null_i_undefined">Używanie <font face="Consolas, Liberation Mono, Courier, monospace">typów</font> <code>null</code> i <code>undefined</code></h3> + +<p>W poniższych przykładach zmienna o przechowuje pusty obiekt <code>Object</code>:</p> + +<pre class="brush: js">var o = new Object(); +</pre> + +<pre class="brush: js">var o = new Object(undefined); +</pre> + +<pre class="brush: js">var o = new Object(null); +</pre> + +<h3 id="Tworzenie_obiektu_Boolean">Tworzenie obiektu <code>Boolean</code></h3> + +<p>W poniższych przykładach zmienna o przechowuje obiekty {{jsxref("Boolean")}}:</p> + +<pre class="brush: js">// równoznaczne z: o = new Boolean(true); +var o = new Object(true); +</pre> + +<pre class="brush: js">// równoznaczne z: o = new Boolean(false); +var o = new Object(Boolean()); +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Początkowa definicja. Zaimplementowana w JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2', 'Object')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object-objects', 'Object')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Dodano Object.assign, Object.getOwnPropertySymbols, Object.setPrototypeOf, Object.is</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object-objects', 'Object')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Dodano Object.entries, Object.values oraz Object.getOwnPropertyDescriptors.</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">Inicjalizator obiektu</a></li> +</ul> 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 +--- +<div class="warning"> +<p><strong>Ostrzeżenie:</strong> Zmiana <code>[[Prototype]]</code> 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 <code>obj.__proto__ = ...</code>, skutki wpływają na <strong>każdy</strong> fragment kodu który odwołuje się do <strong>jakiejkolwiek</strong> właściwości obiektu, którego <code>[[Prototype]]</code> został zmieniony. Dlatego jeżeli zależy ci na wydajności powinieneś unikać tej operacji. Zamiast tego, stwórz nowy obiekt z porządanym <code>[[Prototype]]</code> za pomocą {{jsxref("Object.create()")}}.</p> +</div> + +<div class="warning"> +<p><strong>Ostrzeżenie:</strong> Mimo że w dzisiejszych czasach <code>Object.prototype.__proto__</code> jest wspierany w niemal każdej przeglądarce, jego istnienie oraz zachowanie zostały ujednolicone w specyfikacji ECMAScript 2015 jedynie jako <em>legacy feature</em> aby zapewnić kompatybilność z przeglądarkami. Dla lepszego wsparcia rekomenduje się używanie {{jsxref("Object.getPrototypeOf()")}}.</p> +</div> + +<div>{{JSRef}}</div> + +<p>Właściwość <code>__proto__</code> obiektu {{jsxref("Object.prototype")}} jest operatorem dostępu (metoda getter i setter) która operuje na wewnętrznym <code>[[Prototype]]</code> (na obiekcie lub na {{jsxref("Global_Objects/null", "null")}}) obiektu do którego się odnosi.</p> + +<p>Użycie <code>__proto__</code> 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ść <code>__proto__</code> 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 <code>[[Prototype]]</code> wciąż jest operacją powolną, która powinna być unikana przez wzgląd na wydajność).</p> + +<p><code>Właściwość __proto__</code> może być również używana w notacji literałowej aby ustawić <code>[[Prototype]]</code> tworzonego obiektu, jako alterantywa do {{jsxref("Object.create()")}}. Zobacz: <a href="/pl/docs/Web/JavaScript/Reference/Operators/Object_initializer">inicjalizator obiektu / notacja literałowa</a>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js">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 +</pre> + +<pre class="brush: js">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 +</pre> + +<p>Uwaga: <code>__proto__</code> zapisujemy jako dwie <em>podłogi</em>, następnie pięć liter "proto", następnie dwie kolejne <em>podłogi</em>.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda getter właściwości <code>__proto__</code> daje nam dostęp do wewnętrznej wartości <code>[[Prototype]]</code> 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 <code>new Funkcja</code>, gdzie <code>Funkcja</code> 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 <code>Funkcja.prototype</code>. Dla obiektów stworzonych przy użyciu <code>new Funkcja</code>, gdzie <code>Funkcja</code> to funkcja zdefiniowana w kodzie, wartość ta przyjmuje taką samą wartość jak <code>Funkcja.prototype</code>.</p> + +<p>Metoda setter właściwości <code>__proto__ </code>umożliwia modyfikowanie <code>[[Prototype]]</code> 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.</p> + +<p>Aby zrozumieć w jaki sposób prototypy używane są do dziedziczenia, zobacz artykuł o <a href="/pl/docs/Web/JavaScript/dziedziczenie_lancuch_prototypow">dziedziczeniu oraz łańcuchu prototypów</a>.</p> + +<p>Właściwość <code>__proto__</code> 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 <code>__proto__</code> 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ść <code>__proto__</code> zostanie znaleziona, zanim {{jsxref("Object.prototype")}} zostanie skonsultowany, to właściwość ta przesłoni tą znalezioną w {{jsxref("Object.prototype")}}.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Dołączony (normatywnie) jako jeden z dodatkowych ECMAScript <em>legacy features</em> dla przeglądarek (zauważ że specyfikacja jedynie ujednoliciła coś, co było już zaimplementowane w przeglądarkach).</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatIE("11")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Uwagi_odnośnie_kompatybilności">Uwagi odnośnie kompatybilności</h2> + +<p>Mimo, że specyfikacja ECMAScript 2015 określa iż wsparcie dla <code>__proto__</code> jest wymagane <em>tylko</em> dla przeglądarek internetowych (w zasadzie normatywnie), to inne środowiska równieź mogą wspierać tę funkcjonalność.</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li> + <li>{{jsxref("Object.getPrototypeOf()")}}</li> + <li>{{jsxref("Object.setPrototypeOf()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>Object.seal()</strong></code> "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 <strong>writable</strong>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Object.seal(<var>obj</var>)</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Obiekt który powinien zostać zamknięty.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Uszczelniony obiekt.</p> + +<h2 id="Opis">Opis</h2> + +<p>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)}}).</p> + +<p>Łancuch prototypów pozostaje nie zmieniony, jednakże właściwość {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}} jest również niemożliwa do zmiany.</p> + +<h2 id="Examples">Examples</h2> + +<pre class="brush: js">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ść +</pre> + +<h2 id="Uwagi">Uwagi</h2> + +<p>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.</p> + +<pre class="brush: js">Object.seal(1); +// TypeError: 1 is not an object (ES5 code) + +Object.seal(1); +// 1 (ES6 code) +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.8', 'Object.seal')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Wstępna definicja. Implementowano w JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.seal', 'Object.seal')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_w_przeglądarkach">Kompatybilność w przeglądarkach</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("6")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12")}}</td> + <td>{{CompatSafari("5.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Object.isSealed()")}}</li> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> + <li>{{jsxref("Object.freeze()")}}</li> + <li>{{jsxref("Object.isFrozen()")}}</li> +</ul> 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 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący obiekt. Ta metoda najczęściej jest przysłonięta przez pochodne obiekty.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>obj</var>.toLocaleString();</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>Object</code> <code>toLocaleString</code> zwraca rezultat, który nazywamy {{jsxref("Object.toString", "toString()")}}.</p> + +<p>Ta metoda jest dostarczona dając obiektom generującą metodę <code>toLocaleString()</code>, nawet mimo to nie wszystkie go używają. Aktualnie, tylko <code>Array</code>, <code>Number</code> i <code>Date</code> nadpisują <code>toLocaleString</code>.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca literał obiektowy reprezentujący kod źródłowy danego obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Object.toSource(); +<var>obj</var>.toSource(); +</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toSource()</code> zwraca następujące wartości:</p> + +<ul> + <li>dla obiektu wbudowanego {{jsxref("Object")}} metoda <code>toSource()</code> zwraca następujący ciąg znaków, wskazujący na niedostępność kodu źródłowego: + + <pre class="brush: js">function Object() { + [native code] +} +</pre> + </li> + <li>dla instancji {{jsxref("Object")}} metoda <code>toSource()</code> zwraca ciąg reprezentujący ich kod źródłowy.</li> +</ul> + +<p>Metoda ta zazwyczaj jest używana wewnętrznie przez interpreter JavaScriptu, a nie bezpośrednio w kodzie. Można jednak wywołać <code>toSource()</code> podczas debugowania, by zbadać zawartość danego obiektu.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toSource" name="Przyk.C5.82ad:_Zastosowanie_toSource">Przykład: Zastosowanie <code>toSource()</code></h3> + +<p>Poniższy kod definiuje typ obiektowy <code>Pies</code> i tworzy instancję <code>piesek</code> jako obiekt typu <code>Pies</code>:</p> + +<pre class="brush: js language-js"><code class="language-js"><span class="token keyword">function</span> </code>Pies<code class="language-js"><span class="token function"><span class="token punctuation">(</span></span></code>nazwa<code class="language-js"><span class="token punctuation">)</span> <span class="token punctuation">{</span> + <span class="token keyword">this</span><span class="token punctuation">.</span></code>nazwa<code class="language-js"> <span class="token operator">=</span> </code>nazwa<code class="language-js"><span class="token punctuation">;</span> +<span class="token punctuation">}</span> + +</code><code>Pies</code><code class="language-js"><span class="token punctuation">.</span>prototype<span class="token punctuation">.</span>toSource <span class="token operator">=</span> <span class="token keyword">function</span> </code><code>Pies</code><code class="language-js"><span class="token function">_toSource<span class="token punctuation">(</span></span><span class="token punctuation">)</span> <span class="token punctuation">{</span> + <span class="token keyword">return</span> <span class="token string">'new </span></code><code>Pies</code><code class="language-js"><span class="token string">('</span> <span class="token operator">+</span> <span class="token function">uneval<span class="token punctuation">(</span></span><span class="token keyword">this</span><span class="token punctuation">.</span>nazwa<span class="token punctuation">)</span> <span class="token operator">+</span> <span class="token string">')'</span><span class="token punctuation">;</span> +<span class="token punctuation">}</span><span class="token punctuation">;</span> + +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token keyword">new</span> </code><code>Pies</code><code class="language-js"><span class="token punctuation">(</span><span class="token string">'Joe'</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toSource<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // ---> new </span></code> <code>Pies</code><code class="language-js"><span class="token comment">("Joe")</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Array", "Array")}} Object method.</li> + <li>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Boolean", "Boolean")}} Object method.</li> + <li>{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Date", "Date")}} Object method.</li> + <li>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Function", "Function")}} Object method.</li> + <li>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Number", "Number")}} Object method.</li> + <li>{{jsxref("Regexp.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/RegExp", "RegExp")}} Object method.</li> + <li>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/String", "String")}} Object method.</li> + <li>{{jsxref("Symbol.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Symbol", "Symbol")}} Object method.</li> + <li><code>Math.toSource()</code> — Returns the String "Math".</li> +</ul> 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 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący dany obiekt.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>obj</var>.toString()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Każdy obiekt posiada metodę <code>toString</code>, 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 <code>jakisPies</code> był reprezentowany jako łańcuch znaków:</p> + +<pre class="brush: js">console.log(jakisPies); +console.log("jakisPies to " + jakisPies); +</pre> + +<p>Domyślnie metoda <code>toString</code> jest dziedziczona przez każdy obiekt wyprowadzony z obiektu <code>Object</code>. Można przesłonić tę metodę dla własnych obiektów. Jeśli <code>toString</code> nie zostanie przesłonięta we własnych obiektach użytkownika, zwróci ona <code>[object + <i>typ</i> + ]</code>, gdzie <code> + <i>typ</i> + </code> jest typem obiektu lub nazwą funkcji konstruktora, która utworzyła ten obiekt.</p> + +<p>Na przykład:</p> + +<pre class="brush: js">var o = new Object() +o.toString() // zwraca "[object Object]" +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przes.C5.82anianie_domy.C5.9Blnej_metody_toString" name="Przes.C5.82anianie_domy.C5.9Blnej_metody_toString">Przesłanianie domyślnej metody <code>toString()</code></h3> + +<p>Można utworzyć funkcję, która będzie wywoływana zamiast domyślnej metody <code>toString()</code>. Metoda <code>toString()</code> nie pobiera żadnych argumentów i powinna zwrócić łańcuch znaków. Utworzona przez użytkownika metoda <code>toString()</code> może zwracać dowolną wartość, ale najlepiej, by przekazywała użyteczne informacje na temat obiektu.</p> + +<p>Poniższy kod definiuje typ obiektowy <code>Pies</code> i tworzy obiekt <code>jakisPies</code> typu <code>Pies</code>:</p> + +<pre class="brush: js">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");</pre> + +<p>Jeśli wywołana zostanie metoda <code>toString</code> tego obiektu, zwrócona zostanie domyślna wartość odziedziczona po <code>Object</code>:</p> + +<pre class="brush: js">jakisPies.toString(); // zwraca [object Object] +</pre> + +<p>Poniższy kod tworzy funkcję <code>piesToString</code>, która to funkcja będzie przesłaniać domyślną metodę <code>toString</code>. Funkcja ta tworzy łańcuch znaków zawierający każdą własność; budowany łańcuch będzie postaci "<code>własność = wartość;</code>".</p> + +<pre class="brush: js">function piesToString() { + var ret = "Pies " + this.nazwa + " to: [\n"; + for (var prop in this) + ret += " " + prop + " = " + this[prop] + ";\n"; + return ret + "]"; +} +</pre> + +<p>Poniższy kod przypisuje zdefiniowaną powyżej funkcję do metody <code>toString</code> obiektów typu obiektowego Pies:</p> + +<pre class="brush: js">Pies.prototype.toString = piesToString; +</pre> + +<p>Dzięki powyższemu kodowi za każdym razem, kiedy <code>jakisPies</code> używany jest w kontekście łańcucha znaków, interpreter JavaScriptu automatycznie wywołuje funkcję <code>piesToString</code>, która zwraca poniższy łańcuch:</p> + +<pre>Pies Szarik to: [ + nazwa = Szarik; + rasa = owczarek niemiecki; + wiek = 5; + plec = samiec; +] +</pre> + +<p>Metoda <code>toString</code> danego obiektu jest zazwyczaj wywoływana przez interpreter JavaScriptu, ale można ją wywołać samodzielnie, jak poniżej:</p> + +<pre class="brush: js">var piesString = jakisPies.toString(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> 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 +--- +<p>{{jsRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość podstawową danego obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>object</var>.valueOf()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>JavaScript wywołuje metodę <code>valueOf()</code> by przekonwertować obiekt do wartości podstawowej. Metodę <code>valueOf</code> rzadko wykorzystuje się w pisanych programach, zazwyczaj JavaScript wywołuje ją automatycznie, kiedy oczekując wartości podstawowej napotka obiekt.</p> + +<p>Domyślnie metoda <code>valueOf()</code> 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, <code>valueOf()</code> zwraca sam obiekt, który jest wyświetlany jako:</p> + +<pre>[object Object] +</pre> + +<p>We własnych programach można oczywiście używać metody <code>valueOf</code> do konwersji obiektów na wartości podstawowe. Kiedy użytkownik tworzy własne obiekty, może przesłonić metodę <code>valueOf()</code> własną wersją.</p> + +<h3 id="Przes.C5.82anianie_metody_valueOf_dla_w.C5.82asnych_obiekt.C3.B3w" name="Przes.C5.82anianie_metody_valueOf_dla_w.C5.82asnych_obiekt.C3.B3w">Przesłanianie metody <code>valueOf</code> dla własnych obiektów</h3> + +<p>Można utworzyć funkcję, która będzie wywoływana zamiast domyślnej metody <code>valueOf</code>. Taka funkcja nie powinna mieć argumentów.</p> + +<p>Załóżmy, że mamy typ obiektowy <code>MojTypLiczbowy</code> i chcemy utworzyć dla niego metodę <code>valueOf</code>. Poniższy kod przypisuje zdefiniowaną przez użytkownika funkcję do metody <code>valueOf</code> obiektu:</p> + +<pre class="brush: js">MojTypLiczbowy.prototype.valueOf = new Function(tekstFunkcji); +</pre> + +<p>Dzięki powyższej instrukcji za każdym razem, kiedy obiekt typu <code>MojTypLiczbowy</code> jest używany w kontekście wartości prostej, JavaScript automatycznie wywoła funkcję zdefiniowaną powyżej.</p> + +<p>Metoda <code>valueOf</code> obiektu jest zwykle wywoływana przez interpreter JavaScriptu, ale można ją wywołać samodzielnie:</p> + +<pre class="brush: js">mojaLiczba.valueOf(); +</pre> + +<h3 id="Uwaga" name="Uwaga">Uwaga</h3> + +<p>Obiekty używane w kontekście łańcucha znaków konwertowane są przy użyciu metody <code><a href="/pl/docs/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Object/toString">toString</a></code>, co różni się od konwertowania obiektów <code>String</code> do prostych łańcuchów znaków poprzez <code>valueOf</code>. Wszystkie obiekty posiadają konwersję do łańcucha znaków, choćby <code>[object + <i>typ</i> + ]</code>. Ale wiele obiektów nie posiada domyślnej konwersji do liczby, wartości logicznej lub funkcji.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> + <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> +</ul> |