From de5c456ebded0e038adbf23db34cc290c8829180 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:49:24 +0100 Subject: unslug pl: move --- .../global_objects/array/concat/index.html | 71 +++++ .../global_objects/array/copywithin/index.html | 181 +++++++++++ .../global_objects/array/entries/index.html | 77 +++++ .../global_objects/array/every/index.html | 89 ++++++ .../reference/global_objects/array/fill/index.html | 185 +++++++++++ .../global_objects/array/filter/index.html | 150 +++++++++ .../reference/global_objects/array/find/index.html | 278 +++++++++++++++++ .../global_objects/array/findindex/index.html | 214 +++++++++++++ .../reference/global_objects/array/flat/index.html | 173 +++++++++++ .../global_objects/array/foreach/index.html | 104 +++++++ .../reference/global_objects/array/from/index.html | 248 +++++++++++++++ .../global_objects/array/includes/index.html | 110 +++++++ .../reference/global_objects/array/index.html | 279 +++++++++++++++++ .../global_objects/array/indexof/index.html | 95 ++++++ .../global_objects/array/isarray/index.html | 139 +++++++++ .../reference/global_objects/array/join/index.html | 50 +++ .../reference/global_objects/array/keys/index.html | 120 +++++++ .../global_objects/array/lastindexof/index.html | 114 +++++++ .../global_objects/array/length/index.html | 53 ++++ .../reference/global_objects/array/map/index.html | 93 ++++++ .../reference/global_objects/array/of/index.html | 92 ++++++ .../reference/global_objects/array/pop/index.html | 138 +++++++++ .../reference/global_objects/array/push/index.html | 51 +++ .../global_objects/array/reduce/index.html | 300 ++++++++++++++++++ .../global_objects/array/reduceright/index.html | 344 +++++++++++++++++++++ .../global_objects/array/reverse/index.html | 55 ++++ .../global_objects/array/shift/index.html | 48 +++ .../global_objects/array/slice/index.html | 99 ++++++ .../reference/global_objects/array/some/index.html | 110 +++++++ .../reference/global_objects/array/sort/index.html | 122 ++++++++ .../global_objects/array/splice/index.html | 86 ++++++ .../global_objects/array/tolocalestring/index.html | 128 ++++++++ .../global_objects/array/tosource/index.html | 62 ++++ .../global_objects/array/tostring/index.html | 42 +++ .../global_objects/array/unshift/index.html | 56 ++++ .../global_objects/array/values/index.html | 84 +++++ 36 files changed, 4640 insertions(+) create mode 100644 files/pl/web/javascript/reference/global_objects/array/concat/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/copywithin/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/entries/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/every/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/fill/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/filter/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/find/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/findindex/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/flat/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/foreach/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/from/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/includes/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/indexof/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/isarray/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/join/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/keys/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/lastindexof/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/length/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/map/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/of/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/pop/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/push/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/reduce/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/reduceright/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/reverse/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/shift/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/slice/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/some/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/sort/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/splice/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/tolocalestring/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/tosource/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/tostring/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/unshift/index.html create mode 100644 files/pl/web/javascript/reference/global_objects/array/values/index.html (limited to 'files/pl/web/javascript/reference/global_objects/array') 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 +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Podsumowanie

+ +

Zwraca nową tablicę złożoną z tablicy, na której wywołano tę metodę, połączonej z innymi podanymi tablicami lub wartościami.

+ +

Składnia

+ +
var new_array = old_array.concat(wartość1[, wartość2[, ...[, wartośćN]]])
+ +

Parametry

+ +
+
wartość + N +  
+
Tablice lub wartości do dołączenia do tablicy, na której wywołana została metoda concat.
+
+ +

Opis

+ +

concat 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:

+ + + + + +

Operacje wykonywane na nowej tablicy nie wpłyną w żaden sposób na oryginalną tablicę i na odwrót.

+ +

Przykłady

+ +

Przykład: Połączenie dwóch tablic

+ +

Następujący kod łączy dwie tablice:

+ +
alpha = new Array("a", "b", "c");
+numeric = new Array(1, 2, 3);
+alphaNumeric = alpha.concat(numeric); // tworzy tablicę ["a", "b", "c", 1, 2, 3]
+
+ +

Przykład: Połączenie trzech tablic

+ +

Następujący kod łączy trzy tablice:

+ +
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]
+
+ +

Przykład: Połączenie wartości z tablicą

+ +

Następujący kod łączy trzy wartości z tablicą:

+ +
alpha = ['a', 'b', 'c'];
+alphaNumeric = alpha.concat(1, 2, 3); // tworzy tablicę ["a", "b", "c", 1, 2, 3]
+
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 +--- +
{{JSRef}}
+ +

Metoda copyWithin() tworzy kopie płytkie części tablicy w innej części tej samej tablicy i zwraca tę tablicę bez modyfikowania jej długości.

+ +
{{EmbedInteractiveExample("pages/js/array-copywithin.html")}}
+ + + +

Składnia

+ +
arr.copyWithin(cel[, start[, koniec]])
+
+ +

Parametry

+ +
+
cel
+
Indeks (liczony od zera), do którego ma zostać skopiowana sekwencja. Jeśli wartość target będzie ujemna, pozycja będzie liczona od końca tablicy.
+
Jeśli cel jest większy lub równy arr.length, nic nie zostanie skopiowane. Jeśli wartość cel będzie większa niż start, kopiowana sekwencja zostanie przycięta tak, aby pasować do arr.length.
+
start {{optional_inline}}
+
Indeks (liczony od zera), określający pozycję początkową sekwencji, która ma zostać skopiowana. Jeśli wartość ta będzie ujemna, start będzie liczony od końca tablicy.
+
Jeśli wartość start nie jest podana, copyWithin skopiuje sekwencję zaczynając od indeksu 0. 
+
koniec {{optional_inline}}
+
Indeks (liczony od zera), określający pozycję końcową sekwencji, która ma zostać skopiowana, z wyłączeniem wartości pod indeksem koniec. Jeśli wartość ta będzie ujemna, koniec będzie liczony od końca tablicy.
+
Jeśli wartość koniec nie jest podana, copyWithin skopiuje sekwencję do ostatniego indeksu (domyślnie do arr.length).
+
+ +

Zwracana wartość

+ +

Zmodyfikowana tablica.

+ +

Opis

+ +

Metoda copyWithin działa jak memmove 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.

+ +

Funkcja copyWithin jest celowo ogólna, nie wymaga, by jej wartość this była obiektem typu {{jsxref("Array")}}.

+ +

Metoda copyWithin jest modyfikowalna. Nie zmienia długości this, ale zmienia zawartość this i tworzy nowe własności, jeśli jest to konieczne.

+ +

Polyfill

+ +
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
+  });
+}
+ +

Przykłady

+ +

Użycie copyWithin

+ +
[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]
+
+ +

Specyfikacje

+ + + + + + + + + + +
Specyfikacja
{{SpecName('ESDraft', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}}
+ +

Wsparcie przeglądarek

+ +
+ + +

{{Compat("javascript.builtins.Array.copyWithin")}}

+
+ +

Zobacz też

+ + 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 +--- +
{{JSRef}}
+ +

Metoda entries() zwraca obiekt Iteratora który zawiera parę klucz/wartość dla każdej pozycji w tablicy.

+ +
{{EmbedInteractiveExample("pages/js/array-entries.html")}}
+ + + +

Składnia

+ +
a.entries()
+ +

Zwracana wartość

+ +

Nowy iterator {{jsxref("Tablicy")}}.

+ +

Przykłady

+ +

Użycie w pętli for…of

+ +
var a = ['a', 'b', 'c'];
+var iterator = a.entries();
+
+for (let e of iterator) {
+  console.log(e);
+}
+// [0, 'a']
+// [1, 'b']
+// [2, 'c']
+
+ +

Specyfikacja

+ + + + + + + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarz
{{SpecName('ES2015', '#sec-array.prototype.entries', 'Array.prototype.entries')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}{{Spec2('ESDraft')}} 
+ +

Kompatybilność w przeglądarkach

+ +
+ + +

{{Compat("javascript.builtins.Array.entries")}}

+
+ +

Zobacz również

+ + 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 +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Podsumowanie

+ +

Metoda  every() sprawdza, czy wszystkie elementy w tablicy przechodzą test zrealizowany w postaci dostarczonej funkcji.

+ +

Składnia

+ +
arr.every(callback[, thisArg])
+ +

Parametry

+ +
+
callback
+
Funkcja sprawdzająca dla każdego elementu. Zawiera trzy argumenty.
+ currentValue
+   Bieżący element przetwarzany w tablicy
+
       index
+
+

     Indeks bieżacego elementu przetwarzanego w tablicy

+ +

 array
+     Tablica na której została wywołana funkcja

+
+
thisObject
+
Opcjonalnie. Obiekt, na który będzie wskazywał this, gdy wykonana zostanie funkcja zwrotna callback. 
+
+ +

Opis

+ +

Metoda every wykonuje dostarczoną funkcję callback raz dla każdego elementu tablicy do momentu, kiedy znajdzie taki element, dla którego funkcja callback zwróci wartość false. Jeżeli taki element zostanie znaleziony, test zostanie przerwany, a metoda every zwróci wartość false. W przeciwnym wypadku (callback zwraca wartość true dla wszystkich elementów) every zwróci true. Funkcja callback 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ść.

+ +

Funkcja callback jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.

+ +

Jeśli parametr thisObject został dostarczony do metody every, będzie on wskazywany przez this dla każdego wywołania funkcji callback. W przypadku, gdy nie został on przekazany lub jego wartość jest równa null, this będzie się odnosić do obiektu globalnego połączonego z funkcją callback.

+ +

Metoda every nie modyfikuje tablicy, na której jest wywoływana.

+ +

Zakres elementów przetwarzanych przez every jest ustawiany przed pierwszym wywołaniem funkcji callback. Elementy dołączone do tablicy po momencie wywołania every są testowane przez callback. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji callback odpowiada wartości w momencie, w którym every się o nie zwróci; metoda every nie upomina się o elementy usunięte.

+ +

Kompatybilność

+ +

every 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 every w implementacji ECMA-262, które nie wspierają tego natywnie.

+ +
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;
+  };
+}
+
+ +

Przykłady

+ +

Przykład: Sprawdzanie rozmiaru wszystkich elementów tablicy

+ +

Następujący przykład sprawdza, czy wszystkie elementy w tablicy są większe niż 10.

+ +
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
+
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 +--- +
{{JSRef}}
+ +

Metoda fill() uzupełnia wszystkie elementy tablicy, zaczynając od indeksu początkowego  (start) aż po indeks końcowy (end) statyczną wartością (value).

+ +

{{EmbedInteractiveExample("pages/js/array-fill.html")}}
+ Ź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 https://github.com/mdn/interactive-examples  i wyślij pull request.

+ +

Składnia

+ +
arr.fill(value[, start = 0[, end = this.length]])
+ +

Parametry

+ +
+
value
+
Wartość, którą wypełniana będzie tablica.
+
start
+
Opcjonalnie. Indeks początkowy.
+
end
+
Opcjonalnie. Indeks końcowy.
+
+

Wartość zwracana

+ +

Zmodyfikowana tablica.

+
+
+ +

Opis

+ +

Przedział elementów do wypełnienia to: [start, end).

+ +

Metoda fill przyjmuje do trzech parametrów value, start i end. Argumenty start i end są opcjonalne i przyjmują, odpowiednio,  0 i długość (length) obiektu this.

+ +

Jeżeli parametr start jest ujemny, jest to traktowane jako length+start gdzie length jest liczbą elementów tablicy. Jeżeli parametr end jest negatywny, jest to traktowane jako length+end. 

+ +

Funkcja fill została świdomie zaprojektowana jako generyczna, przez co nie wymaga, by wartość this była obiektem typu Array.

+ +

Metoda fill jest zmienna (ang. mutalbe), metoda ta nie zwraca kopii this, a oryginalny obiekt po modyfikacjach.

+ +

Przykłady

+ +
[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" }]
+
+ +

 

+ +

 

+ +

Polyfill

+ +
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;
+  };
+}
+
+ +

Specyfikacja

+ + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarz
{{SpecName('ES6', '#sec-array.prototype.fill', 'Array.prototype.fill')}}{{Spec2('ES6')}}Definicja początkowa
+ +

Kompatybilność z przeglądarkami

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FunckjonalnośćChromeFirefox (Gecko)Internet ExplorerOperaSafari
Wsparcie podstawowe{{CompatChrome("36")}} [1]{{CompatGeckoDesktop("31")}}{{CompatNo}}{{CompatNo}}{{CompatSafari("7.1")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Wsparcie podstawowe{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("31")}}{{CompatNo}}{{CompatNo}}8.0
+
+ +

[1] The feature is available behind a preference. In chrome://flags, activate the entry “Enable Experimental JavaScript”.

+ +

Zobacz również

+ + 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 +--- +
{{JSRef}}
+ +

Metoda filter() tworzy nową tablicę z wszystkimi elementami, które przechodzą test określony w postaci funkcji.

+ +
function isBigEnough(value) {
+  return value >= 10;
+}
+
+var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+// filtered is [12, 130, 44]
+
+ +

Składnia

+ +
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
+ +

Parametry

+ +
+
callback
+
Funkcja sprawdzająca każdy element tablicy. Funkcja powinna zwrócić true, aby zatrzymać element lub false, aby odrzucić element. Funkcja przyjmuje trzy argumenty:
+
+
+
element
+
Element tablicy do przetworzenia.
+
index
+
Numer indeksu procesowanego elementu tablicy.
+
array
+
Tablica na której filter został wywołany.
+
+
+
thisArg
+
Obiekt na który będzie wskazywał this, przy wywoływaniu funkcji callback.
+
+ +

Opis

+ +

Metoda filter wykonuje dostarczoną funkcję callback dla każdego elementu tablicy, tworząc nową tablicę z wszystkich tych elementów, dla których funkcja callback zwróciła wartość true. Wynikowa tablica jest zwarta; wartości, które nie przechodzą testu funkcji callback, są zwyczajnie pomijane i nie są przypisywane do indeksów nowej tablicy.

+ +

Funkcja callback jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.

+ +

Jeśli parametr thisObject został dostarczony do metody filter, będzie on wskazywany przez this dla każdego wywołania funkcjicallback. W przypadku gdy nie został on przekazany lub jego wartość jest równa null, this będzie się odnosić do obiektu globalnego połączonego z funkcją callback.

+ +

Metoda filter nie modyfikuje tablicy, na której jest wywoływana.

+ +

Zakres elementów przetwarzanych przez filter jest ustawiany przed pierwszym wywołaniem funkcji callback. Elementy dołączone do tablicy po momencie wywołania filter są testowane przez callback. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji callback odpowiada wartości w momencie, w którym filter się o nie zwróci; metoda filter nie upomina się o elementy usunięte.

+ +

Kompatybilność

+ +

filter 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 filter w implementacji ECMA-262, które nie wspierają tego natywnie.

+ +
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;
+  };
+}
+
+ +

Przykłady

+ +

Przykład: Odfiltrowanie wszystkich małych wartości

+ +

Poniższy przykład używa filter by utworzyć przefiltrowaną tablicę, z której usunięto wszystkie elementy których wartość wynosi mniej niż 10.

+ +
function isBigEnough(element, index, array) {
+  return (element >= 10);
+}
+filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+
+ +

Kompatybilność z przeglądarkami

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.8")}}{{CompatIE("9")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("1.8")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
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 +--- +

{{JSRef}}
+ Metoda find() zwraca pierwszy element tablicy, który spełnia warunek podanej funkcji testującej.

+ +
{{EmbedInteractiveExample("pages/js/array-find.html","shorter")}}
+ + + + + +

Składnia

+ +
arr.find(callback[, thisArg])
+ +

Parametry

+ +
+
callback
+
Funkcja do wykonania przy każdym elemencie tablicy, przyjmująca trzy wartości: +
+
element
+
Element obecnie przetwarzany przez funkcję.
+
index
+
Indeks obecnie przetwarzanego elementu.
+
array
+
Tablica, na której wywołano funkcję find.
+
+
+
thisArg
+
Opcjonalny. Obiekt, który będzie się znajdował pod this w czasie wykonywania funkcji callback.
+
+ +

Zwracana wartość

+ +

Wartość pierwszego elementu w tablicy, spełniającego warunek funkcji testującej.
+ W przeciwnym wypadku: {{jsxref("undefined")}}.

+ +

Opis

+ +

Metoda find wywołuje funkcję callback raz dla każdego indeksu tablicy, dopóki nie znajdzie takiego elementu, dla którego callback zwraca wartość true. Wówczas find natychmiast zwraca wartość tego elementu. W przeciwnym razie, gdy żaden z elementów nie spełni warunków funkcji testującej, find zwraca {{jsxref("undefined")}}.

+ +

callback 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.

+ +

Jeśli parametr thisArgjest przekazany do find, będzie użyty jako wartość this w każdym wywołaniu callback. Jeśli parametr ten nie jest przekazany, używana jest wartość {{jsxref("undefined")}}.

+ +

Metoda find nie modyfikuje tablicy, na której jest wywoływana, ale może to robić funkcja przekazana do callback. Jeśli tak się stanie, elementy przetwarzane przez find są ustawiane przed pierwszym wywołaniem funkcji callback. Zatem:

+ + + +

Polyfill

+ +

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ć polyfill z  Array.prototype.find z poniższym fragmentem kodu:

+ +
// 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
+  });
+}
+
+ +

Jeśli potrzebujesz wspierać naprawdę przestarzałe silniki JavaScript, które nie wspierająt Object.defineProperty, najlepiej w ogóle nie używać polyfill z Array.prototype, gdyż nie da się go uczynić niewyliczeniowym.

+ +

Przykłady

+ +

Wyszukiwanie obiektu w tablicy na podstawie jednej z jego własności

+ +
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 }
+ +

Użycie funkcji strzałkowej i destrukturyzacja

+ +
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 }
+ +

Wyszukiwanie liczby pierwszej w tablicy

+ +

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):

+ +
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
+
+ +

Poniższy przykład pokazuje, że nieistniejące i usunięte elementy są odwiedzane, oraz że wartość przekazana do callback jest ich wartością, kiedy są odwiedzane:

+ +
// 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
+
+ +

Specyfikacje

+ + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarz
{{SpecName('ES2015', '#sec-array.prototype.find', 'Array.prototype.find')}}{{Spec2('ES2015')}}Pierwotna definicja.
+ +

Wsparcie przeglądarek

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome("45.0")}}{{CompatGeckoDesktop("25.0")}}{{CompatNo}}{{CompatNo}}{{CompatSafari("7.1")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("25.0")}}{{CompatNo}}{{CompatNo}}iOS 8
+
+ +

Zobacz też

+ + 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 +--- +
{{JSRef}}
+ +

Metoda findIndex() zwraca indeks pierwszego elementu tablicy, który spełnia kryteria postawione w funkcji testującej. W przeciwnym wypadku zwraca -1.

+ +
function isBigEnough(element) {
+  return element >= 15;
+}
+
+[12, 5, 8, 130, 44].findIndex(isBigEnough);
+// zostanie zwrócony indeks czwartego elementu tablicy,
+// który wynosi 3
+ +

Zobacz także metodę {{jsxref("Array.find", "find()")}}, która zwraca wartość znalezionego elementu, zamiast jego indeksu.

+ +

Składnia

+ +
arr.findIndex(callback[, thisArg])
+ +

Parametry

+ +
+
callback
+
Funkcja wywoływana dla każdej wartości w tablicy, bierze trzy argumenty:
+
+
+
element
+
Obecnie przetwarzany element z tablicy.
+
index
+
Indeks obecnie przetwarzanego elementu z tablicy.
+
array
+
Tablica, na której została wywołana funkcja findIndex.
+
+
+
thisArg
+
Opcjonalny.  Obiekt do użycia jako this w czasie wykonywania callback.
+
+ +

Zwracana wartość

+ +

Indeks elementu tablicy, który pomyślnie przeszedł test, jeśli taki nie zostanie znaleziony, zwraca -1.

+ +

Opis

+ +

Metoda findIndex wykonuje funkcję callback dla każdego indeksu tablicy 0..długość - 1 (włącznie) w tablicy dopóki nie znajdzie tego, na którym funkcja callback zwróci prawdę. Jeśli taki element zostanie znaleziony, findIndex natychmiast zwraca indeks dla tej iteracji. Jeśli callback nigdy nie zwróci prawdy lub wielkość tablicy wynosi 0, findIndex zwróci -1. W przeciwieństwie do innych metod tablicowych takich jak Array#some, w tablicach rzadkich callback jest wywoływany nawet dla indeksów niewystępujących w tablicy.

+ +

callback jest wywoływany z trzema argumentami: wartością elementu, indeksem elementu i przetwarzaną tablicą.

+ +

Jeśli thisArg jest dołączony do findIndex, zostanie użyty jako this dla każdego wywołania . Jeśli nie, zostanie użyte {{jsxref("undefined")}}.

+ +

findIndex nie zmienia tablicy na której jest wywoływany.

+ +

Zakres elementów przetwarzanych przez findIndex jest ustawiany przed pierwszym wywołaniem funkcji callback. Elementy, które są dodane po rozpoczęciu wywołania funkcji findIndex nie będą przetworzone przez callback. Jeśli istniejący, nieodwiedzony element tablicy zostanie zmieniony przez callback, jego wartość przekazana do odwiedzającego callback będzie tą wartością z momentu, w którym findIndex odwiedzi indeks tego elementu, elementy usunięte, nie będą odwiedzone.

+ +

Przykłady

+ +

Znajdź indeks liczby pierwszej w tablicy

+ +

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).

+ +
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
+
+ +

Polyfill

+ +
// 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;
+    }
+  });
+}
+
+ +

Jeśli musisz wspierać naprawdę przestarzałe silniki JavaScript, które nie wspierają Object.defineProperty, najlepiej nie korzystać z metod Array.prototype  w ogóle, ponieważ nie można sprawić by były niepoliczalne.

+ +

Specyfikacje

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusKomentarz
{{SpecName('ES2015', '#sec-array.prototype.findindex', 'Array.prototype.findIndex')}}{{Spec2('ES2015')}}Podstawowa definicja.
{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}{{Spec2('ESDraft')}} 
+ +

Kompatybilność przeglądarek

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeEdgeFirefox (Gecko)Internet ExplorerEdgeOperaSafari
Basic support{{CompatChrome(45.0)}}{{CompatVersionUnknown}}{{CompatGeckoDesktop("25.0")}}{{CompatNo}}TakTak{{CompatSafari("7.1")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidEdgeFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}45.0{{CompatVersionUnknown}}{{CompatGeckoMobile("25.0")}}{{CompatNo}}{{CompatNo}}8.0
+
+ +

Zobacz także

+ + 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 +--- +
{{JSRef}}
+ +
+ +

Metoda flat() 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.

+ + + + + +

Składnia

+ +
var newArray = arr.flat([depth]);
+ +

Parametry

+ +
+
depth {{optional_inline}}
+
Parametr ten określa jak głęboko zagnieżdżona tablica powinna być spłaszczona. Wartość domyślna to 1.
+
+ +

Zwracana wartość

+ +

Nowa tablica składająca się z połączonych elementów podtablic.

+ +

Przykłady

+ +

Spłaszczanie zagnieżdżonych tablic

+ +
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]
+
+ +

Spłaszczanie i puste miejsca tablicy

+ +

Metoda flat() usuwa puste miejsca w tablicy:

+ +
var arr4 = [1, 2, , 4, 5];
+arr4.flat();
+// [1, 2, 4, 5]
+
+ +

Alternatywa

+ +

reduce i concat

+ +
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);
+
+ + + +
//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]
+
+ + + +
//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]
+
+ + + +
//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;
+}
+
+ + + +

Polyfill

+ +
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;
+  };
+}
+
+ +

Specifications

+ + + + + + + + + + + + + + +
SpecificationStatusComment
Array.prototype.flat proposalFinished (4)
+ +

Browser compatibility

+ +
+ + +

{{Compat("javascript.builtins.Array.flat")}}

+
+ +

See also

+ + 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 +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Podsumowanie

+ +

Wykonuje dostarczoną funkcję jeden raz na każdy element tablicy.

+ +

Składnia

+ +
arr.forEach(callback[, thisArg])
+ +

Parametry

+ +
+
callback
+
Funkcja wykonywana dla każdego elementu.
+
thisArg
+
Obiekt na który będzie wskazywał this, gdy wykonana zostanie funkcja zwrotna callback.
+
+ +

Opis

+ +

Metoda forEach wykonuje dostarczoną funkcje callback raz dla każdego elementu tablicy. Funkcja callback 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ść.

+ +

Funkcja callback jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.

+ +

Jeśli parametr thisArg został dostarczony do metody forEach, będzie on wskazywany przez this dla każdego wywołania funkcji callback. W przypadku, gdy nie został on przekazany lub jego wartość jest równa null, this będzie się odnosić do obiektu globalnego połączonego z funkcją callback.

+ +

Metoda forEach nie modyfikuje tablicy na której jest wywołana.

+ +

Zakres elementów przetwarzanych przez forEach jest ustawiany przed pierwszym wywołaniem funkcji callback. Elementy dołączone do końca tablicy po momencie wywołania forEach nie są przesyłane do funkcji callback. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji callback odpowiada wartości w momencie, w którym forEach 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.

+ +

Kompatybilność

+ +

forEach 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 forEach w implementacji ECMA-262, które nie wspierają tego natywnie.

+ +
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);
+    }
+  };
+}
+
+ +

Przykłady

+ +

Przykład: Drukowanie zawartości tablicy

+ +

Następujący kod drukuje linie dla każdego elementu w tablicy (i przyjmuje obecność funkcji print do wywołania!):

+ +
function printElt(element, index, array) {
+    print("[" + index + "] jest " + element);
+}
+[2, 5, 9].forEach(printElt);
+// Wydrukuje:
+// [0] jest 2
+// [1] jest 5
+// [2] jest 9
+
+ +

Przykład: Drukowanie zawartości tablicy z metodą obiektu

+ +

Następujący kod tworzy prosty obiekt wypisujący i następnie stosuje metodę writeln do wypisania jednej linii na element w tablicy (przyjmuje obecność funkcji print do wywołania!):

+ +
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
+
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 +--- +
{{JSRef}}
+ +

Array.from()  metoda tworzy nową instację tablicy z obiektu podobnego do tablicy lub obiektu iterowalnego.

+ +

W ES2015, składania klas dopuszcza dziedziczenie obu rodzajów klas: wbudowanych oraz zdefiniowanych przez programistę; w rezultacie, statyczne metody jak Array.from są "dziedziczone" przez klasę pochodną i tworzą nową instancję klasy pochodnej, a nie klasy Array.

+ +

Składnia

+ +
Array.from(arrayLike[, mapFn[, thisArg]])
+
+ +

Argumenty

+ +
+
arrayLike
+
Obiekt podobny do tablicy lub iterowalny.
+
mapFn
+
Opcjonalny. Funkcja mapująca wywoływany z każdym elementem tablicy.
+
thisArg
+
Opcjonalny. Wartość używana jako this podczas wykonywania mapFn.
+
+ +

Opis

+ +

Array.from() pozwala tworzyć tablicę z:

+ + + +

Array.from() has an optional parameter mapFn, 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, Array.from(obj, mapFn, thisArg) is the same as Array.from(obj).map(mapFn, thisArg), except that it does not create an intermediate array. This is especially important for certain array subclasses, like typed arrays, since the intermediate array would necessarily have values truncated to fit into the appropriate type.

+ +

The length property of the from() method is 1.

+ +

Przykłady

+ +
// 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]
+
+
+ +

Polyfill

+ +

Array.from 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 Array.from in implementations that don't natively support it.  This algorithm is exactly the one specified in ECMA-262, 6th edition, assuming Object and TypeError have their original values and that callback.call 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.

+ +
// 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;
+    };
+  }());
+}
+
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES2015', '#sec-array.from', 'Array.from')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-array.from', 'Array.from')}}{{Spec2('ESDraft')}} 
+ +

Browser compatibility

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)EdgeInternet ExplorerOperaSafari
Basic support{{CompatChrome("45")}}{{CompatGeckoDesktop("32")}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}9.0
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("32")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

See also

+ + 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 +--- +
{{JSRef}}
+ +

Metoda includes() ustala czy dana tablica posiada szukany element, zwracając true lub false.

+ +

Składnia

+ +
var boolean = array.includes(searchElement[, fromIndex])
+ +

Zwraca

+ +

{{jsxref("Boolean")}}.

+ +

Parametry

+ +
+
searchElement
+
Szukany element.
+
fromIndex
+
Opcjonalne. Jest to pozycja w tablicy, od której rozpoczyna się szukanie elementu searchElement. Ujemna wartość przeszukuje tablicę od końca tablicy. Domyślna wartość wynosi 0.
+
+ +

Przykłady

+ +
[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
+
+ +

Polyfill

+ +
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;
+  };
+}
+
+ +

Specyfikacja

+ + + + + + + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarz
{{SpecName('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}{{Spec2('ES7')}}Definicja początkowa.
{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}{{Spec2('ESDraft')}} +

 

+
+ +

Kompatybilność przeglądarek

+ +
+
+ + +

{{Compat("javascript.builtins.Array.includes")}}

+
+
+ +

Zobacz również

+ + 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 +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Array  w języku JavaScript jest globalnym obiektem, który jest używany podczas tworzenia tablic – listo-podobnych obieków wysokiego poziomu.

+ +
+

Stwórz tablicę

+ +
var owoce = ['Jabłko', 'Banan'];
+
+console.log(owoce.length);
+// 2
+
+ +

Dostawanie się do elementu tablicy

+ +
var pierwszy = owoce[0];
+// Jablko
+
+var ostatni = owoce[owoce.length - 1];
+// Banan
+ +

Pętla przechodząca przez zawartość tablicy

+ +
owoce.forEach(function(item, index, array) {
+  console.log(item, index);
+});
+// Jablko 0
+// Banan 1
+ +

Dodawanie elementu na końcu tablicy

+ +
var nowaDługosc = owoce.push('Pomarańcz');
+// ["Jabłko", "Banan", "Pomarańcz"]
+ +

Usuwanie elemetu z końca tablicy

+ +
var ostatni = owoce.pop(); // usuwa pomarańczę z końca
+// ["Jabłko", "Banan"];
+ +

Usuwanie elementu z przodu tablicy

+ +
var pierwszy = owoce.shift(); // usuwa jabłko z początku
+// ["Banan"];
+ +

Dodawanie elementu z przodu tablicy

+ +
var nowaDługość = owoce.unshift('Truskawki') // dodaje na początku
+// ["Truskawkę", "Banan"];
+ +

Znajdowanie indeksu (numeru porządkowego) elementu t tablicy

+ +
owoce.push('Mango');
+// ["Truskawka", "Banan", "Mango"]
+
+var pos = owoce.indexOf('Banan');
+// 1
+ +

Usuwanie obiektu przy użyciu indeksu

+ +
var usunElement = owoce.splice(pos, 1); // tak się usuwa element
+
+// ["Truskawka", "Mango"]
+ +

Usuwanie elementów przy użyciu pozycji w indeksie

+ +
var warzywa = ["Kapusta", "Rzepa", "Rzodkiew", "Marchew"];
+console.log(warzywa);
+// ["Kapusta", "Rzepa", "Rzodkiew", "Marchew"]
+
+var pos = 1, n = 2;
+
+var usunieteElementy = warzywa.splice(pos, n);
+// n oznacza liczbę elementów do usunięcia
+// zaczynając od elementu na określonej pozycji(pos)
+
+console.log(warzywa);
+// ["Kapusta", "Marchew"] (początkowa tablica została zmieniona)
+
+console.log(usunieteElementy);
+// ["Rzepa", "Rzodkiew"]
+
+ +

Kopiowanie tablicy

+ +
var płytkaKopia = owoce.slice(); // tak się tworzy kopię
+// ["Truskawka", "Mango"]
+
+ +

Składnia:

+ +
[element0, element1, ..., elementN]
+new Array(element0, element1[, ...[, elementN]])
+new Array(długoscTablicy)
+ +
+
elementN
+
Lista wartości elementów tablicy. Tablica jest inicjowana z określonymi wartościami jako jej elementami. Długość tablicy (length) odpowiada liczbie jej elementów.
+
długośćTablicy
+
Początkowa długość tablicy. Aby móc przetwarzać wartości używamy własności długości tablicy length. 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.
+
+ +

Opis

+ +

Tablica jest uporządkowanym zbiorem wartości przyporządkowanych ustalonej pojedynczej zmiennej.

+ +

Poniższy przykład tworzy obiekt Array przy użyciu literału tablicy. Tablica kawa zawiera trzy elementy i ma długość (length) równą 3:

+ +
kawa = ["mocca", "cappucino", "zbożowa"]
+
+ +

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:

+ +
myArray = new Array("Hello", myVar, 3.14159)
+
+ +

Dostęp do elementów tablicy

+ +

Do elementów tablicy odwołujemy się po ich liczbie porządkowej (zaczynając od zera). Przykładowo, jeśli mamy zdefiniowaną tablicę:

+ +
mojaTablica = new Array("Wiatr","Deszcz","Ogień")
+
+ +

Do pierwszego elementu odwołujemy się poprzez mojaTablica[0], a do drugiego poprzez mojaTablica[1].

+ +

Podawanie pojedynczego parametru

+ +

Jeśli konstruktor Array 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:

+ +
rodzajPlatnosci = new Array(5)
+
+ +

Zachowanie konstruktora Array zależy od tego, czy jedyny parametr jest liczbą.

+ + + +

Poniższy kod tworzy tablicę o długości 25, a następnie przypisuje wartości pierwszym trzem elementom:

+ +
rodzajeMuzyki = new Array(25)
+rodzajeMuzyki[0] = "R&B"
+rodzajeMuzyki[1] = "Blues"
+rodzajeMuzyki[2] = "Jazz"
+
+ +

Pośrednie zwiększanie długości tablicy

+ +

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.

+ +
kolory = new Array();
+kolory[99] = "ciemnoniebieski";
+
+ +

Tworzenie tablicy z wyników wyrażenia regularnego

+ +

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 RegExp.exec, String.match i String.replace. Aby zrozumieć te własności spójrz na poniższy przykład odwołując się do poniższej tabeli:

+ +
//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");
+
+ +

Własności i elementy zwracają wartości z poniższej tabeli:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Własność/ElementOpisPrzykład
inputWartość tylko-do-odczytu, opisująca oryginalny łańcuch znaków, do którego porównano wyrażenie regularne.cdbBdbsbz
indexWłasność tylko-do-odczytu, będąca indeksem (zaczynając od 0) porównanego znaku w łańcuchu znaków.1
[0]Element tylko-do-odczytu, zawierający ostatnio porównane znaki.dbBd
[1], ... [n]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.[1]: bB
+ [2]: d
+ +

Własności

+ +
+
+
+
{{jsxref("Array.length")}}
+
Odzwierciedla ilość elementów tablicy.
+
{{jsxref("Array.prototype")}}
+
Pozwala na dodawanie własności do wszystkich obiektów.
+
+
+
+ +

Metody

+ +
+
{{jsxref("Array.from()")}} {{experimental_inline}}
+
Tworzy nową instancję Array z obiektu podobnego do tablicy lub iterowalnego.
+
{{jsxref("Array.isArray()")}}
+
Zwraca true, jeśli zmienna jest tablicą, jeśli nie false.
+
{{jsxref("Array.observe()")}} {{experimental_inline}}
+
Asynchronicznie obserwuje zmiany w tablicach, podobnie jak {{jsxref ("Object.observe ()")}} dla obiektów. Zapewnia strumień zmian w kolejności występowania.
+
{{jsxref("Array.of()")}} {{experimental_inline}}
+
Tworzy nową instancję Array ze zmienną liczbą argumentów, niezależnie od liczby lub rodzaju argumentów.
+
+ +

Przykłady

+ +

Przykład: Tworzenie tablicy

+ +

Poniższy kod tworzy tablicę msgArray o długości 0, a następnie przypisuje wartości do msgArray[0] i msgArray[99], zwiększając długość tablicy do 100.

+ +
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."
+
+ +

Przykład: Tworzenie tablicy dwuwymiarowej

+ +

Poniższy kod tworzy tablicę dwuwymiarową i przypisuje wyniki do zmiennej myVar.

+ +
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 +"; "
+}
+
+ +

Poniższy łańcuch znaków będzie przypisany do zmiennej myVar (linie zostały przełamane dla zwiększenia czytelności):

+ +
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];
+
+ +
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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

Zwraca pierwszy (najmniejszy) indeks elementu w tablicy równego podanej wartości lub -1, gdy nie znaleziono takiego elementu.

+ +

Składnia

+ +
array.indexOf(searchElement[, fromIndex = 0]);
+
+ +

Parametry

+ +
+
searchElement
+
Element do znalezienia w tablicy.
+
fromIndex
+
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.
+
+ +

Opis

+ +

indexOf porównuje searchElement z elementami tablicy używając ścisłego porównania (podobnie jak w przypadku operatora ===).

+ +

Kompatybilność

+ +

indexOf 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 indexOf w implementacji ECMA-262, które nie wspierają tego natywnie.

+ +
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;
+  };
+}
+
+ +

Należy zwrócić uwagę, że ta implementacja ma na celu całkowitą zgodność z indexOf występującą w Firefoksie i silniku JavaScript SpiderMonkey, włączając w to przypadki w których przesyłany do indexOf 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 from).

+ +

Przykłady

+ +

Przykład: Zastosowanie indexOf

+ +

Następujący przykład stosuje indexOf do znalezienia pierwszego wystąpienia elementów.

+ +
array = [2, 5, 9];
+index = array.indexOf(2);
+// index jest 0
+index = array.indexOf(7);
+// index jest -1
+
+ +

Przykład: Wyszukiwanie wszystkich wystąpień w tablicy

+ +

Poniższy przykład używa indexOf do znalezienia wszystkich wystąpień elementu w tablicy oraz dodaje ich indeksy do drugiej tablicy używając metody {{jsxref("Array.prototype.push()")}}.

+ +
indices = [];
+idx = array.indexOf(element)
+while (idx != -1) {
+   indices.push(idx);
+   idx = array.indexOf(element, idx + 1);
+}
+
+ +

Zobacz także

+ + 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 +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Podsumowanie

+ +

Array.isArray() to metoda, która zwraca true  jeśli obiekt jest tablicą, fałsz jeśli nie jest.

+ +

Składnia

+ +
Array.isArray(obj)
+ +

Parametry

+ +
+
obj
+
Obiekt do sprawdzenia
+
+ +

Opis

+ +

Zobacz artykuł  “Determining with absolute accuracy whether or not a JavaScript object is an array” , aby poznać więcej szczegółów.

+ +

Przykłady

+ +
// 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 });
+
+ +

Dostępność wsteczna

+ +

Jeśli metody Array.isArray() nie jest natywnie dostępna, poniższy kod ją utworzy.

+ +
if (!Array.isArray) {
+  Array.isArray = function(arg) {
+    return Object.prototype.toString.call(arg) === '[object Array]';
+  };
+}
+
+ +

Specyfikacja

+ + + + + + + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarz
{{SpecName('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}{{Spec2('ES5.1')}}Wstępna definicja. Implementacja od  JavaScript 1.8.5.
{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}{{Spec2('ES6')}} 
+ +

Zgodność z przeglądarkami

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome("5")}}{{CompatGeckoDesktop("2.0")}}{{CompatIE("9")}}{{CompatOpera("10.5")}}{{CompatSafari("5")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("2.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Based on Kangax's compat table.

+ +

Zobacz także

+ + 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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

Łączy wszystkie elementy tablicy w jeden łańcuch znaków.

+ +

Składnia

+ +
str = arr.join([separator = ','])
+ +

Parametry

+ +
+
separator 
+
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.
+
+ +

Opis

+ +

Metoda join zmienia w łańcuchy znaków wszystkie elementy tablicy i łączy je w jeden łańcuch znaków.

+ +

Przykłady

+ +

Przykład: Łączenie tablicy na trzy różne sposoby

+ +

Poniższy przykład tworzy trzyelementową tablicę a zawierającą trzy elementy, następnie trzykrotnie łączy ją: używając domyślnego separatora, przecinka i spacji oraz znaku plus.

+ +
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
+
+ +

Zobacz także

+ + 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 +--- +
{{JSRef}}
+ +

Metoda keys() zwraca nowy obiekt typu Array Iterator zawierający indeksy kolejnych elementów tablicy.

+ +
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 }
+
+ +

Składnia

+ +
arr.keys()
+ +

Zwracana wartość

+ +

Nowy iterator dla typu {{jsxref("Array")}}.

+ +

Przykłady

+ +

Iterator nie ignoruje dziur

+ +
var arr = ['a', , 'c'];
+var sparseKeys = Object.keys(arr);
+var denseKeys = [...arr.keys()];
+console.log(sparseKeys); // ['0', '2']
+console.log(denseKeys);  // [0, 1, 2]
+
+ +

Specyfikacje

+ + + + + + + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarz
{{SpecName('ES2015', '#sec-array.prototype.keys', 'Array.prototype.keys')}}{{Spec2('ES2015')}}Pierwsze wystąpienie.
{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}{{Spec2('ESDraft')}} 
+ +

Kompatybilność z przeglądarkami

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)EdgeInternet ExplorerOperaSafari
Basic support{{CompatChrome("38")}}{{CompatGeckoDesktop("28")}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatOpera("25")}}{{CompatSafari("7.1")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("28")}}{{CompatNo}}{{CompatNo}}8.0
+
+ +

Zobacz również

+ + 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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

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 fromIndex

+ +

Składnia

+ +
arr.lastIndexOf(searchElement[, fromIndex = arr.length])
+ +

Parametry

+ +
+
searchElement
+
Element do znalezienia w tablicy.
+
fromIndex
+
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.
+
+ +

Opis

+ +

lastIndexOf porównuje searchElement z elementami tablicy używając ścisłego porównania (podobnie jak w przypadku operatora ===).

+ +

Kompatybilność

+ +

lastIndexOf 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 lastIndexOf w implementacji ECMA-262, które nie wspierają tego natywnie.

+ +
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;
+  };
+}
+
+ +

Należy zwrócić uwagę, że ta implementacja ma na celu całkowitą zgodność z lastIndexOf 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ć from za pomocą mniej skomplikowanego kodu (z pominięciem części instrukcji warunkowych).

+ +

Przykłady

+ +

Przykład: Zastosowanie lastIndexOf

+ +

Poniższy przykład używa lastIndexOf do znalezienia określonych wartości w tablicy.

+ +
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
+
+ +

Przykład: Wyszukiwanie wszystkich wystąpień danego elementu

+ +

Poniższy przykład używa lastIndexOf do znalezienia wszystkich wystąpień elementu w tablicy oraz dodaje ich indeksy do drugiej tablicy używając metody push.

+ +
indices = [];
+idx = array.lastIndexOf(element)
+while (idx != -1) {
+   indices.push(idx);
+   idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1);
+}
+
+ +

Warto zauważyć, że obsłużyliśmy warunek idx == 0 oddzielnie, ponieważ element ten zostanie zawsze odnaleziony - bez względu na wartość parametru fromIndex - w przypadku gdy jest on pierwszym elementem tablicy. To różni tę metodę od metody {{jsxref("Array.prototype.indexOf()")}}.

+ +

Zobacz także

+ + 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 +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Podsumowanie

+ +

32-bitowa liczba całkowita bez znaku określająca liczbę elementów w tablicy.

+ +
{{js_property_attributes(1, 0, 0)}}
+ +
+

Składnia

+ +
arr.length
+
+ +

Opis

+ +

Wartością własności length jest dodatnia liczba całkowita mniejsza niż 2 do potęgi 32 (232).

+ +

W dowolnej chwili możesz ustalić wartość length w celu zmniejszenia rozmiaru tablicy. Ustawienie wartości length na większą niż rozmiar tablicy nie zwiększy liczby elementów, np. jeżeli ustawisz length na 3, podczas gdy obecną wartością jest liczba 2, tablica nadal będzie zawierać tylko 2 elementy.

+ +

Przykłady

+ +

Przykład: Iteracja przez wszystkie elementy tablicy

+ +

W poniższym przykładzie ilość elementów w tablicy numbers jest określana w instrukcji iteracyjnej na podstawie wartości length, następnie wartość każdego elementu jest podwajana.

+ +
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];
+
+ +

Przykład: Skracanie tablicy

+ +

Poniższy przykład zmniejsza rozmiar tablicy statesUS do 50, jeżeli przekracza on tę wartość.

+ +
if (statesUS.length > 50) {
+   statesUS.length=50
+}
+
+ +
 
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 +--- +
{{JSRef}}
+ +

Metoda map() tworzy nową tablicę zawierającą wyniki wywoływania podanej funkcji dla każdego elementu wywołującej tablicy.

+ +
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]
+
+ +

Składnia

+ +
var new_array = arr.map(function callback(currentValue, index, array){ // Zwróć element nowej tablicy }[, thisArg])
+ +

Parametry

+ +
+
callback
+
Funkcja tworząca element nowej tablicy, przyjmująca trzy argumenty:
+
+
+
currentValue
+
Element tablicy nad którym obecnie pracujemy
+
index
+
Indeks elementu tablicy nad którym obecnie pracujemy
+
array
+
Oryginalna tablica na rzecz której wywołano metodę map
+
+
+
thisArg
+
Opcjonalny. Wartość jaką użyć jako this podczas wywołania callback
+
+ +

Zwracana wartość

+ +

Nowa tablica zawierająca elementy będące wynikami wywoływani funkcji callback.

+ +

Opis

+ +

map wykonuje funkcję (callback) raz na każdym z elementów tablicy w kolejności i tworzy nową tablicę na podstawie wyników. callback wywoływany jest tylko dla indeksów tablicy które mają przypisane wartości, włącznie z undefined. 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).

+ +

callback wywoływana jest z trzema argumentami: wartością elementu, jego indeksem i tablicą która jest trawersowana.

+ +

W przypadku podania argumentu thisObject, zostanie on przekazany jako this przy każdym wywołaniu callback. Gdy go brak, lub ma wartość null, użyty zostanie obiekt globalny przyporządkowany do callback.

+ +

map nie modyfikuje tablicy, na której jest wywołany.

+ +

Zakres elementów przetwarzanych przez map ustalany jest przed pierwszym wywołaniem callback. Elementy dodane do tablicy po wywołaniu map nie zostaną odwiedzone przez callback. Jeśli istniejący, element tablicy zostanie zmieniony lub usunięty, wartością przekazaną do callback będzie wartość z momentu w którym map odwiedza dany element; elementy usunięte przed sprawdzeniem będą przekazane jako undefined.

+ +

Przykłady

+ +

Wielkie litery łańcuchów w tablicy

+ +

Poniższy kod tworzy nową tablicę zawierającą pisaną wielkimi literami wersję wszystkich oryginalnych łańcuchów.

+ +
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
+
+ +

Mapowanie tablicy liczb do tablicy pierwiastków kwadratowych

+ +

Poniższy kod pobiera tablicę liczb i tworzy nową tablicę z pierwiastkami kwadratowymi liczb z pierwszej tablicy.

+ +
var liczby = [1, 4, 9];
+var pierwiastki = liczby.map(Math.sqrt);
+// otrzymane pierwiastki [1, 2, 3]
+// pozostające nadal liczby [1, 4, 9]
+
+ +

 

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 +--- +
{{JSRef}}
+ +

Metoda Array.of() tworzy nową instancję obiektu Array, która zawiera w sobie wszystkie argumenty przekazane do funkcji, niezależnie od ich liczby i typu.

+ +

Różnica pomiędzy Array.of() i konstruktorem Array polega na różnej interpretacji argumentów - Array.of(7) tworzy nową tablicę z jednym elementem(7), gdzie Array(7) tworzy nową tablicę z właściwością length ustawioną na 7 (Notatka: Oznacza to tablicę z 7 wolnymi miejscami, nie miejscami z wartościami undefined).

+ +
Array.of(7);       // [7]
+Array.of(1, 2, 3); // [1, 2, 3]
+
+Array(7);          // [ , , , , , , ]
+Array(1, 2, 3);    // [1, 2, 3]
+
+ +

Składnia

+ +
Array.of(element0[, element1[, ...[, elementN]]])
+ +

Parametry

+ +
+
elementN
+
Elementy, które tworzą tablicę.
+
+ +

Wartość zwracana

+ +

Nowa instancja obiektu {{jsxref("Array")}}.

+ +

Opis

+ +

Ta funkcja jest częścią standardu ECMAScript 2015. Po więcej informacji zobacz Array.of and Array.from proposal i Array.of polyfill.

+ +

Przykłady

+ +
Array.of(1);         // [1]
+Array.of(1, 2, 3);   // [1, 2, 3]
+Array.of(undefined); // [undefined]
+
+ +

Polyfill

+ +

Uruchomienie tego kodu przed innym stworzy Array.of() nawet jeśli nie jest ona dostępna natywnie.

+ +
if (!Array.of) {
+  Array.of = function() {
+    return Array.prototype.slice.call(arguments);
+  };
+}
+
+ +

Specyfikacje

+ + + + + + + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarz
{{SpecName('ES2015', '#sec-array.of', 'Array.of')}}{{Spec2('ES2015')}}Początkowa definicja.
{{SpecName('ESDraft', '#sec-array.of', 'Array.of')}}{{Spec2('ESDraft')}} 
+ +

Browser compatibility

+ +
+ + +

{{Compat("javascript.builtins.Array.of")}}

+
+ +

Zobacz także

+ + 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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

Usuwa ostatni element z tablicy zwracając go. Metoda ta zmienia długość tablicy.

+ +

Składnia

+ +
arr.pop()
+ +

Zwracana wartość

+ +

Ostatni element tablicy;
+ Jeśli tablica jest pusta zwraca {{jsxref("undefined")}}

+ +

Opis

+ +

Metoda pop usuwa ostatni element tablicy i zwraca tę wartość.

+ +

pop 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 length odzwierciedlającej ostani element w serii, przy właściwościach liczonych od zera nie mogą zachowywać się w żaden znaczący sposób.

+ +

Jeśli zawołasz  pop() na pustej tablicy, zwróci ona {{jsxref("undefined")}}.

+ +

Przykład

+ +

Przykład: Usuwanie ostatniego elementu tablicy

+ +

Następujący kod tworzy tablicę myFish zawierającą cztery elementy, a następnie usuwa ostatni jej element.

+ +
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'
+ +

Specyfikacja

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition. Implemented in JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}}{{Spec2('ESDraft')}} 
+ +

Kompatybilność z przeglądarkami

+ +

{{CompatibilityTable}}

+ + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome("1.0")}}{{CompatGeckoDesktop("1.7")}}{{CompatIE("5.5")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+ + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+ +

Zobacz także

+ + diff --git a/files/pl/web/javascript/reference/global_objects/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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

Dodaje jeden lub więcej elementów na koniec tablicy i zwraca jej nową długość. Metoda ta zmienia długość tablicy.

+ +

Składnia

+ +
arr.push(element1, ..., elementN)
+ +

Parametry

+ +
+
element + N +  
+
Elementy dodawane na końcu tablicy.
+
+ +

Opis

+ +

Zachowanie metody push jest analogiczne do funkcji push w języku Perl 4. Uwaga: jej zachowanie różni się w języku Perl 5.

+ +

Przykłady

+ +

Przykład: Dodawanie elementów do tablicy

+ +

Następujący kod tworzy tablicę myFish zawierającą dwa elementy, następnie dodaje do niej dwa kolejne. Po wykonaniu kodu, pushed zawiera wartość 4 (w JavaScript 1.2 po wykonaniu kodu zmienna pushed zawiera wartość "lew").

+ +
myFish = ["anioł", "klaun"];
+pushed = myFish.push("bęben", "lew");
+
+ +

Zobacz także

+ + 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 +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Podsumowanie

+ +

Metoda reduce() 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.

+ +

Składnia

+ +
arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
+ +

Parametry

+ +
+
callback
+
Funkcja wykonywana na każdej wartości w tablicy, przyjmuje cztery argumenty: +
+
previousValue
+
+
Wartość zwróconą w ostatnim wywołaniu funkcji callback, lub initialValue, jeśli ta została dostarczona. (Patrz niżej.)
+
currentValue
+
Obecnie przetwarzany element w tablicy.
+
index
+
Indeks w tablicy obecnie przetwarzanego elementu.
+
array
+
Tablica, na której została wykonana funkcja reduce .
+
+
+
initialValue
+
Opcjonalne. Obiekt który będzie użyty jako pierwszy argument pierwszego wywołania funkcji callback.
+
+ +

Opis

+ +

reduce wykonuje funkcję callback raz dla każdego elementu występującego w tablicy, wyłączając dziury. Funkcja callback przyjmuje cztery argumenty: wartość początkową (lub wartość poprzedniego wywołania callback), wartość obecnego elementu, jego indeks, oraz tablicę na której zachodzi proces iteracji.

+ +

Przy pierwszym wywołaniu funkcji callback, previousValue oraz currentValue mogą przyjąć jedną z dwóch wartości. Jeżeli initialValue było dostarczone w wywołaniu, wtedy previousValue przyjmie wartość podaną jako initialValue, natomiast currentValue przyjmie wartość pierwszego elementu tablicy. Jeśli initialValue nie było podane, wtedy previousValue będzie miało wartość pierwszego elementu tablicy, natomiast currentValue będzie równe elementowi drugiemu.

+ +

Jeżeli tablica jest pusta oraz initialValue 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 initialValue nie zostało podane, lub dostarczono initialValue, ale tablica jest pusta, wtedy ta jedyna wartość zostanie zwrócona, bez wywoływania funkcji callback.

+ +

Przyjmijmy, że wystąpiło następujące wywolanie funkcji reduce:

+ +
[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+});
+
+ +

Funkcja callback będzie wywołana cztery razy, z argumentami i wartościami zwrotnymi przy każdym wołaniu jak następuje:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
previousValuecurrentValueindexarraywartość zwracana
pierwsze wywołanie011[0, 1, 2, 3, 4]1
drugie wywołanie122[0, 1, 2, 3, 4]3
trzecie wywołanie333[0, 1, 2, 3, 4]6
czwarte wywołanie644[0, 1, 2, 3, 4]10
+ +

Wartość zwrócona ostatecznie przez reduce będzie tą z ostatniego wywołania funcji callback (10).

+ +

Natomiast, jeśli dostarczylibyśmy wartość początkową jako drugi argument funkcji przekazanej do reduce, wynik wyglądałby jak poniżej:

+ +
[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+}, 10);
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
previousValuecurrentValueindexarraywartość zwracana
pierwsze wywołanie1000[0, 1, 2, 3, 4]10
drugie wywołanie1011[0, 1, 2, 3, 4]11
trzecie wywołanie1122[0, 1, 2, 3, 4]13
czwarte wywołanie1333[0, 1, 2, 3, 4]16
piąte wywołanie1644[0, 1, 2, 3, 4]20
+ +

Tym razem wartość zwrócona przez reduce będzie wynosiła 20.

+ +

Przykłady

+ +

Przykład: Zsumowanie wszystkich wartości w tablicy.

+ +
var total = [0, 1, 2, 3].reduce(function(a, b) {
+  return a + b;
+});
+// total == 6
+
+ +

Przykład: Spłaszczenie tablicy tablic

+ +
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
+  return a.concat(b);
+});
+// flattened is [0, 1, 2, 3, 4, 5]
+
+ +

Polyfill

+ +

Array.prototype.reduce 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 reduce z implementacjami, które nie wspierają tej funkcji.

+ +
// 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;
+  };
+}
+
+ +

Specyfikacja

+ + + + + + + + + + + + + + + + + + + +
SpecyfikacjaStanKomentarz
{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}{{Spec2('ES5.1')}}Definicja początkowa. Wprowadzon w JavaScript 1.8.
{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}{{Spec2('ES6')}}
+ +

Wspierane przeglądarki

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.9")}}{{CompatIE("9")}}{{CompatOpera("10.5")}}{{CompatSafari("4.0")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Zobacz też

+ + 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 +--- +
{{JSRef}}
+ +

Metoda reduceRight() 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.

+ +
{{EmbedInteractiveExample("pages/js/array-reduce-right.html","shorter")}}
+ + + +

Sprawdź również {{jsxref("Array.prototype.reduce()")}} dla redukowania tablicy od lewej do prawej (od najniższego indexu do najwyższego).

+ +

Składnia

+ +
arr.reduceRight(callback(akumulator, obecnaWartość[, index[, tablica]])[, wartośćPoczątkowa])
+ +

Parametry

+ +
+
callback
+
Funkcja która będzie wołana dla każdego elementu w tablicy, przyjmuje 4 argumenty: +
+
akumulator
+
Wartość zwrócona z poprzedniego wywołania funkcji callback lub wartośćPoczątkowa, jeśli została zdefiniowana. (Sprawdź poniżej.)
+
obecnaWartość
+
Element z tablicy, który aktualnie jest przetwarzany
+
index{{optional_inline}}
+
Index aktualnie przetwarzanego elementu z tablicy.
+
tablica{{optional_inline}}
+
Tablica, na której reduceRight() zostało zawołane.
+
+
+
wartośćPoczątkowa{{optional_inline}}
+
Wartość, która zostanie użyta do pierwszego wykonania funkcji callback. 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 TypeError.
+
+ +

Wartość zwracana

+ +

Wartość wynikowa redukcji.

+ +

Opis

+ +

reduceRight wykonuje funkcję callback 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 callback), wartość obecnie przetwarzanego elementu, obecny index oraz tablicę na której wykonywane są iteracje.

+ +

Użycie funkcji callback w metodzie reduceRight może wyglądac następująco:

+ +
array.reduceRight(function(akumulator, obecnaWartość, index, tablica) {
+  // ...
+});
+
+ +

Przy pierwszym wywołaniu funkcji, akumulator i obecnaWartość mogą mieć jedną z 2 wartości. Jeśli wartośćPoczątkowa została przekazana do reduceRight, to akumulator będzie równy wartośćPoczątkowa a obecnaWartość będzie równa ostatniej wartości z tablicy. Jeśli wartośćPoczątkowa nie została zdefiniowana, wtedy akumulator będzie równy ostatniej wartości z tablicy a obecnaWartość będzie równa przedostatniej wartości z tablicy.

+ +

Jeśli tablica jest pusta i wartośćPoczątkowa nie została zdefiniowana, spowoduje to błąd: {{jsxref("TypeError")}}. Jeśli tablica ma tylko jeden element (niezależnie od jego pozycji) i wartośćPoczątkowa nie została zdefiniowana lub wartośćPoczątkowa została zdefiniowana ale tablica jest pusta, to ta pojedyncza wartość zostanie zwrócona bez wołania funkcji callback.

+ +

Przykład pokazujący, jak przepływają dane do funkcji callback:

+ +
[0, 1, 2, 3, 4].reduceRight(function(akumulator, obecnaWartość, index, tablica) {
+  return akumulator + obecnaWartość;
+});
+
+ +

Funkcja callback wykona się 4 razy a argumenty wywołań oraz wartości zwracane będą zgodne z poniższą tabelą:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
callbackakumulatorobecnaWartośćindextablicazwrócona wartość
first call433[0, 1, 2, 3, 4]7
second call722[0, 1, 2, 3, 4]9
third call911[0, 1, 2, 3, 4]10
fourth call1000[0, 1, 2, 3, 4]10
+ +

Wartość zwrócona przez reduceRight będzie tym, co zostało zwrócone przez ostatnie wywołanie funkcji callback (10).

+ +

Jeśli wartośćPoczątkowa zostałaby zdefiniowana wyniki wyglądałyby następująco:

+ +
[0, 1, 2, 3, 4].reduceRight(function(akumulator, obecnaWartość, index, tablica) {
+  return akumulator + obecnaWartość;
+}, 10);
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
callbackakumulatorobecnaWartośćindextablicazwrócona wartość
first call1044[0, 1, 2, 3, 4]14
second call1433[0, 1, 2, 3, 4]17
third call1722[0, 1, 2, 3, 4]19
fourth call1911[0, 1, 2, 3, 4]20
fifth call2000[0, 1, 2, 3, 4]20
+ +

Wartość zwrócona przez reduceRight w tym przypadku, będzie, oczywiście, 20.

+ +

Przykłady

+ +

Zsumuj wszystkie wartości z tablicy

+ +
var sum = [0, 1, 2, 3].reduceRight(function(a, b) {
+  return a + b;
+});
+// sum is 6
+
+ +

Spłaszcz tablicę tablic

+ +
var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
+    return a.concat(b);
+}, []);
+// flattened is [4, 5, 2, 3, 0, 1]
+
+
+ +

Uruchom asynchroniczne funkcje z callbackami z listy w taki sposób aby każda przekazywała wynik wykonania do następnej

+ +
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);
+}
+ +

​​​​​​Różnica pomiędzy reduce i reduceRight

+ +
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"
+ +

Przykład na rozwijanie funkcji

+ +

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ą.

+ +
/**
+ * 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
+
+ +

Polyfill

+ +

reduceRight 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 reduceRight w środowiskach, które tego nie implementują.

+ +
// 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;
+  };
+}
+
+ +

Specyfikacje

+ + + + + + + + + + +
Specyfikacja
{{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}
+ +

Zgodność w przeglądarkach

+ +
+ + +

{{Compat("javascript.builtins.Array.reduceRight")}}

+
+ +

Sprawdź również

+ + 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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

Odwraca kolejność elementów w tablicy: pierwszy staje się ostatnim, ostatni pierwszym.

+ +

Składnia

+ +
arr.reverse()
+ +

Parametry

+ +

Brak.

+ +

Opis

+ +

Metoda reverse zmienia zawartość tablicy, odwracając kolejność jej elementów.

+ +

Przykłady

+ +

Przykład: Odwracanie kolejności elementów w tablicy

+ +

Poniższy przykład tworzy tablicę mojaTablica, posiadającą trzy elementy, następnie odwraca ich kolejność.

+ +
mojaTablica = new Array("jeden", "dwa", "trzy")
+mojaTablica.reverse()
+
+ +

W wyniku działania powyższego kodu:

+ + + +

Zobacz także

+ + + +
 
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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

Usuwa pierwszy element z tablicy i zwraca go. Metoda ta zmienia długość tablicy.

+ +

Składnia

+ +
arr.shift()
+ +

Przykłady

+ +

Przykład: Usuwanie pierwszego elementu tablicy

+ +

Następujący kod wyświetli tablicę myFish, przed i po usunięciu jej pierwszego elementu. Wyświetli również usunięty element:

+ +
// 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);
+
+ +

Przykład wyświetli następujący rezultat:

+ +
myFish przed: ["anioł", "klaun", "mandarynka", "chirurg"]
+myFish po: ["klaun", "mandarynka", "chirurg"]
+//Usunięto element: anioł
+
+ +

Zobacz także

+ + 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 +--- +

{{ JSRef }}

+ +

{{EmbedInteractiveExample("pages/js/array-slice.html")}}

+ +

Podsumowanie

+ +

Wydobywa fragment tablicy i zwraca go jako nową tablicę.

+ +

Składnia

+ +
arr.slice([begin[, end]])
+ +

Parametry

+ +
+
begin
+
Indeks (liczony od zera) od którego zaczyna się wydobywanie.
+
Jeżeli indeks jest ujemny, begin wskazuje przesunięcie w kolejności od końca. slice(-2) wydobywa kolejno drugi od końca i ostatni element tablicy.
+
+ +
+
end
+
Indeks (liczony od zera) przed którym kończy się wydobywanie. slice wydobywa elementy jednakże nie zawiera end.
+
+ +
+
slice(1,4) wydobywa elementy od drugiego do czwartego (o indeksach 1, 2 i 3).
+
+ +
+
Jeżeli parametr ten ma wartość ujemną to end określa odległość od końca tablicy. slice(2,-1) wydobywa kolejne elementy od trzeciego do przedostatniego.
+
+ +
+
Jeżeli end jest pominięty, slice wydobywa wszystkie elementy do końca tablicy.
+
+ +

Opis

+ +

slice 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:

+ + + + + +

Jeżeli nowy element jest dodany do jednej z tablic, to nie wpływa to w żaden sposób na drugą.

+ +

Przykłady

+ +

Przykład: Zastosowanie slice

+ +

W następującym przykładzie slice tworzy nową tablicę newCar z myCar. Obydwie zawierają odniesienie do obiektu myHonda. Kiedy kolor myHonda jest zmieniany na purpurowy, to obie tablice odzwierciedlają zmianę.

+ +
//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);
+
+ +

Ten skrypt wypisze:

+ +
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
+
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 +--- +

{{ JSRef }}

+ +

Podsumowanie

+ +

Sprawdza, czy jakikolwiek element tablicy zalicza test zaimplementowany przez dostarczoną funkcję .

+ +

Składnia

+ +
arr.some(callback[, thisArg])
+ +

Parametry

+ +
+
callback 
+
Funkcja sprawdzająca dla każdego elementu.
+
thisArg
+
Obiekt do użycia jako this gdy wykonujemy funkcję callback.
+
+ +

Opis

+ +

some wykonuje funkcję callback) na każdym elemencie tablicy, aż znajdzie taki, dla którego callback zwróci prawdę (true). Jeżeli taki element zostanie znaleziony, some zakończy swoje działanie i zwróci prawdę (true), w przeciwnym przypadku (gdy callback zwróci fałsz dla każdego z elementów) some zwróci false. Tablice nie są traktowane jako "zwarte" - czyli callback 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ść.

+ +

callback wywoływana jest z trzema argumentami: wartością elementu, jego indeksem i przemierzaną tablicą.

+ +

W przypadku podania argumentu thisObject, zostanie on przekazany jako this przy każdym wywołaniu callback. Gdy go brak, lub ma wartość null, użyty zostanie obiekt globalny przyporządkowany do callback.

+ +

some nie modyfikuje tablicy, na której jest wywołany.

+ +

Zakres elementów przetwarzanych przez some ustalany jest przed pierwszym wywołaniem callback. Elementy dodane do tablicy po wywołaniu some nie zostaną sprawdzone przez callback. Jeśli istniejący, niesprawdzony jeszcze element tablicy zostanie zmieniony lub usunięty przez callback, wartością przekazaną do callback będzie wartość z momentu, w którym some sprawdza dany element; elementy usunięte przed sprawdzeniem będą przekazane jako undefined.

+ +

Przykłady

+ +

Sprawdzanie rozmiaru wszystkich elementów tablicy

+ +

Następujący przykład sprawdza czy jakiś element tablicy jest większy, bądź równy 10.

+ +
function czyWiekszyNiz10(element, index, array) {
+  return element > 10;
+}
+[2, 5, 8, 1, 4].some(czyWiekszyNiz10); // false
+[12, 5, 8, 1, 44].some(czyWiekszyNiz10); // true
+
+ +

Sprawdzanie elementów używając funkcji strzałkowych

+ +

Funkcje strzałkowe dają krótszą składnię dla tego samego testu.

+ +
[2, 5, 8, 1, 4].some(x => x > 10); // false
+[12, 5, 8, 1, 44].some(x => x > 10); // true
+
+ +

Kompatybilność z przeglądarkami

+ +

{{CompatibilityTable}}

+ + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.8")}}{{CompatIE("9")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+ + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("1.8")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

Sortuje elementy tablicy.

+ +

Składnia

+ +
arr.sort([compareFunction])
+ +

Parametry

+ +
+
compareFunction 
+
jest nazwą funkcji porównującej elementy. Jeżeli parametr zostanie pominięty, tablica będzie posortowana w porządku leksykograficznym (alfabetycznie).
+
+ +

Opis

+ +

Jeżeli compareFunction 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.

+ +

Jeżeli compareFunction zostanie podana, elementy tablicy zostaną posortowane odpowiednio do wartości zwracanej przez funkcję porównującą. Jeżeli a oraz b są dwoma porównywanymi elementami tablicy to:

+ + + + + + + +

Ogólna postać funkcji porównującej wygląda następująco:

+ +
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
+}
+
+ +

W celu porównania liczb, zamiast napisów, funkcja porównująca może odejmować b od a:

+ +
function compareNumbers(a, b) {
+   return a - b
+}
+
+ +

Niektóre implementacje JavaScript wykonują sortowanie stabilne: kolejność elementów a i b nie jest zmieniana jeśli a i b są sobie równe. Jeżeli przed sortowaniem a jest w tablicy wcześniej niż b oraz a i b są sobie równe, to po sortowaniu ich kolejność będzie taka sama (niezależnie od tego, jak zmienią się pozycje elementów a i b).

+ +

Przykłady

+ +

Przykład: Tworzenie, wyświetlanie i sortowanie tablic

+ +

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ą.

+ +
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))
+
+ +

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.

+ +
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
+
+ +

Zobacz także

+ + 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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

Zmienia zawartość tablicy, dodając nowe elementy podczas usuwania starych elementów.

+ +

Składnia

+ +
array.splice(start, deleteCount[, item1[, item2[, ...]]])
+
+ +

Parametry

+ +
+
start
+
Indeks od którego rozpoczynamy modyfikację tablicy.
+
+ +
+
deleteCount
+
Liczba całkowita określająca liczbę starych elementów tablicy do usunięcia. Jeżeli deleteCount wynosi 0, nic nie zostanie usunięte. W tym przypadku należy podać co najmniej jeden nowy element. W przypadku gdy parametr deleteCount nie został podany (druga forma składni podana powyżej, która jest rozszerzeniem SpiderMonkey), wszystkie elementy o indeksach wyższych lub równych index są usuwane.
+
+ +
+
itemN
+
Elementy dodawane do tablicy. Jeżeli nie określimy żadnych elementów, splice usunie tylko podaną liczbę elementów.
+
+ +

Opis

+ +

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 splice.

+ +

Metoda splice zwraca tablicę zawierającą usunięte elementy. Jeżeli usunięty został tylko jeden element, zwracana jest tablica jednoelementowa.

+ +

Przykłady

+ +

Przykład: Zastosowanie splice

+ +

Następujący skrypt ilustruje użycie splice:

+ +
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);
+
+ +

Ten skrypt wyświetli:

+ +
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"]
+
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 +--- +
{{JSRef}}
+ +
Metoda toLocaleString() 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ń toLocaleString. Elementy łaczone są separatorem zdefiniowanym dla lokalnego języka (np. przecinek).
+ +
+ +

Składnia

+ +
arr.toLocaleString();
+ +

Opis

+ +

Poniższe elementy tablic są konwertowane na łańcuchy znaków za pomocą wbudowanych metod toLocaleString

+ + + +

Przykład

+ +

Użycie toLocaleString

+ +
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"
+ + + +

Specyfikacja

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarze
{{SpecName('ES3')}}{{Spec2('ES3')}}Inicjalna definicja
{{SpecName('ES5.1', '#sec-15.2.4.3', 'Array.prototype.toLocaleString')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}{{Spec2('ES6')}}
+ +

Zgodność z przeglądarkami

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

Zobacz także

+ + diff --git a/files/pl/web/javascript/reference/global_objects/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 +--- +
{{JSRef}} {{non-standard_header}}
+ +

Podsumowanie

+ +

Zwraca łańcuch znaków reprezentujący kod źródłowy tablicy.

+ +

Składnia

+ +
arr.toSource()
+ +

Parametry

+ +

Brak.

+ +

Opis

+ +

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

+ +

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.

+ + + +

Metoda ta jest zazwyczaj wywoływana wewnętrznie przez JavaScript, a nie bezpośrednio w kodzie. Możliwe jest wywołanie toSource podczas debugowania, aby zbadać zawartość tablicy.

+ +

Przykłady

+ +

Przykład: Sprawdzanie kodu źródłowego tablicy

+ +

Do sprawdzania kodu źródłowego tablicy:

+ +
var alpha = new Array("a", "b", "c");
+
+alpha.toSource() //zwraca ["a", "b", "c"]
+
+ +

Zobacz także

+ + 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 +--- +
{{JSRef}}
+ +

Metoda toString() zwraca łańcuch znaków reprezentujący daną tablicę wraz z jej elementami.

+ +
var months = ['Styczeń', 'Luty', 'Marzec', 'Kwiecień'];
+months.toString(); // "Styczeń,Luty,Marzec,Kwiecień"
+
+ +

Składnia

+ +
arr.toString()
+ +

Parametry

+ +

Brak.

+ +

Opis

+ +

Obiekt {{jsxref("Array")}} przesłania metodę toString obiektu {{jsxref("Object")}}. Dla obiektów Array, metoda toString łą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ę toString, aby przekształcić tablicę do łańcucha znaków.

+ +
var monthNames = new Array("Jan","Feb","Mar","Apr")
+var myVar = monthNames.toString() // przypisuje "Jan,Feb,Mar,Apr" do zmiennej myVar
+
+ +

JavaScript wywołuje metodę toString automatycznie, gdy tablica jest traktowana jako wartość tekstowa lub kiedy istnieje odniesienie do tej tablicy wewnątrz połączonego łańcucha znaków.

+ +

Zobacz także

+ + 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 +--- +
{{JSRef}}
+ +

Podsumowanie

+ +

Dodaje jeden lub więcej elementów na początek tablicy i zwraca jej nową długość.

+ +

Składnia

+ +
arr.unshift([element1[, ...[, elementN]]])
+ +

Parametry

+ +
+
element + N +  
+
Elementy do dodania na początek tablicy.
+
+ +

Przykłady

+ +

Przykład: Dodawanie elementów do tablicy

+ +

Następujący kod wyświetli tablicę myFish przed i po dodaniu do niej elementów.

+ +
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);
+
+ +

Powyższy przykład wyświetli:

+ +
myFish przed: ["anioł", "klaun"]
+myFish po: ["bęben", "lew", "anioł", "klaun"]
+Nowa długość tablicy: 4
+
+ +

Zobacz także

+ + 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 +--- +
{{JSRef}}
+ +

Metoda values() zwraca nowy obiekt Array Iterator , który zawiera wartości dla każdego indeksu w tablicy.

+ +
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
+ +

Składnia

+ +
arr.values()
+ +

Zwracana wartość

+ +

Nowy obiekt {{jsxref("Array")}} iterator.

+ +

Przykłady

+ +

Iteracja używająca pętli for...of

+ +
var arr = ['w', 'y', 'k', 'o', 'p'];
+var iterator = arr.values();
+
+for (let letter of iterator) {
+  console.log(letter);
+}
+
+ +

Specyfikacja

+ + + + + + + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarz
{{SpecName('ES2015', '#sec-array.prototype.values', 'Array.prototype.values')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-array.prototype.values', 'Array.prototype.values')}}{{Spec2('ESDraft')}} 
+ +

Kompatybilność przeglądarek

+ +
+ + +

{{Compat("javascript.builtins.Array.values")}}

+
+ +

Zobacz też

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