diff options
Diffstat (limited to 'files/pl/web/javascript/reference/global_objects')
243 files changed, 22660 insertions, 0 deletions
diff --git a/files/pl/web/javascript/reference/global_objects/array/concat/index.html b/files/pl/web/javascript/reference/global_objects/array/concat/index.html new file mode 100644 index 0000000000..f740400903 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/concat/index.html @@ -0,0 +1,72 @@ +--- +title: Array.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/Array/concat +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat +original_slug: Web/JavaScript/Referencje/Obiekty/Array/concat +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca nową tablicę złożoną z tablicy, na której wywołano tę metodę, połączonej z innymi podanymi tablicami lub wartościami.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>var <var>new_array</var> = <var>old_array</var>.concat(wartość1[, wartość2[, ...[, wartośćN]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>wartość + <i>N</i> + </code> </dt> + <dd>Tablice lub wartości do dołączenia do tablicy, na której wywołana została metoda <code>concat</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>concat</code> nie zmienia oryginalnej tablicy, lecz zwraca jej kopię "o jednym poziomie głębokości" zawierającą te same elementy wspólne co pierwotna tablica. Elementy oryginalnej tablicy są kopiowane do nowej tablicy następująco:</p> + +<ul> + <li>referencje do obiektów (a nie faktyczne obiekty): <code>concat</code> kopiuje referencje do obiektów do nowej tablicy. Zarówno pierwotna, jak i nowa tablica odnoszą się więc do tych samych obiektów. Oznacza to, że jeżeli wskazany obiekt jest modyfikowany, zmiany są widoczne w obydwu tablicach (nowej i starej).</li> +</ul> + +<ul> + <li>Łańcuchy znaków i liczby (ale nie obiekty {{jsxref("String")}} i {{jsxref("Number")}} ): <code>concat</code> kopiuje wartości łańcuchów znaków i liczb do nowej tablicy.</li> +</ul> + +<p>Operacje wykonywane na nowej tablicy nie wpłyną w żaden sposób na oryginalną tablicę i na odwrót.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_dw.C3.B3ch_tablic" name="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_dw.C3.B3ch_tablic">Przykład: Połączenie dwóch tablic</h3> + +<p>Następujący kod łączy dwie tablice:</p> + +<pre class="brush: js">alpha = new Array("a", "b", "c"); +numeric = new Array(1, 2, 3); +alphaNumeric = alpha.concat(numeric); // tworzy tablicę ["a", "b", "c", 1, 2, 3] +</pre> + +<h3 id="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_trzech_tablic" name="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_trzech_tablic">Przykład: Połączenie trzech tablic</h3> + +<p>Następujący kod łączy trzy tablice:</p> + +<pre class="brush: js">num1 = [1, 2, 3]; +num2 = [4, 5, 6]; +num3 = [7, 8, 9]; +nums = num1.concat(num2,num3) // tworzy tablicę [1, 2, 3, 4, 5, 6, 7, 8, 9] +</pre> + +<h3 id="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_warto.C5.9Bci_z_tablic.C4.85" name="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_warto.C5.9Bci_z_tablic.C4.85">Przykład: Połączenie wartości z tablicą</h3> + +<p>Następujący kod łączy trzy wartości z tablicą:</p> + +<pre class="brush: js">alpha = ['a', 'b', 'c']; +alphaNumeric = alpha.concat(1, 2, 3); // tworzy tablicę ["a", "b", "c", 1, 2, 3] +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/array/copywithin/index.html b/files/pl/web/javascript/reference/global_objects/array/copywithin/index.html new file mode 100644 index 0000000000..af9f1b91f7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/copywithin/index.html @@ -0,0 +1,182 @@ +--- +title: Array.prototype.copyWithin() +slug: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Metodă + - Peototyp + - Prototype + - Reference + - Referencja + - Tablica + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +original_slug: Web/JavaScript/Referencje/Obiekty/Array/copyWithin +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>copyWithin()</strong></code> tworzy kopie płytkie części tablicy w innej części tej samej tablicy i zwraca tę tablicę bez modyfikowania jej długości.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-copywithin.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><var>arr</var>.copyWithin(<var>cel[, start[, koniec]]</var>) +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>cel</code></dt> + <dd>Indeks (liczony od zera), do którego ma zostać skopiowana sekwencja. Jeśli wartość <code>target</code> będzie ujemna, pozycja będzie liczona od końca tablicy.</dd> + <dd>Jeśli <code>cel</code> jest większy lub równy <code>arr.length</code>, nic nie zostanie skopiowane. Jeśli wartość <code>cel</code> będzie większa niż <code>start</code>, kopiowana sekwencja zostanie przycięta tak, aby pasować do <code>arr.length</code>.</dd> + <dt><code>start</code> {{optional_inline}}</dt> + <dd>Indeks (liczony od zera), określający pozycję początkową sekwencji, która ma zostać skopiowana. Jeśli wartość ta będzie ujemna, <code>start</code> będzie liczony od końca tablicy.</dd> + <dd>Jeśli wartość <code>start</code> nie jest podana, <code>copyWithin</code> skopiuje sekwencję zaczynając od indeksu <code>0</code>. </dd> + <dt><code>koniec</code> {{optional_inline}}</dt> + <dd>Indeks (liczony od zera), określający pozycję końcową sekwencji, która ma zostać skopiowana, z wyłączeniem wartości pod indeksem <code>koniec</code>. Jeśli wartość ta będzie ujemna, <code>koniec</code> będzie liczony od końca tablicy.</dd> + <dd>Jeśli wartość <code>koniec</code> nie jest podana, <code>copyWithin</code> skopiuje sekwencję do ostatniego indeksu (domyślnie do <code>arr.length</code>).</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Zmodyfikowana tablica.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda <code>copyWithin</code> działa jak <code>memmove</code> w C/C++ i jest wysokowydajną metodą przesuwania wartości w obiektach {{jsxref("Array")}}. Dotyczy to szczególnie metody o tej samej nazwie {{jsxref("TypedArray/copyWithin", "TypedArray")}}. Sekwencja jest kopiowana i wklejana w jednej operacji, a wklejona sekwencja będzie zawierać skopiowane wartości nawet wtedy, gdy zakres żródłowy (kopiowania) i docelowy (wklejania) nakładają się na siebie.</p> + +<p>Funkcja <code>copyWithin</code> jest celowo <em>ogólna</em>, nie wymaga, by jej wartość <code>this</code> była obiektem typu {{jsxref("Array")}}.</p> + +<p>Metoda <code>copyWithin</code> jest modyfikowalna. Nie zmienia długości <code>this</code>, ale zmienia zawartość <code>this</code> i tworzy nowe własności, jeśli jest to konieczne.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js notranslate">if (!Array.prototype.copyWithin) { + Object.defineProperty(Array.prototype, 'copyWithin', { + value: function(target, start/*, end*/) { + // Kroki 1-2. + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + var O = Object(this); + + // Kroki 3-5. + var len = O.length >>> 0; + + // Kroki 6-8. + var relativeTarget = target >> 0; + + var to = relativeTarget < 0 ? + Math.max(len + relativeTarget, 0) : + Math.min(relativeTarget, len); + + // Kroki 9-11. + var relativeStart = start >> 0; + + var from = relativeStart < 0 ? + Math.max(len + relativeStart, 0) : + Math.min(relativeStart, len); + + // Kroki 12-14. + var end = arguments[2]; + var relativeEnd = end === undefined ? len : end >> 0; + + var final = relativeEnd < 0 ? + Math.max(len + relativeEnd, 0) : + Math.min(relativeEnd, len); + + // Krok 15. + var count = Math.min(final - from, len - to); + + // Kroki 16-17. + var direction = 1; + + if (from < to && to < (from + count)) { + direction = -1; + from += count - 1; + to += count - 1; + } + + // Krok 18. + while (count > 0) { + if (from in O) { + O[to] = O[from]; + } else { + delete O[to]; + } + + from += direction; + to += direction; + count--; + } + + // Krok 19. + return O; + }, + configurable: true, + writable: true + }); +}</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_copyWithin">Użycie copyWithin</h3> + +<pre class="brush: js notranslate">[1, 2, 3, 4, 5].copyWithin(-2) +// [1, 2, 3, 1, 2] + +[1, 2, 3, 4, 5].copyWithin(0, 3) +// [4, 5, 3, 4, 5] + +[1, 2, 3, 4, 5].copyWithin(0, 3, 4) +// [4, 2, 3, 4, 5] + +[1, 2, 3, 4, 5].copyWithin(-2, -3, -1) +// [1, 2, 3, 3, 4] + +[].copyWithin.call({długość: 5, 3: 1}, 0, 3) +// {0: 1, 3: 1, długość: 5} + +// ES2015 Typowane tablice są podklasami zwykłej tablicy (Array) +var i32a = new Int32Array([1, 2, 3, 4, 5]) + +i32a.copyWithin(0, 2) +// Int32Array [3, 4, 5, 4, 5] + +// Na platformach niewspierających jeszcze ES 2015: +[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4); +// Int32Array [4, 2, 3, 4, 5] +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.copyWithin")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Array")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/entries/index.html b/files/pl/web/javascript/reference/global_objects/array/entries/index.html new file mode 100644 index 0000000000..f5c7a6d596 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/entries/index.html @@ -0,0 +1,78 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Array/entries +translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries +original_slug: Web/JavaScript/Referencje/Obiekty/Array/entries +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>entries()</strong></code> zwraca obiekt <code><strong>Iteratora</strong></code> który zawiera parę klucz/wartość dla każdej pozycji w tablicy.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-entries.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>a</var>.entries()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator {{jsxref("Tablicy")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_w_pętli_for…of">Użycie w pętli <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for…of</a></h3> + +<pre class="brush:js">var a = ['a', 'b', 'c']; +var iterator = a.entries(); + +for (let e of iterator) { + console.log(e); +} +// [0, 'a'] +// [1, 'b'] +// [2, 'c'] +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_w_przeglądarkach">Kompatybilność w przeglądarkach</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.entries")}}</p> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.values()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/every/index.html b/files/pl/web/javascript/reference/global_objects/array/every/index.html new file mode 100644 index 0000000000..707e7bda84 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/every/index.html @@ -0,0 +1,90 @@ +--- +title: Array.prototype.every() +slug: Web/JavaScript/Reference/Global_Objects/Array/every +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/every +original_slug: Web/JavaScript/Referencje/Obiekty/Array/every +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Metoda <span style="line-height: 23.3333339691162px;"> </span><code style="font-style: normal; line-height: 23.3333339691162px;"><strong>every() </strong></code>sprawdza, czy wszystkie elementy w tablicy przechodzą test zrealizowany w postaci dostarczonej funkcji.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.every(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja sprawdzająca dla każdego elementu. Zawiera trzy argumenty.<br> + <strong style="font-family: consolas,monaco,andale mono,monospace; font-weight: bold; line-height: 23.3333339691162px;">currentValue<br> + </strong>Bieżący element przetwarzany w tablicy</dd> + <dt> <strong style="font-family: consolas,monaco,andale mono,monospace; font-weight: bold; line-height: 23.3333339691162px;">index</strong></dt> + <dd> + <p> Indeks bieżacego elementu przetwarzanego w tablicy</p> + + <p> <strong>array</strong><br> + Tablica na której została wywołana funkcja</p> + </dd> + <dt><code>thisObject</code></dt> + <dd>Opcjonalnie. Obiekt, na który będzie wskazywał <code>this</code>, gdy wykonana zostanie funkcja zwrotna <code>callback</code>. </dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>every</code> wykonuje dostarczoną funkcję <code>callback</code> raz dla każdego elementu tablicy do momentu, kiedy znajdzie taki element, dla którego funkcja <code>callback</code> zwróci wartość <code>false</code>. Jeżeli taki element zostanie znaleziony, test zostanie przerwany, a metoda <code>every</code> zwróci wartość <code>false</code>. W przeciwnym wypadku (<code>callback</code> zwraca wartość <code>true</code> dla wszystkich elementów) <code>every</code> zwróci <code>true</code>. Funkcja <code>callback</code> wywoływana jest jedynie dla indeksów tablicy, którym została przypisana wartość; nie jest wywoływana dla indeksów, które zostały usunięte i tych, którym nigdy nie została przypisana żadna wartość.</p> + +<p>Funkcja <code>callback</code> jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.</p> + +<p>Jeśli parametr <code>thisObject</code> został dostarczony do metody <code>every</code>, będzie on wskazywany przez <code>this</code> dla każdego wywołania funkcji <code>callback</code>. W przypadku, gdy nie został on przekazany lub jego wartość jest równa <code>null</code>, <code>this</code> będzie się odnosić do obiektu globalnego połączonego z funkcją <code>callback</code>.</p> + +<p>Metoda <code>every</code> nie modyfikuje tablicy, na której jest wywoływana.</p> + +<p>Zakres elementów przetwarzanych przez <code>every</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy dołączone do tablicy po momencie wywołania <code>every</code> są testowane przez <code>callback</code>. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji <code>callback</code> odpowiada wartości w momencie, w którym <code>every</code> się o nie zwróci; metoda <code>every</code> nie upomina się o elementy usunięte.</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>every</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>every</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.every) +{ + Array.prototype.every = function(fun /*, thisp*/) + { + var len = this.length; + if (typeof fun != "function") + throw new TypeError(); + + var thisp = arguments[1]; + for (var i = 0; i < len; i++) + { + if (i in this && + !fun.call(thisp, this[i], i, this)) + return false; + } + + return true; + }; +} +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy">Przykład: Sprawdzanie rozmiaru wszystkich elementów tablicy</h3> + +<p>Następujący przykład sprawdza, czy wszystkie elementy w tablicy są większe niż 10.</p> + +<pre class="brush: js">function isBigEnough(element, index, array) { + return (element >= 10); +} +passed = [12, 5, 8, 130, 44].every(isBigEnough); +// fałsz +passed = [12, 54, 18, 130, 44].every(isBigEnough); +// prawda +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/array/fill/index.html b/files/pl/web/javascript/reference/global_objects/array/fill/index.html new file mode 100644 index 0000000000..1251451837 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/fill/index.html @@ -0,0 +1,186 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Reference/Global_Objects/Array/fill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill +original_slug: Web/JavaScript/Referencje/Obiekty/Array/fill +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>fill() </strong>uzupełnia wszystkie elementy tablicy, zaczynając od indeksu początkowego</code> <strong>(start)</strong> aż po indeks końcowy <strong>(end)</strong> statyczną wartością <strong>(value)</strong>.</p> + +<p>{{EmbedInteractiveExample("pages/js/array-fill.html")}}<br> + Źródło tego przykładu jest przechowywane w repozytorium na GitHub. Jeśli chciałbyś dodać coś od siebie do projektu interaktywnych przykładów, sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij pull request.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.fill(<var>value</var>[, <var>start<var> = 0[, <var>end</var> = this.length]])</var></var></code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Wartość, którą wypełniana będzie tablica.</dd> + <dt><code>start</code></dt> + <dd>Opcjonalnie. Indeks początkowy.</dd> + <dt><code>end</code></dt> + <dd>Opcjonalnie. Indeks końcowy.</dd> + <dt> + <h3 id="Wartość_zwracana">Wartość zwracana</h3> + + <p>Zmodyfikowana tablica.</p> + </dt> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Przedział elementów do wypełnienia to: [<code>start</code>, <code>end</code>).</p> + +<p><code>Metoda</code><strong><code> fill</code></strong> przyjmuje do trzech parametrów <code>value</code>, <code>start</code> i <code>end</code>. Argumenty <code>start i</code> <code>end</code> są opcjonalne i przyjmują, odpowiednio, <code>0</code> i długość (<code>length)</code> obiektu <code>this</code>.</p> + +<p>Jeżeli parametr <code>start</code> jest ujemny, jest to traktowane jako <code>length+start</code> gdzie <code>length</code> jest liczbą elementów tablicy. Jeżeli parametr <code>end</code> jest negatywny, jest to traktowane jako <code>length+end</code>. </p> + +<p>Funkcja<strong> fill</strong> została świdomie zaprojektowana jako generyczna, przez co nie wymaga, by wartość <font face="Consolas, Liberation Mono, Courier, monospace">this</font> była obiektem typu Array.</p> + +<p>Metoda<strong> fill </strong>jest zmienna (ang. mutalbe), metoda ta nie zwraca kopii this, a oryginalny obiekt po modyfikacjach.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">[1, 2, 3].fill(4); // [4, 4, 4] +[1, 2, 3].fill(4, 1); // [1, 4, 4] +[1, 2, 3].fill(4, 1, 2); // [1, 4, 3] +[1, 2, 3].fill(4, 1, 1); // [1, 2, 3] +[1, 2, 3].fill(4, -3, -2); // [4, 2, 3] +[1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3] +[].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3} +//Obiekty przez referencję +var arr = Array(3).fill({}) // [{}, {}, {}]; +arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }] +</pre> + +<p> </p> + +<p> </p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.fill) { + Array.prototype.fill = function(value) { + + // Steps 1-2. + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + var O = Object(this); + + // Steps 3-5. + var len = O.length >>> 0; + + // Steps 6-7. + var start = arguments[1]; + var relativeStart = start >> 0; + + // Step 8. + var k = relativeStart < 0 ? + Math.max(len + relativeStart, 0) : + Math.min(relativeStart, len); + + // Steps 9-10. + var end = arguments[2]; + var relativeEnd = end === undefined ? + len : end >> 0; + + // Step 11. + var final = relativeEnd < 0 ? + Math.max(len + relativeEnd, 0) : + Math.min(relativeEnd, len); + + // Step 12. + while (k < final) { + O[k] = value; + k++; + } + + // Step 13. + return O; + }; +} +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.fill', 'Array.prototype.fill')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definicja początkowa</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funckjonalność</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Wsparcie podstawowe</td> + <td>{{CompatChrome("36")}} [1]</td> + <td>{{CompatGeckoDesktop("31")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("7.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>Wsparcie podstawowe</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("31")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] The feature is available behind a preference. In chrome://flags, activate the entry “Enable Experimental JavaScript”.</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("TypedArray.prototype.fill()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/filter/index.html b/files/pl/web/javascript/reference/global_objects/array/filter/index.html new file mode 100644 index 0000000000..6ec5d0cdc5 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/filter/index.html @@ -0,0 +1,151 @@ +--- +title: Array.prototype.filter() +slug: Web/JavaScript/Reference/Global_Objects/Array/filter +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter +original_slug: Web/JavaScript/Referencje/Obiekty/Array/filter +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong>filter()</strong> tworzy nową tablicę z wszystkimi elementami, które przechodzą test określony w postaci funkcji.</p> + +<pre class="brush: js">function isBigEnough(value) { + return value >= 10; +} + +var filtered = [12, 5, 8, 130, 44].filter(isBigEnough); +// filtered is [12, 130, 44] +</pre> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre><var>var newArray = arr</var>.filter(<var>callback(element[, index[, array]])</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja sprawdzająca każdy element tablicy. Funkcja powinna zwrócić <code>true,</code> aby zatrzymać element lub <code>false,</code> aby odrzucić element. Funkcja przyjmuje trzy argumenty:</dd> + <dd> + <dl> + <dt><code>element</code></dt> + <dd>Element tablicy do przetworzenia.</dd> + <dt><code>index</code></dt> + <dd>Numer indeksu procesowanego elementu tablicy.</dd> + <dt><code>array</code></dt> + <dd>Tablica na której <code>filter</code> został wywołany.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Obiekt na który będzie wskazywał <code>this</code>, przy wywoływaniu funkcji <code>callback</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>filter</code> wykonuje dostarczoną funkcję <code>callback</code> dla każdego elementu tablicy, tworząc nową tablicę z wszystkich tych elementów, dla których funkcja <code>callback</code> zwróciła wartość <code>true</code>. Wynikowa tablica jest zwarta; wartości, które nie przechodzą testu funkcji <code>callback,</code> są zwyczajnie pomijane i nie są przypisywane do indeksów nowej tablicy.</p> + +<p>Funkcja <code>callback</code> jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.</p> + +<p>Jeśli parametr <code>thisObject</code> został dostarczony do metody <code>filter</code>, będzie on wskazywany przez <code>this</code> dla każdego wywołania funkcji<code>callback</code>. W przypadku gdy nie został on przekazany lub jego wartość jest równa <code>null</code>, <code>this</code> będzie się odnosić do obiektu globalnego połączonego z funkcją <code>callback</code>.</p> + +<p>Metoda <code>filter</code> nie modyfikuje tablicy, na której jest wywoływana.</p> + +<p>Zakres elementów przetwarzanych przez <code>filter</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy dołączone do tablicy po momencie wywołania <code>filter</code> są testowane przez <code>callback</code>. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji <code>callback</code> odpowiada wartości w momencie, w którym <code>filter</code> się o nie zwróci; metoda <code>filter</code> nie upomina się o elementy usunięte.</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>filter</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>filter</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.filter) +{ + Array.prototype.filter = function(fun /*, thisp*/) + { + var len = this.length; + if (typeof fun != "function") + throw new TypeError(); + + var res = new Array(); + var thisp = arguments[1]; + for (var i = 0; i < len; i++) + { + if (i in this) + { + var val = this[i]; // in case fun mutates this + if (fun.call(thisp, val, i, this)) + res.push(val); + } + } + + return res; + }; +} +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Odfiltrowanie_wszystkich_ma.C5.82ych_warto.C5.9Bci" name="Przyk.C5.82ad:_Odfiltrowanie_wszystkich_ma.C5.82ych_warto.C5.9Bci">Przykład: Odfiltrowanie wszystkich małych wartości</h3> + +<p>Poniższy przykład używa <code>filter</code> by utworzyć przefiltrowaną tablicę, z której usunięto wszystkie elementy których wartość wynosi mniej niż 10.</p> + +<pre class="brush: js">function isBigEnough(element, index, array) { + return (element >= 10); +} +filtered = [12, 5, 8, 130, 44].filter(isBigEnough); +</pre> + +<h2 id="Kompatybilność_z_przeglądarkami" style="margin-bottom: 20px; font-size: 2.14285714285714rem;">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table" style="border-color: transparent;"> + <tbody> + <tr> + <th style="line-height: 16px;">Feature</th> + <th style="line-height: 16px;">Chrome</th> + <th style="line-height: 16px;">Firefox (Gecko)</th> + <th style="line-height: 16px;">Internet Explorer</th> + <th style="line-height: 16px;">Opera</th> + <th style="line-height: 16px;">Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table" style="border-color: transparent;"> + <tbody> + <tr> + <th style="line-height: 16px;">Feature</th> + <th style="line-height: 16px;">Android</th> + <th style="line-height: 16px;">Chrome for Android</th> + <th style="line-height: 16px;">Firefox Mobile (Gecko)</th> + <th style="line-height: 16px;">IE Mobile</th> + <th style="line-height: 16px;">Opera Mobile</th> + <th style="line-height: 16px;">Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.8")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/pl/web/javascript/reference/global_objects/array/find/index.html b/files/pl/web/javascript/reference/global_objects/array/find/index.html new file mode 100644 index 0000000000..520be8939f --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/find/index.html @@ -0,0 +1,279 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Reference/Global_Objects/Array/find +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Metodă + - Prototype + - Referencja + - Tablica + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/find +original_slug: Web/JavaScript/Referencje/Obiekty/Array/find +--- +<p>{{JSRef}}<br> + Metoda <strong>find()</strong> zwraca pierwszy element tablicy, który spełnia warunek podanej funkcji testującej.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-find.html","shorter")}}</div> + + + +<ul> + <li>Jeśli potrzebujesz <strong>indeksu</strong> znalezionego elementu w tablicy, użyj {{jsxref("Array.findIndex", "findIndex()")}}.</li> + <li>Jesli potrzebujesz <strong>indeksu wartości</strong>, użyj {{jsxref("Array.prototype.indexOf()")}}. (Jest to podobne do {{jsxref("Array.findIndex", "findIndex()")}}, ale sprawdza każdy element tablicy pod kątem równości z zadaną wartością, zamiast używać funkcji testującej.)</li> + <li>Jeśli chcesz sprawdzić, czy wartość <strong>istnieje</strong> w tablicy, użyj {{jsxref("Array.prototype.includes()")}}. Tutaj także sprawdzana jest równość elementu z zadaną wartością zamiast używania funkcji testującej.</li> + <li>Jeśli chcesz znaleźć dowolny element, który spełnia warunek funkcji testującej, użyj {{jsxref("Array.prototype.some()")}}.</li> +</ul> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.find(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><em><code>callback</code></em></dt> + <dd>Funkcja do wykonania przy każdym elemencie tablicy, przyjmująca trzy wartości: + <dl> + <dt><em><code>element</code></em></dt> + <dd>Element obecnie przetwarzany przez funkcję.</dd> + <dt><em><code>index</code></em></dt> + <dd>Indeks obecnie przetwarzanego elementu.</dd> + <dt><em><code>array</code></em></dt> + <dd>Tablica, na której wywołano funkcję <code>find</code>.</dd> + </dl> + </dd> + <dt><em><code>thisArg</code></em></dt> + <dd>Opcjonalny. Obiekt, który będzie się znajdował pod <code>this</code> w czasie wykonywania funkcji <code>callback</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p><strong>Wartość pierwszego elementu</strong> w tablicy, spełniającego warunek funkcji testującej.<br> + W przeciwnym wypadku: {{jsxref("undefined")}}.</p> + +<h2 id="Description" name="Description">Opis</h2> + +<p>Metoda <code>find</code> wywołuje funkcję <code><var>callback</var></code> raz dla każdego indeksu tablicy, dopóki nie znajdzie takiego elementu, dla którego <em><code>callback</code></em> zwraca wartość <code>true</code>. Wówczas <code>find</code> natychmiast zwraca wartość tego elementu. W przeciwnym razie, gdy żaden z elementów nie spełni warunków funkcji testującej, <code>find</code> zwraca {{jsxref("undefined")}}.</p> + +<p><code><var>callback</var></code> jest wywoływany dla każdego indeksu tablicy, nie tylko tych z przypisanymi wartościami. Oznacza to, że może to być mniej efektywne w przypadku tablic rzadkich, w porównaniu z metodami, które odwiedzają jedynie indeksy z przypisanymi wartościami.</p> + +<p>Jeśli parametr <code><var>thisArg</var></code>jest przekazany do <code>find</code>, będzie użyty jako wartość <code>this</code> w każdym wywołaniu <code><var>callback</var></code>. Jeśli parametr ten nie jest przekazany, używana jest wartość {{jsxref("undefined")}}.</p> + +<p>Metoda <code>find</code> nie modyfikuje tablicy, na której jest wywoływana, ale może to robić funkcja przekazana do <code><var>callback</var></code>. Jeśli tak się stanie, elementy przetwarzane przez <code>find</code> są ustawiane <em>przed</em> pierwszym wywołaniem funkcji <code><em>callback</em></code>. Zatem:</p> + +<ul> + <li><code><var>callback</var></code> nie odwiedzi żadnych elementów dodanych do tablicy po rozpoczęciu wywowłania <code>find</code>.</li> + <li>Jeśli istniejący, jeszcze nieodwiedzony element tablicy jest zmieniony przez <code><em>callback</em></code>, jego wartość przekazana do <code><em>callback</em></code> będzie wartością w momencie, w którym <code>find</code> odwiedza indeks tego elementu.</li> + <li>Elementy {{jsxref("delete", "usunięte")}} dalej są odwiedzane.</li> +</ul> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Metoda ta została dodana do specyfikacji ECMAScript 2015 i może nie być jeszcze dostępna we wszystkich implementacjach języka JavaScript. Niemniej jednak, możesz użyć <em>polyfill</em> z <code>Array.prototype.find</code> z poniższym fragmentem kodu:</p> + +<pre class="brush: js notranslate">// https://tc39.github.io/ecma262/#sec-array.prototype.find +if (!Array.prototype.find) { + Object.defineProperty(Array.prototype, 'find', { + value: function(predicate) { + // 1. Let O be ? ToObject(this value). + if (this == null) { + throw TypeError('"this" is null or not defined'); + } + + var o = Object(this); + + // 2. Let len be ? ToLength(? Get(O, "length")). + var len = o.length >>> 0; + + // 3. If IsCallable(predicate) is false, throw a TypeError exception. + if (typeof predicate !== 'function') { + throw TypeError('predicate must be a function'); + } + + // 4. If thisArg was supplied, let T be thisArg; else let T be undefined. + var thisArg = arguments[1]; + + // 5. Let k be 0. + var k = 0; + + // 6. Repeat, while k < len + while (k < len) { + // a. Let Pk be ! ToString(k). + // b. Let kValue be ? Get(O, Pk). + // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)). + // d. If testResult is true, return kValue. + var kValue = o[k]; + if (predicate.call(thisArg, kValue, k, o)) { + return kValue; + } + // e. Increase k by 1. + k++; + } + + // 7. Return undefined. + return undefined; + }, + configurable: true, + writable: true + }); +} +</pre> + +<p>Jeśli potrzebujesz wspierać naprawdę przestarzałe silniki JavaScript, które nie wspierająt <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code>, najlepiej w ogóle nie używać <em>polyfill</em> z <code>Array.prototype</code>, gdyż nie da się go uczynić niewyliczeniowym.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Wyszukiwanie_obiektu_w_tablicy_na_podstawie_jednej_z_jego_własności">Wyszukiwanie obiektu w tablicy na podstawie jednej z jego własności</h3> + +<pre class="brush: js notranslate">const inventory = [ + {name: 'apples', quantity: 2}, + {name: 'bananas', quantity: 0}, + {name: 'cherries', quantity: 5} +]; + +function isCherries(fruit) { + return fruit.name === 'cherries'; +} + +console.log(inventory.find(isCherries)); +// { name: 'cherries', quantity: 5 }</pre> + +<h4 id="Użycie_funkcji_strzałkowej_i_destrukturyzacja">Użycie funkcji strzałkowej i destrukturyzacja</h4> + +<pre class="brush: js notranslate">const inventory = [ + {name: 'apples', quantity: 2}, + {name: 'bananas', quantity: 0}, + {name: 'cherries', quantity: 5} +]; + +const result = inventory.find( ({ name }) => name === 'cherries' ); + +console.log(result) // { name: 'cherries', quantity: 5 }</pre> + +<h3 id="Wyszukiwanie_liczby_pierwszej_w_tablicy">Wyszukiwanie liczby pierwszej w tablicy</h3> + +<p>Poniższy przykładowy kod znajduje element tablicy będący liczbą pierwszą (lub zwraca {{jsxref("undefined")}} jeśli w tablicy nie ma liczby pierwszej):</p> + +<pre class="brush: js notranslate">function czyPierwsza(element, indeks, tablica) { + let start = 2; + while (start <= Math.sqrt(element)) { + if (element % start++ < 1) { + return false; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].find(czyPierwsza)); // undefined, nie znaleziono +console.log([4, 5, 8, 12].find(czyPierwsza)); // 5 +</pre> + +<p>Poniższy przykład pokazuje, że nieistniejące i usunięte elementy <em>są</em> odwiedzane, oraz że wartość przekazana do <code><em>callback</em></code> jest ich wartością, kiedy są odwiedzane:</p> + +<pre class="brush: js notranslate">// Zadeklaruj tablicę bez elementów przy indeksach 2, 3 i 4 +const array = [0,1,,,,5,6]; + +// Pokazuje wszystkie indeksy, nie tylko te z przypisanymi wartościami +array.find(function(value, index) { + console.log('Odwiedzono indeks ', index, ' z wartością ', value); +}); + +// Pokazuje wszystkie indeksy, włączając usunięte +array.find(function(value, index) { + // Usuń element 5 w pierwszej iteracji + if (index === 0) { + console.log('Usuwanie array[5] z wartością ', array[5]); + delete array[5]; + } + // Element 5 jest wciąż odwiedzany, choć został usunięty + console.log('Odwiedzono indeks ', index, ' z wartością ', value); +}); +// Oczekiwane wyjście: +// Usuwanie array[5] z wartością 5 +// Odwiedzono indeks 0 z wartością 0 +// Odwiedzono indeks 1 z wartością 1 +// Odwiedzono indeks 2 z wartością undefined +// Odwiedzono indeks 3 z wartością undefined +// Odwiedzono indeks 4 z wartością undefined +// Odwiedzono indeks 5 z wartością undefined +// Odwiedzono indeks 6 z wartością 6 +</pre> + +<h2 id="Specifications" name="Specifications">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.find', 'Array.prototype.find')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Pierwotna definicja.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Wsparcie przeglądarek</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("45.0")}}</td> + <td>{{CompatGeckoDesktop("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("7.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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>iOS 8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Zobacz też</h2> + +<ul> + <li>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/findindex/index.html b/files/pl/web/javascript/reference/global_objects/array/findindex/index.html new file mode 100644 index 0000000000..46d8e2a087 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/findindex/index.html @@ -0,0 +1,215 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Reference/Global_Objects/Array/findIndex +translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex +original_slug: Web/JavaScript/Referencje/Obiekty/Array/findIndex +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>findIndex()</strong></code> zwraca <strong>indeks</strong> pierwszego elementu tablicy, który spełnia kryteria postawione w funkcji testującej. W przeciwnym wypadku zwraca -1.</p> + +<pre class="brush: js">function isBigEnough(element) { + return element >= 15; +} + +[12, 5, 8, 130, 44].findIndex(isBigEnough); +// zostanie zwrócony indeks czwartego elementu tablicy, +// który wynosi 3</pre> + +<p>Zobacz także metodę {{jsxref("Array.find", "find()")}}, która zwraca <strong>wartość</strong> znalezionego elementu, zamiast jego indeksu.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>arr</var>.findIndex(<var>callback</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja wywoływana dla każdej wartości w tablicy, bierze trzy argumenty:</dd> + <dd> + <dl> + <dt><code>element</code></dt> + <dd>Obecnie przetwarzany element z tablicy.</dd> + <dt><code>index</code></dt> + <dd>Indeks obecnie przetwarzanego elementu z tablicy.</dd> + <dt><code>array</code></dt> + <dd>Tablica, na której została wywołana funkcja <code>findIndex</code>.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcjonalny. Obiekt do użycia jako <code>this </code>w czasie wykonywania <code>callback.</code></dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Indeks elementu tablicy, który pomyślnie przeszedł test, jeśli taki nie zostanie znaleziony, zwraca <strong>-1</strong>.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda <code>findIndex</code> wykonuje funkcję <code>callback</code> dla każdego indeksu tablicy 0..długość - 1 (włącznie) w tablicy dopóki nie znajdzie tego, na którym funkcja <code>callback</code> zwróci prawdę. Jeśli taki element zostanie znaleziony, <code>findIndex</code> natychmiast zwraca indeks dla tej iteracji. Jeśli callback nigdy nie zwróci prawdy lub wielkość tablicy wynosi 0, <code>findIndex</code> zwróci -1. W przeciwieństwie do innych metod tablicowych takich jak Array#some, w tablicach rzadkich <code>callback </code><strong>jest</strong> wywoływany nawet dla indeksów niewystępujących w tablicy.</p> + +<p><code>callback </code>jest wywoływany z trzema argumentami: wartością elementu, indeksem elementu i przetwarzaną tablicą.</p> + +<p>Jeśli <code>thisArg</code> jest dołączony do <code>findIndex</code>, zostanie użyty jako <code>this</code> dla każdego wywołania . Jeśli nie, zostanie użyte {{jsxref("undefined")}}.</p> + +<p><code>findIndex </code>nie zmienia tablicy na której jest wywoływany.</p> + +<p>Zakres elementów przetwarzanych przez <code>findIndex</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy, które są dodane po rozpoczęciu wywołania funkcji <code>findIndex </code>nie będą przetworzone przez <code>callback</code>. Jeśli istniejący, nieodwiedzony element tablicy zostanie zmieniony przez <code>callback</code>, jego wartość przekazana do odwiedzającego <code>callback</code> będzie tą wartością z momentu, w którym <code>findIndex</code> odwiedzi indeks tego elementu, elementy usunięte, nie będą odwiedzone.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Znajdź_indeks_liczby_pierwszej_w_tablicy">Znajdź indeks liczby pierwszej w tablicy</h3> + +<p>Poniższy przykład znajduje indeks elementu w tablicy, który jest liczbą pierwszą (lub zwraca -1 jeśli nie w tablicy nie ma liczby pierwszej).</p> + +<pre class="brush: js">function isPrime(element, index, array) { + var start = 2; + while (start <= Math.sqrt(element)) { + if (element % start++ < 1) { + return false; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, nie znaleziono +console.log([4, 6, 7, 12].findIndex(isPrime)); // 2 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.findIndex +if (!Array.prototype.findIndex) { + Object.defineProperty(Array.prototype, 'findIndex', { + value: function(predicate) { + // 1. Let O be ? ToObject(this value). + if (this == null) { + throw new TypeError('"this" ma wartość null lub undefined'); + } + + var o = Object(this); + + // 2. Niech len będzie ? ToLength(? Get(O, "length")). + var len = o.length >>> 0; + + // 3. Jeśli IsCallable(predicate) jest fałszem, rzuć wyjątek TypeError. + if (typeof predicate !== 'function') { + throw new TypeError('predykat musi być funkcją'); + } + + // 4. Jeśli thisArg został podany, niech T będzie thisArg; w przeciwnym wypadku, niech T będzie undefined. + var thisArg = arguments[1]; + + // 5. Let k be 0. + var k = 0; + + // 6. Powtarzaj, dopóki k < len + while (k < len) { + // a. Niech Pk będzie ! ToString(k). + // b. Niech kValue będzie ? Get(O, Pk). + // c. Niech testResult będzie ToBoolean(? Call(predicate, T, « kValue, k, O »)). + // d. Jeśli testResult jest prawdą, zwróć k. + var kValue = o[k]; + if (predicate.call(thisArg, kValue, k, o)) { + return k; + } + // e. Zwiększ wartość k o 1. + k++; + } + + // 7. Return -1. + return -1; + } + }); +} +</pre> + +<p>Jeśli musisz wspierać naprawdę przestarzałe silniki JavaScript, które nie wspierają <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code>, najlepiej nie korzystać z metod <code>Array.prototype</code> w ogóle, ponieważ nie można sprawić by były niepoliczalne.</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">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.findindex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Podstawowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</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.0)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>Tak</td> + <td>Tak</td> + <td>{{CompatSafari("7.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>Edge</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>45.0</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/flat/index.html b/files/pl/web/javascript/reference/global_objects/array/flat/index.html new file mode 100644 index 0000000000..063a4f1084 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/flat/index.html @@ -0,0 +1,174 @@ +--- +title: Array.prototype.flat() +slug: Web/JavaScript/Reference/Global_Objects/Array/flat +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat +original_slug: Web/JavaScript/Referencje/Obiekty/Array/flat +--- +<div>{{JSRef}}</div> + +<div></div> + +<p>Metoda <code><strong>flat()</strong></code> tworzy nową tablicę ze wszystkich elementów, które są podtablicami, łącząc je rekursyjnie z podanym parametrem jak głęboko powinno nastąpić spłaszczenie.</p> + +<p class="hidden">\{{EmbedInteractiveExample("pages/js/array-flatten.html")}}</p> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>var newArray = arr</var>.flat(<em>[depth]</em>);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>depth</code> {{optional_inline}}</dt> + <dd>Parametr ten określa jak głęboko zagnieżdżona tablica powinna być spłaszczona. Wartość domyślna to 1.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowa tablica składająca się z połączonych elementów podtablic.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Spłaszczanie_zagnieżdżonych_tablic">Spłaszczanie zagnieżdżonych tablic</h3> + +<pre class="brush: js">var arr1 = [1, 2, [3, 4]]; +arr1.flat(); +// [1, 2, 3, 4] + +var arr2 = [1, 2, [3, 4, [5, 6]]]; +arr2.flat(); +// [1, 2, 3, 4, [5, 6]] + +var arr3 = [1, 2, [3, 4, [5, 6]]]; +arr3.flat(2); +// [1, 2, 3, 4, 5, 6] +</pre> + +<h3 id="Spłaszczanie_i_puste_miejsca_tablicy">Spłaszczanie i puste miejsca tablicy</h3> + +<p>Metoda flat() usuwa puste miejsca w tablicy:</p> + +<pre class="brush: js">var arr4 = [1, 2, , 4, 5]; +arr4.flat(); +// [1, 2, 4, 5] +</pre> + +<h2 id="Alternatywa">Alternatywa</h2> + +<h3 id="reduce_i_concat"><code>reduce</code> i <code>concat</code></h3> + +<pre class="brush: js">var arr1 = [1, 2, [3, 4]]; +arr1.flat(); + +//to flat single level array +arr1.reduce((acc, val) => acc.concat(val), []);// [1, 2, 3, 4] + +//or +const flatSingle = arr => [].concat(...arr); +</pre> + + + +<pre class="brush: js">//to enable deep level flatten use recursion with reduce and concat +var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]]; + +function flattenDeep(arr1) { + return arr1.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []); +} +flattenDeep(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4] +</pre> + + + +<pre class="brush: js">//non recursive flatten deep using a stack +var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]]; +function flatten(input) { + const stack = [...input]; + const res = []; + while (stack.length) { + // pop value from stack + const next = stack.pop(); + if (Array.isArray(next)) { + // push back array items, won't modify the original input + stack.push(...next); + } else { + res.push(next); + } + } + //reverse to restore input order + return res.reverse(); +} +flatten(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4] +</pre> + + + +<pre class="brush: js">//recursive flatten deep +function flatten(array) { + var flattend = []; + !(function flat(array) { + array.forEach(function(el) { + if (Array.isArray(el)) flat(el); + else flattend.push(el); + }); + })(array); + return flattend; +} +</pre> + + + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.flat) { + Array.prototype.flat = function(depth) { + var flattend = []; + (function flat(array, depth) { + for (let el of array) { + if (Array.isArray(el) && depth > 0) { + flat(el, depth - 1); + } else { + flattend.push(el); + } + } + })(this, Math.floor(depth) || 1); + return flattend; + }; +} +</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><a href="https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flat"><code>Array.prototype.flat</code> proposal</a></td> + <td>Finished (4)</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.flat")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Array.prototype.flatMap()")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("Array.prototype.reduce()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/foreach/index.html b/files/pl/web/javascript/reference/global_objects/array/foreach/index.html new file mode 100644 index 0000000000..612be4d2fb --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/foreach/index.html @@ -0,0 +1,105 @@ +--- +title: Array.prototype.forEach() +slug: Web/JavaScript/Reference/Global_Objects/Array/forEach +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach +original_slug: Web/JavaScript/Referencje/Obiekty/Array/forEach +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wykonuje dostarczoną funkcję jeden raz na każdy element tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.forEach(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja wykonywana dla każdego elementu.</dd> + <dt><code>thisArg</code></dt> + <dd>Obiekt na który będzie wskazywał <code>this</code>, gdy wykonana zostanie funkcja zwrotna <code>callback</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>forEach</code> wykonuje dostarczoną funkcje <code>callback</code> raz dla każdego elementu tablicy. Funkcja <code>callback</code> wywoływana jest jedynie dla indeksów tablicy, którym została przypisana wartość; nie jest wywoływana dla indeksów, które zostały usunięte i tych, którym nigdy nie została przypisana żadna wartość.</p> + +<p>Funkcja <code>callback</code> jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.</p> + +<p>Jeśli parametr <code>thisArg</code> został dostarczony do metody <code>forEach</code>, będzie on wskazywany przez <code>this</code> dla każdego wywołania funkcji <code>callback</code>. W przypadku, gdy nie został on przekazany lub jego wartość jest równa <code>null</code>, <code>this</code> będzie się odnosić do obiektu globalnego połączonego z funkcją <code>callback</code>.</p> + +<p>Metoda <code>forEach</code> nie modyfikuje tablicy na której jest wywołana.</p> + +<p>Zakres elementów przetwarzanych przez <code>forEach</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy dołączone do końca tablicy po momencie wywołania <code>forEach</code> nie są przesyłane do funkcji <code>callback</code>. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji <code>callback</code> odpowiada wartości w momencie, w którym <code>forEach</code> się o nie zwróci; elementy usunięte zanim zostaną odwiedzone nie zostaną odwiedzone. Jeżeli element już odwiedzony zostanie usunięty (nastąpi skrócenie tablicy), element tablicy w kolejności po obecnie odwiedzanym zostanie pominięty.</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>forEach</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>forEach</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.forEach) +{ + Array.prototype.forEach = function(fun /*, thisp*/) + { + var len = this.length; + if (typeof fun != "function") + throw new TypeError(); + + var thisp = arguments[1]; + for (var i = 0; i < len; i++) + { + if (i in this) + fun.call(thisp, this[i], i, this); + } + }; +} +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy" name="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy">Przykład: Drukowanie zawartości tablicy</h3> + +<p>Następujący kod drukuje linie dla każdego elementu w tablicy (i przyjmuje obecność funkcji <code>print</code> do wywołania!):</p> + +<pre class="brush: js">function printElt(element, index, array) { + print("[" + index + "] jest " + element); +} +[2, 5, 9].forEach(printElt); +// Wydrukuje: +// [0] jest 2 +// [1] jest 5 +// [2] jest 9 +</pre> + +<h3 id="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy_z_metod.C4.85_obiektu" name="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy_z_metod.C4.85_obiektu">Przykład: Drukowanie zawartości tablicy z metodą obiektu</h3> + +<p>Następujący kod tworzy prosty obiekt wypisujący i następnie stosuje metodę <code>writeln</code> do wypisania jednej linii na element w tablicy (przyjmuje obecność funkcji <code>print</code> do wywołania!):</p> + +<pre class="brush: js">var writer = { + sb: [], + write: function (s) { + this.sb.push(s); + }, + writeln: function (s) { + this.write(s + "\n"); + }, + toString: function () { + return this.sb.join(""); + } +}; + +[2, 5, 9].forEach(writer.writeln, writer); +print(writer.toString()); + +// Wydrukuje: +// 2 +// 5 +// 9 +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/array/from/index.html b/files/pl/web/javascript/reference/global_objects/array/from/index.html new file mode 100644 index 0000000000..049d4477d1 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/from/index.html @@ -0,0 +1,249 @@ +--- +title: Array.from() +slug: Web/JavaScript/Reference/Global_Objects/Array/from +translation_of: Web/JavaScript/Reference/Global_Objects/Array/from +original_slug: Web/JavaScript/Referencje/Obiekty/Array/from +--- +<div>{{JSRef}}</div> + +<p><code><strong>Array.from() </strong></code> metoda tworzy nową instację tablicy z obiektu podobnego do tablicy lub obiektu iterowalnego.</p> + +<p>W ES2015, składania klas dopuszcza dziedziczenie obu rodzajów klas: wbudowanych oraz zdefiniowanych przez programistę; w rezultacie, statyczne metody jak <code><strong>Array.from</strong></code> są "dziedziczone" przez klasę pochodną i tworzą nową instancję klasy pochodnej, a nie klasy <code><strong>Array</strong></code>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Array.from(arrayLike[, mapFn[, thisArg]]) +</code></pre> + +<h3 id="Argumenty">Argumenty</h3> + +<dl> + <dt><code>arrayLike</code></dt> + <dd>Obiekt podobny do tablicy lub iterowalny.</dd> + <dt><code>mapFn</code></dt> + <dd>Opcjonalny. Funkcja mapująca wywoływany z każdym elementem tablicy.</dd> + <dt><code>thisArg</code></dt> + <dd>Opcjonalny. Wartość używana jako <code>this</code> podczas wykonywania <code>mapFn</code>.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p><code>Array.from()</code> pozwala tworzyć tablicę z:</p> + +<ul> + <li>obiektu podobnego do tablicy (obiekt z właściwością <code>length</code> property oraz liczbowymi elementami)</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterable objects</a> (objects where you can get its elements, such as {{jsxref("Map")}} and {{jsxref("Set")}}).</li> +</ul> + +<p><code>Array.from()</code> has an optional parameter <code>mapFn</code>, which allows you to execute a {{jsxref("Array.prototype.map", "map")}} function on each element of the array (or subclass object) that is being created. More clearly,<code> Array.from(obj, mapFn, thisArg)</code> is the same as <code>Array.from(obj).map(mapFn, thisArg)</code>, except that it does not create an intermediate array. This is especially important for certain array subclasses, like <a href="/en-US/docs/Web/JavaScript/Typed_arrays">typed arrays</a>, since the intermediate array would necessarily have values truncated to fit into the appropriate type.</p> + +<p>The <code>length</code> property of the <code>from()</code> method is 1.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">// Array-like object (arguments) to Array +function f() { + return Array.from(arguments); +} + +f(1, 2, 3); +// [1, 2, 3] + + +// Any iterable object... +// Set +var s = new Set(["foo", window]); +Array.from(s); +// ["foo", window] + + +// Map +var m = new Map([[1, 2], [2, 4], [4, 8]]); +Array.from(m); +// [[1, 2], [2, 4], [4, 8]] + + +// String +Array.from("foo"); +// ["f", "o", "o"] + + +// Using an arrow function as the map function to +// manipulate the elements +Array.from([1, 2, 3], x => x + x); +// [2, 4, 6] + + +// Generate a sequence of numbers +Array.from({length: 5}, (v, k) => k); +// [0, 1, 2, 3, 4] + +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>Array.from</code> was added to the ECMA-262 standard in the 6th edition; as such it may not be present in other implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of <code>Array.from</code> in implementations that don't natively support it. This algorithm is exactly the one specified in ECMA-262, 6th edition, assuming <code>Object</code> and <code>TypeError</code> have their original values and that <code>callback.call</code> evaluates to the original value of {{jsxref("Function.prototype.call")}}. In addition, since true iterables can not be polyfilled, this implementation does not support generic iterables as defined in the 6th edition of ECMA-262.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 6, 22.1.2.1 +// Reference: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from +if (!Array.from) { + Array.from = (function () { + var toStr = Object.prototype.toString; + var isCallable = function (fn) { + return typeof fn === 'function' || toStr.call(fn) === '[object Function]'; + }; + var toInteger = function (value) { + var number = Number(value); + if (isNaN(number)) { return 0; } + if (number === 0 || !isFinite(number)) { return number; } + return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); + }; + var maxSafeInteger = Math.pow(2, 53) - 1; + var toLength = function (value) { + var len = toInteger(value); + return Math.min(Math.max(len, 0), maxSafeInteger); + }; + + // The length property of the from method is 1. + return function from(arrayLike/*, mapFn, thisArg */) { + // 1. Let C be the this value. + var C = this; + + // 2. Let items be ToObject(arrayLike). + var items = Object(arrayLike); + + // 3. ReturnIfAbrupt(items). + if (arrayLike == null) { + throw new TypeError("Array.from requires an array-like object - not null or undefined"); + } + + // 4. If mapfn is undefined, then let mapping be false. + var mapFn = arguments.length > 1 ? arguments[1] : void undefined; + var T; + if (typeof mapFn !== 'undefined') { + // 5. else + // 5. a If IsCallable(mapfn) is false, throw a TypeError exception. + if (!isCallable(mapFn)) { + throw new TypeError('Array.from: when provided, the second argument must be a function'); + } + + // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 2) { + T = arguments[2]; + } + } + + // 10. Let lenValue be Get(items, "length"). + // 11. Let len be ToLength(lenValue). + var len = toLength(items.length); + + // 13. If IsConstructor(C) is true, then + // 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len. + // 14. a. Else, Let A be ArrayCreate(len). + var A = isCallable(C) ? Object(new C(len)) : new Array(len); + + // 16. Let k be 0. + var k = 0; + // 17. Repeat, while k < len… (also steps a - h) + var kValue; + while (k < len) { + kValue = items[k]; + if (mapFn) { + A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k); + } else { + A[k] = kValue; + } + k += 1; + } + // 18. Let putStatus be Put(A, "length", len, true). + A.length = len; + // 20. Return A. + return A; + }; + }()); +} +</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('ES2015', '#sec-array.from', 'Array.from')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.from', 'Array.from')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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>Edge</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("45")}}</td> + <td>{{CompatGeckoDesktop("32")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9.0</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>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("32")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("TypedArray.from()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/includes/index.html b/files/pl/web/javascript/reference/global_objects/array/includes/index.html new file mode 100644 index 0000000000..ead60760a3 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/includes/index.html @@ -0,0 +1,111 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/Array/includes +translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes +original_slug: Web/JavaScript/Referencje/Obiekty/Array/includes +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>includes()</strong></code> ustala czy dana tablica posiada szukany element, zwracając <code>true</code> lub <code>false.</code></p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">var<code><var> boolean = array</var>.includes(<var>searchElement</var>[, <var>fromIndex</var>])</code></pre> + +<h3 id="Zwraca">Zwraca</h3> + +<p>{{jsxref("Boolean")}}.</p> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Szukany element.</dd> + <dt><code>fromIndex</code></dt> + <dd>Opcjonalne. Jest to pozycja w tablicy, od której rozpoczyna się szukanie elementu <code>searchElement</code>. Ujemna wartość przeszukuje tablicę od końca tablicy. Domyślna wartość wynosi 0.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">[1, 2, 3].includes(2); // true +[1, 2, 3].includes(4); // false +[1, 2, 3].includes(3, 3); // false +[1, 2, 3].includes(3, -1); // true +[1, 2, NaN].includes(NaN); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.includes) { + Array.prototype.includes = function(searchElement /*, fromIndex*/ ) { + 'use strict'; + var O = Object(this); + var len = parseInt(O.length) || 0; + if (len === 0) { + return false; + } + var n = parseInt(arguments[1]) || 0; + var k; + if (n >= 0) { + k = n; + } else { + k = len + n; + if (k < 0) {k = 0;} + } + var currentElement; + while (k < len) { + currentElement = O[k]; + if (searchElement === currentElement || + (searchElement !== searchElement && currentElement !== currentElement)) { // NaN !== NaN + return true; + } + k++; + } + return false; + }; +} +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td> + <td>{{Spec2('ES7')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> + <p> </p> + </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Array.includes")}}</p> +</div> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("TypedArray.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.findIndex()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/index.html b/files/pl/web/javascript/reference/global_objects/array/index.html new file mode 100644 index 0000000000..7592e1696b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/index.html @@ -0,0 +1,280 @@ +--- +title: Array +slug: Web/JavaScript/Reference/Global_Objects/Array +tags: + - Array + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Array +original_slug: Web/JavaScript/Referencje/Obiekty/Array +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<p><code>Array</code> w języku JavaScript jest globalnym obiektem, który jest używany podczas tworzenia tablic – listo-podobnych obieków wysokiego poziomu.</p> + +<div class="boxed translate-rendered"> +<p><strong>Stwórz tablicę</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> owoce <span class="operator token">=</span> <span class="punctuation token">[</span><span class="string token">'Jabłko'</span><span class="punctuation token">,</span> <span class="string token">'Banan'</span><span class="punctuation token">]</span><span class="punctuation token">;</span> + +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>owoce<span class="punctuation token">.</span>length<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// 2</span></code></pre> +</div> + +<p><strong>Dostawanie się do elementu tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> pierwszy <span class="operator token">=</span> owoce<span class="punctuation token">[</span><span class="number token">0</span><span class="punctuation token">]</span><span class="punctuation token">;</span> +<span class="comment token">// Jablko</span> + +<span class="keyword token">var</span> ostatni <span class="operator token">=</span> owoce<span class="punctuation token">[</span>owoce<span class="punctuation token">.</span>length <span class="operator token">-</span> <span class="number token">1</span><span class="punctuation token">]</span><span class="punctuation token">;</span> +<span class="comment token">// Banan</span></code></pre> + +<p><strong>Pętla przechodząca przez zawartość tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">owoce<span class="punctuation token">.</span><span class="function token">forEach</span><span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span>item<span class="punctuation token">,</span> index<span class="punctuation token">,</span> array<span class="punctuation token">)</span> <span class="punctuation token">{</span> + console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>item<span class="punctuation token">,</span> index<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// Jablko 0</span> +<span class="comment token">// Banan 1</span></code></pre> + +<p><strong>Dodawanie elementu na końcu tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> nowaDługosc <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">push</span><span class="punctuation token">(</span><span class="string token">'Pomarańcz'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// ["Jabłko", "Banan", "Pomarańcz"]</span></code></pre> + +<p><strong>Usuwanie elemetu z końca tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> ostatni <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">pop</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// usuwa pomarańczę z końca</span> +<span class="comment token">// ["Jabłko", "Banan"];</span></code></pre> + +<p><strong>Usuwanie elementu z przodu tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> pierwszy <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">shift</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// usuwa jabłko z początku</span> +<span class="comment token">// ["Banan"];</span></code></pre> + +<p><strong>Dodawanie elementu z przodu tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> nowaDługość <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">unshift</span><span class="punctuation token">(</span><span class="string token">'Truskawki'</span><span class="punctuation token">)</span> <span class="comment token">// dodaje na początku</span> +<span class="comment token">// ["Truskawkę", "Banan"];</span></code></pre> + +<p><strong>Znajdowanie indeksu (numeru porządkowego) elementu t tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">owoce<span class="punctuation token">.</span><span class="function token">push</span><span class="punctuation token">(</span><span class="string token">'Mango'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// ["Truskawka", "Banan", "Mango"]</span> + +<span class="keyword token">var</span> pos <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">'Banan'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// 1</span></code></pre> + +<p><strong>Usuwanie obiektu przy użyciu indeksu </strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> usunElement <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">splice</span><span class="punctuation token">(</span>pos<span class="punctuation token">,</span> <span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// tak się usuwa element</span> + +<span class="comment token">// ["Truskawka", "Mango"]</span></code></pre> + +<p><strong>Usuwanie elementów przy użyciu pozycji w indeksie</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> warzywa <span class="operator token">=</span> <span class="punctuation token">["</span><span class="string token">Kapusta"</span><span class="punctuation token">,</span> "<span class="string token">Rzepa</span><span class="punctuation token">",</span> "<span class="string token">Rzodkiew"</span><span class="punctuation token">,</span> "<span class="string token">Marchew"</span><span class="punctuation token">]</span><span class="punctuation token">;</span> +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(warzywa</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// </span><span class="punctuation token">[</span><span class="string token">"Kapusta"</span><span class="punctuation token">,</span> "<span class="string token">Rzepa"</span><span class="punctuation token">,</span> "<span class="string token">Rzodkiew"</span><span class="punctuation token">,</span> "<span class="string token">Marchew"</span><span class="punctuation token">]</span> + +<span class="keyword token">var</span> pos <span class="operator token">=</span> <span class="number token">1</span><span class="punctuation token">,</span> n <span class="operator token">=</span> <span class="number token">2</span><span class="punctuation token">;</span> + +<span class="keyword token">var</span> usunieteElementy <span class="operator token">=</span> warzywa<span class="punctuation token">.</span><span class="function token">splice</span><span class="punctuation token">(</span>pos<span class="punctuation token">,</span> n<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// n oznacza liczbę elementów do usunięcia</span> +<span class="comment token">// zaczynając od elementu na określonej pozycji(pos)</span> + +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>warzywa<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// ["Kapusta", "Marchew"] (początkowa tablica została zmieniona)</span> + +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>usunieteElementy<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// ["Rzepa", "Rzodkiew"]</span></code> +</pre> + +<p><strong>Kopiowanie tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> płytkaKopia <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">slice</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// tak się tworzy kopię</span> +<span class="comment token">// ["Truskawka", "Mango"]</span></code> +</pre> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia:</h2> + +<pre class="syntaxbox"><code>[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>] +new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]]) +new Array(długoscTablicy)</code></pre> + +<dl> + <dt><code>elementN </code></dt> + <dd>Lista wartości elementów tablicy. Tablica jest inicjowana z określonymi wartościami jako jej elementami. Długość tablicy (<code>length</code>) odpowiada liczbie jej elementów.</dd> + <dt><code>długośćTablicy</code></dt> + <dd>Początkowa długość tablicy. Aby móc przetwarzać wartości używamy własności długości tablicy <code>length</code>. Jeśli określona wartość nie jest liczbą, zostanie utworzona tablica jednoelementowa, a jej pierwszy element będzie posiadał ową wartość. Maksymalna długość tablicy wynosi 4,294,967,295 elementów.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Tablica jest uporządkowanym zbiorem wartości przyporządkowanych ustalonej pojedynczej zmiennej.</p> + +<p>Poniższy przykład tworzy obiekt <code>Array</code> przy użyciu literału tablicy. Tablica <code>kawa</code> zawiera trzy elementy i ma długość (<code>length</code>) równą 3:</p> + +<pre class="brush: js">kawa = ["mocca", "cappucino", "zbożowa"] +</pre> + +<p>Można utworzyć tzw. zwartą tablicę składającą się z dwóch lub więcej elementów, o początkowym indeksie 0, jeśli poda się początkowe wartości wszystkich elementów. Zwarta tablica to taka, w której każdy element posiada wartość. Poniższy kod tworzy zwartą tablicę o trzech elementach:</p> + +<pre class="brush: js">myArray = new Array("Hello", myVar, 3.14159) +</pre> + +<h3 id="Dost.C4.99p_do_element.C3.B3w_tablicy" name="Dost.C4.99p_do_element.C3.B3w_tablicy">Dostęp do elementów tablicy</h3> + +<p>Do elementów tablicy odwołujemy się po ich liczbie porządkowej (zaczynając od zera). Przykładowo, jeśli mamy zdefiniowaną tablicę:</p> + +<pre class="brush: js">mojaTablica = new Array("Wiatr","Deszcz","Ogień") +</pre> + +<p>Do pierwszego elementu odwołujemy się poprzez <code>mojaTablica[0]</code>, a do drugiego poprzez <code>mojaTablica[1]</code>.</p> + +<h3 id="Podawanie_pojedynczego_parametru" name="Podawanie_pojedynczego_parametru">Podawanie pojedynczego parametru</h3> + +<p>Jeśli konstruktor <code>Array</code> zostanie wywołany z pojedynczym parametrem liczbowym, parametr ten zostanie uznany za początkową długość tablicy. Poniższy kod tworzy tablicę pięciu elementów:</p> + +<pre class="brush: js">rodzajPlatnosci = new Array(5) +</pre> + +<p>Zachowanie konstruktora <code>Array</code> zależy od tego, czy jedyny parametr jest liczbą.</p> + +<ul> + <li>Jeśli jedyny parametr jest liczbą, konstruktor konwertuje tę liczbą do 32-bitowej liczby całkowitej bez znaku i tworzy tablicę o długości (liczbie elementów, <code>length</code>) równej tej liczbie. Tablica początkowo nie zawiera żadnych elementów, mimo że ma niezerową długość.</li> + <li>Jeśli parametr ten nie jest liczbą, tworzona jest tablica o długości 1, a parametr ten staje się jej pierwszym elementem.</li> +</ul> + +<p>Poniższy kod tworzy tablicę o długości 25, a następnie przypisuje wartości pierwszym trzem elementom:</p> + +<pre class="brush: js">rodzajeMuzyki = new Array(25) +rodzajeMuzyki[0] = "R&B" +rodzajeMuzyki[1] = "Blues" +rodzajeMuzyki[2] = "Jazz" +</pre> + +<h3 id="Po.C5.9Brednie_zwi.C4.99kszanie_d.C5.82ugo.C5.9Bci_tablicy" name="Po.C5.9Brednie_zwi.C4.99kszanie_d.C5.82ugo.C5.9Bci_tablicy">Pośrednie zwiększanie długości tablicy</h3> + +<p>Długość tablicy wzrasta samoczynnie, jeśli elementowi o indeksie wyższym niż obecna długość zostanie przypisana wartość. Poniższy kod tworzy tablicę o zerowej długości, a następnie przypisuje do niej 99. element. W wyniku długość tablicy zostaje zmieniona na 100.</p> + +<pre class="brush: js">kolory = new Array(); +kolory[99] = "ciemnoniebieski"; +</pre> + +<h3 id="Tworzenie_tablicy_z_wynik.C3.B3w_wyra.C5.BCenia_regularnego" name="Tworzenie_tablicy_z_wynik.C3.B3w_wyra.C5.BCenia_regularnego">Tworzenie tablicy z wyników wyrażenia regularnego</h3> + +<p>Wynik porównania pomiędzy regularnym wyrażeniem a łańcuchem znaków może utworzyć tablicę. Ta tablica ma własności i elementy, które przekazują informacje dotyczące porównania. Tablica jest wartością zwracaną przez <code>RegExp.exec</code>, <code>String.match</code> i <code>String.replace</code>. Aby zrozumieć te własności spójrz na poniższy przykład odwołując się do poniższej tabeli:</p> + +<pre class="brush: js">//Porównuje łańcuch znaków złożony z jednego 'd' następnie kilku 'b' a następnie jednego 'd' +//Zapamiętuje porównane 'b' i następujące 'd' +//Ignoruje wielkość liter + +mojRe=/d(b+)(d)/i; +mojaTablica = mojRe.exec("cdbBdbsbz"); +</pre> + +<p>Własności i elementy zwracają wartości z poniższej tabeli:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Własność/Element</td> + <td class="header">Opis</td> + <td class="header">Przykład</td> + </tr> + <tr> + <td><code>input</code></td> + <td>Wartość tylko-do-odczytu, opisująca oryginalny łańcuch znaków, do którego porównano wyrażenie regularne.</td> + <td>cdbBdbsbz</td> + </tr> + <tr> + <td><code>index</code></td> + <td>Własność tylko-do-odczytu, będąca indeksem (zaczynając od 0) porównanego znaku w łańcuchu znaków.</td> + <td>1</td> + </tr> + <tr> + <td><code>[0]</code></td> + <td>Element tylko-do-odczytu, zawierający ostatnio porównane znaki.</td> + <td>dbBd</td> + </tr> + <tr> + <td><code>[1], ... [n]</code></td> + <td>Elementy tylko-do-odczytu, zawierające podobne podłańcuchy znaków, zawarte w wyrażeniu regularnym. Liczba możliwych podłańcuchów jest nieskończona.</td> + <td>[1]: bB<br> + [2]: d</td> + </tr> + </tbody> +</table> + +<h2 id="Własności">Własności</h2> + +<dl> + <dd> + <dl> + <dt>{{jsxref("Array.length")}}</dt> + <dd>Odzwierciedla ilość elementów tablicy.</dd> + <dt>{{jsxref("Array.prototype")}}</dt> + <dd>Pozwala na dodawanie własności do wszystkich obiektów.</dd> + </dl> + </dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Array.from()")}} {{experimental_inline}}</dt> + <dd>Tworzy nową instancję <code>Array</code> z obiektu podobnego do tablicy lub iterowalnego.</dd> + <dt>{{jsxref("Array.isArray()")}}</dt> + <dd>Zwraca true, jeśli zmienna jest tablicą, jeśli nie false.</dd> + <dt>{{jsxref("Array.observe()")}} {{experimental_inline}}</dt> + <dd>Asynchronicznie obserwuje zmiany w tablicach, podobnie jak {{jsxref ("Object.observe ()")}} dla obiektów. Zapewnia strumień zmian w kolejności występowania.</dd> + <dt>{{jsxref("Array.of()")}} {{experimental_inline}}</dt> + <dd>Tworzy nową instancję Array ze zmienną liczbą argumentów, niezależnie od liczby lub rodzaju argumentów.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad_Tworzenie_tablicy" name="Przyk.C5.82ad:_Tworzenie_tablicy">Przykład: Tworzenie tablicy</h3> + +<p>Poniższy kod tworzy tablicę <code>msgArray</code> o długości 0, a następnie przypisuje wartości do <code>msgArray[0]</code> i <code>msgArray[99]</code>, zwiększając długość tablicy do 100.</p> + +<pre class="brush: js">msgArray = new Array() +msgArray[0] = "Witaj," +msgArray[99] = "świecie" +// Poniższy warunek jest spełniony, +// ponieważ zdefiniowano element msgArray[99]. +if (msgArray.length == 100) + myVar="Długość tablicy jest równa 100." +</pre> + +<h3 id="Przyk.C5.82ad_Tworzenie_tablicy_dwuwymiarowej" name="Przyk.C5.82ad:_Tworzenie_tablicy_dwuwymiarowej">Przykład: Tworzenie tablicy dwuwymiarowej</h3> + +<p>Poniższy kod tworzy tablicę dwuwymiarową i przypisuje wyniki do zmiennej <code>myVar</code>.</p> + +<pre class="brush: js">myVar="Test tablicy wielowymiarowej; " +a = new Array(4) +for (i=0; i < 4; i++) { + a[i] = new Array(4) + for (j=0; j < 4; j++) { + a[i][j] = "["+i+","+j+"]" + } +} +for (i=0; i < 4; i++) { + str = "Wiersz "+i+":" + for (j=0; j < 4; j++) { + str += a[i][j] + } + myVar += str +"; " +} +</pre> + +<p>Poniższy łańcuch znaków będzie przypisany do zmiennej <code>myVar</code> (linie zostały przełamane dla zwiększenia czytelności):</p> + +<pre>Test tablicy wielowymiarowej; +Wiersz 0:[0,0][0,1][0,2][0,3]; +Wiersz 1:[1,0][1,1][1,2][1,3]; +Wiersz 2:[2,0][2,1][2,2][2,3]; +Wiersz 3:[3,0][3,1][3,2][3,3]; +</pre> + +<div class="noinclude"></div> diff --git a/files/pl/web/javascript/reference/global_objects/array/indexof/index.html b/files/pl/web/javascript/reference/global_objects/array/indexof/index.html new file mode 100644 index 0000000000..512e3de6ab --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/indexof/index.html @@ -0,0 +1,96 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/indexOf +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +original_slug: Web/JavaScript/Referencje/Obiekty/Array/indexOf +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca pierwszy (najmniejszy) indeks elementu w tablicy równego podanej wartości lub -1, gdy nie znaleziono takiego elementu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><em>array</em>.indexOf(<em>searchElement</em>[,<em> fromIndex</em> = 0]); +</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Element do znalezienia w tablicy.</dd> + <dt><code>fromIndex</code></dt> + <dd>Indeks od którego ma zacząć się wyszukiwanie. Domyślnie 0 - przeszukana zostanie cała tablica. Jeżeli indeks będzie większy lub równy ilości elementów tablica nie zostanie przeszukana - funkcja zwróci -1. Jeżeli podana zostanie liczba ujemna zostanie dodany do niej rozmiar tablicy (np. podanie -5 oznacza przeszukiwanie od 5 elementu od końca). Jeżeli tak obliczony indeks jest mniejszy od zera przeszukana zostanie cała tablica. Uwaga, wyszukiwanie dalej będzie się odbywać w kierunku rosnących indeksów.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>indexOf</code> porównuje <code>searchElement</code> z elementami tablicy używając <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_por%c3%b3wnania#.22U.C5.BCywanie_operator.C3.B3w_por.C3.B3wnania">ścisłego porównania</a> (podobnie jak w przypadku operatora ===).</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>indexOf</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>indexOf</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.indexOf) +{ + Array.prototype.indexOf = function(elt /*, from*/) + { + var len = this.length; + + var from = Number(arguments[1]) || 0; + from = (from < 0) + ? Math.ceil(from) + : Math.floor(from); + if (from < 0) + from += len; + + for (; from < len; from++) + { + if (from in this && + this[from] === elt) + return from; + } + return -1; + }; +} +</pre> + +<p>Należy zwrócić uwagę, że ta implementacja ma na celu całkowitą zgodność z <code>indexOf</code> występującą w Firefoksie i silniku JavaScript SpiderMonkey, włączając w to przypadki w których przesyłany do <code>indexOf</code> indeks nie jest wartością liczbową. Jeśli masz zamiar wykorzystać przytoczone rozwiązanie w rzeczywistych aplikacjach, możesz nie potrzebować całego powyższego kodu (części odpowiedzialnej za obliczenie wartości <code>from</code>).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_indexOf" name="Przyk.C5.82ad:_Zastosowanie_indexOf">Przykład: Zastosowanie <code>indexOf</code></h3> + +<p>Następujący przykład stosuje <code>indexOf</code> do znalezienia pierwszego wystąpienia elementów.</p> + +<pre class="brush: js">array = [2, 5, 9]; +index = array.indexOf(2); +// index jest 0 +index = array.indexOf(7); +// index jest -1 +</pre> + +<h3 id="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_w_tablicy" name="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_w_tablicy">Przykład: Wyszukiwanie wszystkich wystąpień w tablicy</h3> + +<p>Poniższy przykład używa <code>indexOf</code> do znalezienia wszystkich wystąpień elementu w tablicy oraz dodaje ich indeksy do drugiej tablicy używając metody {{jsxref("Array.prototype.push()")}}.</p> + +<pre class="brush: js">indices = []; +idx = array.indexOf(element) +while (idx != -1) { + indices.push(idx); + idx = array.indexOf(element, idx + 1); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.indexOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/isarray/index.html b/files/pl/web/javascript/reference/global_objects/array/isarray/index.html new file mode 100644 index 0000000000..2abef7d8b6 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/isarray/index.html @@ -0,0 +1,140 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Reference/Global_Objects/Array/isArray +translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray +original_slug: Web/JavaScript/Referencje/Obiekty/Array/isArray +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Podsumowanie</h2> + +<p><strong>Array.isArray()</strong> to metoda, która zwraca <code style="font-style: normal; line-height: 23.3333339691162px;">true</code><span style="line-height: 23.3333339691162px;"> </span> jeśli obiekt jest tablicą, fałsz jeśli nie jest.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox"><code>Array.isArray(<var>obj</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Obiekt do sprawdzenia</dd> +</dl> + +<h2 id="Description" name="Description">Opis</h2> + +<p>Zobacz artykuł <a href="http://web.mit.edu/jwalden/www/isArray.html">“Determining with absolute accuracy whether or not a JavaScript object is an array”</a> , aby poznać więcej szczegółów.</p> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<pre class="brush: js">// poniższe przykłady zwrócą true +Array.isArray([]); +Array.isArray([1]); +Array.isArray(new Array()); +// Mało znany fakt: Array.prototype sam w sobie jest tablicą: +Array.isArray(Array.prototype); + +// poniższe przykłady zwrócą false +Array.isArray(); +Array.isArray({}); +Array.isArray(null); +Array.isArray(undefined); +Array.isArray(17); +Array.isArray('Array'); +Array.isArray(true); +Array.isArray(false); +Array.isArray({ __proto__: Array.prototype }); +</pre> + +<h2 id="Polyfill" name="Polyfill">Dostępność wsteczna</h2> + +<p>Jeśli metody <span style="font-family: consolas,monaco,andale mono,monospace; line-height: 23.3333339691162px;">Array.isArray() nie jest natywnie dostępna, poniższy kod ją utworzy.</span></p> + +<pre class="brush: js">if (!Array.isArray) { + Array.isArray = function(arg) { + return Object.prototype.toString.call(arg) === '[object Array]'; + }; +} +</pre> + +<h2 id="Specifications" name="Specifications">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Wstępna definicja. Implementacja od JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Zgodność z przeglądarkami</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("5")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("5")}}</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>{{CompatGeckoMobile("2.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>Based on <a href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p> + +<h2 id="See_also" name="See_also">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/Array", "Array")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/join/index.html b/files/pl/web/javascript/reference/global_objects/array/join/index.html new file mode 100644 index 0000000000..cd1d7f8a7b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/join/index.html @@ -0,0 +1,51 @@ +--- +title: Array.prototype.join() +slug: Web/JavaScript/Reference/Global_Objects/Array/join +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/join +original_slug: Web/JavaScript/Referencje/Obiekty/Array/join +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Łączy wszystkie elementy tablicy w jeden łańcuch znaków.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var> = <var>arr</var>.join([<var>separator</var> = ','])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>separator</code> </dt> + <dd>Określa łańcuch znaków użyty do oddzielenia każdego z elementów tablicy. W razie konieczności separator jest konwertowany do łańcucha znaków. Jeśli parametr zostanie pominięty, elementy tablicy będą rozdzielone za pomocą przecinka.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>join</code> zmienia w łańcuchy znaków wszystkie elementy tablicy i łączy je w jeden łańcuch znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_.C5.81.C4.85czenie_tablicy_na_trzy_r.C3.B3.C5.BCne_sposoby" name="Przyk.C5.82ad:_.C5.81.C4.85czenie_tablicy_na_trzy_r.C3.B3.C5.BCne_sposoby">Przykład: Łączenie tablicy na trzy różne sposoby</h3> + +<p>Poniższy przykład tworzy trzyelementową tablicę <code>a</code> zawierającą trzy elementy, następnie trzykrotnie łączy ją: używając domyślnego separatora, przecinka i spacji oraz znaku plus.</p> + +<pre class="brush: js">var a = new Array("Wiatr","Deszcz","Ogień"); +var myVar1 = a.join() // przypisuje "Wiatr,Deszcz,Ogień" do myVar1 +var myVar2 = a.join(", ") // przypisuje "Wiatr, Deszcz, Ogień" do myVar2 +var myVar3 = a.join(" + ") // przypisuje "Wiatr + Deszcz + Ogień" do myVar3 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.toString()")}}</li> + <li>{{jsxref("TypedArray.prototype.join()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/keys/index.html b/files/pl/web/javascript/reference/global_objects/array/keys/index.html new file mode 100644 index 0000000000..a284253ed6 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/keys/index.html @@ -0,0 +1,121 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Reference/Global_Objects/Array/keys +translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys +original_slug: Web/JavaScript/Referencje/Obiekty/Array/keys +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>keys()</strong></code> zwraca nowy obiekt typu <code><strong>Array Iterator</strong></code> zawierający indeksy kolejnych elementów tablicy.</p> + +<pre class="brush: js">var arr = ['a', 'b', 'c']; +var iterator = arr.keys(); + +console.log(iterator.next()); // { value: 0, done: false } +console.log(iterator.next()); // { value: 1, done: false } +console.log(iterator.next()); // { value: 2, done: false } +console.log(iterator.next()); // { value: undefined, done: true } +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>arr</var>.keys()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator dla typu {{jsxref("Array")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Iterator_nie_ignoruje_dziur">Iterator nie ignoruje dziur</h3> + +<pre class="brush: js">var arr = ['a', , 'c']; +var sparseKeys = Object.keys(arr); +var denseKeys = [...arr.keys()]; +console.log(sparseKeys); // ['0', '2'] +console.log(denseKeys); // [0, 1, 2] +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Pierwsze wystąpienie.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</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>Edge</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("38")}}</td> + <td>{{CompatGeckoDesktop("28")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</td> + <td>{{CompatSafari("7.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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Array.prototype.values()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> + <li>{{jsxref("Iteration_protocols", "Iteratory")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/pl/web/javascript/reference/global_objects/array/lastindexof/index.html new file mode 100644 index 0000000000..ca02035c96 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/lastindexof/index.html @@ -0,0 +1,115 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +original_slug: Web/JavaScript/Referencje/Obiekty/Array/lastIndexOf +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca ostatni indeks, pod którym podany element może być znaleziony w tablicy, lub -1 jeśli nie jest obecny. Tablica jest przeszukiwana od końca, zaczynając od indeksu <code>fromIndex</code></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.lastIndexOf(<var>searchElement</var>[, <var>fromIndex</var> = arr.length])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Element do znalezienia w tablicy.</dd> + <dt><code>fromIndex</code></dt> + <dd>Indeks od którego ma zostać rozpoczęte wyszukiwanie od tyłu. Domyślnie jest to długość tablicy, tzn. przeszukana zostanie cała tablica. Jeśli indeks jest większy od lub równy długości tablicy, przeszukana zostanie cała tablica. Jeśli jest ujemny, traktowany będzie jako przesunięcie od końca tablicy. Należy pamiętać, że nawet jeśli indeks jest ujemny, to i tak tablica przeszukiwana jest od końca do początku. Jeśli obliczony indeks jest mniejszy od 0, zwracana jest wartość -1, innymi słowy, tablica nie zostanie przeszukana.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>lastIndexOf</code> porównuje <code>searchElement</code> z elementami tablicy używając <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_por%c3%b3wnania#.22U.C5.BCywanie_operator.C3.B3w_por.C3.B3wnania">ścisłego porównania</a> (podobnie jak w przypadku operatora ===).</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>lastIndexOf</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>lastIndexOf</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.lastIndexOf) +{ + Array.prototype.lastIndexOf = function(elt /*, from*/) + { + var len = this.length; + + var from = Number(arguments[1]); + if (isNaN(from)) + { + from = len - 1; + } + else + { + from = (from < 0) + ? Math.ceil(from) + : Math.floor(from); + if (from < 0) + from += len; + else if (from >= len) + from = len - 1; + } + + for (; from > -1; from--) + { + if (from in this && + this[from] === elt) + return from; + } + return -1; + }; +} +</pre> + +<p>Należy zwrócić uwagę, że ta implementacja ma na celu całkowitą zgodność z <code>lastIndexOf</code> występującą w Firefoksie i silniku JavaScript SpiderMonkey, włączając w to przypadki skrajne. Jeśli masz zamiar wykorzystać przytoczone rozwiązanie w rzeczywistych aplikacjach, możesz obliczyć <code>from</code> za pomocą mniej skomplikowanego kodu (z pominięciem części instrukcji warunkowych).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_lastIndexOf" name="Przyk.C5.82ad:_Zastosowanie_lastIndexOf">Przykład: Zastosowanie <code>lastIndexOf</code></h3> + +<p>Poniższy przykład używa <code>lastIndexOf</code> do znalezienia określonych wartości w tablicy.</p> + +<pre class="brush: js">array = [2, 5, 9, 2]; +index = array.lastIndexOf(2); +// index is 3 +index = array.lastIndexOf(7); +// index is -1 +index = array.lastIndexOf(2, 3); +// index is 3 +index = array.lastIndexOf(2, 2); +// index is 0 +index = array.lastIndexOf(2, -2); +// index is 0 +index = array.lastIndexOf(2, -1); +// index is 3 +</pre> + +<h3 id="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_danego_elementu" name="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_danego_elementu">Przykład: Wyszukiwanie wszystkich wystąpień danego elementu</h3> + +<p>Poniższy przykład używa <code>lastIndexOf</code> do znalezienia wszystkich wystąpień elementu w tablicy oraz dodaje ich indeksy do drugiej tablicy używając metody <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/push">push</a></code>.</p> + +<pre class="brush: js">indices = []; +idx = array.lastIndexOf(element) +while (idx != -1) { + indices.push(idx); + idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1); +} +</pre> + +<p>Warto zauważyć, że obsłużyliśmy warunek <code>idx == 0</code> oddzielnie, ponieważ element ten zostanie zawsze odnaleziony - bez względu na wartość parametru <code>fromIndex</code> - w przypadku gdy jest on pierwszym elementem tablicy. To różni tę metodę od metody {{jsxref("Array.prototype.indexOf()")}}.</p> + +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3> + +<ul> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/length/index.html b/files/pl/web/javascript/reference/global_objects/array/length/index.html new file mode 100644 index 0000000000..520bff2ab7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/length/index.html @@ -0,0 +1,54 @@ +--- +title: Array.prototype.length +slug: Web/JavaScript/Reference/Global_Objects/Array/length +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/length +original_slug: Web/JavaScript/Referencje/Obiekty/Array/length +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>32-bitowa liczba całkowita bez znaku określająca liczbę elementów w tablicy.</p> + +<div>{{js_property_attributes(1, 0, 0)}}</div> + +<div> +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.length</code></pre> +</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością własności <code>length</code> jest dodatnia liczba całkowita mniejsza niż 2 do potęgi 32 (2<sup>32</sup>).</p> + +<p>W dowolnej chwili możesz ustalić wartość <code>length</code> w celu zmniejszenia rozmiaru tablicy. Ustawienie wartości <code>length</code> na większą niż rozmiar tablicy nie zwiększy liczby elementów, np. jeżeli ustawisz <code>length</code> na 3, podczas gdy obecną wartością jest liczba 2, tablica nadal będzie zawierać tylko 2 elementy.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Iteracja_przez_wszystkie_elementy_tablicy" name="Przyk.C5.82ad:_Iteracja_przez_wszystkie_elementy_tablicy">Przykład: Iteracja przez wszystkie elementy tablicy</h3> + +<p>W poniższym przykładzie ilość elementów w tablicy <code>numbers</code> jest określana w instrukcji iteracyjnej na podstawie wartości <code>length</code>, następnie wartość każdego elementu jest podwajana.</p> + +<pre class="brush: js">var numbers = [1,2,3,4,5]; +for (var i = 0; i < numbers.length; i++) { + numbers[i] *= 2; +} +// zawartość tablicy to teraz [2,4,6,8,10]; +</pre> + +<h3 id="Przyk.C5.82ad:_Skracanie_tablicy" name="Przyk.C5.82ad:_Skracanie_tablicy">Przykład: Skracanie tablicy</h3> + +<p>Poniższy przykład zmniejsza rozmiar tablicy <code>statesUS</code> do 50, jeżeli przekracza on tę wartość.</p> + +<pre class="brush: js">if (statesUS.length > 50) { + statesUS.length=50 +} +</pre> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/reference/global_objects/array/map/index.html b/files/pl/web/javascript/reference/global_objects/array/map/index.html new file mode 100644 index 0000000000..41e1f41bbd --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/map/index.html @@ -0,0 +1,94 @@ +--- +title: Array.prototype.map() +slug: Web/JavaScript/Reference/Global_Objects/Array/map +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/map +original_slug: Web/JavaScript/Referencje/Obiekty/Array/map +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>map()</strong></code> tworzy nową tablicę zawierającą wyniki wywoływania podanej funkcji dla każdego elementu wywołującej tablicy.</p> + +<pre class="brush: js">var liczby = [1, 5, 10, 15]; +var podwojenia = liczby.map(function(x) { + return x * 2; +}); +// podwojenia to teraz [2, 10, 20, 30] +// liczby to dalej [1, 5, 10, 15] + +var liczby = [1, 4, 9]; +var pierwiastki = liczby.map(Math.sqrt); +// pierwiastki to teraz [1, 2, 3] +// liczby to dalej [1, 4, 9] +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>var new_array = arr</var>.map(<var>function callback(currentValue, index, array){ // Zwróć element nowej tablicy }</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><strong>callback</strong></code></dt> + <dd>Funkcja tworząca element nowej tablicy, przyjmująca trzy argumenty:</dd> + <dd> + <dl> + <dt><code><strong>currentValue</strong></code></dt> + <dd>Element tablicy nad którym obecnie pracujemy</dd> + <dt><code><strong>index</strong></code></dt> + <dd>Indeks elementu tablicy nad którym obecnie pracujemy</dd> + <dt><code><strong>array</strong></code></dt> + <dd>Oryginalna tablica na rzecz której wywołano metodę <code>map</code></dd> + </dl> + </dd> + <dt><code><strong>thisArg</strong></code></dt> + <dd>Opcjonalny. Wartość jaką użyć jako <code>this</code> podczas wywołania <code>callback</code></dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowa tablica zawierająca elementy będące wynikami wywoływani funkcji <code>callback</code>.</p> + +<h2 id="Opis">Opis</h2> + +<p><code>map</code> wykonuje funkcję (<code>callback</code>) raz na każdym z elementów tablicy w kolejności i tworzy nową tablicę na podstawie wyników. <code>callback</code> wywoływany jest tylko dla indeksów tablicy które mają przypisane wartości, włącznie z <a href="/pl/docs/Web/JavaScript/Referencje/Obiekty/undefined">undefined</a>. Nie jest wywoływany dla brakujących elementów tablicy (indeksów które nigdy nie były ustawione, usunięte lub nie miały nigdy przypisanych wartości).</p> + +<p><code>callback</code> wywoływana jest z trzema argumentami: wartością elementu, jego indeksem i tablicą która jest trawersowana.</p> + +<p>W przypadku podania argumentu <code>thisObject</code>, zostanie on przekazany jako <code>this</code> przy każdym wywołaniu <code>callback</code>. Gdy go brak, lub ma wartość <code>null</code>, użyty zostanie obiekt globalny przyporządkowany do <code>callback</code>.</p> + +<p><code>map</code> nie modyfikuje tablicy, na której jest wywołany.</p> + +<p>Zakres elementów przetwarzanych przez <code>map</code> ustalany jest przed pierwszym wywołaniem <code>callback</code>. Elementy dodane do tablicy po wywołaniu <code>map</code> nie zostaną odwiedzone przez <code>callback</code>. Jeśli istniejący, element tablicy zostanie zmieniony lub usunięty, wartością przekazaną do <code>callback</code> będzie wartość z momentu w którym <code>map</code> odwiedza dany element; elementy usunięte przed sprawdzeniem będą przekazane jako <code>undefined</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Wielkie_litery_.C5.82a.C5.84cuch.C3.B3w_w_tablicy" name="Przyk.C5.82ad:_Wielkie_litery_.C5.82a.C5.84cuch.C3.B3w_w_tablicy">Wielkie litery łańcuchów w tablicy</h3> + +<p>Poniższy kod tworzy nową tablicę zawierającą pisaną wielkimi literami wersję wszystkich oryginalnych łańcuchów.</p> + +<pre class="brush: js">var strings = ["hello", "Array", "WORLD"]; +function makeUpperCase(v) +{ + return v.toUpperCase(); +} +var uppers = strings.map(makeUpperCase); +// uppers są teraz pisane wielkimi literami ["HELLO", "ARRAY", "WORLD"] +// strings są niezmienione +</pre> + +<h3 id="Przyk.C5.82ad:_Mapowanie_tablicy_liczb_do_tablicy_pierwiastk.C3.B3w_kwadratowych" name="Przyk.C5.82ad:_Mapowanie_tablicy_liczb_do_tablicy_pierwiastk.C3.B3w_kwadratowych">Mapowanie tablicy liczb do tablicy pierwiastków kwadratowych</h3> + +<p>Poniższy kod pobiera tablicę liczb i tworzy nową tablicę z pierwiastkami kwadratowymi liczb z pierwszej tablicy.</p> + +<pre class="brush: js">var liczby = [1, 4, 9]; +var pierwiastki = liczby.map(Math.sqrt); +// otrzymane pierwiastki [1, 2, 3] +// pozostające nadal liczby [1, 4, 9] +</pre> + +<p> </p> diff --git a/files/pl/web/javascript/reference/global_objects/array/of/index.html b/files/pl/web/javascript/reference/global_objects/array/of/index.html new file mode 100644 index 0000000000..8a7273148c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/of/index.html @@ -0,0 +1,93 @@ +--- +title: Array.of() +slug: Web/JavaScript/Reference/Global_Objects/Array/of +translation_of: Web/JavaScript/Reference/Global_Objects/Array/of +original_slug: Web/JavaScript/Referencje/Obiekty/Array/of +--- +<div>{{JSRef}}</div> + +<p><code><font face="Verdana, arial, x-locale-body, sans-serif"><span style="background-color: #ffffff;">Metoda </span></font><strong>Array.of()</strong></code> tworzy nową instancję obiektu <code>Array</code>, która zawiera w sobie wszystkie argumenty przekazane do funkcji, niezależnie od ich liczby i typu.</p> + +<p>Różnica pomiędzy <code><strong>Array.of()</strong></code> i konstruktorem <code><strong>Array</strong></code> polega na różnej interpretacji argumentów - <code><strong>Array.of(7)</strong></code> tworzy nową tablicę z jednym elementem(<code>7</code>), gdzie <code><strong>Array(7)</strong></code> tworzy nową tablicę z właściwością <code>length</code> ustawioną na 7 (<strong>Notatka:</strong> Oznacza to tablicę z <code>7</code> wolnymi miejscami, nie miejscami z wartościami <code>undefined</code>).</p> + +<pre class="brush: js">Array.of(7); // [7] +Array.of(1, 2, 3); // [1, 2, 3] + +Array(7); // [ , , , , , , ] +Array(1, 2, 3); // [1, 2, 3] +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">Array.of(<var>element0</var>[, <var>element1</var>[, ...[, <var>elementN</var>]]])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Elementy, które tworzą tablicę.</dd> +</dl> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p>Nowa instancja obiektu {{jsxref("Array")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>Ta funkcja jest częścią standardu ECMAScript 2015. Po więcej informacji zobacz <a href="https://gist.github.com/rwaldron/1074126"><code>Array.of</code> and <code>Array.from</code> proposal</a> i <a href="https://gist.github.com/rwaldron/3186576"><code>Array.of</code> polyfill</a>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">Array.of(1); // [1] +Array.of(1, 2, 3); // [1, 2, 3] +Array.of(undefined); // [undefined] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Uruchomienie tego kodu przed innym stworzy <code>Array.of()</code> nawet jeśli nie jest ona dostępna natywnie.</p> + +<pre class="brush: js">if (!Array.of) { + Array.of = function() { + return Array.prototype.slice.call(arguments); + }; +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.of', 'Array.of')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.of', 'Array.of')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.of")}}</p> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.from()")}}</li> + <li>{{jsxref("TypedArray.of()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/pop/index.html b/files/pl/web/javascript/reference/global_objects/array/pop/index.html new file mode 100644 index 0000000000..32c6f2d6dd --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/pop/index.html @@ -0,0 +1,139 @@ +--- +title: Array.prototype.pop() +slug: Web/JavaScript/Reference/Global_Objects/Array/pop +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Metodă + - Prototype + - Tablica +translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop +original_slug: Web/JavaScript/Referencje/Obiekty/Array/pop +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Usuwa ostatni element z tablicy zwracając go. Metoda ta zmienia długość tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.pop()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Ostatni element tablicy;<br> + Jeśli tablica jest pusta zwraca {{jsxref("undefined")}}</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda pop usuwa ostatni element tablicy i zwraca tę wartość.</p> + +<p><code>pop</code> is intentionally generic. Metoda ta może być {{jsxref("Function.call", "called", "", 1)}} lub {{jsxref("Function.apply", "applied", "", 1)}} do obiektu przypominającego tablice. Obiekty, które nie posiadają właściwości <code>length</code> odzwierciedlającej ostani element w serii, przy właściwościach liczonych od zera nie mogą zachowywać się w żaden znaczący sposób.</p> + +<p>Jeśli zawołasz <code>pop()</code> na pustej tablicy, zwróci ona {{jsxref("undefined")}}.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<h3 id="Przyk.C5.82ad:_Usuwanie_ostatniego_elementu_tablicy" name="Przyk.C5.82ad:_Usuwanie_ostatniego_elementu_tablicy">Przykład: Usuwanie ostatniego elementu tablicy</h3> + +<p>Następujący kod tworzy tablicę <code>myFish</code> zawierającą cztery elementy, a następnie usuwa ostatni jej element.</p> + +<pre><code>var myFish = ['angel', 'clown', 'mandarin', 'sturgeon']; + +console.log(myFish); // ['angel', 'clown', 'mandarin', 'sturgeon'] + +var popped = myFish.pop(); + +console.log(myFish); // ['angel', 'clown', 'mandarin' ] + +console.log(popped); // 'sturgeon'</code></pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<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("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> + +<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> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/push/index.html b/files/pl/web/javascript/reference/global_objects/array/push/index.html new file mode 100644 index 0000000000..ad55ffe255 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/push/index.html @@ -0,0 +1,52 @@ +--- +title: Array.prototype.push() +slug: Web/JavaScript/Reference/Global_Objects/Array/push +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/push +original_slug: Web/JavaScript/Referencje/Obiekty/Array/push +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Dodaje jeden lub więcej elementów na koniec tablicy i zwraca jej nową długość. Metoda ta zmienia długość tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.push(<var>element1</var>, ..., <var>elementN</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>element + <i>N</i> + </code> </dt> + <dd>Elementy dodawane na końcu tablicy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Zachowanie metody <code>push</code> jest analogiczne do funkcji <code>push</code> w języku Perl 4. Uwaga: jej zachowanie różni się w języku Perl 5.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy" name="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy">Przykład: Dodawanie elementów do tablicy</h3> + +<p>Następujący kod tworzy tablicę <code>myFish</code> zawierającą dwa elementy, następnie dodaje do niej dwa kolejne. Po wykonaniu kodu, <code>pushed</code> zawiera wartość 4 (w JavaScript 1.2 po wykonaniu kodu zmienna <code>pushed</code> zawiera wartość "lew").</p> + +<pre class="brush: js">myFish = ["anioł", "klaun"]; +pushed = myFish.push("bęben", "lew"); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/reduce/index.html b/files/pl/web/javascript/reference/global_objects/array/reduce/index.html new file mode 100644 index 0000000000..f98d5375c3 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/reduce/index.html @@ -0,0 +1,301 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce +translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce +original_slug: Web/JavaScript/Referencje/Obiekty/Array/Reduce +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Podsumowanie</h2> + +<p><code><font face="Open Sans, Arial, sans-serif">Metoda </font><strong>reduce()</strong></code> wywołuje funkcję względem wartości przyrostowej z każdego wywołania i kolejnego elementu tablicy (od lewej do prawej) w celu sprowadzenia tej tablicy do pojedynczej wartości.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])</var></code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja wykonywana na każdej wartości w tablicy, przyjmuje cztery argumenty: + <dl> + <dt><code>previousValue</code></dt> + <dt></dt> + <dd>Wartość zwróconą w ostatnim wywołaniu funkcji <code>callback</code>, lub <code>initialValue</code>, jeśli ta została dostarczona. (Patrz niżej.)</dd> + <dt><code>currentValue</code></dt> + <dd>Obecnie przetwarzany element w tablicy.</dd> + <dt><code>index</code></dt> + <dd>Indeks w tablicy obecnie przetwarzanego elementu.</dd> + <dt><code>array</code></dt> + <dd>Tablica, na której została wykonana funkcja <code>reduce</code> .</dd> + </dl> + </dd> + <dt><code>initialValue</code></dt> + <dd>Opcjonalne. Obiekt który będzie użyty jako pierwszy argument pierwszego wywołania funkcji <code>callback</code>.</dd> +</dl> + +<h2 id="Description" name="Description">Opis</h2> + +<p><code>reduce</code> wykonuje funkcję <code>callback</code> raz dla każdego elementu występującego w tablicy, wyłączając dziury. Funkcja <code>callback</code> przyjmuje cztery argumenty: wartość początkową (lub wartość poprzedniego wywołania <code>callback)</code>, wartość obecnego elementu, jego indeks, oraz tablicę na której zachodzi proces iteracji.</p> + +<p>Przy pierwszym wywołaniu funkcji <code>callback, previousValue</code> oraz <code>currentValue</code> mogą przyjąć jedną z dwóch wartości. Jeżeli <code>initialValue</code> było dostarczone w wywołaniu, wtedy <code>previousValue</code> przyjmie wartość podaną jako <code>initialValue</code>, natomiast <code>currentValue</code> przyjmie wartość pierwszego elementu tablicy. Jeśli <code>initialValue</code> nie było podane, wtedy <code>previousValue</code> będzie miało wartość pierwszego elementu tablicy, natomiast <code>currentValue</code> będzie równe elementowi drugiemu.</p> + +<p>Jeżeli tablica jest pusta oraz <code>initialValue</code> nie zostało dostarczone, będzie rzucony błąd {{jsxref("Global_Objects/TypeError", "TypeError")}}. Jeśli natomiast tablica ma jeden tylko element (bez względu na jego pozycję) i <code>initialValue</code> nie zostało podane, lub dostarczono <code>initialValue</code>, ale tablica jest pusta, wtedy ta jedyna wartość zostanie zwrócona, bez wywoływania funkcji <code>callback</code>.</p> + +<p>Przyjmijmy, że wystąpiło następujące wywolanie funkcji <code>reduce</code>:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) { + return previousValue + currentValue; +}); +</pre> + +<p>Funkcja callback będzie wywołana cztery razy, z argumentami i wartościami zwrotnymi przy każdym wołaniu jak następuje:</p> + +<table style="width: 100%;"> + <thead> + <tr> + <th scope="col"></th> + <th scope="col"><code>previousValue</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">wartość zwracana</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">pierwsze wywołanie</th> + <td><code>0</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>1</code></td> + </tr> + <tr> + <th scope="row">drugie wywołanie</th> + <td><code>1</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>3</code></td> + </tr> + <tr> + <th scope="row">trzecie wywołanie</th> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>6</code></td> + </tr> + <tr> + <th scope="row">czwarte wywołanie</th> + <td><code>6</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + </tbody> +</table> + +<p>Wartość zwrócona ostatecznie przez <code>reduce</code> będzie tą z ostatniego wywołania funcji callback (<code>10</code>).</p> + +<p>Natomiast, jeśli dostarczylibyśmy wartość początkową jako drugi argument funkcji przekazanej do <code>reduce</code>, wynik wyglądałby jak poniżej:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) { + return previousValue + currentValue; +}, 10); +</pre> + +<table style="width: 100%;"> + <thead> + <tr> + <th scope="col"></th> + <th scope="col"><code>previousValue</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">wartość zwracana</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">pierwsze wywołanie</th> + <td><code>10</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + <tr> + <th scope="row">drugie wywołanie</th> + <td><code>10</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>11</code></td> + </tr> + <tr> + <th scope="row">trzecie wywołanie</th> + <td><code>11</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>13</code></td> + </tr> + <tr> + <th scope="row">czwarte wywołanie</th> + <td><code>13</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>16</code></td> + </tr> + <tr> + <th scope="row">piąte wywołanie</th> + <td><code>16</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + </tbody> +</table> + +<p>Tym razem wartość zwrócona przez <code>reduce</code> będzie wynosiła <code>20</code>.</p> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<h3 id="Example_Sum_up_all_values_within_an_array" name="Example:_Sum_up_all_values_within_an_array">Przykład: Zsumowanie wszystkich wartości w tablicy.</h3> + +<pre class="brush: js">var total = [0, 1, 2, 3].reduce(function(a, b) { + return a + b; +}); +// total == 6 +</pre> + +<h3 id="Example_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Przykład: Spłaszczenie tablicy tablic</h3> + +<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) { + return a.concat(b); +}); +// flattened is [0, 1, 2, 3, 4, 5] +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p><code>Array.prototype.reduce</code> zostało dodane do standardu ECMA-262 w edycji piątej i jako takie może nie występować we wszystkich implementacji standardu. Można obejśc ten brak poprzez wstawienie poniższego kodu na początku skryptu, co pozwala na użycie <code>reduce</code> z implementacjami, które nie wspierają tej funkcji.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.21 +// Reference: http://es5.github.io/#x15.4.4.21 +if (!Array.prototype.reduce) { + Array.prototype.reduce = function(callback /*, initialValue*/) { + 'use strict'; + if (this == null) { + throw new TypeError('Array.prototype.reduce called on null or undefined'); + } + if (typeof callback !== 'function') { + throw new TypeError(callback + ' is not a function'); + } + var t = Object(this), len = t.length >>> 0, k = 0, value; + if (arguments.length == 2) { + value = arguments[1]; + } else { + while (k < len && !(k in t)) { + k++; + } + if (k >= len) { + throw new TypeError('Reduce of empty array with no initial value'); + } + value = t[k++]; + } + for (; k < len; k++) { + if (k in t) { + value = callback(value, t[k], k, t); + } + } + return value; + }; +} +</pre> + +<h2 id="Specifications" name="Specifications">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Stan</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definicja początkowa. Wprowadzon w JavaScript 1.8.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Wspierane przeglądarki</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>{{CompatGeckoDesktop("1.9")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("4.0")}}</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="See_also" name="See_also">Zobacz też</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduceRight()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/reduceright/index.html b/files/pl/web/javascript/reference/global_objects/array/reduceright/index.html new file mode 100644 index 0000000000..53e9a3d6b9 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/reduceright/index.html @@ -0,0 +1,345 @@ +--- +title: Array.prototype.reduceRight() +slug: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +original_slug: Web/JavaScript/Referencje/Obiekty/Array/ReduceRight +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>reduceRight()</strong></code> przekazuje do funkcji wartość przyrostową dla każdego elementu w tablicy zaczynając od prawej do lewej (od najwyższego indexu do najniższego) w celu sprowadzenia tablicy do pojedynczej wartości.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-reduce-right.html","shorter")}}</div> + + + +<p>Sprawdź również {{jsxref("Array.prototype.reduce()")}} dla redukowania tablicy od lewej do prawej (od najniższego indexu do najwyższego).</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>arr.reduceRight(callback(akumulator, obecnaWartość[, index[, tablica]])[, wartośćPoczątkowa])</var></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja która będzie wołana dla każdego elementu w tablicy, przyjmuje 4 argumenty: + <dl> + <dt><code>akumulator</code></dt> + <dd>Wartość zwrócona z poprzedniego wywołania funkcji <code>callback</code> lub <code>wartośćPoczątkowa</code>, jeśli została zdefiniowana. (Sprawdź poniżej.)</dd> + <dt><code>obecnaWartość</code></dt> + <dd>Element z tablicy, który aktualnie jest przetwarzany</dd> + <dt><code>index</code>{{optional_inline}}</dt> + <dd>Index aktualnie przetwarzanego elementu z tablicy.</dd> + <dt><code>tablica</code>{{optional_inline}}</dt> + <dd>Tablica, na której <code>reduceRight()</code> zostało zawołane.</dd> + </dl> + </dd> + <dt><code>wartośćPoczątkowa</code>{{optional_inline}}</dt> + <dd>Wartość, która zostanie użyta do pierwszego wykonania funkcji <code>callback</code>. Jeśli wartość ta nie zostanie zdefiniowana, ostatni element tablicy zostanie użyty i pominięty. Wołanie reduce lub reduceRight na pustej tablicy bez zdefiniowanej wartości początkowej spowoduje błąd <code>TypeError</code>.</dd> +</dl> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p>Wartość wynikowa redukcji.</p> + +<h2 id="Opis">Opis</h2> + +<p><code>reduceRight</code> wykonuje funkcję <code>callback</code> dla każdego elementu z tablicy, z wyłączeniem miejsc niezdefiniowanych w tablicy, przekazując cztery argumenty: wartość początkową (lub wartość z poprzedniego wywołania funkcji <code>callback</code>), wartość obecnie przetwarzanego elementu, obecny index oraz tablicę na której wykonywane są iteracje.</p> + +<p>Użycie funkcji <code>callback</code> w metodzie reduceRight może wyglądac następująco:</p> + +<pre class="brush: js">array.reduceRight(function(akumulator, obecnaWartość, index, tablica) { + // ... +}); +</pre> + +<p>Przy pierwszym wywołaniu funkcji, <code>akumulator</code> i <code>obecnaWartość</code> mogą mieć jedną z 2 wartości. Jeśli <code>wartośćPoczątkowa</code> została przekazana do <code>reduceRight</code>, to <code>akumulator</code> będzie równy <code>wartośćPoczątkowa</code> a <code>obecnaWartość</code> będzie równa ostatniej wartości z tablicy. Jeśli <code>wartośćPoczątkowa</code> nie została zdefiniowana, wtedy <code>akumulator</code> będzie równy ostatniej wartości z tablicy a <code>obecnaWartość</code> będzie równa przedostatniej wartości z tablicy.</p> + +<p>Jeśli tablica jest pusta i <code>wartośćPoczątkowa</code> nie została zdefiniowana, spowoduje to błąd: {{jsxref("TypeError")}}. Jeśli tablica ma tylko jeden element (niezależnie od jego pozycji) i <code>wartośćPoczątkowa</code> nie została zdefiniowana lub <code>wartośćPoczątkowa</code> została zdefiniowana ale tablica jest pusta, to ta pojedyncza wartość zostanie zwrócona bez wołania funkcji <code>callback</code>.</p> + +<p>Przykład pokazujący, jak przepływają dane do funkcji <code>callback</code>:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(akumulator, obecnaWartość, index, tablica) { + return akumulator + obecnaWartość; +}); +</pre> + +<p>Funkcja <code>callback</code> wykona się 4 razy a argumenty wywołań oraz wartości zwracane będą zgodne z poniższą tabelą:</p> + +<table> + <thead> + <tr> + <th scope="col"><code>callback</code></th> + <th scope="col"><code>akumulator</code></th> + <th scope="col"><code>obecnaWartość</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>tablica</code></th> + <th scope="col">zwrócona wartość</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">first call</th> + <td><code>4</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>7</code></td> + </tr> + <tr> + <th scope="row">second call</th> + <td><code>7</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>9</code></td> + </tr> + <tr> + <th scope="row">third call</th> + <td><code>9</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + <tr> + <th scope="row">fourth call</th> + <td><code>10</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + </tbody> +</table> + +<p>Wartość zwrócona przez <code>reduceRight</code> będzie tym, co zostało zwrócone przez ostatnie wywołanie funkcji <code>callback</code> (<code>10</code>).</p> + +<p>Jeśli <code>wartośćPoczątkowa</code> zostałaby zdefiniowana wyniki wyglądałyby następująco:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(akumulator, obecnaWartość, index, tablica) { + return akumulator + obecnaWartość; +}, 10); +</pre> + +<table> + <thead> + <tr> + <th scope="col"><code>callback</code></th> + <th scope="col"><code>akumulator</code></th> + <th scope="col"><code>obecnaWartość</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>tablica</code></th> + <th scope="col">zwrócona wartość</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">first call</th> + <td><code>10</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>14</code></td> + </tr> + <tr> + <th scope="row">second call</th> + <td><code>14</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>17</code></td> + </tr> + <tr> + <th scope="row">third call</th> + <td><code>17</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>19</code></td> + </tr> + <tr> + <th scope="row">fourth call</th> + <td><code>19</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + <tr> + <th scope="row">fifth call</th> + <td><code>20</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + </tbody> +</table> + +<p>Wartość zwrócona przez <code>reduceRight</code> w tym przypadku, będzie, oczywiście, <code>20</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Zsumuj_wszystkie_wartości_z_tablicy">Zsumuj wszystkie wartości z tablicy</h3> + +<pre class="brush: js">var sum = [0, 1, 2, 3].reduceRight(function(a, b) { + return a + b; +}); +// sum is 6 +</pre> + +<h3 id="Spłaszcz_tablicę_tablic">Spłaszcz tablicę tablic</h3> + +<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) { + return a.concat(b); +}, []); +// flattened is [4, 5, 2, 3, 0, 1] + +</pre> + +<h3 id="Uruchom_asynchroniczne_funkcje_z_callbackami_z_listy_w_taki_sposób_aby_każda_przekazywała_wynik_wykonania_do_następnej">Uruchom asynchroniczne funkcje z callbackami z listy w taki sposób aby każda przekazywała wynik wykonania do następnej</h3> + +<pre class="brush: js">const waterfall = (...functions) => (callback, ...args) => + functions.reduceRight( + (composition, fn) => (...results) => fn(composition, ...results), + callback + )(...args); + +const randInt = max => Math.floor(Math.random() * max) + +const add5 = (callback, x) => { + setTimeout(callback, randInt(1000), x + 5); +}; +const mult3 = (callback, x) => { + setTimeout(callback, randInt(1000), x * 3); +}; +const sub2 = (callback, x) => { + setTimeout(callback, randInt(1000), x - 2); +}; +const split = (callback, x) => { + setTimeout(callback, randInt(1000), x, x); +}; +const add = (callback, x, y) => { + setTimeout(callback, randInt(1000), x + y); +}; +const div4 = (callback, x) => { + setTimeout(callback, randInt(1000), x / 4); +}; + +const computation = waterfall(add5, mult3, sub2, split, add, div4); +computation(console.log, 5) // -> 14 + +// same as: + +const computation2 = (input, callback) => { + const f6 = x=> div4(callback, x); + const f5 = (x, y) => add(f6, x, y); + const f4 = x => split(f5, x); + const f3 = x => sub2(f4, x); + const f2 = x => mult3(f3, x); + add5(f2, input); +}</pre> + +<h3 id="Różnica_pomiędzy_reduce_i_reduceRight">Różnica pomiędzy <code>reduce</code> i <code>reduceRight</code></h3> + +<pre class="brush: js">var a = ['1', '2', '3', '4', '5']; +var left = a.reduce(function(prev, cur) { return prev + cur; }); +var right = a.reduceRight(function(prev, cur) { return prev + cur; }); + +console.log(left); // "12345" +console.log(right); // "54321"</pre> + +<h3 id="Przykład_na_rozwijanie_funkcji">Przykład na rozwijanie funkcji</h3> + +<p>W rozwijaniu funkcji chodzi o to, że w wywołaniu jednej funkcji możemy użyć wielu funkcji. Odbywa się to od prawej do lewej, wołając każdą funkcję z wynikiem zwróconym przez poprzednią.</p> + +<pre class="brush: js">/** + * Function Composition is way in which result of one function can + * be passed to another and so on. + * + * h(x) = f(g(x)) + * + * Function execution happens right to left + * + * https://en.wikipedia.org/wiki/Function_composition + */ + +const compose = (...args) => (value) => args.reduceRight((acc, fn) => fn(acc), value) + +// Increment passed number +const inc = (n) => n + 1 + +// Doubles the passed value +const double = (n) => n * 2 + +// using composition function +console.log(compose(double, inc)(2)); // 6 + +// using composition function +console.log(compose(inc, double)(2)); // 5 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>reduceRight</code> zostało dodane dostandardu ECMA-262 w piątej edycji, w związku z czym może jeszcze nie być dodane do wszystkich implementacji standardu. Można to rozwiązać poprzez użycie poniższego kodu na początku aplikacji, pozwoli to na używanie <code>reduceRight</code> w środowiskach, które tego nie implementują.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.22 +// Reference: http://es5.github.io/#x15.4.4.22 +if ('function' !== typeof Array.prototype.reduceRight) { + Array.prototype.reduceRight = function(callback /*, initialValue*/) { + 'use strict'; + if (null === this || 'undefined' === typeof this) { + throw new TypeError('Array.prototype.reduce called on null or undefined'); + } + if ('function' !== typeof callback) { + throw new TypeError(callback + ' is not a function'); + } + var t = Object(this), len = t.length >>> 0, k = len - 1, value; + if (arguments.length >= 2) { + value = arguments[1]; + } else { + while (k >= 0 && !(k in t)) { + k--; + } + if (k < 0) { + throw new TypeError('Reduce of empty array with no initial value'); + } + value = t[k--]; + } + for (; k >= 0; k--) { + if (k in t) { + value = callback(value, t[k], k, t); + } + } + return value; + }; +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_w_przeglądarkach">Zgodność w przeglądarkach</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.reduceRight")}}</p> +</div> + +<h2 id="Sprawdź_również">Sprawdź również</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduce()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/reverse/index.html b/files/pl/web/javascript/reference/global_objects/array/reverse/index.html new file mode 100644 index 0000000000..6a18aa625c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/reverse/index.html @@ -0,0 +1,56 @@ +--- +title: Array.prototype.reverse() +slug: Web/JavaScript/Reference/Global_Objects/Array/reverse +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse +original_slug: Web/JavaScript/Referencje/Obiekty/Array/reverse +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Odwraca kolejność elementów w tablicy: pierwszy staje się ostatnim, ostatni pierwszym.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.reverse()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>reverse</code> zmienia zawartość tablicy, odwracając kolejność jej elementów.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Odwracanie_kolejno.C5.9Bci_element.C3.B3w_w_tablicy" name="Przyk.C5.82ad:_Odwracanie_kolejno.C5.9Bci_element.C3.B3w_w_tablicy">Przykład: Odwracanie kolejności elementów w tablicy</h3> + +<p>Poniższy przykład tworzy tablicę mojaTablica, posiadającą trzy elementy, następnie odwraca ich kolejność.</p> + +<pre class="brush: js">mojaTablica = new Array("jeden", "dwa", "trzy") +mojaTablica.reverse() +</pre> + +<p>W wyniku działania powyższego kodu:</p> + +<ul> + <li><code>mojaTablica[0]</code> ma wartość "trzy"</li> + <li><code>mojaTablica[1]</code> ma wartość "dwa"</li> + <li><code>mojaTablica[2]</code> ma wartość "jeden"</li> +</ul> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.join()")}}</li> + <li>{{jsxref("Array.prototype.sort()")}}</li> + <li>{{jsxref("TypedArray.prototype.reverse()")}}</li> +</ul> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/reference/global_objects/array/shift/index.html b/files/pl/web/javascript/reference/global_objects/array/shift/index.html new file mode 100644 index 0000000000..a83215d6c5 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/shift/index.html @@ -0,0 +1,49 @@ +--- +title: Array.prototype.shift() +slug: Web/JavaScript/Reference/Global_Objects/Array/shift +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift +original_slug: Web/JavaScript/Referencje/Obiekty/Array/shift +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Usuwa pierwszy element z tablicy i zwraca go. Metoda ta zmienia długość tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.shift()</code></pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Usuwanie_pierwszego_elementu_tablicy" name="Przyk.C5.82ad:_Usuwanie_pierwszego_elementu_tablicy">Przykład: Usuwanie pierwszego elementu tablicy</h3> + +<p>Następujący kod wyświetli tablicę <code>myFish</code>, przed i po usunięciu jej pierwszego elementu. Wyświetli również usunięty element:</p> + +<pre class="brush: js">// przyjmując że funkcja print jest zdefiniowana +var myFish = ["anioł", "klaun", "mandarynka", "chirurg"]; +console.log("myFish przed: " + myFish); +var shifted = myFish.shift(); +console.log("myFish po: " + myFish); +console.log("Usunięto element: " + shifted); +</pre> + +<p>Przykład wyświetli następujący rezultat:</p> + +<pre class="brush: js">myFish przed: ["anioł", "klaun", "mandarynka", "chirurg"] +myFish po: ["klaun", "mandarynka", "chirurg"] +//Usunięto element: anioł +</pre> + +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/slice/index.html b/files/pl/web/javascript/reference/global_objects/array/slice/index.html new file mode 100644 index 0000000000..5de5456984 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/slice/index.html @@ -0,0 +1,100 @@ +--- +title: Array.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/Array/slice +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice +original_slug: Web/JavaScript/Referencje/Obiekty/Array/slice +--- +<p>{{ JSRef }}</p> + +<p>{{EmbedInteractiveExample("pages/js/array-slice.html")}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wydobywa fragment tablicy i zwraca go jako nową tablicę.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.slice([<var>begin</var>[, <var>end</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>begin</code></dt> + <dd>Indeks (liczony od zera) od którego zaczyna się wydobywanie.</dd> + <dd>Jeżeli indeks jest ujemny, <code>begin</code> wskazuje przesunięcie w kolejności od końca. <code>slice(-2)</code> wydobywa kolejno drugi od końca i ostatni element tablicy.</dd> +</dl> + +<dl> + <dt><code>end</code></dt> + <dd>Indeks (liczony od zera) przed którym kończy się wydobywanie. <code>slice</code> wydobywa elementy jednakże nie zawiera <code>end</code>.</dd> +</dl> + +<dl> + <dd><code>slice(1,4)</code> wydobywa elementy od drugiego do czwartego (o indeksach 1, 2 i 3).</dd> +</dl> + +<dl> + <dd>Jeżeli parametr ten ma wartość ujemną to <code>end</code> określa odległość od końca tablicy. <code>slice(2,-1)</code> wydobywa kolejne elementy od trzeciego do przedostatniego.</dd> +</dl> + +<dl> + <dd>Jeżeli <code>end</code> jest pominięty, <code>slice</code> wydobywa wszystkie elementy do końca tablicy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>slice</code> nie zmienia zawartości oryginalnej tablicy, tylko zwraca nową kopię "o jednym poziomie głębokości" zawierającą elementy wyciągnięte z oryginalnej tablicy. Elementy oryginalnej tablicy są kopiowane do nowej tablicy następująco:</p> + +<ul> + <li>W przypadku referencji do obiektów (nie obiektów właściwych), <code>slice</code> kopiuje referencje do nowej tablicy. Obydwie - oryginalna i nowa tablica - odnoszą się do tego samego obiektu. Jeżeli zmienimy obiekt odniesienia, zmiany są widoczne dla obydwu tablic, nowej i oryginalnej.</li> +</ul> + +<ul> + <li>Dla łańcuchów znaków i liczb (nie będących obiektami {{jsxref("String")}} i {{jsxref("Number")}}, <code>slice</code> kopiuje łańcuchy znaków i liczby do nowej tablicy. Zmiana łańcucha znaków lub liczby w jednej z tablic nie wpływa na wartość w drugiej.</li> +</ul> + +<p>Jeżeli nowy element jest dodany do jednej z tablic, to nie wpływa to w żaden sposób na drugą.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_slice" name="Przyk.C5.82ad:_Zastosowanie_slice">Przykład: Zastosowanie <code>slice</code></h3> + +<p>W następującym przykładzie <code>slice</code> tworzy nową tablicę <code>newCar</code> z <code>myCar</code>. Obydwie zawierają odniesienie do obiektu <code>myHonda</code>. Kiedy kolor <code>myHonda</code> jest zmieniany na purpurowy, to obie tablice odzwierciedlają zmianę.</p> + +<pre class="brush: js">//Użycie slice, tworzenie newCar z myCar. +var myHonda = { color: "red", wheels: 4, engine: { cylinders: 4, size: 2.2 } }; +var myCar = [myHonda, 2, "cherry condition", "purchased 1997"]; +var newCar = myCar.slice(0, 2); + +//Wpisz wartości myCar, newCar i color myHonda +// referenced from both arrays. +console.log("myCar = " + myCar.toSource()); +console.log("newCar = " + newCar.toSource()); +console.log("myCar[0].color = " + myCar[0].color); +console.log("newCar[0].color = " + newCar[0].color); + +//zmienia kolor myHonda. +myHonda.color = "purple"; +console.log("Nowy kolor mojej Honda to " + myHonda.color); + +//Wpisz color myHonda odnoszący się do oby tablic +console.log("myCar[0].color = " + myCar[0].color); +console.log("newCar[0].color = " + newCar[0].color); +</pre> + +<p>Ten skrypt wypisze:</p> + +<pre class="brush: js">myCar = [{color:"red", wheels:4, engine:{cylinders:4, size:2.2}}, 2, "cherry condition", "purchased 1997"] +newCar = [{color:"red", wheels:4, engine:{cylinders:4, size:2.2}}, 2] +myCar[0].color = red +newCar[0].color = red +Nowym kolorem mojej Honda jest purpurowy +myCar[0].color = purple +newCar[0].color = purple +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/array/some/index.html b/files/pl/web/javascript/reference/global_objects/array/some/index.html new file mode 100644 index 0000000000..c05147d8ae --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/some/index.html @@ -0,0 +1,111 @@ +--- +title: Array.prototype.some() +slug: Web/JavaScript/Reference/Global_Objects/Array/some +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/some +original_slug: Web/JavaScript/Referencje/Obiekty/Array/some +--- +<p>{{ JSRef }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Sprawdza, czy jakikolwiek element tablicy zalicza test zaimplementowany przez dostarczoną funkcję .</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.some(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code> </dt> + <dd>Funkcja sprawdzająca dla każdego elementu.</dd> + <dt><code>thisArg</code></dt> + <dd>Obiekt do użycia jako <code>this</code> gdy wykonujemy funkcję <code>callback</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>some</code> wykonuje funkcję <code>callback</code>) na każdym elemencie tablicy, aż znajdzie taki, dla którego <code>callback</code> zwróci prawdę (<code>true</code>). Jeżeli taki element zostanie znaleziony, <code>some</code> zakończy swoje działanie i zwróci prawdę (<code>true</code>), w przeciwnym przypadku (gdy <code>callback</code> zwróci fałsz dla każdego z elementów) <code>some</code> zwróci <code>false</code>. Tablice nie są traktowane jako "zwarte" - czyli <code>callback</code> zostanie wywołany dla każdego indeksu tablicy dla którego wartość została przypisana. Nie zostanie wywołany dla indeksów, które zostały usunięte, bądź dla których nigdy nie została przypisana wartość.</p> + +<p><code>callback</code> wywoływana jest z trzema argumentami: wartością elementu, jego indeksem i przemierzaną tablicą.</p> + +<p>W przypadku podania argumentu <code>thisObject</code>, zostanie on przekazany jako <code>this</code> przy każdym wywołaniu <code>callback</code>. Gdy go brak, lub ma wartość <code>null</code>, użyty zostanie obiekt globalny przyporządkowany do <code>callback</code>.</p> + +<p><code>some</code> nie modyfikuje tablicy, na której jest wywołany.</p> + +<p>Zakres elementów przetwarzanych przez <code>some</code> ustalany jest przed pierwszym wywołaniem <code>callback</code>. Elementy dodane do tablicy po wywołaniu <code>some</code> nie zostaną sprawdzone przez <code>callback</code>. Jeśli istniejący, niesprawdzony jeszcze element tablicy zostanie zmieniony lub usunięty przez <code>callback</code>, wartością przekazaną do <code>callback</code> będzie wartość z momentu, w którym <code>some</code> sprawdza dany element; elementy usunięte przed sprawdzeniem będą przekazane jako <code>undefined</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy">Sprawdzanie rozmiaru wszystkich elementów tablicy</h3> + +<p>Następujący przykład sprawdza czy jakiś element tablicy jest większy, bądź równy 10.</p> + +<pre class="brush: js">function czyWiekszyNiz10(element, index, array) { + return element > 10; +} +[2, 5, 8, 1, 4].some(czyWiekszyNiz10); // false +[12, 5, 8, 1, 44].some(czyWiekszyNiz10); // true +</pre> + +<h3 id="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy">Sprawdzanie elementów używając funkcji strzałkowych</h3> + +<p>Funkcje strzałkowe dają krótszą składnię dla tego samego testu.</p> + +<pre class="brush: js">[2, 5, 8, 1, 4].some(x => x > 10); // false +[12, 5, 8, 1, 44].some(x => x > 10); // true +</pre> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<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>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> + +<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>{{CompatGeckoMobile("1.8")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> diff --git a/files/pl/web/javascript/reference/global_objects/array/sort/index.html b/files/pl/web/javascript/reference/global_objects/array/sort/index.html new file mode 100644 index 0000000000..f179b3c45b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/sort/index.html @@ -0,0 +1,123 @@ +--- +title: Array.prototype.sort() +slug: Web/JavaScript/Reference/Global_Objects/Array/sort +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort +original_slug: Web/JavaScript/Referencje/Obiekty/Array/sort +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Sortuje elementy tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.sort([<var>compareFunction</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>compareFunction</code> </dt> + <dd>jest nazwą funkcji porównującej elementy. Jeżeli parametr zostanie pominięty, tablica będzie posortowana w porządku leksykograficznym (alfabetycznie).</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeżeli <code>compareFunction</code> nie zostanie podana, elementy zostaną posortowane leksykograficznie (alfabetycznie - słownikowo) według porównania ich reprezentacji znakowej (łańcucha znaków). Przykładowo "80" znajdzie się przed "9" w porządku leksykograficznym, pomimo że numerycznie 9 poprzedza 80.</p> + +<p>Jeżeli <code>compareFunction</code> zostanie podana, elementy tablicy zostaną posortowane odpowiednio do wartości zwracanej przez funkcję porównującą. Jeżeli <code>a</code> oraz <code>b</code> są dwoma porównywanymi elementami tablicy to:</p> + +<ul> + <li><code>compareFunction(a, b)</code> zwróci wartość mniejszą od 0 - indeks elementu <code>a</code> będzie mniejszy niż indeks <code>b</code> (logicznie <code>a</code> < <code>b</code>).</li> +</ul> + +<ul> + <li><code>compareFunction(a, b)</code> zwróci 0 - pozostawia <code>a</code> oraz <code>b</code> w niezmienionej kolejności względem siebie, jednak w dalszym ciągu oba będą porównywane z innymi elementami (logicznie <code>b</code> = <code>a</code>). Uwaga: Standard ECMAscript nie gwarantuje niezmienionej kolejności (np. Mozilla wszystkie wersje do 2003 roku).</li> +</ul> + +<ul> + <li><code>compareFunction(a, b)</code> zwraca wartość większą od 0 - indeks elementu <code>a</code> będzie większy niż indeks <code>b</code> (logicznie <code>a</code> > <code>b</code>).</li> +</ul> + +<p>Ogólna postać funkcji porównującej wygląda następująco:</p> + +<pre class="brush: js">function compare(a, b) { + if (a mniejsze niż b według kryteriów sortowania) + return -1 + if (a większe od b według kryteriów sortowania) + return 1 + // a równe b + return 0 +} +</pre> + +<p>W celu porównania liczb, zamiast napisów, funkcja porównująca może odejmować <code>b</code> od <code>a</code>:</p> + +<pre class="brush: js">function compareNumbers(a, b) { + return a - b +} +</pre> + +<p>Niektóre implementacje JavaScript wykonują sortowanie stabilne: kolejność elementów <code>a</code> i <code>b</code> nie jest zmieniana jeśli <code>a</code> i <code>b</code> są sobie równe. Jeżeli przed sortowaniem <code>a</code> jest w tablicy wcześniej niż <code>b</code> oraz <code>a</code> i <code>b</code> są sobie równe, to po sortowaniu ich kolejność będzie taka sama (niezależnie od tego, jak zmienią się pozycje elementów <code>a</code> i <code>b</code>).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Tworzenie.2C_wy.C5.9Bwietlanie_i_sortowanie_tablic" name="Przyk.C5.82ad:_Tworzenie.2C_wy.C5.9Bwietlanie_i_sortowanie_tablic">Przykład: Tworzenie, wyświetlanie i sortowanie tablic</h3> + +<p>Następujący przykład tworzy cztery tablice i wyświetla oryginalną tablicę, potem posortowane tablice. Tablice liczbowe są sortowane najpierw bez podania funkcji porównującej, następnie z taką funkcją.</p> + +<pre class="brush: js">stringArray = new Array("Blue","Humpback","Beluga") +numericStringArray = new Array("80","9","700") +numberArray = new Array(40,1,5,200) +mixedNumericArray = new Array("80","9","700",40,1,5,200) + +function compareNumbers(a, b) { + return a - b +} + +console.log("tablicaNapisów: " + stringArray.join()) +console.log("Posortowana: " + stringArray.sort()) + +console.log("tablicaLiczbowa: " + numberArray.join()) +console.log("Posortowana bez funkcji porównującej: " + numberArray.sort()) +console.log("Posortowana z funkcją porównującą: " + numberArray.sort(compareNumbers)) + +console.log("tablicaNapisówLiczbowych: " + numericStringArray.join()) +console.log("Posortowana bez funkcji porównującej: " + numericStringArray.sort()) +console.log("Posortowana z funkcją porównującą: " + numericStringArray.sort(compareNumbers)) + +console.log("tablicaLiczbowaMieszna: " + mixedNumericArray.join()) +console.log("Posortowana bez funkcji porównującej: " + mixedNumericArray.sort()) +console.log("Posortowana z funkcją porównującą: " + mixedNumericArray.sort(compareNumbers)) +</pre> + +<p>Ten przykład wyświetla następujące dane. Jak widać, przy zastosowaniu funkcji porównującej, liczby są sortowane prawidłowo niezależnie od tego czy są przedstawiane jako wartości liczbowe bądź też napisy.</p> + +<pre>tablicaNapisów: Blue,Humpback,Beluga +Posortowana: Beluga,Blue,Humpback + +tablicaLiczbowa: 40,1,5,200 +Posortowana bez funkcji porównującej: 1,200,40,5 +Posortowana z funkcją porównującą: 1,5,40,200 + +tablicaNapisówLiczbowych: 80,9,700 +Posortowana bez funkcji porównującej: 700,80,9 +Posortowana z funkcją porównującą: 9,80,700 + +tablicaLiczbowaMieszna: 80,9,700,40,1,5,200 +Posortowana bez funkcji porównującej: 1,200,40,5,700,80,9 +Posortowana z funkcją porównującą: 1,5,9,40,80,200,700 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.reverse()")}}</li> + <li>{{jsxref("String.prototype.localeCompare()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/splice/index.html b/files/pl/web/javascript/reference/global_objects/array/splice/index.html new file mode 100644 index 0000000000..bbe9d2b474 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/splice/index.html @@ -0,0 +1,87 @@ +--- +title: Array.prototype.splice() +slug: Web/JavaScript/Reference/Global_Objects/Array/splice +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice +original_slug: Web/JavaScript/Referencje/Obiekty/Array/splice +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zmienia zawartość tablicy, dodając nowe elementy podczas usuwania starych elementów.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>array</var>.splice(<var>start</var>, <var>deleteCount</var>[, <var>item1</var>[, <var>item2</var>[, ...]]]) +</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>start</code></dt> + <dd>Indeks od którego rozpoczynamy modyfikację tablicy.</dd> +</dl> + +<dl> + <dt><code>deleteCount</code></dt> + <dd>Liczba całkowita określająca liczbę starych elementów tablicy do usunięcia. Jeżeli <font face="Consolas, Monaco, Andale Mono, monospace">deleteCount</font> wynosi 0, nic nie zostanie usunięte. W tym przypadku należy podać co najmniej jeden nowy element. W przypadku gdy parametr <font face="Consolas, Monaco, Andale Mono, monospace">deleteCount</font> nie został podany (druga forma składni podana powyżej, która jest rozszerzeniem SpiderMonkey), wszystkie elementy o indeksach wyższych <code>lub równych index</code> są usuwane.</dd> +</dl> + +<dl> + <dt><code>itemN</code></dt> + <dd>Elementy dodawane do tablicy. Jeżeli nie określimy żadnych elementów, <code>splice</code> usunie tylko podaną liczbę elementów.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeżeli podamy różną liczbę wstawianych elementów od liczby usuwanych elementów, tablica będzie posiadała inną długość po wywołaniu metody <code>splice</code>.</p> + +<p>Metoda <code>splice</code> zwraca tablicę zawierającą usunięte elementy. Jeżeli usunięty został tylko jeden element, zwracana jest tablica jednoelementowa.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_splice" name="Przyk.C5.82ad:_Zastosowanie_splice">Przykład: Zastosowanie <code>splice</code></h3> + +<p>Następujący skrypt ilustruje użycie splice:</p> + +<pre class="brush: js">myFish = ["anioł", "klaun", "mandarynka", "jesiotr"]; +console.log("myFish: " + myFish); + +removed = myFish.splice(2, 0, "bęben"); +console.log("Po dodaniu 1: " + myFish); +console.log("Usunięty jest: " + removed); + +removed = myFish.splice(3, 1) +console.log("Po usunięciu 1: " + myFish); +console.log("Usunięty jest: " + removed); + +removed = myFish.splice(2, 1, "trąba") +console.log("Po zastąpieniu 1: " + myFish); +console.log("Usunięty jest: " + removed); + +removed = myFish.splice(0, 2, "papuga", "zawilec", "niebieski") +console.log("Po zastąpieniu 2: " + myFish); +console.log("Usunięty jest: " + removed); +</pre> + +<p>Ten skrypt wyświetli:</p> + +<pre>myFish: ["anioł", "klaun", "mandarynka", "jesiotr"] + +Po dodaniu 1: ["anioł", "klaun", "bęben", "mandarynka", "jesiotr"] +Usunięty jest: undefined + +Po usunięciu 1: ["anioł", "klaun", "bęben, "jesiotr"] +Usunięty jest: mandarynka + +Po zastąpieniu 1: ["anioł", "klaun", "trąba", "jesiotr"] +Usunięty jest: bęben + +Po zastąpieniu 2: ["papuga", "zawilec", "niebieski", "trąba", "jesiotr"] +Usunięty jest: ["anioł", "klaun"] +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/array/tolocalestring/index.html b/files/pl/web/javascript/reference/global_objects/array/tolocalestring/index.html new file mode 100644 index 0000000000..45c7ec7864 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/tolocalestring/index.html @@ -0,0 +1,129 @@ +--- +title: Array.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +original_slug: Web/JavaScript/Referencje/Obiekty/Array/toLocaleString +--- +<div>{{JSRef}}</div> + +<div>Metoda <code><strong>toLocaleString()</strong></code> zwraca łańcuch znaków reprezentujący wszystkie elementy w tablicy. Każdy element jest konwerterowany do łańcucha znaku za pomocą lokalnych wywołań <code>toLocaleString. Elementy </code>łaczone są separatorem zdefiniowanym dla lokalnego języka (np. przecinek).</div> + +<div></div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.toLocaleString();</code></pre> + +<h2 id="Opis">Opis</h2> + +<p>Poniższe elementy tablic są konwertowane na łańcuchy znaków za pomocą wbudowanych metod <code>toLocaleString</code></p> + +<ul> + <li><code>Object</code>: {{jsxref("Object.prototype.toLocaleString()")}}</li> + <li><code>Number</code>: {{jsxref("Number.prototype.toLocaleString()")}}</li> + <li><code>Date</code>: {{jsxref("Date.prototype.toLocaleString()")}}</li> +</ul> + +<h2 id="Przykład">Przykład</h2> + +<h3 id="Użycie_toLocaleString">Użycie <code>toLocaleString</code></h3> + +<pre class="notranslate">let numer = 1337; +let data = new Date(); +let tablica = [numer , data, 'foo']; + +let str = tablica.toLocaleString(); + +console.log(str); +// logs '1337,19.11.2020, 17:21:06,foo' +// if run in a Polish (pl-PL) locale with timezone Europe/Warsaw + + +let strEn = tablica.toLocaleString("en-US"); // "1,337,11/19/2020, 5:21:06 PM,foo"</pre> + + + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarze</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Inicjalna definicja</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.4.3', 'Array.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</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>{{jsxref("Array.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/tosource/index.html b/files/pl/web/javascript/reference/global_objects/array/tosource/index.html new file mode 100644 index 0000000000..4a3fa7d355 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/tosource/index.html @@ -0,0 +1,63 @@ +--- +title: Array.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Array/toSource +tags: + - Array + - JavaScript + - Method + - Non-standard + - Prototype + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource +original_slug: Web/JavaScript/Referencje/Obiekty/Array/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</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> + +<p><span class="comment">This shouldn't be here, but until reorganization where pages are moved to their proper places, the title of this article is ambiguous, so it can stay. After reorganization, this should be removed.</span></p> + +<ul> + <li>Dla wbudowanego obiektu <code>Array</code>, <code>toSource</code> zwraca następujący łańcuch znaków sygnalizując, że kod źródłowy jest niedostępny: + + <pre class="brush: js">function Array() { + [natywny kod] +} +</pre> + </li> + <li>Dla instancji {{jsxref("Array")}}, <code>toSource</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Metoda ta jest zazwyczaj wywoływana wewnętrznie przez JavaScript, a nie bezpośrednio w kodzie. Możliwe jest wywołanie <code>toSource</code> podczas debugowania, aby zbadać zawartość tablicy.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Sprawdzanie_kodu_.C5.BAr.C3.B3d.C5.82owego_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_kodu_.C5.BAr.C3.B3d.C5.82owego_tablicy">Przykład: Sprawdzanie kodu źródłowego tablicy</h3> + +<p>Do sprawdzania kodu źródłowego tablicy:</p> + +<pre class="brush: js">var alpha = new Array("a", "b", "c"); + +alpha.toSource() //zwraca ["a", "b", "c"] +</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("Array.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/tostring/index.html b/files/pl/web/javascript/reference/global_objects/array/tostring/index.html new file mode 100644 index 0000000000..ffc994aeae --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/tostring/index.html @@ -0,0 +1,43 @@ +--- +title: Array.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString +original_slug: Web/JavaScript/Referencje/Obiekty/Array/toString +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>toString()</strong></code> zwraca łańcuch znaków reprezentujący daną tablicę wraz z jej elementami.</p> + +<pre class="brush: js">var months = ['Styczeń', 'Luty', 'Marzec', 'Kwiecień']; +months.toString(); // "Styczeń,Luty,Marzec,Kwiecień" +</pre> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.toString()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Array")}} przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}. Dla obiektów Array, metoda <code>toString</code> łączy tablicę i zwraca jeden łańcuch znaków zawierający wszystkie elementy tablicy oddzielone przecinkami. Przykładowo poniższy kod tworzy tablicę i stosuje metodę <code>toString</code>, aby przekształcić tablicę do łańcucha znaków.</p> + +<pre class="brush: js">var monthNames = new Array("Jan","Feb","Mar","Apr") +var myVar = monthNames.toString() // przypisuje "Jan,Feb,Mar,Apr" do zmiennej myVar +</pre> + +<p>JavaScript wywołuje metodę <code>toString</code> automatycznie, gdy tablica jest traktowana jako wartość tekstowa lub kiedy istnieje odniesienie do tej tablicy wewnątrz połączonego łańcucha znaków.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("Array.prototype.join()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/unshift/index.html b/files/pl/web/javascript/reference/global_objects/array/unshift/index.html new file mode 100644 index 0000000000..3d249e3ec8 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/unshift/index.html @@ -0,0 +1,57 @@ +--- +title: Array.prototype.unshift() +slug: Web/JavaScript/Reference/Global_Objects/Array/unshift +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift +original_slug: Web/JavaScript/Referencje/Obiekty/Array/unshift +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Dodaje jeden lub więcej elementów na początek tablicy i zwraca jej nową długość.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.unshift([<var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>element + <i>N</i> + </code> </dt> + <dd>Elementy do dodania na początek tablicy.</dd> +</dl> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy" name="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy">Przykład: Dodawanie elementów do tablicy</h3> + +<p>Następujący kod wyświetli tablicę <code>myFish</code> przed i po dodaniu do niej elementów.</p> + +<pre class="brush: js">myFish = ["anioł", "klaun"]; +console.log("myFish przed: " + myFish); +unshifted = myFish.unshift("bęben", "lew"); +console.log("myFish po: " + myFish); +console.log("Nowa długość tablicy: " + unshifted); +</pre> + +<p>Powyższy przykład wyświetli:</p> + +<pre>myFish przed: ["anioł", "klaun"] +myFish po: ["bęben", "lew", "anioł", "klaun"] +Nowa długość tablicy: 4 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/array/values/index.html b/files/pl/web/javascript/reference/global_objects/array/values/index.html new file mode 100644 index 0000000000..1a2df94435 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/values/index.html @@ -0,0 +1,85 @@ +--- +title: Array.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Array/values +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Metodă + - Prototype + - Tablica +translation_of: Web/JavaScript/Reference/Global_Objects/Array/values +original_slug: Web/JavaScript/Referencje/Obiekty/Array/values +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>values()</code></strong> zwraca nowy obiekt <strong><code>Array Iterator</code></strong> , który zawiera wartości dla każdego indeksu w tablicy.</p> + +<pre class="brush: js">var a = ['w', 'y', 'k', 'o', 'p']; +var iterator = a.values(); + +console.log(iterator.next().value); // w +console.log(iterator.next().value); // y +console.log(iterator.next().value); // k +console.log(iterator.next().value); // o +console.log(iterator.next().value); // p</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>arr</var>.values()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy obiekt {{jsxref("Array")}} iterator.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Iteracja_używająca_pętli_for...of">Iteracja używająca pętli <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code></h3> + +<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p']; +var iterator = arr.values(); + +for (let letter of iterator) { + console.log(letter); +} +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.values', 'Array.prototype.values')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.values', 'Array.prototype.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.values")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/arraybuffer/index.html b/files/pl/web/javascript/reference/global_objects/arraybuffer/index.html new file mode 100644 index 0000000000..a1ac4a5da1 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/arraybuffer/index.html @@ -0,0 +1,223 @@ +--- +title: ArrayBuffer +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +tags: + - ArrayBuffer + - JavaScript + - Konstruktor + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +original_slug: Web/JavaScript/Referencje/Obiekty/ArrayBuffer +--- +<div>{{JSRef}}</div> + +<p>Objekt<strong> <code>ArrayBuffer</code></strong> reprezentuje buffer z surowymi danymi binarnymi o niezmiennej długości. Nie możesz bezpośrednio wpływać na zawartość obiektu <code><strong>ArrayBuffer</strong></code>, możesz natomiast stworzyć jeden z obiektów<code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">typedArray</a></code> lub obiekt {{jsxref("DataView")}} reprezentujący buffer w specjalnym formacie i używać tego obiektu do odczytu oraz zapisu treści buffera.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">new ArrayBuffer(length) +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>długość<code>(length)</code></dt> + <dd>Rozmiar, w bajtach, tworzony z bufferu tablicy (array buffer).</dd> +</dl> + +<h3 id="Wartość_zwrócona">Wartość zwrócona</h3> + +<p>Nowy obiekt <code>ArrayBuffer</code> o określonym rozmiarze. Jego wartości początkowe wynoszą 0.</p> + +<h3 id="Wyjątki">Wyjątki</h3> + +<p>{{jsxref("RangeError")}} pojawi się, jeśli długość (<code>length</code>) jest większa niż {{jsxref("Number.MAX_SAFE_INTEGER")}} (>= 2 ** 53) lub ujemna.</p> + +<h2 id="Opis">Opis</h2> + +<p>Konstruktor <code>ArrayBuffer</code> tworzy nowy <code>ArrayBuffer </code>z podanej długości (<code>length</code>) w bajtach.</p> + +<h3 id="Otrzymywanie_bufferu_tablicy_z_istniejących_danych">Otrzymywanie bufferu tablicy z istniejących danych</h3> + +<ul> + <li><a href="/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">ze stringa Base64</a></li> + <li><a href="/en-US/docs/Web/API/FileReader#readAsArrayBuffer()">z lokalnego pliku</a></li> +</ul> + +<h2 id="Właściwości">Właściwości</h2> + +<dl> + <dt><code>ArrayBuffer.length</code></dt> + <dd>Właściwość długości konstruktura <code>ArrayBuffer</code>, której wartość wynosi 1.</dd> + <dt>{{jsxref("ArrayBuffer.@@species", "get ArrayBuffer[@@species]")}}</dt> + <dd>Funkcja konstruktora jest używana do tworzenia dostarczanych obiektów.</dd> + <dt>{{jsxref("ArrayBuffer.prototype")}}</dt> + <dd>Pozwala dodać właściwości do wszystkich obiektów <code>ArrayBuffer</code>.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("ArrayBuffer.isView", "ArrayBuffer.isView(arg)")}}</dt> + <dd>Zwraca <code>true</code>, jeśli <code>arg</code> jest jednym z widoków <code>ArrayBuffer</code>, jak obiekty <code>typedArray</code> lub {{jsxref("DataView")}}. W innych przypadkach zwraca <code>false</code>.</dd> + <dt>{{jsxref("ArrayBuffer.transfer", "ArrayBuffer.transfer(oldBuffer [, newByteLength])")}} {{experimental_inline}}</dt> + <dd> + <div class="line" id="file-arraybuffer-transfer-LC6">Zwraca nowy <code>ArrayBuffer</code>, którego zawartości są pobrane z danych <code>oldBuffer</code>. Następnie zostaje skrócony lub przedłużony od 0 przez <code>newByteLength</code>.</div> + </dd> +</dl> + +<h2 id="Instancje_ArrayBuffer"><code>Instancje ArrayBuffer</code></h2> + +<p>Wszystkie instancje <code>ArrayBuffer </code>dziedziczą z {{jsxref("ArrayBuffer.prototype")}}.</p> + +<h3 id="Właściwości_2">Właściwości</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Properties')}}</p> + +<h3 id="Metody_2">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Methods')}}</p> + +<dl> + <dt>{{jsxref("ArrayBuffer.slice()")}} {{non-standard_inline}}</dt> + <dd>Posiada tę samą funkcjonalność, jak {{jsxref("ArrayBuffer.prototype.slice()")}}.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<p>W niniejszym przykładzie tworzymy 8-bajtowy buffer z widokiem {{jsxref("Global_Objects/Int32Array", "Int32Array")}} odnoszącym się do buffera:</p> + +<pre class="brush: js">var buffer = new ArrayBuffer(8); +var view = new Int32Array(buffer);</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Zastępiony przez ECMAScript 6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definicja początkowa w standardzie ECMA. Zgłasza, że wymagany jest <code>new</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Cecha</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Wsparcie podstawowe</td> + <td>7.0</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>10</td> + <td>11.6</td> + <td>5.1</td> + </tr> + <tr> + <td><code>ArrayBuffer()</code> bez odsyłacza <code>new</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("44")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>ArrayBuffer.slice()</code> {{non-standard_inline}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}<br> + {{CompatNo}} {{CompatGeckoDesktop("53")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Cecha</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>Wsparcie podstawowe</td> + <td>4.0</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("2")}}</td> + <td>10</td> + <td>11.6</td> + <td>4.2</td> + </tr> + <tr> + <td><code>ArrayBuffer()</code> bez odsyłacza <code>new</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("44")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>ArrayBuffer.slice()</code> {{non-standard_inline}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}<br> + {{CompatNo}} {{CompatGeckoMobile("53")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zapis_kompatybilny">Zapis kompatybilny</h2> + +<p>Od ECMAScript 2015 kontruktory <code>ArrayBuffer</code> muszą być tworzone poprzez operator {{jsxref("Operators/new", "new")}}. Wywoływanie kontruktora ArrayBuffer jako funkcji bez <code>new</code> zaskutkuje od teraz pojawieniem się {{jsxref("TypeError")}}.</p> + +<pre class="brush: js example-bad">var dv = ArrayBuffer(10); +// TypeError: calling a builtin ArrayBuffer constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new ArrayBuffer(10);</pre> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typed arrays</a></li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/bigint/asintn/index.html b/files/pl/web/javascript/reference/global_objects/bigint/asintn/index.html new file mode 100644 index 0000000000..fca69d7e9c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/asintn/index.html @@ -0,0 +1,80 @@ +--- +title: BigInt.asIntN() +slug: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN +tags: + - BigInt + - JavaScript + - Metodă + - Referencja + - asIntN +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/asIntN +--- +<div>{{JSRef}}</div> + +<p>Metoda statyczna <strong><code>BigInt.asIntN</code></strong> jest używana do opakowywania wartości BigInt w wartości całkowite ze znakiem w zakresie od -2<sup>szerokość-1</sup> do 2<sup>szerokość-1</sup>-1.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-asintn.html", "taller")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">BigInt.asIntN(<em>szerokość</em>, <var>bigint</var>);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>szerokość</var></code></dt> + <dd>Liczba bitów dostępnych dla rozmiaru wartości całkowitej (integer).</dd> + <dt><code><var>bigint</var></code></dt> + <dd>Wartość całkowita, którą chcemy wpasować w daną liczbę bitów.</dd> +</dl> + +<h3 id="Wynik">Wynik</h3> + +<p>Wartość <code><var>bigint</var></code> modulo 2<sup><code><var>szerokość</var></code></sup> jako liczba całkowita ze znakiem.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Pozostawanie_w_zakresie_arytmetyki_64-bitowej">Pozostawanie w zakresie arytmetyki 64-bitowej</h3> + +<p>Metoda <code>BigInt.asIntN()</code> może być użyteczna do tego, by pozostać w zakresie obliczeń arytmetyki 64-bitowej.</p> + +<pre class="brush: js">const max = 2n ** (64n - 1n) - 1n; + +BigInt.asIntN(64, max); +// ↪ 9223372036854775807n + +BigInt.asIntN(64, max + 1n); +// ↪ -9223372036854775807n +// wartość ujemna ze względu na przepełnienie +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.asintn', 'BigInt.asIntN()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.BigInt.asIntN")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("BigInt")}}</li> + <li>{{JSxRef("BigInt.asUintN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/bigint/asuintn/index.html b/files/pl/web/javascript/reference/global_objects/bigint/asuintn/index.html new file mode 100644 index 0000000000..63ed40473a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/asuintn/index.html @@ -0,0 +1,79 @@ +--- +title: BigInt.asUintN() +slug: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN +tags: + - BigInt + - JavaScript + - Metodă + - Referencja + - asUintN +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/asUintN +--- +<div>{{JSRef}}</div> + +<p>Metoda statyczna <strong><code>BigInt.asUintN</code></strong> jest używana do opakowywania wartości BigInt w wartości całkowite bez znaku w zakresie od 0 do 2<sup>szerokość</sup>-1.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-asuintn.html", "taller")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">BigInt.asUintN(<em>szerokość</em>, <var>bigint</var>);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>szerokość</var></code></dt> + <dd>Liczba bitów dostępnych dla rozmiaru wartości całkowitej (integer).</dd> + <dt><code><var>bigint</var></code></dt> + <dd>Wartość całkowita, którą chcemy wpasować w daną liczbę bitów.</dd> +</dl> + +<h3 id="Wynik">Wynik</h3> + +<p>Wartość <code><var>bigint</var></code> modulo 2<sup><code><var>szerokość</var></code></sup> jako wartość całkowita bez znaku.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Pozostawanie_w_zakresie_arytmetyki_64-bitowej">Pozostawanie w zakresie arytmetyki 64-bitowej</h3> + +<p>Metoda <code>BigInt.asUintN()</code> może być użyteczna do tego, by pozostać w zakresie obliczeń arytmetyki 64-bitowej.</p> + +<pre class="brush: js">const max = 2n ** 64n - 1n; + +BigInt.asUintN(64, max); +// ↪ 18446744073709551615n + +BigInt.asUintN(64, max + 1n); +// ↪ 0n +// zero z powodu przepełnienia</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.asuintn', 'BigInt.asUintN()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.BigInt.asUintN")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("BigInt")}}</li> + <li>{{JSxRef("BigInt.asIntN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/bigint/index.html b/files/pl/web/javascript/reference/global_objects/bigint/index.html new file mode 100644 index 0000000000..4f66412f67 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/index.html @@ -0,0 +1,294 @@ +--- +title: BigInt +slug: Web/JavaScript/Reference/Global_Objects/BigInt +tags: + - BigInt + - JavaScript + - Referencja +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt +--- +<div>{{JSRef}}</div> + +<p><strong><code>BigInt</code></strong> jest wbudowanym obiektem umożliwiającym reprezentowanie całych liczb większch niż 2<sup>53</sup> - 1, ile wynosi największa liczba, którą JavaScript może faktycznie reprezentować przez prymityw {{JSxRef("Number")}}, co jest też reprezentowane przez stałą {{JSxRef("Number.MAX_SAFE_INTEGER")}}. <strong><code>BigInt</code></strong> może być używany do dowolnie dużych liczb całkowitych.</p> + +<dl> +</dl> + +<h2 id="Opis">Opis</h2> + +<p><code>BigInt</code> jest tworzony przez dodanie <code>n</code> na końcu literału liczby — <code>10n</code> — lub przez wywołanie funkcji <code>BigInt()</code>.</p> + +<pre class="brush: js">const najwiekszyInt = 9007199254740991n + +const tezDuzaLiczba = BigInt(9007199254740991) +// ↪ 9007199254740991n + +const duzyString = BigInt("9007199254740991") +// ↪ 9007199254740991n + +const duzyHex = BigInt("0x1fffffffffffff") +// ↪ 9007199254740991n + +const duzyBin = BigInt("0b11111111111111111111111111111111111111111111111111111") +// ↪ 9007199254740991n +</pre> + +<p><code>BigInt</code> jest w pewnym sensie podobny do {{JSxRef("Number")}} ale też różni się od niego w kilku kluczowych sprawach — nie może być używany z metodami wbudowanego obiektu {{JSxRef("Math")}}, a także nie może być mieszany z instancjami <code>Number</code> w żadnych operacjach; konieczne jest wymuszenie tego samego typu operandów. Należy uważać z wymuszaniem typów w jedną i drugą stronę, w szczególności precyzja <code>BigInt</code> może być utracona przy wymuszonej konwersji do typu <code>Number</code>.</p> + +<h3 id="Informacje_o_typie">Informacje o typie</h3> + +<p>Przy sprawdzeniu za pomocą <code>typeof</code>, <code>BigInt</code> zwróci "bigint":</p> + +<pre class="brush: js">typeof 1n === 'bigint' // true +typeof BigInt('1') === 'bigint' // true +</pre> + +<p>Obudowany w <code>Object</code>, <code>BigInt</code> będzie rozważany jako zwykły "obiekt":</p> + +<pre class="brush: js">typeof Object(1n) === 'object' // true +</pre> + +<h3 id="Operatory">Operatory</h3> + +<p>Z <code>BigInt</code>ami (lub <code>BigInt</code>ami obudowanymi w obiekty) mogą być używane następujące operatory: : <code>+</code>, <code>*</code>, <code>-</code>, <code>**</code>, <code>%</code>.</p> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Operatory bitowe</a> także są wspierane, z wyjątkiem <code>>>></code> (przesunięcie w prawo z dopełnieniem zerami), gdyż wszystkie <code>BigInt</code>y mają znak.</p> + +<p>Niewspierany jest także operator jednoargumentowy (<code>+</code>), <a href="https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs">aby nie złamać zasad asm.js</a>.</p> + +<pre class="brush: js">const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER) +// ↪ 9007199254740991n + +const maxPlusOne = previousMaxSafe + 1n +// ↪ 9007199254740992n + +const theFuture = previousMaxSafe + 2n +// ↪ 9007199254740993n, this works now! + +const multi = previousMaxSafe * 2n +// ↪ 18014398509481982n + +const subtr = multi – 10n +// ↪ 18014398509481972n + +const mod = multi % 10n +// ↪ 2n + +const bigN = 2n ** 54n +// ↪ 18014398509481984n + +bigN * -1n +// ↪ –18014398509481984n +</pre> + +<p>Operator <code>/</code> także działa zgodnie z założeniami z całymi liczbami.</p> + +<p>Jako że są to <code>BigInt</code>y, a nie <code>BigDecimal</code>, operacja dzielenia będzie zaokroąglała wynik do <code>0</code> (zatem można prościej powiedzieć, że nie zwraca ułamkowej części wyniku).</p> + +<div class="blockIndicator warning"> +<p>Ułamkowy wynik operacji będzie przycięty, kiedy używany jest <code>BigInt</code>.</p> +</div> + +<pre class="brush: js">const expected = 4n / 2n +// ↪ 2n + +const rounded = 5n / 2n +// ↪ 2n, not 2.5n + +</pre> + +<h3 id="Porównania">Porównania</h3> + +<p><code>BigInt</code> nie jest ściśle równy {{JSxRef("Number")}}, ale jest równy w luźnym sensie, zatem:</p> + +<pre class="brush: js">0n === 0 +// ↪ false + +0n == 0 +// ↪ true</pre> + +<p>{{JSxRef("Global_Objects/Number", "Number")}} i <code>BigInt</code> mogą być porównywane w zwyczajny sposób:</p> + +<pre class="brush: js">1n < 2 +// ↪ true + +2n > 1 +// ↪ true + +2 > 2 +// ↪ false + +2n > 2 +// ↪ false + +2n >= 2 +// ↪ true</pre> + +<p>Mogą być też mieszane w tablicach i sortowane:</p> + +<pre class="brush: js">const mixed = [4n, 6, -12n, 10, 4, 0, 0n] +// ↪ [4n, 6, -12n, 10, 4, 0, 0n] + +mixed.sort() +// ↪ [-12n, 0, 0n, 4n, 4, 6, 10] +</pre> + +<p>Zauważ, że porównania z <code>BigInt</code>ami opakowanymi w obiekty działają jak z innymi obiektami, wskazując równość tylko wtedy, kiedy ta sama instancja obiektu znajduje się po obu stronach porównania:</p> + +<pre class="brush: js">0n === Object(0n) // false +Object(0n) === Object(0n) // false + +const o = Object(0n) +o === o // true +</pre> + +<h3 id="Instrukcje_warunkowe">Instrukcje warunkowe</h3> + +<p><code>BigInt</code> zachowuje się jak {{JSxRef("Global_Objects/Number", "Number")}} w przypadkach, gdy:</p> + +<ul> + <li>jest konwertowany na {{JSxRef("Global_Objects/Boolean", "Boolean")}} za pomocą funkcji {{JSxRef("Global_Objects/Boolean", "Boolean")}};</li> + <li>jest używany z <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Logical_Operators">operatorami logicznymi</a> <code>||</code>, <code>&&</code> lub <code>!</code>;</li> + <li>w instrukcjach warunkowych {{JSxRef("Statements/if...else", "if")}}.</li> +</ul> + +<pre class="brush: js">if (0n) { + console.log('Hello from the if!') +} else { + console.log('Hello from the else!') +} + +// ↪ "Hello from the else!" + +0n || 12n +// ↪ 12n + +0n && 12n +// ↪ 0n + +Boolean(0n) +// ↪ false + +Boolean(12n) +// ↪ true + +!12n +// ↪ false + +!0n +// ↪ true +</pre> + +<h2 id="Konstruktor">Konstruktor</h2> + +<dl> + <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/BigInt">BigInt()</a></code></dt> + <dd>Tworzy obiekty {{jsxref("BigInt")}}.</dd> +</dl> + +<h2 id="Metody_statyczne">Metody statyczne</h2> + +<dl> + <dt>{{JSxRef("BigInt.asIntN()")}}</dt> + <dd>Opakowuje wartość <code>BigInt</code> w liczbę całkowitą ze znakiem o wartości między <code>-2<var><sup>width</sup></var><sup>-1</sup></code> a <code>2<var><sup>width</sup></var><sup>-1</sup> - 1</code>.</dd> + <dt>{{JSxRef("BigInt.asUintN()")}}</dt> + <dd>Opakowuje wartość <code>BigInt</code> w liczbę całkowitą bez znaku o wartości między <code>0</code> a <code>2<var><sup>width</sup></var> - 1</code>.</dd> +</dl> + +<h2 id="Metody_instancyjne">Metody instancyjne</h2> + +<dl> + <dt>{{JSxRef("BigInt.prototype.toLocaleString()")}}</dt> + <dd>Zwraca string z zależną od języka reprezentacją danej liczby. Nadpisuje metodę {{JSxRef("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{JSxRef("BigInt.prototype.toString()")}}</dt> + <dd>Zwraca string reprezentujący dany obiekt w określonym źródle. Nadpisuje metodę {{JSxRef("Object.prototype.toString()")}}.</dd> + <dt>{{JSxRef("BigInt.prototype.valueOf()")}}</dt> + <dd>Zwraca prymitywną wartość danego obiektu. Nadpisuje metodę {{JSxRef("Object.prototype.valueOf()")}}.</dd> +</dl> + +<h2 id="Zalecenia_w_użyciu">Zalecenia w użyciu</h2> + +<h3 id="Wymuszanie_typów">Wymuszanie typów</h3> + +<p>Ponieważ wymuszanie tupów między {{JSxRef("Number")}} a <code>BigInt</code> może prowadzić do utraty precyzji, zaleca się używanie jedynie typu <code>BigInt</code>, gdy można się spodziewać, że pojawią się wartości przekraczające 2<sup>53</sup> i nie należy wówczas przeprowadzać konwersji między tymi typami.</p> + +<h3 id="Kryptografia">Kryptografia</h3> + +<p>Operacje wspierane dla <code>BigInt</code>ów nie są stałe czasowo, dlatego też typ <code>BigInt</code> <a href="https://www.chosenplaintext.ca/articles/beginners-guide-constant-time-cryptography.html">nie nadaje się do użycia w kryptografii</a>.</p> + +<h3 id="Użycie_w_JSON">Użycie w JSON</h3> + +<p>Użycie {{jsxref("JSON.stringify()")}} z dowolną wartością typu <code>BigInt</code> spowoduje błąd <code>TypeError</code>, ponieważ wartości <code>BigInt</code> nie są domyślnie serialozowane w JSONie. Jednakże, jeśli taka operacja jest potrzebna, możesz zaimplemntować własną metodę <code>toJSON</code>:</p> + +<pre class="brush: js">BigInt.prototype.toJSON = function() { return this.toString() }</pre> + +<p>Zamiast wyrzucania wyjątku, <code>JSON.stringify</code> będzie teraz zwracać string:</p> + +<pre class="brush: js">JSON.stringify(BigInt(1)) +// '"1"'</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Obliczanie_liczb_pierwszych">Obliczanie liczb pierwszych</h3> + +<pre class="brush: js">// Zwraca true jeśl dany BigInt jest liczbą pierwszą +function isPrime(p) { + for (let i = 2n; i * i <= p; i++) { + if (p % i === 0n) return false; + } + return true +} + +// Przyjmuje BigInt n jako argument, zwraca n-tą liczbę pierwszą jako BigInt +function nthPrime(nth) { + let maybePrime = 2n + let prime = 0n + + while (nth >= 0n) { + if (isPrime(maybePrime)) { + nth-- + prime = maybePrime + } + maybePrime++ + } + + return prime +} + +nthPrime(20n) +// ↪ 73n</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName("ESDraft", "#sec-bigint-objects", "<code>BigInt</code> objects")}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div class="hidden">The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a class="external" href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</div> + +<p>{{Compat("javascript.builtins.BigInt")}}</p> + +<h3 id="Postęp_implementacji">Postęp implementacji</h3> + +<p>Poniższa tabela przedstawia postęp implementacji tej funkcji języka JavaScript, gdyż nie osiągnęła ona jeszcze pełnej stabilności między przeglądarkami. Dane są generowane przez uruchamianie odpowiednich testów tej funkcji w <a href="https://github.com/tc39/test262">Test262</a>,standrardowym zestawie testów JavaScript, „nocnych wersji” (ang. <em>nightly build</em>) lub ostatnich wydań silnika JavaScript w każdej przeglądarce.</p> + +<div>{{EmbedTest262ReportResultsTable("BigInt")}}</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("Number")}}</li> + <li>{{JSxRef("Number.MAX_SAFE_INTEGER")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/bigint/tostring/index.html b/files/pl/web/javascript/reference/global_objects/bigint/tostring/index.html new file mode 100644 index 0000000000..8c3cc98381 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/tostring/index.html @@ -0,0 +1,96 @@ +--- +title: BigInt.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/BigInt/toString +tags: + - BigInt + - JavaScript + - Metodă + - Prototyp + - toString() +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toString +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/toString +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>toString()</code></strong> zwraca ciąg znaków (<em>string</em>), reprezentujący dany obiekt {{jsxref("BigInt")}}. Końcowy znak "n" nie jest częścią wynikowego ciągu znaków.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-tostring.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>bigIntObj</var>.toString([podstawa])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>podstawa</code>{{optional_inline}}</dt> + <dd>Argument opcjonalny. Liczba całkowita w zakresie od 2 do 36, reprezentująca bazę systemu liczbowego, w którym ma być przedstawiona dana wartość {{jsxref("BigInt")}}.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Ciąg znaków reprezentujący dany obiekt {{jsxref("BigInt")}}.</p> + +<h3 id="Wyjątki">Wyjątki</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Jeśli do metody <code>toString()</code> przekazana jest podstawa systemu mniejsza niż 2 lub większa niż 36, wyrzucany jest błąd {{jsxref("RangeError")}}.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt {{jsxref("BigInt")}} nadpisuje metodę <code>toString()</code> obiektu {{jsxref("Object")}}; nie dziedziczy metody {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref( "BigInt")}}, metoda <code>toString()</code> zwraca ciąg znaków reprezentujący daną wartość w systemie pozycyjnym o zadanej bazie.</p> + +<p>Metoda <code>toString()</code> parsuje pierwszy argument i próbuje zwrócić ciąg znaków reprezentujący daną wartość w systemie o zadanej podstawie (bazie). Dla systemów o podstawie większej niż 10, do reprezentacji cyfr większych niż 9 używane są kolejne litery alfabetu łacińskiego. Przykładowo, dla wartości w systemie szesnastkowym (o podstawie równej 16), używane są litery od <code>a</code> do <code>f</code>.</p> + +<p>Jeśli <code>podstawa</code> nie jest podana, zakłada się, że preferowaną bazą systemu jest 10.</p> + +<p>Jeśli wartość <code>bigIntObj</code> jest ujemna, znak jest zachowywany. Dzieje się tak nawet wtedy, gdy podstawą jest 2; zwracany ciąg cyfr jest dodatnią reprezentacją <code>bigIntObj</code>, poprzedzoną znakiem <code>-</code>, <strong>nie</strong> dopełnieniem dwójkowym <code>bigIntObj</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_toString">Użycie <code>toString</code></h3> + +<pre class="brush: js">17n.toString(); // '17' +66n.toString(2); // '1000010' +254n.toString(16); // 'fe' +-10n.toString(2); // -1010' +-0xffn.toString(2); // '-11111111' +</pre> + +<h3 id="BigInt_z_ujemnym_zerem"><code>BigInt</code> z ujemnym zerem</h3> + +<p>Nie ma obiektów <code>BigInt</code> reprezentujących ujemne zero, tak jak nie ma ujemnych zer wśród liczb całkowitych.. <code>-0.0</code> jest zmiennoprzecinkową koncepcją zmiennoprzecinkową IEEE, która pojawia się w języku JavaScript jedynie w typie {{jsxref("Number")}}.</p> + +<pre class="brush: js">(-0n).toString(); // '0' +BigInt(-0).toString(); // '0'</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.prototype.tostring', 'BigInt.prototype.toString()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.BigInt.toString")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("BigInt.prototype.toLocaleString()")}}</li> + <li>{{jsxref("BigInt.prototype.valueOf()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/bigint/valueof/index.html b/files/pl/web/javascript/reference/global_objects/bigint/valueof/index.html new file mode 100644 index 0000000000..e1ed582948 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/valueof/index.html @@ -0,0 +1,60 @@ +--- +title: BigInt.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf +tags: + - BigInt + - JavaScript + - Metodă + - Prototype + - valueOf() +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/valueOf +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>valueOf()</code></strong> zwraca opakowaną wartość prymitywną obiektu {{jsxref("BigInt")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-valueof.html","shorter")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>bigIntObj</var>.valueOf()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>BigInt reprezentujący wartość prymitywną danego obiektu {{jsxref("BigInt")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_valueOf">Użycie <code>valueOf</code></h3> + +<pre class="brush: js">typeof Object(1n); // object +typeof Object(1n).valueOf(); // bigint +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.prototype.valueof', 'BigInt.prototype.valueOf()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.BigInt.valueOf")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("BigInt.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/boolean/index.html b/files/pl/web/javascript/reference/global_objects/boolean/index.html new file mode 100644 index 0000000000..29719a9605 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/boolean/index.html @@ -0,0 +1,112 @@ +--- +title: Boolean +slug: Web/JavaScript/Reference/Global_Objects/Boolean +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +original_slug: Web/JavaScript/Referencje/Obiekty/Boolean +--- +<p>{{JSRef("Global_Objects", "Boolean")}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Obiekt <code>Boolean</code> jest obiektem opakowującym (ang.<em>wrapper</em> ) dla wartości logicznych.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>new Boolean([wartosc])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>wartosc</code> </dt> + <dd>Początkowa wartość obiektu <code>Boolean</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość przekazana jako pierwszy parametr jest w razie konieczności konwertowana do wartości logicznej. Jeśli wartość zostanie pominięta lub będzie równa 0, -0, null, false, <code>NaN</code>, będzie pustym łańcuchem znaków ("") lub będzie niezdefiniowana, obiekt przyjmie początkową wartość false. Dowolna inna wartość, włączając łańcuch znaków <code>"false"</code>, spowoduje utworzenie obiektu z początkową wartością true.</p> + +<p>Nie należy mylić prostych wartości logicznych true i false z wartościami <code>true</code> i <code>false</code> obiektu Boolean.</p> + +<p>Każdy obiekt, którego wartością nie jest wartość <code>undefined</code> lub <code>null</code>, w tym obiekt Boolean posiadający wartość <code>false</code>, traktowany jest w instrukcjach warunkowych jako <code>true</code>. Przykładowo warunek w poniższej instrukcji if będzie miał wartość <code>true</code>:</p> + +<pre class="eval">x = new Boolean(false); +if (x) { + // . . . ten kod zostanie wykonany +} +</pre> + +<p>Taka sytuacja nie zachodzi przy prostych wartościach logicznych. Przykładowo warunek w poniższej instrukcji if będzie miał wartość <code>false</code>::</p> + +<pre class="eval">x = false; +if (x) { + // . . . ten kod nie zostanie wykonany +} +</pre> + +<p>Nie należy zatem używać obiektu <code>Boolean</code> do konwersji wartości nie będącej wartością logiczną na wartość typu Boolean. Zamiast tego należy skorzystać z funkcji <code>Boolean()</code>:</p> + +<pre class="eval">x = Boolean(wyrazenie); // zalecane +x = new Boolean(wyrazenie); // nie należy używać +</pre> + +<p>Jeśli jako wartość początkową określony zostanie dowolny obiekt, w tym obiekt Boolean o wartości <code>false</code>, nowy obiekt Boolean będzie miał wartość <code>true</code>.</p> + +<pre class="eval">myFalse = new Boolean(false); // wartość początkowa: false +g = new Boolean(myFalse); // wartość początkowa: true +myString = new String("Hello"); // obiekt String (łańcuch znaków) +s = new Boolean(myString); // wartość początkowa: true +</pre> + +<p><strong>Nie należy</strong> używać obiektu Boolean zamiast prostej wartości logicznej.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt><code>Boolean.length</code></dt> + <dd>Length property whose value is 1.</dd> +</dl> + +<dl> + <dt>{{jsxref("Boolean.prototype")}}</dt> + <dd>Definiuje własność współdzieloną przez wszystkie obiekty Boolean.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<p>Globalny obiekt <code>Boolean</code> sam w sobie nie zawiera żadnych metod, jednak dziedziczy on niektóre metody poprzez łańcuch prototypu.</p> + +<div>{{jsOverrides("Function", "Methods")}}</div> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Efa.C5.82sz.E2.80.9D" name="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Efa.C5.82sz.E2.80.9D">Tworzenie obiektów <code>Boolean</code> z początkową wartością „fałsz”</h3> + +<pre class="brush: js">bNoParam = new Boolean(); +bZero = new Boolean(0); +bNull = new Boolean(null); +bEmptyString = new Boolean(""); +bfalse = new Boolean(false); +</pre> + +<h3 id="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Eprawda.E2.80.9D" name="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Eprawda.E2.80.9D">Tworzenie obiektów <code>Boolean</code> z początkową wartością „prawda”</h3> + +<pre class="brush: js">btrue = new Boolean(true); +btrueString = new Boolean("true"); +bfalseString = new Boolean("false"); +bSuLin = new Boolean("Su Lin"); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Boolean.prototype")}}</li> + <li>{{Glossary("Boolean")}}</li> + <li><a href="http://en.wikipedia.org/wiki/Boolean_data_type">Boolean data type (Wikipedia)</a></li> +</ul> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/reference/global_objects/boolean/tosource/index.html b/files/pl/web/javascript/reference/global_objects/boolean/tosource/index.html new file mode 100644 index 0000000000..532bffc87c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/boolean/tosource/index.html @@ -0,0 +1,52 @@ +--- +title: Boolean.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Boolean/toSource +tags: + - Boolean + - JavaScript + - Method + - Non-standard + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toSource +original_slug: Web/JavaScript/Referencje/Obiekty/Boolean/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków z kodem źródłowym obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>booleanObj</var>.toSource() +Boolean.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 wbudowanego obiektu <code>Boolean</code> metoda <code>toSource</code> zwraca następujący łańcuch znaków, oznaczający, że kod źródłowy nie jest dostępny: + + <pre class="brush: js">function Boolean() { + [native code] +} +</pre> + </li> +</ul> + +<ul> + <li>dla instancji obiektu <code>Boolean</code> metoda <code>toSource</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Metoda ta jest zwykle stosowana wewnętrznie przez interpreter JavaScriptu, a nie bezpośrednio w kodzie programów.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/boolean/tostring/index.html b/files/pl/web/javascript/reference/global_objects/boolean/tostring/index.html new file mode 100644 index 0000000000..708dae8151 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/boolean/tostring/index.html @@ -0,0 +1,42 @@ +--- +title: Boolean.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Boolean/toString +tags: + - Boolean + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toString +original_slug: Web/JavaScript/Referencje/Obiekty/Boolean/toString +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca ciąg znaków reprezentujący dany obiekt Boolean</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>bool</var>.toString()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Boolean")}} przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}, nie dziedziczy metody {{jsxref("Object.prototype.toString()")}}. Dla obiektów <code>Boolean</code> metoda <code>toString</code> zwraca ich tekstową reprezentację.</p> + +<p>JavaScript wywołuje metodę <code>toString</code> samoczynnie, kiedy instancja obiektu {{jsxref("Boolean")}} ma być reprezentowana jako wartość tekstowa lub kiedy instancja obiektu {{jsxref("Boolean")}} jest składnikiem konkatenacji ciągu(-ów) znaków.</p> + +<p>Dla obiektów i wartości {{jsxref("Boolean")}} wbudowana metoda <code>toString</code> zwraca ciąg znaków "<code>true</code>" lub "<code>false</code>" w zależności od wartości obiektu boolowskiego. W poniższym przykładzie <code>flaga.toString</code> zwraca "<code>true</code>".</p> + +<pre class="brush: js">var flaga = new Boolean(true) +var mojaZmienna=flaga.toString() +</pre> + +<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/boolean/valueof/index.html b/files/pl/web/javascript/reference/global_objects/boolean/valueof/index.html new file mode 100644 index 0000000000..005bde3e87 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/boolean/valueof/index.html @@ -0,0 +1,44 @@ +--- +title: Boolean.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf +tags: + - Boolean + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf +original_slug: Web/JavaScript/Referencje/Obiekty/Boolean/valueOf +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość prostą obiektu {{jsxref("Boolean")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>bool</var>.valueOf()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>valueOf</code> obiektu {{jsxref("Boolean")}} zwraca wartość prostą obiektu {{jsxref("Boolean")}} lub literału {{jsxref("Boolean")}} jako typ Boolean.</p> + +<p>Metoda ta jest zwykle wywoływana wewnętrznie przez interpreter JavaScriptu, a nie w typowym kodzie w JavaScripcie.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_valueOf" name="Przyk.C5.82ad:_Zastosowanie_valueOf">Przykład: Zastosowanie <code>valueOf</code></h3> + +<pre class="brush: js">var x = new Boolean(); +myVar = x.valueOf() // przypisuje myVar wartość false +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/dataview/index.html b/files/pl/web/javascript/reference/global_objects/dataview/index.html new file mode 100644 index 0000000000..0df48f7f98 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/dataview/index.html @@ -0,0 +1,119 @@ +--- +title: DataView +slug: Web/JavaScript/Reference/Global_Objects/DataView +translation_of: Web/JavaScript/Reference/Global_Objects/DataView +original_slug: Web/JavaScript/Referencje/Obiekty/DataView +--- +<div>{{JSRef}}</div> + +<p><strong><code>DataView</code></strong> udostępnia niskopoziowy interfejs do zapisu i odczytu typów numerycznych w formie {{jsxref("ArrayBuffer")}} niezależnie od kodowania platformy.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">new DataView(buffer [, byteOffset [, byteLength]])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>buffer</code></dt> + <dd>Istniejący {{jsxref("ArrayBuffer")}} lub {{jsxref("SharedArrayBuffer")}} {{experimental_inline}} używany jako pamięć dla obiektu <code>DataView</code> .</dd> + <dt><code>byteOffset</code> {{optional_inline}}</dt> + <dd>The offset, in bytes, to the first byte in the specified buffer for the new view to reference. If not specified, the view of the buffer will start with the first byte.</dd> + <dt><code>byteLength</code> {{optional_inline}}</dt> + <dd>The number of elements in the byte array. If unspecified, length of the view will match the buffer's length.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>A new <code>DataView</code> object representing the specified data buffer.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt><code>{{jsxref("RangeError")}}</code></dt> + <dd>Thrown if the <code>byteOffset</code> and <code>byteLength</code> result in the specified view extending past the end of the buffer.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<h3 id="Endianness">Endianness</h3> + +<p>Multi-byte number formats are represented in memory differently depending on machine architecture, see {{Glossary("Endianness")}} for an explanation. DataView accessors provide explicit control of how data will be accessed irrespective of the platform architecture's endianness.</p> + +<pre class="brush: js">var littleEndian = (function() { + var buffer = new ArrayBuffer(2); + new DataView(buffer).setInt16(0, 256, true /* littleEndian */); + // Int16Array uses the platform's endianness. + return new Int16Array(buffer)[0] === 256; +})(); +console.log(littleEndian); // true or false +</pre> + +<h2 id="Properties">Properties</h2> + +<p>All <code>DataView</code> instances inherit from {{jsxref("DataView.prototype")}} and allows the addition of properties to all DataView objects.</p> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Properties')}}</p> + +<h2 id="Methods">Methods</h2> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Methods')}}</p> + +<h2 id="Example">Example</h2> + +<pre class="brush: js">var buffer = new ArrayBuffer(16); +var dv = new DataView(buffer, 0); + +dv.setInt16(1, 42); +dv.getInt16(1); //42 +</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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Superseded by ECMAScript 6</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition in an ECMA standard</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview-constructor', 'DataView')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("javascript.builtins.DataView")}}</p> + +<h2 id="Compatibility_notes">Compatibility notes</h2> + +<p>Starting with Firefox 40, <code>DataView</code> requires to be constructed with a {{jsxref("Operators/new", "new")}} operator. Calling <code>DataView()</code> as a function without <code>new</code>, will throw a {{jsxref("TypeError")}} from now on.</p> + +<pre class="brush: js example-bad">var dv = DataView(buffer, 0); +// TypeError: calling a builtin DataView constructor without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new DataView(buffer, 0);</pre> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a class="link-https" href="https://github.com/jDataView/jDataView">jDataView</a>: JavaScript library that polyfills and extends the <code>DataView</code> API to all browsers and Node.js.</li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getdate/index.html b/files/pl/web/javascript/reference/global_objects/date/getdate/index.html new file mode 100644 index 0000000000..5828087a48 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getdate/index.html @@ -0,0 +1,48 @@ +--- +title: Date.prototype.getDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/getDate +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getDate +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca dzień miesiąca dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getDate()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getDate</code> to liczby całkowite z przedziału liczb pomiędzy 1 a 31.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getDate" name="Przyk.C5.82ad:_Zastosowanie_getDate">Przykład: Zastosowanie <code>getDate()</code></h3> + +<p>Druga instrukcja poniżej przydziela wartość 25 do zmiennej <code>dzien</code>, wartość oparta na <code>Date</code>, obiektu <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var dzien = Xmas95.getDate(); + +console.log(dzien), // 25 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getday/index.html b/files/pl/web/javascript/reference/global_objects/date/getday/index.html new file mode 100644 index 0000000000..021381df42 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getday/index.html @@ -0,0 +1,48 @@ +--- +title: Date.prototype.getDay() +slug: Web/JavaScript/Reference/Global_Objects/Date/getDay +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getDay +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca dzień tygodnia określonej daty, stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getDay()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością zwracaną przez <code>getDay</code> jest liczba całkowita, odnosząca się do dnia tygodnia: 0 dla niedzieli, 1 dla poniedziałku, 2 dla wtorku, i tak dalej.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getDay" name="Przyk.C5.82ad:_Zastosowanie_getDay">Przykład: Zastosowanie <code>getDay()</code></h3> + +<p>Druga instrukcja poniżej przydziela wartość 1 do <code>dzienTyg</code>, opierając się o wartość <code>Date</code>, obiektu <code>Xmas95</code>. 25 grudnia 1995 roku wypadał w poniedziałek.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var weekday = Xmas95.getDay(); + +console.log(weekday); // 1 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getfullyear/index.html b/files/pl/web/javascript/reference/global_objects/date/getfullyear/index.html new file mode 100644 index 0000000000..bca657a324 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getfullyear/index.html @@ -0,0 +1,48 @@ +--- +title: Date.prototype.getFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/getFullYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getFullYear +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca rok określonej daty, stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getFullYear()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość <code>getFullYear</code> zwracana jest jako pełna liczba. Dla dat liczba lat zawiera się pomiędzy 1000 i 9999, <code>getFullYear</code> zwraca czterocyfrową liczbę, na przykład: 1995. Użyj tej funkcji, aby być pewnym, że wyświetlona będzie pełna data po roku 2000.</p> + +<p>Użyj tej metody zamiast metody <code>getYear</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getFullYear" name="Przyk.C5.82ad:_Zastosowanie_getFullYear">Przykład: Zastosowanie <code>getFullYear</code></h3> + +<p>Następujący przykład przydziela czterocyfrową wartość aktualnego roku do zmiennej <code>yr</code>.</p> + +<pre class="brush: js">var today = new Date(); +var yr = today.getFullYear(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/gethours/index.html b/files/pl/web/javascript/reference/global_objects/date/gethours/index.html new file mode 100644 index 0000000000..2caecf0633 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/gethours/index.html @@ -0,0 +1,47 @@ +--- +title: Date.prototype.getHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/getHours +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getHours +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca godzinę określonej daty, stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getHours()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getHours</code> jest liczbą całkowitą z przedziału od 0 do 23.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getHours" name="Przyk.C5.82ad:_Zastosowanie_getHours">Przykład: Zastosowanie <code>getHours()</code></h3> + +<p>Druga instrukcja poniżej przydziela wartość liczby 23 zmiennej <code>hours</code>, opartej o wartość <code>Date</code> obiektu <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var hours = Xmas95.getHours(); + +console.log(hours); // 23 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getmilliseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/getmilliseconds/index.html new file mode 100644 index 0000000000..12762689c8 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getmilliseconds/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.getMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getMilliseconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca milisekundy określonej daty, stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMilliseconds()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getMilliseconds</code> jest liczbą pomiędzy 0 a 999.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_getMilliseconds">Przykład: Zastosowanie <code>getMilliseconds()</code></h3> + +<p>Następujący przykład przydziela liczbę milisekund aktualnego czasu do zmiennej <code>ms</code>.</p> + +<pre class="brush: js">var today = new Date(); +var ms = today.getMilliseconds(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getminutes/index.html b/files/pl/web/javascript/reference/global_objects/date/getminutes/index.html new file mode 100644 index 0000000000..d12e7ab7d7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getminutes/index.html @@ -0,0 +1,49 @@ +--- +title: Date.prototype.getMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/getMinutes +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getMinutes +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca minuty dla określonej daty w zależności od czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMinutes()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getMinutes</code> jest liczbą całkowitą z przedziału od 0 do 59.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getMinutes" name="Przyk.C5.82ad:_Zastosowanie_getMinutes">Przykład: Zastosowanie <code>getMinutes</code></h3> + +<p>Druga instrukcja poniżej przypisuje wartość 15 do zmiennej <code>minutes</code>, bazując na wartości obiektu <code>Xmas95</code> typu <code>Date</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var minutes = Xmas95.getMinutes(); + +console.log(minutes); // 15 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<div class="noinclude"> +<ul> + <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> +</div> diff --git a/files/pl/web/javascript/reference/global_objects/date/getmonth/index.html b/files/pl/web/javascript/reference/global_objects/date/getmonth/index.html new file mode 100644 index 0000000000..2ed9843375 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getmonth/index.html @@ -0,0 +1,47 @@ +--- +title: Date.prototype.getMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/getMonth +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getMonth +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca miesiąc dla określonej daty w zależności od czasu lokalnego.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMonth()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getMonth</code> jest liczbą całkowitą z przedziału od 0 do 11. 0 reprezentuje styczeń, 1 luty, i tak dalej.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getMonth" name="Przyk.C5.82ad:_Zastosowanie_getMonth">Przykład: Zastosowanie <code>getMonth()</code></h3> + +<p>Druga instrukcja z przykładu poniżej przypisuje wartość 11 zmiennej <code>month</code>, bazując na wartości obiektu <code>Xmas95</code> typu <code>Date</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var month = Xmas95.getMonth(); + +console.log(month); // 11 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/getseconds/index.html new file mode 100644 index 0000000000..228fe5355e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getseconds/index.html @@ -0,0 +1,47 @@ +--- +title: Date.prototype.getSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getSeconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getSeconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca sekundy dla określonej daty w zależności od czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getSeconds()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getSeconds</code> jest liczbą całkowitą z przedziału od 0 do 59.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getSeconds" name="Przyk.C5.82ad:_Zastosowanie_getSeconds">Przykład: Zastosowanie <code>getSeconds()</code></h3> + +<p>Druga instrukcja poniżej przypisuje wartość 30 do zmiennej <code>secs</code>, bazując na wartości obiektu <code>Xmas95</code> typu <code>Date</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:30"); +var seconds = Xmas95.getSeconds(); + +console.log(seconds); // 30 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/gettime/index.html b/files/pl/web/javascript/reference/global_objects/date/gettime/index.html new file mode 100644 index 0000000000..9371ea3350 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/gettime/index.html @@ -0,0 +1,48 @@ +--- +title: Date.prototype.getTime() +slug: Web/JavaScript/Reference/Global_Objects/Date/getTime +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getTime +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca liczbę reprezentującą czas dla określonej daty stosownie do czasu uniwersalnego.</p> + +<p>Może być wykorzystana do przypisania daty i czasu do innego obiektu {{jsxref("Date")}}. Ta metoda jest funkcjonalnie równoważna metodzie {{jsxref("Date.valueof", "valueOf()")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTime()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez metodę <code>getTime</code> jest liczbą milisekund liczoną od 1 stycznia 1970 00:00:00.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getTime" name="Przyk.C5.82ad:_Zastosowanie_getTime">Przykład: Zastosowanie <code>getTime()</code></h3> + +<p>Następująca instrukcja przypisuje wartość daty <code>theBigDay</code> do <code>sameAsBigDay</code>:</p> + +<pre class="brush: js">var theBigDay = new Date("July 1, 1999"); +var sameAsBigDay = new Date(); +sameAsBigDay.setTime(theBigDay.getTime()); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.setTime()")}}</li> + <li>{{jsxref("Date.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html b/files/pl/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html new file mode 100644 index 0000000000..bf73ff0ea4 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html @@ -0,0 +1,36 @@ +--- +title: Date.prototype.getTimezoneOffset() +slug: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getTimezoneOffset +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca przesunięcie strefy czasowej w minutach dla bieżącej lokalizacji.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTimezoneOffset()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Przesunięcie strefy czasowej jest to różnica, wyrażona w minutach, pomiędzy <strong>Greenwich Mean Time</strong> (<strong>GMT</strong>) a bieżącym czasem lokalnym. Na przykład, jeśli aktualna strefa to GMT+10, wynikiem jest -600. Wartość nie jest liczbą stałą ze względu na zmiany czasu na letni i zimowy.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_getTimezoneOffset" name="Przyk.C5.82ad:_Zastosowanie_getTimezoneOffset">Przykład: Zastosowanie <code>getTimezoneOffset()</code></h4> + +<pre class="brush: js">var x = new Date(); +var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60; +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcdate/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcdate/index.html new file mode 100644 index 0000000000..c8dca866f1 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getutcdate/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.getUTCDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCDate +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca dzień (datę) miesiąca dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDate()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością zwracaną przez <code>getUTCDate</code> jest liczba całkowita z przedziału od 1 do 31.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCDate" name="Przyk.C5.82ad:_Zastosowanie_getUTCDate">Przykład: Zastosowanie <code>getUTCDate()</code></h3> + +<p>Następujący przykład przypisuje aktualny dzień miesiąca do zmiennej <code>d</code>.</p> + +<pre class="brush: js">var today = new Date(); +var d = today.getUTCDate(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcday/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcday/index.html new file mode 100644 index 0000000000..89a9b1c090 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getutcday/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.getUTCDay() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCDay +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca dzień tygodnia dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDay()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCDay</code> jest liczbą całkowitą określającą dzień tygodnia: 0 dla niedzieli, 1 dla poniedziałku, 2 dla wtorku itd.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCDay" name="Przyk.C5.82ad:_Zastosowanie_getUTCDay">Przykład: Zastosowanie <code>getUTCDay()</code></h3> + +<p>Następujący przykład przypisuje aktualny dzień tygodnia do zmiennej <code>weekday</code>.</p> + +<pre class="brush: js">var today = new Date(); +var weekday = today.getUTCDay(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcfullyear/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcfullyear/index.html new file mode 100644 index 0000000000..f815b1c921 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getutcfullyear/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.getUTCFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCFullYear +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca rok dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCFullYear()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością zwracaną przez <code>getUTCFullYear</code> jest dodatnia liczba całkowita, zgodna z rokiem 2000, na przykład 1995.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCFullYear" name="Przyk.C5.82ad:_Zastosowanie_getUTCFullYear">Przykład: Zastosowanie <code>getUTCFullYear()</code></h3> + +<p>Następujący przykład przypisuje czterocyfrową liczbę aktualnego roku do zmiennej <code>yr</code>.</p> + +<pre class="brush: js">var today = new Date(); +var year = today.getUTCFullYear(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getutchours/index.html b/files/pl/web/javascript/reference/global_objects/date/getutchours/index.html new file mode 100644 index 0000000000..0ff3ff5fc5 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getutchours/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.getUTCHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCHours +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca godziny dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCHours()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCHours</code> jest liczbą całkowitą z przedziału od 0 do 23.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCHours" name="Przyk.C5.82ad:_Zastosowanie_getUTCHours">Przykład: Zastosowanie <code>getUTCHours()</code></h3> + +<p>Następujący przykład przypisuje część aktualnej daty określającą godzinę do zmiennej <code>hrs</code>.</p> + +<pre class="brush: js">var today = new Date(); +var hours = today.getUTCHours(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html new file mode 100644 index 0000000000..8c3603a46d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.getUTCMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCMilliseconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca milisekundy dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMilliseconds()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana <code>getUTCMilliseconds</code> jest liczbą całkowitą z przedziału od 0 do 999.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_getUTCMilliseconds">Przykład: Zastosowanie <code>getUTCMilliseconds()</code></h3> + +<p>Następujący przykład przypisuje część aktualnej daty określającą liczbę milisekund do zmiennej <code>ms</code>.</p> + +<pre class="brush: js">var today = new Date(); +var ms = today.getUTCMilliseconds(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcminutes/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcminutes/index.html new file mode 100644 index 0000000000..d83258052f --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getutcminutes/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.getUTCMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCMinutes +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca minuty dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMinutes()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCMinutes()</code> jest liczbą całkowitą z przedziału od 0 do 59.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCMinutes" name="Przyk.C5.82ad:_Zastosowanie_getUTCMinutes">Przykład: Zastosowanie <code>getUTCMinutes()</code></h3> + +<p>Następujący przykład przypisuje część aktualnej daty określającą minuty do zmiennej <code>min</code>.</p> + +<pre class="brush: js">var today = new Date(); +var min = today.getUTCMinutes(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcmonth/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcmonth/index.html new file mode 100644 index 0000000000..9bb65f2552 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getutcmonth/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.getUTCMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCMonth +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca miesiąc dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMonth()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCMonth()</code> jest liczbą całkowitą z przedziału od 0 do 11 odpowiadającą miesiącowi: 0 dla stycznia, 1 dla lutego, 2 dla marca, i tak dalej.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCMonth" name="Przyk.C5.82ad:_Zastosowanie_getUTCMonth">Przykład: Zastosowanie <code>getUTCMonth()</code></h3> + +<p>Następujący przykład przypisuje aktualny miesiąc do zmiennej <code>mon</code>.</p> + +<pre class="brush: js">var today = new Date(); +var mon = today.getUTCMonth(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcseconds/index.html new file mode 100644 index 0000000000..b20f50a93d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getutcseconds/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.getUTCSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCSeconds +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca sekundy dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCSeconds()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCSeconds()</code> jest liczbą całkowitą z przedziału od 0 do 59.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCSeconds" name="Przyk.C5.82ad:_Zastosowanie_getUTCSeconds">Przykład: Zastosowanie <code>getUTCSeconds()</code></h3> + +<p>Następujący przykład przypisuje część aktualnej daty określającą liczbę sekund do zmiennej <code>sec</code>.</p> + +<pre class="brush: js">var today = new Date(); +var sec = today.getUTCSeconds(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/getyear/index.html b/files/pl/web/javascript/reference/global_objects/date/getyear/index.html new file mode 100644 index 0000000000..b8186a6e7e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/getyear/index.html @@ -0,0 +1,98 @@ +--- +title: Date.prototype.getYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/getYear +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear +original_slug: Web/JavaScript/Referencje/Obiekty/Date/getYear +--- +<p>{{JSRef}}{{ Deprecated_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca rok dla określonej daty w zależności od czasu lokalnego. Metoda <code>getYear</code> nie jest dłużej wykorzystywana i została zastąpiona metodą {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getYear()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>getYear</code> zwraca rok minus 1900; tak więc:</p> + +<ul> + <li>Dla lat późniejszych lub równych 2000, wartość zwracana przez <code>getYear</code> wynosi 100 lub więcej. Przykładowo, dla roku 2026, <code>getYear</code> zwraca 126.</li> +</ul> + +<ul> + <li>Dla lat pomiędzy i włącznie z latami 1900 i 1999, wartość zwracana przez <code>getYear</code> zawiera się w przedziale od 0 do 99. Na przykład, jeśli mamy rok 1976, <code>getYear</code> zwraca 76.</li> +</ul> + +<ul> + <li>Dla lat wcześniejszych niż 1900, wartość zwracana przez <code>getYear</code> jest mniejsza niż 0. Na przykład, dla roku 1800, <code>getYear</code> zwraca -100.</li> +</ul> + +<p>Aby obsłużyć lata zarówno przed jak i po roku 2000, należy zamiast <code>getYear</code> użyć metody {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}, która zwraca pełną liczbę określającą rok.</p> + +<h2 id="Kompatybilno.C5.9B.C4.87_wsteczna" name="Kompatybilno.C5.9B.C4.87_wsteczna">Kompatybilność wstecz</h2> + +<h3 id="JavaScript_1.2_i_wersje_wcze.C5.9Bniejsze" name="JavaScript_1.2_i_wersje_wcze.C5.9Bniejsze">JavaScript 1.2 i wersje wcześniejsze</h3> + +<p>Metoda <code>getYear()</code> zwraca rok w formacie 2-cyfrowym lub 4-cyfrowym:</p> + +<ul> + <li>Dla roczników pomiędzy i włącznie z latami 1900 i 1999, wartość zwracana przez <code>getYear</code> jest to rok minus 1900. Na przykład, dla roku 1976 będzie to liczba 76.</li> +</ul> + +<ul> + <li>Dla roczników niższych niż 1900 lub wyższych niż 1999, wartość zwracana przez <code>getYear</code> jest cztero-cyfrowa. Na przykład, dla roku 1856, wartość jest równa 1856. Dla roku 2026, wartość wynosi 2026.</li> +</ul> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Lata_pomi.C4.99dzy_1900_i_1999" name="Przyk.C5.82ad:_Lata_pomi.C4.99dzy_1900_i_1999">Przykład: Lata pomiędzy 1900 i 1999</h3> + +<p>Druga instrukcja przypisuje wartość 95 do zmiennej <code>year</code>.</p> + +<pre class="brush: js">var Xmas = new Date("December 25, 1995 23:15:00"); +var year = Xmas.getYear(); // zwraca 95 +</pre> + +<h3 id="Przyk.C5.82ad:_Lata_powy.C5.BCej_1999" name="Przyk.C5.82ad:_Lata_powy.C5.BCej_1999">Przykład: Lata powyżej 1999</h3> + +<p>Druga instrukcja przypisuje wartość 100 do zmiennej <code>year</code>.</p> + +<pre class="brush: js">var Xmas = new Date("December 25, 2000 23:15:00"); +var year = Xmas.getYear(); // zwraca 100 +</pre> + +<h3 id="Przyk.C5.82ad:_Lata_powy.C5.BCej_1900" name="Przyk.C5.82ad:_Lata_powy.C5.BCej_1900">Przykład: Lata poniżej 1900</h3> + +<p>Druga instrukcja przypisuje wartość -100 do zmiennej <code>year</code>.</p> + +<pre class="brush: js">var Xmas = new Date("December 25, 1800 23:15:00"); +var year = Xmas.getYear(); // zwraca -100 +</pre> + +<h3 id="Przyk.C5.82ad:_Ustawienie_i_pobieranie_lat_pomi.C4.99dzy_1900_i_1999" name="Przyk.C5.82ad:_Ustawienie_i_pobieranie_lat_pomi.C4.99dzy_1900_i_1999">Przykład: Ustawianie i pobieranie roku pomiędzy 1900 i 1999</h3> + +<p>Druga instrukcja przypisuje wartość 95 do zmiennej <code>year</code>, reprezentując rok 1995.</p> + +<pre class="brush: js">var Xmas.setYear(95); +var year = Xmas.getYear(); // zwraca 95 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/index.html b/files/pl/web/javascript/reference/global_objects/date/index.html new file mode 100644 index 0000000000..2b74956882 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/index.html @@ -0,0 +1,139 @@ +--- +title: Date +slug: Web/JavaScript/Reference/Global_Objects/Date +tags: + - Date + - JavaScript + - data +translation_of: Web/JavaScript/Reference/Global_Objects/Date +original_slug: Web/JavaScript/Referencje/Obiekty/Date +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Tworzy instancje <code>Date</code>, które pozwalają na pracę z danymi opisującymi datę i czas.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia</h2> + +<pre class="syntaxbox"><code>new Date(); +new Date(<em>milisekundy</em>); +new Date(<em>dateString</em>); +new Date(<em>rok</em>, <em>indeksMiesiąca </em>[, <em>dzień </em>[, <em>godzina </em>[, <em>minuta </em>[, <em>sekunda </em>[, <em>milisekunda</em>]]]]]); +</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>milisekundy</code> </dt> + <dd>Wartość całkowita reprezentująca liczbę milisekund od 1 stycznia 1970, godz. 00:00:00 UTC.</dd> +</dl> + +<dl> + <dt><code>dateString</code> </dt> + <dd>Łańcuch znaków reprezentujący datę. Łańcuch znaków powinien być w formacie rozpoznawalnym przez metodę <a href="/pl/Dokumentacja_j%C4%99zyka_JavaScript_1.5/Obiekty/Date/parse" title="pl/Dokumentacja_języka_JavaScript_1.5/Obiekty/Date/parse">parse</a>.</dd> +</dl> + +<dl> + <dt><code>rok</code></dt> + <dd>Wartość całkowita reprezentująca rok. Dla zgodności (w celu uniknięcia problemu roku 2000) należy zawsze określać rok w pełnej formie, używając raczej <code>1998</code> niż <code>98</code>.</dd> +</dl> + +<dl> + <dt><code>indeksMiesiąca</code></dt> + <dd>Wartość całkowita reprezentująca miesiąc, począwszy od 0 dla stycznia, kończąc na 11 dla grudnia.</dd> +</dl> + +<dl> + <dt><code>dzień</code></dt> + <dd>Wartość całkowita reprezentująca dzień miesiąca.</dd> +</dl> + +<dl> + <dt><code>godzina</code></dt> + <dd>Wartość całkowita reprezentująca godzinę (w formacie 24-godzinnym).</dd> +</dl> + +<dl> + <dt><code>minuta</code></dt> + <dd>Wartość całkowita reprezentująca część minutową odczytywanego czasu.</dd> +</dl> + +<dl> + <dt><code>second</code></dt> + <dd>Wartość całkowita reprezentująca część sekundową odczytywanego czasu.</dd> +</dl> + +<dl> + <dt><code>millisecond</code></dt> + <dd>Wartość całkowita reprezentująca część milisekundową odczytywanego czasu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie dostarczasz żadnych argumentów, konstruktor tworzy obiekt <code>Date</code> dla dzisiejszej daty i czasu stosownie do czasu lokalnego. Jeśli dostarczasz jakieś argumenty, lecz nie wszystkie, brakujące argumenty mają ustawioną wartość 0. Jeśli jednak dostarczasz jakieś argumenty, musisz dostarczyć co najmniej rok, miesiąc i dzień. Pominąć możesz godzinę, minuty, sekundy i milisekundy.</p> + +<p>Data jest mierzona w milisekundach od północy 1 stycznia 1970 UTC. W jednym dniu jest 86,400,000 milisekund. Zakres wartości obiektu <code>Date</code> wynosi od -100,000,000 dni do 100,000,000 dni w stosunku do 01 stycznia 1970 UTC.</p> + +<p>Obiekt <code>Date</code> zapewnia jednolite działanie bez względu na platformę.</p> + +<p>Obiekt <code>Date</code> wspiera wiele metod UTC (uniwersalny czas światowy) i metody czasu lokalnego. UTC, także znany jako <em>Greenwich Mean Time</em> (GMT), odnosi się do czasu ustanowionego przez "światowy standard czasu" (ang. World Time Standard). Czas lokalny jest czasem, który zna komputer, na jakim jest wykonywany JavaScript.</p> + +<p>Dla kompatybilności z obliczeniami milenijnymi (inaczej, syndromem roku 2000), powinieneś zawsze określić pełen rok, czyli na przykład, używa 1998, nie 98. Aby pomóc Ci w określeniu całego roku, JavaScript zawiera metody {{jsxref("Date.prototype.getFullYear()")}}, {{jsxref("Date.prototype.setFullYear()")}}, {{jsxref("Date.getUTCFullYear()")}} i {{jsxref("Date.setUTCFullYear()")}}.</p> + +<p>Odwoływanie się do <code>Date </code>w kontekście innym niż konstruktor (np. bez operatora {{jsxref("new")}}) będzie zwracało ciąg reprezentujący aktualny czas.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("Date.prototype")}}</dt> + <dd>Pozwala dodać własności do obiektu <code>Date</code>.</dd> + <dt><code>Date.length</code></dt> + <dd>The value of <code>Date.length</code> is 7. This is the number of arguments handled by the constructor.</dd> + <dt> + <div>{{jsOverrides("Function", "properties", "prototype")}}</div> + </dt> +</dl> + +<h2 id="Metody_statyczne" name="Metody_statyczne">Metody</h2> + +<dl> + <dt>{{jsxref("Date.now()")}}</dt> + <dd>Zwraca wartość liczbową odnoszącą się do aktualnego czasu.</dd> + <dt>{{jsxref("Date.parse()")}}</dt> + <dd>Zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 czasu lokalnego do daty podanej jako argument string.</dd> + <dt>{{jsxref("Date.UTC()")}}</dt> + <dd>Zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 czasu uniwersalnego do daty podanej jako zestaw liczb (parametry jak w najdłuższej formie konstruktora).</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Kilka_sposob.C3.B3w_na_przypisywanie_dat" name="Przyk.C5.82ad:_Kilka_sposob.C3.B3w_na_przypisywanie_dat">Przykład: Kilka sposobów na przypisywanie dat</h3> + +<p>Poniżej przedstawiono kilka przykładowych przypisań dat:</p> + +<pre class="brush: js">var dzisiaj = new Date(); +var urodziny = new Date("December 17, 1995 03:24:00"); +var urodziny = new Date(1995,11,17); +var urodziny = new Date(1995,11,17,3,24,0); +</pre> + +<h3 id="Przyk.C5.82ad:_Obliczanie_czasu_trwania" name="Przyk.C5.82ad:_Obliczanie_czasu_trwania">Przykład: Obliczanie czasu trwania</h3> + +<p>Poniższy przykład pokazuje, jak określić czas, jaki minął pomiędzy dwoma datami:</p> + +<pre class="brush: js">// używając metod statycznych +var start = Date.now(); +// zdarzenie, dla którego chciałbyś zmierzyć czas trwania: +zrobCosPrzezDlugiCzas(); +var stop = Date.now(); +var roznica_czasow = stop - start; // czas w milisekundach +</pre> + +<pre class="brush: js">// wykorzystując obiekty Date +var start = new Date(); +// zdarzenie, dla którego chciałbyś zmierzyć czas trwania: +zrobCosPrzezDlugiCzas(); +var stop = new Date(); +var roznica_czasow = stop.getTime() - start.getTime(); // czas w milisekundach +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/date/now/index.html b/files/pl/web/javascript/reference/global_objects/date/now/index.html new file mode 100644 index 0000000000..4bffd676df --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/now/index.html @@ -0,0 +1,44 @@ +--- +title: Date.now() +slug: Web/JavaScript/Reference/Global_Objects/Date/now +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/now +original_slug: Web/JavaScript/Referencje/Obiekty/Date/now +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca liczbę milisekund, która upłynęła od 1 stycznia 1970 00:00:00 UTC.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>var timeInMs = Date.now();</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda now zwraca milisekundy, które upłynęły od 1 stycznia 1970 00:00:00 UTC do teraz w postaci obiektu {{jsxref("Number")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_now" name="Przyk.C5.82ad:_Zastosowanie_now">Przykład: Zastosowanie <code>now</code></h3> + +<p>Poniższy przykład używa <code>now</code> do stworzenia znacznika czasu.</p> + +<pre class="brush: js">var timestamp = Date.now(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{domxref("Performance.now()")}}</li> + <li>{{domxref("Console.time()")}} / {{domxref("Console.timeEnd()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/parse/index.html b/files/pl/web/javascript/reference/global_objects/date/parse/index.html new file mode 100644 index 0000000000..49cd5c9441 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/parse/index.html @@ -0,0 +1,75 @@ +--- +title: Date.parse() +slug: Web/JavaScript/Reference/Global_Objects/Date/parse +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse +original_slug: Web/JavaScript/Referencje/Obiekty/Date/parse +--- +<div> {{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Analizuje łańcuch znaków reprezentujący datę i zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 UTC.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Date.parse(<var>dateString</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>dateString</code> </dt> + <dd>Łańcuch znaków reprezentujący datę.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>parse</code> pobiera łańcuch znaków daty (na przykład: "<code>Dec 25, 1995</code>") i zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 UTC. Gdy parametr nie zawiera informacji na temat strefy czasowej, domyślnie używana jest lokalna strefa czasowa. Ta funkcja jest przydatna do ustawiania wartości daty w oparciu o wartość łańcucha znaków, przykładowo w połączeniu z metodą {{jsxref("Date.prototype.setTime()", "setTime()")}} oraz obiektem {{jsxref("Date")}}.</p> + +<p>Dla podanego łańcucha znaków reprezentującego czas, <code>parse</code> zwraca wartość czasu. Akceptuje składnię standardu daty - IETF: "<code>Mon, 25 Dec 1995 13:30:00 GMT</code>". Rozpoznaje skróty kontynentalnej strefy czasowej US, lecz w ogólnym zastosowaniu używa się przesunięć dla strefy czasowej, na przykład: "<code>Mon, 25 Dec 1995 13:30:00 GMT+0430</code>" (4 godziny i 30 minut na zachód od południka Greenwich). Jeśli nie określono strefy czasowej, domyślna jest strefa lokalna. GMT i UTC są rozpatrywane jako równoważne.</p> + +<p>Mimo iż specyfikatory strefy czasowej są brane pod uwagę podczas analizy łańcucha znaków do prawidłowej interpretacji argumentu, nie wpływają one jednak na zwracaną wartość, którą zawsze jest ilość milisekund pomiędzy 1 stycznia 1970 roku, 00:00:00 UTC a punktem w czasie reprezentowanym przez argument.</p> + +<p>Ponieważ <code>parse</code> jest metodą statyczną obiektu <code>Date</code>, używamy jej jako <code>Date.parse()</code>, raczej niż jako wywołanie metody utworzonego przez nas obiektu <code>Date</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_parse" name="Przyk.C5.82ad:_Zastosowanie_parse">Przykład: Zastosowanie <code>parse</code></h3> + +<p>Jeśli <code>IPOdate</code> jest istniejącym obiektem <code>Date</code>, możemy przypisać mu wartość 9 sierpnia 1995 (czasu lokalnego) w następujący sposób:</p> + +<pre class="brush: js">IPOdate.setTime(Date.parse("Aug 9, 1995")) ; +</pre> + +<p>Kilka innych przykładów:</p> + +<pre class="brush: js">// Zwraca 807937200000 w strefie czasowej GMT-0300, i inne wartości dla innych stref +// czasowych, ponieważ argument nie specyfikuje strefy czasowej. +Date.parse("Aug 9, 1995");</pre> + +<pre class="brush: js">// Zwraca 807926400000 niezależnie od lokalnej strefy czasowej. +Date.parse("Wed, 09 Aug 1995 00:00:00 GMT");</pre> + +<pre class="brush: js">// Zwraca 807937200000 w strefie czasowej GMT-0300, a inne wartości w innych +// strefach czasowych, ponieważ strefa nie jest wyspecyfikowana w argumencie. +Date.parse("Wed, 09 Aug 1995 00:00:00");</pre> + +<pre class="brush: js">// Zwraca 0 niezależnie od lokalnej strefy czasowej. +Date.parse("Thu, 01 Jan 1970 00:00:00 GMT");</pre> + +<pre class="brush: js">// Zwraca 14400000 w strefie czasowej GMT-0400, a inne wartości w innych +// strefach czasowych, ponieważ strefa nie jest podana w argumencie. +Date.parse("Thu, 01 Jan 1970 00:00:00");</pre> + +<pre class="brush: js">// Zwraca 14400000 niezależnie od lokalnej strefy czasowej. +Date.parse("Thu, 01 Jan 1970 00:00:00 GMT-0400");</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.UTC()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setdate/index.html b/files/pl/web/javascript/reference/global_objects/date/setdate/index.html new file mode 100644 index 0000000000..f0569b5eac --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setdate/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.setDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/setDate +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setDate +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia dzień miesiąca dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setDate(<var>dayValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita z przedziału od 1 do 31, reprezentująca dzień miesiąca.</dd> +</dl> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setDate" name="Przyk.C5.82ad:_Zastosowanie_setDate">Przykład: Zastosowanie <code>setDate()</code></h3> + +<p>Druga instrukcja poniżej zmienia dzień miesiąca dla zmiennej <code>theBigDay</code> z jego oryginalnej wartości na 24 lipca.</p> + +<pre class="brush: js">var theBigDay = new Date("July 27, 1962 23:30:00"); +var theBigDay.setDate(24); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setfullyear/index.html b/files/pl/web/javascript/reference/global_objects/date/setfullyear/index.html new file mode 100644 index 0000000000..c119547e86 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setfullyear/index.html @@ -0,0 +1,59 @@ +--- +title: Date.prototype.setFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/setFullYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setFullYear +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia kompletny rok dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>yearValue</code> </dt> + <dd>Liczba całkowita określająca wartość numeryczną roku, na przykład; 1995.</dd> +</dl> + +<dl> + <dt><code>monthValue</code> </dt> + <dd>Liczba całkowita z przedziału od 0 do 11 (reprezentująca miesiące od stycznia do grudnia).</dd> +</dl> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita z przedziału od 1 do 31 reprezentująca dzień miesiąca. Jeśli zostaje podany parametr <code>dayValue</code>, należzy również podać <code>monthValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie zostały podane parametry <code>monthValue</code> i <code>dayValue</code>, biblioteka pobierze te dane z metod {{jsxref("Date.prototype.getMonth()", "getMonth()")}} i {{jsxref("Date.prototype.getDate()", "getDate()")}}.</p> + +<p>Jeżeli określony parametr jest poza oczekiwanym zakresem, <code>setFullYear()</code> spróbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Przykładowo, jeśli zostanie podana wartość 15 dla <code>monthValue</code> to rok zostanie zwiększony o 1 (rok+1), a miesiąc zostanie ustawiony na wartość 3.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setFullYear" name="Przyk.C5.82ad:_Zastosowanie_setFullYear">Przykład: Zastosowanie <code>setFullYear()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setFullYear(1997); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/sethours/index.html b/files/pl/web/javascript/reference/global_objects/date/sethours/index.html new file mode 100644 index 0000000000..c621fd575a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/sethours/index.html @@ -0,0 +1,67 @@ +--- +title: Date.prototype.setHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/setHours +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setHours +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia godziny dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre> + +<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>)</code></pre> + +<h2 id="Parametry" name="Parametry">Parametry</h2> + +<dl> + <dt><code>hoursValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 23, reprezentująca godziny.</dd> +</dl> + +<dl> + <dt><code>minutesValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca minuty.</dd> +</dl> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, musisz także określić <code>minutesValue</code>.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>A Liczba pomiędzy 0 i 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, musisz także określić <code>minutesValue</code> i <code>secondsValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametrów <code>minutesValue</code>, <code>secondsValue</code> i <code>msValue</code>, wartość zwracana użytych metod {{jsxref("Date.prototype.getMinutes()", "getMinutes()")}}, {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} i {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setHours</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty będą wzrastać o 1 (min + 1), i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad_Zastosowanie_setHours" name="Przyk.C5.82ad:_Zastosowanie_setHours">Przykład: Zastosowanie <code>setHours()</code></h3> + +<pre class="brush: js">var the BigDay = new Date(); +theBigDay.setHours(7); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setmilliseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/setmilliseconds/index.html new file mode 100644 index 0000000000..1e33e8f97a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setmilliseconds/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.setMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setMilliseconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia milisekundy dla określonej daty stosownie do czasu lokalnego.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMilliseconds(<var>millisecondsValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>millisecondsValue</code> </dt> + <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli sprecyzujesz liczbę z poza oczekiwanego szeregu, informacje zawarte w obiekcie <code>Date</code> będą aktualizowane. Na przykład, jeśli określisz 1005, liczba sekund rośnie o 1, i 5 jest użyte dla milisekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_setMilliseconds">Przykład: Zastosowanie <code>setMilliseconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setMilliseconds(100); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setminutes/index.html b/files/pl/web/javascript/reference/global_objects/date/setminutes/index.html new file mode 100644 index 0000000000..737598c146 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setminutes/index.html @@ -0,0 +1,61 @@ +--- +title: Date.prototype.setMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/setMinutes +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setMinutes +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia minuty dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre> + +<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>minutesValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca minuty.</dd> +</dl> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, musisz także określić <code>minutesValue</code>.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba pomiędzy 0 i 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, musisz także określić <code>minutesValue</code> i <code>secondsValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określono parametrów <code>secondsValue</code> i <code>msValue</code>, są użyte wartości zwracanych metod <code>getSeconds</code> i <code>getMilliseconds</code>.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setMinutes</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty (<code>minutesValue</code>) będą wzrastać o 1 (<code>minutesValue</code> + 1) i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setMinutes" name="Przyk.C5.82ad:_Zastosowanie_setMinutes">Przykład: Zastosowanie <code>setMinutes()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setMinutes(45);</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setmonth/index.html b/files/pl/web/javascript/reference/global_objects/date/setmonth/index.html new file mode 100644 index 0000000000..c9dcbbea7f --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setmonth/index.html @@ -0,0 +1,57 @@ +--- +title: Date.prototype.setMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/setMonth +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setMonth +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia nazwę miesiąca dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre> + +<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>)</code></pre> + +<h3 id="Parameter" name="Parameter">Parametry</h3> + +<dl> + <dt><code>monthValue</code> </dt> + <dd>Liczba całkowita z przedziału 0 i 11 (reprezentuje miesiące od stycznia do grudnia).</dd> +</dl> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita z przedziału 1 i 31, reprezentuje dzień miesiąca.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametru <code>dayValue</code>, zostanie zwrócona wartość użytej metody <code>getDate</code>.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setMonth()</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 15 dla <code>monthValue</code>, rok wzrośnie o 1 (year + 1) i 3 będzie użyte dla miesiąca.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setMonth" name="Przyk.C5.82ad:_Zastosowanie_setMonth">Przykład: Zastosowanie <code>setMonth()</code></h3> + +<pre class="brush: js">var theBigDay = new Date; +theBigDay.setMonth(6); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/setseconds/index.html new file mode 100644 index 0000000000..e2af3ab2b7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setseconds/index.html @@ -0,0 +1,57 @@ +--- +title: Date.prototype.setSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setSeconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setSeconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia sekundy dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre> + +<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>)</code></pre> + +<h2 id="Parametry" name="Parametry">Parametry</h2> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita z przedziału 0 i 59.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba z przedziału 0 i 999, reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametru <code>msValue</code>, wartość zwracana użytej metody {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setSeconds()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty zawarte w obiekcie {{jsxref("Date")}} będą wzrastać o 1 i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setSeconds" name="Przyk.C5.82ad:_Zastosowanie_setSeconds">Przykład: Zastosowanie <code>setSeconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setSeconds(30); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/settime/index.html b/files/pl/web/javascript/reference/global_objects/date/settime/index.html new file mode 100644 index 0000000000..c2f6c15564 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/settime/index.html @@ -0,0 +1,47 @@ +--- +title: Date.prototype.setTime() +slug: Web/JavaScript/Reference/Global_Objects/Date/setTime +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setTime +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setTime +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia wartość obiektu {{jsxref("Date")}} stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setTime(<var>timeValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>timeValue</code> </dt> + <dd>Liczba całkowita reprezentująca liczbę milisekund liczonych od 1 stycznia 1970, 00:00:00.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Użyj metody <code>setTime()</code>, aby pomóc przydzielić dacie czas następnego obiektu {{jsxref("Date")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setTime" name="Przyk.C5.82ad:_Zastosowanie_setTime">Przykład: Zastosowanie <code>setTime()</code></h3> + +<pre class="brush: js">var theBigDay = new Date("July 1, 1999"); +var sameAsBigDay = new Date(); +sameAsBigDay.setTime(theBigDay.getTime()) +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getTime()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcdate/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcdate/index.html new file mode 100644 index 0000000000..efae5bb77b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setutcdate/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.setUTCDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCDate +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia dzień miesiąca dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCDate(<var>dayValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita od 1 do 31, reprezentująca dni miesiąca.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCDate()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 40 dla <code>dayValue</code>, i nazwa miesiąca jaki jest w danym momencie przechowywany w obiekcie {{jsxref("Date")}} będzie czerwcem, to do dni przypiszemy wartość 10, ale wyświetlaną nazwą miesiąca będzie już lipiec.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCDate" name="Przyk.C5.82ad:_Zastosowanie_setUTCDate">Przykład: Zastosowanie <code>setUTCDate()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCDate(20); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcfullyear/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcfullyear/index.html new file mode 100644 index 0000000000..f87b25b50d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setutcfullyear/index.html @@ -0,0 +1,58 @@ +--- +title: Date.prototype.setUTCFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCFullYear +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia pełen rok dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>yearValue</code> </dt> + <dd>Liczba całkowita określająca numerycznie wartość roku, na przykład: 1995.</dd> +</dl> + +<dl> + <dt><code>monthValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 11, reprezentuje nazwy miesięcy, od stycznia do grudnia.</dd> +</dl> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita pomiędzy 1 a 31, reprezentuje dzień miesiąca. Jeśli określimy parametr <code>dayValue</code>, to musimy także sprecyzować <code>monthValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametrów <code>monthValue</code> i <code>dayValue</code>, wartość zwracana metod {{jsxref("Date.prototype.getUTCMonth()", "getUTCMonth()")}} i {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}} jest w użyciu.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCFullYear()</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 15 dla <code>monthValue</code>, lata będą wzrastać o 1 (rok + 1), i 3 jest użyta jako miesiąc.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCFullYear" name="Przyk.C5.82ad:_Zastosowanie_setUTCFullYear">Przykład: Zastosowanie <code>setUTCFullYear()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCFullYear(1997); +</pre> + +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setutchours/index.html b/files/pl/web/javascript/reference/global_objects/date/setutchours/index.html new file mode 100644 index 0000000000..66b51f50e5 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setutchours/index.html @@ -0,0 +1,63 @@ +--- +title: Date.prototype.setUTCHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCHours +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia godzinę dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>hoursValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 23, reprezentująca godzinę.</dd> +</dl> + +<dl> + <dt><code>minutesValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 59, reprezentująca minutami.</dd> +</dl> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, to musisz także określić parametr <code>minutesValue</code>.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, to musisz także określić parametry <code>minutesValue</code> i <code>secondsValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametrów <code>minutesValue</code>, <code>secondsValue</code> i <code>msValue</code>, wartość zwracana będzie użytych metod {{jsxref("Date.prototype.getUTCMinutes()", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} i {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCHours()</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty zawarte w obiekcie <code>Date</code> będą wzrastać o 1 i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCHours" name="Przyk.C5.82ad:_Zastosowanie_setUTCHours">Przykład: Zastosowanie <code>setUTCHours()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCHours(8); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html new file mode 100644 index 0000000000..e9360b2e0f --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.UTCMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCMilliseconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia milisekundy dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMilliseconds(<var>millisecondsValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>millisecondsValue</code> </dt> + <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli parametr, który określiłeś jest z poza szeregu, <code>setUTCMilliseconds()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz 1100 dla <code>millisecondsValue</code>, sekunda przechowana w obiekcie {{jsxref("Date")}} wzrośnie o 1 i wartość 100 będzie użyta dla milisekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_setUTCMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_setUTCMilliseconds">Przykład: Zastosowanie <code>setUTCMilliseconds()</code></h4> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCMilliseconds(500); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcminutes/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcminutes/index.html new file mode 100644 index 0000000000..c99dadaa2b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setutcminutes/index.html @@ -0,0 +1,58 @@ +--- +title: Date.prototype.setUTCMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCMinutes +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia minuty dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>minutesValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca minuty.</dd> +</dl> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, musisz także określić <code>minutesValue</code>.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba pomiędzy 0 i 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, musisz także określić <code>minutesValue</code> i <code>secondsValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określono parametrów <code>secondsValue</code> i <code>msValue</code>, są użyte wartości zwracanych metod {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} i {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCMinutes()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty (<code>minutesValue</code>) będą wzrastać o 1 (<code>minutesValue</code> + 1) i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCMinutes" name="Przyk.C5.82ad:_Zastosowanie_setUTCMinutes">Przykład: Zastosowanie <code>setUTCMinutes()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCMinutes(43); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcmonth/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcmonth/index.html new file mode 100644 index 0000000000..3d8947802e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setutcmonth/index.html @@ -0,0 +1,53 @@ +--- +title: Date.prototype.setUTCMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCMonth +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia miesiąc dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>monthValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 11, reprezentująca nazwy miesięcy od stycznia do grudnia.</dd> +</dl> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita od 1 do 31, reprezentująca dzień miesiąca.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametru <code>dayValue</code>, zostanie zwrócona wartość użytej metody {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCMonth()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 15 dla <code>monthValue</code>, rok wzrośnie o 1 (rok + 1) i 3, które pozostało będzie użyte dla miesiąca.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCMonth" name="Przyk.C5.82ad:_Zastosowanie_setUTCMonth">Przykład: Zastosowanie <code>setUTCMonth()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCMonth(11); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcseconds/index.html new file mode 100644 index 0000000000..adf4079334 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setutcseconds/index.html @@ -0,0 +1,53 @@ +--- +title: Date.prototype.setUTCSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCSeconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia sekundy dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 59.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametru <code>msValue</code>, wartość zwracana jest z użytej metody {jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCSeconds()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty zawarte w obiekcie {{jsxref("Date")}} będą wzrastać o 1 i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCSeconds" name="Przyk.C5.82ad:_Zastosowanie_setUTCSeconds">Przykład: Zastosowanie <code>setUTCSeconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCSeconds(20); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/setyear/index.html b/files/pl/web/javascript/reference/global_objects/date/setyear/index.html new file mode 100644 index 0000000000..932dda7f51 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/setyear/index.html @@ -0,0 +1,53 @@ +--- +title: Date.prototype.setYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/setYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setYear +original_slug: Web/JavaScript/Referencje/Obiekty/Date/setYear +--- +<p>{{jSRef}}{{ Deprecated_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia rok dla określonej daty stosownie do czasu lokalnego. Aby móc korzystać z roczników przed i po roku 2000, powinieneś użyć metody {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} zawierającej <code>setYear()</code>, która rok potrafi określić w pełni.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setYear(<var>yearValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>yearValue</code> </dt> + <dd>Liczba całkowita.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli <code>yearValue</code> jest liczbą pomiędzy 0 a 99 (inclusive), to rok dla <code>dateObjectName</code> jest ustawiany - 1900 + <code>yearValue</code>. W innym przypadku, rok dla <code>dateObjectName</code> jest ustawiany w postaci wyświetlenia <code>yearValue</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setYear" name="Przyk.C5.82ad:_Zastosowanie_setYear">Przykład: Zastosowanie <code>setYear()</code></h3> + +<p>Dwie pierwsze linie ustawiają rok w dacie na 1996. Trzecia ustawia rok na 2000.</p> + +<pre class="brush: js">var theBigDay = new Date(); + +theBigDay.setYear(96) +theBigDay.setYear(1996) +theBigDay.setYear(2000) +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/togmtstring/index.html b/files/pl/web/javascript/reference/global_objects/date/togmtstring/index.html new file mode 100644 index 0000000000..8b82e892a3 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/togmtstring/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.toGMTString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toGMTString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toGMTString +original_slug: Web/JavaScript/Referencje/Obiekty/Date/toGMTString +--- +<p>{{JSRef}}{{ Deprecated_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Konwertuje datę na łańcuch znaków używając konwersji czasu GMT. Dokładny format zwracanych wartości <code>toGMTString()</code> różni się w zależności platformy.</p> + +<div class="note"> +<p>Metoda <code>toGMTString</code> jest nie długo używana i została ona zastąpiona metodą {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}. Powinieneś używać {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}} zamiast <code>toGMTSTring</code>().</p> +</div> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toGMTString()</code></pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toGMTString" name="Przyk.C5.82ad:_Zastosowanie_toGMTString">Przykład: Zastosowanie <code>toGMTString()</code></h3> + +<p>W następującym przykładzie jest dzisiejsza data obiektu <code>Date</code>:</p> + +<pre class="brush: js">var today = new Date(); +var str = today.toGMTString(); + +console.log(str); // Mon, 18 Dec 1995 17:28:35 GMT</pre> + +<p>W tym przykładzie metoda <code>toGMTString</code> konwertuje datę w czasie GMT (UTC) używanego przez system operacyjny w odpowiedniej strefie czasowej i zwraca wartość łańcucha znaków, która jest podobna do następującej formy. Format jest w pełni zależny od platformy.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/tojson/index.html b/files/pl/web/javascript/reference/global_objects/date/tojson/index.html new file mode 100644 index 0000000000..b5b3110291 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/tojson/index.html @@ -0,0 +1,71 @@ +--- +title: Date.prototype.toJSON() +slug: Web/JavaScript/Reference/Global_Objects/Date/toJSON +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toJSON +original_slug: Web/JavaScript/Referencje/Obiekty/Date/toJSON +--- +<div>{{JSRef}}</div> + +<div>Zwraca objekt {{jsxref("Date")}} w postaci tekstu.</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toJSON()</code> +</pre> + +<h2 id="Opis">Opis</h2> + +<p><code>toJSON()</code> zwraca ciąg znaków (using {{jsxref("Date.prototype.toISOString()", "toISOString()")}}) reprezentujący wartość obiektu {{jsxref("Date")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_toJSON()">Użycie <code>toJSON()</code></h3> + +<pre class="brush:js">var jsonDate = (new Date()).toJSON(); +var backToDate = new Date(jsonDate); + +console.log(jsonDate); //2015-10-26T07:46:36.611Z +</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.9.5.44', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Początkowa definicja zaimplementowana w JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Date.toJSON")}}</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/tolocaledatestring/index.html b/files/pl/web/javascript/reference/global_objects/date/tolocaledatestring/index.html new file mode 100644 index 0000000000..103db5d284 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/tolocaledatestring/index.html @@ -0,0 +1,56 @@ +--- +title: Date.prototype.toLocaleDateString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString +original_slug: Web/JavaScript/Referencje/Obiekty/Date/toLocaleDateString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca "date", porcje daty jako łańcuch znaków, używając aktualnych lokalnych konwersji.</p> + +<p>Metoda <code>toLocaleDateString</code> polega na znalezieniu formatu daty w systemie operacyjnym. Konwertuje datę do łańcucha znakowego używając konwencji formatowania systemu operacyjnego, gdzie skrypt jest uruchomiony. Na przykład, w USA, miesiąc pojawia się przed dniem (04/15/98), gdzie w Niemczech data wyświetla miesiąc po dniu (15.04.98). Jeśli system operacyjny nie używa, nie spełnia roku 2000 i nie używa pełnego roku dla lat przed 1900 lub po 2000, <code>toLocaleDateString</code> zwraca łańcuch znakowy, który nie jest uległy wobec roku 2000. <code>toLocaleDateString</code> postępuje podobnie do <code>toString</code>, kiedy konwertuje rok, który system operacyjny ma w niewłaściwym formacie.</p> + +<p>Metody takie jak <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getHours">getHours</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getMinutes">getMinutes</a></code> i <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getSeconds">getSeconds</a></code> dają więcej przenośnych rezultatów niż <code>toLocaleDateString</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleDateString([<var>locales</var> [, <var>options</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Check the {{anch("Browser compatibility")}} section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleDateString$edit#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div> + +<p>The default value for each date-time component property is {{jsxref("Global_Objects/undefined", "undefined")}}, but if the <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code> properties are all {{jsxref("Global_Objects/undefined", "undefined")}}, then <code>year</code>, <code>month</code>, and <code>day</code> are assumed to be <code>"numeric"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toLocaleDateString" name="Przyk.C5.82ad:_Zastosowanie_toLocaleDateString">Przykład: Zastosowanie <code>toLocaleDateString()</code></h3> + +<p>Następujący przykład <code>today</code> jest obiektem <code>Date</code>:</p> + +<pre class="brush: js">var today = new Date(95,11,18,17,28,35) //miesiąc jest reprezentowany przez liczby od 0 do 11 +today.toLocaleDateString() +</pre> + +<p>W tym przykładzie, <code>toLocaleDateString</code> zwraca łańcuch znakowy, który jest podobny do poniższej formy. Dokładny format, jaki znajduje się na platformie.</p> + +<pre>12/18/95 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/tolocalestring/index.html b/files/pl/web/javascript/reference/global_objects/date/tolocalestring/index.html new file mode 100644 index 0000000000..3735e6885b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/tolocalestring/index.html @@ -0,0 +1,52 @@ +--- +title: Date.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString +original_slug: Web/JavaScript/Referencje/Obiekty/Date/toLocaleString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Konwertuje datę na łańcuch znakowy, używając aktualnej lokalnej konwersji.</p> + +<p>Metoda <code>toLocaleString</code> polega na znalezieniu formatu daty w systemie operacyjnym. Konwertuje datę do łańcucha znakowego używając konwencji formatowania systemu operacyjnego, gdzie skrypt jest uruchomiony. Na przykład, w USA, miesiąc pojawia się przed dniem (<b>04</b>/15/98), gdzie w Niemczech data wyświetla miesiąc, zaraz po dniu (15.<b>04</b>.98). Jeśli system operacyjny nie używa, nie spełnia roku 2000 i nie używa pełnego roku dla lat przed 1900 lub po 2000, <code>toLocaleString</code> zwraca łańcuch znakowy, który nie jest uległy wobec roku 2000. <code>toLocaleString</code> postępuje podobnie do <code>toString</code>, kiedy konwertuje rok, który system operacyjny ma w niewłaściwym formacie.</p> + +<p>Metody, takie jak <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getHours">getHours</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getMinutes">getMinutes</a></code> i <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getSeconds">getSeconds</a></code> dają więcej przenośnych rezultatów niż <code>toLocaleString</code></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleString([<var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Check the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleString$edit#Browser_Compatibility">Browser compatibility</a> section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleString$edit#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div> + +<p>The default value for each date-time component property is {{jsxref("Global_Objects/undefined", "undefined")}}, but if the <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, <code>second</code> properties are all {{jsxref("Global_Objects/undefined", "undefined")}}, then <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, and <code>second</code> are assumed to be <code>"numeric"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Zastosowanie_toLocaleString" name="Zastosowanie_toLocaleString">Zastosowanie <code>toLocaleString()</code></h3> + +<p>W następującym przykładzie, obiekt <code>today</code> jest <code>Date</code>:</p> + +<pre class="brush: js">var today = new Date(95,11,18,17,28,35); //miesiące są reprezentowane poprzez liczby od 0 do 11 +today.toLocaleString(); // 12/18/95 17:28:35</pre> + +<p>W tym przykładzie, <code>toLocaleString</code> zwraca łańcuch znaków, który jest podobny do następującej formy. Dokładnie to taki format, jaki jest w systemie.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/tolocaletimestring/index.html b/files/pl/web/javascript/reference/global_objects/date/tolocaletimestring/index.html new file mode 100644 index 0000000000..4e87a02b41 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/tolocaletimestring/index.html @@ -0,0 +1,53 @@ +--- +title: Date.prototype.toLocaleTimeString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString +original_slug: Web/JavaScript/Referencje/Obiekty/Date/toLocaleTimeString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca "czas", porcje daty jako łańcuch znaków, używając aktualnych lokalnych konwersji.</p> + +<p>Metoda <code>toLocaleTimeString</code> polega na znalezieniu formatu daty w systemie operacyjnym. Konwertuje datę do łańcucha znakowego używając konwencji formatowania systemu operacyjnego, gdzie skrypt jest uruchomiony. Na przykład, w USA, miesiąc pojawia się przed dniem (04/15/98), gdzie w Niemczech data wyświetla miesiąc po dniu (15.04.98). Jeśli system operacyjny nie używa, nie spełnia roku 2000 i nie używa pełnego roku dla lat przed 1900 lub po 2000, <code>toLocaleTimeString</code> zwraca łańcuch znakowy, który nie jest uległy wobec roku 2000. <code>toLocaleTimeString</code> postępuje podobnie do <code>toString</code>, kiedy konwertuje rok, który system operacyjny ma w nie właściwym formacie.</p> + +<p>Metody takie jak <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getHours">getHours</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getMinutes">getMinutes</a></code> i <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getSeconds">getSeconds</a></code> dają więcej podobnych rezultatów niż <code>toLocaleTimeString</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleTimeString([<var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Check the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleTimeString$edit#Browser_Compatibility">Browser compatibility</a> section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleTimeString$edit#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div> + +<p>The default value for each date-time component property is {{jsxref("Global_Objects/undefined", "undefined")}}, but if the <code>hour</code>, <code>minute</code>, <code>second</code> properties are all {{jsxref("Global_Objects/undefined", "undefined")}}, then <code>hour</code>, <code>minute</code>, and <code>second</code> are assumed to be <code>"numeric"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Zastosowanie_toLocaleTimeString" name="Zastosowanie_toLocaleTimeString">Zastosowanie <code>toLocaleTimeString()</code></h4> + +<p>W następującym przykładzie, <code>today</code> jest obiektem <code>Date</code> object:</p> + +<pre class="brush: js">var today = new Date(95,11,18,17,28,35); //miesiące są reprezentowane przez liczby od 0 do 11 +today.toLocaleTimeString(); // 17:28:35</pre> + +<p>W tym przykładzie, <code>toLocaleTimeString</code> zwraca wartość łańcucha znakowego, która jest podobna do następującej formy. Dokładny format, jaki znajduje się na platformie.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/tosource/index.html b/files/pl/web/javascript/reference/global_objects/date/tosource/index.html new file mode 100644 index 0000000000..6019f0d46b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/tosource/index.html @@ -0,0 +1,50 @@ +--- +title: Date.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Date/toSource +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toSource +original_slug: Web/JavaScript/Referencje/Obiekty/Date/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toSource() +Date.toSource()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Metoda <code>toSource()</code> zwraca następującą wartość:</p> + +<ul> + <li>Dla wewnętrznej budowy obiekt {{jsxref("Date")}}, <code>toSource()</code> zwraca następujący łańcuch znaków sygnalizując, który kod źródłowy jest nieosiągalny:</li> +</ul> + +<pre class="brush: js">function Date() { + [native code] +} +</pre> + +<ul> + <li>Dla instancji {{jsxref("Date")}}, <code>toSource()</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Ta metoda jest często nazywana wewnętrzną metodą JavaScript i jest nie wyraźna w kodzie.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/tostring/index.html b/files/pl/web/javascript/reference/global_objects/date/tostring/index.html new file mode 100644 index 0000000000..d19870e9b2 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/tostring/index.html @@ -0,0 +1,50 @@ +--- +title: Date.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toString +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString +original_slug: Web/JavaScript/Referencje/Obiekty/Date/toString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków, reprezentujący określony obiekt <code>Date</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toString()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Date")}} przesłania metodę <code>toString</code> z obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref("Date")}}, metoda <code>toString()</code> zwraca łańcuch znaków, które reprezentują obiekt.</p> + +<p>JavaScript wywołuje metodę <code>toString()</code> automatycznie wtedy, gdy data jest reprezentowana jako wartość tekstowa lub kieruje powiązanym łańcuchem znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toString" name="Przyk.C5.82ad:_Zastosowanie_toString">Przykład: Zastosowanie <code>toString()</code></h3> + +<p>Następujący przykład przydziela <code>toString</code> wartość obiektu <code>Date</code> do <code>myVar</code>:</p> + +<pre class="brush: js">var x = new Date(); +myVar=x.toString(); //przydziela wartość myVar, podobnie do: +// Mon Sep 28 14:36:22 GMT-0700 (Pacific Daylight Time) 1998 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/toutcstring/index.html b/files/pl/web/javascript/reference/global_objects/date/toutcstring/index.html new file mode 100644 index 0000000000..c185e5b46d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/toutcstring/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.toUTCString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toUTCString +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toUTCString +original_slug: Web/JavaScript/Referencje/Obiekty/Date/toUTCString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Konwertuje datę na łańcuch znaków, używając do konwersji czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toUTCString()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>toUTCString()</code> jest sformatowanym i tylko do odczytu łańcuchem znaków, stosowanym do konwersji UTC. Wartość zwracanego formatu może być określona stosownie do platformy.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toUTCString" name="Przyk.C5.82ad:_Zastosowanie_toUTCString">Przykład: Zastosowanie <code>toUTCString()</code></h3> + +<pre class="brush: js language-js">var today = new Date(); +var UTCstring = today.toUTCString(); +<code class="language-js"><span class="token comment">// Mon, 03 Jul 2006 21:44:38 GMT</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toISOString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/utc/index.html b/files/pl/web/javascript/reference/global_objects/date/utc/index.html new file mode 100644 index 0000000000..21cbba9e24 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/utc/index.html @@ -0,0 +1,70 @@ +--- +title: Date.UTC() +slug: Web/JavaScript/Reference/Global_Objects/Date/UTC +tags: + - Date + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC +original_slug: Web/JavaScript/Referencje/Obiekty/Date/UTC +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Akceptuje te same parametry co najdłuższa forma konstruktora i zwraca liczbę milisekund w obiekcie {{jsxref("Date")}}, które upłynęły od 1 stycznia, 1970, 00:00:00, czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Date.UTC(<em>rok</em>,<em> miesiąc</em>[,<em> dzień</em>[,<em> godz</em>[,<em> min</em>[,<em> sek</em>[, ms]]]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>rok</code> </dt> + <dd>Rok po 1900.</dd> + <dt><code>miesiąc</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 11 reprezentująca miesiąc.</dd> + <dt><code>dzień</code> </dt> + <dd>Liczba całkowita pomiędzy 1 i 31 reprezentująca dzień miesiąca.</dd> + <dt><code>godz</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 23 reprezentująca godziny.</dd> + <dt><code>min</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59 reprezentująca minuty.</dd> + <dt><code>sek</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59 reprezentująca sekundy.</dd> + <dt><code>ms</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 999 reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>UTC</code> pobiera parametry daty oddzielone za pomocą przecinków i zwraca liczbę milisekund między 1 stycznia, 1970, 00:00:00, czasu uniwersalnego a określoną datą.</p> + +<p>Powinno używać się pełnego zapisu roku, na przykład 1998. Jeśli określony jest rok z przedziału pomiędzy 0 a 99, metoda konwertuje go do roku w 20 wieku (1900 + rok); na przykład, jeśli określiłeś go jako 95, zostanie użyty rok 1995.</p> + +<p>Metoda <code>UTC</code> różni się od konstruktora {{jsxref("Date")}} na dwa sposoby.</p> + +<ul> + <li><code>Date.UTC</code> używa czasu uniwersalnego zamiast lokalnego.</li> + <li><code>Date.UTC</code> zwraca wartość czasu jako liczbę zamiast tworzenia obiektu typu {{jsxref("Date")}}.</li> +</ul> + +<p>Jeśli parametr określony jest poza spodziewanym zasięgiem, metoda <code>UTC</code> zaktualizuje pozostałe parametry. Na przykład, jeśli użyjesz liczby 15 do określenia miesiąca, wartość parametru <code>rok</code> zostanie powiększona o 1 (rok + 1), a 3 zostanie użyte w parametrze <code>miesiąc</code>.</p> + +<p>Ponieważ <code>UTC</code> jest statyczną metodą obiektu {{jsxref("Date")}}, zawsze powinno używać się jej jako <code>Date.UTC()</code>, niż jako metodę utworzonego obiektu {{jsxref("Date")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Date.UTC" name="Przyk.C5.82ad:_Zastosowanie_Date.UTC">Przykład: Zastosowanie <code>Date.UTC()</code></h3> + +<p>Następująca instrukcja tworzy obiekt <code>Date</code> używający GMT (czasu uniwersalnego) zamiast czasu lokalnego:</p> + +<pre class="brush: js">var utcDate = new Date(Date.UTC(96, 11, 1, 0, 0, 0)); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.parse()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/date/valueof/index.html b/files/pl/web/javascript/reference/global_objects/date/valueof/index.html new file mode 100644 index 0000000000..7cf5d666fc --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/date/valueof/index.html @@ -0,0 +1,47 @@ +--- +title: Date.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Date/valueOf +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/valueOf +original_slug: Web/JavaScript/Referencje/Obiekty/Date/valueOf +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca prymitywną wartość obiektu <code>Date</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.valueOf()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Metoda <code>valueOf</code> zwraca wartość prymitywną obiektu {{jsxref("Date")}} jako typ danych liczbowych, czyli liczbę milisekund od północy 1 stycznia 1970 UTC.</p> + +<p>Ta metoda jest funkcyjnie równoważna do metody {{jsxref("Date.prototype.getTime()")}}.</p> + +<p>Ta metoda często jest nazywana wewnętrzną metodą JavaScriptu i nie jest wyraźna w kodzie.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_valueOf" name="Przyk.C5.82ad:_Zastosowanie_valueOf">Przykład: Zastosowanie <code>valueOf()</code></h3> + +<pre class="brush: js">var x = new Date(56, 6, 17); +var myVar = x.valueOf(); // przydziela -424713600000 do myVar +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> + <li>{{jsxref("Date.prototype.getTime()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/decodeuri/index.html b/files/pl/web/javascript/reference/global_objects/decodeuri/index.html new file mode 100644 index 0000000000..5563376592 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/decodeuri/index.html @@ -0,0 +1,40 @@ +--- +title: decodeURI() +slug: Web/JavaScript/Reference/Global_Objects/decodeURI +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/decodeURI +original_slug: Web/JavaScript/Referencje/Obiekty/decodeURI +--- +<div>{{jsSidebar("Objects")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Dekoduje Jednolity Identyfikator Zasobu (URI) utworzony wcześniej przez funkcję {{jsxref("encodeURI", "encodeURI()")}} lub podobną.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>decodeURI(<i>encodedURI</i>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>encodedURI</code> </dt> + <dd>Kompletny, odkodowany Jednolity Identyfikator Zasobu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Podmienia każdą sekwencję ucieczki (ang. + <i>escape sequence</i> + ) w zakodowanym URI znakiem, który reprezentuje.</p> + +<p>Nie dekoduje sekwencji, które nie mogłyby być wprowadzone przez {{jsxref("encodeURI", "encodeURI()")}}.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li> + <li>{{jsxref("encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/decodeuricomponent/index.html b/files/pl/web/javascript/reference/global_objects/decodeuricomponent/index.html new file mode 100644 index 0000000000..b14a436859 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/decodeuricomponent/index.html @@ -0,0 +1,42 @@ +--- +title: decodeURIComponent() +slug: Web/JavaScript/Reference/Global_Objects/decodeURIComponent +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent +original_slug: Web/JavaScript/Referencje/Obiekty/decodeURIComponent +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Dekoduje komponent Jednolitego Identyfikatora Zasobu (URI) stworzonego przez {{jsxref("encodeURIComponent", "encodeURIComponent()")}} lub podobną.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>decodeURIComponent(<em>encodedURI</em>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>encodedURI</code> </dt> + <dd>Odkodowany komponent Jednolitego Identyfikatora Zasobu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Podmienia każdą sekwencję ucieczki (ang. + <i>escape sequence</i> + ) w zakodowanym komponencie URI znakiem, który ona reprezentuje.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/encodeuri/index.html b/files/pl/web/javascript/reference/global_objects/encodeuri/index.html new file mode 100644 index 0000000000..52229240b8 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/encodeuri/index.html @@ -0,0 +1,73 @@ +--- +title: encodeURI() +slug: Web/JavaScript/Reference/Global_Objects/encodeURI +tags: + - JavaScript + - URI +translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI +original_slug: Web/JavaScript/Referencje/Obiekty/encodeURI +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Koduje Jednolity Identyfikator Zasobu (URI) poprzez zamianę każdego z wystąpień pewnych znaków na jedną, dwie lub trzy sekwencje ucieczki (ang. + <i>escape sequences</i> + ) kodowania UTF-8 danego znaku.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>encodeURI(<em>URI</em>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>URI</code> </dt> + <dd>Kompletny Jednolity Identyfikator Zasobu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Zakłada się, iż URI jest kompletnym URI, więc nie koduje znaków zarezerwowanych, mających specjalne znaczenie w URI.</p> + +<p><code>encodeURI</code> zamienia wszystkie znaki, poza podanymi poniżej, odpowiednimi sekwencjami ucieczki.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Typ</td> + <td class="header">Zawiera</td> + </tr> + <tr> + <td>Znaki zarezerwowane</td> + <td><code>; , / ? : @ & = + $</code></td> + </tr> + <tr> + <td>Znaki nie podlegające ucieczce</td> + <td>Litery, cyfry, <code>- _ . ! ~ * ' ( )</code></td> + </tr> + <tr> + <td> + <i>Score</i> + </td> + <td><code>#</code></td> + </tr> + </tbody> +</table> + +<p>Zauważ, że <code>encodeURI</code> samo z siebie + + <i>nie</i> + potrafi utworzyć poprawnych żądań HTTP GET i POST, jak na przykład XMLHTTPRequest, ponieważ "&", "+", i "=" nie są kodowane, a są traktowane jako znaki specjalne w żądaniach GET i POST. Jednakże, {{jsxref("encodeURIComponent", "encodeURIComponent()")}}, koduje te znaki. Zachowania te są konsekwentnie wspomagane przez różne przeglądarki.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li> + <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/encodeuricomponent/index.html b/files/pl/web/javascript/reference/global_objects/encodeuricomponent/index.html new file mode 100644 index 0000000000..2c694bc5ba --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/encodeuricomponent/index.html @@ -0,0 +1,39 @@ +--- +title: encodeURIComponent() +slug: Web/JavaScript/Reference/Global_Objects/encodeURIComponent +tags: + - JavaScript + - URI +translation_of: Web/JavaScript/Reference/Global_Objects/encodeURIComponent +original_slug: Web/JavaScript/Referencje/Obiekty/encodeURIComponent +--- +<div>{{jsSidebar("Objects")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Koduje każdy komponent Jednolitego Identyfikatora Zasobu (URI) poprzez zamianę, każdego wystąpienia pewnych znaków jedną, dwoma lub trzema sekwencjami ucieczki reprezentujące kodowanie UTF-8 znaku.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox">encodeURIComponent(str);</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>str</code></dt> + <dd>Komponent Jednolitego Identyfikatora Zasobu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>encodeURIComponent()</code> zamienia wszystkie znaki na sekwencje ucieczki poza znakami: alfabetycznymi, cyframi, <code>- _ . ! ~ * ' ( )</code></p> + +<p>Ze względów bezpieczeństwa, powinieneś wywoływać <code>encodeURIComponent</code> na każdym parametrze podanym przez użytkownika, który będzie podany jako część URI. Na przykład, użytkownik mógł wpisać "<code>Thyme &time=again</code>" dla zmiennej <code>comment</code>. Nie użycie <code>encodeURIComponent</code> na tej zmiennej da <code>comment=Thyme%20&time=again</code>. Zauważ, że znak ampersand (<em>&</em>) i znak równości (<em>=</em> ) oznaczają nową parę kluczy i wartość. Więc, zamiast wysyłać klucz <code>comment</code> równy <code>Thyme &time=again</code>, dostaniesz dwa klucze POST, jeden równy "Thyme" , a drugi (<code>time</code>) równy again.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/error/columnnumber/index.html b/files/pl/web/javascript/reference/global_objects/error/columnnumber/index.html new file mode 100644 index 0000000000..ac83ab1f07 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/error/columnnumber/index.html @@ -0,0 +1,82 @@ +--- +title: Error.prototype.columnNumber +slug: Web/JavaScript/Reference/Global_Objects/Error/columnNumber +translation_of: Web/JavaScript/Reference/Global_Objects/Error/columnNumber +original_slug: Web/JavaScript/Referencje/Obiekty/Error/columnNumber +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>The <code><strong>columnNumber</strong></code> property contains the column number in the line of the file that raised this error.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_columnNumber">Using <code>columnNumber</code></h3> + +<pre class="brush: js">var e = new Error('Could not parse input'); +throw e; +console.log(e.columnNumber) // 0 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<p>Not part of any specification. Non-standard.</p> + +<h2 id="Browser_compatibility">Browser compatibility</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>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</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>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/error/filename/index.html b/files/pl/web/javascript/reference/global_objects/error/filename/index.html new file mode 100644 index 0000000000..b6533ba106 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/error/filename/index.html @@ -0,0 +1,50 @@ +--- +title: Error.prototype.fileName +slug: Web/JavaScript/Reference/Global_Objects/Error/fileName +tags: + - JavaScript + - Prototyp + - Prototype + - Właściwość + - niestandardowe +translation_of: Web/JavaScript/Reference/Global_Objects/Error/fileName +original_slug: Web/JavaScript/Referencje/Obiekty/Error/fileName +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Właściwość <code><strong>fileName</strong></code> zawiera ścieżkę do pliku, który spowodował błąd.</p> + +<h2 id="Opis">Opis</h2> + +<p>Ta nieopisana w żadnym standardzie właściwość zawiera ścieżkę do pliku, który spowodował błąd. Jeśli jest wywoływana z kontekstu debuggera, jak na przykład Firefox Developer Tools, zwracana jest wartość "debugger eval code".</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_fileName">Użycie <code>fileName</code></h3> + +<pre class="brush: js">var e = new Error('Błąd przy parsowaniu wejścia'); +throw e; +// wartość e.fileName powinna być czymś podobnym do "file:///C:/example.html" +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<p><span class="pl-s">Nie jest częścią żadnego standardu.</span></p> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Error.fileName")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}}</li> + <li>{{jsxref("Error.prototype.columnNumber")}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/error/index.html b/files/pl/web/javascript/reference/global_objects/error/index.html new file mode 100644 index 0000000000..2d61bfdb38 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/error/index.html @@ -0,0 +1,247 @@ +--- +title: Error +slug: Web/JavaScript/Reference/Global_Objects/Error +tags: + - Błąd + - CustomError + - Error + - JavaScript + - Obsługa błędów +translation_of: Web/JavaScript/Reference/Global_Objects/Error +original_slug: Web/JavaScript/Referencje/Obiekty/Error +--- +<div>{{JSRef}}</div> + +<div>Kontruktor klasy <strong><code>Error</code></strong> tworzy obiekt błędu. Instancja klasy <code>Error</code> jest rzucana w momencie napotkania błędu w trakcie wykonywania programu. Klasa <code>Error</code> może być także używana do tworzenia własnych wyjątków. Poniżej przestawione zostaną wbudowane standardowe typy błędów.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">new Error([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Opcjonalny. Opis błędu zrozumiały dla użytkownika.</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Opcjonalny. Wartość dla parametru <code>fileName</code> przy tworzeniu obiektu <code>Error</code>. Domyślnie to nazwa pliku zawierającego kod, który wywołał konstruktor.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Opcjonalny. Wartość dla paramteru <code>lineNumber</code> przy tworzeniu obiektu <code>Error</code>. Domyślnie zawiera numer linijki zawirającej wywołanie konstruktora klasy <code>Error</code>.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Błędy w trakcie wykonywania programu skutkują utworzeniem i rzuceniem nowego obiektu <code>Error</code>.</p> + +<p>This page documents the use of the <code>Error</code> object itself and its use as a constructor function. For a list of properties and methods inherited by <code>Error</code> instances, see {{jsxref("Error.prototype")}}.</p> + + + +<h3 id="Używanie_jako_funkcja">Używanie jako funkcja</h3> + +<p>Gdy <code>Error</code> jest używany jako funkcja -- bez słowa kluczowego <code>new</code>, zwraca on obiekt <code>Error</code>. Możemy więc zauważyć, że zwykłe wywołanie <code>Error</code> zwróci nam to samo co stworznie nowego obiektu <code>Error</code> przy pomocy słowa kluczowego <code>new</code>.</p> + +<pre class="notranslate"><code>// to: +const x = Error('Jestem stworzony przy pomocy wyowałania funkcji!'); +// działa tak samo jak to: +const y = new Error('Jestem stworzony przy pomocy słowa kluczowego "new"!');</code></pre> + + + +<h3 id="Typy_błędów">Typy błędów</h3> + +<p>Oprócz konstruktora generycznego <code>Error</code>, mamy jeszcze siedem innych podstawowych konstruktorów błędów w JavaScript. Dla wyjątów po stronie klienta zobacz <a href="/en-US/docs/Web/JavaScript/Guide/Statements#Exception_Handling_Statements">Exception Handling Statements</a>.</p> + +<dl> + <dt>{{jsxref("EvalError")}}</dt> + <dd>Tworzy instancje reprezentującą błąd dotyczący globalnej funkcji {{jsxref("Global_Objects/eval", "eval()")}}.</dd> + <dt>{{jsxref("InternalError")}} {{non-standard_inline}}</dt> + <dd>Tworzy instancje reprezentującą błąd, który występuje w momencie wyrzucenia wewnętrznego błędu silnika JavaScript np. "too much recursion".</dd> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tworzy instancje reprezentującą błąd, który występuje w momencie gdy zmienna numeryczna lub parametr wyjdzie poza zakres. </dd> + <dt>{{jsxref("ReferenceError")}}</dt> + <dd>Tworzy instancje reprezentującą błąd, który występuje przy próbie odwołania do nieistniejącego zasobu.</dd> + <dt>{{jsxref("SyntaxError")}}</dt> + <dd>Tworzy instancje reprezentującą błąd składni, który występuje przy parsowaniu kodu przy pomocy {{jsxref("Global_Objects/eval", "eval()")}}.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Tworzy instancję reprezentującą błąd, który występuje gdy zmienna lub parametr mają niepoprawny typ.</dd> + <dt>{{jsxref("URIError")}}</dt> + <dd>Tworzy instancję reprezentującą błąd, który występuje gdy {{jsxref("Global_Objects/encodeURI", "encodeURI()")}} i {{jsxref("Global_Objects/decodeURI", "decodeURI()")}} mają przekazane nieprawidłowe parametry.</dd> +</dl> + +<h2 id="Właściwości">Właściwości</h2> + +<dl> + <dt>{{jsxref("Error.prototype")}}</dt> + <dd>Pozwala na dodawanie właściwości do instancji klasy <code>Error</code>.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<p>Globalny obiekt <code>Error</code> sam w sobie nie zawiera metod, niemniej, dziedziczy on niektóre metody z łańcucha prototypów.</p> + +<h2 id="Error_instancje"><code>Error</code> instancje</h2> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/Error/prototype', 'Description')}}</div> + +<h3 id="Właściwości_2">Właściwości</h3> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/Error/prototype', 'Properties')}}</div> + +<h3 id="Metody_2">Metody</h3> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/Error/prototype', 'Methods')}}</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Rzucanie_ogólnego_błędu">Rzucanie ogólnego błędu</h3> + +<p>Zazwyczaj tworzysz obiekt <code>Error</code> w celu wywołania go przy użyciu słowa kluczowego {{jsxref("Statements/throw", "throw")}}. Możesz obsłużyć tak rzucony błąd przy pomocy konstrukcji {{jsxref("Statements/try...catch", "try...catch")}}:</p> + +<pre class="brush: js notranslate">try { + throw new Error('Whoops!'); +} catch (e) { + alert(e.name + ': ' + e.message); +} +</pre> + +<h3 id="Obsługa_specyficznych_błędów">Obsługa specyficznych błędów</h3> + +<p>Jeżeli chcesz możesz obsługiwać tylko specyficzny rodzaj błędu poprzez użycie właściwości jego {{jsxref("Object.prototype.constructor", "constructor")}} lub, jeżeli używasz nowoczesnego silnika JavaScript, poprzez słowo kluczowe {{jsxref("Operators/instanceof", "instanceof")}}:</p> + +<pre class="brush: js notranslate">try { + foo.bar(); +} catch (e) { + if (e instanceof EvalError) { + alert(e.name + ': ' + e.message); + } else if (e instanceof RangeError) { + alert(e.name + ': ' + e.message); + } + // ... etc +} +</pre> + +<h3 id="Niestandardowe_typy_błędów">Niestandardowe typy błędów</h3> + +<p>Możesz chcieć zdefiniować własny typ błędu pochodzący z klasy <code>Error</code> z możliwością rzucenia błędu <code>throw new MyError()</code> i użycia <code>instanceof MyError</code> w celu sprawdzenia jego rodzaju. Skutkuje to czystszym i spójniejszym kodem obsługi błędów. Zobacz <a href="http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript">"What's a good way to extend Error in JavaScript?"</a> na StackOverflow dla dogłębniejszej analizy.</p> + +<h4 id="ES6_Custom_Error_Class">ES6 Custom Error Class</h4> + +<div class="warning"> +<p>Babel i inne transpilatory nie potrafią poprawnie obsłużyć podanego kodu bez <a href="https://github.com/loganfsmyth/babel-plugin-transform-builtin-extend">dodatkowej konfiguracji</a>.</p> +</div> + +<div class="note"> +<p>Nie które przeglądarki dodają constructor <code>CustomError</code> w stosie błędu kiedy używamy klas ES2015</p> +</div> + +<pre class="brush: js notranslate">class CustomError extends Error { + constructor(foo = 'bar', ...params) { + // Pass remaining arguments (including vendor specific ones) to parent constructor + super(...params); + + // Maintains proper stack trace for where our error was thrown (only available on V8) + if (Error.captureStackTrace) { + Error.captureStackTrace(this, CustomError); + } + + // Custom debugging information + this.foo = foo; + this.date = new Date(); + } +} + +try { + throw new CustomError('baz', 'bazMessage'); +} catch(e){ + console.log(e.foo); //baz + console.log(e.message); //bazMessage + console.log(e.stack); //stacktrace +}</pre> + +<h4 id="ES5_Custom_Error_Object">ES5 Custom Error Object</h4> + +<div class="warning"> +<p><strong>Wszystkie</strong> przeględarki dodają konstruktor <code>CustomError </code>kiedy używasz konstruktora z wykorzystaniem prototype</p> +</div> + +<pre class="brush: js notranslate">function CustomError(foo, message, fileName, lineNumber) { + var instance = new Error(message, fileName, lineNumber); + instance.foo = foo; + Object.setPrototypeOf(instance, Object.getPrototypeOf(this)); + if (Error.captureStackTrace) { + Error.captureStackTrace(instance, CustomError); + } + return instance; +} + +CustomError.prototype = Object.create(Error.prototype, { + constructor: { + value: Error, + enumerable: false, + writable: true, + configurable: true + } +}); + +if (Object.setPrototypeOf){ + Object.setPrototypeOf(CustomError, Error); +} else { + CustomError.__proto__ = Error; +} + + +try { + throw new CustomError('baz', 'bazMessage'); +} catch(e){ + console.log(e.foo); //baz + console.log(e.message) ;//bazMessage +}</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Początkowa definicja. Zaimplementowana w JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11', 'Error')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-error-objects', 'Error')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-error-objects', 'Error')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error")}}</p> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Statements/throw", "throw")}}</li> + <li>{{jsxref("Statements/try...catch", "try...catch")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/error/linenumber/index.html b/files/pl/web/javascript/reference/global_objects/error/linenumber/index.html new file mode 100644 index 0000000000..955f768c0b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/error/linenumber/index.html @@ -0,0 +1,58 @@ +--- +title: Error.prototype.lineNumber +slug: Web/JavaScript/Reference/Global_Objects/Error/lineNumber +tags: + - JavaScript + - Prototyp + - Prototype + - Referencja + - Własność + - niestandardowe +translation_of: Web/JavaScript/Reference/Global_Objects/Error/lineNumber +original_slug: Web/JavaScript/Referencje/Obiekty/Error/lineNumber +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Właściwość <code><strong>lineNumber</strong></code> zawiera numer linii w pliku, gdzie pojawił się błąd.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_lineNumber">Użycie <code>lineNumber</code></h3> + +<pre class="brush: js">var e = new Error('Błąd przy parsowaniu wejścia'); +throw e; +console.log(e.lineNumber) // 2 +</pre> + +<h3 id="Alternatywny_przykład_użycia_zdarzenia_error">Alternatywny przykład użycia zdarzenia <code>error</code></h3> + +<pre class="brush: js">window.addEventListener('error', function(e) { + console.log(e.lineNumber); // 5 +}); +var e = new Error('Błąd przy parsowaniu wejścia'); +throw e; +</pre> + +<p>Własność <code>lineNumber</code> jest niestandardowa i nie posiada szerokiego wsparcia – zobacz tabelę opisującą wsparcie przeglądarek dla tej własności.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<p><span class="pl-s">Nie jest częścią żadnego standardu.</span></p> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Error.lineNumber")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}}</li> + <li>{{jsxref("Error.prototype.columnNumber")}}</li> + <li>{{jsxref("Error.prototype.fileName")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/error/message/index.html b/files/pl/web/javascript/reference/global_objects/error/message/index.html new file mode 100644 index 0000000000..3cfdd45e92 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/error/message/index.html @@ -0,0 +1,109 @@ +--- +title: Error.prototype.message +slug: Web/JavaScript/Reference/Global_Objects/Error/message +translation_of: Web/JavaScript/Reference/Global_Objects/Error/message +original_slug: Web/JavaScript/Referencje/Obiekty/Error/message +--- +<div>{{JSRef}}</div> + +<p>Właściwość <code><strong>message</strong></code> jest komunikatem błędu zapisanym w sposób czytelny dla czlowieka.</p> + +<h2 id="Opis">Opis</h2> + +<p>Właściwość zawiera krótki opis błędu, jeśli jest dostępny, lub został ustawiony. <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> szeroko wykorzystuje właściwość <code>message</code> w wyjątkach. Właściwość <code>message</code> jest używany, wraz z właściwością {{jsxref("Error.prototype.name", "name")}} przez metodę {{jsxref("Error.prototype.toString()")}} do tworzenia tekstowej reprezentacji obiektu Error.</p> + +<p>Domyślnie właściwość <code>message </code>jest pustym stringiem, ale to zachowanie może zostać nadpisane w instancji, poprzez przekazanie komunikatu jako pierwszy parametr do {{jsxref("Error", "Error constructor")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Rzucanie_ustawionego_błędu">Rzucanie ustawionego błędu</h3> + +<pre class="brush: js">var e = new Error('Could not parse input'); // e.message is 'Could not parse input' +throw e; +</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>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.4.3', 'Error.prototype.message')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype.message', 'Error.prototype.message')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</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_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.name")}}</li> + <li>{{jsxref("Error.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/error/name/index.html b/files/pl/web/javascript/reference/global_objects/error/name/index.html new file mode 100644 index 0000000000..e797299222 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/error/name/index.html @@ -0,0 +1,110 @@ +--- +title: Error.prototype.name +slug: Web/JavaScript/Reference/Global_Objects/Error/name +translation_of: Web/JavaScript/Reference/Global_Objects/Error/name +original_slug: Web/JavaScript/Referencje/Obiekty/Error/name +--- +<div>{{JSRef}}</div> + +<p>Właściwość <code><strong>name</strong></code> reprezentuję nazwę danego typu błędu. Początkową wartością jest "Error".</p> + +<h2 id="Opis">Opis</h2> + +<p>Domyślnie, instancje {{jsxref("Error")}} mają ustawioną nazwę "Error". Właściwość <code>name</code>, razem z właściwością {{jsxref("Error.prototype.message", "message")}}, jest używana przez metodę {{jsxref("Error.prototype.toString()")}} do tworzenia tekstowej reprezentacji obiektu Error.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Rzucanie_ustawionego_błędu">Rzucanie ustawionego błędu</h3> + +<pre class="brush: js">var e = new Error('Malformed input'); // e.name is 'Error' + +e.name = 'ParseError'; +throw e; +// e.toString() would return 'ParseError: Malformed input' +</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>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.4.2', 'Error.prototype.name')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype.name', 'Error.prototype.name')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</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_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.message")}}</li> + <li>{{jsxref("Error.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/error/stack/index.html b/files/pl/web/javascript/reference/global_objects/error/stack/index.html new file mode 100644 index 0000000000..ab989c4b8d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/error/stack/index.html @@ -0,0 +1,128 @@ +--- +title: Error.prototype.stack +slug: Web/JavaScript/Reference/Global_Objects/Error/Stack +tags: + - JavaScript + - Prototyp + - Referencja + - Własność + - niestandardowe +translation_of: Web/JavaScript/Reference/Global_Objects/Error/Stack +original_slug: Web/JavaScript/Referencje/Obiekty/Error/Stack +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Niestandardowa własność <strong><code>stack</code></strong> obiektów {{jsxref("Error")}} podaje ścieżkę wywołań funkcji – które z nich były wywołane, w jakiej kolejności, z której linii i pliku, z jakimi argumentami. Stos wywołań zaczyna się od ostatnich wywołań, przez wcześniejsze, prowadząc do pierwotnego wywołania z zakresu globalnego.</p> + +<h2 id="Opis">Opis</h2> + +<p>Każdy krok będzie znajdował się w oddzielnej linii, zawierając w pierwszej części nazwę funkcji (jeśli nie jest to wywołanie z zakresu globalnego), następnie znak <em>at</em> (<code>@</code>), lokalizację pliku (z wyjątkiem sytuacji, w których funkcja jest konstruktorem zgłaszanego błędu), dwukropek oraz numer linii (jeśli zdefiniowana jest lokalizacja pliku). (Zauważ, że obiekt {{jsxref("Error")}} także posiada własności <code>fileName</code>, <code>lineNumber</code> i <code>columnNumber</code>, które można odczytać z danego błędu, jednak jedynie błędu, a nie jego stosu wywołań).</p> + +<p>Należy podkreślić, że opisany wyżej format jest formatem przeglądarki Firefox – nie ma standardu formatowania, jednakże Safari 6+ i Opera 12- używają bardzo podobnego formatu. Przeglądarki używające silnika JavaScript V8 (takie jak Chrome, Opera 15+, Android Browser) oraz IE10+, używają natomiast innego formatu (zobacz <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">archiwalną dokumentację MSDN dla error.stack</a>).</p> + +<p><strong>Wartości argumentów w stosie:</strong> w wersjach wcześniejszych niż Firefox 14, po nazwie funkcji następowały wartości argumentów przekonwertowane do łańcucha znaków (<em>string</em>) w nawiasach, przed znakiem <em>at</em> (<code>@</code>). Podczas gdy obiekt (lub tablica itp.) pojawia się w przekonwertowanej formie <code>"[object Object]"</code> i nie może być przekonwertowany z powrotem do właściwych obiektów, wartości skalarne mogą być odzyskane (choć być może — w Firefoksie 14 nadal jest to możliwe — łatwiej będzie użyć <code>arguments.callee.caller.arguments</code>, tak jak nazwa funkcji może być uzyskana przez <code>arguments.callee.caller.name</code>). <code>"undefined"</code> jest wylistowany jako <code>"(void 0)"</code>. Zauważ, że jeśli argumenty typu <em>string</em> były przekazane z wartościami takimi jak <code>"@"</code>, <code>"("</code>, <code>")"</code> (lub znaki te występują w nazwach plików), nie możesz polegać po prostu na podzieleniu linii na części składowe – <span class="tlid-translation translation" lang="pl"><span title="">dlatego w Firefoksie 14 i nowszych jest to mniejszy problem<strong>.</strong></span></span></p> + +<p>Różne przeglądarki ustawiają tę wartość w różnych momentach. Przykładowo, Firefox ustawia ją podczas tworzenia obiektu {{jsxref("Error")}}, natomiast PhantomJS ustawia ją jedynie podczas wyrzucania {{jsxref("Error")}} – i <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">archiwalna dokumentacja MSDN</a> również wydaje się zgadzać z implementacją PhantomJS.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_własności_stack">Użycie własności <code>stack</code></h3> + +<p>Poniższy dokument HTML prezentuje użycie własności <code>stack</code>.</p> + +<pre class="brush: html notranslate"><!DOCTYPE HTML> +<meta charset="UTF-8"> +<title>Stack Trace Example</title> +<body> +<script> +function trace() { + try { + throw new Error('myError'); + } + catch(e) { + alert(e.stack); + } +} +function b() { + trace(); +} +function a() { + b(3, 4, '\n\n', undefined, {}); +} +a('first call, firstarg'); +</script> +</pre> + +<p>Zakładając, że powyższy dokument zapisany jest pod adresem <code>C:\example.html</code> w systemie plików Windows, kod utworzy okno typu <em>alert</em> z następującą treścią:</p> + +<p>W przeglądarce Firefox 30 i późniejszych wersjach, wraz z numerem kolumny:</p> + +<pre class="notranslate"><samp>trace@file:///C:/example.html:9:17 +b@file:///C:/example.html:16:13 +a@file:///C:/example.html:19:13 +@file:///C:/example.html:21:9</samp></pre> + +<p>Od Firefoxa 14 do Firefoxa 29:</p> + +<pre class="notranslate"><samp>trace@file:///C:/example.html:9 +b@file:///C:/example.html:16 +a@file:///C:/example.html:19 +@file:///C:/example.html:21</samp></pre> + +<p>Firefox 13 i wcześniejsze zwróci zamiast tego następujący tekst:</p> + +<pre class="notranslate"><samp>Error("myError")@:0 +trace()@file:///C:/example.html:9 +b(3,4,"\n\n",(void 0),[object Object])@file:///C:/example.html:16 +a("first call, firstarg")@file:///C:/example.html:19 +@file:///C:/example.html:21</samp></pre> + +<h3 id="Stos_ewaluowanego_kodu">Stos ewaluowanego kodu</h3> + +<p>Od Firefoxa 30, stos błędu w wywołaniach <code>Function()</code> i <code>eval()</code> tworzy stos z bardziej szczegółową informacją o linii i kolumnie wewnątrz tych wywołań. Wywołania funkcji są wskazywane przez <code>"> Function"</code>, a eval przez <code>"> eval"</code>.</p> + +<pre class="brush: js notranslate">try { + new Function('throw new Error()')(); +} catch (e) { + console.log(e.stack); +} + +// anonymous@file:///C:/example.html line 7 > Function:1:1 +// @file:///C:/example.html:7:6 + + +try { + eval("eval('FAIL')"); +} catch (x) { + console.log(x.stack); +} + +// @file:///C:/example.html line 7 > eval line 1 > eval:1:1 +// @file:///C:/example.html line 7 > eval:1:1 +// @file:///C:/example.html:7:6 +</pre> + +<p>Możesz także użyć dyrektywy <code>//# sourceURL</code> do nazwania źródła <code>eval</code>. Zobacz też źródła <a href="/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources">Debug eval</a> w dokumentacji <a href="/en-US/docs/Tools/Debugger">Debuggera</a> oraz w <a href="http://fitzgeraldnick.com/weblog/59/">tym artykule</a>.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<p><span class="pl-s">Nie jest częścią żadnego standardu.</span></p> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Error.stack")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Components.stack">Components.stack</a></li> + <li>Projekty zewnetrzne: <a class="link-https" href="https://github.com/csnover/TraceKit/">TraceKit</a> i <a class="link-https" href="https://github.com/eriwen/javascript-stacktrace">javascript-stacktrace</a></li> + <li>MSDN: <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">archiwalna dokumentacja error.stack</a></li> + <li><a href="https://github.com/v8/v8/wiki/Stack%20Trace%20API">Przegląd API stosu wywołań w JavaScript V8</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/error/tosource/index.html b/files/pl/web/javascript/reference/global_objects/error/tosource/index.html new file mode 100644 index 0000000000..1a6c5b4e2f --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/error/tosource/index.html @@ -0,0 +1,61 @@ +--- +title: Error.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Error/toSource +tags: + - JavaScript + - Metodă + - Niestandardowy + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource +original_slug: Web/JavaScript/Referencje/Obiekty/Error/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Metoda <code><strong>toSource()</strong></code> zwraca kod, który możemethod returns code that could eval to the same error.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><var>e</var>.toSource()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Łańcuch znaków (<em>string</em>) zawierający kod źródłowy błędu.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_toSource">Użycie toSource</h3> + +<p>Wywołanie metody <code>toSource</code> instancji {{jsxref("Error")}} (w tym <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types">NativeErrors</a></em>) zwróci łańcuch znaków zawierający kod źródłowy błędu. Zwrócony <em>string</em> może być ewaluowany do utworzenia (w przybliżeniu) takiego samego obiektu. Oczywiście ciąg znaków zawierający kod źródłowy jest zgodny ze strukturą konstruktora {{jsxref("Error")}}. Przykładowo:</p> + +<pre class="brush: js notranslate">(<em>newname</em>(<em>message</em>, <em>nazwaPliku</em>, <em>numerLinii</em>)) +</pre> + +<p>gdzie wymienione atrybuty odpowiadają właściwym własnościom instancji błędu.</p> + +<div class="note"> +<p><strong>Uwaga:</strong> należy pamiętać, że własności używanen przez metodę <code>toSource</code> podczas tworzenia tego ciągu znaków są modyfikowalne i mogą nie odzwierciedlać dokładnie funkcji użytej do stworzenia instancji błędu lub nazwy pliku czy numeru linii gdzie wystąpił dany błąd.</p> +</div> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<p>Nie należy do żadnego standardu.</p> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Error.toSource")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.fileName")}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}}</li> + <li>{{jsxref("Error.prototype.message")}}</li> + <li>{{jsxref("Error.prototype.name")}}</li> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/error/tostring/index.html b/files/pl/web/javascript/reference/global_objects/error/tostring/index.html new file mode 100644 index 0000000000..34c420487e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/error/tostring/index.html @@ -0,0 +1,99 @@ +--- +title: Error.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Error/toString +tags: + - JavaScript + - Metodă + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString +original_slug: Web/JavaScript/Referencje/Obiekty/Error/toString +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>toString()</strong></code> zwraca iąg znaków reprezentujący dany obiekt {{jsxref("Error")}}.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><code><var>e</var>.toString()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Ciąg znaków reprezentujący dany obiekt {{jsxref("Error")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Error")}} nadpisuje metodę {{jsxref("Object.prototype.toString()")}} dziedziczoną przez wszystkie obiekty. Jego semantyka jest następująca (przy założeniu, że {{jsxref("Object")}} i {{jsxref("String")}} mają swoje oryginalne wartości):</p> + +<pre class="brush: js notranslate">Error.prototype.toString = function() { + 'use strict'; + + var obj = Object(this); + if (obj !== this) { + throw new TypeError(); + } + + var name = this.name; + name = (name === undefined) ? 'Error' : String(name); + + var msg = this.message; + msg = (msg === undefined) ? '' : String(msg); + + if (name === '') { + return msg; + } + if (msg === '') { + return name; + } + + return name + ': ' + msg; +}; +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_toString">Użycie toString()</h3> + +<pre class="brush: js notranslate">var e = new Error('fatal error'); +console.log(e.toString()); // 'Error: fatal error' + +e.name = undefined; +console.log(e.toString()); // 'Error: fatal error' + +e.name = ''; +console.log(e.toString()); // 'fatal error' + +e.message = undefined; +console.log(e.toString()); // '' + +e.name = 'hello'; +console.log(e.toString()); // 'hello' +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.toString")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.toSource()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/escape/index.html b/files/pl/web/javascript/reference/global_objects/escape/index.html new file mode 100644 index 0000000000..2fcf67431d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/escape/index.html @@ -0,0 +1,121 @@ +--- +title: escape() +slug: Web/JavaScript/Reference/Global_Objects/escape +translation_of: Web/JavaScript/Reference/Global_Objects/escape +original_slug: Web/JavaScript/Referencje/Obiekty/escape +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>The deprecated <code><strong>escape()</strong></code> function computes a new string in which certain characters have been replaced by a hexadecimal escape sequence. Use {{jsxref("encodeURI")}} or {{jsxref("encodeURIComponent")}} instead.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>escape(str)</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>str</code></dt> + <dd>A string to be encoded.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>The <code>escape</code> function is a property of the <em>global object</em>. Special characters are encoded with the exception of: @*_+-./</p> + +<p>The hexadecimal form for characters, whose code unit value is 0xFF or less, is a two-digit escape sequence: %xx. For characters with a greater code unit, the four-digit format %<strong>u</strong>xxxx is used.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">escape("abc123"); // "abc123" +escape("äöü"); // "%E4%F6%FC" +escape("ć"); // "%u0107" + +// znaki specjalne +escape("@*_+-./"); // "@*_+-./"</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.1', 'escape')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Defined in the (informative) Compatibility Annex B</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-escape-string', 'escape')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<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="See_also">See also</h2> + +<ul> + <li>{{jsxref("encodeURI")}}</li> + <li>{{jsxref("encodeURIComponent")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/evalerror/index.html b/files/pl/web/javascript/reference/global_objects/evalerror/index.html new file mode 100644 index 0000000000..15b2ee1c40 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/evalerror/index.html @@ -0,0 +1,88 @@ +--- +title: EvalError +slug: Web/JavaScript/Reference/Global_Objects/EvalError +tags: + - EvalError + - JavaScript + - Klasa + - Obiekt + - Referencja +translation_of: Web/JavaScript/Reference/Global_Objects/EvalError +original_slug: Web/JavaScript/Referencje/Obiekty/EvalError +--- +<div>{{JSRef}}</div> + +<p>Obiekt <strong><code>EvalError</code></strong> wskazuje na błąd dotyczący globalnej funkcji {{jsxref("Global_Objects/eval", "eval()")}}. Ten wyjątek nie jest już wywoływany przez JavaScript, jednak obiekt <code>EvalError</code> został zachowany ze względu na kompatybilność wsteczną.</p> + +<h2 id="Konstruktor">Konstruktor</h2> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/EvalError"><code>EvalError()</code></a></dt> + <dd>Tworzy nowy obiekt <code>EvalError</code>.</dd> +</dl> + +<h2 id="Własności_instancji">Własności instancji</h2> + +<dl> + <dt>{{jsxref("Error.prototype.message", "EvalError.prototype.message")}}</dt> + <dd>Treść błędu. Choć ECMA-262 określa, że {{jsxref("EvalError")}} powinien mieć swoją własną wartość <code>message</code>, w <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> jest ona dziedziczona z {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "EvalError.prototype.name")}}</dt> + <dd>Nazwa błędu. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "EvalError.prototype.fileName")}}</dt> + <dd>Ścieżka do pliku, w którym został wywołany błąd. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "EvalError.prototype.lineNumber")}}</dt> + <dd>Numer linii w pliku, gdzie został wywołany błąd. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "EvalError.prototype.columnNumber")}}</dt> + <dd>Kolumna w linii, gdzie został wywołany błąd. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "EvalError.prototype.stack")}}</dt> + <dd>Stos wywołań. Dziedziczone z {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<p><code>EvalError</code> nie jest używany w obecnej specyfikacji ECMAScript, zatem nie będzie wywoływany podczas wykonania programu – jednakże sam obiekt został zachowany ze względu na wsteczną kompatybilność z wcześniejszymi wersjami specyfikacji.</p> + +<h3 id="Tworzenie_EvalError">Tworzenie EvalError</h3> + +<pre class="brush: js notranslate">try { + throw new EvalError('Hello', 'someFile.js', 10); +} catch (e) { + console.log(e instanceof EvalError); // true + console.log(e.message); // "Hello" + console.log(e.name); // "EvalError" + console.log(e.fileName); // "someFile.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:2:9\n" +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.EvalError")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/function/apply/index.html b/files/pl/web/javascript/reference/global_objects/function/apply/index.html new file mode 100644 index 0000000000..1114e51167 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/function/apply/index.html @@ -0,0 +1,290 @@ +--- +title: Function.prototype.apply() +slug: Web/JavaScript/Reference/Global_Objects/Function/apply +translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply +original_slug: Web/JavaScript/Referencje/Obiekty/Function/apply +--- +<div>{{JSRef}}</div> + +<p>Metoda <code>apply()</code> wywołuje daną funkcję podstawiając daną wartość <code>this</code> i argumenty <span id="result_box" lang="pl"><span>przedstawione</span> <span>w postaci tablicy</span></span> (lub obiektu tablicopodobnego (<a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">array-like object</a>)).</p> + +<div class="note"> +<p><strong>Notka:</strong> <span id="result_box" lang="pl"><span>Składnia</span> <span>tej funkcji jest</span> <span>niemal identyczna </span><span>do</span></span> {{jsxref("Function.call", "call()")}}, podstawową różnicą jest to, iż <code>call()</code> przyjmuje <strong>listę argumentów</strong>, podczas gdy <code>apply()</code> akceptuje <strong>pojedynczą tablicę argumentów</strong>.</p> +</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><em><var>fun</var>ction</em>.apply(<var>thisArg, </var>[<var>argsArray</var>])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd>Optional. The value of <code>this</code> provided for the call to <em><code>func</code></em>. Note that <code>this</code> may not be the actual value seen by the method: if the method is a function in {{jsxref("Strict_mode", "non-strict mode", "", 1)}} code, {{jsxref("null")}} and {{jsxref("undefined")}} will be replaced with the global object, and primitive values will be boxed.</dd> + <dt><code>argsArray</code></dt> + <dd>Optional. An array-like object, specifying the arguments with which <em><code>fun</code></em> should be called, or {{jsxref("null")}} or {{jsxref("undefined")}} if no arguments should be provided to the function. Starting with ECMAScript 5 these arguments can be a generic array-like object instead of an array. See below for {{anch("Browser_compatibility", "browser compatibility")}} information.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Wynik wywoływanej funkcji z określoną wartością <code>this</code> i argumentami.</p> + +<h2 id="Opis">Opis</h2> + +<p><span id="result_box" lang="pl"><span>Można</span> <span>przypisać inny</span> <span>obiekt</span> <code>this</code> <span>podczas wywoływania</span> <span>istniejącej</span> <span>funkcji.</span></span> <code>this</code> <span id="result_box" lang="pl"><span>odnosi się do</span> <span>bieżącego obiektu</span><span>,</span> <span>obiektu</span> <span>wywołującego. </span></span><span lang="pl"><span>Z</span> <span>apply</span><span> można</span> <span>napisać metodę</span> <span>raz, a następnie</span> <span>dziedziczyć</span> <span>ją</span> <span>w innym</span> <span>obiekcie,</span> <span>bez konieczności</span> <span>przepisywania</span> <span>metody</span> <span>dla nowego</span> <span>obiektu.</span></span></p> + +<p><code>apply</code> jest bardzo podobne do {{jsxref("Function.call", "call()")}}, <span class="short_text" id="result_box" lang="pl"><span>z wyjątkiem typu danych</span> <span>argumentów</span><span>, które wspiera</span><span>. </span></span><span id="result_box" lang="pl"><span>Można</span> <span>używać tablicy</span> <span>argumentów</span> <span>zamiast</span> <span>zestawu argumentów (parametrów</span><span>).</span></span> Z metodą <code>apply</code>, możesz używać tablic w sensie dosłownym, na przykład <code><em>fun</em>c.apply(this, ['eat', 'bananas'])</code>, lub obiektów typu {{jsxref("Array")}}, na przykład, <code><em>func</em>.apply(this, new Array('eat', 'bananas'))</code>.</p> + +<p>Można używać również {{jsxref("Funkcje/arguments", "arguments")}} dla parametru <code>argsArray</code>. <code>arguments</code> jest zmienną lokalną dostępną wewnątrz każdej funkcji. Można to zastosować<span id="result_box" lang="pl"><span> do wszystkich</span> <span>nieokreślonych</span> <span>argumentów</span> wywoływanego <span>obiektu</span><span>.</span></span> <span id="result_box" lang="pl"><span>Tak więc</span> <span>nie trzeba</span> <span>znać</span> <span>argumentów</span> <span>wywoływanego obiektu</span> <span>przy</span> <span>użyciu</span> <span>metody</span> <span><code>apply</code>. </span></span> Możesz użyć <code>arguments</code>, aby <span class="short_text" id="result_box" lang="pl"><span>przekazać</span> <span>wszystkie argumenty do wywoływanego obiektu. </span></span><span id="result_box" lang="pl"><span>Wywołany</span> <span>obiekt</span> <span>jest</span> <span>odpowiedzialny za obsługę</span> <span>otrzymanych argumentów</span><span>.</span></span></p> + +<p><span lang="pl"><span>Od </span></span>ECMAScript 5th Edition możliwe jest również używanie wszelkiego rodzaju obiektów „tablicopodobnych” (array-like), co w praktyce oznacza, że obiekt taki musi mieć własność <code>length</code> i całkowite własności (indeksy) w zakresie <code>(0..length-1)</code>. Przykładowo możesz użyć {{domxref("NodeList")}} lub własnego oiektu jak np. <code>{ 'length': 2, '0': 'eat', '1': 'bananas' }</code>.</p> + +<div class="note"> +<p>Większość przeglądarek, w tym Chrome 14 i Internet Explorer 9, w dalszym ciągu nie akceptuje obiektów tablicopodobnych i będzie wyrzucać wyjątek.</p> +</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_apply_do_dodania_tablicy_do_innej_tablicy">Użycie <code>apply</code> do dodania tablicy do innej tablicy</h3> + +<p>Możemy użyć metody <code>push</code> do dodania elementu do tablicy. I, jako że <code>push</code> przyjmuje zmienną liczbę argumentów, możemy również dodać wiele elementów naraz – ale jeśli faktycznie przekażemy tablicę do funkcji <code>push</code>, wówczas rzeczywiście doda ona tablicę jako pojedynczy element, zamiast dodać jej elementy, więc skończymy z tablicą wewnątrz tablicy. Co jeśli to nie jest to, co chcieliśmy osiągnąć? <code>concat</code> ma zachowanie takie, jakiego oczekiwalibyśmy w tym przypadku, jednak funkcja ta nie dodaje w rzeczywistości tablicy do istniejącej tablicy, ale tworzy i zwraca nową. Ale chcieliśmy zmodyfikować naszą istniejącą tablicę… Więc co teraz? Napisać pętlę? No chyba nie?</p> + +<p><code>apply</code> przychodzi na ratunek!</p> + +<pre class="brush: js">var array = ['a', 'b']; +var elements = [0, 1, 2]; +array.push.apply(array, elements); +console.info(array); // ["a", "b", 0, 1, 2] +</pre> + +<p> </p> + +<h3 id="Using_apply_and_built-in_functions">Using <code>apply</code> and built-in functions</h3> + +<p> </p> + +<p>Clever usage of <code>apply</code> allows you to use built-ins functions for some tasks, that otherwise probably would have been written by looping over the array values. As an example here we are going to use <code>Math.max</code>/<code>Math.min</code>, to find out the maximum/minimum value in an array.</p> + +<pre class="brush: js">// min/max number in an array +var numbers = [5, 6, 2, 3, 7]; + +// using Math.min/Math.max apply +var max = Math.max.apply(null, numbers); +// This about equal to Math.max(numbers[0], ...) +// or Math.max(5, 6, ...) + +var min = Math.min.apply(null, numbers); + +// vs. simple loop based algorithm +max = -Infinity, min = +Infinity; + +for (var i = 0; i < numbers.length; i++) { + if (numbers[i] > max) { + max = numbers[i]; + } + if (numbers[i] < min) { + min = numbers[i]; + } +} +</pre> + +<p>But beware: in using <code>apply</code> this way, you run the risk of exceeding the JavaScript engine's argument length limit. The consequences of applying a function with too many arguments (think more than tens of thousands of arguments) vary across engines (JavaScriptCore has hard-coded <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=80797">argument limit of 65536</a>), because the limit (indeed even the nature of any excessively-large-stack behavior) is unspecified. Some engines will throw an exception. More perniciously, others will arbitrarily limit the number of arguments actually passed to the applied function. To illustrate this latter case: if such an engine had a limit of four arguments (actual limits are of course significantly higher), it would be as if the arguments <code>5, 6, 2, 3</code> had been passed to <code>apply</code> in the examples above, rather than the full array.</p> + +<p>If your value array might grow into the tens of thousands, use a hybrid strategy: apply your function to chunks of the array at a time:</p> + +<pre class="brush: js">function minOfArray(arr) { + var min = Infinity; + var QUANTUM = 32768; + + for (var i = 0, len = arr.length; i < len; i += QUANTUM) { + var submin = Math.min.apply(null, + arr.slice(i, Math.min(i+QUANTUM, len))); + min = Math.min(submin, min); + } + + return min; +} + +var min = minOfArray([5, 6, 2, 3, 7]); +</pre> + +<p> </p> + +<h3 id="Using_apply_to_chain_constructors">Using <code>apply</code> to chain constructors</h3> + +<p> </p> + +<p>You can use <code>apply</code> to chain {{jsxref("Operators/new", "constructors", "", 1)}} for an object, similar to Java. In the following example we will create a global {{jsxref("Function")}} method called <code>construct</code>, which will enable you to use an array-like object with a constructor instead of an arguments list.</p> + +<pre class="brush: js">Function.prototype.construct = function(aArgs) { + var oNew = Object.create(this.prototype); + this.apply(oNew, aArgs); + return oNew; +}; +</pre> + +<div class="note" style="height: 250px; overflow: auto;"> +<p><strong>Note:</strong> The <code>Object.create()</code> method used above is relatively new. For alternative methods, please consider one of the following approaches:</p> + +<p>Using {{jsxref("Object/__proto__", "Object.__proto__")}}:</p> + +<pre class="brush: js">Function.prototype.construct = function (aArgs) { + var oNew = {}; + oNew.__proto__ = this.prototype; + this.apply(oNew, aArgs); + return oNew; +}; +</pre> + +<p>Using <a href="/en-US/docs/Web/JavaScript/Closures">closures</a>:</p> + +<pre class="brush: js">Function.prototype.construct = function(aArgs) { + var fConstructor = this, fNewConstr = function() { + fConstructor.apply(this, aArgs); + }; + fNewConstr.prototype = fConstructor.prototype; + return new fNewConstr(); +};</pre> + +<p>Using the {{jsxref("Function")}} constructor:</p> + +<pre class="brush: js">Function.prototype.construct = function (aArgs) { + var fNewConstr = new Function(""); + fNewConstr.prototype = this.prototype; + var oNew = new fNewConstr(); + this.apply(oNew, aArgs); + return oNew; +}; +</pre> +</div> + +<p>Example usage:</p> + +<pre class="brush: js">function MyConstructor() { + for (var nProp = 0; nProp < arguments.length; nProp++) { + this['property' + nProp] = arguments[nProp]; + } +} + +var myArray = [4, 'Hello world!', false]; +var myInstance = MyConstructor.construct(myArray); + +console.log(myInstance.property1); // logs 'Hello world!' +console.log(myInstance instanceof MyConstructor); // logs 'true' +console.log(myInstance.constructor); // logs 'MyConstructor' +</pre> + +<div class="note"> +<p><strong>Note:</strong> This non-native <code>Function.construct</code> method will not work with some native constructors; like {{jsxref("Date")}}, for example. In these cases you have to use the {{jsxref("Function.prototype.bind")}} method. For example, imagine having an array like the following, to be used with {{jsxref("Global_Objects/Date", "Date")}} constructor: <code>[2012, 11, 4]</code>; in this case you have to write something like: <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()</code>. This is not the best way to do things, and probably not to be used in any production environment.</p> +</div> + +<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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</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> + <tr> + <td>ES 5.1 generic array-like object as {{jsxref("Functions/arguments", "arguments")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</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> + <tr> + <td>ES 5.1 generic array-like object as {{jsxref("Functions/arguments", "arguments")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("2.0")}}</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("Functions/arguments", "arguments")}} object</li> + <li>{{jsxref("Function.prototype.bind()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions", "Functions and function scope", "", 1)}}</li> + <li>{{jsxref("Reflect.apply()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/function/arguments/index.html b/files/pl/web/javascript/reference/global_objects/function/arguments/index.html new file mode 100644 index 0000000000..2730721c86 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/function/arguments/index.html @@ -0,0 +1,42 @@ +--- +title: Function.arguments +slug: Web/JavaScript/Reference/Global_Objects/Function/arguments +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments +original_slug: Web/JavaScript/Referencje/Obiekty/Function/arguments +--- +<p>{{JSRef}}{{ Deprecated_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Obiekt tablicopodobny odpowiadający argumentom przekazywanym funkcji.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Należy użyć obiektu <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments">arguments</a></code> dostępnego wewnątrz funkcji zamiast <code>Function.arguments</code>.</p> + +<p>W przypadku rekurencji, tzn. jeśli funkcja <code>f</code> pojawia się kilkakrotnie na stosie wywołania, wartość of <code>f.arguments</code> reprezentuje argumenty odpowiadające ostatniemu wywołaniu funkcji.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<pre class="brush: js">function f(n) { g(n-1) } + +function g(n) { + console.log("przed: " + g.arguments[0]); + if(n>0) { f(n); } + console.log("po: " + g.arguments[0]); +} +f(2); +</pre> + +<p>wyświetli:</p> + +<pre class="eval">przed: 1 +przed: 0 +po: 0 +po: 1 +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/function/bind/index.html b/files/pl/web/javascript/reference/global_objects/function/bind/index.html new file mode 100644 index 0000000000..804d686f1d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/function/bind/index.html @@ -0,0 +1,333 @@ +--- +title: Function.prototype.bind() +slug: Web/JavaScript/Reference/Global_Objects/Function/bind +translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind +original_slug: Web/JavaScript/Referencje/Obiekty/Function/bind +--- +<div>{{JSRef}}<br> +Metoda <span class="seoSummary"><code><strong>bind()</strong></code> </span> tworzy nową funkcję, której wywołanie powoduje ustawienie <strong>this</strong> na podaną wartość, z podaną sekwencją argumentów poprzedzającą dowolną podaną podczas wywołania nowej funkcji.<br> + </div> + +<div>{{EmbedInteractiveExample („pages / js / function-bind.html”, „taller”)}}<br> +Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do projektu interaktywnych przykładów, sklonuj https://github.com/mdn/interactive-examples i wyślij nam prośbę o pobranie.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate">let boundFunc = <var>func</var>.bind(thisAtr[, <var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]]]) +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>thisAtr</var></code></dt> + <dd>Wartość, która ma być przekazana jako <strong>this</strong> do funkcji docelowej func po wywołaniu funkcji powiązanej. Wartość jest ignorowana, jeśli funkcja powiązana jest konstruowana przy użyciu operatora {{jsxref („Operators / new”, „new”)}}. Podczas używania funkcji <strong>bind</strong> do utworzenia funkcji (dostarczonej jako wywołanie zwrotne) wewnątrz setTimeout, każda prymitywna wartość przekazywana, gdy <strong>thisAtr</strong> jest konwertowany na obiekt. Jeśli nie podano żadnych argumentów, aby powiązać (bind), lub jeśli thisArg jest <strong>null</strong> lub <strong>undefined</strong>, <strong>this</strong> z zakresu wykonania jest traktowany jako <strong>thisAtr</strong> dla nowej funkcji.</dd> + <dt><code><var>arg1</var>, <var>arg2</var>, ...<var>argN</var></code> {{optional_inline}}</dt> + <dd>Argumenty poprzedzające argumenty dostarczone funkcji powiązanej podczas wywoływania func.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Kopia podanej funkcji z podaną tą wartością i początkowymi argumentami (jeśli podano).</p> + +<h2 id="Opis">Opis</h2> + +<p>Funkcja <strong>bind</strong>() tworzy nową funkcję wiązania (bound function), która jest exotic function object (termin z ECMAScript 2015), który zawija oryginalny obiekt funkcji. Wywołanie funkcji powiązanej zazwyczaj skutkuje wykonaniem jej owrapowanej funkcji.</p> + +<p>Funckja wiązania <strong>(bound function)</strong> ma następujące właściwości wewnętrzne:</p> + +<dl> + <dt><strong><code>[[BoundTargetFunction]]</code> </strong></dt> + <dd>The wrapped function object</dd> + <dt><code><strong>[[BoundThis]]</strong></code></dt> + <dd>The value that is always passed as <code>this</code> value when calling the wrapped function.</dd> + <dt><code><strong>[[BoundArguments]]</strong></code></dt> + <dd>A list of values whose elements are used as the first arguments to any call to the wrapped function.</dd> + <dt><code><strong>[[Call]]</strong></code></dt> + <dd>Executes code associated with this object. Invoked via a function call expression. The arguments to the internal method are a <code>this</code> value and a list containing the arguments passed to the function by a call expression.</dd> +</dl> + +<p>When a bound function is called, it calls internal method <code>[[Call]]</code> on <code>[[BoundTargetFunction]]</code>, with following arguments <code>Call(<var>boundThis</var>, ...<var>args</var>)</code>. Where <code><var>boundThis</var></code> is <code>[[BoundThis]]</code>, <code><var>args</var></code> is <code>[[BoundArguments]]</code>, followed by the arguments passed by the function call.</p> + +<p>A bound function may also be constructed using the {{jsxref("Operators/new", "new")}} operator. Doing so acts as though the target function had instead been constructed. The provided <code>this</code> value is ignored, while prepended arguments are provided to the emulated function.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Creating_a_bound_function">Creating a bound function</h3> + +<p>The simplest use of <code>bind()</code> is to make a function that, no matter how it is called, is called with a particular <code>this</code> value.</p> + +<p>A common mistake for new JavaScript programmers is to extract a method from an object, then to later call that function and expect it to use the original object as its <code>this</code> (e.g., by using the method in callback-based code).</p> + +<p>Without special care, however, the original object is usually lost. Creating a bound function from the function, using the original object, neatly solves this problem:</p> + +<pre class="brush: js notranslate">this.x = 9; // 'this' refers to global 'window' object here in a browser +const module = { + x: 81, + getX: function() { return this.x; } +}; + +module.getX(); +// returns 81 + +const retrieveX = module.getX; +retrieveX(); +// returns 9; the function gets invoked at the global scope + +// Create a new function with 'this' bound to module +// New programmers might confuse the +// global variable 'x' with module's property 'x' +const boundGetX = retrieveX.bind(module); +boundGetX(); +// returns 81 +</pre> + +<p><strong>Funkcje częściowo zastosowane</strong><br> + Kolejnym najprostszym zastosowaniem bind () jest utworzenie funkcji z wcześniej określonymi argumentami początkowymi.</p> + +<p>Argumenty te (jeśli występują) są zgodne z podaną wartością, a następnie są wstawiane na początku argumentów przekazywanych do funkcji docelowej, a następnie wszelkie argumenty przekazywane funkcja powiązana w momencie jej wywołania.</p> + +<pre class="brush: js notranslate">function list() { + return Array.prototype.slice.call(arguments); +} + +function addArguments(arg1, arg2) { + return arg1 + arg2 +} + +const list1 = list(1, 2, 3); +// [1, 2, 3] + +const result1 = addArguments(1, 2); +// 3 + +// Create a function with a preset leading argument +const leadingThirtysevenList = list.bind(null, 37); + +// Create a function with a preset first argument. +const addThirtySeven = addArguments.bind(null, 37); + +const list2 = leadingThirtysevenList(); +// [37] + +const list3 = leadingThirtysevenList(1, 2, 3); +// [37, 1, 2, 3] + +const result2 = addThirtySeven(5); +// 37 + 5 = 42 + +const result3 = addThirtySeven(5, 10); +// 37 + 5 = 42 +// (the second argument is ignored) + + +</pre> + +<h3 id="With_setTimeout">With <code>setTimeout()</code></h3> + +<p>By default within <a href="/en-US/docs/Web/API/Window/setTimeout" title="REDIRECT WindowTimers.setTimeout"><code>window.setTimeout()</code></a>, the <code>this</code> keyword will be set to the <a href="/en-US/docs/Web/API/Window" title="The Window interface represents a window containing a DOM document; the document property points to the DOM document loaded in that window."><code>window</code></a> (or <code>global</code>) object. When working with class methods that require <code>this</code> to refer to class instances, you may explicitly bind <code>this</code> to the callback function, in order to maintain the instance.</p> + +<pre class="brush: js notranslate">function LateBloomer() { + this.petalCount = Math.floor(Math.random() * 12) + 1; +} + +// Declare bloom after a delay of 1 second +LateBloomer.prototype.bloom = function() { + window.setTimeout(this.declare.bind(this), 1000); +}; + +LateBloomer.prototype.declare = function() { + console.log(`I am a beautiful flower with ${this.petalCount} petals!`); +}; + +const flower = new LateBloomer(); +flower.bloom(); +// after 1 second, calls 'flower.declare()' +</pre> + +<h3 id="Funkcje_powiązane_używane_jako_kostruktory">Funkcje powiązane używane jako kostruktory</h3> + +<div class="warning"> +<p>Ostrzeżenie: ta sekcja pokazuje możliwości JavaScript i dokumentuje niektóre przypadki krawędzi metody bind ().</p> + +<p>Metody przedstawione poniżej nie są najlepszym sposobem na robienie rzeczy i prawdopodobnie nie powinny być stosowane w żadnym środowisku produkcyjnym.</p> +</div> + +<p>Funkcje powiązane są automatycznie odpowiednie do użycia z operatorem {{jsxref („Operators / new”, „new”)}} do tworzenia nowych instancji utworzonych przez funkcję docelową. Gdy do utworzenia wartości używana jest funkcja powiązana, pod warunkiem, że jest to ignorowane.</p> + +<p>Jednak pod warunkiem, że argumenty są nadal dołączane do wywołania konstruktora:</p> + +<pre class="brush: js notranslate">function Point(x, y) { + this.x = x; + this.y = y; +} + +Point.prototype.toString = function() { + return `${this.x},${this.y}`; +}; + +const p = new Point(1, 2); +p.toString(); +// '1,2' + + +// not supported in the polyfill below, + +// works fine with native bind: + +const YAxisPoint = Point.bind(null, 0/*x*/); + + +const emptyObj = {}; +const YAxisPoint = Point.bind(emptyObj, 0/*x*/); + +const axisPoint = new YAxisPoint(5); +axisPoint.toString(); // '0,5' + +axisPoint instanceof Point; // true +axisPoint instanceof YAxisPoint; // true +new YAxisPoint(17, 42) instanceof Point; // true +</pre> + +<p>Zauważ, że nie musisz robić nic specjalnego, aby utworzyć powiązaną funkcję do użycia z {{jsxref („Operators / new”, „new”)}}.</p> + +<p>Następstwem jest to, że nie musisz robić nic specjalnego, aby utworzyć funkcję powiązaną, która będzie wywoływana w sposób jawny, nawet jeśli wolisz, aby funkcja powiązana była wywoływana tylko za pomocą {{jsxref („Operators / new”, „new”)}} .</p> + +<pre class="brush: js notranslate">// Example can be run directly in your JavaScript console +// ...continued from above + +// Can still be called as a normal function +// (although usually this is undesired) +YAxisPoint(13); + +`${emptyObj.x},${emptyObj.y}`; +// > '0,13' +</pre> + +<p>If you wish to support the use of a bound function only using {{jsxref("Operators/new", "new")}}, or only by calling it, the target function must enforce that restriction.</p> + +<h3 id="Tworzenie_skrótów">Tworzenie skrótów</h3> + +<p>bind () jest również pomocny w przypadkach, w których chcesz utworzyć skrót do funkcji, która wymaga podania tej wartości.</p> + +<p>Weźmy na przykład {{jsxref ("Array.prototype.slice ()")}}, którego chcesz użyć do konwersji obiektu podobnego do tablicy na prawdziwą tablicę. Możesz utworzyć taki skrót:</p> + +<pre class="brush: js notranslate">const slice = Array.prototype.slice; + +// ... + +slice.apply(arguments); +</pre> + +<p>Za pomocą bind () można to uprościć.</p> + +<p>W poniższym fragmencie kodu slice () jest funkcją powiązaną z funkcją {{jsxref („Function.prototype.apply ()”, „Apply ()”)}} z {{jsxref („Function.prototype”) }}, z tą wartością ustawioną na {{jsxref („Array.prototype.slice ()”, „slice ()”)}} funkcji {{jsxref („Array.prototype”)}}. Oznacza to, że dodatkowe wywołania apply () można wyeliminować:</p> + +<pre class="brush: js notranslate">// same as "slice" in the previous example +const unboundSlice = Array.prototype.slice; +const slice = Function.prototype.apply.bind(unboundSlice); + +// ... + +slice(arguments); +</pre> + +<p>Polyfill<br> + Ponieważ starsze przeglądarki są na ogół również wolniejszymi przeglądarkami, jest to o wiele bardziej krytyczne niż większość ludzi rozpoznaje tworzenie polifillów wydajności, aby przeglądanie w przestarzałych przeglądarkach było nieco mniej straszne.</p> + +<p>W związku z tym poniżej przedstawiono dwie opcje dla funkcji wypełniania funkcji Function.prototype.bind ():</p> + +<p>Pierwszy jest znacznie mniejszy i bardziej wydajny, ale nie działa, gdy używasz nowego operatora.<br> + Drugi jest większy i mniej wydajny, ale pozwala na pewne użycie nowego operatora na powiązanych funkcjach.<br> + Zasadniczo w większości kodów bardzo rzadko widuje się nowe używane w funkcji powiązanej, więc najlepiej jest wybrać pierwszą opcję.</p> + +<pre class="brush: js notranslate">// Does not work with `new funcA.bind(thisArg, args)` +if (!Function.prototype.bind) (function(){ + var slice = Array.prototype.slice; + Function.prototype.bind = function() { + var thatFunc = this, thatArg = arguments[0]; + var args = slice.call(arguments, 1); + if (typeof thatFunc !== 'function') { + // closest thing possible to the ECMAScript 5 + // internal IsCallable function + throw new TypeError('Function.prototype.bind - ' + + 'what is trying to be bound is not callable'); + } + return function(){ + var funcArgs = args.concat(slice.call(arguments)) + return thatFunc.apply(thatArg, funcArgs); + }; + }; +})();</pre> + +<p>Możesz częściowo obejść ten problem, wstawiając następujący kod na początku skryptów, umożliwiając korzystanie z większości funkcji bind () w implementacjach, które nie obsługują go natywnie.</p> + +<pre class="brush: js notranslate">// Yes, it does work with `new funcA.bind(thisArg, args)` +if (!Function.prototype.bind) (function(){ + var ArrayPrototypeSlice = Array.prototype.slice; + Function.prototype.bind = function(otherThis) { + if (typeof this !== 'function') { + // closest thing possible to the ECMAScript 5 + // internal IsCallable function + throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable'); + } + + var baseArgs= ArrayPrototypeSlice .call(arguments, 1), + baseArgsLength = baseArgs.length, + fToBind = this, + fNOP = function() {}, + fBound = function() { + baseArgs.length = baseArgsLength; // reset to default base arguments + baseArgs.push.apply(baseArgs, arguments); + return fToBind.apply( + fNOP.prototype.isPrototypeOf(this) ? this : otherThis, baseArgs + ); + }; + + if (this.prototype) { + // Function.prototype doesn't have a prototype property + fNOP.prototype = this.prototype; + } + fBound.prototype = new fNOP(); + + return fBound; + }; +})(); +</pre> + +<p>Niektóre z wielu różnic (mogą być też inne, ponieważ ta lista nie próbuje być wyczerpująca) między tym algorytmem a określonym algorytmem to:</p> + +<p>Częściowa implementacja opiera się na {{jsxref ("Array.prototype.slice ()")}}, {{jsxref ("Array.prototype.concat ()")}}, {{jsxref ("Function.prototype.call ( ) ")}} i {{jsxref (" Function.prototype.apply () ")}}, wbudowane metody mające swoje oryginalne wartości.<br> + Częściowa implementacja tworzy funkcje, które nie mają niezmiennej „pigułki trucizny” {{jsxref („Function.caller”, „caller”)}} i właściwości argumentów, które wyrzucają {{jsxref („Global_Objects / TypeError”, „TypeError”) }} przy pobieraniu, ustawianiu lub usuwaniu. (Można to dodać, jeśli implementacja obsługuje {{jsxref („Object.defineProperty”)}} lub częściowo zaimplementowana [bez zachowania polegającego na rzucaniu przy usuwaniu], jeśli implementacja obsługuje {{jsxref („Object .__ zdefiniujGetter__”, „ __defineGetter__ ”)}} i {{jsxref („ Object .__ definiSetter__ ”,„ __defineSetter__ ”)}}).<br> + Częściowa implementacja tworzy funkcje, które mają właściwość prototypu. (Właściwie powiązane funkcje nie mają żadnych.)<br> + Częściowa implementacja tworzy powiązane funkcje, których właściwość {{jsxref („Function.length”, „length”)}}} nie zgadza się z właściwością nakazaną przez ECMA-262: tworzy funkcje o długości 0. Pełna implementacja - w zależności od długość funkcji docelowej i liczba wcześniej określonych argumentów - może zwrócić niezerową długość.<br> + Częściowa implementacja tworzy powiązane funkcje, których właściwość {{jsxref („Function.name”, „name”)}} nie jest pochodną oryginalnej nazwy funkcji. Według ECMA-262 nazwa zwróconej funkcji powiązanej powinna być „związana” + nazwa funkcji docelowej.<br> + Jeśli zdecydujesz się użyć tej częściowej implementacji, nie możesz polegać na przypadkach, w których zachowanie odbiega od ECMA-262, wydanie 5! Na szczęście te odchylenia od specyfikacji rzadko (jeśli w ogóle) pojawiają się w większości sytuacji kodowania. Jeśli nie rozumiesz żadnego z odchyleń od powyższej specyfikacji, w tym konkretnym przypadku można bezpiecznie nie martwić się o te niezgodne szczegóły odchylenia.</p> + +<p>Jeśli jest to absolutnie konieczne, a wydajność nie stanowi problemu, znacznie wolniejsze (ale bardziej zgodne ze specyfikacją rozwiązanie) można znaleźć na stronie https://github.com/Raynos/function-bind.</p> + +<h2 id="Dane_techniczne">Dane techniczne</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td> + </tr> + </tbody> +</table> + +<h5 id="Kompatybilność_z_przeglądarkami_Tabela_zgodności_na_tej_stronie_jest_generowana_z_danych_strukturalnych._Jeśli_chcesz_przyczynić_się_do_danych_sprawdź_httpsgithub.commdnbrowser-compat-data_i_wyślij_nam_żądanie_ściągnięcia._Compat_javascript.builtins.Function.bind">Kompatybilność z przeglądarkami<br> + Tabela zgodności na tej stronie jest generowana z danych strukturalnych. Jeśli chcesz przyczynić się do danych, sprawdź https://github.com/mdn/browser-compat-data i wyślij nam żądanie ściągnięcia.<br> + {{Compat ("javascript.builtins.Function.bind")}}</h5> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Function.prototype.apply()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions", "Functions", "", 1)}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/function/caller/index.html b/files/pl/web/javascript/reference/global_objects/function/caller/index.html new file mode 100644 index 0000000000..c32102869a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/function/caller/index.html @@ -0,0 +1,70 @@ +--- +title: Function.caller +slug: Web/JavaScript/Reference/Global_Objects/Function/caller +tags: + - Function + - JavaScript + - Non-standard + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller +original_slug: Web/JavaScript/Referencje/Obiekty/Function/caller +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Określa funkcję, która powołuje się na aktualnie wykonywaną funkcje.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli funkcja <code>f</code> została wywołana przez kod najwyższego poziomu, własność <code>f.caller</code> ma wartość {{jsxref("null")}}, w przeciwnym przypadku jest to funkcja, która wywołała <code>f</code>.</p> + +<p>Ta własność zastąpiła wycofaną własność {{jsxref("arguments.caller")}}.</p> + +<h3 id="Notes" name="Notes">Notes</h3> + +<p>Note that in case of recursion, you can't reconstruct the call stack using this property. Consider:</p> + +<pre class="brush: js">function f(n) { g(n-1); } +function g(n) { if(n>0) { f(n); } else { stop(); } } +f(2); +</pre> + +<p>At the moment <code>stop()</code> is called the call stack will be:</p> + +<pre class="eval">f(2) -> g(1) -> f(1) -> g(0) -> stop() +</pre> + +<p>The following is true:</p> + +<pre class="eval">stop.caller === g && f.caller === g && g.caller === f +</pre> + +<p>so if you tried to get the stack trace in the <code>stop()</code> function like this:</p> + +<pre class="brush: js">var f = stop; +var stack = "Stack trace:"; +while (f) { + stack += "\n" + f.name; + f = f.caller; +} +</pre> + +<p>the loop would never stop.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Sprawdzenie_warto.C5.9Bci_w.C5.82asno.C5.9Bci_funkcji_caller" name="Przyk.C5.82ad:_Sprawdzenie_warto.C5.9Bci_w.C5.82asno.C5.9Bci_funkcji_caller">Przykład: Sprawdzenie wartości własności funkcji <code>caller</code></h3> + +<p>Następujący kod sprawdza wartość własności funkcji <code>caller</code>.</p> + +<pre class="brush: js">function myFunc() { + if (myFunc.caller == null) { + return ("The function was called from the top!"); + } else { + return ("This function's caller was " + myFunc.caller); + } +} +</pre> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/reference/global_objects/function/displayname/index.html b/files/pl/web/javascript/reference/global_objects/function/displayname/index.html new file mode 100644 index 0000000000..c9fe6b741a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/function/displayname/index.html @@ -0,0 +1,120 @@ +--- +title: Function.displayName +slug: Web/JavaScript/Reference/Global_Objects/Function/displayName +translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName +original_slug: Web/JavaScript/Referencje/Obiekty/Function/displayName +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Właściwość <code><strong><em>function</em>.displayName</strong></code> zwraca wyświetlaną nazwę funkcji.</p> + +<h2 id="Opis">Opis</h2> + +<p>Gdy jest zdefiniowana, wlaściwość <code>displayName</code> zwraca wyświetlaną nazwę funkcji:</p> + +<pre class="brush: js">function doSomething() {} + +console.log(doSomething.displayName); // "undefined" + +var popup = function(content) { console.log(content); }; + +popup.displayName = 'Pokaż Popup'; + +console.log(popup.displayName); // "Pokaż Popup" +</pre> + +<p>Możesz zdefiniować funkcję z wyświetlaną nazwą {{jsxref("Functions", "function expression", "", 1)}}:</p> + +<pre class="brush: js">var object = { + someMethod: function() {} +}; + +object.someMethod.displayName = 'jakaśMetoda'; + +console.log(object.someMethod.displayName); // logs "jakaśMetoda" + +try { someMethod } catch(e) { console.log(e); } +// ReferenceError: jakaśMetoda is not defined +</pre> + +<p>Możesz dynamicznie zmieniać <code>displayName </code>z funkcji:</p> + +<pre class="brush: js">var object = { + // anonymous + someMethod: function(value) { + this.displayName = 'jakaśMetoda (' + value + ')'; + } +}; + +console.log(object.someMethod.displayName); // "undefined" + +object.someMethod('123') +console.log(object.someMethod.displayName); // "jakaśMetoda (123)" +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Zazwyczaj preferowane jest przez konsole i profilery podczas {{jsxref("Function.name", "func.name")}} aby wyświetlić nazwę funkcji.</p> + +<p>Umieszczony w konsoli powinien wyświetlić coś w rodzaju "<code>function Moja Funkcja()</code>":</p> + +<pre class="brush: js">var a = function() {}; +a.displayName = '<code>Moja Funkcja</code>'; + +a; // "function <code>Moja Funkcja</code>()"</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<p>Nie jest częścią żadnej specyfikacji.</p> + +<h2 id="Zgodność_z_przeglądarką">Zgodność 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>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop(13)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</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> diff --git a/files/pl/web/javascript/reference/global_objects/function/index.html b/files/pl/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..5a9e96f266 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,238 @@ +--- +title: Function +slug: Web/JavaScript/Reference/Global_Objects/Function +tags: + - Function + - JavaScript + - Konstruktor +translation_of: Web/JavaScript/Reference/Global_Objects/Function +original_slug: Web/JavaScript/Referencje/Obiekty/Function +--- +<div>{{JSRef}}</div> + +<p><strong>Konstruktor</strong> <strong><code>Function</code> </strong>tworzy nowy obiekt Function(tworzy funkcję poprzez konstruktor). W JavaScripcie właściwie każda funkcja jest obiektem <code>Function</code>.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox"><code>new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Names to be used by the function as formal argument names. Each must be a string that corresponds to a valid JavaScript identifier or a list of such strings separated with a comma; for example "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd> + <dt><code>functionBody</code></dt> + <dd>A string containing the JavaScript statements comprising the function definition.</dd> +</dl> + +<h2 id="Description" name="Description">Opis</h2> + +<p><code>Function</code> objects created with the <code>Function</code> constructor are parsed when the function is created. This is less efficient than declaring a function with a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expression</a> or <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a> and calling it within your code, because such functions are parsed with the rest of the code.</p> + +<p>All arguments passed to the function are treated as the names of the identifiers of the parameters in the function to be created, in the order in which they are passed.</p> + +<div class="note"> +<p><strong>Note:</strong> Functions created with the <code>Function</code> constructor do not create closures to their creation contexts; they always are created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the <code>Function</code> constructor was called. This is different from using {{jsxref("Global_Objects/eval", "eval")}} with code for a function expression.</p> +</div> + +<p>Wywołanie konstruktora Function jako funkcję (bez użycia operatora 'new') ma taki sam efekt jak wywołanie konstruktora(z operatorem).</p> + +<h2 id="Właściwości_i_metody_Function">Właściwości i metody <code>Function</code></h2> + +<p>The global <code>Function</code> object has no methods or properties of its own, however, since it is a function itself it does inherit some methods and properties through the prototype chain from {{jsxref("Function.prototype")}}.</p> + +<h2 id="Function_prototype_object"><code>Function</code> prototype object</h2> + +<h3 id="Właściwości">Właściwości</h3> + +<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}</div> + +<h3 id="Methods" name="Methods">Metody</h3> + +<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}</div> + +<h2 id="Function_instances" name="Function_instances"><code>Function</code> instances</h2> + +<p><code>Function</code> instances inherit methods and properties from {{jsxref("Function.prototype")}}. As with all constructors, you can change the constructor's prototype object to make changes to all <code>Function</code> instances.</p> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<h3 id="Example.3A_Specifying_arguments_with_the_Function_constructor" name="Example.3A_Specifying_arguments_with_the_Function_constructor">Przykład: Specifying arguments with the <code>Function</code> constructor</h3> + +<p>Poniższy przykład tworzy obiekt Function(tworzy funkcję poprzez konstruktor), który przyjmuje dwa argumenty.</p> + +<pre class="brush: js">// Przykład może być uruchomiony bezpośrednio w konsoli JavaScript + +// Tworzy funkcję, która przyjmuje dwa argumenty i zwraca ich sumę +var adder = new Function('a', 'b', 'return a + b'); + +// Wywołanie funkcji +adder(2, 6); +// > 8 +</pre> + +<p>Argumenty "<code>a</code>" i "<code>b</code>" są formanie nazwami argumentrów, które są użyte w ciele funkcji, "<code>return a + b</code>".</p> + +<h3 id="Example:_A_recursive_shortcut_to_massively_modify_the_DOM" name="Example:_A_recursive_shortcut_to_massively_modify_the_DOM">Przykład: A recursive shortcut to massively modify the DOM</h3> + +<p>Creating functions with the <code>Function</code> constructor is one of the ways to dynamically create an indeterminate number of new objects with some executable code into the global scope from a function. The following example (a recursive shortcut to massively modify the DOM) is impossible without the invocation of the <code>Function</code> constructor for each new query if you want to avoid closures.</p> + +<pre class="brush: html language-html"><code class="language-html"><!doctype html> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>html</span><span class="punctuation token">></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>head</span><span class="punctuation token">></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>meta</span> <span class="attr-name token">http-equiv</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>Content-Type<span class="punctuation token">"</span></span> <span class="attr-name token">content</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>text/html; charset<span class="punctuation token">=</span>UTF-8<span class="punctuation token">"</span></span> <span class="punctuation token">/></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>title</span><span class="punctuation token">></span></span>MDN Example - a recursive shortcut to massively modify the DOM<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>title</span><span class="punctuation token">></span></span> +<span class="script token"><span class="tag token"><span class="tag token"><span class="punctuation token"><</span>script</span> <span class="attr-name token">type</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>text/javascript<span class="punctuation token">"</span></span><span class="punctuation token">></span></span> +<span class="keyword token">var</span> domQuery <span class="operator token">=</span> <span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> aDOMFunc <span class="operator token">=</span> <span class="punctuation token">[</span> + Element<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>removeAttribute<span class="punctuation token">,</span> + Element<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>setAttribute<span class="punctuation token">,</span> + CSSStyleDeclaration<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>removeProperty<span class="punctuation token">,</span> + CSSStyleDeclaration<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>setProperty + <span class="punctuation token">]</span><span class="punctuation token">;</span> + + <span class="keyword token">function</span> <span class="function token">setSomething<span class="punctuation token">(</span></span>bStyle<span class="punctuation token">,</span> sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> bSet <span class="operator token">=</span> <span class="function token">Boolean<span class="punctuation token">(</span></span>sVal<span class="punctuation token">)</span><span class="punctuation token">,</span> fAction <span class="operator token">=</span> aDOMFunc<span class="punctuation token">[</span>bSet <span class="operator token">|</span> bStyle <span class="operator token"><</span><span class="operator token"><</span> <span class="number token">1</span><span class="punctuation token">]</span><span class="punctuation token">,</span> + aArgs <span class="operator token">=</span> Array<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>slice<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span>arguments<span class="punctuation token">,</span> <span class="number token">1</span><span class="punctuation token">,</span> bSet <span class="operator token">?</span> <span class="number token">3</span> <span class="punctuation token">:</span> <span class="number token">2</span><span class="punctuation token">)</span><span class="punctuation token">,</span> + aNodeList <span class="operator token">=</span> bStyle <span class="operator token">?</span> <span class="keyword token">this</span><span class="punctuation token">.</span>cssNodes <span class="punctuation token">:</span> <span class="keyword token">this</span><span class="punctuation token">.</span>nodes<span class="punctuation token">;</span> + + <span class="keyword token">if</span> <span class="punctuation token">(</span>bSet <span class="operator token">&&</span> bStyle<span class="punctuation token">)</span> <span class="punctuation token">{</span> aArgs<span class="punctuation token">.</span><span class="function token">push<span class="punctuation token">(</span></span><span class="string token">''</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="punctuation token">}</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span> + <span class="keyword token">var</span> nItem <span class="operator token">=</span> <span class="number token">0</span><span class="punctuation token">,</span> nLen <span class="operator token">=</span> <span class="keyword token">this</span><span class="punctuation token">.</span>nodes<span class="punctuation token">.</span>length<span class="punctuation token">;</span> + nItem <span class="operator token"><</span> nLen<span class="punctuation token">;</span> + fAction<span class="punctuation token">.</span><span class="function token">apply<span class="punctuation token">(</span></span>aNodeList<span class="punctuation token">[</span>nItem<span class="operator token">++</span><span class="punctuation token">]</span><span class="punctuation token">,</span> aArgs<span class="punctuation token">)</span> + <span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">this</span><span class="punctuation token">.</span>follow <span class="operator token">=</span> setSomething<span class="punctuation token">.</span>caller<span class="punctuation token">;</span> + <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + + <span class="keyword token">function</span> <span class="function token">setStyles<span class="punctuation token">(</span></span>sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> setSomething<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span><span class="keyword token">this</span><span class="punctuation token">,</span> <span class="keyword token">true</span><span class="punctuation token">,</span> sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="punctuation token">}</span> + <span class="keyword token">function</span> <span class="function token">setAttribs<span class="punctuation token">(</span></span>sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> setSomething<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span><span class="keyword token">this</span><span class="punctuation token">,</span> <span class="keyword token">false</span><span class="punctuation token">,</span> sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="punctuation token">}</span> + <span class="keyword token">function</span> <span class="function token">getSelectors<span class="punctuation token">(</span></span><span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">.</span>selectors<span class="punctuation token">;</span> <span class="punctuation token">}</span><span class="punctuation token">;</span> + <span class="keyword token">function</span> <span class="function token">getNodes<span class="punctuation token">(</span></span><span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">.</span>nodes<span class="punctuation token">;</span> <span class="punctuation token">}</span><span class="punctuation token">;</span> + + <span class="keyword token">return</span> <span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span>sSelectors<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> oQuery <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Function</span><span class="punctuation token">(</span><span class="string token">'return arguments.callee.follow.apply(arguments.callee, arguments);'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>selectors <span class="operator token">=</span> sSelectors<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>nodes <span class="operator token">=</span> document<span class="punctuation token">.</span><span class="function token">querySelectorAll<span class="punctuation token">(</span></span>sSelectors<span class="punctuation token">)</span><span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>cssNodes <span class="operator token">=</span> Array<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>map<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span>oQuery<span class="punctuation token">.</span>nodes<span class="punctuation token">,</span> <span class="keyword token">function</span><span class="punctuation token">(</span>oInlineCSS<span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> oInlineCSS<span class="punctuation token">.</span>style<span class="punctuation token">;</span> <span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>attributes <span class="operator token">=</span> setAttribs<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>inlineStyle <span class="operator token">=</span> setStyles<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>follow <span class="operator token">=</span> getNodes<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>toString <span class="operator token">=</span> getSelectors<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>valueOf <span class="operator token">=</span> getNodes<span class="punctuation token">;</span> + <span class="keyword token">return</span> oQuery<span class="punctuation token">;</span> + <span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>script</span><span class="punctuation token">></span></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>head</span><span class="punctuation token">></span></span> + +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>body</span><span class="punctuation token">></span></span> + +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>div</span> <span class="attr-name token">class</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>testClass<span class="punctuation token">"</span></span><span class="punctuation token">></span></span>Lorem ipsum<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>div</span><span class="punctuation token">></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>p</span><span class="punctuation token">></span></span>Some text<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>p</span><span class="punctuation token">></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>div</span> <span class="attr-name token">class</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>testClass<span class="punctuation token">"</span></span><span class="punctuation token">></span></span>dolor sit amet<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>div</span><span class="punctuation token">></span></span> + +<span class="script token"><span class="tag token"><span class="tag token"><span class="punctuation token"><</span>script</span> <span class="attr-name token">type</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>text/javascript<span class="punctuation token">"</span></span><span class="punctuation token">></span></span> +<span class="function token">domQuery<span class="punctuation token">(</span></span><span class="string token">'.testClass'</span><span class="punctuation token">)</span> + <span class="punctuation token">.</span><span class="function token">attributes<span class="punctuation token">(</span></span><span class="string token">'lang'</span><span class="punctuation token">,</span> <span class="string token">'en'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'title'</span><span class="punctuation token">,</span> <span class="string token">'Risus abundat in ore stultorum'</span><span class="punctuation token">)</span> + <span class="punctuation token">.</span><span class="function token">inlineStyle<span class="punctuation token">(</span></span><span class="string token">'background-color'</span><span class="punctuation token">,</span> <span class="string token">'black'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'color'</span><span class="punctuation token">,</span> <span class="string token">'white'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'width'</span><span class="punctuation token">,</span> <span class="string token">'100px'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'height'</span><span class="punctuation token">,</span> <span class="string token">'50px'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>script</span><span class="punctuation token">></span></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>body</span><span class="punctuation token">></span></span> + +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>html</span><span class="punctuation token">></span></span></code></pre> + +<p> </p> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<p> </p> + +<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 1st Edition.</td> + <td>Standard</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</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="See_also" name="See_also">Zobacz również</h2> + +<ul> + <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Statements/function*", "function* statement")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/function/length/index.html b/files/pl/web/javascript/reference/global_objects/function/length/index.html new file mode 100644 index 0000000000..df26b64675 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/function/length/index.html @@ -0,0 +1,43 @@ +--- +title: Function.length +slug: Web/JavaScript/Reference/Global_Objects/Function/length +tags: + - Function + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/length +original_slug: Web/JavaScript/Referencje/Obiekty/Function/length +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Określa liczbę argumentów oczekiwanych przez funkcję.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt <code>length</code> znajduje się na zewnątrz funkcji i określa jak wiele argumentów ma oczekiwać funkcja, i.e. liczbę oficjalnych parametrów. W przeciwieństwie do obiektu {{jsxref("arguments.length")}}, który znajduje się wewnątrz funkcji, określa liczbę argumentów faktycznie przekazywanych do funkcji.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length" name="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length">Przykład: Zastosowanie <code>Function.length</code> i <code>arguments.length</code></h3> + +<p>Następujący przykład pokazuje w jaki należy zastosować <code>Function.length</code> i <code>arguments.length</code>.</p> + +<pre class="brush: js">function addNumbers(x, y){ + if (arguments.length == addNumbers.length) { + return (x + y); + } + else + return 0; +} +</pre> + +<p>Jeśli podamy więcej niż dwa argumenty do tej funkcji, funkcja zwróci 0:</p> + +<pre class="eval">addNumbers(3,4,5) // zwraca 0 +addNumbers(3,4) // zwraca 7 +addNumbers(103,104) // zwraca 207 +</pre> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/reference/global_objects/function/tostring/index.html b/files/pl/web/javascript/reference/global_objects/function/tostring/index.html new file mode 100644 index 0000000000..675f65c662 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/function/tostring/index.html @@ -0,0 +1,57 @@ +--- +title: Function.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Function/toString +tags: + - Function + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString +original_slug: Web/JavaScript/Referencje/Obiekty/Function/toString +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy funkcji.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code><var>function</var>.toString(indentation)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>indentation</code> {{non-standard_inline}} {{obsolete_inline(17)}}</dt> + <dd>The amount of spaces to indent the string representation of the source code. If <code>indentation</code> is less than or equal to <code>-1</code>, most unnecessary spaces are removed.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Function")}} przesłania metodę {{jsxref("Object.prototype.toString", "toString")}} obiektu {{jsxref("Function")}}; nie dziedziczy {{jsxref("Object.prototype.toString")}}. Dla obiektów <code>Function</code>, metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt.</p> + +<p>JavaScript wywołuje metodę <code>toString()</code> automatycznie, gdy {{jsxref("Function")}} jest reprezentowana jako wartość tekstowa lub kiedy <code>Function</code> jest odsyłana do połączenia łańcuchów znaków.</p> + +<p>Dla obiektów {{jsxref("Function")}}, wbudowana metoda <code>toString)=</code> dekompiluje funkcję z powrotem do kodu JavaScript, który tę funkcję definiuje. Łańcuch znaków zawiera słowa kluczowe <code>function</code>, listę argumentów, nawiasy klamrowe oraz ciało funkcji.</p> + +<p>Załóżmy na przykład, że masz poniższy kod, który definiuje obiektowy typ <code>Dog</code> i tworzy <code>theDog</code>, obiekt typu <code>Dog</code>:</p> + +<pre class="brush:js">function Dog(name, breed, color, sex) { + this.name = name + this.breed = breed + this.color = color + this.sex = sex +} + +theDog = new Dog( "Gabby", "Lab", "chocolate", "girl" ); +</pre> + +<p>W dowolnej chwili, gdy <code>Dog</code> jest użyty w kontekście jako łańcuch znaków, JavaScript automatycznie wywołuje funkcję <code>toString</code>, która zwraca poniższy łańcuch znaków:</p> + +<pre class="brush: js">function Dog(name, breed, color, sex) { this.name = name; this.breed = breed; this.color = color; this.sex = sex; }</pre> + +<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/generator/index.html b/files/pl/web/javascript/reference/global_objects/generator/index.html new file mode 100644 index 0000000000..a84467e7ca --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/generator/index.html @@ -0,0 +1,179 @@ +--- +title: Generator +slug: Web/JavaScript/Reference/Global_Objects/Generator +translation_of: Web/JavaScript/Reference/Global_Objects/Generator +original_slug: Web/JavaScript/Referencje/Obiekty/Generator +--- +<div>{{JSRef}}</div> + +<p>Obiekt <code><strong>Generator</strong></code> jest zwracany przez {{jsxref("Polecenia/function*", "generator function", "", 1)}} i odpowiada obu: <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable">iterable protocol</a> i <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator">iterator protocol</a>.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); // "Generator { }"</pre> + +<h2 id="Methods">Methods</h2> + +<dl> + <dt>{{jsxref("Generator.prototype.next()")}}</dt> + <dd>Returns a value yielded by the {{jsxref("Operators/yield", "yield")}} expression.</dd> + <dt>{{jsxref("Generator.prototype.return()")}}</dt> + <dd>Returns the given value and finishes the generator.</dd> + <dt>{{jsxref("Generator.prototype.throw()")}}</dt> + <dd>Throws an error to a generator.</dd> +</dl> + +<h2 id="Example">Example</h2> + +<h3 id="An_infinite_iterator">An infinite iterator</h3> + +<pre class="brush: js">function* idMaker() { + var index = 0; + while(true) + yield index++; +} + +var gen = idMaker(); // "Generator { }" + +console.log(gen.next().value); // 0 +console.log(gen.next().value); // 1 +console.log(gen.next().value); // 2 +// ...</pre> + +<h2 id="Legacy_generator_objects">Legacy generator objects</h2> + +<p>Firefox (SpiderMonkey) also implements an earlier version of generators in <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.7">JavaScript 1.7</a>, where the star (*) in the function declaration was not necessary (you just use the <code>yield</code> keyword in the function body). However, legacy generators are deprecated. Do not use them; they are going to be removed ({{bug(1083482)}}).</p> + +<h3 id="Legacy_generator_methods">Legacy generator methods</h3> + +<dl> + <dt><code>Generator.prototype.next() </code>{{non-standard_inline}}</dt> + <dd>Returns a value yielded by the {{jsxref("Operatory/yield", "yield")}} expression. This corresponds to <code>next()</code> in the ES2015 generator object.</dd> + <dt><code>Generator.prototype.close()</code> {{non-standard_inline}}</dt> + <dd>Closes the generator, so that when calling <code>next()</code> an {{jsxref("StopIteration")}} error will be thrown. This corresponds to the <code>return()</code> method in the ES2015 generator object.</dd> + <dt><code>Generator.prototype.send()</code> {{non-standard_inline}}</dt> + <dd>Used to send a value to a generator. The value is returned from the {{jsxref("Operatory/yield", "yield")}} expression, and returns a value yielded by the next {{jsxref("Operatory/yield", "yield")}} expression. <code>send(x)</code> corresponds to <code>next(x)</code> in the ES2015 generator object.</dd> + <dt><strong><code>Generator.</code></strong><code>prototype.</code><strong><code>throw()</code> </strong> {{non-standard_inline}}</dt> + <dd>Throws an error to a generator. This corresponds to the <code>throw()</code> method in the ES2015 generator object.</dd> +</dl> + +<h3 id="Legacy_generator_example">Legacy generator example</h3> + +<pre class="brush: js">function fibonacci() { + var a = yield 1; + yield a * 2; +} + +var it = fibonacci(); +console.log(it); // "Generator { }" +console.log(it.next()); // 1 +console.log(it.send(10)); // 20 +console.log(it.close()); // undefined +console.log(it.next()); // throws StopIteration (as the generator is now closed) +</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('ES2015', '#sec-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<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(39.0)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(39.0)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(39.0)}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<h3 id="Legacy_generators">Legacy generators</h3> + +<ul> + <li>{{jsxref("Statements/Legacy_generator_function", "The legacy generator function", "", 1)}}</li> + <li>{{jsxref("Operators/Legacy_generator_function", "The legacy generator function expression", "", 1)}}</li> + <li>{{jsxref("StopIteration")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features/The_legacy_Iterator_protocol">The legacy Iterator protocol</a></li> +</ul> + +<h3 id="ES2015_generators">ES2015 generators</h3> + +<ul> + <li>{{jsxref("Functions", "Functions", "", 1)}}</li> + <li>{{jsxref("Statements/function", "function")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function*", "function*")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/index.html b/files/pl/web/javascript/reference/global_objects/index.html new file mode 100644 index 0000000000..8d18c5e730 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/index.html @@ -0,0 +1,194 @@ +--- +title: Obiekty +slug: Web/JavaScript/Reference/Global_Objects +tags: + - Dokumentacja + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects +original_slug: Web/JavaScript/Referencje/Obiekty +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>W tym rozdziale opisano wszystkie standardowe obiekty wbudowane JavaScript, w tym ich metody i właściwości.</p> + +<p>Pojęcie "obiekty globalne" (lub standardowe obiekty wbudowane) tutaj nie są tym samym, co <strong>obiekt globalny</strong>, który odnosi się do <strong>obiektów o zasięgu globalnym</strong>. Dostęp do <strong>obiektu globalnego</strong> można uzyskać za pomocą operatoa {{jsxref("Operatory/this", "this")}} w zakresie globalnym (ale tylko, jeśli nie jest właczony tryb ścisły ECMAScript 5. W trybie ścisłym, w takim przypadku zostanie zwrócona wartość {{jsxref("undefined")}}). W rzeczywistości, zakres globalny <strong>składa się</strong> z własciwości obiektu globalnego, w tym właściwości dziedziczonych, jeśli istnieją.</p> + +<p>Innymi obiektami o zasięgu globalnym są <a href="/pl/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">obiekty tworzone w skryptach przez użytkowników</a> albo dostarczane przez aplikacje hosta. Obiekty hosta dostępne w kontekście przeglądarki są opisane w <a href="/pl/docs/Web/API/Reference">informatorze API</a>. Więcej informacji o różnicach dzielących <a href="/pl/docs/DOM/DOM_Reference">DOM</a> i rdzeń <a href="/pl/docs/Web/JavaScript">JavaScript</a>, znajdziesz we <a href="/pl/docs/Web/JavaScript/JavaScript_technologies_overview">Przeglądzie technologii JavaScript</a>.</p> + +<h2 id="Obiekty_standardowe_wg_kategorii">Obiekty standardowe wg kategorii</h2> + +<h3 id="Wartości">Wartości</h3> + +<p>Właściwości globalne zwracają proste wartości, które nie mają swoich własciwości ani metod</p> + +<ul> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("NaN")}}</li> + <li>{{jsxref("undefined")}}</li> + <li>literał {{jsxref("null")}}</li> +</ul> + +<h3 id="Funkcje">Funkcje</h3> + +<p>Należą tu funkcje globalne (wywoływane globalnie a nie w jakimś obiekcie), które zwracają swoją wartość bezpośredni do wywołania.</p> + +<ul> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> + <li>{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline}}</li> + <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> + <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li> + <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> + <li>{{jsxref("Global_Objects/decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent()")}}</li> + <li>{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}</li> + <li>{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline}}</li> + <li>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline}}</li> +</ul> + +<h3 id="Obiekty_podstawowe">Obiekty podstawowe</h3> + +<p>Są to fundamentalne, podstawowe obiekty, stanowiące podstawę do tworzenia innych obiektów. Obejmuje to obiekty reprezentujace obiekty ogólne, funkcje i błędy.</p> + +<ul> + <li>{{jsxref("Object")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Boolean")}}</li> + <li>{{jsxref("Symbol")}}</li> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("EvalError")}}</li> + <li>{{jsxref("InternalError")}}</li> + <li>{{jsxref("RangeError")}}</li> + <li>{{jsxref("ReferenceError")}}</li> + <li>{{jsxref("SyntaxError")}}</li> + <li>{{jsxref("TypeError")}}</li> + <li>{{jsxref("URIError")}}</li> +</ul> + +<h3 id="Liczby_i_daty">Liczby i daty</h3> + +<p>Są to obiekty podstawowe reprezentujace liczby, daty i obliczenia matematyczne.</p> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("Math")}}</li> + <li>{{jsxref("Date")}}</li> +</ul> + +<h3 id="Przetwarzanie_tekstu">Przetwarzanie tekstu</h3> + +<p>Kategorie te tworzą obiekty reprezentujące łańcuchy i obsługujace manipulowanie łańcuchami.</p> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("RegExp")}}</li> +</ul> + +<h3 id="Indeksowane_kolekcje">Indeksowane kolekcje</h3> + +<p>Obiekty te reprezentują kolekcje danych, ktore są uporządkowane według wartości indeksu. Opejmuje to tablice, typowane tablice i konstrukcje podobne do tablic.</p> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Int8Array")}}</li> + <li>{{jsxref("Uint8Array")}}</li> + <li>{{jsxref("Uint8ClampedArray")}}</li> + <li>{{jsxref("Int16Array")}}</li> + <li>{{jsxref("Uint16Array")}}</li> + <li>{{jsxref("Int32Array")}}</li> + <li>{{jsxref("Uint32Array")}}</li> + <li>{{jsxref("Float32Array")}}</li> + <li>{{jsxref("Float64Array")}}</li> +</ul> + +<h3 id="Kolekcje_z_kluczami">Kolekcje z kluczami</h3> + +<p>Są to obiekty reprezentujące kolekcje stosujace klucze. Zawierają elementy, które są iterowalne w kolejności estawiania.</p> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> + +<h3 id="Kolekcje_wektorowe">Kolekcje wektorowe</h3> + +<p>Typy danych wektorowych {{Glossary("SIMD")}} są obiektami, w których dane formowane są w potoki.</p> + +<ul> + <li>{{jsxref("SIMD")}} {{experimental_inline}}</li> + <li>{{jsxref("Float32x4", "SIMD.Float32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Float64x2", "SIMD.Float64x2")}} {{experimental_inline}}</li> + <li>{{jsxref("Int8x16", "SIMD.Int8x16")}} {{experimental_inline}}</li> + <li>{{jsxref("Int16x8", "SIMD.Int16x8")}} {{experimental_inline}}</li> + <li>{{jsxref("Int32x4", "SIMD.Int32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Uint8x16", "SIMD.Uint8x16")}} {{experimental_inline}}</li> + <li>{{jsxref("Uint16x8", "SIMD.Uint16x8")}} {{experimental_inline}}</li> + <li>{{jsxref("Uint32x4", "SIMD.Uint32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool8x16", "SIMD.Bool8x16")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool16x8", "SIMD.Bool16x8")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool32x4", "SIMD.Bool32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool64x2", "SIMD.Bool64x2")}} {{experimental_inline}}</li> +</ul> + +<h3 id="Dane_strukturalne">Dane strukturalne</h3> + +<p>Obiekty tej kategorii reprezentują i współdziałają ze strukturyzowanymi buforami danych i danymi kodowymi uzywającymi notacji JSON (JavaScript Object Notation).</p> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}} {{experimental_inline}}</li> + <li>{{jsxref("Atomics")}} {{experimental_inline}}</li> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("JSON")}}</li> +</ul> + +<h3 id="Kontrola_obiektów_abstrakcyjnych">Kontrola obiektów abstrakcyjnych</h3> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Generator")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li>{{experimental_inline}} {{jsxref("AsyncFunction")}}</li> +</ul> + +<h3 id="Refleksy">Refleksy</h3> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Proxy")}}</li> +</ul> + +<h3 id="Internacjonalizacja">Internacjonalizacja</h3> + +<p>Dodatki do jadra ECMAScript dla funkcji językowych.</p> + +<ul> + <li>{{jsxref("Intl")}}</li> + <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</li> +</ul> + +<h3 id="WebAssembly">WebAssembly</h3> + +<ul> + <li>{{jsxref("WebAssembly")}}</li> + <li>{{jsxref("WebAssembly.Module")}}</li> + <li>{{jsxref("WebAssembly.Instance")}}</li> + <li>{{jsxref("WebAssembly.Memory")}}</li> + <li>{{jsxref("WebAssembly.Table")}}</li> + <li>{{jsxref("WebAssembly.CompileError")}}</li> + <li>{{jsxref("WebAssembly.LinkError")}}</li> + <li>{{jsxref("WebAssembly.RuntimeError")}}</li> +</ul> + +<h3 id="Pozostałe">Pozostałe</h3> + +<ul> + <li><code><a href="/pl/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></code></li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/infinity/index.html b/files/pl/web/javascript/reference/global_objects/infinity/index.html new file mode 100644 index 0000000000..e20fe96052 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/infinity/index.html @@ -0,0 +1,36 @@ +--- +title: Infinity +slug: Web/JavaScript/Reference/Global_Objects/Infinity +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Infinity +original_slug: Web/JavaScript/Referencje/Obiekty/Infinity +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość numeryczna reprezentująca nieskończoność.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Infinity </code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>Infinity</code> jest własnością najwyższego rzędu i nie jest przypisana do żadnego obiektu.</p> + +<p>Początkową wartością <code>Infinity</code> jest {{jsxref("Number.POSITIVE_INFINITY")}}.</p> + +<p>Wartość <code>Infinity</code> (+nieskończoność) jest większa niż jakakolwiek liczba. Wartość ta ma wszystkie cechy matematycznej nieskończoności; np. cokolwiek pomnożone przez <code>Infinity</code> jest równe <code>Infinity</code>, a cokolwiek podzielone przez <code>Infinity</code> jest równe 0.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/isfinite/index.html b/files/pl/web/javascript/reference/global_objects/isfinite/index.html new file mode 100644 index 0000000000..9147ea7ad8 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/isfinite/index.html @@ -0,0 +1,57 @@ +--- +title: isFinite() +slug: Web/JavaScript/Reference/Global_Objects/isFinite +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/isFinite +original_slug: Web/JavaScript/Referencje/Obiekty/isFinite +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Przetwarza argument w celu stwierdzenia czy jest on liczbą skończoną.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox">isFinite(<em>liczba</em>)</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>liczba</code> </dt> + <dd>Liczba do przetworzenia.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>isFinite()</code> jest funkcją najwyższego poziomu, niepowiązaną z żadnym obiektem.</p> + +<p>Można użyć tej metody do określenia czy dana liczba jest skończona. Metoda <code>isFinite()</code> sprawdza liczbę podaną jako jej argument. Jeśli argument ma wartość {{jsxref("NaN")}} (nie jest liczbą), jest dodatnią lub ujemną nieskończonością, metoda ta zwraca <code>false</code>, w przeciwnym wypadku zwraca wartość <code>true</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<pre class="brush: js">isFinite(Infinity); // false +isFinite(NaN); // false +isFinite(-Infinity); // false + +isFinite(0); // true +isFinite(2e64); // true + + +isFinite("0"); // true, would've been false with the + // more robust Number.isFinite("0") +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Number.NaN()")}}</li> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/isnan/index.html b/files/pl/web/javascript/reference/global_objects/isnan/index.html new file mode 100644 index 0000000000..fa2ec80b5c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/isnan/index.html @@ -0,0 +1,54 @@ +--- +title: isNaN() +slug: Web/JavaScript/Reference/Global_Objects/isNaN +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/isNaN +original_slug: Web/JavaScript/Referencje/Obiekty/isNaN +--- +<p>{{jsSidebar("Objects")}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Sprawdza, czy argument nie ma wartości NaN ("nie-liczba").</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>isNaN(<em>testowanaWartość</em>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>testowanaWartość</code> </dt> + <dd>Wartość do sprawdzenia.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>isNaN</code> jest funkcją najwyższego rzędu i nie jest przypisana do żadnego obiektu.</p> + +<p>Funkcje <code>parseFloat</code> i <code>parseInt</code> zwracają <code>NaN</code>, kiedy wyliczą wartość, która nie jest liczbą. <code>isNaN</code> zwraca <code>true</code>, jeśli przekazano jej <code>NaN</code>, a <code>false</code> w przeciwnym wypadku.</p> + +<p>Funkcja ta jest o tyle przydatna, że wartości {{jsxref("NaN", "NaN")}} nie można skutecznie sprawdzać przy użyciu operatorów równości. <code>x == NaN</code> i <code>x === NaN</code> mają zawsze wartość <code>false</code>, bez względu na to, jaką wartość ma <code>x</code>, nawet jeśli <code>x</code> to <code>NaN</code>. Na przykład, zarówno <code>1 == NaN</code>, jak i <code>NaN == NaN</code> zwracają <code>false</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_isNaN" name="Przyk.C5.82ad:_Zastosowanie_isNaN">Przykład: Zastosowanie <code>isNaN</code></h3> + +<p>Poniższy przykład wylicza wartość <code>floatValue</code>, by sprawdzić, czy jest liczbą, a następnie wywołuje odpowiednią procedurę.</p> + +<pre class="brush: js">var floatValue = parseFloat(toFloat); + +if (isNaN(floatValue)) { + notFloat(); +} else { + isFloat(); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("NaN")}}</li> + <li>{{jsxref("Number.isNaN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/json/index.html b/files/pl/web/javascript/reference/global_objects/json/index.html new file mode 100644 index 0000000000..18d748958d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/json/index.html @@ -0,0 +1,148 @@ +--- +title: JSON +slug: Web/JavaScript/Reference/Global_Objects/JSON +tags: + - JSON + - JavaScript + - Obiekt +translation_of: Web/JavaScript/Reference/Global_Objects/JSON +original_slug: Web/JavaScript/Referencje/Obiekty/JSON +--- +<div>{{JSRef}}</div> + +<p>Obiekt <strong><code>JSON</code></strong> zawiera metody do analizy składniowej <a class="external" href="https://json.org/">JavaScript Object Notation</a> ({{glossary("JSON")}}) i konwertowania wartości do formatu JSON. Nie może być on wywołany lub utworzony i oprócz jego dwóch metod, sam w sobie nie ma interesującej funkcjonalności .</p> + +<h2 id="Różnice_między_językiem_JavaScript_i_formatem_JSON">Różnice między językiem JavaScript i formatem JSON</h2> + +<p>Format JSON jest składnią do serializowania obiektów, tablic, liczb, napisów, wartości logicznych oraz {{jsxref("null")}}. Bazuje na składni języka JavaScript, ale różni się od niego: <em>nie każdy</em> JavaScript to JSON.</p> + +<p><strong>Obiekty i tablice</strong>: Nazwy właściwości muszą znajdować się w podwójnym cudzysłowie; przecinki na końcach (<a href="https://wiki.developer.mozilla.org/pl/docs/Web/JavaScript/Reference/Trailing_commas">trailing commas</a>) nie są dozwolone.</p> + +<p><strong>Liczby</strong>: Zera nieznaczące są zakazane. Po przecinku musi się znaleźć co najmniej jedna liczba. Wartości NaN i Infinity nie są wspierane.</p> + +<p><strong>Każdy tekst w formacie JSON jest poprawnym wyrażeniem w języku JavaScript</strong> – ale wyłącznie w silnikach JavaScript, które mają zaimplementową możliwości, <a href="https://github.com/tc39/proposal-json-superset">by wszystkie dokumenty w formacie JSON były zgodne ze standardem ECMA-262</a>. W przeciwnym razie, znaki U+2028 (separator linii) i U+2029 (separator akapitów) są dozwolone w literałach znakowych i kluczach w formacie JSON, ale ich użycie w tym konteksie w języku JavaScript skutkuje zgłoszeniem błędu {{jsxref("SyntaxError")}}.</p> + +<p>Rozważmy przykład, gdzie funkcja {{jsxref("JSON.parse()")}} przetwarza poniższy literał znakowy jako obiekt JSON, a funkcja <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval">eval</a></code> wykonuje go jako tekst w języku JavaScript:</p> + +<pre class="brush: js">var code = '"\u2028\u2029"'; +JSON.parse(code); // działa poprawnie +eval(code); // zgłasza błąd SyntaxError +</pre> + +<p>Inne różnice to zgoda wyłącznie na literały znakowe w podwójnym cudzysłowie, brak zabezpieczenia dla {{jsxref("undefined")}} lub komentarzy.</p> + +<h2 id="Pełna_składnia_JSON">Pełna składnia JSON</h2> + +<p>Pełna składnia JSON jest następująca:</p> + +<pre class="syntaxbox"><var>JSON</var> = <strong>null</strong> + <em>or</em> <strong>true</strong> <em>or</em> <strong>false</strong> + <em>or</em> <var>JSONNumber</var> + <em>or</em> <var>JSONString</var> + <em>or</em> <var>JSONObject</var> + <em>or</em> <var>JSONArray</var> + +<var>JSONNumber</var> = <strong>-</strong> <var>PositiveNumber</var> + <em>or</em> <var>PositiveNumber</var> +<var>PositiveNumber</var> = DecimalNumber + <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> + <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> <var>ExponentPart</var> + <em>or</em> <var>DecimalNumber</var> <var>ExponentPart</var> +<var>DecimalNumber</var> = <strong>0</strong> + <em>or</em> <var>OneToNine</var> <var>Digits</var> +<var>ExponentPart</var> = <strong>e</strong> <var>Exponent</var> + <em>or</em> <strong>E</strong> <var>Exponent</var> +<var>Exponent</var> = <var>Digits</var> + <em>or</em> <strong>+</strong> <var>Digits</var> + <em>or</em> <strong>-</strong> <var>Digits</var> +<var>Digits</var> = <var>Digit</var> + <em>or</em> <var>Digits</var> <var>Digit</var> +<var>Digit</var> = <strong>0</strong> through <strong>9</strong> +<var>OneToNine</var> = <strong>1</strong> through <strong>9</strong> + +<var>JSONString</var> = <strong>""</strong> + <em>or</em> <strong>"</strong> <var>StringCharacters</var> <strong>"</strong> +<var>StringCharacters</var> = <var>StringCharacter</var> + <em>or</em> <var>StringCharacters</var> <var>StringCharacter</var> +<var>StringCharacter</var> = any character + <em>except</em> <strong>"</strong> <em>or</em> <strong>\</strong> <em>or</em> U+0000 through U+001F + <em>or</em> <var>EscapeSequence</var> +<var>EscapeSequence</var> = <strong>\"</strong> <em>or</em> <strong>\/</strong> <em>or</em> <strong>\\</strong> <em>or</em> <strong>\b</strong> <em>or</em> <strong>\f</strong> <em>or</em> <strong>\n</strong> <em>or</em> <strong>\r</strong> <em>or</em> <strong>\t</strong> + <em>or</em> <strong>\u</strong> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> +<var>HexDigit</var> = <strong>0</strong> through <strong>9</strong> + <em>or</em> <strong>A</strong> through <strong>F</strong> + <em>or</em> <strong>a</strong> through <strong>f</strong> + +<var>JSONObject</var> = <strong>{</strong> <strong>}</strong> + <em>or</em> <strong>{</strong> <var>Members</var> <strong>}</strong> +<var>Members</var> = <var>JSONString</var> <strong>:</strong> <var>JSON</var> + <em>or</em> <var>Members</var> <strong>,</strong> <var>JSONString</var> <strong>:</strong> <var>JSON</var> + +<var>JSONArray</var> = <strong>[</strong> <strong>]</strong> + <em>or</em> <strong>[</strong> <var>ArrayElements</var> <strong>]</strong> +<var>ArrayElements</var> = <var>JSON</var> + <em>or</em> <var>ArrayElements</var> <strong>,</strong> <var>JSON</var> +</pre> + +<p>Nieznaczące białe znaki nie mogą występować tylko wewnątrz <code><var>JSONNumber</var></code> (liczby nie mogą zawierać białych znaków) oraz <code><var>JSONString</var></code> (gdzie jest to interpretowane jako odpowiedni znak w litarale znakowym lub może spowodować błąd). Tabulacja pozioma (<a href="https://unicode-table.com/pl/#0009">U+0009</a>), powrót karetki (<a href="https://unicode-table.com/pl/#000D">U+000D</a>), nowa linia (<a href="https://unicode-table.com/pl/#000A">U+000A</a>) oraz spacja (<a href="https://unicode-table.com/pl/#0020">U+0020</a>) to jedyne prawidłowe białe znaki.</p> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("JSON.parse()")}}</dt> + <dd>Parsuje literał znakowy na JSON, opcjonalnie przekształca otrzymaną wartosć i ją zwraca. Każde naruszenie składni JSON, wliczając w różnice między językiem JavaScript i JSON, powodują zgłosznie błędu {{jsxref("SyntaxError")}}. Opcja <code>reviver</code> pozwala zinterpretować, co <code>replacer</code> użył zamiast innych typów danych.</dd> + <dt>{{jsxref("JSON.stringify()")}}</dt> + <dd>Zwraca literał znakowy JSON odpowiadający określonej wartosci, ewentualnie zawierający jedynie niektóre wartości lub ze zamienionymi wartościami w sposób zdefinowany przez użytkownika. Domyślnie, wszystkie instance {{jsxref("undefined")}} są zastępowane przez {{jsxref("null")}} i inne niewspierane typy danych są ocenzurowywane. Opcja <code>replacer</code> pozwala określić inne zachowanie.</dd> +</dl> + +<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.12', 'JSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-json-object', 'JSON')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-json-object', 'JSON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.JSON")}}</p> +</div> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.toJSON()")}}</li> +</ul> + +<h2 id="Tools">Tools</h2> + +<ul> + <li><a href="http://jsoncompare.org/">JSON Diff</a> checker.</li> + <li><a href="http://jsonbeautifier.org/">JSON Beautifier/editor</a>.</li> + <li><a href="http://jsonparser.org/">JSON Parser</a></li> + <li><a href="https://tools.learningcontainer.com/json-validator/">JSON Validator</a>.</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/clear/index.html b/files/pl/web/javascript/reference/global_objects/map/clear/index.html new file mode 100644 index 0000000000..15fa630779 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/clear/index.html @@ -0,0 +1,88 @@ +--- +title: Map.prototype.clear() +slug: Web/JavaScript/Reference/Global_Objects/Map/clear +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/clear +original_slug: Web/JavaScript/Referencje/Obiekty/Map/clear +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>clear()</strong></code> usuwa wszystkie elementy z obiektu <code>Map</code>.</p> + +<pre class="brush: js">var map1 = new Map(); + +map1.set('bar', 'baz'); +map1.set(1, 'foo'); + +console.log(map1.size); +// wartość zwracana: 2 + +map1.clear(); + +console.log(map1.size); +// wartość zwracana: 0 +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.clear();</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_metody_clear">Używanie metody <code>clear</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'baz'); +myMap.set(1, 'foo'); + +myMap.size; // 2 +myMap.has('bar'); // true + +myMap.clear(); + +myMap.size; // 0 +myMap.has('bar') // false +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.clear")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/delete/index.html b/files/pl/web/javascript/reference/global_objects/map/delete/index.html new file mode 100644 index 0000000000..bb33f16d44 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/delete/index.html @@ -0,0 +1,86 @@ +--- +title: Map.prototype.delete() +slug: Web/JavaScript/Reference/Global_Objects/Map/delete +tags: + - Mapa + - Metodă +translation_of: Web/JavaScript/Reference/Global_Objects/Map/delete +original_slug: Web/JavaScript/Referencje/Obiekty/Map/delete +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>delete()</strong></code> usuwa określony element z obiektu <code>Map</code>.</p> + +<pre class="brush: js">var map1 = new Map(); +map1.set('bar', 'foo'); + +console.log(map1.delete('bar')); +// oczekiwany wynik: true +// (true wskazuje na poprawne usunięcie) + +console.log(map1.has('bar')); +// oczekiwany wynik: false +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js">myMap.delete(key);</pre> + +<h3 id="Parametery">Parametery</h3> + +<dl> + <dt>key</dt> + <dd>Wymagany. Klucz elementu, który ma zostać usunięty z obiektu <code>Map</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<dl> + <dt>Boolean</dt> + <dd>Zwraca <code>true</code>, jeśli element w <code>Map</code> istniał i został usunięty lub <code>false</code>, jeśli nie.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_metody_delete">Używanie metody <code>delete</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'foo'); + +myMap.delete('bar'); // Zwraca true. Udało się usunąć. +myMap.has('bar'); // Zwraca false. Element "bar" już nie istnieje. +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.delete")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/entries/index.html b/files/pl/web/javascript/reference/global_objects/map/entries/index.html new file mode 100644 index 0000000000..25589210ac --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/entries/index.html @@ -0,0 +1,129 @@ +--- +title: Map.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Map/entries +tags: + - ECMAScript2015 + - Iterator + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/entries +original_slug: Web/JavaScript/Referencje/Obiekty/Map/entries +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>entries()</strong></code> zwraca nowy obiekt typu <a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a> który zawiera pary<code>[klucz, wartość]</code> dla każdego elementu <code>Mapy</code>. Można się do nich odnieść w takiej kolejności, jakiej zostały wstawione.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-entries.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.entries()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator obiektu typu {{jsxref("Map")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_entries()">Używanie <code>entries()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +var mapIter = myMap.entries(); + +console.log(mapIter.next().value); // ["0", "foo"] +console.log(mapIter.next().value); // [1, "bar"] +console.log(mapIter.next().value); // [Object, "baz"] +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoDesktop("20") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.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>Edge</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>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("20")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map.prototype.keys()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/foreach/index.html b/files/pl/web/javascript/reference/global_objects/map/foreach/index.html new file mode 100644 index 0000000000..ec53470515 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/foreach/index.html @@ -0,0 +1,105 @@ +--- +title: Map.prototype.forEach() +slug: Web/JavaScript/Reference/Global_Objects/Map/forEach +tags: + - ECMAScript2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/forEach +original_slug: Web/JavaScript/Referencje/Obiekty/Map/forEach +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>forEach()</strong></code> wykonuje dostarczoną funcję <code>callback</code> raz dla każdej pary klucz-wartosć <code>Mapy</code> w kolejności, w jakiej zostały zostały wstawione.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-foreach.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.forEach(<em>callback</em>[, <em>thisArg</em>])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja wykonywana dla każdego elementu.</dd> + <dt><code>thisArg</code></dt> + <dd>Wartość przypisywana do <code>this</code> poczas wywołania zwrotnego (funkcja <code>callback</code>).</dd> +</dl> + +<h3 id="Zwracana_wartosć">Zwracana wartosć</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda <code>forEach</code> wykonuje dostarczoną funkcję <code>callback</code> raz dla każdego klucza mapy, który istnieje. Nie jest wywoływana dla usuniętych kluczy, ale dla istniejących z wartością <code>undefined</code> już tak.</p> + +<p>Funkcja <code>callback</code> przyjmuje <strong>trzy argumenty</strong>:</p> + +<ul> + <li><strong>wartość elementu</strong></li> + <li><strong>klucz elementu</strong></li> + <li>obiekt typu <strong><code>Map</code> do przetworzenia</strong></li> +</ul> + +<p>Jeśli argument <code>thisArg</code> jest dostarczony do <code>forEach</code>, zostaje przekazany do fukncji <code>callback</code> podczas jej wywołania, jako jej własna wartość <code>this</code>. W przeciwnym wypadku, <code>this</code> przyjmuje wartość <code>undefined</code>. </p> + +<p>Każda wartość jest odwiedzana raz, oprócz przypadku, gdzie została usunięta, a następnie dodana ponownie, nim metoda <code>forEach</code> zakończyła swoje działanie. Funkcja <code>callback</code> nie jest wywoływana dla wartości usuniętych przed ich odwiedzeniem. Nowe wartości dodane jeszcze przed zakończeniem <code>forEach</code> zostaną odwiedzone.</p> + +<p>Metoda <code>forEach</code> nie zwraca żadnej wartości.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Wyświetlanie_zawartości_Mapy">Wyświetlanie zawartości <code>Mapy</code></h3> + +<p>Poniższy kod wyświetla jedną linię dla każdej pary klucz-wartość <code>Mapy</code>:</p> + +<pre class="brush:js">function logMapElements(value, key, map) { + console.log(`m[${key}] = ${value}`); +} +new Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(logMapElements); +// logs: +// "m[foo] = 3" +// "m[bar] = [object Object]" +// "m[baz] = undefined" +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.forEach")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Set.prototype.forEach()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/get/index.html b/files/pl/web/javascript/reference/global_objects/map/get/index.html new file mode 100644 index 0000000000..b9b3da5da3 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/get/index.html @@ -0,0 +1,81 @@ +--- +title: Map.prototype.get() +slug: Web/JavaScript/Reference/Global_Objects/Map/get +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/get +original_slug: Web/JavaScript/Referencje/Obiekty/Map/get +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>get()</strong></code> zwraca podany element <code>Mapy</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-get.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.get(key);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>key</dt> + <dd>Wymagany. Klucz elementu, który ma zostać zwrócony.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Element powiązany z danym kluczym lub <code>undefined</code>, jeśli klucz nie został odnaleziony.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_metody_get">Używanie metody <code>get</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'foo'); + +myMap.get('bar'); // zwraca "foo". +myMap.get('baz'); // zwraca undefined. +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.get")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/has/index.html b/files/pl/web/javascript/reference/global_objects/map/has/index.html new file mode 100644 index 0000000000..3f9f330b4e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/has/index.html @@ -0,0 +1,86 @@ +--- +title: Map.prototype.has() +slug: Web/JavaScript/Reference/Global_Objects/Map/has +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/has +original_slug: Web/JavaScript/Referencje/Obiekty/Map/has +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>has()</strong></code> zwraca <a href="/pl/docs/Web/JavaScript/Referencje/Obiekty/Boolean">Boolean</a>, który określa czy element o podanym kluczu istnieje.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-has.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.has(key);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>key</dt> + <dd>Wymagany. Klucz elementu, którego istnienie w <code>Mapie</code> zostanie sprawdzone.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<dl> + <dt>Boolean</dt> + <dd> + <p><code>true</code>, jeśli dany element istnieje w <code>Mapie</code> - w przeciwnym wypadku <code>false</code>.</p> + </dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_metody_has">Używanie metody <code>has</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', "foo"); + +myMap.has('bar'); // zwraca true +myMap.has('baz'); // zwraca false +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.has', 'Map.prototype.has')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.has', 'Map.prototype.has')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.has")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/index.html b/files/pl/web/javascript/reference/global_objects/map/index.html new file mode 100644 index 0000000000..a72cd3dc26 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/index.html @@ -0,0 +1,459 @@ +--- +title: Map +slug: Web/JavaScript/Reference/Global_Objects/Map +tags: + - ECMAScript 2015 + - JavaScript + - Map +translation_of: Web/JavaScript/Reference/Global_Objects/Map +original_slug: Web/JavaScript/Referencje/Obiekty/Map +--- +<div>{{JSRef}}</div> + +<p><strong>Map </strong>jest prostym obiektem mapującym klucze na wartości. Każdy element (zarówno obiekt jak i {{Glossary("Primitive", "wartości proste")}}) mogą być użyte zarówno jako klucz jak i wartość.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">new Map([iterable])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>iterable</code></dt> + <dd>Iterable jest tablicą lub innym iterowalnym obiektem, którego elementy są parami typu klucz-wartość (np. 2 elementowa tablica). Każda para klucz-wartość jest dodawana do obiektu new Map. <code>null</code> jest traktowane jako <code>undefined.</code></dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt Map iteruje swoje elementy we wprowadzonej kolejności — pętla {{jsxref("Statements/for...of", "for...of")}} zwraca tablicę <code>[key, value] </code>dla każdej iteracji.</p> + +<p>Należy pamiętać, że kolejność iteracji dla <code>Map</code> mapującej obiekty, w szczególności np. dla słownika słowników, odzwieciedlać będzie jedynie kolejność dodawania obiektów do kolekcji, natomiast kolejność dodawania elementów do samych obiektów nie jest gwarantowana i powinna być traktowana jako losowa.</p> + +<h3 id="Równość_kluczy">Równość kluczy</h3> + +<p>Klucze porównywane są według algorytmu "same-value" (tej samej wartości).</p> + +<p><code>NaN</code> jest traktowana jako równa <code>NaN</code> (mimo tego, że <code>NaN !== NaN</code>). Wszystkie inne wartości są uważane za równe zgodnie z semantyką <code>===</code> operatora równości.</p> + +<p>W obecnej specyfikacji ECMAScript <code>-0 === +0</code>, choć wcześniejsze propozycje zakładały inne zachowanie, co zaowocowało implementacją w niektórych wersjach przeglądarek. Szczegóły zawarte są w "Value equality for -0 and 0" w tabeli <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Map$edit#Browser_compatibility">kompatybilności przeglądarek</a>.</p> + +<h3 id="Porównanie_Obiektów_i_Map">Porównanie Obiektów i Map</h3> + +<p>{{jsxref("Object", "Obiekty")}} są podobne do Map. W obu przypadkach pozwalają ustawić klucze dla wartości, zwracają te wartości, usuwają klucze i wykrywają czy coś jest przechowywane jako klucz. Z tego powodu (i ponieważ nie było innych wbudowanych alternatyw), <code>Object</code> był używany wcześniej jako <code>Map</code>. Istnieją jednak ważne różnice pomiędzy <code>Obiektami</code> i <code>Mapami</code>, które powodują, że <code>Map</code> jest lepszym wyborem w pewnych przypadkach:</p> + +<ul> + <li>Klucze obiektu są {{jsxref("String", "Stringami")}}' i {{jsxref("Symbol", "Symbolami")}}, podczas gdy dla <code>Map</code> mogą być dowolną wartością, włączając w to funkcje, obiekty czy wartości proste.</li> + <li>Można łatwo pobrać wielkość mapy używając właściwości <code>size</code>, podczas gdy wielkość obiektu musi być określana ręcznie.</li> + <li>Po mapie można iterować bezpośrednio, iteracja po obiekcie wymaga pobrania jego kluczy i iteracji po ich liście.</li> + <li>Obiekt posiada prototyp, istnieją więc domyślne klucze, które mogą kolidować z Twoimi kluczami, jeśli nie jesteś ostrożny. Można ominąć ten problem używając <code>Object.create(null)</code> (dostępne od ES5), ale było to rzadko stosowane rozwiązanie.</li> + <li>Mapa może osiągnąć lepszą wydajność w scenariuszu, w którym często dodajemy i usuwamy pary klucz-wartość.</li> +</ul> + +<p>Nie oznacza to, że powinno się używać <code>Maps</code> wszędzie. Obiekty są wciąż używane w większości przypadków. Instancje <code>Map</code> są użyteczne dla kolekcji, warto rozważyć ich zaadaptowanie jedynie w przypadkach, gdy wcześniej używano dla nich obiektów. Obiekty powinny być używane jako rejestr z polami i metodami. Jeśli wciąż nie jesteś pewien czego użyć, pomocne mogą okazać się poniższe pytania:</p> + +<ul> + <li>Czy klucze są nieznane do momentu uruchomienia programu? Czy potrzebujesz wyszukiwać lub tworzyć je dynamicznie?</li> + <li>Czy wszystkie wartości mają ten sam typ? Czy mogą być użyte wymiennie?</li> + <li>Czy potrzebujesz kluczy, które nie są typu string?</li> + <li>Czy pary klucz-wartość są często dodawane lub usuwane?</li> + <li>Czy kolekcja powinna być iterowalna?</li> +</ul> + +<p>Jeśli odpowiedziałeś 'tak' na którekolwiek z tych pytań, prawdopodobnie powinieneś użyć <code>Map</code>. I przeciwnie, jeśli masz zamknięty zbiór kluczy, jeśli musisz odwoływać się do poszczególnych, specyficznych kluczy a każdy z nich ma swoje, odrębne od innych znaczenie, najprawdopodobniej potrzebujesz obiektu.</p> + +<h2 id="Własności">Własności</h2> + +<dl> + <dt><code>Map.length</code></dt> + <dd>Wartość <code>length</code> jest zawsze równa 0.</dd> + <dt>{{jsxref("Map.@@species", "get Map[@@species]")}}</dt> + <dd>Funkcja konstruktora używana do tworzenia obiektów pochodnych.</dd> + <dt>{{jsxref("Map.prototype")}}</dt> + <dd>Reprezentuje prototyp funkcji konstruktora <code>Map</code>. Pozwala rozszerzać prototyp wszystkich obiektów <code>Map</code> o własne własności.</dd> +</dl> + +<h2 id="Instancje_Map">Instancje <code>Map</code></h2> + +<p>Wszystkie instancje <code>Map</code> dziedziczą po {{jsxref("Map.prototype")}}.</p> + +<h3 id="Własności_2">Własności</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Map/prototype','Properties')}}</p> + +<h3 id="Metody">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Map/prototype','Methods')}}</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_obiektu_typu_Map">Używanie obiektu typu <code>Map</code></h3> + +<pre class="brush: js notranslate">var myMap = new Map(); + +var keyString = 'a string', + keyObj = {}, + keyFunc = function() {}; + +// setting the values +myMap.set(keyString, "value associated with 'a string'"); +myMap.set(keyObj, 'value associated with keyObj'); +myMap.set(keyFunc, 'value associated with keyFunc'); + +myMap.size; // 3 + +// getting the values +myMap.get(keyString); // "value associated with 'a string'" +myMap.get(keyObj); // "value associated with keyObj" +myMap.get(keyFunc); // "value associated with keyFunc" + +myMap.get('a string'); // "value associated with 'a string'" + // because keyString === 'a string' +myMap.get({}); // undefined, because keyObj !== {} +myMap.get(function() {}) // undefined, because keyFunc !== function () {} +</pre> + +<h3 id="Użycie_NaN_jako_kluczy_w_Map">Użycie <code>NaN</code> jako kluczy w <code>Map</code></h3> + +<p><code>NaN</code> can also be used as a key. Even though every <code>NaN</code> is not equal to itself (<code>NaN !== NaN</code> is true), the following example works, because <code>NaN</code>s are indistinguishable from each other:</p> + +<pre class="brush: js notranslate">var myMap = new Map(); +myMap.set(NaN, 'not a number'); + +myMap.get(NaN); // "not a number" + +var otherNaN = Number('foo'); +myMap.get(otherNaN); // "not a number" +</pre> + +<h3 id="Iteracja_po_Map_przy_użyciu_for..of">Iteracja po <code>Map</code> przy użyciu <code>for..of</code></h3> + +<pre class="brush: js notranslate">var myMap = new Map(); +myMap.set(0, 'zero'); +myMap.set(1, 'one'); +for (var [key, value] of myMap) { + console.log(key + ' = ' + value); +} +// 0 = zero +// 1 = one + +for (var key of myMap.keys()) { + console.log(key); +} +// 0 +// 1 + +for (var value of myMap.values()) { + console.log(value); +} +// zero +// one + +for (var [key, value] of myMap.entries()) { + console.log(key + ' = ' + value); +} +// 0 = zero +// 1 = one +</pre> + +<h3 id="Iteracja_po_Map_przy_użyciu_forEach">Iteracja po <code>Map</code> przy użyciu <code>forEach()</code></h3> + +<pre class="brush: js notranslate">myMap.forEach(function(value, key) { + console.log(key + ' = ' + value); +}); +// Will show 2 logs; first with "0 = zero" and second with "1 = one" +</pre> + +<h3 id="Relacja_do_obiektów_typu_Array">Relacja do obiektów typu <code>Array</code></h3> + +<pre class="brush: js notranslate">var kvArray = [['key1', 'value1'], ['key2', 'value2']]; + +// Use the regular Map constructor to transform a 2D key-value Array into a map +var myMap = new Map(kvArray); + +myMap.get('key1'); // returns "value1" + +// Use the spread operator to transform a map into a 2D key-value Array. +console.log(uneval([...myMap])); // Will show you exactly the same Array as kvArray + +// Or use the spread operator on the keys or values iterator to get +// an array of only the keys or values +console.log(uneval([...myMap.keys()])); // Will show ["key1", "key2"] +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map-objects', 'Map')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map-objects', 'Map')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td> + <p>{{ CompatChrome(38) }} [1]</p> + </td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Constructor argument: <code>new Map(iterable)</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatSafari("9")}}</td> + </tr> + <tr> + <td>iterable</td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("17") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Map.clear()</code></td> + <td>{{ CompatChrome(31) }}<br> + {{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("19")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Map.keys(), Map.values(), Map.entries()</code></td> + <td>{{ CompatChrome(37) }}<br> + {{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("20")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Map.forEach()</code></td> + <td>{{ CompatChrome(36) }}<br> + {{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Key equality for -0 and 0</td> + <td>{{ CompatChrome(34) }}<br> + {{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatSafari("9")}}</td> + </tr> + <tr> + <td>Constructor argument: <code>new Map(null)</code></td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>11</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + <tr> + <td>Monkey-patched <code>set()</code> in Constructor</td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + <tr> + <td><code>Map[@@species]</code></td> + <td>{{CompatChrome("51")}}</td> + <td>13</td> + <td>{{CompatGeckoDesktop("41")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("38")}}</td> + <td>{{CompatSafari("10")}}</td> + </tr> + <tr> + <td><code>Map()</code> without <code>new</code> throws</td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("42") }}</td> + <td>11</td> + <td>{{CompatVersionUnknown}}</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(38) }} [1]</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Constructor argument: <code>new Map(iterable)</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td>iterable</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile("17") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Map.clear()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(31) }}<br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("19")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Map.keys(), Map.values(), Map.entries()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(37) }}<br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("20")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Map.forEach()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(36) }}<br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Key equality for -0 and 0</td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(34) }}<br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Constructor argument: <code>new Map(null)</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td>Monkey-patched <code>set()</code> in Constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td><code>Map[@@species]</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("41")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>10</td> + </tr> + <tr> + <td><code>Map()</code> without <code>new</code> throws</td> + <td>5.1</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("42")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Starting with Chrome 31, the feature was available behind a preference. In <code>chrome://flags</code>, activate the entry “Enable Experimental JavaScript”.</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697479">Map and Set bug at Mozilla</a></li> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets">ECMAScript Harmony proposal</a></li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/keys/index.html b/files/pl/web/javascript/reference/global_objects/map/keys/index.html new file mode 100644 index 0000000000..6d018a6f9a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/keys/index.html @@ -0,0 +1,79 @@ +--- +title: Map.prototype.keys() +slug: Web/JavaScript/Reference/Global_Objects/Map/keys +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/keys +original_slug: Web/JavaScript/Referencje/Obiekty/Map/keys +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>keys()</strong></code> zwraca nowy obiekt typu <strong><a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong>, który zawiera klucze dla każdego elementu w <code>Mapie</code>. Można się do nich odnieść w takiej kolejności, jakiej zostały wstawione.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-keys.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.keys()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator obiektu typu {{jsxref("Map")}}</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_keys()">Używanie <code>keys()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +var mapIter = myMap.keys(); + +console.log(mapIter.next().value); // "0" +console.log(mapIter.next().value); // 1 +console.log(mapIter.next().value); // Object +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.keys")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/set/index.html b/files/pl/web/javascript/reference/global_objects/map/set/index.html new file mode 100644 index 0000000000..96f3340090 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/set/index.html @@ -0,0 +1,97 @@ +--- +title: Map.prototype.set() +slug: Web/JavaScript/Reference/Global_Objects/Map/set +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/set +original_slug: Web/JavaScript/Referencje/Obiekty/Map/set +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>set()</strong></code> dodaje lub zmienia element o podany <code>kluczu</code> i <code>wartości</code> w <code>Mapie</code>. </p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-set.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.set(key, value);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>key</dt> + <dd>Wymagany. Klucz elementu, który zostanie dodany do <code>Mapy</code>.</dd> + <dt>value</dt> + <dd>Wymagany. Wartość elementu, który zostanie dodany do <code>Mapy</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p> Obiekt typu <code>Map</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_set()">Używanie <code>set()</code></h3> + +<pre class="brush: js">var myMap = new Map(); + +// Dodawanie nowych elementu +myMap.set('bar', 'foo'); +myMap.set(1, 'foobar'); + +// Zmiana istniejącego już elementu +myMap.set('bar', 'baz'); +</pre> + +<h3 id="Używanie_set_w_połączeniu_z_łańcuchowaniem">Używanie <code>set</code> w połączeniu z łańcuchowaniem</h3> + +<p>Ponieważ <code>set()</code> zwraca ten sam obiekt typu <code>Mapa</code>, można użyć chainingu (uruchamianie metod jedna po drugiej na danym obiekcie przy użyciu kropek).</p> + +<pre class="brush: js">// Dodawanie elementów do mapy za pomocą chainingu +myMap.set('bar', 'foo') + .set(1, 'foobar') + .set(2, 'baz'); + +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.set', 'Map.prototype.set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.set', 'Map.prototype.set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.set")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/size/index.html b/files/pl/web/javascript/reference/global_objects/map/size/index.html new file mode 100644 index 0000000000..cd85fbb940 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/size/index.html @@ -0,0 +1,66 @@ +--- +title: Map.prototype.size +slug: Web/JavaScript/Reference/Global_Objects/Map/size +tags: + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Map/size +original_slug: Web/JavaScript/Referencje/Obiekty/Map/size +--- +<div>{{JSRef}}</div> + +<p>Atrybut <code><strong>size</strong></code> zwraca ilość elementów znajdujących się w obiekcie {{jsxref("Map")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-size.html")}}</div> + +<p class="hidden">Żródło dla tego przykładu interaktywnego jest przechowywane w repozytorium w serwisie GitHub. Jeśli chciałbyś pomoć przy projekcie przykładów, prosimy o sklonowanie repozytorium <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wysłanie pull request.</p> + +<h2 id="Opis">Opis</h2> + +<p>Wartość <code>size</code> to liczba reprezentująca ile elementów posiada obiekt <code>Map</code>. Funkcja set dla <code>size</code> to <code>undefined</code>; nie można edytować tego atrybutu.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_size">Użycie <code>size</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('a', 'alpha'); +myMap.set('b', 'beta'); +myMap.set('g', 'gamma'); + +myMap.size // 3 +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<div class="hidden">Tabela kompatybilności na tej stronie jest generowana z danych zewnętrznych. Jeśli chciałbyś pomóc przy tych danych, polecamy zajrzeć na <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> i wysłać pull request.</div> + +<p>{{Compat("javascript.builtins.Map.size")}}</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/map/values/index.html b/files/pl/web/javascript/reference/global_objects/map/values/index.html new file mode 100644 index 0000000000..163f99de5d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/map/values/index.html @@ -0,0 +1,78 @@ +--- +title: Map.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Map/values +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/values +original_slug: Web/JavaScript/Referencje/Obiekty/Map/values +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>values()</strong></code> zwraca nowy obiekt typu <strong><a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong>, który zawiera wartości dla każdego elementu w <code>Mapie</code>. Można się do nich odnieść w takiej kolejności, jakiej zostały wstawione.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-values.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.values()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator obiektu typu {{jsxref("Map")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_values()">Używanie <code>values()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +var mapIter = myMap.values(); + +console.log(mapIter.next().value); // "foo" +console.log(mapIter.next().value); // "bar" +console.log(mapIter.next().value); // "baz"</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.values', 'Map.prototype.values')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.values', 'Map.prototype.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.values")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.keys()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/abs/index.html b/files/pl/web/javascript/reference/global_objects/math/abs/index.html new file mode 100644 index 0000000000..7130c60e4d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/abs/index.html @@ -0,0 +1,55 @@ +--- +title: Math.abs() +slug: Web/JavaScript/Reference/Global_Objects/Math/abs +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs +original_slug: Web/JavaScript/Referencje/Obiekty/Math/abs +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość bezwzględną danej liczby.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>></mo><mn>0</mn></mtd></mtr><mtr><mtd><mi>0</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>=</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo><</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{if} \quad x \geq 0 \\ -x & \text{if} \quad x < 0 \end{cases} </annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.abs(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>abs</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.abs()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.abs" name="Przyk.C5.82ad:_Zastosowanie_Math.abs">Przykład: Zastosowanie <code>Math.abs()</code></h3> + +<p>Poniższa funkcja zwraca wartość bezwzględną zmiennej <code>x</code>:</p> + +<pre class="brush: js">Math.abs('-1'); // 1 +Math.abs(-2); // 2 +Math.abs(null); // 0 +Math.abs('string'); // NaN +Math.abs(); // NaN +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/acos/index.html b/files/pl/web/javascript/reference/global_objects/math/acos/index.html new file mode 100644 index 0000000000..1a5631dbf5 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/acos/index.html @@ -0,0 +1,60 @@ +--- +title: Math.acos() +slug: Web/JavaScript/Reference/Global_Objects/Math/acos +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos +original_slug: Web/JavaScript/Referencje/Obiekty/Math/acos +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca arcus cosinus (w radianach) danej liczby.</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.acos(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>acos</code> zwraca wartość numeryczną od 0 do pi dla <code>x</code> pomiędzy -1 a 1. Jeśli liczba <code>x</code> jest spoza przedziału [-1, 1], zwracany jest {{jsxref("NaN")}}.</p> + +<p>Ponieważ <code>acos</code> jest statyczną metodą obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.acos()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.acos" name="Przyk.C5.82ad:_Zastosowanie_Math.acos">Przykład: Zastosowanie <code>Math.acos()</code></h3> + +<p>Poniższa funkcja zwraca arcus cosinus zmiennej <code>x</code>:</p> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 3.141592653589793 +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1.5707963267948966 +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">0.5</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.0471975511965979 +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN</span></code></pre> + +<p>Jeśli do <code>getAcos</code> przekazana zostanie wartość -1, funkcja zwróci 3.141592653589793; jeśli przekazana zostanie wartość 2, zwrócony zostanie <code>NaN</code>, ponieważ 2 jest poza zakresem (tj. dziedziną funkcji arcus cosinus).</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/asin/index.html b/files/pl/web/javascript/reference/global_objects/math/asin/index.html new file mode 100644 index 0000000000..bd7d955271 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/asin/index.html @@ -0,0 +1,59 @@ +--- +title: Math.asin() +slug: Web/JavaScript/Reference/Global_Objects/Math/asin +tags: + - JavaScript + - Math +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin +original_slug: Web/JavaScript/Referencje/Obiekty/Math/asin +--- +<p>{{jsref}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca arcus sinus (w radianach) danej liczby.</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.asin(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>Math.asin()</code> zwraca wartość liczbową pomiędzy <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> i <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianów dla <code>x</code> z przedziału [-1, 1]. Jeśli <code>x</code> jest poza tym zakresem, zwracany jest <code>NaN</code>.</p> + +<p>Ponieważ <code>asin</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.asin()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.asin" name="Przyk.C5.82ad:_Zastosowanie_Math.asin">Przykład: Zastosowanie <code>Math.asin()</code></h3> + +<p>Poniższa funkcja zwraca arcus sinus zmiennej <code>x</code>:</p> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -1.5707963267948966 (-pi/2) +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">0.5</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.5235987755982989 +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1.570796326794897 (pi/2) +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN</span></code></pre> + +<p>Jeśli do funkcji <code>getAsin</code> przekazana zostanie wartość 1, funkcja ta zwróci 1.570796326794897 (pi/2); jeśli przekazana zostanie wartość 2, funkcja zwróci {{jsxref("<code>NaN</code>")}}, ponieważ 2 jest poza dziedziną funkcji arcus sinus.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/atan/index.html b/files/pl/web/javascript/reference/global_objects/math/atan/index.html new file mode 100644 index 0000000000..06fa2229fe --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/atan/index.html @@ -0,0 +1,52 @@ +--- +title: Math.atan() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan +original_slug: Web/JavaScript/Referencje/Obiekty/Math/atan +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca arcus tangens (w radianach) danej liczby.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.atan(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>atan</code> zwraca wartość liczbową pomiędzy <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> i <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianów.</p> + +<p>Ponieważ <code>atan</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.atan()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.atan" name="Przyk.C5.82ad:_Zastosowanie_Math.atan">Przykład: Zastosowanie <code>Math.atan()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">atan<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0.7853981633974483 +</span>Math<span class="token punctuation">.</span><span class="token function">atan<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/atan2/index.html b/files/pl/web/javascript/reference/global_objects/math/atan2/index.html new file mode 100644 index 0000000000..e8cc44766c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/atan2/index.html @@ -0,0 +1,64 @@ +--- +title: Math.atan2() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan2 +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2 +original_slug: Web/JavaScript/Referencje/Obiekty/Math/atan2 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca kąta (w radianach) utworzony przez oś OX i prostą przechodzącą przez punkt o podanych współrzędnych.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.atan2(<var>y</var>, <var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>y, x</code> </dt> + <dd>liczby.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>atan2</code> zwraca wartość liczbową pomiędzy -π a π, reprezentującą kąt theta punktu <code>(x, y)</code>. Kąt ten, mierzony w radianach, został utworzony przez dodatnią oś OX i punkt <code>(x,y)</code>, z obrotem w kierunku przeciwnym do ruchu wskazówek zegara. Należy zwrócić uwagę na to, że pierwszym argumentem tej funkcji jest współrzędna y, a x jest argumentem drugim.</p> + +<p>Do metody Math.<code>atan2</code>() przekazywane są osobno argumenty <code>x</code> i <code>y</code>, podczas gdy do metody <code>atan</code> przekazywany jest stosunek tych dwóch wartości.</p> + +<p>Ponieważ <code>atan2()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.atan2()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.atan2" name="Przyk.C5.82ad:_Zastosowanie_Math.atan2">Przykład: Zastosowanie <code>Math.atan2()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span><span class="token number">90</span><span class="token punctuation">,</span> <span class="token number">15</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.4056476493802699 +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span><span class="token number">15</span><span class="token punctuation">,</span> <span class="token number">90</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.16514867741462683 +</span> +Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±PI. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> <span class="token operator">+</span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> <span class="token operator">-</span>x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±PI for x > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±0 for x > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span><span class="token operator">-</span>y<span class="token punctuation">,</span> ±<span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -PI/2 for y > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>y<span class="token punctuation">,</span> ±<span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // PI/2 for y > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±y<span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±PI for finite y > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±y<span class="token punctuation">,</span> <span class="token operator">+</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±0 for finite y > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">Infinity</span><span class="token punctuation">,</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±PI/2 for finite x. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">Infinity</span><span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // ±3*PI/4. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">Infinity</span><span class="token punctuation">,</span> <span class="token operator">+</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // ±PI/4.</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/ceil/index.html b/files/pl/web/javascript/reference/global_objects/math/ceil/index.html new file mode 100644 index 0000000000..a46dbd3069 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/ceil/index.html @@ -0,0 +1,50 @@ +--- +title: Math.ceil() +slug: Web/JavaScript/Reference/Global_Objects/Math/ceil +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil +original_slug: Web/JavaScript/Referencje/Obiekty/Math/ceil +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca najmniejszą liczbę całkowitą większą od lub równą danej.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.ceil(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>ceil</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.ceil()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_Math.ceil" name="Przyk.C5.82ad:_Zastosowanie_Math.ceil">Przykład: Zastosowanie <code>Math.ceil()</code></h4> + +<p>Poniższa funkcja zwraca wartość metody ceil dla zmiennej <code>x</code>:</p> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">ceil<span class="token punctuation">(</span></span><span class="token punctuation">.</span><span class="token number">95</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1 +</span>Math<span class="token punctuation">.</span><span class="token function">ceil<span class="token punctuation">(</span></span><span class="token number">4</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 4 +</span>Math<span class="token punctuation">.</span><span class="token function">ceil<span class="token punctuation">(</span></span><span class="token number">7.004</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 8</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/cos/index.html b/files/pl/web/javascript/reference/global_objects/math/cos/index.html new file mode 100644 index 0000000000..cb0c692240 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/cos/index.html @@ -0,0 +1,53 @@ +--- +title: Math.cos() +slug: Web/JavaScript/Reference/Global_Objects/Math/cos +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos +original_slug: Web/JavaScript/Referencje/Obiekty/Math/cos +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca cosinus danej liczby.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code>Math.cos(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>cos</code> zwraca wartość liczbową pomiędzy -1 a 1, która reprezentuje cosinus kąta.</p> + +<p>Ponieważ <code>cos()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.cos()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.cos" name="Przyk.C5.82ad:_Zastosowanie_Math.cos">Przykład: Zastosowanie <code>Math.cos()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1 +</span>Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0.5403023058681398 +</span> +Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span>Math<span class="token punctuation">.</span>PI<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -1 +</span>Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span><span class="token number">2</span> <span class="token operator">*</span> Math<span class="token punctuation">.</span>PI<span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/e/index.html b/files/pl/web/javascript/reference/global_objects/math/e/index.html new file mode 100644 index 0000000000..718bb943fd --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/e/index.html @@ -0,0 +1,41 @@ +--- +title: Math.E +slug: Web/JavaScript/Reference/Global_Objects/Math/E +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/E +original_slug: Web/JavaScript/Referencje/Obiekty/Math/E +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Stała Eulera stanowiąca podstawę logarytmów naturalnych, w przybliżeniu 2.718.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2.718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2.718</annotation></semantics></math></p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>E</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.E</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_E" name="Przyk.C5.82ad:_Zastosowanie_E">Przykład: Zastosowanie <code>Math.E</code></h3> + +<p>Poniższa funkcja zwraca e:</p> + +<pre class="brush: js language-js">function getNapier() { + return Math.E; +} + +<code class="language-js"><span class="token function">getNapier<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 2.718281828459045</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/exp/index.html b/files/pl/web/javascript/reference/global_objects/math/exp/index.html new file mode 100644 index 0000000000..64ac1e7d0d --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/exp/index.html @@ -0,0 +1,50 @@ +--- +title: Math.exp() +slug: Web/JavaScript/Reference/Global_Objects/Math/exp +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp +original_slug: Web/JavaScript/Referencje/Obiekty/Math/exp +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca e<sup>x</sup>, gdzie <code>x</code> to argument, a e to {{jsxref("Math.E", "stała Eulera", "", 1)}}, podstawa logarytmu naturalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.exp(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>exp</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.exp()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.exp" name="Przyk.C5.82ad:_Zastosowanie_Math.exp">Przykład: Zastosowanie <code>Math.exp()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">exp<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.36787944117144233 +</span>Math<span class="token punctuation">.</span><span class="token function">exp<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1 +</span>Math<span class="token punctuation">.</span><span class="token function">exp<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 2.718281828459045</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.E")}}</li> + <li>{{jsxref("Math.expm1()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/floor/index.html b/files/pl/web/javascript/reference/global_objects/math/floor/index.html new file mode 100644 index 0000000000..7ae1710c3c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/floor/index.html @@ -0,0 +1,47 @@ +--- +title: Math.floor() +slug: Web/JavaScript/Reference/Global_Objects/Math/floor +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor +original_slug: Web/JavaScript/Referencje/Obiekty/Math/floor +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca największą liczbę całkowitą mniejszą od lub równą danej.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.floor(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>floor</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.floor()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.floor" name="Przyk.C5.82ad:_Zastosowanie_Math.floor">Przykład: Zastosowanie <code>Math.floor()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">floor<span class="token punctuation">(</span></span> <span class="token number">45.95</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 45 +</span>Math<span class="token punctuation">.</span><span class="token function">floor<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">45.95</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // -46</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/index.html b/files/pl/web/javascript/reference/global_objects/math/index.html new file mode 100644 index 0000000000..5fb44f3d1c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/index.html @@ -0,0 +1,95 @@ +--- +title: Math +slug: Web/JavaScript/Reference/Global_Objects/Math +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Math +original_slug: Web/JavaScript/Referencje/Obiekty/Math +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wbudowany obiekt zawierający własności i metody związane z funkcjami i stałymi matematycznymi. Na przykład własność {{jsxref("Math.PI", "PI")}} obiektu <code>Math</code> zawiera wartość liczby pi.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Tworzony przez</h2> + +<p>Obiekt <code>Math</code> w języku JavaScript jest predefiniowanym obiektem najwyższego poziomu. Można z niego korzystać od razu, bez korzystania z konstruktora lub wywoływania tworzącej metody.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wszystkie własności i metody obiektu <code>Math</code> są statyczne. Do stałej pi odwołujemy się poprzez <code>Math.PI</code>, a funkcję sinus wywołujemy jako <code>Math.sin(x)</code>, gdzie <code>x</code> jest argumentem metody. Stałe zdefiniowane są z pełną precyzją liczb rzeczywistych JavaScriptu.</p> + +<p>Czasami wygodniej jest skorzystać z polecenia {{jsxref("with")}}, kiedy w pewnym fragmencie kodu wykonywane jest wiele obliczeń korzystających z metod i stałych obiektu <code>Math</code>. Unika się wtedy wielokrotnego wpisywania "Math". Na przykład:</p> + +<pre class="brush: js">with (Math) { + a = PI * r*r; + y = r*sin(theta); + x = r*cos(theta); +} +</pre> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("Math.E")}}</dt> + <dd>stała Eulera, podstawa logarytmu naturalnego, w przybliżeniu 2.718.</dd> + <dt>{{jsxref("Math.LN2")}}</dt> + <dd>logarytm naturalny liczby 2, w przybliżeniu 0.693.</dd> + <dt>{{jsxref("Math.LN10")}}</dt> + <dd>logarytm naturalny liczby 10, w przybliżeniu 2.302.</dd> + <dt>{{jsxref("Math.LOG2E")}}</dt> + <dd>logarytm o podstawie 2 z liczby E, w przybliżeniu 1.442.</dd> + <dt>{{jsxref("Math.LOG10E")}}</dt> + <dd>logarytm o podstawie 10 z liczby E, w przybliżeniu 0.434.</dd> + <dt>{{jsxref("Math.PI")}}</dt> + <dd>stosunek obwodu okręgu do jego średnicy, w przybliżeniu 3.14159.</dd> + <dt>{{jsxref("Math.SQRT1_2")}}</dt> + <dd>pierwiastek kwadratowy z liczby 1/2, albo, inaczej mówiąc, odwrotność pierwiastka kwadratowego z liczby 2, w przybliżeniu 0.707.</dd> + <dt>{{jsxref("Math.SQRT2")}}</dt> + <dd>pierwiastek kwadratowy z liczby 2, w przybliżeniu 1.414.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Math.abs()")}}</dt> + <dd>zwraca wartość bezwzględną danej liczby.</dd> + <dt>{{jsxref("Math.acos()")}}</dt> + <dd>zwraca arcus cosinus (w radianach) danej liczby.</dd> + <dt>{{jsxref("Math.asin()")}}</dt> + <dd>zwraca arcus sinus (w radianach) danej liczby.</dd> + <dt>{{jsxref("Math.atan()")}}</dt> + <dd>zwraca arcus tangens (w radianach) danej liczby.</dd> + <dt>{{jsxref("Math.atan2()")}}</dt> + <dd>zwraca kąt (w radianach) utworzony przez oś OX i prostą przechodzącą przez punkt o podanych współrzędnych.</dd> + <dt>{{jsxref("Math.ceil()")}}</dt> + <dd>zwraca najmniejszą liczbę całkowitą większą od lub równą danej.</dd> + <dt>{{jsxref("Math.cos()")}}</dt> + <dd>zwraca cosinus danej liczby.</dd> + <dt>{{jsxref("Math.exp()")}}</dt> + <dd>zwraca <code>E<sup>x</sup></code>, gdzie <code>x</code> to argument, a <code>E</code> to stała Eulera.</dd> + <dt>{{jsxref("Math.floor()")}}</dt> + <dd>zwraca największą liczbę całkowitą mniejszą od lub równą danej.</dd> + <dt>{{jsxref("Math.log()")}}</dt> + <dd>zwraca logarytm naturalny (tj. o podstawie E) z danej liczby.</dd> + <dt>{{jsxref("Math.max()")}}</dt> + <dd>zwraca większą z dwóch liczb.</dd> + <dt>{{jsxref("Math.min()")}}</dt> + <dd>zwraca mniejszą z dwóch liczb.</dd> + <dt>{{jsxref("Math.pow()")}}</dt> + <dd>zwraca daną liczbę podniesioną do danej potęgi.</dd> + <dt>{{jsxref("Math.random()")}}</dt> + <dd>zwraca liczbą pseudolosową z przedziału [0, 1).</dd> + <dt>{{jsxref("Math.round()")}}</dt> + <dd>zwraca daną liczbę zaokrągloną do najbliższej liczby całkowitej.</dd> + <dt>{{jsxref("Math.sin()")}}</dt> + <dd>zwraca sinus danej liczby.</dd> + <dt>{{jsxref("Math.sqrt()")}}</dt> + <dd>zwraca pierwiastek kwadratowy danej liczby.</dd> + <dt>{{jsxref("Math.tan()")}}</dt> + <dd>zwraca tangens danej liczby.</dd> +</dl> diff --git a/files/pl/web/javascript/reference/global_objects/math/ln10/index.html b/files/pl/web/javascript/reference/global_objects/math/ln10/index.html new file mode 100644 index 0000000000..a7123ea09a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/ln10/index.html @@ -0,0 +1,43 @@ +--- +title: Math.LN10 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN10 +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10 +original_slug: Web/JavaScript/Referencje/Obiekty/Math/LN10 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Logarytm naturalny liczby 10, w przybliżeniu 2.302.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2.302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>LN10</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.LN10</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_LN10" name="Przyk.C5.82ad:_Zastosowanie_LN10">Przykład: Zastosowanie <code>Math.LN10</code></h3> + +<p>Poniższa funkcja zwraca logarytm naturalny liczby 10:</p> + +<pre class="brush:js language-js">function getNatLog10() { + return Math.LN10; +} + +getNatLog10(); <code class="language-js"><span class="token comment">// 2.302585092994046</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/ln2/index.html b/files/pl/web/javascript/reference/global_objects/math/ln2/index.html new file mode 100644 index 0000000000..58d20c3e2c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/ln2/index.html @@ -0,0 +1,41 @@ +--- +title: Math.LN2 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN2 +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2 +original_slug: Web/JavaScript/Referencje/Obiekty/Math/LN2 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Logarytm naturalny liczby 2, w przybliżeniu 0.693</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0.693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693</annotation></semantics></math></p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>LN2</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.LN2</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_LN2" name="Przyk.C5.82ad:_Zastosowanie_LN2">Przykład: Zastosowanie <code>Math.LN2</code></h3> + +<p>Poniższa funkcja zwraca logarytm naturalny liczby 2:</p> + +<pre class="brush:js language-js">function getNatLog2() { + return Math.LN2; +} + +getNatLog2(); <code class="language-js"><span class="token comment">// 0.6931471805599453</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/log/index.html b/files/pl/web/javascript/reference/global_objects/math/log/index.html new file mode 100644 index 0000000000..a037a745d4 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/log/index.html @@ -0,0 +1,55 @@ +--- +title: Math.log() +slug: Web/JavaScript/Reference/Global_Objects/Math/log +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log +original_slug: Web/JavaScript/Referencje/Obiekty/Math/log +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca logarytm naturalny (o podstawie {{jsxref("Math.E", "e")}}) z danej liczby.</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.log(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli wartość liczby <code>x</code> jest ujemna, zwracaną wartością jest zawsze {{jsxref("NaN")}}.</p> + +<p>Ponieważ <code>log()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.log()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.log" name="Przyk.C5.82ad:_Zastosowanie_Math.log">Przykład: Zastosowanie <code>Math.log()</code></h3> + +<p> </p> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // NaN, out of range +</span>Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -Infinity +</span>Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token number">10</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 2.302585092994046</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/log10e/index.html b/files/pl/web/javascript/reference/global_objects/math/log10e/index.html new file mode 100644 index 0000000000..19872df5f6 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/log10e/index.html @@ -0,0 +1,45 @@ +--- +title: Math.LOG10E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +original_slug: Web/JavaScript/Referencje/Obiekty/Math/LOG10E +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Logarytm o podstawie 10 z E, w przybliżeniu 0.434.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0.434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="sect1"> </h2> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Ponieważ <code>LOG10E</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.LOG10E</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_LOG10E" name="Przyk.C5.82ad:_Zastosowanie_LOG10E">Przykład: Zastosowanie <code>Math.LOG10E</code></h3> + +<p>Poniższa funkcja zwraca logarytm o podstawie 10 z E:</p> + +<pre class="brush:js language-js">function getLog10e() { + return Math.LOG10E; +} + +getLog10e();<code class="language-js"><span class="token comment"> // 0.4342944819032518</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/log2e/index.html b/files/pl/web/javascript/reference/global_objects/math/log2e/index.html new file mode 100644 index 0000000000..aca585cea3 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/log2e/index.html @@ -0,0 +1,43 @@ +--- +title: Math.LOG2E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +original_slug: Web/JavaScript/Referencje/Obiekty/Math/LOG2E +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Logarytm o podstawie 2 z E, w przybliżeniu 1.442.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1.442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>LOG2E</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.LOG2E</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_LOG2E" name="Przyk.C5.82ad:_Zastosowanie_LOG2E">Przykład: Zastosowanie <code>Math.LOG2E</code></h3> + +<p>Poniższa funkcja zwraca logarytm o podstawie 2 z E:</p> + +<pre class="brush: js language-js">function getLog2e() { + return Math.LOG2E; +} + +getLog2e(); <code class="language-js"><span class="token comment">// 1.4426950408889634</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/max/index.html b/files/pl/web/javascript/reference/global_objects/math/max/index.html new file mode 100644 index 0000000000..ef23c6a7d8 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/max/index.html @@ -0,0 +1,44 @@ +--- +title: Math.max() +slug: Web/JavaScript/Reference/Global_Objects/Math/max +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/max +original_slug: Web/JavaScript/Referencje/Obiekty/Math/max +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca największą z podanych liczb.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code>Math.max([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>value1, value2, ...</code></dt> + <dd>liczby.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>max</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez Math.max(), a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.max" name="Przyk.C5.82ad:_Zastosowanie_Math.max">Przykład: Zastosowanie <code>Math.max()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="punctuation token">.</span><span class="function token">max<span class="punctuation token">(</span></span><span class="number token">10</span><span class="punctuation token">,</span> <span class="number token">20</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token"> // 20 +</span>Math<span class="punctuation token">.</span><span class="function token">max<span class="punctuation token">(</span></span><span class="operator token">-</span><span class="number token">10</span><span class="punctuation token">,</span> <span class="operator token">-</span><span class="number token">20</span><span class="punctuation token">)</span><span class="punctuation token">;</span><span class="comment token"> // -10 +</span>Math<span class="punctuation token">.</span><span class="function token">max<span class="punctuation token">(</span></span><span class="operator token">-</span><span class="number token">10</span><span class="punctuation token">,</span> <span class="number token">20</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token"> // 20</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.min()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/min/index.html b/files/pl/web/javascript/reference/global_objects/math/min/index.html new file mode 100644 index 0000000000..2994b7e363 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/min/index.html @@ -0,0 +1,45 @@ +--- +title: Math.min() +slug: Web/JavaScript/Reference/Global_Objects/Math/min +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/min +original_slug: Web/JavaScript/Referencje/Obiekty/Math/min +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca najmniejszą z podanych liczb.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.min([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>value1, value2, ...</code></dt> + <dd>liczby.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Ponieważ <code>min</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.min()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Przykład_Zastosowanie_Math.min()">Przykład: Zastosowanie <code>Math.min()</code></h3> + +<p>Poniższa funkcja porównuje zmienne <code>x</code> and <code>y</code> i zwraca mniejszą <code>z</code> nich:</p> + +<pre class="brush: js language-js"><code class="language-js">var x = 10, y = -20; +var z = Math.min(x, y);</code></pre> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.max()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/pi/index.html b/files/pl/web/javascript/reference/global_objects/math/pi/index.html new file mode 100644 index 0000000000..f4c7c2c91e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/pi/index.html @@ -0,0 +1,41 @@ +--- +title: Math.PI +slug: Web/JavaScript/Reference/Global_Objects/Math/PI +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI +original_slug: Web/JavaScript/Referencje/Obiekty/Math/PI +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Stosunek obwodu okręgu do jego średnicy, w przybliżeniu 3.14159.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3.14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3.14159</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>PI</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.PI</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_PI" name="Przyk.C5.82ad:_Zastosowanie_PI">Przykład: Zastosowanie <code>Math.PI</code></h4> + +<p>Poniższa funkcja zwraca wartość pi:</p> + +<pre class="brush: js language-js">function getPi() { + return Math.PI; +} + +<code class="language-js"><span class="token function">calculateCircumference<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 6.283185307179586</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/Math", "Math")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/pow/index.html b/files/pl/web/javascript/reference/global_objects/math/pow/index.html new file mode 100644 index 0000000000..82b449f8d2 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/pow/index.html @@ -0,0 +1,50 @@ +--- +title: Math.pow() +slug: Web/JavaScript/Reference/Global_Objects/Math/pow +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow +original_slug: Web/JavaScript/Referencje/Obiekty/Math/pow +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca liczbę <code>podstawa</code> podniesioną do potęgi o wykładniku <code>wykładnik</code>, tj. <code>podstawa<sup>wykładnik</sup></code>.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code>Math.pow(podstawa, wykładnik)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>podstawa</code> </dt> + <dd>liczba podnoszona do potęgi.</dd> +</dl> + +<dl> + <dt><code>wykładnik</code> </dt> + <dd>wykładnik potęgi, do której podnoszona jest liczba <code>podstawa</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>pow</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.pow()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.pow" name="Przyk.C5.82ad:_Zastosowanie_Math.pow">Przykład: Zastosowanie <code>Math.pow()</code></h3> + +<pre class="brush: js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">pow<span class="token punctuation">(</span></span><span class="token number">7</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 49</span></code></pre> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.cbrt()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/random/index.html b/files/pl/web/javascript/reference/global_objects/math/random/index.html new file mode 100644 index 0000000000..fd68b5ea29 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/random/index.html @@ -0,0 +1,68 @@ +--- +title: Math.random() +slug: Web/JavaScript/Reference/Global_Objects/Math/random +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/random +original_slug: Web/JavaScript/Referencje/Obiekty/Math/random +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca pseudolosową, zmiennoprzecinkową liczbę z przedziału <code>[0, 1)</code> ( jedynka nie należy do przedziału). Podstawą generatora liczb losowych (ang.<em> seed</em> ) jest aktualny czas, tak samo jak w języku Java. Ponieważ <code>random</code> jest statyczną metodą obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.random()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<div class="note"> +<p><strong>Notatka:</strong> <code>Math.random()</code> <strong>nie zapewnia</strong><span class="tlid-translation translation"><span title=""> kryptograficznie bezpiecznych liczb losowych.</span></span> <span class="tlid-translation translation"><span title="">Nie używaj ich do niczego związanego z bezpieczeństwem (np. generowanie haseł).</span></span> <span class="tlid-translation translation"><span title="">Zamiast tego użyj Web Crypto API, a dokładniej:</span></span> metodę {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.</p> +</div> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.random()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p><span class="tlid-translation translation"><span title="">Liczba pseudolosowa, zmiennoprzecinkowa zawarta w przedziale <code>[0, 1)</code> (od 0 (włącznie) do 1 (wykluczając 1)).</span></span></p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad_Zastosowanie_Math.random" name="Przyk.C5.82ad:_Zastosowanie_Math.random">Zastosowanie <code>Math.random()</code></h3> + +<p>Zwraca losową liczbę większą lub równą 0 i mniejszą od 1.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> getRandom<span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></pre> + +<h3 id="Uzyskanie_losowej_liczby_między_dwiema_wartościami"><span class="tlid-translation translation"><span title="">Uzyskanie losowej liczby między dwiema wartościami</span></span></h3> + +<p><span class="tlid-translation translation"><span title="">Ten przykład zwraca losową liczbę znajdującą się pomiędzy określonymi wartościami.</span> <span title="">Zwrócona wartość jest większa lub równa <code>min</code>, i jest mniejsza niż <code>max</code>.</span></span></p> + +<pre><code class="language-js"><span class="keyword token">function</span> <span class="function token">getRandomInt</span><span class="punctuation token">(</span>min<span class="punctuation token">,</span> max<span class="punctuation token">)</span> <span class="punctuation token">{</span> + min <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">ceil</span><span class="punctuation token">(</span>min<span class="punctuation token">)</span><span class="punctuation token">;</span> + max <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>max<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">*</span> <span class="punctuation token">(</span>max <span class="operator token">-</span> min<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">+</span> min<span class="punctuation token">;</span> +<span class="punctuation token">}</span></code> +</pre> + +<h3 id="Uzyskanie_losowej_liczby_między_dwiema_wartościami_z_przedziału_min_max_max_włącznie"><span class="tlid-translation translation"><span title="">Uzyskanie losowej liczby między dwiema wartościami z przedziału <code>[min, max]</code> (<code>max</code> włącznie)</span></span></h3> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">getRandomIntInclusive</span><span class="punctuation token">(</span>min<span class="punctuation token">,</span> max<span class="punctuation token">)</span> <span class="punctuation token">{</span> + min <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">ceil</span><span class="punctuation token">(</span>min<span class="punctuation token">)</span><span class="punctuation token">;</span> + max <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>max<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">*</span> <span class="punctuation token">(</span>max <span class="operator token">-</span> min <span class="operator token">+</span> <span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">+</span> min<span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></pre> + +<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> + +<p>{{Compat("javascript.builtins.Math.random")}}</p> diff --git a/files/pl/web/javascript/reference/global_objects/math/round/index.html b/files/pl/web/javascript/reference/global_objects/math/round/index.html new file mode 100644 index 0000000000..01aabb9aa1 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/round/index.html @@ -0,0 +1,51 @@ +--- +title: Math.round() +slug: Web/JavaScript/Reference/Global_Objects/Math/round +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/round +original_slug: Web/JavaScript/Referencje/Obiekty/Math/round +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca daną liczbę zaokrągloną do najbliższej liczby całkowitej.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.round(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli część ułamkowa liczby <code>x</code> wynosi 0.5 lub więcej, argument jest zaokrąglany do najbliższej większej liczby całkowitej. Jeśli część ułamkowa liczby <code>x</code> jest mniejsza niż 0.5, argument jest zaokrąglany do najbliższej mniejszej liczby całkowitej.</p> + +<p>Ponieważ <code>round</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.round()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.round" name="Przyk.C5.82ad:_Zastosowanie_Math.round">Przykład: Zastosowanie <code>Math.round()</code></h3> + +<pre class="brush: js">// zwraca 20 +x = Math.round(20.49) + +// zwraca 21 +x = Math.round(20.5) + +// zwraca -20 +x = Math.round(-20.5) + +// zwraca -21 +x = Math.round(-20.51) +</pre> + +<p> </p> diff --git a/files/pl/web/javascript/reference/global_objects/math/sign/index.html b/files/pl/web/javascript/reference/global_objects/math/sign/index.html new file mode 100644 index 0000000000..bd919f950a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/sign/index.html @@ -0,0 +1,119 @@ +--- +title: Math.sign() +slug: Web/JavaScript/Reference/Global_Objects/Math/sign +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign +original_slug: Web/JavaScript/Referencje/Obiekty/Math/sign +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Podsumowanie</h2> + +<p>Funkcja<strong style="font-weight: bold;"> </strong><code><strong>Math.sign() </strong></code>zwraca znak liczby. Wynik wskazuje czy liczba przekazana jako argument jest dodatnia, ujemna lub czy jest zerem.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox"><code>Math.sign(<em>x</em>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Liczba, której znak ma zostać określony.</dd> +</dl> + +<h2 id="Description" name="Description">Opis</h2> + +<p>Metoda <code>sign</code> powinna być zawsze używana jako <code>Math.sign()</code>, ponieważ jest metodą statyczną w obiekcie <code>Math</code>. (Nie jako metoda stworzonego obiektu (<code>Math</code> nie jest konstruktorem)).</p> + +<p>Funkcja ma pięć wartości wynikowych <code>1, -1, 0, -0, NaN,</code> które reprezentują odpowiednio: "liczbę dodatnią", "liczbę ujemną", "zero "dodatnie"", <span style="line-height: 1.572;"> "zero "ujemne"" </span><span style="line-height: 1.572;">oraz NaN (parametr nie jest liczbą).</span></p> + +<p>Argument funkcji jest domyślnie konwertowany do <code>number</code>.</p> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<h3 id="Example:_Using_Math.log" name="Example:_Using_Math.log">Przykład: Użycie <code>Math.sign</code></h3> + +<pre class="brush:js">Math.sign(3) // 1 +Math.sign(-3) // -1 +Math.sign("-3") // -1 +Math.sign(0) // 0 +Math.sign(-0) // -0 +Math.sign(NaN) // NaN +Math.sign("foo") // NaN +Math.sign() // NaN +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sign', 'Math.sign')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Tabela_zgodności_przeglądarek">Tabela zgodności przeglądarek</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>{{CompatNo}}</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</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>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Zobacz również</h2> + +<ul> + <li>Obiekt {{jsxref("Math")}}, który definiuje tą funkcję.</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/sin/index.html b/files/pl/web/javascript/reference/global_objects/math/sin/index.html new file mode 100644 index 0000000000..b61ffd0560 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/sin/index.html @@ -0,0 +1,52 @@ +--- +title: Math.sin() +slug: Web/JavaScript/Reference/Global_Objects/Math/sin +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin +original_slug: Web/JavaScript/Referencje/Obiekty/Math/sin +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca sinus danej liczby.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.sin(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>sin</code> zwraca wartość numeryczną większą lub równą -1 i mniejszą lub równą 1, stanowiącą sinus argumentu.</p> + +<p>Ponieważ <code>sin</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.sin()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.sin" name="Przyk.C5.82ad:_Zastosowanie_Math.sin">Przykład: Zastosowanie <code>Math.sin()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">sin<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">sin<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0.8414709848078965 +</span> +Math<span class="token punctuation">.</span><span class="token function">sin<span class="token punctuation">(</span></span>Math<span class="token punctuation">.</span>PI <span class="token operator">/</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/sqrt/index.html b/files/pl/web/javascript/reference/global_objects/math/sqrt/index.html new file mode 100644 index 0000000000..4622fd2620 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/sqrt/index.html @@ -0,0 +1,47 @@ +--- +title: Math.sqrt() +slug: Web/JavaScript/Reference/Global_Objects/Math/sqrt +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt +original_slug: Web/JavaScript/Referencje/Obiekty/Math/sqrt +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca pierwiastek kwadratowy danej liczby.</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>s</mi><mi>q</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mi>x</mi></msqrt><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.sqrt(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli wartość <code>x</code> jest ujemna, funkcja <code>sqrt</code> zwraca {{jsxref("NaN")}}.</p> + +<p>Ponieważ <code>sqrt()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.sqrt()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.sqrt" name="Przyk.C5.82ad:_Zastosowanie_Math.sqrt">Przykład: Zastosowanie <code>Math.sqrt()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">9</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 3 +</span>Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.414213562373095 +</span> +Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1 +</span>Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // NaN</span></code></pre> + +<p> </p> diff --git a/files/pl/web/javascript/reference/global_objects/math/sqrt1_2/index.html b/files/pl/web/javascript/reference/global_objects/math/sqrt1_2/index.html new file mode 100644 index 0000000000..1c1215f5b7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/sqrt1_2/index.html @@ -0,0 +1,40 @@ +--- +title: Math.SQRT1 2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +original_slug: Web/JavaScript/Referencje/Obiekty/Math/SQRT1_2 +--- +<p>{{jsref}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Pierwiastek kwadratowy z liczby 1/2, albo, inaczej mówiąc, odwrotność pierwiastka kwadratowego z liczby 2, w przybliżeniu 0.707.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0.707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707</annotation></semantics></math></p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>SQRT1_2</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.SQRT1_2</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_SQRT1_2" name="Przyk.C5.82ad:_Zastosowanie_SQRT1_2">Przykład: Zastosowanie <code>Math.SQRT1_2</code></h3> + +<p>Poniższa funkcja zwraca pierwiastek kwadratowy z 1/2:</p> + +<pre class="brush:js language-js">function getRoot1_2() { + return Math.SQRT1_2 +} + +<code class="language-js"><span class="token function">getRoot1_2<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.7071067811865476</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/sqrt2/index.html b/files/pl/web/javascript/reference/global_objects/math/sqrt2/index.html new file mode 100644 index 0000000000..4fca0036ce --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/sqrt2/index.html @@ -0,0 +1,42 @@ +--- +title: Math.SQRT2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +original_slug: Web/JavaScript/Referencje/Obiekty/Math/SQRT2 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Pierwiastek kwadratowy z liczby 2, w przybliżeniu 1.414.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1.414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>SQRT2</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez {{jsxref("Math")}}<code>.SQRT2</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_SQRT2" name="Przyk.C5.82ad:_Zastosowanie_SQRT2">Przykład: Zastosowanie <code>Math.SQRT2</code></h3> + +<p>Poniższa funkcja zwraca pierwiastek kwadratowy z liczby 2:</p> + +<pre class="brush: js language-js">function getRoot2() { + return Math.SQRT2; +} + +<code class="language-js"><span class="token function">getRoot2<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.4142135623730951</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/math/tan/index.html b/files/pl/web/javascript/reference/global_objects/math/tan/index.html new file mode 100644 index 0000000000..adede7c207 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/math/tan/index.html @@ -0,0 +1,54 @@ +--- +title: Math.tan() +slug: Web/JavaScript/Reference/Global_Objects/Math/tan +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan +original_slug: Web/JavaScript/Referencje/Obiekty/Math/tan +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca tangens danej liczby.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.tan(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>tan</code> zwraca wartość numeryczną reprezentującą tangens kąta.</p> + +<p>Ponieważ <code>tan()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.tan()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_Math.tan" name="Przyk.C5.82ad:_Zastosowanie_Math.tan">Przykład: Zastosowanie <code>Math.tan()</code></h4> + +<p>Poniższa funkcja zwraca tangens zmiennej <code>x</code>:</p> + +<pre class="brush: js">function getTan(x) { + return Math.tan(x) +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/nan/index.html b/files/pl/web/javascript/reference/global_objects/nan/index.html new file mode 100644 index 0000000000..22a87a7002 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/nan/index.html @@ -0,0 +1,46 @@ +--- +title: NaN +slug: Web/JavaScript/Reference/Global_Objects/NaN +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/NaN +original_slug: Web/JavaScript/Referencje/Obiekty/NaN +--- +<div> +<div> +<div>{{jsSidebar("Obiekty")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość reprezentująca + <i>Not-A-Number</i> + , tj. nie będąca liczbą.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>NaN</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>NaN</code> jest własnością najwyższego rzędu i nie jest powiązana z żadnym obiektem.</p> + +<p>Wartością początkową <code>NaN</code> jest <code>NaN</code>.</p> + +<p><code>NaN</code> nigdy nie jest równa innej liczbie, nie jest równa nawet samej sobie. Nie jest możliwe sprawdzenie, czy dana wartość jest NaN przez porównanie z {{jsxref("Number.NaN")}} – należy zamiast tego stosować funkcję {{jsxref("Obiekty.isNaN", "isNaN()")}}.</p> + +<p>Wiele metod języka JavaScript (m. in. konstruktor <code>Number</code>, <code>parseFloat</code> i <code>parseInt</code>) zwracają <code>NaN</code>, jeśli wartość ich parametrów nie jest liczbą lub nie daje się na liczbę skonwertować.</p> + +<p><code>NaN</code> można zastosować do zasygnalizowania błędu w funkcji, która zazwyczaj zwraca poprawną liczbę.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.NaN")}}</li> + <li>{{jsxref("Number.isNaN()")}}</li> + <li>{{jsxref("Obiekty.isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/null/index.html b/files/pl/web/javascript/reference/global_objects/null/index.html new file mode 100644 index 0000000000..bfe3ad5a72 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/null/index.html @@ -0,0 +1,135 @@ +--- +title: 'null' +slug: Web/JavaScript/Reference/Global_Objects/null +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/null +original_slug: Web/JavaScript/Referencje/Obiekty/null +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Wartość <code>null</code> reprezentuje zamierzony brak wartości jakiegoś obiektu. Jest jedną z {{Glossary("Primitive", "podstawowych wartości")}} w JavaSript.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>null </code></pre> + +<h2 id="Opis">Opis</h2> + +<p>Wartość <code>null</code>, jak podpowiada nazwa, zapisujemy używając słowa "<code>null</code>". <code>null</code> nie jest zmienną globalną, w przeciwieństwie do {{jsxref("Global_Objects/undefined","undefined")}}. Zamiast tego <code>null</code> wyraża brak identyfikacji, mówiąc nam, że zmienna nie wskazuje na obiekt. W wielu API <code>null</code> jest często zwracany tam, gdzie może być obiekt, ale aktualnie jeszcze go tam nie ma.</p> + +<pre class="brush: js">// foo nie istnieje. Nie jest zdefiniowany oraz nigdy nie był zainicjalizowany: +> foo +"ReferenceError: foo is not defined" + +// Teraz wiadomo że null istnieje, ale nie ma on żadnego typu ani wartości: +> var foo = null; foo; +"null" +</pre> + +<h3 id="Różnice_pomiędzy_null_i_undefined">Różnice pomiędzy <code>null</code> i <code>undefined</code></h3> + +<p>Podczas sprawdzania <code>null</code> lub <font face="Consolas, Liberation Mono, Courier, monospace">undefined</font>, uważaj na <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_porównania">róźnice pomiędzy operatorami równości (==) oraz identyczności (===)</a>, ponieważ ten pierwszy wykonuje konwersję typu.</p> + +<pre class="brush: js">typeof null // "object" (nie jest to "null" ze względu na starsze przyczyny) +typeof undefined // "undefined" +null === undefined // false +null == undefined // true +null === null // true +null == null // true +!null // true +isNaN(1 + null) // false +isNaN(1 + undefined) // true</pre> + +<p> </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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-4.3.11', 'null value')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-null-value', 'null value')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-null-value', 'null value')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2> + +<p>{{CompatibilityTable}}</p> + +<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_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("undefined")}}</li> + <li>{{jsxref("NaN")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/epsilon/index.html b/files/pl/web/javascript/reference/global_objects/number/epsilon/index.html new file mode 100644 index 0000000000..09ea32708c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/epsilon/index.html @@ -0,0 +1,77 @@ +--- +title: Number.EPSILON +slug: Web/JavaScript/Reference/Global_Objects/Number/EPSILON +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Właściwość +translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON +original_slug: Web/JavaScript/Referencje/Obiekty/Number/EPSILON +--- +<div>{{JSRef}}</div> + +<p>Właściwość <strong><code>Number.EPSILON</code></strong> reprezentuje różnicę pomiędzy 1 a najmniejszą liczbą zmiennoprzecinkową większą niż 1.</p> + +<p>Jest to właściwość statyczna. Nie musisz tworzyć obiektu {{jsxref("Number")}}, żeby mieć do niej dostęp (użyj <code>Number.EPSILON</code>).</p> + +<div>{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis">Opis</h2> + +<p>Wartość właściwości <code>EPSILON</code> to w przybliżeniu <code>2.2204460492503130808472633361816E-16</code> lub <code>2<sup>-52</sup></code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Testowanie_równości">Testowanie równości</h3> + +<pre class="brush: js">x = 0.2; +y = 0.3; +z = 0.1; +equal = (Math.abs(x - y + z) < Number.EPSILON); +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (Number.EPSILON === undefined) { + Number.EPSILON = Math.pow(2, -52); +} +</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('ES2015', '#sec-number.epsilon', 'Number.EPSILON')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.EPSILON")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Number")}} obiekt, do którego należy ta właściwość.</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/index.html b/files/pl/web/javascript/reference/global_objects/number/index.html new file mode 100644 index 0000000000..57d2491e77 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/index.html @@ -0,0 +1,112 @@ +--- +title: Number +slug: Web/JavaScript/Reference/Global_Objects/Number +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Number +original_slug: Web/JavaScript/Referencje/Obiekty/Number +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Pozwala pracować z wartościami liczbowymi. Obiekt <code>Number</code> jest opakowaniem (ang.<em>wrapper</em> ) dla prymitywnych wartości numerycznych.</p> + +<h2 id="Tworzone_przez" name="Tworzone_przez">Tworzone przez</h2> + +<p>Konstruktor <code>Number</code>:</p> + +<pre class="syntaxbox">new Number(value);</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>value</code> </dt> + <dd>Wartość numeryczna tworzonego obiektu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt <code>Number</code> jest głównie stosowany do:</p> + +<ul> + <li>Uzyskania dostępu do jego stałych własnościach, które reprezentują najmniejszą i największa możliwą (przestawialną) liczbę, dodatnią lub ujemną nieskończoność i wartość nieliczbową (<em>Not-a-Number</em> ).</li> +</ul> + +<ul> + <li>Aby stworzyć obiekty liczbowe do których możesz dodać własności. Najprawdopodobniej rzadko, kiedy będziesz musiał stworzyć obiekt typu <code>Number</code>.</li> +</ul> + +<p>Własności <code>Number</code> są własnościami jego klasy, nieindywidualnymi własnościami obiektu.</p> + +<p><strong>JavaScript 1.2</strong>: <code>Number(x)</code> teraz tworzy raczej <code>NaN</code> niż błąd jeśli <code>x</code> jest ciągiem znaków, który nie zawiera poprawnie sformatowanej liczby. Na przykład, poniższy kod drukuje <code>NaN</code>:</p> + +<pre class="brush: js">var x = Number("three"); +document.write(x + "<BR>"); +</pre> + +<p>Możesz przekonwertować, każdy obiekt na liczbę używając funkcji wysokiego poziomu <code>Number</code>.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("Number.constructor")}}</dt> + <dd>Oznacza funkcję, która tworzy prototyp obiektu.</dd> + <dt>{{jsxref("Number.MAX_VALUE")}}</dt> + <dd>Największa możliwa do przedstawienia liczba.</dd> + <dt>{{jsxref("Number.MIN_VALUE")}}</dt> + <dd>Najmniejsza możliwa do przedstawienia liczba.</dd> + <dt>{{jsxref("Number.NaN")}}</dt> + <dd>Specjalna wartość "nie jest liczbą" (Not-a-Number).</dd> + <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt> + <dd>Specjalna wartość reprezentująca negatywną nieskończoność; zwracana przy przepełnieniu.</dd> + <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt> + <dd>Specjalna wartość reprezentująca nieskończoność; zwracana przy przepełnieniu.</dd> + <dt>{{jsxref("Number.prototype")}}</dt> + <dd>Pozwala na dodawanie (tworzenie) nowych własności obiektu <code>Number</code>.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<p><strong>{{jsxref("Number.isInteger()")}}</strong></p> + +<p> Sprawdza czy liczba jest całkowita.</p> + +<dl> + <dt>{{jsxref("Number.toExponential()")}}</dt> + <dd>Zwraca ciąg znaków, reprezentujący liczbę zapisaną w postaci wykładniczej.</dd> + <dt>{{jsxref("Number.toFixed()")}}</dt> + <dd>Zwraca ciąg znaków, reprezentujący liczbę stałoprzecinkową.</dd> + <dt>{{jsxref("Number.toLocaleString()")}}</dt> + <dd>Zwraca czytelny dla ludzi ciąg znaków reprezentujący liczbę zapisaną przy wykorzystaniu lokalnego formatu zapisu liczb. Przesłania metodę {{jsxref("Object.toLocaleString()")}}.</dd> + <dt>{{jsxref("Number.toPrecision()")}}</dt> + <dd>Zwraca ciąg znaków reprezentujący liczbę stałoprzecinkową o podanej precyzji.</dd> + <dt>{{jsxref("Number.toSource()")}}</dt> + <dd>Zwraca literał obiektu reprezentujący podany obiekt <code>Number</code>; możesz użyć tą wartość, przy tworzeniu nowego obiektu. Przesłania metodę {{jsxref("Object.toSource()")}}.</dd> + <dt>{{jsxref("Number.toString()")}}</dt> + <dd>Zwraca ciąg znaków reprezentujący podany obiekt. Przesłania metodę {{jsxref("Object.toString()")}}.</dd> + <dt>{{jsxref("Number.valueOf()")}}</dt> + <dd>Zwraca zmienną typu prostego reprezentującą wartość podanego obiektu. Przesłania metodę {{jsxref("Object.valueOf()")}}.</dd> +</dl> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_obiektu_Number.2C_przy_przypisaniu_warto.C5.9Bci_zmiennym_liczbowym" name="Przyk.C5.82ad:_Zastosowanie_obiektu_Number.2C_przy_przypisaniu_warto.C5.9Bci_zmiennym_liczbowym">Przykład: Zastosowanie obiektu <code>Number</code>, przy przypisaniu wartości zmiennym liczbowym</h3> + +<p>Poniższy przykład używa własności obiektu <code>Number</code>, aby przypisać wartości do kilku wartości numerycznych:</p> + +<pre class="brush: js">var najwiekszaLiczba = Number.MAX_VALUE; +var najmniejszaLiczba = Number.MIN_VALUE; +var nieskonczonosc = Number.POSITIVE_INFINITY; +var negatywnaNieskonczonosc = Number.NEGATIVE_INFINITY; +var nieJestLiczba = Number.NaN; +</pre> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_obiektu_Number_do_modyfikacji_wszystkich_obiekt.C3.B3w_Number" name="Przyk.C5.82ad:_Zastosowanie_obiektu_Number_do_modyfikacji_wszystkich_obiekt.C3.B3w_Number">Przykład: Zastosowanie obiektu <code>Number</code> do modyfikacji wszystkich obiektów <code>Number</code></h3> + +<p>Poniższy przykład tworzy obiekt typu <code>Number</code>, <code>.mojaLiczba</code>, wtedy dodaje własność <code>opis</code>, wszystkim obiektom <code>Number</code>. Następnie wartość jest przypisana do własności <code>opis</code> obiektu <code>mojaLiczba</code>.</p> + +<pre class="brush: js">var mojaLiczba = new Number(65); +Number.prototype.opis = null; +var mojaLiczba.opis = "prędkość wiatru"; +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/number/isinteger/index.html b/files/pl/web/javascript/reference/global_objects/number/isinteger/index.html new file mode 100644 index 0000000000..5e11d160c8 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/isinteger/index.html @@ -0,0 +1,89 @@ +--- +title: Number.isInteger() +slug: Web/JavaScript/Reference/Global_Objects/Number/isInteger +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger +original_slug: Web/JavaScript/Referencje/Obiekty/Number/isInteger +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>Number.isInteger()</code></strong> sprawdza czy wpisana wartość jest liczbą całkowitą.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Number.isInteger(v<var>alue</var>)</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>zmienna</code></dt> + <dd>Zmienna będzie testowana jako liczba.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Metoda zwraca wartość typu {{jsxref("Boolean")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>Jeśli sprawdzana zmienna jest liczbą całkowitą metoda zwraca <code>true</code>, w innym przypadku zwraca <code>false</code>. Jeśli zmienna jest typu {{jsxref("NaN")}} lub spoza zakresu metoda zwraca <code>false</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">Number.isInteger(0); // true +Number.isInteger(1); // true +Number.isInteger(-100000); // true + +Number.isInteger(0.1); // false +Number.isInteger(Math.PI); // false + +Number.isInteger(NaN); // false +Number.isInteger(Infinity); // false +Number.isInteger(-Infinity); // false +Number.isInteger('10'); // false +Number.isInteger(true); // false +Number.isInteger(false); // false +Number.isInteger([1]); // false +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) { + return typeof value === 'number' && + isFinite(value) && + Math.floor(value) === value; +}; +</pre> + +<h2 id="Dokumentacja">Dokumentacja</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('ES6', '#sec-number.isinteger', 'Number.isInteger')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilne_przegladarki">Kompatybilne przegladarki</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.isInteger")}}</p> + +<h2 id="Sprawdź_również">Sprawdź również</h2> + +<ul> + <li>Metoda ta należy do klasy {{jsxref("Number")}}.</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/isnan/index.html b/files/pl/web/javascript/reference/global_objects/number/isnan/index.html new file mode 100644 index 0000000000..41486c7204 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/isnan/index.html @@ -0,0 +1,109 @@ +--- +title: Number.isNaN() +slug: Web/JavaScript/Reference/Global_Objects/Number/isNaN +tags: + - ECMAScript 2015 + - JavaScript + - Metodă + - NaN + - Number + - isNaN +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN +original_slug: Web/JavaScript/Referencje/Obiekty/Number/isNaN +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>Number.isNaN()</code></strong> określa czy podany parametr ma wartość {{jsxref("NaN")}} i czy jest typu {{jsxref("Number")}}. Jest to ulepszona wersja oryginalnej, globalne funkcji {{jsxref("isNaN", "isNaN()")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-isnan.html", "taller")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Number.isNaN(<var>value</var>)</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>value</var></code></dt> + <dd>Wartość, którą będziemy testować {{jsxref("NaN")}}.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p><strong>true</strong>, jeśli podana wartość jest {{jsxref("NaN")}}, a jej typem jest {{jsxref("Number")}}; w przeciwnym razie, <strong>false</strong>.</p> + +<h2 id="Opis">Opis</h2> + +<p>Ponieważ oba operatory porównania, {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} i {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}, dla zapytania czy {{jsxref("NaN")}} <em>jest równe</em> {{jsxref("NaN")}} zwracają <code>false</code> funkcja <code>Number.isNaN()</code> staje się niezbędna. Jest sytuacja wyjątkowa i nie występuje, gdy porównujemy dowolne inne wartości w języku JavaScript.</p> + +<p>W porównaniu do funkcji globalnej {{jsxref("isNaN", "isNaN()")}}, metoda <code>Number.isNaN()</code> nie ma problemu z usilnym konwertowaniem parametru na liczbę. To oznacza, że można bezpiecznie przekazywać wartości, które normalnie mogłyby zostać skonwertowane na {{jsxref("NaN")}}, ale nie mają tej samej wartości co {{jsxref("NaN")}}. To również oznacza, że jedynie wartości typu {{jsxref("Number")}}, które są również {{jsxref("NaN")}}, zwrócą <code>true</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">Number.isNaN(NaN); // true +Number.isNaN(Number.NaN); // true +Number.isNaN(0 / 0); // true + +// Gdybyśmy użyli funkcji isNaN(), te przykłady zwróciłby true +Number.isNaN('NaN'); // false +Number.isNaN(undefined); // false +Number.isNaN({}); // false +Number.isNaN('blabla'); // false + +// Wszystkie zwracają false +Number.isNaN(true); +Number.isNaN(null); +Number.isNaN(37); +Number.isNaN('37'); +Number.isNaN('37.37'); +Number.isNaN(''); +Number.isNaN(' '); +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Następujący przykład działa, ponieważ {{jsxref("NaN")}} jest jedyną wartością w języku JavaScript, która nie jest równa samej sobie.</p> + +<pre class="brush: js">Number.isNaN = Number.isNaN || function(value) { + return value !== null && (value != value || +value != value); +} +</pre> + +<h2 id="Opis_2">Opis</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isnan', 'Number.isnan')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.isnan', 'Number.isnan')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + + + +<div>{{Compat("javascript.builtins.Number.isNaN")}}</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/max_value/index.html b/files/pl/web/javascript/reference/global_objects/number/max_value/index.html new file mode 100644 index 0000000000..9013774586 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/max_value/index.html @@ -0,0 +1,36 @@ +--- +title: Number.MAX_VALUE +slug: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE +original_slug: Web/JavaScript/Referencje/Obiekty/Number/MAX_VALUE +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Największa liczba, której reprezentacja jest możliwa w języku JavaScript.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Własność <code>MAX_VALUE</code> ma wartość ok. 1.79E+308. Wartości większe niż <code>MAX_VALUE</code> są reprezentowane jako "<code>Infinity</code>" (nieskończoność).</p> + +<p>Ponieważ <code>MAX_VALUE</code> jest statyczną własnością {{jsxref("Number")}}, używa jej się zawsze jako <code>Number.MAX_VALUE</code>, a nie jako własność utworzonego przez programistę obiektu {{jsxref("Number")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h2 id="Przyk.C5.82ad:_Zastosowanie_MAX_VALUE" name="Przyk.C5.82ad:_Zastosowanie_MAX_VALUE">Przykład: Zastosowanie <code>MAX_VALUE</code></h2> + +<p>Poniższy kod mnoży dwie liczby. Jeśli wynik jest większy lub równy <code>MAX_VALUE</code>, wywoływana jest funkcja <code>func1</code>, w przeciwnym wypadku wywoływana jest funkcja <code>func2</code>.</p> + +<pre class="eval">if (num1 * num2 <= Number.MAX_VALUE) { + func1(); +} else { + func2(); +} +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/number/min_value/index.html b/files/pl/web/javascript/reference/global_objects/number/min_value/index.html new file mode 100644 index 0000000000..ca91bc36f9 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/min_value/index.html @@ -0,0 +1,40 @@ +--- +title: Number.MIN VALUE +slug: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE +original_slug: Web/JavaScript/Referencje/Obiekty/Number/MIN_VALUE +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Najmniejsza dodatnia wartość liczbowa, której reprezentacja jest możliwa w języku JavaScript.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Własność <code>MIN_VALUE</code> to najbliższa zeru liczba dodatnia, jakiej reprezentacja jest możliwa w języku JavaScript - nie jest to najmniejsza liczba ujemna.</p> + +<p><code>MIN_VALUE</code> ma wartość ok. 5e-324. Wartości mniejsze niż <code>MIN_VALUE</code> (ang. "underflow values") konwertowane są do 0.</p> + +<p>Ponieważ <code>MIN_VALUE</code> jest statyczną własnością {{jsxref("Number")}}, używa jej się zawsze jako <code>Number.MIN_VALUE</code>, a nie jako własność utworzonego przez programistę obiektu {{jsxref("Number")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_MIN_VALUE" name="Przyk.C5.82ad:_Zastosowanie_MIN_VALUE">Przykład: Zastosowanie <code>Number.MIN_VALUE</code></h3> + +<p>Poniższy kod dzieli jedną liczbę przez drugą. Jeśli wynik jest większy lub równy <code>MIN_VALUE</code>, wywoływana jest funkcja <code>func1</code>, w przeciwnym wypadku wywoływana jest funkcja <code>func2</code>.</p> + +<pre class="brush: js">if (num1 / num2 >= Number.MIN_VALUE) { + func1(); +} else { + func2(); +} +</pre> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/reference/global_objects/number/nan/index.html b/files/pl/web/javascript/reference/global_objects/number/nan/index.html new file mode 100644 index 0000000000..ca26af77cf --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/nan/index.html @@ -0,0 +1,49 @@ +--- +title: Number.NaN +slug: Web/JavaScript/Reference/Global_Objects/Number/NaN +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN +original_slug: Web/JavaScript/Referencje/Obiekty/Number/NaN +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość reprezentująca Not-A-Number (Nie-Liczbę).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością <code>Number.NaN</code> jest Not-A-Number, taką samą jak wartość własności {{jsxref("Obiekty/NaN", "NaN")}} obiektu globalnego.</p> + +<p><span class="comment">Keep text below in sync with Properties:NaN page</span> <code>NaN</code> jest zawsze różna od dowolnej liczby, włączając również <code>NaN</code>; nie możesz sprawdzić wartości nieliczbowej poprzez porównanie do <code>Number.NaN</code>. Użyj zamiast tego funkcji {{jsxref("Obiekty/isNaN", "isNaN()")}}.</p> + +<p>Kilka metod JavaScript (takie jak konstruktor <code>Number</code>, <code>parseFloat</code> i <code>parseInt</code>) zwracają <code>NaN</code>, jeśli wartość określona w parametrze nie może być przetworzona jako liczba.</p> + +<p>Możesz użyć własności <code>NaN</code>, aby wskazać warunek błędu dla Twojej funkcji, która zwraca liczbę w przypadku sukcesu.</p> + +<p>JavaScript wyświetla wartość <code>Number.NaN</code> jako <code>NaN</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_NaN" name="Przyk.C5.82ad:_Zastosowanie_NaN">Przykład: Zastosowanie <code>Number.NaN</code></h3> + +<p>W poniższym przykładzie, jeśli miesiąc (month) jest wartość większą niż 12, zostaje mu przypisane <code>NaN</code> i wyświetlana jest informacja o nieprawidłowych wartościach.</p> + +<pre class="brush: js">var month = 13; +if (month < 1 || month > 12) { + month = Number.NaN; + console.log("Miesiąc musi być liczbą między 1 i 12."); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Obiekty/NaN", "NaN")}}</li> + <li>The {{jsxref("Number")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/negative_infinity/index.html b/files/pl/web/javascript/reference/global_objects/number/negative_infinity/index.html new file mode 100644 index 0000000000..a266fc571b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/negative_infinity/index.html @@ -0,0 +1,54 @@ +--- +title: Number.NEGATIVE INFINITY +slug: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY +original_slug: Web/JavaScript/Referencje/Obiekty/Number/NEGATIVE_INFINITY +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość reprezentująca ujemną nieskończoność.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość własności <code>Number.NEGATIVE_INFINITY</code> jest taka sama jak ujemna wartość własności {{jsxref("Infinity")}} obiektu globalnego.</p> + +<p>Wartość ta zachowuje się nieco inaczej niż matematyczna nieskończoność:</p> + +<ul> + <li>Dowolna dodatnia wartość, włączając {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, pomnożona przez <code>NEGATIVE_INFINITY</code> jest równa <code>NEGATIVE_INFINITY</code>.</li> + <li>Dowolna ujemna wartość, włączając <code>NEGATIVE_INFINITY</code>, pomnożona przez <code>NEGATIVE_INFINITY</code> jest równa {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li>Zero pomnożone przez <code>NEGATIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>NaN pomnożone przez <code>NEGATIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>Wartość <code>NEGATIVE_INFINITY</code> podzielona przez dowolną wartość ujemną za wyjątkiem <code>NEGATIVE_INFINITY</code> jest równa {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li>Wartość <code>NEGATIVE_INFINITY</code> podzielona przez dowolną wartość dodatnią za wyjątkiem {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}} jest równa <code>NEGATIVE_INFINITY</code>.</li> + <li>Wartość <code>NEGATIVE_INFINITY</code> podzielona przez <code>NEGATIVE_INFINITY</code> lub {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}} zwraca wartość NaN.</li> + <li>Dowolna liczba podzielona przez <code>NEGATIVE_INFINITY</code> jest równa zero.</li> +</ul> + +<p>Własności <code>Number.NEGATIVE_INFINITY</code> można użyć do wskazania błędu warunku, który zwraca liczbę skończoną w przypadku powodzenia. Należy jednak zauważyć, że funkcja {{jsxref("Obiekty/isFinite", "isFinite")}} będzie w tym wypadku bardziej odpowiednia.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<p>W poniższym przykładzie do zmiennej smallNumber została przypisana wartość mniejsza niż wartość minimalna. Gdy zostaje wykonana instrukcja <code>if</code>, smallNumber posiada wartość "<code>-Infinity</code>", więc przed kontynuowaniem do zmiennej smallNumber jest przypisywana bardziej wykonywalna wartość.</p> + +<pre class="brush: js">var smallNumber = (-Number.MAX_VALUE) * 2; + +if (smallNumber == Number.NEGATIVE_INFINITY) { + smallNumber = returnFinite(); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Obiekty/Infinity", "Infinity")}}</li> + <li>{{jsxref("Obiekty/isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/positive_infinity/index.html b/files/pl/web/javascript/reference/global_objects/number/positive_infinity/index.html new file mode 100644 index 0000000000..b5643f1cdc --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/positive_infinity/index.html @@ -0,0 +1,58 @@ +--- +title: Number.POSITIVE INFINITY +slug: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY +original_slug: Web/JavaScript/Referencje/Obiekty/Number/POSITIVE_INFINITY +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość reprezentująca dodatnią nieskończoność.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość własności <code>Number.POSITIVE_INFINITY</code> jest taka sama jak wartość własności {{jsxref("Infinity")}} obiektu globalnego.</p> + +<p>Wartość ta zachowuje się nieco inaczej niż matematyczna nieskończoność:</p> + +<ul> + <li>Dowolna dodatnia wartość, włączając <code>POSITIVE_INFINITY</code>, pomnożona przez <code>POSITIVE_INFINITY</code> jest równa <code>POSITIVE_INFINITY</code>.</li> + <li>Dowolna ujemna wartość, włączając {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, pomnożona przez <code>POSITIVE_INFINITY</code> jest równa {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li> + <li>Zero pomnożone przez <code>POSITIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>NaN pomnożone przez <code>POSITIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>Wartość <code>POSITIVE_INFINITY</code> podzielona przez dowolną wartość ujemną za wyjątkiem {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} jest równa {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li> + <li>Wartość <code>POSITIVE_INFINITY</code> podzielona przez dowolną wartość dodatnią za wyjątkiem <code>POSITIVE_INFINITY</code> jest równa <code>POSITIVE_INFINITY</code>.</li> + <li>Wartość <code>POSITIVE_INFINITY</code> podzielona przez {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} lub <code>POSITIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>Dowolna liczba podzielona przez <code>POSITIVE_INFINITY</code> jest równa <code>0</code>.</li> +</ul> + +<p>Niektóre metody JavaScript (takie jak konstruktor <code>Number</code>, <code>parseFloat</code> i <code>parseInt</code>) zwracają wartość <code>NaN</code>, jeśli wartość określona w parametrze znacznie przewyższa wartość <code>Number.MAX_VALUE</code>.</p> + +<p>Własności <code>Number.POSITIVE_INFINITY</code> można użyć do wskazania błędu warunku, który zwraca liczbę skończoną w przypadku powodzenia. Należy jednak zauważyć, że funkcja {{jsxref("Obiekty/isFinite", "isFinite")}} będzie w tym wypadku bardziej odpowiednia.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<p>W poniższym przykładzie do zmiennej largeNumber została przypisana wartość większa niż wartość maksymalna. Gdy zostaje wykonana instrukcja {{jsxref("Polecenia/if...else", "if")}}, largeNumber posiada wartość <code>Infinity</code>, więc przed kontynuowaniem do zmiennej <code>bigNumber</code> jest przypisywana bardziej wykonywalna wartość.</p> + +<pre class="brush: js">var bigNumber = Number.MAX_VALUE * 2; + +if (bigNumber == Number.POSITIVE_INFINITY) { + bigNumber = returnFinite(); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("Obiekty/isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/toexponential/index.html b/files/pl/web/javascript/reference/global_objects/number/toexponential/index.html new file mode 100644 index 0000000000..946714b2b8 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/toexponential/index.html @@ -0,0 +1,54 @@ +--- +title: Number.prototype.toExponential() +slug: Web/JavaScript/Reference/Global_Objects/Number/toExponential +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential +original_slug: Web/JavaScript/Referencje/Obiekty/Number/toExponential +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący Number w notacji wykładniczej.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toExponential([<var>fractionDigits</var>])</code></pre> + +<h3 id="Parametr" name="Parametr">Parametr</h3> + +<dl> + <dt>fractionDigits</dt> + <dd>Liczba całkowita określająca liczbę cyfr występujących po kropce dziesiętnej. Domyślną wartością jest tyle cyfr, ile potrzeba do określenia liczby.</dd> +</dl> + +<h3 id="Zwraca" name="Zwraca">Zwraca</h3> + +<p>Łańcuch znaków reprezentujący obiekt {{jsxref("Number")}} w notacji wykładniczej z jedną cyfrą przed kropką dziesiętną i zaokrągleniem do tylu cyfr po kropce, ile określa parametr <code>fractionDigits</code>. Jeśli argument <code>fractionDigits</code> zostanie pominięty, domyślnie przyjmowana jest taka wartość zaokrąglenia, która pozwala na przedstawienie wartości w sposób unikatowy.</p> + +<p>Jeśli metoda <code>toExponential()</code> zostanie użyta do literałów liczbowych, które nie posiadają wykładnika i kropki dziesiętnej, należy wstawić spację przed kropką poprzedzającą wywołanie metody, aby zapobiec zinterpretowaniu tej kropki jako kropki dziesiętnej.</p> + +<p>Jeśli liczba posiada więcej cyfr niż określono przez parametr <code>fractionDigits</code>, jest ona zaokrąglana do najbliższej liczby o ilości cyfr wskazanej przez wartość <code>fractionDigits</code>. Zobacz dyskusję na temat zaokrąglania w opisie metody <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Number/toFixed">toFixed</a>, która również odnosi się do metody <code>toExponential()</code>.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<pre>var num=77.1234; + +console.log("num.toExponential() is " + num.toExponential()); //wyświetla 7.71234e+1 +console.log("num.toExponential(4) is " + num.toExponential(4)); //wyświetla 7.7123e+1 +console.log("num.toExponential(2) is " + num.toExponential(2)); //wyświetla 7.71e+1 +console.log("77.1234.toExponential() is " + 77.1234.toExponential()); //wyświetla 7.71234e+1 +console.log("77 .toExponential() is " + 77 .toExponential()); //wyświetla 7.7e+1 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/tofixed/index.html b/files/pl/web/javascript/reference/global_objects/number/tofixed/index.html new file mode 100644 index 0000000000..df80458f16 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/tofixed/index.html @@ -0,0 +1,62 @@ +--- +title: Number.prototype.toFixed() +slug: Web/JavaScript/Reference/Global_Objects/Number/toFixed +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed +original_slug: Web/JavaScript/Referencje/Obiekty/Number/toFixed +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Formatuje liczbę stosując notację stałoprzecinkową.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toFixed([<var>digits</var>])</code></pre> + +<h3 id="Parametr" name="Parametr">Parametr</h3> + +<dl> + <dt>digits</dt> + <dd>Liczba cyfr, które mają zostać wyświetlone po kropce dziesiętnej; może to być wartość z zakresu od 0 do 20 włącznie, ale implementacje mogą opcjonalnie wprowadzać większe zakresy. Jeśli argument zostanie pominięty, przyjmowana jest wartość 0.</dd> +</dl> + +<h3 id="Zwraca" name="Zwraca">Zwraca</h3> + +<p>Reprezentację wartości <code>number</code> w postaci łańcucha znaków, która nie stosuje notacji wykładniczej i posiada dokładnie tyle cyfr po separatorze dziesiętnym, ile wskazuje na to wartość parametru <code>digits</code>. Liczba w razie konieczności jest zaokrąglana, a część ułamkowa wypełniana zerami, aby liczba posiadała określoną długość. Jeśli liczba <code>number</code> jest większa niż 1e+21, metoda ta po prostu wywołuje {{jsxref("Number.prototype.toString()")}} i zwraca łańcuch znaków w notacji wykładniczej.</p> + +<h3 id="Wyrzuca" name="Wyrzuca">Wyrzuca</h3> + +<dl> + <dt>{{jsxref("Obiekty/RangeError", "RangeError")}}</dt> + <dd>Jeśli wartość parametru <code>digits</code> jest za duża lub za mała. Wartości z zakresu od 0 do 20 włącznie nie spowodują wystąpienia {{jsxref("Obiekty/RangeError", "RangeError")}}. Dopuszcza się na obsługę mniejszych lub większych wartości przez różne implementacje.</dd> +</dl> + +<dl> + <dt>{{jsxref("Obiekty/TypeError", "TypeError")}}</dt> + <dd>Jeśli ta metoda jest przywołana w obiekcie, który nie jest obiektem {{jsxref("Number")}}.</dd> +</dl> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<pre class="brush: js">var n = 12345.6789; + +n.toFixed(); // zwraca 12346: zauważ zaokrąglenie i brak części ułamkowej +n.toFixed(1); // zwraca 12345.7: zauważ zaokrąglenie +n.toFixed(6); // zwraca 12345.678900: zauważ dodane zera +(1.23e+20).toFixed(2); // zwraca 123000000000000000000.00 +(1.23e-10).toFixed(2) // zwraca 0.00 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/tolocalestring/index.html b/files/pl/web/javascript/reference/global_objects/number/tolocalestring/index.html new file mode 100644 index 0000000000..035efe8464 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/tolocalestring/index.html @@ -0,0 +1,183 @@ +--- +title: Number.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString +original_slug: Web/JavaScript/Referencje/Obiekty/Number/toLocaleString +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>toLocaleString()</code></strong> zwraca łańcuch znaków przedstawiający dany numer w formacie wybranej lokalizacji.</p> + +<p>Nowe argumenty - <code>lokalizacje</code> i <code>opcje</code> - pozwalają na wybranie lokalizacji w jakiej ma zostać przedstawiona liczba. Starsza implementacja, która nie posiadała tych argumentów, zwracała łańcuch znaków zależny od implementacji danego środowiska.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>numObj</em>.toLocaleString(</code><code>[lokalizacje [, opcje]])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<p>W sekcji <a href="#Browser_compatibility">kompatybilności</a> możesz sprawdzić, które przeglądarki obsługują argumenty <code>lokalizacji</code> i <code>opcji</code> . W sekcji <a href="#Checking_for_support_for_locales_and_options_arguments">Przykład: Sprawdzanie obsługi argumentów <code>lokalizacji</code> i <code>opcji</code> </a>rozpisane są sposoby na przetestowanie obsługiwanych przez przeglądarkę argumentów tej metody.</p> + +<div class="note"> +<p><strong>Info:</strong> ECMAScript Internationalization API, zaimplementowane w Firefoxie 29, dodaje obsługę parametry<code>lokalizacje</code> do metody<code>Number.toLocaleString()</code>. Jeśli argument nie zostanie podany ({{jsxref("undefined")}}) metoda przyjmię lokalizację systemu operacyjnego. Poprzednie wersje Firefoxa zwracały liczby z lokalizacji <a href="https://en.wikipedia.org/wiki/Arabic_numerals">Western Arabic</a>. Zmiana zostala zgłoszona jako regresja rzutująca na wsteczną kompatybilność metody, i wkrótce zostanie naprawiona. ({{bug(999003)}})</p> +</div> + +<div>{{page('/pl-PL/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat', 'Parameters')}}</div> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Łańcuch znaków przedstawiający liczbę w danym formacie.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Przykłady_użycia_metody_toLocaleString">Przykłady użycia metody <code>toLocaleString</code></h3> + +<p>Podstawowy sposób użycia, bez podanych argumentów, zwróci nam łańcuch znaków w domyślnej lokalizacji i z domyślnymi opcjami.</p> + +<pre class="brush: js">var liczba = 3500; + +console.log(liczba.toLocaleString()); // Wyświetli "3 500", jeśli twoją lokalizacją jest „pl-PL” +</pre> + +<h3 id="Sprawdzanie_dostępności_argumentów_lokalizacji_i_opcji">Sprawdzanie dostępności argumentów <code>lokalizacji</code> i <code>opcji</code></h3> + +<p>Nie wszystkie przeglądarki obsługuję argumenty <code>lokalizacji</code> i <code>opcji</code>. Aby to sprawdzić w wersji języka ES5.1 i późniejszych możemy użyć wyjątku {{jsxref("Global_Objects/RangeError", "RangeError")}}, który zostanie rzucony gdy niepoprawna nazwa lokalizacji zostanie użyta:</p> + +<pre class="brush: js">function toLocaleStringSupportsLocales() { + var liczba = 0; + try { + liczba.toLocaleString('i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<p>W wersjach przed ES5.1 nie było obowiązku wyrzucania wyjątku Range Error jeśli metoda <code>toLocaleString</code> została wywołana z argumentami.</p> + +<p>Sprawdzenie działające na wszystkich wersjach języka przed 5.1 polega na użyciu funkcjonalności niezbędnych do działania tych argumentów bezpośrednio na <code>Number.prototype.toLocaleString</code>:</p> + +<pre class="brush: js">function toLocaleStringSupportsOptions() { + return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function'); +} +</pre> + +<p>Sprawdzamy tutaj czy istnieje globalny obiekt <code>Intl</code>, czy nie jest <code>nullem</code>, a także czy posiada właściwość <code>NumberFormat</code>, która jest funkcją.</p> + +<h3 id="Przykłady_użycia_lokalizacji">Przykłady użycia <code>lokalizacji</code></h3> + +<p>Przykład ten pokazuje kilka różnych lokalizacji. Aby uzyskać foramt języka interfejsu użytkownika upewnij się, że podajesz tę lokalizację (i dla pewności kilka innych jako fallbacki) przy pomocy aargumentu <code>localizacji</code>:</p> + +<pre class="brush: js">var liczba = 123456.789; + +// Język niemiecki oddziela części dziesiętne przecinkiem, a tysiące kropką +console.log(liczba.toLocaleString('de-DE')); +// → 123.456,789 + +// W większości krajów arabskich używa cyfr <a href="https://en.wikipedia.org/wiki/Eastern_Arabic_numerals">Eastern Arabic</a> +console.log(liczba.toLocaleString('ar-EG')); +// → ١٢٣٤٥٦٫٧٨٩ + +// Indyjski używa separatorów tysięcy/lakh/crore +console.log(liczba.toLocaleString('en-IN')); +// → 1,23,456.789 + +// Klucz rozszerzeń „nu” pyta o system numeryczny, np. Chiński system dziesiętny +console.log(liczba.toLocaleString('zh-Hans-CN-u-nu-hanidec')); +// → 一二三,四五六.七八九 + +// jeśli masz zamiar użyć lokalizacji, która może nie być obsługiwana +// jak np. Balinese, zawsze dodaj drugi lokalizację, tutaj Indonezyjską +console.log(liczba.toLocaleString(['ban', 'id'])); +// → 123.456,789 +</pre> + +<h3 id="Przykłady_użycia_opcji">Przykłady użycia <code>opcji</code></h3> + +<p>Rezultaty metody<code>toLocaleString</code> mogą być dostosowywane przy pomocy argumentu <code>opcje</code>:</p> + +<pre class="brush: js">var liczba = 123456.789; + +// format walutowy +console.log(liczba.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' })); +// → 123.456,79 € + +// Japoński yen +console.log(liczba.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' })) +// → ￥123,457 + +// ogranicz wyświetlanie do 3 miejsc znaczących +console.log(liczba.toLocaleString('en-IN', { maximumSignificantDigits: 3 })); +// → 1,23,000 + +// Użyj domyślnego języka hosta z opcjami formatowania liczby +var num = 30000.65; +console.log(num.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2})); +// → "30,000.65" w języku angielskim lub +// → "30.000,65" w języku niemieckiem lub +// → "30 000,65" w języku francuskim +</pre> + +<h2 id="Wydajność">Wydajność</h2> + +<p>Jeśli zamierzasz formatować wiele liczb, lepiej użyć obiektu {{jsxref("NumberFormat")}} i formatować przy pomocy metody {{jsxref("NumberFormat.format")}}.</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Pierwsza definicja. Zaimplementowane w JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.3', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Number.prototype.toLocaleString', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.toLocaleString")}}</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/toprecision/index.html b/files/pl/web/javascript/reference/global_objects/number/toprecision/index.html new file mode 100644 index 0000000000..126b6c2d95 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/toprecision/index.html @@ -0,0 +1,57 @@ +--- +title: Number.prototype.toPrecision() +slug: Web/JavaScript/Reference/Global_Objects/Number/toPrecision +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision +original_slug: Web/JavaScript/Referencje/Obiekty/Number/toPrecision +--- +<p>{{jsref}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący dany obiekt Number z określoną dokładnością.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toPrecision([<var>precision</var>])</code></pre> + +<h3 id="Parametr" name="Parametr">Parametr</h3> + +<dl> + <dt>precision</dt> + <dd>Liczba całkowita określająca liczbę cyfr po kropce dziesiętnej.</dd> +</dl> + +<h3 id="Zwraca" name="Zwraca">Zwraca</h3> + +<p>Łańcuch znaków reprezentujący obiekt {{jsxref("Number")}} w notacji stałoprzecinkowej lub wykładniczej z zaokrągleniem do tylu ważnych cyfr, ile wskazuje wartość <code>precision</code>.</p> + +<p>Jeśli metoda <code>toPrecision()</code> zostanie użyta do literałów liczbowych, które nie posiadają wykładnika i kropki dziesiętnej, należy wstawić spację przed kropką poprzedzającą wywołanie metody, aby zapobiec zinterpretowaniu tej kropki jako kropki dziesiętnej.</p> + +<p>Jeśli argument <code>precision</code> zostanie pominięty, metoda zachowuje się jak {{jsxref("Number.prototype.toString()")}}.</p> + +<p>Jeśli liczba posiada więcej cyfr niż określono przez parametr <code>precision</code>, jest ona zaokrąglana do najbliższej liczby o ilości cyfr wskazanej przez wartość <code>precision</code>. Zobacz dyskusję na temat zaokrąglania w opisie metody {{jsxref("Number.prototype.toFixed()")}}, która również odnosi się do metody <code>toPrecision</code>.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<pre class="brush: js">var num=5.123456; + +console.log("num.toPrecision() is " + num.toPrecision()); //wyświetli 5.123456 +console.log("num.toPrecision(4) is " + num.toPrecision(4)); //wyświetli 5.123 +console.log("num.toPrecision(2) is " + num.toPrecision(2)); //wyświetli 5.1 +console.log("num.toPrecision(1) is " + num.toPrecision(1)); //wyświetli 5 +console.log("1250 .toPrecision(2) is " + 1250 .toPrecision(2)); //wyświetli 1.3e+3 +console.log("1250 .toPrecision(5) is " + 1250 .toPrecision(5)); //wyświetli 1250.0 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/number/tostring/index.html b/files/pl/web/javascript/reference/global_objects/number/tostring/index.html new file mode 100644 index 0000000000..672019ca59 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/number/tostring/index.html @@ -0,0 +1,60 @@ +--- +title: Number.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Number/toString +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString +original_slug: Web/JavaScript/Referencje/Obiekty/Number/toString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący dany obiekt {{jsxref("Number")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toString([<var>radix</var>])</code></pre> + +<h3 id="Parametr" name="Parametr">Parametr</h3> + +<dl> + <dt>radix</dt> + <dd>Liczba całkowita z zakresu od 2 do 36 określająca podstawę użytą do reprezentacji wartości liczbowych.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt <code>Number</code> przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektów <code>Number</code> metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt w danej podstawie wyliczeń.</p> + +<p>Metoda toString przetwarza pierwszy podany argument i próbuje zwrócić reprezentację w postaci łańcucha znaków w określonej podstawie wyliczeń. Dla podstawy większej od 10 litery alfabetu wskazują liczby większe niż 9. Przykładowo dla liczb heksadecymalnych (podstawa 16) użyte zostaną litery od A do F.</p> + +<p>Jeśli jako argument <code>toString()</code> podano podstawę nie będącą w zakresie od 2 do 36, zostanie wywołany wyjątek.</p> + +<p>Jeśli podstawa nie została określona, JavaScript przyjmuje za podstawę wartość 10.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<pre class="brush: js language-js"><code class="language-js"><span class="token keyword">var</span> count <span class="token operator">=</span> <span class="token number">10</span><span class="token punctuation">;</span> + +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>count<span class="token punctuation">.</span><span class="token function">toString<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"> // displays '10' +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token number">17</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<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"> // displays '17' +</span> +<span class="token keyword">var</span> x <span class="token operator">=</span> <span class="token number">6</span><span class="token punctuation">;</span> + +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>x<span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // displays '110' +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token number">254</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">16</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // displays 'fe' +</span> +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token operator">-</span><span class="token number">10</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // displays '-1010' +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token operator">-</span><span class="token number">0xff</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // displays '-11111111'</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> 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..84c139a058 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/assign/index.html @@ -0,0 +1,308 @@ +--- +title: Object.assign() +slug: Web/JavaScript/Reference/Global_Objects/Object/assign +translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign +original_slug: Web/JavaScript/Referencje/Obiekty/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..ec5cc5bc04 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/constructor/index.html @@ -0,0 +1,50 @@ +--- +title: Object.prototype.constructor +slug: Web/JavaScript/Reference/Global_Objects/Object/constructor +tags: + - JavaScript + - Object + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Object/constructor +original_slug: Web/JavaScript/Referencje/Obiekty/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..7abf0aed56 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/freeze/index.html @@ -0,0 +1,202 @@ +--- +title: Object.freeze() +slug: Web/JavaScript/Reference/Global_Objects/Object/freeze +translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze +original_slug: Web/JavaScript/Referencje/Obiekty/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..7ab7948ccc --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html @@ -0,0 +1,122 @@ +--- +title: Object.getOwnPropertyDescriptor() +slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor +translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor +original_slug: Web/JavaScript/Referencje/Obiekty/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..3a05d6d5ae --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/hasownproperty/index.html @@ -0,0 +1,151 @@ +--- +title: Object.prototype.hasOwnProperty() +slug: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty +translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty +original_slug: Web/JavaScript/Referencje/Obiekty/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..e5df7e69c3 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/index.html @@ -0,0 +1,213 @@ +--- +title: Object +slug: Web/JavaScript/Reference/Global_Objects/Object +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Object +original_slug: Web/JavaScript/Referencje/Obiekty/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..72951af19a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/proto/index.html @@ -0,0 +1,194 @@ +--- +title: Object.prototype.__proto__ +slug: Web/JavaScript/Reference/Global_Objects/Object/proto +translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto +original_slug: Web/JavaScript/Referencje/Obiekty/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..b4ec8de711 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/seal/index.html @@ -0,0 +1,166 @@ +--- +title: Object.seal() +slug: Web/JavaScript/Reference/Global_Objects/Object/seal +translation_of: Web/JavaScript/Reference/Global_Objects/Object/seal +original_slug: Web/JavaScript/Referencje/Obiekty/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..e8187f90e3 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/tolocalestring/index.html @@ -0,0 +1,36 @@ +--- +title: Object.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString +original_slug: Web/JavaScript/Referencje/Obiekty/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..502cef66c7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/tosource/index.html @@ -0,0 +1,74 @@ +--- +title: Object.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Object/toSource +tags: + - JavaScript + - Method + - Non-standard + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource +original_slug: Web/JavaScript/Referencje/Obiekty/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..f78488b4c4 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/tostring/index.html @@ -0,0 +1,99 @@ +--- +title: Object.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Object/toString +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toString +original_slug: Web/JavaScript/Referencje/Obiekty/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..a9ac36102c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/object/valueof/index.html @@ -0,0 +1,64 @@ +--- +title: Object.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Object/valueOf +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf +original_slug: Web/JavaScript/Referencje/Obiekty/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> diff --git a/files/pl/web/javascript/reference/global_objects/parsefloat/index.html b/files/pl/web/javascript/reference/global_objects/parsefloat/index.html new file mode 100644 index 0000000000..e2187c39d8 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/parsefloat/index.html @@ -0,0 +1,69 @@ +--- +title: parseFloat() +slug: Web/JavaScript/Reference/Global_Objects/parseFloat +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/parseFloat +original_slug: Web/JavaScript/Referencje/Obiekty/parseFloat +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Przetwarza argument w postaci łańcucha znaków zwracając liczbę zmiennoprzecinkową.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox">parseFloat(<em>string</em>)</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>string</code> </dt> + <dd>Łańcuch znaków do przetworzenia.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>parseFloat()</code> jest funkcją najwyższego poziomu, niepowiązaną z żadnym obiektem.</p> + +<p><code>parseFloat()</code> przetwarza argument będący łańcuchem znaków i zwraca liczbę zmiennoprzecinkową. Jeśli natknie się na znak inny niż <code>+</code>, <code>-</code>, liczbę (<code>0</code>-<code>9</code>), kropkę dziesiętną ("<code>.</code>") lub wykładnik potęgi, zwraca wartość do tego miejsca i ignoruje dany znak oraz wszystkie dalsze znaki. Dozwolone są spacje na początku i na końcu łańcucha znaków.</p> + +<p>Jeśli pierwszy znak nie może być przekonwertowany do liczby, <code>parseFloat()</code> zwraca <code>NaN</code>.</p> + +<p>W zastosowaniach arytmetycznych, wartość <code>NaN</code> nie jest liczbą w żadnej podstawie wyliczeń (ang. + + <i>radix</i> + ). Aby stwierdzić, czy wynik <code>parseFloat</code> będzie <code>NaN</code>, można wywołać funkcję {{jsxref("isNan", "isNaN()")}}. Jeśli wartość <code>NaN</code> użyta zostanie w operacji arytmetycznej, wynikiem operacji także będzie <code>NaN</code>.</p> + +<p><b>Uwaga:</b> Funkcja <code>parseFloat</code> wymaga, aby punktem dziesiętnym była kropka, a nie przecinek. Zastosowanie przecinka spowoduje pominięcie części ułamkowej.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h2 id="Przyk.C5.82ad:_parseFloat_zwraca_liczb.C4.99" name="Przyk.C5.82ad:_parseFloat_zwraca_liczb.C4.99">Przykład: <code>parseFloat()</code> zwraca liczbę</h2> + +<p>Wszystkie poniższe przykłady zwracają 3.14.</p> + +<pre class="brush: js"><code>parseFloat("3.14"); +<code>parseFloat("314e-2"); +<code>parseFloat("0.0314E+2"); +<code>parseFloat("3.14 więcej znaków nienumerycznych");</code></code></code></code></pre> + +<h3 id="Przyk.C5.82ad:_parseFloat_zwraca_NaN" name="Przyk.C5.82ad:_parseFloat_zwraca_NaN">Przykład: <code>parseFloat()</code> zwraca NaN</h3> + +<p>Poniższy przykład zwraca <code>NaN</code>:</p> + +<pre class="brush: js"><code>parseFloat("FF2");</code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("parseInt", "parseInt()")}}</li> + <li>{{jsxref("Number.parseFloat()")}}</li> + <li>{{jsxref("Number.parseInt()")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/parseint/index.html b/files/pl/web/javascript/reference/global_objects/parseint/index.html new file mode 100644 index 0000000000..dad4b53ed7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/parseint/index.html @@ -0,0 +1,113 @@ +--- +title: parseInt() +slug: Web/JavaScript/Reference/Global_Objects/parseInt +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/parseInt +original_slug: Web/JavaScript/Referencje/Obiekty/parseInt +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Przetwarza argument w postaci łańcucha znaków i zwraca liczbę całkowitą typu + <i>integer</i> + , o zadanej podstawie.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox">parseInt(<em>string</em>, <em>radix</em>);</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>string</code> </dt> + <dd>Łańcuch znaków zawierający wartość do przetworzenia.</dd> +</dl> + +<dl> + <dt><code>radix</code> </dt> + <dd>Liczba typu + <i>integer</i> + określająca podstawę powyższego łańcucha (np. 2 - system dwójkowy, 10 - system dziesiętny, przyp. tłum.)</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>parseInt</code> jest funkcją najwyższego poziomu i nie jest związana z żadnym obiektem.</p> + +<p>Funkcja <code>parseInt</code> parsuje jej pierwszy argument, łańcuch znaków, i próbuje zwrócić liczbę całkowitą typu + + <i>integer</i> + o podanej podstawie. Na przykład, podstawa 10 oznacza że liczba w łańcuchu jest liczbą dziesiętną, podstawa 8 - ósemkową, 16 - szesnastkową (heksadecymalną), itd. Dla podstaw większych niż 10, litery alfabetu oznaczają cyfry większe niż 9. Dla przykładu, dla liczb szesnastkowych (o podstawie 16), używane są litery od A do F.</p> + +<p>Jeśli <code>parseInt</code> natknie się na znak nie będący cyfrą o danej podstawie, ignoruje ona ten znak i wszystkie następne znaki, a następnie zwraca wartość przetworzoną do tej pory. <code>parseInt</code> przycina liczby do wartości całkowitych. Początkowe i grupujące spacje są dozwolone.</p> + +<p>Jeśli podstawa nie jest podana lub jest podana jako 0, JavaScript przyjmuje:</p> + +<ul> + <li>Podstawę <code>16</code>, jeśli łańcuch wejściowy zaczyna się od "<code>0x</code>".</li> + <li>Podstawę <code>8</code> jeśli łańcuch wejściowy rozpoczyna się od "<code>0</code>". Ta cecha jest wycofywana.</li> + <li>Podstawę <code>10</code> jeśli łańcuch zaczyna się od jakiejkolwiek innej wartości.</li> +</ul> + +<p>Jeśli pierwszy znak nie może być skonwertowany na liczbę, <code>parseInt</code> zwraca <code>NaN</code>.</p> + +<p>Dla potrzeb arytmetycznych, wartość <code>NaN</code> nie jest liczbą o żadnej podstawie. Możesz wywołać funkcję {{jsxref("isNaN", "isNaN()")}}, by stwierdzić czy wynik <code>parseInt</code> będzie <code>NaN</code>. Jeśli <code>NaN</code> jest podane do jakichkolwiek operacji arytmetycznych, wynikiem tych operacji również będzie <code>NaN</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_parseInt" name="Przyk.C5.82ad:_Zastosowanie_parseInt">Przykład: Zastosowanie <code>parseInt()</code></h3> + +<p>Wszystkie poniższe przykłady zwracają 15:</p> + +<pre class="brush: js"><code>parseInt(" 0xF, 16); +parseInt(" F", 16); +<code>parseInt("17", 8); +<code>parseInt(021, 8); +<code>parseInt(15.99, 10); +<code><code><code><code>parseInt(<code>"FXX123", 16);</code></code></code></code></code></code></code></code></code> +<code><code>parseInt("1111", 2); +<code>parseInt("15*3", 10); +parseInt("15e2", 10); +parseInt("15px", 10); +<code>parseInt("12", 13);</code></code></code></code></pre> + +<p>Wszystkie poniższe przykłady zwracają <strong><code>NaN</code></strong>:</p> + +<pre class="brush: js"><code>parseInt("Hello", 8); // nie jest wcale liczbą</code> +<code>parseInt("546", 2); // te cyfry nie są używane do zapisu liczb binarnych</code></pre> + +<p>Wszystkie poniższe przykłady zwracają <strong>-15</strong>:</p> + +<pre class="brush: js"><code><code><code><code>parseInt("-F", 16); +parseInt("-0F", 16); +parseInt("-0XF", 16);</code></code></code></code> +parseInt("-15.1, 10); +parseInt(" -17", 8); +parseInt(" -15", 10); +parseInt("-1111", 2); +parseInt("-15e1", 10); +parseInt("-12", 13); +</pre> + +<p>Wszystkie poniższe przykłady zwracają <strong>224</strong>:</p> + +<pre class="brush: js"><code><code><code><code>parseInt("0e0", 16);</code></code></code></code></pre> + +<p> </p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("parseFloat", "parseFloat()")}}</li> + <li>{{jsxref("Number.parseFloat()")}}</li> + <li>{{jsxref("Number.parseInt()")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> + <li>{{jsxref("Number.toString()")}}</li> + <li>{{jsxref("Object.valueOf")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/promise/index.html b/files/pl/web/javascript/reference/global_objects/promise/index.html new file mode 100644 index 0000000000..1227a0edab --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/promise/index.html @@ -0,0 +1,257 @@ +--- +title: Promise +slug: Web/JavaScript/Reference/Global_Objects/Promise +tags: + - JavaScript + - Obietnice +translation_of: Web/JavaScript/Reference/Global_Objects/Promise +original_slug: Web/JavaScript/Referencje/Obiekty/Promise +--- +<div>{{JSRef}}</div> + +<p>Obiekt <strong><code>Promise</code></strong> reprezentuje ewentualne zakończenie (lub porażkę) asynchronicznej operacji i jej wartości.</p> + +<div class="note"> +<p>Artykuł opisuje konstruktor, metody i właściwości obiektu <code>Promise</code>. By nauczyć się jak działają obietnice i jak można ich używać zalecamy przeczytać najpierw <a href="/en-US/docs/Web/JavaScript/Guide/Using_promises">Użycie obietnic</a> . Ten konstruktor jest głównie używany do opakowania funkcji, które nie wspierają jeszcze obietnic.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/promise-constructor.html")}}</div> + +<p class="hidden">Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do interaktywnego projektu sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij do nas pull request.</p> + +<p class="hidden">Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do interaktywnego projektu sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij do nas pull request.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js notranslate">new Promise( /* wykonawca */ function(resolve, reject) { ... } );</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>wykonawca (executor)</dt> + <dd>Funkcja przekazywana z argumentami <code>resolve</code> i <code>reject</code>. Funkcja ta wykonywana jest natychmiast przez implementację obietnicy, przekazując funkcje <code>resolve</code> i <code>reject</code> (ta funkcja jest wywoływana, zanim konstruktor Promise zwróci utworzony obiekt). Funkcje <code>resolve</code> i <code>reject</code> , gdy są wywoływane, odpowiednio rozwiązują lub odrzucają obietnicę. Ta funkcja zwykle inicjuje pracę asynchroniczną, a następnie, po jej zakończeniu, wywołuje funkcję <code>resolve</code> w celu rozwiązania obietnicy lub odrzuca ją, jeśli wystąpił błąd. Jeśli błąd zostanie zgłoszony w tej funkcji, obietnica zostaje odrzucona. Wartość zwracana tej funkcji jest ignorowana.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p><code><strong>Promise</strong></code> jest proxy dla wartości niekoniecznie znanej, gdy jest tworzona. Pozwala na kojarzenie uchwytu z ewentualnym sukcesem lub porażką asynchroniczne akcji. Pozwala to metodom asynchronicznym zwracać wartości takie jak metody synchroniczne, zamiast natychmiastowego zwracania wartości końcowej, metoda asynchroniczna zwraca <em>obietnicę </em>dostarczenia wartości w pewnym momencie w przyszłości.</p> + +<p><code>Promise</code> jest dostępny w jednym z tych stanów:</p> + +<ul> + <li><em>pending</em>: stan inicjacji, ani wypełnione, ani odrzucone.</li> + <li><em>fulfilled</em>: operacja zakończona sukcesem.</li> + <li><em>rejected</em>: operacja zakończona porażką.</li> +</ul> + +<p>Obowiązująca objetnica może być <em>zakończona </em>z wartością lub <em>odrzucona </em>z powodem(błędem). Kiedy dzieje się jedna z tych opcji, wywoływane są zakolejkowane, powiązane za pomocą metody <code>then</code> procedury. (Jeśli obietnica została już spełniona lub odrzucona, gdy dołączony jest odpowiedni moduł obsługi, zostanie on wywołany, więc nie ma potrzeby wyścigu między zakończeniem operacji asynchronicznej a jej obsługą).</p> + +<p>Tak jak w <code>{{jsxref("Promise.then", "Promise.prototype.then()")}}</code> oraz <code>{{jsxref("Promise.catch", "Promise.prototype.catch()")}}</code> gdy metoda zwróci obietnice, mogą one być łączone w łańcuchy.</p> + +<p><img alt="" src="https://mdn.mozillademos.org/files/8633/promises.png" style="height: 297px; width: 801px;"></p> + +<div class="note"> +<p><strong>Nie mylić z:</strong> Kilka innych języków ma mechanizmy leniwego oceniania i odraczania obliczeń, które nazywają również "obietnicami", np. Scheme. Obietnice w JavaScript oznaczają procesy, które już się odbywają, które mogą być powiązane z funkcjami wywołania zwrotnego. Jeśli chcesz leniwie oceniać wyrażenie, rozważ <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">funkcje strzałkowe</a> bez argumentów: <code>f = () => <em>wyrażenie</em></code> by stworzyć leniwo oszacowane wyrażenie, i <code>f()</code> by ocenić.</p> +</div> + +<div class="note"> +<p>Mówi się, że obietnica zostanie uregulowana, jeśli zostanie spełniona lub odrzucona, ale nie oczekuje na rozpatrzenie. Usłyszysz także termin <em>rozwiązany </em>używany z obietnicami - oznacza to, że obietnica jest ustalona lub "zamknięta", aby dopasować się do stanu innej obietnicy. <a href="https://github.com/domenic/promises-unwrapping/blob/master/docs/states-and-fates.md">Stany i losy</a> zawierają więcej szczegółów na temat obiecanej terminologii.</p> +</div> + +<h2 id="Właściwości">Właściwości</h2> + +<dl> + <dt><code>Promise.length</code></dt> + <dd>Właściwość Length, której wartość wynosi zawsze 1 (liczba argumentów konstruktora).</dd> + <dt>{{jsxref("Promise.prototype")}}</dt> + <dd>Reprezentuje prototyp konstruktora <code>Promise</code>.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Promise.all", "Promise.all(iterable)")}}</dt> + <dd>Zwraca obietnice, która albo kończy się sukcesem gdy wszystkie z obietnic w <code>iterable</code> się zakończą powodzeniem lub kończy sie porażką tak szybko jak jedna z obietnic skończy się porażką. Jeżeli zwrócona obietnica kończy się sukcesem jest ona wypełniana tablicą wartości z obietnic zakończonych sukcesem w takim samym układzie jak były one zdefiniowane w <code>iterable</code>. Jeżeli zwrócona obietnica zakończyła się porażką, jest ona odrzucana z Powodem z pierwszej obietnicy w <code>iterable</code>, która zakończyła się porażką. Ta metoda może być pomocna do zachowywania rezultatów różnych obietnic.</dd> + <dt>{{jsxref("Promise.race", "Promise.race(iterable)")}}</dt> + <dd>Returns a promise that fulfills or rejects as soon as one of the promises in the iterable fulfills or rejects, with the value or reason from that promise.</dd> +</dl> + +<dl> + <dt>{{jsxref("Promise.reject", "Promise.reject(reason)")}}</dt> + <dd>Returns a <code>Promise</code> object that is rejected with the given reason.</dd> +</dl> + +<dl> + <dt>{{jsxref("Promise.resolve", "Promise.resolve(value)")}}</dt> + <dd>Returns a <code>Promise</code> object that is resolved with the given value. If the value is a thenable (i.e. has a <code>then</code> method), the returned promise will "follow" that thenable, adopting its eventual state; otherwise the returned promise will be fulfilled with the value. Generally, if you don't know if a value is a promise or not, {{jsxref("Promise.resolve", "Promise.resolve(value)")}} it instead and work with the return value as a promise.</dd> +</dl> + +<h2 id="Promise_prototype">Promise prototype</h2> + +<h3 id="Właściwości_2">Właściwości</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Properties')}}</p> + +<h3 id="Metody_2">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Methods')}}</p> + +<h2 id="Tworzenie_Promise">Tworzenie Promise</h2> + +<p>A <code>Promise</code> object is created using the <code>new </code>keyword and its constructor. This constructor takes as its argument a function, called the "executor function". This function should take two functions as parameters. The first of these functions (<code>resolve</code>) is called when the asynchronous task completes successfully and returns the results of the task as a value. The second (<code>reject</code>) is called when the task fails, and returns the reason for failure, which is typically an error object.</p> + +<pre class="brush: js notranslate">const myFirstPromise = new Promise((resolve, reject) => { + // do something asynchronous which eventually calls either: + // + // resolve(someValue); // fulfilled + // or + // reject("failure reason"); // rejected +}); +</pre> + +<p>To provide a function with promise functionality, simply have it return a promise:</p> + +<pre class="brush: js notranslate">function myAsyncFunction(url) { + return new Promise((resolve, reject) => { + const xhr = new XMLHttpRequest(); + xhr.open("GET", url); + xhr.onload = () => resolve(xhr.responseText); + xhr.onerror = () => reject(xhr.statusText); + xhr.send(); + }); +}</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Podstawowy_przykład">Podstawowy przykład</h3> + +<pre class="brush: js notranslate">let myFirstPromise = new Promise((resolve, reject) => { + // We call resolve(...) when what we were doing asynchronously was successful, and reject(...) when it failed. + // In this example, we use setTimeout(...) to simulate async code. + // In reality, you will probably be using something like XHR or an HTML5 API. + setTimeout(function(){ + resolve("Success!"); // Yay! Everything went well! + }, 250); +}); + +myFirstPromise.then((successMessage) => { + // successMessage is whatever we passed in the resolve(...) function above. + // It doesn't have to be a string, but if it is only a succeed message, it probably will be. + console.log("Yay! " + successMessage); +}); +</pre> + +<h3 id="Zaawansowany_Przykład">Zaawansowany Przykład</h3> + +<pre class="brush: html hidden notranslate"><button id="btn">Make a promise!</button> +<div id="log"></div> +</pre> + +<p>This small example shows the mechanism of a <code>Promise</code>. The <code>testPromise()</code> method is called each time the {{HTMLElement("button")}} is clicked. It creates a promise that will be fulfilled, using {{domxref("window.setTimeout()")}}, to the promise count (number starting from 1) every 1-3 seconds, at random. The <code>Promise()</code> constructor is used to create the promise.</p> + +<p>The fulfillment of the promise is simply logged, via a fulfill callback set using {{jsxref("Promise.prototype.then()","p1.then()")}}. A few logs show how the synchronous part of the method is decoupled from the asynchronous completion of the promise.</p> + +<pre class="brush: js notranslate">'use strict'; +var promiseCount = 0; + +function testPromise() { + let thisPromiseCount = ++promiseCount; + + let log = document.getElementById('log'); + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Started (<small>Sync code started</small>)<br/>'); + + // We make a new promise: we promise a numeric count of this promise, starting from 1 (after waiting 3s) + let p1 = new Promise( + // The resolver function is called with the ability to resolve or + // reject the promise + (resolve, reject) => { + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Promise started (<small>Async code started</small>)<br/>'); + // This is only an example to create asynchronism + window.setTimeout( + function() { + // We fulfill the promise ! + resolve(thisPromiseCount); + }, Math.random() * 2000 + 1000); + } + ); + + // We define what to do when the promise is resolved with the then() call, + // and what to do when the promise is rejected with the catch() call + p1.then( + // Log the fulfillment value + function(val) { + log.insertAdjacentHTML('beforeend', val + + ') Promise fulfilled (<small>Async code terminated</small>)<br/>'); + }) + .catch( + // Log the rejection reason + (reason) => { + console.log('Handle rejected promise ('+reason+') here.'); + }); + + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Promise made (<small>Sync code terminated</small>)<br/>'); +}</pre> + +<pre class="brush:js hidden notranslate">if ("Promise" in window) { + let btn = document.getElementById("btn"); + btn.addEventListener("click",testPromise); +} else { + log = document.getElementById('log'); + log.innerHTML = "Live example not available as your browser doesn't support the <code>Promise<code> interface."; +} +</pre> + +<p>This example is started by clicking the button. You need a browser that supports <code>Promise</code>. By clicking the button several times in a short amount of time, you'll even see the different promises being fulfilled one after another.</p> + +<p>{{EmbedLiveSample("Advanced_Example", "500", "200")}}</p> + +<h2 id="Ładowanie_obrazka_z_XHR">Ładowanie obrazka z XHR</h2> + +<p>Another simple example using <code>Promise</code> and <code><a href="/en-US/docs/Web/API/XMLHttpRequest">XMLHttpRequest</a></code> to load an image is available at the MDN GitHub<a href="https://github.com/mdn/js-examples/tree/master/promises-test"> js-examples</a> repository. You can also <a href="https://mdn.github.io/js-examples/promises-test/">see it in action</a>. Each step is commented and allows you to follow the Promise and XHR architecture closely.</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>{{SpecName('ES2015', '#sec-promise-objects', 'Promise')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition in an ECMA standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-promise-objects', 'Promise')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2> + +<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Promise")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Using_promises">Using promises</a></li> + <li><a href="http://promisesaplus.com/">Promises/A+ specification</a></li> + <li><a href="https://medium.com/@ramsunvtech/promises-of-promise-part-1-53f769245a53">Venkatraman.R - JS Promise (Part 1, Basics)</a></li> + <li><a href="https://medium.com/@ramsunvtech/js-promise-part-2-q-js-when-js-and-rsvp-js-af596232525c#.dzlqh6ski">Venkatraman.R - JS Promise (Part 2 - Using Q.js, When.js and RSVP.js)</a></li> + <li><a href="https://tech.io/playgrounds/11107/tools-for-promises-unittesting/introduction">Venkatraman.R - Tools for Promises Unit Testing</a></li> + <li><a href="http://www.html5rocks.com/en/tutorials/es6/promises/">Jake Archibald: JavaScript Promises: There and Back Again</a></li> + <li><a href="http://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript">Domenic Denicola: Callbacks, Promises, and Coroutines – Asynchronous Programming Patterns in JavaScript</a></li> + <li><a href="http://www.mattgreer.org/articles/promises-in-wicked-detail/">Matt Greer: JavaScript Promises ... In Wicked Detail</a></li> + <li><a href="https://www.promisejs.org/">Forbes Lindesay: promisejs.org</a></li> + <li><a href="https://github.com/jakearchibald/es6-promise/">Promise polyfill</a></li> + <li><a href="https://www.udacity.com/course/javascript-promises--ud898">Udacity: JavaScript Promises</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/proxy/index.html b/files/pl/web/javascript/reference/global_objects/proxy/index.html new file mode 100644 index 0000000000..26c8cd88be --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/proxy/index.html @@ -0,0 +1,402 @@ +--- +title: Proxy +slug: Web/JavaScript/Reference/Global_Objects/Proxy +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy +original_slug: Web/JavaScript/Referencje/Obiekty/Proxy +--- +<div> +<div>{{JSRef}}</div> +</div> + +<p>Obiekt <strong>Proxy</strong> jest używany w celu definiowania specyficznego zachowania dla podstawowych operacji (n.p. wyszukiwanie atrybutu, przypisanie, wyliczanie, wywołanie funkcji, etc).</p> + +<h2 id="Terminologia">Terminologia</h2> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler">handler</a></dt> + <dd>Zastępczy obiekt zawierający pułapki (traps).</dd> + <dt>traps</dt> + <dd>Metody zapewniające dostęp do atrybutów. Pojęcie to jest analogiczne do pułapek w systemie operacyjnym.</dd> + <dt>target</dt> + <dd>Obiekt wirtualizowany przez proxy. Często jest używany aby magazyować dane obiektu proxy. Niezmienniki (wartości które pozostają niezmienione) dotyczące nierozszerzalności obiektu lub niekonfigurowalnnych atrybutów są weryfikowane w oparciu o <strong>target</strong>.</dd> +</dl> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">var p = new Proxy(target, handler); +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>target</code></dt> + <dd>Docelowy obiekt (może być obiektem dowolnego typu, włącznie z wbudowanymi tablicami, funkcjami, a nawet innyi obiektami proxy) przeznaczony do opakowania przez <code>Proxy</code>.</dd> + <dt><code>handler</code></dt> + <dd>Obiekt obsługujący którego atrybuty są funkcjami definiującymi zachowanie proxy podczas wykonania na nim operacji.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Proxy.revocable()")}}</dt> + <dd>Tworzy odwracalny obiekt <code>Proxy</code>.</dd> +</dl> + +<h2 id="Metody_obiektu_obsługującego">Metody obiektu obsługującego</h2> + +<p>Obiekt obsługujący jest obiektem zastępczym zawierającym pułapki dla obieku <code>Proxy</code>.</p> + +<div>{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Proxy/handler', 'Metody') }}</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Podstawowy_przykład">Podstawowy przykład</h3> + +<p>W tym prostym przykładzie liczba <code>37</code> jest zwracana jako domyślna wartość kiedy nazwa atrybutu nie istnieje w obiekcie. W tym celu użyty jest handler <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get"><code>get</code></a>.</p> + +<pre class="brush: js">var handler = { + get: function(target, name) { + return name in target ? + target[name] : + 37; + } +}; + +var p = new Proxy({}, handler); +p.a = 1; +p.b = undefined; + +console.log(p.a, p.b); // 1, undefined +console.log('c' in p, p.c); // false, 37 +</pre> + +<h3 id="Puste_proxy_przekazujące">Puste proxy przekazujące</h3> + +<p>W tym przykładzie używamy wbudowanego obiektu JavaScript do którego proxy przekaże wszystkie zaaplikowane na nim operacje.</p> + +<pre class="brush: js">var target = {}; +var p = new Proxy(target, {}); + +p.a = 37; // operacja przekazana do obiektu target + +console.log(target.a); // 37. Operacja została prawidłowo przekazana +</pre> + +<p>Zwróć uwagę, że ten przykład działa dla obiektów JavaScript jednak nie sprawdzi się w przypadku obiektów przeglądarki takich jak elementy DOM. <a href="/en-US/docs/">Sprawdź jedno rozwiązanie</a>.</p> + +<h3 id="Walidacja">Walidacja</h3> + +<p>Używając <code>Proxy</code>, łatwo możesz zwalidować wartości przekazywane do obiektu. Poniższy przykład używa metody obsługującej <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"><code>set</code></a>.</p> + +<pre class="brush: js">let validator = { + set: function(obj, prop, value) { + if (prop === 'age') { + if (!Number.isInteger(value)) { + throw new TypeError('The age is not an integer'); + } + if (value > 200) { + throw new RangeError('The age seems invalid'); + } + } + + // domyślnym zachowaniem jest zapisanie wartości + obj[prop] = value; + + // oznacza pomyślne wykonanie + return true; + } +}; + +let person = new Proxy({}, validator); + +person.age = 100; +console.log(person.age); // 100 +person.age = 'young'; // rzuca wyjątek +person.age = 300; // rzuca wyjątek</pre> + +<h3 id="Rozszerzanie_konstruktora">Rozszerzanie konstruktora</h3> + +<p>Funkcja proxy może w łatwy sposób rozszerzyć konstruktor innym konstruktorem. W tym przykładzie użyto funkcje obsługujące <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/construct"><code>construct</code></a> oraz <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/apply"><code>apply</code></a>.</p> + +<pre class="brush: js">function extend(sup, base) { + var descriptor = Object.getOwnPropertyDescriptor( + base.prototype, 'constructor' + ); + base.prototype = Object.create(sup.prototype); + var handler = { + construct: function(target, args) { + var obj = Object.create(base.prototype); + this.apply(target, obj, args); + return obj; + }, + apply: function(target, that, args) { + sup.apply(that, args); + base.apply(that, args); + } + }; + var proxy = new Proxy(base, handler); + descriptor.value = proxy; + Object.defineProperty(base.prototype, 'constructor', descriptor); + return proxy; +} + +var Person = function(name) { + this.name = name; +}; + +var Boy = extend(Person, function(name, age) { + this.age = age; +}); + +Boy.prototype.sex = 'M'; + +var Peter = new Boy('Peter', 13); +console.log(Peter.sex); // "M" +console.log(Peter.name); // "Peter" +console.log(Peter.age); // 13</pre> + +<h3 id="Manipulacja_węzłami_DOM">Manipulacja węzłami DOM</h3> + +<p>Czasami konieczne jest przełączenie atrybutu lub nazwy klasy dwóch innych elementów. Poniższy przykład pokazuje wykonanie funkcją obsługującą <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"><code>set</code></a>.</p> + +<pre class="brush: js">let view = new Proxy({ + selected: null +}, +{ + set: function(obj, prop, newval) { + let oldval = obj[prop]; + + if (prop === 'selected') { + if (oldval) { + oldval.setAttribute('aria-selected', 'false'); + } + if (newval) { + newval.setAttribute('aria-selected', 'true'); + } + } + + // The default behavior to store the value + obj[prop] = newval; + + // Indicate success + return true; + } +}); + +let i1 = view.selected = document.getElementById('item-1'); +console.log(i1.getAttribute('aria-selected')); // 'true' + +let i2 = view.selected = document.getElementById('item-2'); +console.log(i1.getAttribute('aria-selected')); // 'false' +console.log(i2.getAttribute('aria-selected')); // 'true'</pre> + +<h3 id="Korekcja_wartości_i_dodatkowych_atrybutów">Korekcja wartości i dodatkowych atrybutów</h3> + +<p>Obiekt proxy <code>products</code> wylicza przekazaną wartość i konwertuje to tablicy w razie potrzeby. Obiekt dodatkowo obsługuje dodatkowy atrybut <code>latestBrowser</code> zarówno jako getter i setter.</p> + +<pre class="brush: js">let products = new Proxy({ + browsers: ['Internet Explorer', 'Netscape'] +}, +{ + get: function(obj, prop) { + // An extra property + if (prop === 'latestBrowser') { + return obj.browsers[obj.browsers.length - 1]; + } + + // The default behavior to return the value + return obj[prop]; + }, + set: function(obj, prop, value) { + // An extra property + if (prop === 'latestBrowser') { + obj.browsers.push(value); + return true; + } + + // Convert the value if it is not an array + if (typeof value === 'string') { + value = [value]; + } + + // The default behavior to store the value + obj[prop] = value; + + // Indicate success + return true; + } +}); + +console.log(products.browsers); // ['Internet Explorer', 'Netscape'] +products.browsers = 'Firefox'; // przekazano string (przez pomyłkę) +console.log(products.browsers); // ['Firefox'] <- nie ma problemu, wartość jest typu array + +products.latestBrowser = 'Chrome'; +console.log(products.browsers); // ['Firefox', 'Chrome'] +console.log(products.latestBrowser); // 'Chrome'</pre> + +<h3 id="Wyszukiwanie_elementu_tablicy_po_jego_właściwości">Wyszukiwanie elementu tablicy po jego właściwości</h3> + +<p>Poniższe proxy rozszerza tablicę o różne użyteczne funkcjonalności. Jak widać, można elastycznie "definiować" właściwości bez użycia <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties"><code>Object.defineProperties</code></a>. Ten przykład może być użyty aby znaleźć wiersz tabeli po jego komórce. W takim przypadku, celem będzie <a href="/en-US/docs/DOM/table.rows"><code>table.rows</code></a>.</p> + +<pre class="brush: js">let products = new Proxy([ + { name: 'Firefox', type: 'browser' }, + { name: 'SeaMonkey', type: 'browser' }, + { name: 'Thunderbird', type: 'mailer' } +], +{ + get: function(obj, prop) { + // domyślnym zachowaniem jest zwrócenie wartości; prop jest zwykle typu integer + if (prop in obj) { + return obj[prop]; + } + + // zwróć liczbę produktów; alias dla products.length + if (prop === 'number') { + return obj.length; + } + + let result, types = {}; + + for (let product of obj) { + if (product.name === prop) { + result = product; + } + if (types[product.type]) { + types[product.type].push(product); + } else { + types[product.type] = [product]; + } + } + + // znajdź product po nazwie + if (result) { + return result; + } + + // znajdź produkty po typie + if (prop in types) { + return types[prop]; + } + + // zwróć typy produktów + if (prop === 'types') { + return Object.keys(types); + } + + return undefined; + } +}); + +console.log(products[0]); // { name: 'Firefox', type: 'browser' } +console.log(products['Firefox']); // { name: 'Firefox', type: 'browser' } +console.log(products['Chrome']); // undefined +console.log(products.browser); // [{ name: 'Firefox', type: 'browser' }, { name: 'SeaMonkey', type: 'browser' }] +console.log(products.types); // ['browser', 'mailer'] +console.log(products.number); // 3 +</pre> + +<h3 id="Pełna_lista_przykładów_pułapek">Pełna lista przykładów <code>pułapek</code></h3> + +<p>W celu stworzenia pełnej listy przykładów <code>pułapek</code>, w celach dydaktycznych, spróbujemy zastosować proxy na<em>nie natywnym obiekcie </em>który się szczególnie nadaje do tego typu operacji: globalny obiekt <code>docCookies</code> stworzony przez <a href="https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie/Simple_document.cookie_framework" title="https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support">"mały framework" opublikowany na stronie <code>document.cookie</code></a>.</p> + +<pre class="brush: js">/* + var docCookies = ... pobranie obiektu "docCookies" tutaj: + https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support +*/ + +var docCookies = new Proxy(docCookies, { + get: function (oTarget, sKey) { + return oTarget[sKey] || oTarget.getItem(sKey) || undefined; + }, + set: function (oTarget, sKey, vValue) { + if (sKey in oTarget) { return false; } + return oTarget.setItem(sKey, vValue); + }, + deleteProperty: function (oTarget, sKey) { + if (sKey in oTarget) { return false; } + return oTarget.removeItem(sKey); + }, + enumerate: function (oTarget, sKey) { + return oTarget.keys(); + }, + ownKeys: function (oTarget, sKey) { + return oTarget.keys(); + }, + has: function (oTarget, sKey) { + return sKey in oTarget || oTarget.hasItem(sKey); + }, + defineProperty: function (oTarget, sKey, oDesc) { + if (oDesc && 'value' in oDesc) { oTarget.setItem(sKey, oDesc.value); } + return oTarget; + }, + getOwnPropertyDescriptor: function (oTarget, sKey) { + var vValue = oTarget.getItem(sKey); + return vValue ? { + value: vValue, + writable: true, + enumerable: true, + configurable: false + } : undefined; + }, +}); + +/* Cookies test */ + +console.log(docCookies.my_cookie1 = 'First value'); +console.log(docCookies.getItem('my_cookie1')); + +docCookies.setItem('my_cookie1', 'Changed value'); +console.log(docCookies.my_cookie1);</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-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES2016', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2016')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES2017', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2017')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.Proxy", 2)}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a class="external" href="https://www.youtube.com/watch?v=sClk6aB_CPk">"Proxies are awesome" Brendan Eich presentation at JSConf</a> (<a class="external" href="http://www.slideshare.net/BrendanEich/metaprog-5303821">slides</a>)</li> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies">ECMAScript Harmony Proxy proposal page</a> and <a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies_semantics">ECMAScript Harmony proxy semantics page</a></li> + <li><a class="external" href="http://soft.vub.ac.be/~tvcutsem/proxies/">Tutorial on proxies</a></li> + <li><a href="/en-US/docs/JavaScript/Old_Proxy_API" title="/en-US/docs/JavaScript/Old_Proxy_API">SpiderMonkey specific Old Proxy API</a></li> + <li>{{jsxref("Object.watch()")}} is a non-standard feature but has been supported in Gecko for a long time.</li> +</ul> + +<h2 id="Licensing_note">Licensing note</h2> + +<p>Some content (text, examples) in this page has been copied or adapted from the <a class="external" href="http://wiki.ecmascript.org/doku.php">ECMAScript wiki</a> which content is licensed <a class="external" href="http://creativecommons.org/licenses/by-nc-sa/2.0/">CC 2.0 BY-NC-SA</a>.</p> diff --git a/files/pl/web/javascript/reference/global_objects/proxy/proxy/apply/index.html b/files/pl/web/javascript/reference/global_objects/proxy/proxy/apply/index.html new file mode 100644 index 0000000000..1037441e42 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/proxy/proxy/apply/index.html @@ -0,0 +1,118 @@ +--- +title: handler.apply() +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply +tags: + - ECMAScript 2015 + - JavaScript + - Metodă + - Proxy +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply +original_slug: Web/JavaScript/Referencje/Obiekty/Proxy/handler/apply +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>handler.apply()</code></strong> jest pułapką na wywołanie funkcji.</p> + +<div>{{EmbedInteractiveExample("pages/js/proxyhandler-apply.html", "taller")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js">var p = new Proxy(target, { + apply: function(target, thisArg, argumentsList) { + } +}); +</pre> + +<h3 id="Parametry">Parametry</h3> + +<p>Następujące parametry są przekazywane do metody <code>apply</code>. Wartością <code>this</code> jest handler.</p> + +<dl> + <dt><code>target</code></dt> + <dd>Obiekt, na którym została wywołana metoda.</dd> + <dt><code>thisArg</code></dt> + <dd>Obiekt, który jest <code>this</code> w metodzie.</dd> + <dt><code>argumentsList</code></dt> + <dd>Lista argumentów, które zostały przekazane do metody.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Metoda <code>apply</code> może zwrócić dowolną wartość.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda <code><strong>handler.apply</strong></code> jest pułapką na wywołanie funkcji.</p> + +<h3 id="Przechwycenia">Przechwycenia</h3> + +<p>Ta pułapka może przechwycić poniższe operacje:</p> + +<ul> + <li><code>proxy(...args)</code></li> + <li>{{jsxref("Function.prototype.apply()")}} i {{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Reflect.apply()")}}</li> +</ul> + +<h3 id="Niezmienniki">Niezmienniki</h3> + +<p>Jeśli poniższe zmiemienniki są naruszone, poxy rzuci wyjątek TypeError:</p> + +<p><code>target</code> musi być obiektem, który da się wywołać. To znaczy, że musi być obiektem funkcyjnym.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Poniższy kod przechwytuje wywołanie funkcji.</p> + +<pre class="brush: js">var p = new Proxy(function() {}, { + apply: function(target, thisArg, argumentsList) { + console.log('called: ' + argumentsList.join(', ')); + return argumentsList[0] + argumentsList[1] + argumentsList[2]; + } +}); + +console.log(p(1, 2, 3)); // "called: 1, 2, 3" + // 6 +</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-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist', '[[Call]]')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist', '[[Call]]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Proxy.handler.apply")}}</p> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Proxy")}}</li> + <li>{{jsxref("Proxy.handler", "handler")}}</li> + <li>{{jsxref("Function.prototype.apply")}}</li> + <li>{{jsxref("Function.prototype.call")}}</li> + <li>{{jsxref("Reflect.apply()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/proxy/proxy/index.html b/files/pl/web/javascript/reference/global_objects/proxy/proxy/index.html new file mode 100644 index 0000000000..0b5819767e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/proxy/proxy/index.html @@ -0,0 +1,79 @@ +--- +title: Proxy handler +slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy +translation_of_original: Web/JavaScript/Reference/Global_Objects/Proxy/handler +original_slug: Web/JavaScript/Referencje/Obiekty/Proxy/handler +--- +<div>{{JSRef}}</div> + +<p>Obiekt obsługujący proxy (proxy's handler object) jest obiektem zastępczym który zawiera pułapki dla obiektów {{jsxref("Proxy", "proxy", "", 1)}}.</p> + +<h2 id="Metody">Metody</h2> + +<p>Wszystkie pułapki są opcjonalne. Jeśli pułapka nie została zdefiniowana, domyślnym zachowaniem jest przekazanie operacji do obiektu docelowego.</p> + +<dl> + <dt>{{jsxref("Global_Objects/Proxy/handler/getPrototypeOf", "handler.getPrototypeOf()")}}</dt> + <dd>Pułapka na {{jsxref("Object.getPrototypeOf")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/setPrototypeOf", "handler.setPrototypeOf()")}}</dt> + <dd>Pułapka na {{jsxref("Object.setPrototypeOf")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/isExtensible", "handler.isExtensible()")}}</dt> + <dd>Pułapka na {{jsxref("Object.isExtensible")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/preventExtensions", "handler.preventExtensions()")}}</dt> + <dd>Pułapka na {{jsxref("Object.preventExtensions")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/getOwnPropertyDescriptor", "handler.getOwnPropertyDescriptor()")}}</dt> + <dd>Pułapka na {{jsxref("Object.getOwnPropertyDescriptor")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/defineProperty", "handler.defineProperty()")}}</dt> + <dd>Pułapka na {{jsxref("Object.defineProperty")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/has", "handler.has()")}}</dt> + <dd>Pułapka na operator {{jsxref("Operators/in", "in")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/get", "handler.get()")}}</dt> + <dd>Pułapka na pobieranie wartości atrybutu.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/set", "handler.set()")}}</dt> + <dd>Pułapka na ustawianie wartości atrybutu.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/deleteProperty", "handler.deleteProperty()")}}</dt> + <dd>Pułapka na operator {{jsxref("Operators/delete", "delete")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/ownKeys", "handler.ownKeys()")}}</dt> + <dd>Pułapka na {{jsxref("Object.getOwnPropertyNames")}} i {{jsxref("Object.getOwnPropertySymbols")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/apply", "handler.apply()")}}</dt> + <dd>Pułapka na wywołanie funkcji.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/construct", "handler.construct()")}}</dt> + <dd>Pułapka na operator {{jsxref("Operators/new", "new")}}.</dd> +</dl> + +<p>Niektóre niestandardowe pułapki są <a href="/en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features#Proxy">przestarzałe i zostały usunięte</a>.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots', 'Proxy Object Internal Methods and Internal Slots')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots', 'Proxy Object Internal Methods and Internal Slots')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Usunięto funkcję obsługującą <code>enumerate</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.Proxy.handler")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Proxy")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/rangeerror/index.html b/files/pl/web/javascript/reference/global_objects/rangeerror/index.html new file mode 100644 index 0000000000..f9037c41a2 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/rangeerror/index.html @@ -0,0 +1,163 @@ +--- +title: RangeError +slug: Web/JavaScript/Reference/Global_Objects/RangeError +translation_of: Web/JavaScript/Reference/Global_Objects/RangeError +original_slug: Web/JavaScript/Referencje/Obiekty/RangeError +--- +<div>{{JSRef}}</div> + +<p>Obiekt <code><strong>RangeError</strong></code> wskazuje na błąd, gdy wartość jest poza zakresem dozwolonych wartości.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>new RangeError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>message</code></dt> + <dd><code>Opcjonalne. Czytelny opis błędu.</code></dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Opcjonalne. Nazwa pliku zawierającego kod, któy wywołał wyjątek.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Opcjonalne. Numer linii kodu, gdzie wywołany został wyjątek.</dd> +</dl> + +<h2 id="sect1"> </h2> + +<h2 id="Opis">Opis</h2> + +<p><code>RangeError</code> rzucany jest podczas próby przesłaniu numeru, jako argumentu do funkcji, która nie pozwala na zakresy zawierające ten numer. To może zdarzyć się podczas próby stworzenia listy (array) o niedozwolonej długości za pomocą konstruktora {{jsxref("Array")}}, lub podczas wywołania metod {{jsxref("Number.toExponential()")}}, {{jsxref("Number.toFixed()")}} lub {{jsxref("Number.toPrecision()")}} z przekazaną złą wartością.</p> + +<p> </p> + +<h2 id="Właściwości">Właściwości</h2> + +<dl> + <dt>{{jsxref("RangeError.prototype")}}</dt> + <dd>Pozwala na dodanie właściwości do obiektu RangeError.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<p><code>RangeError</code> nie posiada metod jako takich, ale dziedziczy pewne metody z łańcucha prototypów.</p> + +<h2 id="Instancje_RangeError"><code>Instancje RangeError</code></h2> + +<h3 id="Właściwości_2">Właściwości</h3> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/RangeError/prototype', 'Właściwości')}}</div> + +<h3 id="Metody_2">Metody</h3> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/RangeError/prototype', 'Metody')}}</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_RangeError">Użycie <code>RangeError</code></h3> + +<pre class="brush: js">var check = function(num) { + if (num < MIN || num > MAX) { + throw new RangeError('Parameter must be between ' + MIN + ' and ' + MAX); + } +}; + +try { + check(500); +} +catch (e) { + if (e instanceof RangeError) { + // Handle range error + } +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.2', 'RangeError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-rangeerror', 'RangeError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</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>Bazowe wsparcie</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>Bazowe wsparcie</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_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("RangeError.prototype")}}</li> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Number.toExponential()")}}</li> + <li>{{jsxref("Number.toFixed()")}}</li> + <li>{{jsxref("Number.toPrecision()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/regexp/exec/index.html b/files/pl/web/javascript/reference/global_objects/regexp/exec/index.html new file mode 100644 index 0000000000..8385a71d92 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/regexp/exec/index.html @@ -0,0 +1,145 @@ +--- +title: RegExp.prototype.exec() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/exec +tags: + - JavaScript + - Method + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec +original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/exec +--- +<p>{{ JSRef }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wykonuje operacje wyszukiwania danego łańcucha znaków. Wynikiem jest macierz.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>regexObj</var>.exec(<var>str</var>)</code></pre> + +<p> </p> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>str</code> </dt> + <dd>Łańcuch znaków, do którego ma być porównane wyrażenie.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jak wynika z opisu składni metoda exec może być wywołana w sposób bezpośredni (za pomocą <code>regexp.exec(str)</code>) lub pośredni (za pomocą <code>regexp(str)</code>).</p> + +<p>Jeśli wynik będzie pozytywny metoda <code>exec</code> zwróci macierz oraz zaktualizuje własności obiektu. W przeciwnym wypadku zostanie zwrócone <code>null</code>.</p> + +<p>Przejrzyj poniższy przykład:</p> + +<pre class="brush: js">//Znajdź pojedyncze "d" poprzedzone przez jedno lub więcej "b", po których następuje pojedyncze "d" +//Zapamiętaj znalezione "b" oraz następujące "d" +//Ignoruj wielkość liter +var re=/d(b+)(d)/ig; +var myArray = re.exec("cdbBdbsbz"); +</pre> + +<p>Poniższa tabela pokazuje rezultaty wygenerowane przez skrypt:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Obiekt</td> + <td class="header">Właściwość/Indeks</td> + <td class="header">Opis</td> + <td class="header">Przykład</td> + </tr> + <tr> + <td rowspan="5"><code>myArray</code></td> + <td><code> </code></td> + <td>Zawartość <code>myArray</code>.</td> + <td><code>[ \"dbBd\", \"bB\", \"d\"') ]</code></td> + </tr> + <tr> + <td><code>index</code></td> + <td>Indeks wyszukania łańcucha znaków rozpoczynający się od 0.</td> + <td><code>1</code></td> + </tr> + <tr> + <td><code>input</code></td> + <td>Ciąg bazowy.</td> + <td><code>cdbBdbsbz</code></td> + </tr> + <tr> + <td><code>[0]</code></td> + <td>Ostatnie odnalezione znaki.</td> + <td><code>dbBd</code></td> + </tr> + <tr> + <td><code>[1], ...[<em>n</em> ]</code></td> + <td>Wyszukane podłańcuch w nawiasach. Liczba możliwych podłańcuch jest nieokreślona.</td> + <td><code>[1] = bB<br> + [2] = d</code></td> + </tr> + <tr> + <td rowspan="5"><code>myRe</code></td> + <td><code>lastIndex</code></td> + <td>Indeks, od którego rozpocząć nowe wyszukiwanie.</td> + <td><code>5</code></td> + </tr> + <tr> + <td><code>ignoreCase</code></td> + <td>Wskazuje czy flaga "<code>i</code>" została użyta.</td> + <td><code>true</code></td> + </tr> + <tr> + <td><code>global</code></td> + <td>Wskazuje czy flaga "<code>g</code>" została użyta do globalnego przeszukiwania.</td> + <td><code>true</code></td> + </tr> + <tr> + <td><code>multiline</code></td> + <td>Wskazuje czy flaga "<code>m</code>" została użyta do globalnego przeszukiwania.</td> + <td><code>false</code></td> + </tr> + <tr> + <td><code>source</code></td> + <td>Tekst wyszukiwanego łańcucha znaków.</td> + <td><code>d(b+)(d)</code></td> + </tr> + </tbody> +</table> + +<p>Jeżeli twoje wyrażenie regularne korzysta z flagi "g", możesz wielokrotnie używać metody exec() aby porównać je z tym samym ciągiem znaków. W takim wypadku porównywanie rozpoczyna się od elementu zdefiniowanego jako <code>lastIndex. </code>Na przykład:</p> + +<pre class="brush: js language-js"><code class="language-js"><span class="keyword token">var</span> myRe <span class="operator token">=</span> <span class="regex token">/ab*/g</span><span class="punctuation token">;</span> +<span class="keyword token">var</span> str <span class="operator token">=</span> <span class="string token">'abbcdefabh'</span><span class="punctuation token">;</span> +<span class="keyword token">var</span> myArray<span class="punctuation token">;</span> +<span class="keyword token">while</span> <span class="punctuation token">(</span><span class="punctuation token">(</span>myArray <span class="operator token">=</span> myRe<span class="punctuation token">.</span><span class="function token">exec<span class="punctuation token">(</span></span>str<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">!</span><span class="operator token">==</span> <span class="keyword token">null</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> msg <span class="operator token">=</span> <span class="string token">'Found '</span> <span class="operator token">+</span> myArray<span class="punctuation token">[</span><span class="number token">0</span><span class="punctuation token">]</span> <span class="operator token">+</span> <span class="string token">'. '</span><span class="punctuation token">;</span> + msg <span class="operator token">+</span><span class="operator token">=</span> <span class="string token">'Next match starts at '</span> <span class="operator token">+</span> myRe<span class="punctuation token">.</span>lastIndex<span class="punctuation token">;</span> + console<span class="punctuation token">.</span><span class="function token">log<span class="punctuation token">(</span></span>msg<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></pre> + +<p>Skrypt ten wyświetli następujący tekst:</p> + +<pre>Found abb. Next match starts at 3 +Found ab. Next match starts at 9 +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_exec" name="Przyk.C5.82ad:_Zastosowanie_exec">Przykład: Zastosowanie <code>exec()</code></h3> + +<p>You can also use <code>exec()</code> without creating a {{jsxref("RegExp")}} object:</p> + +<pre class="brush: js language-js"><code class="language-js"><span class="keyword token">var</span> matches <span class="operator token">=</span> <span class="regex token">/(hello \S+)/</span><span class="punctuation token">.</span><span class="function token">exec<span class="punctuation token">(</span></span><span class="string token">'This is a hello world!'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +console<span class="punctuation token">.</span><span class="function token">log<span class="punctuation token">(</span></span>matches<span class="punctuation token">[</span><span class="number token">1</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>This will display an alert containing 'hello world!'.</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="https://developer.mozilla.org//pl/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("RegExp")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/regexp/global/index.html b/files/pl/web/javascript/reference/global_objects/regexp/global/index.html new file mode 100644 index 0000000000..db7b9adf71 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/regexp/global/index.html @@ -0,0 +1,36 @@ +--- +title: RexExp.prototype.global +slug: Web/JavaScript/Reference/Global_Objects/RegExp/global +tags: + - JavaScript + - Property + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/global +original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/global +--- +<div>{{JSRef("Global_Objects", "RegExp")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Określa czy z wyrażeniem regularnym została użyta flaga "<code>g</code>".</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>global</code> jest własnością pojedynczego obiektu wyrażenia regularnego.</p> + +<p>Wartość <code>global</code> wynosi true, jeśli użyta została flaga "<code>g</code>"; w przeciwnym przypadku będzie to wartość <code>false</code>. Flaga "<code>g</code>" wskazuje, że wyrażenie regularne powinno zostać sprawdzone w stosunku do wszystkich możliwych wyników w łańcuchu znaków.</p> + +<p>Tej własności nie można zmieniać bezpośrednio.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("RegExp.lastIndex")}}</li> + <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li> + <li>{{jsxref("RegExp.prototype.multiline")}}</li> + <li>{{jsxref("RegExp.prototype.source")}}</li> + <li>{{jsxref("RegExp.prototype.sticky")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/regexp/ignorecase/index.html b/files/pl/web/javascript/reference/global_objects/regexp/ignorecase/index.html new file mode 100644 index 0000000000..5de3081dbf --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/regexp/ignorecase/index.html @@ -0,0 +1,36 @@ +--- +title: RegExp.prototype.ignoreCase +slug: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase +tags: + - JavaScript + - Property + - RegExp + - protype +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase +original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/ignoreCase +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Określa czy z wyrażeniem regularnym została użyta flaga "<code>i</code>".</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>ignoreCase</code> jest własnością pojedynczego obiektu wyrażenia regularnego.</p> + +<p>Wartość <code>ignoreCase</code> wynosi <code>true</code>, jeśli użyta została flaga "<code>i</code>"; w przeciwnym przypadku będzie to wartość <code>false</code>. Flaga "<code>i</code>" wskazuje, że wielkość znaków ma być ignorowana podczas dokonywania porównań w łańcuchu znaków.</p> + +<p>Tej własności nie można zmieniać bezpośrednio.</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("RegExp.lastIndex")}}</li> + <li>{{jsxref("RegExp.prototype.global")}}</li> + <li>{{jsxref("RegExp.prototype.multiline")}}</li> + <li>{{jsxref("RegExp.prototype.source")}}</li> + <li>{{jsxref("RegExp.prototype.sticky")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/regexp/index.html b/files/pl/web/javascript/reference/global_objects/regexp/index.html new file mode 100644 index 0000000000..8d3d520453 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/regexp/index.html @@ -0,0 +1,384 @@ +--- +title: RegExp +slug: Web/JavaScript/Reference/Global_Objects/RegExp +tags: + - Constructor + - JavaScript + - RegExp + - Regular Expressions +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +original_slug: Web/JavaScript/Referencje/Obiekty/RegExp +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Obiekt wyrażeń regularnych (ang. <em>regular expression</em>) zawiera wzór regularnego wyrażenia. Posiada ono właściwości i metody, które umożliwiają znalezienie lub zmianę ciągu znaków w innym ciągu znaków.</p> + +<p>W dodatku do właściwości pojedynczego obiektu wyrażenia regularnego, które tworzysz używając funkcji konstruktora <code>RegExp</code>, predefiniowany obiekt <code>RegExp</code> posiada własności statyczne, które są ustawione, kiedy jakiekolwiek wyrażenie regularne jest użyte.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Tworzony przez</h2> + +<p>Odpowiednik tekstowy lub funkcja-konstruktor <code>RegExp</code>.</p> + +<p>Odpowiednik tekstowy jest używany jak poniżej:</p> + +<pre class="brush: js"><em>/wzór/flagi</em> +</pre> + +<p>Konstruktor jest używany jak poniżej:</p> + +<pre class="brush: js">new RegExp("<em>wzór</em>"[, "<em>flagi</em>"]) +</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>wzór</code></dt> + <dd>Tekst wyrażenia regularnego.</dd> + <dt><code>flagi</code></dt> + <dd>Jeśli podane, flagi mogą mieć jakąkolwiek kombinację poniższych wartości: <code>g</code> - wyszukiwanie globalne, <code>i</code> - ignoruje wielkość liter, <code>m</code> - wyszukiwanie w wielu liniach.</dd> +</dl> + +<p>Zauważ, że parametry w formacie tekstowym nie używają cudzysłowu do oznaczenia ciągów znaków, kiedy parametry funkcji konstruktora używają cudzysłów. Tak, więc poniższe wyrażenia tworzą to samo wyrażenie regularne:</p> + +<pre class="brush: js">/ab+c/i; +new RegExp("ab+c", "i"); +</pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Podczas użycia funkcji konstruktora, standardowe znaki ucieczki (<em>string escape rule</em>, poprzedzanie znaków specjalnych <em>backslash'’ "\" kiedy użyte w ciągu znaków) są wymagane. Na przykład poniższe dwa przykłady są identyczne:</em></p> + +<pre class="brush: js">re = new RegExp("\\w+"); +re = /\w+/; +</pre> + +<h3 id="Znaki_specjalne_w_wyra.C5.BCeniach_regularnych" name="Znaki_specjalne_w_wyra.C5.BCeniach_regularnych">Znaki specjalne w wyrażeniach regularnych</h3> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Znak</td> + <td class="header">Znaczenie</td> + </tr> + <tr> + <td><code>\</code></td> + <td> + <p>Dla znaków które zwykle są traktowane dosłownie, oznacza że następny znak jest specjalny i nie ma być interpretowany standardowo.</p> + + <p>Na przykład, <code>/b/</code> szuka znaku "b". Wstawiając backslash (<code>\</code>) przed b, to jest używając <code>/\b/</code>, znak staje się specjalny "znajdź granicę wyrazu".</p> + + <p>-lub-</p> + + <p>Dla znaków, które zwykle są traktowane jako specjalne oznacza, że następny znak jest zwykły powinien być interpretowany dosłownie.</p> + + <p>Na przykład, <code>*</code> jest znakiem specjalnym oznaczającym 0 lub więcej wystąpień poprzedzającego znaku powinno być znalezionych; na przykład, <code>/a*/</code> oznacza "znajdź 0 lub więcej znaków <code>a</code>". Aby znaleźć dosłownie <code>*</code>, poprzedź ten znak backslashem (<code>\</code>), na przykład <code>/a\*/</code> znajduje "a*".</p> + </td> + </tr> + <tr> + <td><code>^</code></td> + <td> + <p>Znajduje początek wejścia. Jeśli flaga wielu linii (ang. <em>multiline</em>) jest ustawiona na <em>prawda</em> (<code>true</code>), znajduje również od razu po znaku nowej linii.</p> + + <p>Na przykład, <code>/^B/</code> nie znajdzie "B" w "Andrzej B" ale znajdzie "B" w "Bogusław A".</p> + </td> + </tr> + <tr> + <td><code>$</code></td> + <td> + <p>Oznacza koniec wejścia. Jeśli flaga wielu linii (ang. <em>multiline</em>) jest ustawiona na <em>prawda</em> (<code>true</code>), znajduje również bezpośrednio przed znakiem końca linii.</p> + + <p>Na przykład, <code>/a$/</code> nie znajdzie "a" w "mrówkojad" ale znajdzie "a" w "mrówka".</p> + </td> + </tr> + <tr> + <td><code>*</code></td> + <td> + <p>Znajduje poprzedzającą pozycję 0 lub więcej razy.</p> + + <p>Na przykład, <code>/bu*/</code> znajdzie "buuuu" w "Duch krzyknął buuuu" i "b" w "Głośnik zabrzmiał basowo" ale nic w "Ptak zaśpiewał".</p> + </td> + </tr> + <tr> + <td><code>+</code></td> + <td> + <p>Znajduje poprzedzającą pozycję 1 lub więcej razy. Równoważne do <code>{1,}</code>.</p> + + <p>Na przykład, <code>/r+/</code> dopasuje się do "r" w "cukierek" i do wszystkich "r" w "cukierrrrrrrek".</p> + </td> + </tr> + <tr> + <td><code>?</code></td> + <td> + <p>Znajduje poprzedzającą pozycję 0 razy lub 1 raz.</p> + + <p>Na przykład <code>/o?ąt?/</code> znajdzie "oł" w "anioł" i "ąt" w "kąt".</p> + + <p>Jeśli zostanie użyte zaraz po którymś ze znaków *, +, ?, lub {}, to wymusza przejście do trybu niezachłannego (domyślne jest dopasowanie zachłanne), czyli dopasowanie następuje do najmniejszego ciągu spełniającego wyrażenie, a nie do największego.</p> + + <p>Pytajnik używany jest także w <em>lookahead assertions</em>, opisanych pod <code>(?=)</code>, <code>(?!)</code> i <code>(?:)</code> w tej tabeli.</p> + </td> + </tr> + <tr> + <td><code>.</code></td> + <td> + <p>(Kropka) znajduje jakikolwiek pojedynczy znak poza znakiem nowej linii.</p> + + <p>Na przykład, <code>/.a/</code> znajdzie "ja" i "na" w "jabłko rośnie na drzewie ale arbuz nie", ale nie znajdzie "al" i "ar".</p> + </td> + </tr> + <tr> + <td><code>(x)</code></td> + <td> + <p>Znajduje "x" i zapamiętuje to dopasowanie. Nazywa się to "nawiasy wychwytujące" (ang. <em>capturing parentheses</em>).</p> + + <p>Na przykład, <code>/(foo)/</code> znajduje i zapamiętuje "foo" w "foo bar". Znaleziony pod-ciąg (<em>substring</em>) może być ponownie wywołany elementów tablicy wynikowej <code>1, ..., n</code> jak również z predefiniowanych własności obiektu <code>RegExp</code>, <code>$1, ..., $9</code>.</p> + </td> + </tr> + <tr> + <td><code>(?:x)</code></td> + <td> + <p>Znajduje "x", ale nie pamięta dopasowania. Nazywa się to "nawiasy niewychwytujące" (ang. <em>non-capturing parentheses</em>). Znaleziony podciąg (<em>substring</em>) nie może być wywołany ponownie z elementów wynikowych tablicy <code>1, ..., n</code> ani za pomocą właściwości obiektu <code>RegExp</code>, <code>$1, ..., $9</code>.</p> + </td> + </tr> + <tr> + <td><code>x(?=y)</code></td> + <td> + <p>Znajduje "x", tylko wtedy, gdy zaraz po "x" jest "y". Na przykład, <code>/Jacek(?=Szprotka)/</code> znajdzie "Jacek" tylko, jeśli zaraz po tym jest wyraz "Szprotka". <code>/Jacek(?=Szprotka|Mróz)/</code> znajdzie "Jacek" tylko, jeśli po tym jest zaraz wyraz "Szprotka" lub "Mróz"). Jednakże, ani "Szprotka" ani "Mróz" nie jest częścią wyników.</p> + </td> + </tr> + <tr> + <td><code>x(?!y)</code></td> + <td> + <p>Znajduje "x", tylko, jeśli po "x" nie ma "y". Na przykład, <code>/\d+(?!\,)/</code> zostanie dopasowane do liczby całkowitej, tylko jeśli nie ma po niej przecinka.</p> + + <p><code>/\d+(?!\,)/.exec("3,141")</code> zostanie dopasowane tylko do 141, nie zostanie dopasowane do 3, bo wystąpił po niej przecinek.</p> + </td> + </tr> + <tr> + <td><code>x|y</code></td> + <td> + <p>Znajduje "x" lub "y".</p> + + <p>Na przykład, <code>/zielone|czerwone/</code> znajdzie "zielone" w "zielone jabłko" i "czerwone" w "czerwone jabłko".</p> + </td> + </tr> + <tr> + <td><code>{n}</code></td> + <td> + <p>Gdzie <code>n</code> jest dodatnią liczbą całkowitą. Znajduje dokładnie <code>n</code> wystąpień poprzedzającej pozycji.</p> + + <p>Na przykład, <code>/u{2}/</code> nie znajdzie "u" w "cukierek", ale znajdzie wszystkie "u" w "cuukierek" i pierwsze dwa "u" w "cuuukierek".</p> + </td> + </tr> + <tr> + <td><code>{n,}</code></td> + <td> + <p>Gdzie <code>n</code> jest dodatnią liczbą całkowitą. Znajduje, co najmniej <code>n</code> wystąpień poprzedzającej pozycji.</p> + + <p>Na przykład, <code>/u{2,}/</code> nie znajdzie "u" w "cukierek", ale znajdzie wszystkie "u" w "cuukierek" i w "cuuukierek".</p> + </td> + </tr> + <tr> + <td><code>{n,m}</code></td> + <td> + <p>Gdzie <code>n</code> i <code>m</code> są pozytywnymi liczbami całkowitymi. Wyszukuje, co najmniej <code>n</code> i co najwyżej <code>m</code> wystąpień poprzedzającego wyrażenia.</p> + + <p>Na przykład, <code>/u{1,3}/</code> nie znajdzie niczego w "ckierek", znajdzie "u" w "cukierek", znajdzie dwa "u" w "cuukierek" i pierwsze trzy "u" w "cuuuuukierek". Zauważ, że podczas wyszukiwania w "cuuuuukierek", wynik wyszukiwania to "uuu" mimo iż ciąg oryginalny zawiera więcej liter "u".</p> + </td> + </tr> + <tr> + <td><code>xyz</code></td> + <td> + <p>Zestaw znaków. Wyszukuje jakikolwiek z podanych znaków. Możesz podać przedział znaków używając myślnika.</p> + + <p>Na przykład, <code>abcd</code> oznacza tyle samo, co <code>a-d</code>. Wyrażenia te znajdą "b" w "buziak" i "d" w "kasza".</p> + </td> + </tr> + <tr> + <td><code>^xyz</code></td> + <td> + <p>Przeciwny zestaw znaków. Wyszukuje cokolwiek, co nie jest wewnątrz nawiasów. Podobnie jak powyżej można podać zakres znaków używając myślnika.</p> + + <p>Na przykład, <code>^abc</code> oznacza tyle samo, co <code>^a-c</code>. Wyrażenia te znajdą "u" w "buziak" i "k" w "kasza".</p> + </td> + </tr> + <tr> + <td><code>\\b</code></td> + <td> + <p>Wyszukuje znak backspace (nie mylić z <code>\b</code>).</p> + </td> + </tr> + <tr> + <td><code>\b</code></td> + <td> + <p>Wyszukuje granicę wyrazów (ang. <em>word boundary</em>), jak na przykład spację (nie mylić z <code>\\b</code>).</p> + + <p>Na przykład, <code>/\bn\w/</code> zaznaczy "no" w "noonday"; <code>/\wy\b/</code> zaznaczy "ly" w "possibly yesterday".</p> + </td> + </tr> + <tr> + <td><code>\B</code></td> + <td> + <p>Znajduje brak granicy niewyrazu (ang. <em>non-word boundary</em>).</p> + + <p>Na przykład, <code>/\w\Bn/</code> zaznaczy "on" w "noonday", a <code>/y\B\w/</code> zaznaczy "ye" w "possibly yesterday".</p> + </td> + </tr> + <tr> + <td><code>\cX</code></td> + <td> + <p>Gdzie <code>X</code> jest literą od A do Z. Zaznacza znak kontrolny w ciągu.</p> + + <p>Na przykład, <code>/\cM/</code> zaznaczy <code>control-M</code> w <em>string</em>u.</p> + </td> + </tr> + <tr> + <td><code>\d</code></td> + <td> + <p>Znajduje cyfrę. Odpowiednik <code>0-9</code>.</p> + + <p>Na przykład, <code>/\d/</code> lub <code>/0-9/<code> zaznaczy "2" w "B2 jest numerem pokoju". </td> </tr> </code></p> + </td> + </tr> + <tr> + <td>\D</td> + <td> + <p>Wyszukuje jakikolwiek znak nieliczbowy. Odpowiednik <code>^0-9') }}</code>.</p> + + <p>Na przykład, <code>/\D/</code> lub <code>/^0-9/</code> zaznaczy "B" w "B2 jest numerem pokoju".</p> + </td> + </tr> + <tr> + <td><code>\f</code></td> + <td> + <p>Znajduje znak wysuwu wiersza (<em>form feed</em>).</p> + </td> + </tr> + <tr> + <td><code>\n</code></td> + <td> + <p>Znajduje znak następnego wiersza (<em>line feed</em>).</p> + </td> + </tr> + <tr> + <td><code>\r</code></td> + <td> + <p>Znajduje znak powrotu karetki (<em>carriage return</em>).</p> + </td> + </tr> + <tr> + <td><code>\s</code></td> + <td> + <p>Znajduje pojedynczy biały znak (ang. <em>white space character</em>), wliczając w to spację, tabulator, znak wysuwu wiersza, znak następnego wiersza. Odpowiednik <code>\\f\\n\\r\\t\\u00A0\\u2028\\u2029</code>.</p> + + <p>Na przykład, <code>/\s\w*/</code> zaznaczy " bar" w "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\S</code></td> + <td> + <p>Zaznacza jakikolwiek znak inny niż biały (ang. <em>white space</em>). Odpowiednik <code>^ \\f\\n\\r\\t\\u00A0\\u2028\\u2029</code>.</p> + + <p>Na przykład, <code>/\S/\w*</code> zaznaczy "foo" w "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\t</code></td> + <td> + <p>Znajduje tabulator.</p> + </td> + </tr> + <tr> + <td><code>\v</code></td> + <td> + <p>Znajduje pionowy tabulator (ang. <em>vertical tab</em>).</p> + </td> + </tr> + <tr> + <td><code>\w</code></td> + <td> + <p>Znajduje jakikolwiek znak alfanumeryczny i znak podkreślenia <code>_</code>. Odpowiednik <code>A-Za-z0-9_</code>.</p> + + <p>Na przykład, <code>/\w/</code> zaznaczy "j" w "jabłko", "5" w "??5.28", i "3" w "3D".</p> + </td> + </tr> + <tr> + <td><code>\W</code></td> + <td> + <p>Zaznaczy jakikolwiek znak niewyrazowy. Odpowiednik <code>^A-Za-z0-9_</code>.</p> + + <p>Na przykład, <code>/\W/</code> lub <code>/^$A-Za-z0-9_/</code> znajdzie "%" w "50%".</p> + </td> + </tr> + <tr> + <td><code>\n</code></td> + <td> + <p>Gdzie <code>n</code> jest pozytywną liczbą całkowitą. Odwołanie wsteczne (ang. <em>back reference</em>) do ostatniego podciągu (<em>substring</em>) pasującego do n wyrażenia umieszczonego w nawiasie (licząc od nawiasu otwierającego "(").</p> + + <p>Na przykład, <code>/jabłko(,)\spomarańcz\1/</code> pasuje do "jabłko, pomarańcz," w "jabłko, pomarańcz, wiśnia, brzoskwinia". Dokładniejszy przykład znajduje się po tabeli.</p> + </td> + </tr> + <tr> + <td><code>\0</code></td> + <td> + <p>Wyszukuje znak NUL. Bezpośrednio po <code>\0</code> nie powinna znajdować się żadna liczba.</p> + </td> + </tr> + <tr> + <td><code>\xhh</code></td> + <td> + <p>Znajduje znak o kodzie hh (dwie cyfry szesnastkowe)</p> + </td> + </tr> + <tr> + <td><code>\uhhhh</code></td> + <td> + <p>Znajduje znak o kodzie hhhh (cztery cyfry szesnastkowe).</p> + </td> + </tr> + </tbody> +</table> + +<p>Notacja tekstowa zostaje skompilowana, kiedy wyrażenie regularne jest wykonane. Używaj notacji tekstowej wtedy, kiedy wyrażenie regularne pozostanie niezmienione. Na przykład, jeśli użyjesz notacji tekstowej do konstrukcji wyrażenia regularnego w pętli, wyrażenie to nie zostanie przekompilowane podczas każdej iteracji.</p> + +<p>Konstruktor obiektu wyrażenia regularnego, na przykład <code>new RegExp("ab+c")</code>, pozwala na kompilację podczas czasu wykonywania (ang. <em>runtime compilation</em>) wyrażenia. Używaj funkcji konstruktora, kiedy wiesz, że wzór wyrażenia regularnego będzie się zmieniać lub gdy nie znasz tego wzoru i pobierasz go z innego źródła, jak na przykład wejście użytkownika.</p> + +<p>Oddzielny predefiniowany obiekt <code>RegExp</code> jest dostępny dla każdego okna, to jest każdy oddzielny wątek uruchomienia JavaScriptu dostaje jego własny obiekt <code>RegExp</code>. Jako że każdy skrypt uruchamiany jest cały w oddzielnym wątku, zapewnia to, iż oddzielne skrypty nie nadpisują wartości obiektu <code>RegExp</code>.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("RegExp.prototype")}}</dt> + <dd>Pozwala na dodanie własności wszystkim obiektom.</dd> + <dt><code>RegExp.length</code></dt> + <dd>Wartość parametru <code>RegExp.length</code> wynosi 2.</dd> + <dt>{{jsxref("RegExp.lastIndex")}}</dt> + <dd>Indeks, od którego rozpoczynać następne szukanie.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<p>Globalny objekt <code>RegExp</code> nie posiada własnych metod, jednam może dziedziczyć metody z innych obiektów.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_replace" name="Przyk.C5.82ad:_Zastosowanie_metody_replace">Przykład: Zastosowanie metody <code>replace</code></h3> + +<p>Poniższy przykład używa metodę <code>replace</code> do zamiany wyrazów w ciągu (<em>stringu</em>). Podczas zamiany tekstu, skrypt używa "<code>$1</code>" i "<code>$2</code>" do oznaczenia wyników odpowiadających im nawiasów we wzorze wyrażenia regularnego.</p> + +<pre class="brush: js">var re = /(\w+)\s(\w+)/; +var str = "Jan Kowalski"; +var newstr = str.replace(re, "$2, $1"); +document.write(newstr); +</pre> + +<p>Wyświetli "Kowalski, Jan".</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>Rozdział w <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a> o <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a></li> + <li>{{jsxref("String.prototype.match()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/regexp/lastmatch/index.html b/files/pl/web/javascript/reference/global_objects/regexp/lastmatch/index.html new file mode 100644 index 0000000000..f9f1c9a129 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/regexp/lastmatch/index.html @@ -0,0 +1,55 @@ +--- +title: RegExp.lastMatch ($&) +slug: Web/JavaScript/Reference/Global_Objects/RegExp/lastMatch +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/lastMatch +original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/lastMatch +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Niestandardowa właściwość <strong>lastMatch</strong> jest właściwością statyczną, tylko do odczytu wyrażeń regularnych, który zawiera ostatnie dopasowane znaki. <code>RegExp.$&</code> jest aliasem tej właściwości.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>RegExp</var>.lastMatch +RegExp['$&'] +</pre> + +<h2 id="Description">Description</h2> + +<p>The <code>lastMatch</code> property is static, it is not a property of an individual regular expression object. Instead, you always use it as <code>RegExp.lastMatch</code> or <code>RegExp['$&'].</code></p> + +<p>The value of the <code>lastMatch</code> property is read-only and modified whenever a successful match is made.</p> + +<p>You can not use the shorthand alias with the dot property accessor (<code>RegExp.$&</code>), because the parser expects an expression with "&" in that case and a {{jsxref("SyntaxError")}} is thrown. Use the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors">bracket notation for property access</a>.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_lastMatch_and">Using <code>lastMatch</code> and <code>$&</code></h3> + +<pre class="brush: js">var re = /hi/g; +re.test('hi there!'); +RegExp.lastMatch; // "hi" +RegExp['$&']; // "hi" +</pre> + +<h2 id="Specifications">Specifications</h2> + +<p>Niestandardowe. Nie jest częścią aktualnej specyfikacji.</p> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.builtins.RegExp.lastMatch")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}</li> + <li>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</li> + <li>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</li> + <li>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</li> + <li>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/regexp/source/index.html b/files/pl/web/javascript/reference/global_objects/regexp/source/index.html new file mode 100644 index 0000000000..c508b9f257 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/regexp/source/index.html @@ -0,0 +1,30 @@ +--- +title: RegExp.prototype.source +slug: Web/JavaScript/Reference/Global_Objects/RegExp/source +tags: + - JavaScript + - Property + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/source +original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/source +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Własność tylko do odczytu stanowiąca wzór tekstu, wykluczając przesyłanie slashy.</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>source</code> jest własnością indywidualnej instancji wyrażenia regularnego obiektu.</p> + +<p>Nie możesz zmienić tej własności bezpośrednio.</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("RegExp.prototype.flags")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/regexp/test/index.html b/files/pl/web/javascript/reference/global_objects/regexp/test/index.html new file mode 100644 index 0000000000..8acfb1eae2 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/regexp/test/index.html @@ -0,0 +1,54 @@ +--- +title: RegExp.prototype.test() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/test +tags: + - JavaScript + - Method + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test +original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/test +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wykonuje poszukiwanie łańcucha znaków pomiędzy wyrażeniem regularnym i określonym wzorcem. Zwraca <code>true</code> lub <code>false</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>regexObj</var>.test(<var>str</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>str</code> </dt> + <dd>Łańcuch znaków w zależności od tego, czym jest wyrażenie regularne.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli chcesz wiedzieć, czy wzorzec został znaleziony w łańcuchu znaków zastosuj metodę <code>test</code> (podobną do metody {{jsxref("String.prototype.search()")}}); aby uzyskać więcej informacji (lecz powolniej wykonywana) zastosuj metodę {{jsxref("RegExp.prototype.exec()", "exec()")}}(podobną do metody {{jsxref("String.prototype.match()")}} ).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_test" name="Przyk.C5.82ad:_Zastosowanie_test">Przykład: Zastosowanie <code>test()</code></h3> + +<p>Poniższy funkcja wypisuje wiadomość, której tekst zależy od powodzenia testu:</p> + +<pre class="brush: js">function testinput(re, str){ + if (re.test(str)) { + midstring = " zawiera "; + } else { + midstring = " nie zawiera "; + } + console.log(str + midstring + re.source); +} +</pre> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("RegExp")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/regexp/tosource/index.html b/files/pl/web/javascript/reference/global_objects/regexp/tosource/index.html new file mode 100644 index 0000000000..ae5886df86 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/regexp/tosource/index.html @@ -0,0 +1,48 @@ +--- +title: RegExp.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/toSource +tags: + - JavaScript + - Method + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toSource +original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/toSource +--- +<p>{{JSRef}}{{Non-standard_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>regexObj</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 wbudowanego obiektu {{jsxref("RegExp")}}, <code>toSource()</code> zwraca następujący łańcuch znaków sygnalizujący, który kod źródłowy nie jest dostępny: + + <pre class="brush: js">function RegExp() { + [native code] +} +</pre> + </li> + <li>Dla instancji {{jsxref("RegExp")}}, <code>toSource()</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Ta metoda jest często nazywana wewnętrzną metodą JavaScriptu i nie jest widoczna w kodzie.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/regexp/tostring/index.html b/files/pl/web/javascript/reference/global_objects/regexp/tostring/index.html new file mode 100644 index 0000000000..b62621fa71 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/regexp/tostring/index.html @@ -0,0 +1,47 @@ +--- +title: RegExp.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/toString +tags: + - JavaScript + - Method + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toString +original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/toString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący określony obiekt.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>regexObj</var>.toString();</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("RegExp")}} przypisuje <code>toString()</code> metodzie obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektu {{jsxref("RegExp")}}, metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toString" name="Przyk.C5.82ad:_Zastosowanie_toString">Przykład: Zastosowanie <code>toString()</code></h3> + +<p>Następujący przykład wyświetla wartość łańcucha znaków obiektu <code>RegExp</code>:</p> + +<pre class="brush: js"><code class="language-js"><span class="token keyword">var</span> myExp <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">RegExp</span><span class="token punctuation">(</span><span class="token string">'a+b+c'</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>myExp<span class="token punctuation">.</span><span class="token function">toString<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"> // </span></code><code class="language-js"><span class="token comment">wyświetli</span></code><code class="language-js"><span class="token comment"> '/a+b+c/' +</span> +<span class="token keyword">var</span> foo <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">RegExp</span><span class="token punctuation">(</span><span class="token string">'bar'</span><span class="token punctuation">,</span> <span class="token string">'g'</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>foo<span class="token punctuation">.</span><span class="token function">toString<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"> // </span></code><code class="language-js"><span class="token comment">wyświetli</span></code><code class="language-js"><span class="token comment"> '/bar/g'</span></code> +</pre> + +<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/set/add/index.html b/files/pl/web/javascript/reference/global_objects/set/add/index.html new file mode 100644 index 0000000000..8b143212d7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/set/add/index.html @@ -0,0 +1,135 @@ +--- +title: Set.prototype.add() +slug: Web/JavaScript/Reference/Global_Objects/Set/add +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/add +original_slug: Web/JavaScript/Referencje/Obiekty/Set/Set.prototype.add() +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong>add()</strong> dodaje nowy element o określonej wartości (<code>value</code>) na koniec obieku <code>Set</code>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.add(value);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>value</dt> + <dd>Wymagany parametr. Wartość elementu, która zostanie dodana do obieku <code>Set</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Obiekt <code>Set</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_metody_add">Użycie metody add</h3> + +<pre class="brush: js">var mySet = new Set(); + +mySet.add(1); +mySet.add(5).add('some text'); // można stworzyć "łańcuch" + +console.log(mySet); +// Set [1, 5, "some text"] +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-set.prototype.add', 'Set.prototype.add')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.add', 'Set.prototype.add')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.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>Edge</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>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Specyficzne_zachowania_w_przeglądarkach">Specyficzne zachowania w przeglądarkach</h2> + +<ul> + <li>W Firefox 33 {{geckoRelease("33")}} i wcześniejszych wersjach, <code>Set.prototype.add</code> zwracał <code>undefined</code> i nie można było stworzyć "łańcucha". Błąd został naprawiony ({{bug(1031632)}}). Również w Chrome/v8 występuje ten <a href="https://code.google.com/p/v8/issues/detail?id=3410">problem</a>.</li> +</ul> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> + <li>{{jsxref("Set.prototype.has()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/set/clear/index.html b/files/pl/web/javascript/reference/global_objects/set/clear/index.html new file mode 100644 index 0000000000..32df4660f3 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/set/clear/index.html @@ -0,0 +1,125 @@ +--- +title: Set.prototype.clear() +slug: Web/JavaScript/Reference/Global_Objects/Set/clear +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/clear +original_slug: Web/JavaScript/Referencje/Obiekty/Set/Set.prototype.clear() +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong>clear()</strong> usuwa wszystkie elementy obiektu <code>Set</code>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.clear();</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_metody_clear">Użycie metody clear</h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add(1); +mySet.add('foo'); + +mySet.size; // 2 +mySet.has('foo'); // true + +mySet.clear(); + +mySet.size; // 0 +mySet.has('bar') // false +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("19.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.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>Edge</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>25</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("19.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/set/delete/index.html b/files/pl/web/javascript/reference/global_objects/set/delete/index.html new file mode 100644 index 0000000000..a9358078f1 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/set/delete/index.html @@ -0,0 +1,103 @@ +--- +title: Set.prototype.delete() +slug: Web/JavaScript/Reference/Global_Objects/Set/delete +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/delete +original_slug: Web/JavaScript/Referencje/Obiekty/Set/Set.prototype.delete() +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong>delete()</strong> usuwa określony element z obiektu <code>Set</code>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.delete(value);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>value</dt> + <dd>Wymagany parametr. Wartość elementu, która zostanie usunięta z obiektu <code>Set</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p><code>true </code>jeżeli element został pomyślnie usunięty, w innym wypadku <code>false</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_metody_delete">Użycie metody delete</h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add('foo'); + +mySet.delete('bar'); // Zwraca false. Brak elementu "bar" do usunięca. +mySet.delete('foo'); // Zwraca true. Usunięto pomyślnie. + +mySet.has('foo'); // Zwraca false. Element "foo" nie znajduje się już w Set. +</pre> + +<p>Jak usunąć obiekt z Set:</p> + +<pre class="brush: js">var points = new Set(); // Tworzy Set + +points.add({x: 10, y: 20}); // Dodaje obiekt do Set +points.add({x: 20, y: 30}); // Dodaje obiekt do Set + +// Usuwa point, dla którego `x > 10` +points.forEach(function(point){ + if(point.x > 10){ + points.delete(point); + } +}) +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p> </p> + +<div class="hidden"> +<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> +</div> + +<p>{{Compat("javascript.builtins.Set.delete")}}</p> + +<p> </p> + +<div id="compat-desktop"> </div> + +<div id="compat-mobile"> </div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.clear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/set/index.html b/files/pl/web/javascript/reference/global_objects/set/index.html new file mode 100644 index 0000000000..995d238f97 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/set/index.html @@ -0,0 +1,487 @@ +--- +title: Set +slug: Web/JavaScript/Reference/Global_Objects/Set +tags: + - ECMAScript 2015 + - ECMAScript6 + - Global Objects + - JavaScript + - Object + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set +original_slug: Web/JavaScript/Referencje/Obiekty/Set +--- +<div>{{JSRef}}</div> + +<p>Obiekt <code><strong>Set</strong></code> umożliwia przechowywanie <em>unikalnych </em>wartości każdego typu, zarówno {{Glossary("Primitive", "primitywów")}} jak i obiektów.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">new Set([<em>iterable</em>]);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>iterable</code></dt> + <dd>Jeżeli przekażesz <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of">obiekt iterowalny</a>, wszystkie jego elementy zostaną dodane do nowego <code>Set</code>. Podczas gdy nie przekażemy żadnego parametru lub wartość parametru będzie równa <em><code>null</code></em>, zostanie stworzony pusty <code>Set</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy obiekt <code>Set</code>.</p> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt <code><em>Set</em></code> jest kolekcją wartości. Możesz iterować po elementach <code><em>Set</em></code> w kolejności, w której zostały dodane. Wartość w <code><em>Set</em></code> <strong>może występować tylko jeden raz</strong>.</p> + +<h3 id="Równość_wartości">Równość wartości</h3> + +<p>Dlatego, że każda wartość w <code>Set </code>musi być unikalna, musi zostać to sprawdzone. We wcześniejszych specyfikacjach ECMAScript nie było to oparte na tym samym algorytmie co w przypadku operatora ===. Konkretnie dla Set +0 (co jest tym samym co -0) i -0 były innymi wartościami. W specyfikacji ECMAScript 2015 zostało to zmienione. Zobacz "Value equality for -0 and 0" w tabeli <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Set#Kompatybilność_przeglądarek">Kompatybilność z przeglądarkami</a>.</p> + +<p><code>NaN</code> i <code>undefined</code> mogą być przechowywane w <code>Set</code>. <code>NaN</code> w <code>Set</code> uważane jest za równe <code>NaN</code>, podczas gdy <code>NaN !== NaN</code> zwraca <code>true</code></p> + +<h2 id="Własności">Własności</h2> + +<dl> + <dt><code>Set.length</code></dt> + <dd>Wartość <code>length</code> zawsze wynosi 0.</dd> + <dt>{{jsxref("Set.@@species", "get Set[@@species]")}}</dt> + <dd>Funkcja wykorzystywana do stworzenia pochodnych obiektów.</dd> + <dt>{{jsxref("Set.prototype")}}</dt> + <dd>Reprezentuje prototyp konstruktora <code>Set.</code> Pozwala na dodanie własności do obiektu <code>Set</code>.</dd> +</dl> + +<h2 id="Instancje_Set"><font face="consolas, Liberation Mono, courier, monospace">Instancje <code>Set</code></font></h2> + +<p>Wszystkie instancje <code>Set</code> dziedziczą od {{jsxref("Set.prototype")}}.</p> + +<h3 id="Własności_2">Własności</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Properties')}}</p> + +<h3 id="Metody">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Methods')}}</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_obiektu_Set">Użycie obiektu <code>Set</code></h3> + +<pre class="brush: js">var mySet = new Set(); + +mySet.add(1); // Set { 1 } +mySet.add(5); // Set { 1, 5 } +mySet.add(5); // Set { 1, 5 } +mySet.add('some text'); // Set { 1, 5, 'some text' } +var o = {a: 1, b: 2}; +mySet.add(o); + +mySet.add({a: 1, b: 2}); // o jest referencją do innego obiektu, więc dwa obiekty zostają dodane do Set. + +mySet.has(1); // true +mySet.has(3); // false, 3 nie zostało dodane do Set. +mySet.has(5); // true +mySet.has(Math.sqrt(25)); // true +mySet.has('Some Text'.toLowerCase()); // true +mySet.has(o); // true + +mySet.size; // 5 + +mySet.delete(5); // Usuwa 5 z Set. +mySet.has(5); // false, 5 zostało usunięte. + +mySet.size; // 4, usuneliśmy jedną wartość. +console.log(mySet);// Set {1, "some text", Object {a: 1, b: 2}, Object {a: 1, b: 2}}</pre> + +<h3 id="Iterowanie_po_Set.">Iterowanie po Set.</h3> + +<pre class="brush: js">// Iterowanie po items w Set. +// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2} +for (let item of mySet) console.log(item); + +// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2} +for (let item of mySet.keys()) console.log(item); + +// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2} +for (let item of mySet.values()) console.log(item); + +// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2} +//(key i value są takie same) +for (let [key, value] of mySet.entries()) console.log(key); + +// zamienia Set na Array, przy użyciu Array.from +var myArr = Array.from(mySet); // [1, "some text", {"a": 1, "b": 2}] + +// następujące funkcje również zadziałają, jeżeli skrypt odpalony jest w dokumencie HTML +mySet.add(document.body); +mySet.has(document.querySelector('body')); // true + +// zamiana Array na Set i na odwrót +mySet2 = new Set([1, 2, 3, 4]); +mySet2.size; // 4 +[...mySet2]; // [1, 2, 3, 4] + +// Set z wartościami, które są w set1 i set2, może być uzyskany następująco +var intersection = new Set([...set1].filter(x => set2.has(x))); + +// Set z różnicami wartości set1 i set2 może być uzyskany następująco +var difference = new Set([...set1].filter(x => !set2.has(x))); + +// iterowanie po Set za pomocą .forEach +mySet.forEach(function(value) { + console.log(value); +}); +// 1 +// 2 +// 3 +// 4</pre> + +<h3 id="Implementacja_podstawowych_operacji_Set">Implementacja podstawowych operacji <code>Set</code></h3> + +<pre class="brush: js">Set.prototype.isSuperset = function(subset) { + for (var elem of subset) { + if (!this.has(elem)) { + return false; + } + } + return true; +} + +Set.prototype.union = function(setB) { + var union = new Set(this); + for (var elem of setB) { + union.add(elem); + } + return union; +} + +Set.prototype.intersection = function(setB) { + var intersection = new Set(); + for (var elem of setB) { + if (this.has(elem)) { + intersection.add(elem); + } + } + return intersection; +} + +Set.prototype.difference = function(setB) { + var difference = new Set(this); + for (var elem of setB) { + difference.delete(elem); + } + return difference; +} + +// Przykłady +var setA = new Set([1, 2, 3, 4]), + setB = new Set([2, 3]), + setC = new Set([3, 4, 5, 6]); + +setA.isSuperset(setB); // => true +setA.union(setC); // => Set [1, 2, 3, 4, 5, 6] +setA.intersection(setC); // => Set [3, 4] +setA.difference(setC); // => Set [1, 2] + +</pre> + +<h3 id="Relacje_z_Tablicami_(Array)">Relacje z Tablicami (<code>Array</code>)</h3> + +<pre class="brush: js">var myArray = ['value1', 'value2', 'value3']; + +// Użycie konstruktora Set do zamiany Array na Set. +var mySet = new Set(myArray); + +mySet.has('value1'); // => true + +// Użycie spread operator do zamiany Set na Array. +console.log([...mySet]); // Will show you exactly the same Array as myArray</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td> + <p>{{ CompatChrome(38) }} [1]</p> + </td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Constructor argument: <code>new Set(iterable)</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>9.0</td> + </tr> + <tr> + <td>iterable</td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("17") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.add()</code> returns the set</td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.clear()</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("19")}}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.keys(), Set.values(), Set.entries()</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("24")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.forEach()</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Value equality for -0 and 0</td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatSafari(9)}}</td> + </tr> + <tr> + <td>Constructor argument: <code>new Set(null)</code></td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatIE(11)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari(7.1)}}</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> in Constructor</td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari(9)}}</td> + </tr> + <tr> + <td><code>Set[@@species]</code></td> + <td>{{ CompatChrome(51) }}</td> + <td>13</td> + <td>{{CompatGeckoDesktop("41")}}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatOpera(38) }}</td> + <td>{{CompatSafari(10)}}</td> + </tr> + <tr> + <td><code>Set()</code> without <code>new</code> throws</td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("42")}}</td> + <td>{{CompatIE(11)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>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>Edge</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(38)}} [1]</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Constructor argument: <code>new Set(iterable)</code></td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(38)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td>iterable</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("17") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Set.clear()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("19")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Set.keys(), Set.values(), Set.entries()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("24")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Set.forEach()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Value equality for -0 and 0</td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td>Constructor argument: <code>new Set(null)</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>8</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> in Constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td><code>Set[@@species]</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("41")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>10</td> + </tr> + <tr> + <td><code>Set()</code> without <code>new</code> throws</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("42")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] The feature was available behind a preference from Chrome 31. In <code>chrome://flags</code>, activate the entry “Enable Experimental JavaScript”.</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/anchor/index.html b/files/pl/web/javascript/reference/global_objects/string/anchor/index.html new file mode 100644 index 0000000000..3f70573b83 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/anchor/index.html @@ -0,0 +1,57 @@ +--- +title: String.prototype.anchor() +slug: Web/JavaScript/Reference/Global_Objects/String/anchor +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor +original_slug: Web/JavaScript/Referencje/Obiekty/String/anchor +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Tworzy kotwicę HTML {{HTMLElement("a")}} do użycia jako cel odnośnika.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.anchor(<var>name</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>name</code></dt> + <dd>Łańcuch znaków.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Use the <code>anchor()</code> method to programmatically create and display an anchor in a document.</p> + +<p>W składni łańcuch znaków reprezentuje literał tekstowy, który ma zobaczyć użytkownik. Łańcuch <code>name</code> reprezentuje atrybut <code>name</code> znacznika <code>a</code>.</p> + +<p>Kotwice stworzone za pomocą metody <code>anchor</code> stają się elementami tablicy <code>document.anchors</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_anchor" name="Przyk.C5.82ad:_Zastosowanie_anchor">Przykład: Zastosowanie <code>anchor()</code></h3> + +<p>Następujący przykład wewnątrz kodu HTML elementu <code>script</code>:</p> + +<pre class="brush: js">var myString = "Tabela zawartości"; + +document.body.innerHTML = myString.anchor("contents_anchor"); +</pre> + +<p>spowoduje otrzymanie na wyjściu kodu HTML:</p> + +<pre class="brush: js"><a name="contents_anchor">Tabela zawartości</a> +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.link()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/big/index.html b/files/pl/web/javascript/reference/global_objects/string/big/index.html new file mode 100644 index 0000000000..e0dfbfbf7c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/big/index.html @@ -0,0 +1,44 @@ +--- +title: String.prototype.big() +slug: Web/JavaScript/Reference/Global_Objects/String/big +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/big +original_slug: Web/JavaScript/Referencje/Obiekty/String/big +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch znaków zostanie wyświetlony jakby znajdował się wewnątrz znacznika {{HTMLElement("big")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.big()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>big()</code> method embeds a string in a <code><big></code> tag: <code>"<big>str</big>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_big" name="Przyk.C5.82ad:_Zastosowanie_big">Przykład: Zastosowanie <code>big()</code></h3> + +<p>Następujący przykład stosuje metodę string do zmiany rozmiaru łańcucha znaków:</p> + +<pre class="brush: js">var worldString = "Witaj, Świecie"; + +console.log(worldString.small())<code class="language-js"><span class="token punctuation">;</span> <span class="token comment"> // </span></code><small>Witaj, Świecie</small> +console.log(worldString.big()); // <big>Witaj, Świecie</big> +console.log(worldString.fontsize(7)); // <fontsize=7>Witaj, Świecie</fontsize></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/blink/index.html b/files/pl/web/javascript/reference/global_objects/string/blink/index.html new file mode 100644 index 0000000000..7430744309 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/blink/index.html @@ -0,0 +1,51 @@ +--- +title: String.prototype.blink() +slug: Web/JavaScript/Reference/Global_Objects/String/blink +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/blink +original_slug: Web/JavaScript/Referencje/Obiekty/String/blink +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch będzie migotał tak, jakby był on wewnątrz znacznika {{HTMLElement("blink")}}.</p> + +<div class="warning"> +<p><strong>Warning:</strong> Blinking text is frowned upon by several accessibility standards. The <code><blink></code> element itself is non-standard and deprecated!</p> +</div> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.blink()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>blink()</code> method embeds a string in a <code><blink></code> tag: <code>"<blink>str</blink>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <code>blink()</code></h3> + +<p>Następujący przykład stosuje metodę string do zmiany formatowania łańcucha znaków:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.blink()); // <blink>Witaj, Świecie</blink> +console.log(worldString.bold()); // <bold>Witaj, Świecie</bold> +console.log(worldString.italics()); // <i>Witaj, Świecie</i> +console.log(worldString.strike()); // <s>Witaj, Świecie</s> +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/bold/index.html b/files/pl/web/javascript/reference/global_objects/string/bold/index.html new file mode 100644 index 0000000000..49b5f4446b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/bold/index.html @@ -0,0 +1,46 @@ +--- +title: String.prototype.bold() +slug: Web/JavaScript/Reference/Global_Objects/String/bold +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/bold +original_slug: Web/JavaScript/Referencje/Obiekty/String/bold +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje wyświetlenie łańcucha znaków jako pogrubienia, jakby był w znaczniku {{HTMLElement("b")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.bold()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>bold()</code> method embeds a string in a <code><b></code> tag: <code>"<b>str</b>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <strong><code>bold()</code></strong></h4> + +<p>Następujący przykład stosuje metodę string do zmiany rozmiaru łańcucha znaków:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.blink()); // <blink>Witaj, Świecie</blink> +console.log(worldString.bold()); // <bold>Witaj, Świecie</bold> +console.log(worldString.italics()); // <i>Witaj, Świecie</i> +console.log(worldString.strike()); // <s>Witaj, Świecie</s></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/charat/index.html b/files/pl/web/javascript/reference/global_objects/string/charat/index.html new file mode 100644 index 0000000000..44526655bd --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/charat/index.html @@ -0,0 +1,69 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charAt +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +original_slug: Web/JavaScript/Referencje/Obiekty/String/charAt +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca określony znak z łańcucha znaków.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.charAt(<var>index</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>index</code> </dt> + <dd>Liczba całkowita z przedziału od 0 do liczby o 1 mniejszej od długości łańcucha.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Znaki w łańcuchu znaków są indeksowane od lewej do prawej strony. Indeksem pierwszego znaku jest 0, a indeksem ostatniego znaku w łańcuchu znaków o nazwie <code>stringName</code> jest <code>stringName.length - 1</code>. Jeśli dostarczona wartość parametru <code>index</code> znajduje się poza zakresem, JavaScript zwróci pusty łańcuch znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_r.C3.B3.C5.BCnych_znak.C3.B3w_z_okre.C5.9Blonego_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_r.C3.B3.C5.BCnych_znak.C3.B3w_z_okre.C5.9Blonego_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Wyświetlanie różnych znaków z określonego łańcucha znaków</h3> + +<p>Poniższy przykład wyświetla różne znaki łańcucha "<code>Brave new world</code>":</p> + +<pre class="brush: js">var anyString="Brave new world"; + +console.log("Znakiem o indeksie 0 jest '" + anyString.charAt(0) + "'"); +console.log("Znakiem o indeksie 1 jest '" + anyString.charAt(1) + "'"); +console.log("Znakiem o indeksie 2 jest '" + anyString.charAt(2) + "'"); +console.log("Znakiem o indeksie 3 jest '" + anyString.charAt(3) + "'"); +console.log("Znakiem o indeksie 4 jest '" + anyString.charAt(4) + "'"); +console.log("Znakiem o indeksie 999 jest '" + anyString.charAt(999) + "'"); +</pre> + +<p>Powyższy kod wyświetli:</p> + +<pre>Znakiem o indeksie 0 jest 'B' +Znakiem o indeksie 1 jest 'r' +Znakiem o indeksie 2 jest 'a' +Znakiem o indeksie 3 jest 'v' +Znakiem o indeksie 4 jest 'e' +Znakiem o indeksie 999 jest '' +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/charcodeat/index.html b/files/pl/web/javascript/reference/global_objects/string/charcodeat/index.html new file mode 100644 index 0000000000..fefe5418b5 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/charcodeat/index.html @@ -0,0 +1,43 @@ +--- +title: String.prototype.charCodeAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +tags: + - JavaScript + - Method + - Prototype + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +original_slug: Web/JavaScript/Referencje/Obiekty/String/charCodeAt +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca liczbę oznaczającą wartość Unicode znaku o podanym indeksie.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.charCodeAt(<var>index</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>index</code> </dt> + <dd>Liczba całkowita z przedziału od 0 do liczby o 1 mniejszej od długości łańcucha.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartości Unicode mieszczą się w zakresie od 0 do 65535. Pierwsze 128 wartości Unicode jest takie same jak w zbiorze znaków ASCII. Aby dowiedzieć się więcej o Unicode, zobacz <a href="/pl/docs/Web/JavaScript/Guide/Grammar_and_types#Unicode">Przewodnik po języku JavaScript</a>.</p> + +<p>Zgodność wsteczna: JavaScript 1.2 — Metoda <code>charCodeAt</code> zwraca liczbę wskazującą wartość ze zbioru kodowania ISO-Latin-1 znaku o podanym indeksie. Zbiór kodowania ISO-Latin-1 posiada zakres od 0 do 255. Znaki od 0 do 127 są identyczne, co te w zbiorze znaków ASCII.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_charCodeAt" name="Przyk.C5.82ad:_Zastosowanie_charCodeAt">Przykład: Zastosowanie <code>charCodeAt()</code></h3> + +<p>Następujący przykład zwróci 65, wartość A w Unicode.</p> + +<pre class="brush: js">"ABC".charCodeAt(0); // zwróci 65 +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/string/concat/index.html b/files/pl/web/javascript/reference/global_objects/string/concat/index.html new file mode 100644 index 0000000000..ea0dbf7847 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/concat/index.html @@ -0,0 +1,45 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/String/concat +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +original_slug: Web/JavaScript/Referencje/Obiekty/String/concat +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Łączy tekst dwóch lub więcej łańcuchów znaków i zwraca nowy łańcuch.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.concat(<var>string2</var>, <var>string3</var>[, ..., <var>stringN</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>string2...string + <i>N</i> + </code> </dt> + <dd>Łańcuchy znaków mające być dołączone do tego łańcucha.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>concat()</code> łączy tekst jednego lub więcej łańcuchów znaków i zwraca nowy łańcuch znaków. Zmiana tekstu w jednym łańcuchu znaków nie ma wpływu na drugi łańcuch.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_concat" name="Przyk.C5.82ad:_Zastosowanie_concat">Przykład: Zastosowanie <code>concat()</code></h3> + +<p>Następujący przykład łączy łańcuchy znaków w nowy łańcuch znaków.</p> + +<pre class="brush: js">var s1="Och, "; +var s2="jaki piękny "; +var s3="poranek."; +var s4=s1.concat(s2,s3); // zwraca "Och, jaki piękny poranek." +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/string/fontcolor/index.html b/files/pl/web/javascript/reference/global_objects/string/fontcolor/index.html new file mode 100644 index 0000000000..4753478194 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/fontcolor/index.html @@ -0,0 +1,51 @@ +--- +title: String.prototype.fontcolor() +slug: Web/JavaScript/Reference/Global_Objects/String/fontcolor +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor +original_slug: Web/JavaScript/Referencje/Obiekty/String/fontcolor +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony podanym kolorem tak jakby był wewnątrz znacznika {{HTMLElement("font")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.fontcolor(<var>color</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>color</code> </dt> + <dd>Łańcuch znaków wyrażający kolor jako trójka heksadecymalna RGB lub jako łańcuch znaków. Lista nazw w postaci łańcucha znaków dla kolorów jest dostępna w <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5">przewodniku po języku JavaScript 1.5</a>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli wyrażamy kolor w postaci trójki heksadecymalnej RGB, to musisz zastosować format <code>rrggbb</code>. Na przykład, wartość heksadecymalna koloru łososiowego składa się z red=FA, green=80 i blue=72, więc trójka RGB dla łososiowego będzie miała wartość "<code>FA8072</code>".</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_fontcolor" name="Przyk.C5.82ad:_Zastosowanie_fontcolor">Przykład: Zastosowanie <code>fontcolor()</code></h3> + +<p>Następujący przykład stosuje metodę <code>string</code> do zmiany koloru łańcucha znaków:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.fontcolor("red") + " jest koloru czerwonego w tej linii"); +// <font color="red">Witaj, Świecie</font> jest koloru czerwonego w tej linii + +console.log(worldString.fontcolor("FF00") +" linia jest czerwona i podany kolor heksadecymalny"); +// <font color="FF00">Witaj, Świecie</font> linia jest czerwona i podany kolor heksadecymalny +</pre> + +<div class="noinclude"> </div> + +<p> </p> diff --git a/files/pl/web/javascript/reference/global_objects/string/fontsize/index.html b/files/pl/web/javascript/reference/global_objects/string/fontsize/index.html new file mode 100644 index 0000000000..7c15a79def --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/fontsize/index.html @@ -0,0 +1,49 @@ +--- +title: String.prototype.fontsize() +slug: Web/JavaScript/Reference/Global_Objects/String/fontsize +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize +original_slug: Web/JavaScript/Referencje/Obiekty/String/fontsize +--- +<p>{{JSRef}}{{ Non-standard_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje wyświetlenie łańcucha znaków w określonym rozmiarze czcionki, tak jak to było w znaczniku {{HTMLElement("font")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.fontsize(<var>size</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>size</code> </dt> + <dd>Liczba całkowita pomiędzy 1 a 7, łańcuch znaków reprezentujący rozmiar znaku liczby całkowitej między 1 a 7.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Kiedy określisz rozmiar jako liczbę całkowitą, ustaw rozmiar <code>stringName</code> na jeden z 7 innych rozmiarów. Kiedy określisz <code>size</code> łańcucha znaków jako "-2", to dostosujesz rozmiar czcionki <code>stringName</code> relatywnie do rozmiaru jaki został ustawiony w znaczniku {{HTMLElement("basefont")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <strong><code>fontsize()</code></strong></h3> + +<pre class="brush: js language-js"><code class="language-js"><span class="token keyword">var</span> worldString <span class="token operator">=</span> <span class="token string">"Witaj, Świecie"</span><span class="token punctuation">;</span> + +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>worldString<span class="token punctuation">.</span><span class="token function">small<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"> // <small>Witaj, Świecie</small> +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>worldString<span class="token punctuation">.</span><span class="token function">big<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"> // <big>Witaj, Świecie</big> +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>worldString<span class="token punctuation">.</span><span class="token function">fontsize<span class="token punctuation">(</span></span><span class="token number">7</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // <fontsize=7>Witaj, Świecie</fontsize></span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.big()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/pl/web/javascript/reference/global_objects/string/fromcharcode/index.html new file mode 100644 index 0000000000..d9a96bafd0 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/fromcharcode/index.html @@ -0,0 +1,51 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +tags: + - JavaScript + - Method + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +original_slug: Web/JavaScript/Referencje/Obiekty/String/fromCharCode +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków stworzony przez podaną sekwencję kodów Unicode.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em> </code> </dt> + <dd>Sekwencja liczb, które są wartościami Unicode.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ta metoda zwraca łańcuch znaków nie będący {{jsxref("String")}}.</p> + +<p>Ponieważ <code>fromCharCode()</code> jest metodą statyczną {{jsxref("String")}}, używaj ją zawsze jako <code>String.fromCharCode()</code>, a nie jako metodę obiektu {{jsxref("String")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_fromCharCode" name="Przyk.C5.82ad:_Zastosowanie_fromCharCode">Przykład: Zastosowanie <code>fromCharCode()</code></h3> + +<p>Następujący przykład zwraca łańcuch znaków <code>"ABC"</code>.</p> + +<pre class="brush: js">String.fromCharCode(65,66,67); // "ABC" +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/fromcodepoint/index.html b/files/pl/web/javascript/reference/global_objects/string/fromcodepoint/index.html new file mode 100644 index 0000000000..d929675696 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/fromcodepoint/index.html @@ -0,0 +1,150 @@ +--- +title: String.fromCodePoint() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +original_slug: Web/JavaScript/Referencje/Obiekty/String/fromCodePoint +--- +<div>{{JSRef}}</div> + +<p>The static <strong><code>String.fromCodePoint()</code></strong> method returns a string created by using the specified sequence of code points.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-fromcodepoint.html","shorter")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate">String<code>.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code><var>num1</var>, ..., <var>numN</var></code></dt> + <dd>A sequence of code points.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>A string created by using the specified sequence of code points.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>A {{jsxref("Errors/Not_a_codepoint", "RangeError")}} is thrown if an invalid Unicode code point is given (e.g. <code>"RangeError: NaN is not a valid code point"</code>).</li> +</ul> + +<h2 id="Description">Description</h2> + +<p>This method returns a string (and <em>not</em> a {{jsxref("String")}} object).</p> + +<p>Because <code>fromCodePoint()</code> is a static method of {{jsxref("String")}}, you must call it as <code>String.fromCodePoint()</code>, rather than as a method of a {{jsxref("String")}} object you created.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>The <code>String.fromCodePoint()</code> method has been added to ECMAScript 2015 and may not be supported in all web browsers or environments yet.</p> + +<p>Use the code below for a polyfill:</p> + +<pre class="brush: js notranslate">if (!String.fromCodePoint) (function(stringFromCharCode) { + var fromCodePoint = function(_) { + var codeUnits = [], codeLen = 0, result = ""; + for (var index=0, len = arguments.length; index !== len; ++index) { + var codePoint = +arguments[index]; + // correctly handles all cases including `NaN`, `-Infinity`, `+Infinity` + // The surrounding `!(...)` is required to correctly handle `NaN` cases + // The (codePoint>>>0) === codePoint clause handles decimals and negatives + if (!(codePoint < 0x10FFFF && (codePoint>>>0) === codePoint)) + throw RangeError("Invalid code point: " + codePoint); + if (codePoint <= 0xFFFF) { // BMP code point + codeLen = codeUnits.push(codePoint); + } else { // Astral code point; split in surrogate halves + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + codePoint -= 0x10000; + codeLen = codeUnits.push( + (codePoint >> 10) + 0xD800, // highSurrogate + (codePoint % 0x400) + 0xDC00 // lowSurrogate + ); + } + if (codeLen >= 0x3fff) { + result += stringFromCharCode.apply(null, codeUnits); + codeUnits.length = 0; + } + } + return result + stringFromCharCode.apply(null, codeUnits); + }; + try { // IE 8 only supports `Object.defineProperty` on DOM elements + Object.defineProperty(String, "fromCodePoint", { + "value": fromCodePoint, "configurable": true, "writable": true + }); + } catch(e) { + String.fromCodePoint = fromCodePoint; + } +}(String.fromCharCode)); +</pre> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_fromCodePoint">Using <code>fromCodePoint()</code></h3> + +<p>Valid input:</p> + +<pre class="brush: js notranslate">String.fromCodePoint(42); // "*" +String.fromCodePoint(65, 90); // "AZ" +String.fromCodePoint(0x404); // "\u0404" == "Є" +String.fromCodePoint(0x2F804); // "\uD87E\uDC04" +String.fromCodePoint(194564); // "\uD87E\uDC04" +String.fromCodePoint(0x1D306, 0x61, 0x1D307); // "\uD834\uDF06a\uD834\uDF07" +</pre> + +<p>Invalid input:</p> + +<pre class="brush: js notranslate">String.fromCodePoint('_'); // RangeError +String.fromCodePoint(Infinity); // RangeError +String.fromCodePoint(-1); // RangeError +String.fromCodePoint(3.14); // RangeError +String.fromCodePoint(3e-2); // RangeError +String.fromCodePoint(NaN); // RangeError +</pre> + +<h3 id="Compared_to_fromCharCode">Compared to <code>fromCharCode()</code></h3> + +<p>{{jsxref("String.fromCharCode()")}} cannot return supplementary characters (i.e. code points <code>0x010000</code> – <code>0x10FFFF</code>) by specifying their code point. Instead, it requires the UTF-16 surrogate pair in order to return a supplementary character:</p> + +<pre class="brush: js notranslate">String.fromCharCode(0xD83C, 0xDF03); // Code Point U+1F303 "Night with +String.fromCharCode(55356, 57091); // Stars" == "\uD83C\uDF03" +</pre> + +<p><code>String.fromCodePoint()</code>, on the other hand, can return 4-byte supplementary characters, as well as the more common 2-byte BMP characters, by specifying their code point (which is equivalent to the UTF-32 code unit):</p> + +<pre class="brush: js notranslate">String.fromCodePoint(0x1F303); // or 127747 in decimal +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.fromCodePoint")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/index.html b/files/pl/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..e343b8b35a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,195 @@ +--- +title: String +slug: Web/JavaScript/Reference/Global_Objects/String +tags: + - JavaScript + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +original_slug: Web/JavaScript/Referencje/Obiekty/String +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Tworzy obiekt pozwalający działać na ciągach znaków.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia</h2> + +<p>Literały znakowe są postaci:</p> + +<pre class="syntaxbox notranslate">'string text' +"string text" +"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ்" +</pre> + +<p>Beside regular, printable characters, special characters can be encoded using escape notation:</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Code</th> + <th scope="col">Output</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>\0</code></td> + <td>the NUL character</td> + </tr> + <tr> + <td><code>\'</code></td> + <td>single quote</td> + </tr> + <tr> + <td><code>\"</code></td> + <td>double quote</td> + </tr> + <tr> + <td><code>\\</code></td> + <td>backslash</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>new line</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>carriage return</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>vertical tab</td> + </tr> + <tr> + <td><code>\t</code></td> + <td>tab</td> + </tr> + <tr> + <td><code>\b</code></td> + <td>backspace</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>form feed</td> + </tr> + <tr> + <td><code>\uXXXX</code></td> + <td>unicode codepoint</td> + </tr> + <tr> + <td><code>\xXX</code></td> + <td>the Latin-1 character</td> + </tr> + </tbody> +</table> + +<p>Or, using the <code>String</code> global object directly:</p> + +<pre class="syntaxbox notranslate">String(thing) +new String(thing) +</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>thing</code></dt> + <dd>Dowolny łańcuch znaków.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>trings are useful for holding data that can be represented in text form. Some of the most-used operations on strings are to check their {{jsxref("String.length", "length")}}, to build and concatenate them using the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">+ and += string operators</a>, checking for the existence or location of substrings with the {{jsxref("String.prototype.indexOf()", "indexOf()")}} method, or extracting substrings with the {{jsxref("String.prototype.substring()", "substring()")}} method.</p> + +<h3 id="Character_access" name="Character_access">Character access</h3> + +<p>There are two ways to access an individual character in a string. The first is the {{jsxref("String.prototype.charAt()", "charAt()")}} method:</p> + +<pre class="brush: js notranslate">return 'cat'.charAt(1); // returns "a"</pre> + +<div class="line-number" style="top: 0px;"></div> + +<p>The other way (introduced in ECMAScript 5) is to treat the string as an array-like object, where individual characters correspond to a numerical index:</p> + +<pre class="brush: js notranslate">return 'cat'[1]; // returns "a"</pre> + +<div class="line-number" style="top: 0px;"></div> + +<p>For character access using bracket notation, attempting to delete or assign a value to these properties will not succeed. The properties involved are neither writable nor configurable. (See {{jsxref("Object.defineProperty()")}} for more information.)</p> + +<h3 id="Comparing_strings" name="Comparing_strings">Comparing strings</h3> + +<p>C developers have the <code>strcmp()</code> function for comparing strings. In JavaScript, you just use the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">less-than and greater-than operators</a>:</p> + +<pre class="brush: js notranslate">var a = 'a'; +var b = 'b'; +if (a < b) { // true + print(a + ' is less than ' + b); +} else if (a > b) { + print(a + ' is greater than ' + b); +} else { + print(a + ' and ' + b + ' are equal.'); +}</pre> + +<p>A similar result can be achieved using the {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} method inherited by <code>String</code> instances.</p> + +<h3 id="Distinction_between_string_primitives_and_String_objects">Distinction between string primitives and <code>String</code> objects</h3> + +<p>Note that JavaScript distinguishes between <code>String</code> objects and primitive string values. (The same is true of {{jsxref("Global_Objects/Boolean", "Boolean")}} and {{jsxref("Global_Objects/Number", "Numbers")}}.)</p> + +<p>String literals (denoted by double or single quotes) and strings returned from <code>String</code> calls in a non-constructor context (i.e., without using the {{jsxref("Operators/new", "new")}} keyword) are primitive strings. JavaScript automatically converts primitives to <code>String</code> objects, so that it's possible to use <code>String</code> object methods for primitive strings. In contexts where a method is to be invoked on a primitive string or a property lookup occurs, JavaScript will automatically wrap the string primitive and call the method or perform the property lookup.</p> + +<pre class="brush: js notranslate">var s_prim = 'foo'; +var s_obj = new String(s_prim); + +console.log(typeof s_prim); // Logs "string" +console.log(typeof s_obj); // Logs "object"</pre> + +<div class="line-number" style="top: 76px;"></div> + +<p>String primitives and <code>String</code> objects also give different results when using {{jsxref("Global_Objects/eval", "eval()")}}. Primitives passed to <code>eval</code> are treated as source code; <code>String</code> objects are treated as all other objects are, by returning the object. For example:</p> + +<pre class="brush: js notranslate">var s1 = '2 + 2'; // creates a string primitive +var s2 = new String('2 + 2'); // creates a String object +console.log(eval(s1)); // returns the number 4 +console.log(eval(s2)); // returns the string "2 + 2"</pre> + +<p>For these reasons, code may break when it encounters <code>String</code> objects when it expects a primitive string instead, although generally authors need not worry about the distinction.</p> + +<p>A <code>String</code> object can always be converted to its primitive counterpart with the {{jsxref("String.prototype.valueOf()", "valueOf()")}} method.</p> + +<pre class="brush: js notranslate">console.log(eval(s2.valueOf())); // returns the number 4</pre> + +<div class="note"><strong>Note:</strong> For another possible approach to strings in JavaScript, please read the article about <a href="https://developer.mozilla.org/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — a C-like representation of strings based on typed arrays</a>.</div> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("String.prototype")}}</dt> + <dd>Pozwala na dodawanie własności do obiektu <code>String</code>.</dd> +</dl> + +<div>{{jsOverrides("Function", "Properties", "prototype")}}</div> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("String.fromCharCode()")}}</dt> + <dd>Zwraca łańcuch znaków stworzony przez podaną sekwencję kodów Unicode.</dd> + <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt> + <dd>Returns a string created by using the specified sequence of code points.</dd> + <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt> + <dd>Returns a string created from a raw template string.</dd> +</dl> + +<div>{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint", "raw")}}</div> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Example_String_conversion">Example: String conversion</h3> + +<p>It's possible to use <code>String</code> as a "safer" {{jsxref("String.prototype.toString()", "toString()")}} alternative, as although it still normally calls the underlying <code>toString()</code>, it also works for {{jsxref("null")}} and {{jsxref("undefined")}}. For example:</p> + +<pre class="brush: js notranslate">var outputStrings = []; +for (var i = 0, n = inputValues.length; i < n; ++i) { + outputStrings.push(String(inputValues[i])); +}</pre> diff --git a/files/pl/web/javascript/reference/global_objects/string/italics/index.html b/files/pl/web/javascript/reference/global_objects/string/italics/index.html new file mode 100644 index 0000000000..16c5d77bcb --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/italics/index.html @@ -0,0 +1,46 @@ +--- +title: String.prototype.italics() +slug: Web/JavaScript/Reference/Global_Objects/String/italics +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/italics +original_slug: Web/JavaScript/Referencje/Obiekty/String/italics +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony kursywą tak jakby był wewnątrz znacznika {{HTMLElement("i")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.italics()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>italics()</code> method embeds a string in an <code><i></code> tag: <code>"<i>str</i>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego">Przykład: Zastosowanie metody <code>italics()</code></h3> + +<p>Następujący przykład stosuje metodę <code>string</code> do zmiany formatowania łańcucha znakowego:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.blink()); // <blink>Witaj, Świecie</blink> +console.log(worldString.bold()); // <bold>Witaj, Świecie</bold> +console.log(worldString.italics()); // <i>Witaj, Świecie</i> +console.log(worldString.strike()); // <s>Witaj, Świecie</s></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/link/index.html b/files/pl/web/javascript/reference/global_objects/string/link/index.html new file mode 100644 index 0000000000..dddd49ecf7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/link/index.html @@ -0,0 +1,44 @@ +--- +title: String.prototype.link() +slug: Web/JavaScript/Reference/Global_Objects/String/link +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/link +original_slug: Web/JavaScript/Referencje/Obiekty/String/link +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Tworzy <a class="external" href="http://www.w3.org/TR/html401/struct/links.html#adef-href">łącze hipertekstowe</a>, które wywołuje inny URL.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.link(<var>url</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>url</code></dt> + <dd>Jakikolwiek łańcuch określony w <code>href</code> ze znacznika <code>a</code>; powinien być umieszczany poprawny URL (relatywny lub absolutny).</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Linki tworzymy poprzez metodę <code>link</code> stającą się elementami tablicy <code>links</code> z obiektu <code>document</code>. Zobacz <code>document.links</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_link" name="Przyk.C5.82ad:_Zastosowanie_link">Przykład: Zastosowanie <code>link()</code></h3> + +<p>Następujący przykład wyświetla słowo "MDN" jako odnośnik hipertekstowy, poprzez który użytkownik będzie mógł przejść na stronę domową Netscape:</p> + +<pre class="brush: js">var hotText="MDN"; +var URL="<code class="language-js"><span class="token string">https://developer.mozilla.org/</span></code>"; + +console.log("Kliknij, aby powrócić do " + hotText.link(URL)); +// Kliknij, aby powrócić do <a href="https://developer.mozilla.org">MDN</a> +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/string/repeat/index.html b/files/pl/web/javascript/reference/global_objects/string/repeat/index.html new file mode 100644 index 0000000000..a6542a4bb7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/repeat/index.html @@ -0,0 +1,167 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Reference/Global_Objects/String/repeat +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +original_slug: Web/JavaScript/Referencje/Obiekty/String/repeat +--- +<div>{{JSRef}}</div> + +<p>The <strong><code>repeat()</code></strong> method constructs and returns a new string which contains the specified number of copies of the string on which it was called, concatenated together.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>str</var>.repeat(<var>count</var>)</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>count</code></dt> + <dd>An integer between 0 and +∞: [0, +∞), indicating the number of times to repeat the string in the newly-created string that is to be returned.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>A new string containing the specified number of copies of the given string.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: repeat count must be non-negative.</li> + <li>{{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: repeat count must be less than infinity and not overflow maximum string size.</li> +</ul> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">'abc'.repeat(-1); // RangeError +'abc'.repeat(0); // '' +'abc'.repeat(1); // 'abc' +'abc'.repeat(2); // 'abcabc' +'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer) +'abc'.repeat(1/0); // RangeError + +({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2); +// 'abcabc' (repeat() is a generic method) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>This method has been added to the ECMAScript 6 specification and may not be available in all JavaScript implementations yet. However, you can polyfill <code>String.prototype.repeat()</code> with the following snippet:</p> + +<pre class="brush: js">if (!String.prototype.repeat) { + String.prototype.repeat = function(count) { + 'use strict'; + if (this == null) { + throw new TypeError('can\'t convert ' + this + ' to object'); + } + var str = '' + this; + count = +count; + if (count != count) { + count = 0; + } + if (count < 0) { + throw new RangeError('repeat count must be non-negative'); + } + if (count == Infinity) { + throw new RangeError('repeat count must be less than infinity'); + } + count = Math.floor(count); + if (str.length == 0 || count == 0) { + return ''; + } + // Ensuring count is a 31-bit integer allows us to heavily optimize the + // main part. But anyway, most current (August 2014) browsers can't handle + // strings 1 << 28 chars or longer, so: + if (str.length * count >= 1 << 28) { + throw new RangeError('repeat count must not overflow maximum string size'); + } + var rpt = ''; + for (;;) { + if ((count & 1) == 1) { + rpt += str; + } + count >>>= 1; + if (count == 0) { + break; + } + str += str; + } + // Could we try: + // return Array(count + 1).join(this); + return rpt; + } +} +</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('ES6', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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("41")}} </td> + <td>{{CompatGeckoDesktop("24")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</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("36")}}</td> + <td>{{CompatGeckoMobile("24")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/pl/web/javascript/reference/global_objects/string/search/index.html b/files/pl/web/javascript/reference/global_objects/string/search/index.html new file mode 100644 index 0000000000..ab4d438903 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/search/index.html @@ -0,0 +1,50 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Reference/Global_Objects/String/search +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +original_slug: Web/JavaScript/Referencje/Obiekty/String/search +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wykonuje przeszukanie dla dopasowanych wyrażeń regularnych i tego obiektu {{jsxref("String")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><var>str</var>.search(<var>regexp</var>)</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>regexp</code> </dt> + <dd>Nazwa wyrażenia regularnego. Może być to nazwa zmiennej lub literał.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli sukces, rezultat przeszukania indeksu wyrażenia regularnego wewnątrz łańcucha znaków. Inaczej zwróci -1.</p> + +<p>Kiedy chcesz wiedzieć gdzie jest znaleziony wzorzec w łańcuchu znaków zastosuj <code>search()</code> (podobne do wyrażenia regularnego metody {{jsxref("RegExp.prototype.test()", "test()")}}); aby uzyskać więcej informacji (lecz wolniej wykonywanie) zastosuj {{jsxref("String.prototype.match()", "match()")}} (podobne do wyrażenia regularnego metody {{jsxref("RegExp.prototype.exec()", "exec()")}} method).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_search" name="Przyk.C5.82ad:_Zastosowanie_search">Przykład: Zastosowanie <code>search</code>()</h3> + +<p>Następujący przykład drukuje wiadomość, która zależy od sukcesu testu.</p> + +<pre class="brush: js">function testinput(re, str){ + var midstring; + if (str.search(re) != -1) { + midstring = " contains "; + } else { + midstring = " does not contain "; + } + console.log (str + midstring + re.source); +} +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/string/slice/index.html b/files/pl/web/javascript/reference/global_objects/string/slice/index.html new file mode 100644 index 0000000000..65ae41a685 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/slice/index.html @@ -0,0 +1,52 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/String/slice +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +original_slug: Web/JavaScript/Referencje/Obiekty/String/slice +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wydobywa część łańcucha znaków i zwraca go jako nowy łańcuch znaków.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.slice(<var>beginSlice</var>[, <var>endSlice</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>beginSlice</code> </dt> + <dd>Oparty na zerze początek indeksu rozpoczynający wyciąganie.</dd> +</dl> + +<dl> + <dt><code>endSlice</code> </dt> + <dd>Oparty na zerze początek indeksu, który kończy wyciąganie. Jeśli pominięty <code>slice()</code> wydobywa do końca łańcuch znaków.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>slice()</code> wyciąga tekst z jednego łańcucha znaków i zwraca nowy łańcuch znaków. Zmiany w treści jednego łańcucha znaków nie mają wpływu na drugi.</p> + +<p><code>slice()</code> wyciąga tekst do <code>endSlice</code> lecz go nie włącza. <code>string.slice(1,4)</code> wyciąga drugi znak aż do czwartego (znaki o indeksach 1, 2 i 3).</p> + +<p>Jako ujemny indeks <code>endSlice</code> sygnalizuje przesunięcie z końca łańcucha znaków. <code>str.slice(2,-1)</code> wyciąga trzeci przez ostatni znak w łańcuchu znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad_Zastosowanie_slice_do_stworzenia_nowego_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_slice_do_stworzenia_nowego_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <code>slice()</code></h3> + +<p>Poniższy przykład używa <code>slice</code> do stworzenia nowego łańcucha znaków.</p> + +<pre class="brush: js">var str1 = 'The morning is upon us.'; +var str2 = str1.slice(4,-2); + +console.log(str2); // OUTPUT: morning is upon u +</pre> diff --git a/files/pl/web/javascript/reference/global_objects/string/small/index.html b/files/pl/web/javascript/reference/global_objects/string/small/index.html new file mode 100644 index 0000000000..176d59deed --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/small/index.html @@ -0,0 +1,38 @@ +--- +title: String.prototype.small() +slug: Web/JavaScript/Reference/Global_Objects/String/small +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/String/small +original_slug: Web/JavaScript/Referencje/Obiekty/String/small +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje to, że łańcuch znaków będzie wyświetlany małą czcionką, jakby znajdował się wewnątrz znacznika {{HTMLElement("small")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.small()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>small()</code> method embeds a string in a <code><small></code> tag: <code>"<small>str</small>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znakowego" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znakowego">Przykład: Zastosowanie metody <code>small()</code></h3> + +<pre class="brush: js">var worldString = "Witaj, Świecie"; + +console.log(worldString.small()); // <small>Witaj, Świecie</small> +console.log(worldString.big()); // <big>Witaj, Świecie</big> +console.log(worldString.fontsize(7)); // <fontsize=7>Witaj, Świecie</fontsize></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.big()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/strike/index.html b/files/pl/web/javascript/reference/global_objects/string/strike/index.html new file mode 100644 index 0000000000..09e3615055 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/strike/index.html @@ -0,0 +1,45 @@ +--- +title: String.prototype.strike() +slug: Web/JavaScript/Reference/Global_Objects/String/strike +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/strike +original_slug: Web/JavaScript/Referencje/Obiekty/String/strike +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony przekreślony, tak jakby był wewnątrz znacznika {{HTMLElement("strike")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.strike()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>strike()</code> method embeds a string in a <code><strike></code> tag: <code>"<strike>str</strike>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego">Przykład: Zastosowanie metody <code>strike()</code></h3> + +<p>Następujący przykład stosuje metodę <code>string</code> do zmiany formatowania łańcucha znakowego:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.blink()); // <blink>Witaj, Świecie</blink> +console.log(worldString.bold()); // <bold>Witaj, Świecie</bold> +console.log(worldString.italics()); // <i>Witaj, Świecie</i> +console.log(worldString.strike()); // <s>Witaj, Świecie</s></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/sub/index.html b/files/pl/web/javascript/reference/global_objects/string/sub/index.html new file mode 100644 index 0000000000..94bfb8722e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/sub/index.html @@ -0,0 +1,45 @@ +--- +title: String.prototype.sub() +slug: Web/JavaScript/Reference/Global_Objects/String/sub +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sub +original_slug: Web/JavaScript/Referencje/Obiekty/String/sub +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony jako indeks dolny tak jakby był wewnątrz znacznika {{HTMLElement("sub")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.sub()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>sub()</code> method embeds a string in a <code><sub></code> tag: <code>"<sub>str</sub>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_metod_sub_i_sup_do_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metod_sub_i_sup_do_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie metod <code>sub()</code> i <code>sup()</code></h4> + +<p>Następujący przykład stosuje metody <code>sub()</code> i {{jsxref("String.prototype.sup()", "sup()")}} do formatowania łańcucha znaków:</p> + +<pre class="brush: js">var superText="superscript"; +var subText="subscript"; + +console.log("This is what a " + superText.sup() + " looks like."); +// This is what a <sup>superscript</sup> looks like + +console.log("This is what a " + subText.sub() + " looks like."); +// This is what a <sub>subscript</sub> looks like.</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.sup()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/substr/index.html b/files/pl/web/javascript/reference/global_objects/string/substr/index.html new file mode 100644 index 0000000000..de389081b7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/substr/index.html @@ -0,0 +1,67 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Reference/Global_Objects/String/substr +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +original_slug: Web/JavaScript/Referencje/Obiekty/String/substr +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca określoną liczbę początkowych znaków w łańcuchu znaków w określonej lokalizacji.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.substr(<var>start</var>[, <var>length</var>])</code></pre> + +<h2 id="Parametry" name="Parametry">Parametry</h2> + +<dl> + <dt><code>start</code> </dt> + <dd>Lokalizacja, w której rozpoczyna się wyciąganie znaków (wartość liczbowa pomiędzy 0, a jeden znak mniej niż długość łańcucha znaków).</dd> +</dl> + +<dl> + <dt><code>length</code> </dt> + <dd>Liczba znaków do wyciągnięcia.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>start</code> jest indeksem znaków. Pierwszym znakiem w indeksie jest 0 i ostatnim znakiem w indeksie jest liczba o 1 mniejsza niż długość łańcucha znaków. <code>substr()</code> rozpoczyna wyciąganie znaków w <code>start</code> i ściąga liczbę <code>length</code> znaków.</p> + +<p>Jeśli <code>start</code> jest dodatnie i jest długością łańcucha znaków lub dłuższą wartością, <code>substr()</code> nie zwraca znaków.</p> + +<p>Jeśli <code>start</code> jest ujemne, <code>substr()</code> stosuje to jako indeks znaków z końca łańcucha znaków. Jeśli <code>start</code> jest ujemne i <code>abs(start)</code> jest większe niż długość łańcucha znaków to <code>substr()</code> stosuje 0 jako początek indeksu.</p> + +<p>Jeśli <code>length</code> jest 0 lub ujemne, <code>substr()</code> nie zwróci znaków. Jeśli <code>length</code> jest opuszczone, <code>substr()</code> wyciągnie znaki aż do końca łańcucha znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_substr" name="Przyk.C5.82ad:_Zastosowanie_substr">Przykład: Zastosowanie <code>substr()</code></h3> + +<p>Rozpatrz poniższy skrypt:</p> + +<pre class="brush: js">var str = 'abcdefghij'; + +console.log('(1, 2): ' + str.substr(1, 2)); // '(1, 2): bc' +console.log('(-3, 2): ' + str.substr(-3, 2)); // '(-3, 2): hi' +console.log('(-3): ' + str.substr(-3)); // '(-3): hij' +console.log('(1): ' + str.substr(1)); // '(1): bcdefghij' +console.log('(-20, 2): ' + str.substr(-20, 2)); // '(-20, 2): ab' +console.log('(20, 2): ' + str.substr(20, 2)); // '(20, 2): ' +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<p> </p> + +<ul> + <li>{{jsxref("String.prototype.slice()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/substring/index.html b/files/pl/web/javascript/reference/global_objects/string/substring/index.html new file mode 100644 index 0000000000..718663d8f4 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/substring/index.html @@ -0,0 +1,91 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Reference/Global_Objects/String/substring +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +original_slug: Web/JavaScript/Referencje/Obiekty/String/substring +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca podciąg obiektu <code>String</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.substring(<var>indexA</var>[, <var>indexB</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>indexA</code> </dt> + <dd>Liczba całkowita pomiędzy 0, a liczbą o jeden mniejszą niż długość łańcucha znaków.</dd> + <dt><code>indexB</code> </dt> + <dd>Opcjonalny. Liczba całkowita pomiędzy 0 i długością łańcucha znaków.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>substring</code> urywa znaki z <code>indexA</code> lecz nie włącza ich do <code>indexB</code>. W szczególności:</p> + +<ul> + <li>Jeśli <code>indexA</code> jest mniejsze niż 0, <code>indexA</code> zostanie potraktowany tak, jakby był 0.</li> + <li>Jeśli <code>indexB</code> jest większe niż <code>stringName.length</code>, <code>indexB</code> zostanie potraktowany tak, jakby był <code>stringName.length</code>.</li> + <li>Jeśli <code>indexA</code> jest równe <code>indexB</code>, <code>substring</code> zwraca pusty łańcuch znaków.</li> + <li>Jeśli <code>indexB</code> jest pominięty, <code>substring</code> urwie znaki znajdujące się na końcu łańcucha znaków.</li> +</ul> + +<p>Jeśli <code>indexA</code> jest większy niż <code>indexB</code>, JavaScript zwróci <code>substring(indexB, indexA)</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_substring" name="Przyk.C5.82ad:_Zastosowanie_substring">Przykład: Zastosowanie <code>substring()</code></h3> + +<p>Następujący przykład <code>substring</code> stosujemy do wyświetlenia znaków ze słowa "<code>Mozilla</code>":</p> + +<pre class="brush: js">var anyString = "Mozilla"; + +// Wyświetli "Moz" +console.log(anyString.substring(0,3)); +console.log(anyString.substring(3,0)); + +// Wyświetli "lla" +console.log(anyString.substring(4)); +console.log(anyString.substring(4,7)); +console.log(anyString.substring(7,4)); + +// Wyświetli "Mozill" +console.log(anyString.substring(0,6)); + +// Wyświetli "Mozilla" +console.log(anyString.substring(0,7)); +console.log(anyString.substring(0,10)); +</pre> + +<h3 id="Przyk.C5.82ad:_Zamina_podci.C4.85gu_wewn.C4.85trz_ci.C4.85gu" name="Przyk.C5.82ad:_Zamina_podci.C4.85gu_wewn.C4.85trz_ci.C4.85gu">Przykład: Zamiana podciągu wewnątrz ciągu</h3> + +<p>Następujący przykład zamienia podciąg wewnątrz ciągu. Zostaną zamienione oba poszczególne znaki i podciągi. Funkcja zostanie wywołana na koniec przykładu zmieniając łańcuch znaków; "<code>Brave New World</code>" na "<code>Brave New Web</code>".</p> + +<pre class="brush: js">function replaceString(oldS, newS, fullS) { +// Replaces oldS with newS in the string fullS + for (var i = 0; i < fullS.length; i++) { + if (fullS.substring(i, i + oldS.length) == oldS) { + fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length); + } + } + return fullS; +} + +replaceString("World", "Web", "Brave New World"); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.slice()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/sup/index.html b/files/pl/web/javascript/reference/global_objects/string/sup/index.html new file mode 100644 index 0000000000..50aca68b97 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/sup/index.html @@ -0,0 +1,46 @@ +--- +title: String.prototype.sup() +slug: Web/JavaScript/Reference/Global_Objects/String/sup +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sup +original_slug: Web/JavaScript/Referencje/Obiekty/String/sup +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony jako indeks górny tak jakby był wewnątrz znacznika {{HTMLElement("sup")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.sup()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>sup()</code> method embeds a string in a <code><sup></code> tag: <code>"<sup>str</sup>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_metody_sub_i_sup_do_zmiany_formatu_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_sub_i_sup_do_zmiany_formatu_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie metody <code>sub()</code> i <code>sup()</code></h4> + +<p>Następujący przykład stosuje metodę {{jsxref("String.prototype.sub()", "sub()")}} i <code>sup()</code> do zmiany formatu łańcucha znaków:</p> + +<pre class="brush: js">var superText="superscript"; +var subText="subscript"; + +console.log("This is what a " + superText.sup() + " looks like."); +// This is what a <sup>superscript</sup> looks like + +console.log("This is what a " + subText.sub() + " looks like."); +// This is what a <sub>subscript</sub> looks like.</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.sub()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/pl/web/javascript/reference/global_objects/string/tolowercase/index.html new file mode 100644 index 0000000000..8cb6d10a10 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/tolowercase/index.html @@ -0,0 +1,41 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +original_slug: Web/JavaScript/Referencje/Obiekty/String/toLowerCase +--- +<p>{{jsref}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość wywołującego łańcucha znaków, skonwertowaną na małe litery.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.toLowerCase()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toLowerCase()</code> zwraca wartość łańcucha znaków skonwertowanego na małe litery. <code>toLowerCase()</code> nie wpływa na wartość samego łańcucha.</p> + +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_toLowerCase" name="Przyk.C5.82ad:_Zastosowanie_toLowerCase">Przykład: Zastosowanie <code>toLowerCase</code></h4> + +<p>Następujący przykład wyświetli łańcuch "<code>alfabet</code>" złożony z małych liter:</p> + +<pre class="brush: js">console.log('ALFABET'.toLowerCase()); // 'alfabet' +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/tosource/index.html b/files/pl/web/javascript/reference/global_objects/string/tosource/index.html new file mode 100644 index 0000000000..3540727b00 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/tosource/index.html @@ -0,0 +1,42 @@ +--- +title: String.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/String/toSource +tags: + - JavaScript + - Method + - Non-standard + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource +original_slug: Web/JavaScript/Referencje/Obiekty/String/toSource +--- +<p>{{JSRef}}{{non-standard_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>String.toSource() +<var>str</var>.toSource() +</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toSource()</code> zwraca następujące wartości:</p> + +<ul> + <li>Dla wbudowanego obiektu {{jsxref("String")}}, <code>toSource()</code> zwraca następujący łańcuch znaków wskazujący, że kod źródłowy nie jest dostępny: + + <pre class="brush: js">function String() { + [natywny kod] +} +</pre> + </li> + <li>W przypadku obiektu {{jsxref("String")}} lub łańcuchów znaków, <code>toSource()</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Ta metoda jest w JavaScript wywoływana zazwyczaj wewnętrznie, nie bezpośrednio w kodzie.</p> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/reference/global_objects/string/tostring/index.html b/files/pl/web/javascript/reference/global_objects/string/tostring/index.html new file mode 100644 index 0000000000..ab19cbe40c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/tostring/index.html @@ -0,0 +1,42 @@ +--- +title: String.protype.toString() +slug: Web/JavaScript/Reference/Global_Objects/String/toString +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toString +original_slug: Web/JavaScript/Referencje/Obiekty/String/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>str</var>.toString()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("String")}} przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref("String")}}, metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toString" name="Przyk.C5.82ad:_Zastosowanie_toString">Przykład: Zastosowanie <code>toString()</code></h3> + +<p>Następujący przykład wyświetli wartość łańcuch znaków obiektu {{jsxref("String")}}:</p> + +<pre class="brush: js">var x = new String("Witaj świecie"); + +console.log(x.toString()) // Wyświetla "Witaj świecie" +</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("String.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/touppercase/index.html b/files/pl/web/javascript/reference/global_objects/string/touppercase/index.html new file mode 100644 index 0000000000..f56902e420 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/touppercase/index.html @@ -0,0 +1,39 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +original_slug: Web/JavaScript/Referencje/Obiekty/String/toUpperCase +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość wywołującego łańcucha znaków, skonwertowaną na duże litery.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.toUpperCase()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toUpperCase()</code> zwraca wartość łańcucha znaków skonwertowanego na duże litery. <code>toUpperCase()</code> nie wpływa na wartość samego łańcucha.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toUpperCase" name="Przyk.C5.82ad:_Zastosowanie_toUpperCase">Przykład: Zastosowanie <code>toUpperCase()</code></h3> + +<pre class="brush: js">console.log('alfabet'.toUpperCase()); // 'ALFABET' +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/string/valueof/index.html b/files/pl/web/javascript/reference/global_objects/string/valueof/index.html new file mode 100644 index 0000000000..9d7e986682 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/string/valueof/index.html @@ -0,0 +1,41 @@ +--- +title: String.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/String/valueOf +tags: + - JavaScript + - Method + - Property + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf +original_slug: Web/JavaScript/Referencje/Obiekty/String/valueOf +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca pierwotną wartość obiektu {{jsxref("String")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.valueOf()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>valueOf()</code> obiektu {{jsxref("String")}} zwraca pierwotną wartość obiektu {{jsxref("String")}} jako łańcuch znaków. Ta wartość jest równoważna do {{jsxref("String.prototype.toString()")}}.</p> + +<p>Ta metoda jest w JavaScript wywoływana zazwyczaj wewnętrznie, nie bezpośrednio w kodzie.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_valueOf" name="Przyk.C5.82ad:_Zastosowanie_valueOf">Przykład: Zastosowanie <code>valueOf()</code></h3> + +<pre class="brush: js">var x = new String("Witaj świecie"); +console.log(x.valueOf()); // Wyświetla "Witaj świecie" +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.toString()")}}</li> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/symbol/index.html b/files/pl/web/javascript/reference/global_objects/symbol/index.html new file mode 100644 index 0000000000..4ff4612b3f --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/symbol/index.html @@ -0,0 +1,228 @@ +--- +title: Symbol +slug: Web/JavaScript/Reference/Global_Objects/Symbol +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol +original_slug: Web/JavaScript/Referencje/Obiekty/Symbol +--- +<div>{{JSRef}}</div> + +<p>Funkcja <code>Symbol()</code> zwraca wartość typu <strong>symbol</strong>, posiada statyczne własności wystawiające kilka wartości używanych we wbudowanych obiektach, posiada statyczne metody wystawiające globalny rejestr symboli i przypomina wbudowaną klasę obiektu, jest jednak niekompletna jako konstruktor ponieważ nie wspiera składni "<code>new Symbol()</code>". </p> + +<p>Każdy symbol zwrócony przez <code>Symbol()</code> jest unikalny. Symbol powinien być użyty jako identyfikator własności obiektu, został zaprojektowany jedynie w tym celu. Pełniejsze wyjaśnienie dotyczące jego przeznaczenia i użycia można znaleźć w <a href="/en-US/docs/Glossary/Symbol">poświęconym mu wpisie w glosariuszu</a>.</p> + +<p>Typ <strong>symbol</strong> jest {{Glossary("Primitive", "typem prostym")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-constructor.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">Symbol(<em>[opis]</em>)</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>opis</code> {{optional_inline}}</dt> + <dd>Ciąg znaków, parametr opcjonalny. Opis symbolu, może być użyty do debugowania, ale nie do dostania się do samego symbolu.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Aby stworzyć nowy symbol należy użyć funkcji <code>Symbol()</code>, opcjonalnie przekazując jej opisowy ciąg znaków:</p> + +<pre class="brush: js">var sym1 = Symbol(); +var sym2 = Symbol('foo'); +var sym3 = Symbol('foo'); +</pre> + +<p>Powyższy kod tworzy trzy nowe symbole. Należy zwrócić uwagę, że <code>Symbol("foo")</code> nie konwertuje ciągu znaków "foo" na symbol, tylko tworzy za każdym razem nowy symbol:</p> + +<pre class="brush: js">Symbol('foo') === Symbol('foo'); // false</pre> + +<p>Następująca składnia z operatorem {{jsxref("Operators/new", "new")}} spowoduje wyjątek {{jsxref("TypeError")}}:</p> + +<pre class="brush: js">var sym = new Symbol(); // TypeError</pre> + +<p>Dzieje się tak dlatego żeby powstrzymać programistów przed opakowywaniem wartości symboli w obiekty i może być zaskakujące, gdyż tworzenie opakowanych wartości dla typów prostych jest zazwyczaj możliwe (na przykład <code>new Boolean</code>, <code>new String</code> i <code>new Number</code>).</p> + +<p>Jeśli stworzenie opakowanego symbolu jest dokładnie tym czego chce programista, może do tego użyć funkcji <code>Object()</code>:</p> + +<pre class="brush: js">var sym = Symbol('foo'); +typeof sym; // "symbol" +var symObj = Object(sym); +typeof symObj; // "object" +</pre> + +<h3 id="Symbole_współdzielone_w_globalnym_rejestrze_symboli">Symbole współdzielone w globalnym rejestrze symboli</h3> + +<p>Powyższa składnia używająca funkcji <code>Symbol()</code> nie stworzy globalnego symbolu, który będzie dostępny w całym kodzie. Aby stworzyć symbol dostępny między plikami, a nawet między sferami (z których każda ma swoją globalną przestrzeń) należy użyć metody {{jsxref("Symbol.for()")}}. Z kolei metody {{jsxref("Symbol.keyFor()")}} można użyć aby uzyskać nazwę globalnego klucza dla posiadanego symbolu.</p> + +<h3 id="Znajdowanie_własności_indeksowanych_symbolami_na_obiekcie">Znajdowanie własności indeksowanych symbolami na obiekcie</h3> + +<p>Metoda {{jsxref("Object.getOwnPropertySymbols()")}} zwraca tablicę symboli i pozwala znaleźć własności indeksowane symbolami na danym obiekcie. Każdy obiekt jest inicjowany bez takich własności, więc metoda ta zwróci pustą tablicę do czasu ustawienia na obiekcie własności pod kluczem typu symbol.</p> + +<h2 id="Własności">Własności</h2> + +<dl> + <dt><code>Symbol.length</code></dt> + <dd>Własność length której wartością jest 0.</dd> + <dt>{{jsxref("Symbol.prototype")}}</dt> + <dd>Reprezentuje prototyp konstruktora <code>Symbol</code>.</dd> +</dl> + +<h3 id="Znane_symbole">Znane symbole</h3> + +<p>Oprócz symboli zdefiniowanych przez programistę, JavaScript posiada wbudowane symbole reprezentujące wewnętrzne mechanizmy języka, które nie były widoczne dla programisty w wersji ECMAScript 5 i wcześniejszych. Dostęp do tych symboli jest możliwy za pomocą następujących własności statycznych:</p> + +<h4 id="Symbole_iteracji">Symbole iteracji</h4> + +<dl> + <dt>{{jsxref("Symbol.iterator")}}</dt> + <dd>Metoda zwracająca domyślny iterator dla obiektu. Używana przez <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>.</dd> + <dt>{{jsxref("Symbol.asyncIterator")}} {{experimental_inline}}</dt> + <dd>Metoda zwracająca domyślny asynchroniczny iterator dla obiektu. Używana przez <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for-await-of"><code>for await of</code></a>.</dd> +</dl> + +<h4 id="Symbole_wyrażeń_regularnych">Symbole wyrażeń regularnych</h4> + +<dl> + <dt>{{jsxref("Symbol.match")}}</dt> + <dd>Metoda dopasowująca dla ciągu znaków, używana również dla określenia czy obiekt może zostać użyty jako wyrażenie regularne. Używana przez {{jsxref("String.prototype.match()")}}.</dd> + <dt>{{jsxref("Symbol.replace")}}</dt> + <dd>Metoda zastępująca dopasowany ciąg w ciągu znaków. Używana przez {{jsxref("String.prototype.replace()")}}.</dd> + <dt>{{jsxref("Symbol.search")}}</dt> + <dd>Metoda zwracająca indeks początku ciągu znaków który został dopasowany do wyrażenia regularnego. Używana przez {{jsxref("String.prototype.search()")}}.</dd> + <dt>{{jsxref("Symbol.split")}}</dt> + <dd>Metoda dzieląca łańcuch znaków w miejscu w którym został dopasowany do wyrażenia regularnego. Używana przez {{jsxref("String.prototype.split()")}}.</dd> +</dl> + +<h4 id="Pozostałe_symbole">Pozostałe symbole</h4> + +<dl> + <dt>{{jsxref("Symbol.hasInstance")}}</dt> + <dd>Metoda określająca czy konstruktor rozpoznaje obiekt jako swoją instancję. Używana przez {{jsxref("Operators/instanceof", "instanceof")}}.</dd> + <dt>{{jsxref("Symbol.isConcatSpreadable")}}</dt> + <dd>Wartość logiczna określająca czy obiekt powinien zostać spłaszczony do jego elementów tablicy. Używana przez {{jsxref("Array.prototype.concat()")}}.</dd> + <dt>{{jsxref("Symbol.unscopables")}}</dt> + <dd>Wartość obiektu którego własne i dziediczone nazwy własności są wykluczone ze środowiska <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> powiązanego obiektu.</dd> + <dt>{{jsxref("Symbol.species")}}</dt> + <dd>Funkcja konstruktora używana do tworzenia obiektów wywodzących się z danego.</dd> + <dt>{{jsxref("Symbol.toPrimitive")}}</dt> + <dd>Metoda konwertująca obiekt na typ prosty.</dd> + <dt>{{jsxref("Symbol.toStringTag")}}</dt> + <dd>Ciąg znaków używany dla domyślnego opisu obiektu. Używany przez {{jsxref("Object.prototype.toString()")}}.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Symbol.for()", "Symbol.for(key)")}}</dt> + <dd>Szuka istniejącego symbolu o podanym kluczu i zwraca go, jeśli został znaleziony. W przeciwnym razie w globalnym rejestrze tworzony jest nowy symbol o podanym kluczu i również zwracany.</dd> + <dt>{{jsxref("Symbol.keyFor", "Symbol.keyFor(sym)")}}</dt> + <dd>Zwraca klucz w globalnym rejestrze zapisany dla danego symbolu.</dd> +</dl> + +<h2 id="Symbol_prototype"><code>Symbol</code> prototype</h2> + +<p>Wszystkie symbole dziecidzą po {{jsxref("Symbol.prototype")}}.</p> + +<h3 id="Własności_2">Własności</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Properties')}}</p> + +<h3 id="Metody_2">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Methods')}}</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_operatora_typeof_z_symbolami">Używanie operatora <code>typeof</code> z symbolami</h3> + +<p>Operator {{jsxref("Operators/typeof", "typeof")}} może pomóc w identyfikacji symboli.</p> + +<pre class="brush: js">typeof Symbol() === 'symbol' +typeof Symbol('foo') === 'symbol' +typeof Symbol.iterator === 'symbol' +</pre> + +<h3 id="Konwersje_typu_symbol">Konwersje typu symbol</h3> + +<ul> + <li>Podczas próby konwersji symbolu na liczbę zostanie rzucony wyjątek {{jsxref("TypeError")}}.<br> + (np. <code>+sym</code> lub <code>sym | 0</code>).</li> + <li>Przy porównaniu z pominięciem typu <code>Object(sym) == sym</code> zwraca <code>true.</code></li> + <li><code>Symbol("foo") + "bar" </code>wyrzuci {{jsxref("TypeError")}} (nie można skonwertować symbolu na ciąg znaków). Służy to powstrzymaniu programisty na przykład przed stworzeniem nowej nazwy własności z użyciem symbolu.</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#String_conversion">"Bezpieczniejsza" konwersja <code>String(sym)</code></a> działa jak wywołanie {{jsxref("Symbol.prototype.toString()")}} ale należy mieć na uwadze, że <code>new String(sym)</code> rzuci wyjątkiem.</li> +</ul> + +<h3 id="Symbole_i_iteracja_for...in">Symbole i iteracja <code>for...in</code></h3> + +<p>Symbole nie są iterowalne w pętlach <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a>. Dodatkowo, {{jsxref("Object.getOwnPropertyNames()")}} nie zwróci własności obiektu zapisanych pod kluczem którym jest symbol, do tego celu można użyć {{jsxref("Object.getOwnPropertySymbols()")}}.</p> + +<pre class="brush: js">var obj = {}; + +obj[Symbol('a')] = 'a'; +obj[Symbol.for('b')] = 'b'; +obj['c'] = 'c'; +obj.d = 'd'; + +for (var i in obj) { + console.log(i); // loguje "c" i "d" +}</pre> + +<h3 id="Symbole_i_JSON.stringify()">Symbole i <code>JSON.stringify()</code></h3> + +<p>Własności obiektu znajdujące się pod kluczem w postaci symbolu są ignorowane przez <code>JSON.stringify()</code>:</p> + +<pre class="brush: js">JSON.stringify({[Symbol('foo')]: 'foo'}); +// '{}'</pre> + +<p>Żeby dowiedzieć się więcej zobacz {{jsxref("JSON.stringify()")}}.</p> + +<h3 id="Symbole_opakowane_w_obiekty_jako_klucze_własności">Symbole opakowane w obiekty jako klucze własności</h3> + +<p>Gdy symbol opakowany w obiekt jest użyty jako klucz własności, obiekt opakowujący zostanie skonwertowany do symbolu który opakowuje:</p> + +<pre class="brush: js">var sym = Symbol('foo'); +var obj = {[sym]: 1}; +obj[sym]; // 1 +obj[Object(sym)]; // nadal 1 +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-symbol-objects', 'Symbol')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Wstępna definicja</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-symbol-objects', 'Symbol')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.Symbol")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Glossary/Symbol">Glosariusz: typ Symbol</a></li> + <li>{{jsxref("Operators/typeof", "typeof")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Data_structures">Typy i struktury danych</a></li> + <li><a href="https://hacks.mozilla.org/2015/06/es6-in-depth-symbols/">"ES6 In Depth: Symbols" na hacks.mozilla.org</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/syntaxerror/index.html b/files/pl/web/javascript/reference/global_objects/syntaxerror/index.html new file mode 100644 index 0000000000..eaef4344ce --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/syntaxerror/index.html @@ -0,0 +1,101 @@ +--- +title: SyntaxError +slug: Web/JavaScript/Reference/Global_Objects/SyntaxError +tags: + - Błąd składniowy + - JavaScript + - Klasa + - Obiekt + - Referencja + - SyntaxError +translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError +original_slug: Web/JavaScript/Referencje/Obiekty/SyntaxError +--- +<div>{{JSRef}}</div> + +<p>Obiekt <code><strong>SyntaxError</strong></code> reprezentuje błąd przy próbie interpretacji kodu niepoprawnego pod względem składni. Jest wyrzucany wtedy, gdy silnik JavaScript podczas interpretacji kodu napotyka znak lub ciąg znaków niezgodny ze składnią języka.</p> + +<h2 id="Konstruktor">Konstruktor</h2> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/SyntaxError"><code>SyntaxError()</code></a></dt> + <dd>Tworzy nowy obiekt <code>SyntaxError</code>.</dd> +</dl> + +<h2 id="Właściwości_instancji">Właściwości instancji</h2> + +<dl> + <dt>{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}</dt> + <dd>Wiadomość błędu. Chociaż ECMA-262 mówi, że {{jsxref("SyntaxError")}} powinien dostarczać własną właściwość <code>message</code>, w <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> jest ona dziedziczona z {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}</dt> + <dd>Nazwa błędu. Odziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}</dt> + <dd>Ścieżka do pliku zawierającego błąd. Odziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}</dt> + <dd>Numer zawierającej błąd linii w pliku. Odziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}</dt> + <dd>Numer zawierającej błąd kolumny w linii kodu. Odziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}}</dt> + <dd>Stos wywołań. Odziedziczone z {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Obsługa_SyntaxError">Obsługa <code>SyntaxError</code></h3> + +<pre class="brush: js">try { + eval('hoo bar'); +} catch (e) { + console.error(e instanceof SyntaxError); + console.error(e.message); + console.error(e.name); + console.error(e.fileName); + console.error(e.lineNumber); + console.error(e.columnNumber); + console.error(e.stack); +} +</pre> + +<h3 id="Tworzenie_SyntaxError">Tworzenie <code>SyntaxError</code></h3> + +<pre class="brush: js">try { + throw new SyntaxError('Hej', 'jakisPlik.js', 10); +} catch (e) { + console.error(e instanceof SyntaxError); // true + console.error(e.message); // Hej + console.error(e.name); // SyntaxError + console.error(e.fileName); // jakisPlik.js + console.error(e.lineNumber); // 10 + console.error(e.columnNumber); // 0 + console.error(e.stack); // @debugger eval code:3:9 +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-syntaxerror', 'SyntaxError')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.SyntaxError")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/uint16array/index.html b/files/pl/web/javascript/reference/global_objects/uint16array/index.html new file mode 100644 index 0000000000..759ad9d56e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/uint16array/index.html @@ -0,0 +1,225 @@ +--- +title: Uint16Array +slug: Web/JavaScript/Reference/Global_Objects/Uint16Array +translation_of: Web/JavaScript/Reference/Global_Objects/Uint16Array +original_slug: Web/JavaScript/Referencje/Obiekty/Uint16Array +--- +<div>{{JSRef("Global_Objects", "TypedArray", "Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array")}}</div> + +<h2 id="Summary">Summary</h2> + +<p>The <strong><code>Uint16Array</code></strong> typed array represents an array of 16-bit unsigned integers in the platform byte order. If control over byte order is needed, use {{jsxref("DataView")}} instead. The contents are initialized to <code>0</code>. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Uint16Array(length); +Uint16Array(typedArray); +Uint16Array(object); +Uint16Array(buffer [, byteOffset [, length]]);</pre> + +<p>For more information about the constructor syntax and the parameters, see <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Uint16Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Returns a number value of the element size. <code>2</code> in the case of an <code>Uint16Array</code>.</dd> + <dt>Uint16Array.length</dt> + <dd>Length property whose value is 3.</dd> + <dt>{{jsxref("TypedArray.name", "Uint16Array.name")}}</dt> + <dd>Returns the string value of the constructor name. In the case of the <code>Uint16Array</code> type: "Uint16Array".</dd> + <dt>{{jsxref("TypedArray.prototype", "Uint16Array.prototype")}}</dt> + <dd>Prototype for the <em>TypedArray</em> objects.</dd> +</dl> + +<h2 id="Methods">Methods</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Uint16Array.from()")}}</dt> + <dd>Creates a new <code>Uint16Array</code> from an array-like or iterable object. See also {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Uint16Array.of()")}}</dt> + <dd>Creates a new <code>Uint16Array</code> with a variable number of arguments. See also {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Boolean_instances" name="Boolean_instances"><code>Uint16Array</code> prototype</h2> + +<p>All <code>Uint16Array</code> objects inherit from {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p> + +<h3 id="Properties_2">Properties</h3> + +<dl> + <dt><code>Uint16Array.prototype.constructor</code></dt> + <dd>Returns the function that created an instance's prototype. This is the <code>Uint16Array</code> constructor by default.</dd> + <dt>{{jsxref("TypedArray.prototype.buffer", "Uint16Array.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Returns the {{jsxref("ArrayBuffer")}} referenced by the <code>Uint16Array</code> Fixed at construction time and thus <strong>read only</strong>.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Uint16Array.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Returns the length (in bytes) of the <code>Uint16Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Uint16Array.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Returns the offset (in bytes) of the <code>Uint16Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd> + <dt>{{jsxref("TypedArray.prototype.length", "Uint16Array.prototype.length")}} {{readonlyInline}}</dt> + <dd>Returns the number of elements hold in the <code>Uint16Array</code>. Fixed at construction time and thus <strong>read only.</strong></dd> +</dl> + +<h3 id="Methods_2">Methods</h3> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Uint16Array.prototype.copyWithin()")}}</dt> + <dd>Copies a sequence of array elements within the array. See also {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Uint16Array.prototype.entries()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> object that contains the key/value pairs for each index in the array. See also {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Uint16Array.prototype.every()")}}</dt> + <dd>Tests whether all elements in the array pass the test provided by a function. See also {{jsxref("Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Uint16Array.prototype.fill()")}}</dt> + <dd>Fills all the elements of an array from a start index to an end index with a static value. See also {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Uint16Array.prototype.filter()")}}</dt> + <dd>Creates a new array with all of the elements of this array for which the provided filtering function returns true. See also {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Uint16Array.prototype.find()")}}</dt> + <dd>Returns the found value in the array, if an element in the array satisfies the provided testing function or <code>undefined</code> if not found. See also {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Uint16Array.prototype.findIndex()")}}</dt> + <dd>Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found. See also {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Uint16Array.prototype.forEach()")}}</dt> + <dd>Calls a function for each element in the array. See also {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Uint16Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Determines whether a typed array includes a certain element, returning <code>true</code> or <code>false</code> as appropriate. See also {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Uint16Array.prototype.indexOf()")}}</dt> + <dd>Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Uint16Array.prototype.join()")}}</dt> + <dd>Joins all elements of an array into a string. See also {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Uint16Array.prototype.keys()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> that contains the keys for each index in the array. See also {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Uint16Array.prototype.lastIndexOf()")}}</dt> + <dd>Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Uint16Array.prototype.map()")}}</dt> + <dd>Creates a new array with the results of calling a provided function on every element in this array. See also {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.move", "Uint16Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt> + <dd>Former non-standard version of {{jsxref("TypedArray.copyWithin", "Uint16Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Uint16Array.prototype.reduce()")}}</dt> + <dd>Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Uint16Array.prototype.reduceRight()")}}</dt> + <dd>Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduceRight()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Uint16Array.prototype.reverse()")}}</dt> + <dd>Reverses the order of the elements of an array — the first becomes the last, and the last becomes the first. See also {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Uint16Array.prototype.set()")}}</dt> + <dd>Stores multiple values in the typed array, reading input values from a specified array.</dd> + <dt>{{jsxref("TypedArray.slice", "Uint16Array.prototype.slice()")}}</dt> + <dd>Extracts a section of an array and returns a new array. See also {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Uint16Array.prototype.some()")}}</dt> + <dd>Returns true if at least one element in this array satisfies the provided testing function. See also {{jsxref("Array.prototype.some()")}}.</dd> + <dt>{{jsxref("TypedArray.sort", "Uint16Array.prototype.sort()")}}</dt> + <dd>Sorts the elements of an array in place and returns the array. See also {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Uint16Array.prototype.subarray()")}}</dt> + <dd>Returns a new <code>Uint16Array</code> from the given start and end element index.</dd> + <dt>{{jsxref("TypedArray.values", "Uint16Array.prototype.values()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array. See also {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Uint16Array.prototype.toLocaleString()")}}</dt> + <dd>Returns a localized string representing the array and its elements. See also {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Uint16Array.prototype.toString()")}}</dt> + <dd>Returns a string representing the array and its elements. See also {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Uint16Array.prototype[@@iterator]()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array.</dd> +</dl> + +<h2 id="Examples">Examples</h2> + +<pre class="brush: js">// From a length +var uint16 = new Uint16Array(2); +uint16[0] = 42; +console.log(uint16[0]); // 42 +console.log(uint16.length); // 2 +console.log(uint16.BYTES_PER_ELEMENT); // 2 + +// From an array +var arr = new Uint16Array([21,31]); +console.log(arr[1]); // 31 + +// From another TypedArray +var x = new Uint16Array([21, 31]); +var y = new Uint16Array(x); +console.log(y[0]); // 21 + +// From an ArrayBuffer +var buffer = new ArrayBuffer(8); +var z = new Uint16Array(buffer, 0, 4); +</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><a href="https://www.khronos.org/registry/typedarray/specs/latest/#7">Typed Array Specification</a></td> + <td>Obsolete</td> + <td><span><span>Superseded by ECMAScript 6.</span></span></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#table-45', 'TypedArray constructors')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition in an ECMA standard.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>7.0</td> + <td>{{ CompatGeckoDesktop("2") }}</td> + <td>10</td> + <td>11.6</td> + <td>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>4.0</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatGeckoMobile("2") }}</td> + <td>10</td> + <td>11.6</td> + <td>4.2</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/undefined/index.html b/files/pl/web/javascript/reference/global_objects/undefined/index.html new file mode 100644 index 0000000000..f2e31e90c2 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/undefined/index.html @@ -0,0 +1,41 @@ +--- +title: undefined +slug: Web/JavaScript/Reference/Global_Objects/undefined +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/undefined +original_slug: Web/JavaScript/Referencje/Obiekty/undefined +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość niezdefiniowana.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>undefined</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>undefined</code> jest własnością najwyższego rzędu i nie jest przypisana do żadnego obiektu.</p> + +<p>Zmienna, której nie przypisano wartości, jest typu undefined. Metoda lub wyrażenie zwraca <code>undefined</code>, jeśli wyliczana zmienna nie posiada wartości.</p> + +<p>Można wykorzystać <code>undefined</code> do zbadania, czy dana zmienna ma wartość. W poniższym kodzie zmienna <code>x</code> nie jest zdefiniowana i wyrażenie <code>if</code> ma wartość "prawda" (true).</p> + +<pre class="brush: js">var x; +if (x === undefined) { + // polecenia tu umieszczone są wykonywane +} else { + // polecenia tu umieszczone nie są wykonywane +} +</pre> + +<p><code>undefined</code> jest także wartością prostą.</p> |