diff options
Diffstat (limited to 'files/pl/web/javascript/reference/global_objects/array')
36 files changed, 4640 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..014219e1d9 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/concat/index.html @@ -0,0 +1,71 @@ +--- +title: Array.prototype.concat() +slug: Web/JavaScript/Referencje/Obiekty/Array/concat +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..1a1917eabd --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/copywithin/index.html @@ -0,0 +1,181 @@ +--- +title: Array.prototype.copyWithin() +slug: Web/JavaScript/Referencje/Obiekty/Array/copyWithin +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Metodă + - Peototyp + - Prototype + - Reference + - Referencja + - Tablica + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/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..6ff83958f4 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/entries/index.html @@ -0,0 +1,77 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Referencje/Obiekty/Array/entries +translation_of: Web/JavaScript/Reference/Global_Objects/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..4b6cb612a2 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/every/index.html @@ -0,0 +1,89 @@ +--- +title: Array.prototype.every() +slug: Web/JavaScript/Referencje/Obiekty/Array/every +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..1ab2ef4719 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/fill/index.html @@ -0,0 +1,185 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Referencje/Obiekty/Array/fill +translation_of: Web/JavaScript/Reference/Global_Objects/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..4b18a34c9c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/filter/index.html @@ -0,0 +1,150 @@ +--- +title: Array.prototype.filter() +slug: Web/JavaScript/Referencje/Obiekty/Array/filter +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..6e8d67373b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/find/index.html @@ -0,0 +1,278 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Referencje/Obiekty/Array/find +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Metodă + - Prototype + - Referencja + - Tablica + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/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..86a9cf67cf --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/findindex/index.html @@ -0,0 +1,214 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Referencje/Obiekty/Array/findIndex +translation_of: Web/JavaScript/Reference/Global_Objects/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..3c8de3a43c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/flat/index.html @@ -0,0 +1,173 @@ +--- +title: Array.prototype.flat() +slug: Web/JavaScript/Referencje/Obiekty/Array/flat +translation_of: Web/JavaScript/Reference/Global_Objects/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..6968498311 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/foreach/index.html @@ -0,0 +1,104 @@ +--- +title: Array.prototype.forEach() +slug: Web/JavaScript/Referencje/Obiekty/Array/forEach +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..bd5f0294de --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/from/index.html @@ -0,0 +1,248 @@ +--- +title: Array.from() +slug: Web/JavaScript/Referencje/Obiekty/Array/from +translation_of: Web/JavaScript/Reference/Global_Objects/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..526e660571 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/includes/index.html @@ -0,0 +1,110 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Referencje/Obiekty/Array/includes +translation_of: Web/JavaScript/Reference/Global_Objects/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..5cfe52578b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/index.html @@ -0,0 +1,279 @@ +--- +title: Array +slug: Web/JavaScript/Referencje/Obiekty/Array +tags: + - Array + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/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..db63c3384c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/indexof/index.html @@ -0,0 +1,95 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Referencje/Obiekty/Array/indexOf +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..62083e0853 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/isarray/index.html @@ -0,0 +1,139 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Referencje/Obiekty/Array/isArray +translation_of: Web/JavaScript/Reference/Global_Objects/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..b4b22afc49 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/join/index.html @@ -0,0 +1,50 @@ +--- +title: Array.prototype.join() +slug: Web/JavaScript/Referencje/Obiekty/Array/join +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..4ab6d7e18e --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/keys/index.html @@ -0,0 +1,120 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Referencje/Obiekty/Array/keys +translation_of: Web/JavaScript/Reference/Global_Objects/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..3a6322d6b4 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/lastindexof/index.html @@ -0,0 +1,114 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Referencje/Obiekty/Array/lastIndexOf +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..0ce2bbde35 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/length/index.html @@ -0,0 +1,53 @@ +--- +title: Array.prototype.length +slug: Web/JavaScript/Referencje/Obiekty/Array/length +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..2b25e7f1cd --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/map/index.html @@ -0,0 +1,93 @@ +--- +title: Array.prototype.map() +slug: Web/JavaScript/Referencje/Obiekty/Array/map +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..74c9974bd0 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/of/index.html @@ -0,0 +1,92 @@ +--- +title: Array.of() +slug: Web/JavaScript/Referencje/Obiekty/Array/of +translation_of: Web/JavaScript/Reference/Global_Objects/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..2b7483dbd7 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/pop/index.html @@ -0,0 +1,138 @@ +--- +title: Array.prototype.pop() +slug: Web/JavaScript/Referencje/Obiekty/Array/pop +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Metodă + - Prototype + - Tablica +translation_of: Web/JavaScript/Reference/Global_Objects/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..92bf342cda --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/push/index.html @@ -0,0 +1,51 @@ +--- +title: Array.prototype.push() +slug: Web/JavaScript/Referencje/Obiekty/Array/push +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..8699a308c5 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/reduce/index.html @@ -0,0 +1,300 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Referencje/Obiekty/Array/Reduce +translation_of: Web/JavaScript/Reference/Global_Objects/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..fcb2b0e694 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/reduceright/index.html @@ -0,0 +1,344 @@ +--- +title: Array.prototype.reduceRight() +slug: Web/JavaScript/Referencje/Obiekty/Array/ReduceRight +translation_of: Web/JavaScript/Reference/Global_Objects/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..bc6fd9082b --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/reverse/index.html @@ -0,0 +1,55 @@ +--- +title: Array.prototype.reverse() +slug: Web/JavaScript/Referencje/Obiekty/Array/reverse +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..adf8ca36e4 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/shift/index.html @@ -0,0 +1,48 @@ +--- +title: Array.prototype.shift() +slug: Web/JavaScript/Referencje/Obiekty/Array/shift +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..ced8efba96 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/slice/index.html @@ -0,0 +1,99 @@ +--- +title: Array.prototype.slice() +slug: Web/JavaScript/Referencje/Obiekty/Array/slice +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..6ba1777370 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/some/index.html @@ -0,0 +1,110 @@ +--- +title: Array.prototype.some() +slug: Web/JavaScript/Referencje/Obiekty/Array/some +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..2b53d4e6d5 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/sort/index.html @@ -0,0 +1,122 @@ +--- +title: Array.prototype.sort() +slug: Web/JavaScript/Referencje/Obiekty/Array/sort +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..cc4d13def3 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/splice/index.html @@ -0,0 +1,86 @@ +--- +title: Array.prototype.splice() +slug: Web/JavaScript/Referencje/Obiekty/Array/splice +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..1dc476c413 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/tolocalestring/index.html @@ -0,0 +1,128 @@ +--- +title: Array.prototype.toLocaleString() +slug: Web/JavaScript/Referencje/Obiekty/Array/toLocaleString +translation_of: Web/JavaScript/Reference/Global_Objects/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..675e8431a2 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/tosource/index.html @@ -0,0 +1,62 @@ +--- +title: Array.prototype.toSource() +slug: Web/JavaScript/Referencje/Obiekty/Array/toSource +tags: + - Array + - JavaScript + - Method + - Non-standard + - Prototype + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..e4801cbdc4 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/tostring/index.html @@ -0,0 +1,42 @@ +--- +title: Array.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/Array/toString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..56346f6552 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/unshift/index.html @@ -0,0 +1,56 @@ +--- +title: Array.prototype.unshift() +slug: Web/JavaScript/Referencje/Obiekty/Array/unshift +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/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..b079877dd9 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/array/values/index.html @@ -0,0 +1,84 @@ +--- +title: Array.prototype.values() +slug: Web/JavaScript/Referencje/Obiekty/Array/values +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Metodă + - Prototype + - Tablica +translation_of: Web/JavaScript/Reference/Global_Objects/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> |