From 2a289d584f99b0ff5740910f9d205f5f3df4a35e Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 6 Jul 2021 10:30:13 -0400 Subject: delete conflicting/orphaned docs in pl (#1415) --- .../web/javascript/reference/operators/index.html | 560 --------------------- .../reference/operators/spread_syntax/index.html | 231 --------- 2 files changed, 791 deletions(-) delete mode 100644 files/pl/conflicting/web/javascript/reference/operators/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/operators/spread_syntax/index.html (limited to 'files/pl/conflicting/web/javascript/reference/operators') diff --git a/files/pl/conflicting/web/javascript/reference/operators/index.html b/files/pl/conflicting/web/javascript/reference/operators/index.html deleted file mode 100644 index 06c78ff69e..0000000000 --- a/files/pl/conflicting/web/javascript/reference/operators/index.html +++ /dev/null @@ -1,560 +0,0 @@ ---- -title: Operatory bitowe -slug: conflicting/Web/JavaScript/Reference/Operators -tags: - - JavaScript - - Operator -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators -original_slug: Web/JavaScript/Referencje/Operatory/Bitwise_Operators ---- -
{{jsSidebar("Operators")}}
- -

Operatory bitowe traktuję swoje operandy jako sekwencje 32 bitów (zer i jedynek), bardziej niż jako dziesiętne, szesnastkowe czy ósemkowe wartości liczbowe. Przykładowo, reprezentacją binarną dziesiętnej liczby 9 jest 1001. Operatory bitowe dokonują operacji na takich właśnie reprezentacjach bitowych, zwracają jednak standardowe JavaScriptowe wartości liczbowe.

- -
{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}
- - - -

Poniższa tabela zawiera podsumowanie operatorów bitowych w języku JavaScript:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
OperatorUżycieOpis
Bitowe ANDa & bZwraca 1 na każdej pozycji bitowej, dla której odpowiadające jej bity obydwu operandów mają wartość 1.
Bitowe ORa | bZwraca 1 na każdej pozycji bitowej, dla której jeden lub oba odpowiadające jej bity operandów mają wartość 1.
Bitowe XORa ^ bZwraca 1 na każdej pozycji bitowej, dla której dokładnie jeden bit spośród odpowiadających jej bitów operandów ma wartość jeden.
Bitowe NOT~ aNeguje bity swojego operandu.
Przesunięcie w lewoa << bPrzesuwa a w binarnej reprezentacji o b bitów w lewo (gdzie b < 32), dodając zera z prawej strony.
Przesunięcie w prawo z propagacją znakua >> bPrzesuwa a w binarnej reprezentacji o b bitów w prawo (gdzie b < 32), odrzucając b bitów z prawej strony.
Przesunięcie w prawo z dopełnieniem zeramia >>> b  Przesuwa a w binarnej reprezentacji o b bitów w prawo (gdzie b < 32), odrzucając b bitów z prawej strony i uzupełniając sekwencję zerami z lewej strony.
- -

32-bitowe wartości całkowite ze znakiem

- -

Operandy wszystkich operatorów bitowych są konwertowane do 32-bitowych wartości całkowitych w dwójkowym kodzie uzupełnieniowym, z wyjątkiem przesunięcia w prawo z dopełnieniem zerami, które zwraca 32-bitową wartość całkowitą bez znaku. Dwójkowy kod uzupełnieniowy oznacza, że liczba przeciwna danej wartości (na przykład 5 i -5) ma wszystkie bity zanegowane w stosunku do tejże wartości (bitowe NOT liczby, znane również jako jedynkowe dopełnienie liczby) plus jeden. Przykładowo, dziesiętna liczba 314 ma następującą postać dwójkową:

- -
00000000000000000000000100111010
-
- -

Reprezentacja binarna ~314, czyli jedynkowe dopełnienie 314:

- -
11111111111111111111111011000101
-
- -

-314 ma ostatecznie następującą postać, będącą dwójkowym dopełnieniem 314:

- -
11111111111111111111111011000110
-
- -

Dopełnienie dwójkowe gwarantuje, że skrajny lewy bit będzie zerem dla liczby dodatniej i jedynką dla liczby ujemnej – bit ten zwany jest stąd bitem znaku.

- -

Liczba 0 jest wartością całkowitą, złożoną w całości z bitów o wartości 0.

- -
0 (base 10) = 00000000000000000000000000000000 (base 2)
-
- -

Liczba -1 jest wartością całkowitą, złożoną z samych bitów o wartości 1.

- -
-1 (base 10) = 11111111111111111111111111111111 (base 2)
-
- -

Liczba -2147483648 (reprezentacja szesnastkowa: -0x80000000) jest wartością całkowitą, złożoną z samych bitów o wartości 0, z wyjątkiem pierwszego (znajdującego się najbardziej z lewej strony) bitu.

- -
-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)
-
- -

Liczba 2147483647 (rprezentacja szesnastkowa: 0x7fffffff) jest wartością całkowitą, złożoną jedynie z bitów o wartości 1, z wyjątkiem pierwszego (skrajnie lewego) bitu.

- -
2147483647 (base 10) = 01111111111111111111111111111111 (base 2)
-
- -

Liczby -2147483648 i 2147483647 stanowią odpowiednio minimalną i maksymalną wartość całkowitą, którą można zapisać przy użyciu 32-bitowej liczby ze znakiem.

- -

Bitowe operatory logiczne

- -

Idea działania bitowych operatorów logicznych jest następująca:

- - - -

& (Bitowe AND)

- -

Stosuje operację AND (koniunkcję) na każdej parze bitów. a AND b daje 1 wtedy i tylko wtedy, gdy zarówno a, jak i b będą miały wartość 1. Tablica prawdy dla operacji AND przedstawiona jest poniżej:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
aba AND b
000
010
100
111
- -
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
-
- -

Bitowa koniunkcja (AND) dowolnej wartości x i 0 zawsze daje 0.

- -

| (Bitowe OR)

- -

Stosuje operację OR (alternatywę) na każdej parze bitów. a OR b daje 1 wtedy i tylko wtedy, gdy a lub b ma wartość 1. Tablica prawdy dla operacji OR przedstawina jest poniżej:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
aba OR b
000
011
101
111
- -
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
-
- -

Zastosowanie alternatywy bitowej (OR) dowlonej wartości x i 0 zawsze daje x.

- -

^ (Bitowe XOR)

- -

Stosuje bitowe XOR (alternatywę wykluczającą) na każdej parze bitów. a XOR b daje 1 wtedy i tylko wtedy, gdy a i b mają różne wartości. Tablica prawdy dla operacji XOR przedstawiona jest poniżej:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
aba XOR b
000
011
101
110
- -
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
-
- -

Zastosowanie bitowej alternatywy wykluczającej (XOR) dowolnej wartości x i 0 daje x.

- -

~ (Bitowe NOT)

- -

Stosuje operator NOT (negację) na każdym bicie. NOT a zwraca odwróconą wartość (inaczej zwaną dopełnieniem jedynkowym) a. Tablica prawdy operacji NOT przedstawiona jest poniżej:

- - - - - - - - - - - - - - - - -
aNOT a
01
10
- -
 9 (base 10) = 00000000000000000000000000001001 (base 2)
-               --------------------------------
-~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
-
- -

Bitowa negacja (NOT) dowolnej wartości x daje -(x + 1). Przykładowo, ~-5 daje 4.

- -

Zauważmy, że z powodu używania 32-bitowej reprezentacji liczb, zarówno ~-1, jak i ~4294967295 (232-1) daje wynik 0.

- -

Bitowe operatory przesunięcia

- -

Bitowe operatory przesunięcia przyjmują dwa operandy: pierwszy jest wartością do przesunięcia, a drugi wskazuje liczbę pozycji bitowych, o którą pierszy operand ma być przesunięty. Kierunek operacji przesunięcia jest zdefiniowany przez użycie danego operatora.

- -

Operatory przesunięcia konwertują swoje operandy do 32-bitowych wartości całkowitych w porządku big-endian (znanym też pod nazwą grubokońcowość) i zwraca wynik tego samego typu, co lewy operand. Użytych będzie przy tym jedynie pięć najniższych bitów prawego operandu.

- -

<< (Przesunięcie w lewo)

- -

Operator ten przesuwa pierwszy operand o określoną liczbę bitów w lewo. Nadmiarowe bity przesunięte poza zakres z lewej strony są odrzucane. Z prawej strony sekwencja uzupełniana jest zerami.

- -

Przykładowo, 9 << 2 daje 36:

- -
.    9 (base 10): 00000000000000000000000000001001 (base 2)
-                  --------------------------------
-9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
-
- -

Bitowe przesuwanie dowolnej wartości x w lewo o y bitów daje x * 2 ** y.
- Tak więc, przykładowo: 9 << 3 można przetłumaczyć jako: 9 * (2 ** 3) = 9 * (8) = 72.

- -

>> (Przesunięcie w prawo z propagacją znaku)

- -

Operator ten przesuwa pierwszy operand o określoną liczbę bitów w prawo. Nadmiarowe bity przesunięte z prawej strony poza zakres są odrzucane. Sekwencja jest uzupełniana z lewej strony wartościami skrajnie lewego bitu. Kiedy skrajnie lewy bit ma taką samą wartość, jak poprzedni skrajnie lewy bit, znak się nie zmienia – stąd nazwa „z propagacją znaku”.

- -

Przykładowo, 9 >> 2 daje 2:

- -
.    9 (base 10): 00000000000000000000000000001001 (base 2)
-                  --------------------------------
-9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
-
- -

Podobnie, -9 >> 2 daje -3, ponieważ zachowywany jest znak:

- -
.    -9 (base 10): 11111111111111111111111111110111 (base 2)
-                   --------------------------------
--9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
-
- -

>>> (Przesunięcie w prawo z dopełnieniem zerami)

- -

Operator ten przesuwa pierwszy operand o określoną liczbę bitów w prawo. Nadmiarowe bity przesunięte poza zakres z prawej strony są odrzucane. Sekwencja jest uzupełniana z lewej strony zerami. Bit znaku staje się zerem, dlatego też wynik jest zawsze nieujemny. W przeciwieństwie do pozostałych operatorów bitowych, przesunięcie w prawo z dopełnieniem zerami zwraca 32-bitową wartość całkowitą bez znaku.

- -

Dla liczb nieujemnych, przesunięcie w prawo z zerami i z zachowaniem znaku dają taki sam wynik. Przykładowo, 9 >>> 2 daje 2, tak samo jak 9 >> 2:

- -
.     9 (base 10): 00000000000000000000000000001001 (base 2)
-                   --------------------------------
-9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
-
- -

Inaczej wygląda to jednak w przypadku liczb ujemnych. Przykładowo, -9 >>> 2 daje 1073741821, co jest różne od -9 >> 2 (które daje -3):

- -
.     -9 (base 10): 11111111111111111111111111110111 (base 2)
-                    --------------------------------
--9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
-
- -

Przykłady

- -

Flagi i maski bitowe

- -

Bitowe operatory logiczne są często używane do tworzenia, manipulowania i odczytywania sekwencji flag, które działają jak zmienne binarne. Zmienne mogą być używane zamiast tych sekwencji, ale flagi zajmują znacznie mniej pamięci (32-krotnie).

- -

Załóżmy, że mamy następujące 4 flagi:

- - - -

Flagi te są reprezentowane przez sekwencję bitów: DCBA. Kiedy flaga jest ustawiona, odpowiedni bit ma wartość 1. Kiedy flaga jest wyczyszczona, właściwy bit ma wartość 0. Załóżmy, że zmienna flagi ma binarną wartość 0101:

- -
var flagi = 5;   // binarnie 0101
-
- -

Wartość ta wskazuje, że:

- - - -

Ponieważ operatory bitowe są 32-bitowe, 0101 to faktycznie 00000000000000000000000000000101, ale zera wiodące mogą być pominięte, gdyż nie zawierają żadnej znaczącej informacji.

- -

Maska bitowa jest sekwencją bitów pozwalającą na manipulowanie flagami lub odczytywanie ich wartości. Zazwyczaj „podstawowe” maski bitowe dla każdej flagi będą zdefiniowane w następujący sposób:

- -
var FLAGA_A = 1; // 0001
-var FLAGA_B = 2; // 0010
-var FLAGA_C = 4; // 0100
-var FLAGA_D = 8; // 1000
-
- -

Nowe maski bitowe mogą być stworzone przy użyciu operatorów bitowych na tychże podstawowych maskach. Przykładowo, maska 1011 może być stworzona przy użyciu operatora OR na zmiennych FLAGA_A, FLAGA_B i FLAGA_D.

- -
var maska = FLAGA_A | FLAGA_B | FLAGA_D; // 0001 | 0010 | 1000 => 1011
-
- -

Pojedyncze wartości flag mogą być wyekstrahowane przez użycie operatora AND na fladze i właściwej masce – bit z wartością 1 „ekstrahuje” odpowiednią flagę. Maska bitowa maskuje wszystkie nieistotne flagi przez koniunkcję ich bitów z zerami maski (stąd nazwa „maska”). Przykładowo, maska 0100 może być użyta do sprawdzenia, czy flaga C jest ustawiona:

- -
// czy mamy kota
-if (flagi & FLAGA_C) { // 0101 & 0100 => 0100 => true
-   // coś zrób
-}
-
- -

Maska z ustawionymi wieloma flagami działa jak alternatywa logiczna. Przykładowo, poniższe dwie wersje są równoważne:

- -
// czy mamy nietoperza lub czy mamy kota
-// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
-if ((flagi & FLAGA_B) || (flagi & FLAGA_C)) {
-   // coś zrób
-}
-
- -
// czy mamy nietoperza lub kota
-var maska = FLAGA_B | FLAGA_C; // 0010 | 0100 => 0110
-if (flagi & maska) { // 0101 & 0110 => 0100 => true
-   // coś zrób
-}
-
- -

Flagi mogą być ustawione przez użycie na nich i masce operacji OR, gdzie każdy z bitów z wartością 1 będzie ustawiał odpowiednią flagę, jeśli nie jest już ustawiona. Przykładowo, maska 1100 może być użyta do ustawienia flag C i D:

- -
// tak, możemy mieć kota i kaczkę
-var maska = FLAGA_C | FLAGA_D; // 0100 | 1000 => 1100
-flagi |= maska;   // 0101 | 1100 => 1101
-
- -

Flagi mogą być czyszczone przez użycie operatora AND z maską, gdzie każdy z bitów z wartością 0 będzie czyścił odpowiednią flagę, jeśli nie jest już wyczyszczona. Maska może być stworzona przez użycie operatora NOT na maskach podstawowych. Przykładowo, maska 1010 może być użyta do wyczyszczenia flag A i C:

- -
// nieprawdą jest, że mamy problem z mrówkami lub posiadamy kota
-var maska = ~(FLAG_A | FLAG_C); // ~0101 => 1010
-flagi &= maska;   // 1101 & 1010 => 1000
-
- -

Maska może być również stworzona przez wyrażenie ~FLAG_A & ~FLAG_C (z praw De Morgana):

- -
// nie, nie mamy problemu z mrówkami i nie posiadamy kota
-var maska = ~FLAGA_A & ~FLAGA_C;
-flagi &= maska;   // 1101 & 1010 => 1000
-
- -

Flagi mogą być przełączane przez użycie operatora XOR z maską bitową, gdzie każðy bit będzie przełączał odpowiednią flagę. Przykładowo, maska 0110 może być użyta do przełączenia flag B i C:

- -
// jeśli nie mieliśmy nietoperza, teraz go mamy,
-// a jeśli go mieliśmy – pa, pa, nietoperku!
-// tak samo z kotami
-var maska = FLAGA_B | FLAGA_C;
-flagi = flagi ^ maska;   // 1100 ^ 0110 => 1010
-
- -

Flagi mogą być odwracane przez operator NOT:

- -
// przechodzimy do równoległego wszechświata...
-flagi = ~flagi;    // ~1010 => 0101
-
- -

Conversion snippets

- -

Konwersja binarnej zmiennej typu String do liczby dziesiętnej typu Number:

- -
var sBinString = '1011';
-var nMojaLiczba = parseInt(sBinString, 2);
-alert(nMojaLiczba); // wypisuje 11, tzn. binarnie 1011
-
- -

Konwersja dziesiętnej liczby do binarnego Stringa:

- -
var nMojaLiczba = 11;
-var sBinString = nMojaLiczba.toString(2);
-alert(sBinString); // wypisuje 1011, tzn. dziesiętnie 11
-
- -

Automatyczne tworzenie masek

- -

Możesz stworzyć wiele masek ze zbioru wartości typu Boolean values, na przykład:

- -
function createMask() {
-  var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;
-  for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
-  return nMask;
-}
-var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011
-var mask2 = createMask(false, false, true); // 4, i.e.: 0100
-var mask3 = createMask(true); // 1, i.e.: 0001
-// itd.
-
-alert(mask1); // wypisuje 11, czyli binarnie: 1011
-
- -

Algorytm odwrotny: tablica zmiennych boolowskich z maski

- -

Jeśli chcesz stworzyć tablicę złożoną ze zmiennych boolowskich, możesz użyć następującego kodu:

- -
function arrayFromMask(nMask) {
-  // nMask musi być pomiędzy -2147483648 a 2147483647
-  if (nMask > 0x7fffffff || nMask < -0x80000000) {
-    throw new TypeError('arrayFromMask - out of range');
-  }
-  for (var nShifted = nMask, aFromMask = []; nShifted;
-       aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1);
-  return aFromMask;
-}
-
-var array1 = arrayFromMask(11);
-var array2 = arrayFromMask(4);
-var array3 = arrayFromMask(1);
-
-alert('[' + array1.join(', ') + ']');
-// wypisuje "[true, true, false, true]", tzn.: 11, tzn.: 1011
-
- -

Możesz przetestować obydwa algorytmy naraz:

- -
var nTest = 19; // nasza maska
-var nResult = createMask.apply(this, arrayFromMask(nTest));
-
-alert(nResult); // 19
-
- -

Jedynie dla celów dydaktycznych (jako że istnieje metoda Number.toString(2)), pokażemy jak można zmodyfikować algorytm arrayFromMask tak, by tworzył zmienną String zawierającą binarną reprezentację danej liczby, zamiast tablicy zmiennych typu Boolean:

- -
function createBinaryString(nMask) {
-  // nMask musi być pomiędzy -2147483648 a 2147483647
-  for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32;
-       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
-  return sMask;
-}
-
-var string1 = createBinaryString(11);
-var string2 = createBinaryString(4);
-var string3 = createBinaryString(1);
-
-alert(string1);
-// wypisuje 00000000000000000000000000001011, i.e. 11
-
- -

Specyfikacje

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecyfikacjaStatusKomentarz
{{SpecName('ES1')}}{{Spec2('ES1')}}Definicja początkowa.
{{SpecName('ES5.1', '#sec-11.7')}}{{Spec2('ES5.1')}}Zdefiniowane w kilku sekcjach specyfikacji: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators
{{SpecName('ES6', '#sec-bitwise-shift-operators')}}{{Spec2('ES6')}}Zdefiniowane w kilku sekcjach specyfikacji: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators
{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}{{Spec2('ESDraft')}}Zdefiniowane w kilku sekcjach specyfikacji: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators
- -

Wsparcie przeglądarek

- - - -

{{Compat("javascript.operators.bitwise")}}

- -

Zobacz też

- - diff --git a/files/pl/conflicting/web/javascript/reference/operators/spread_syntax/index.html b/files/pl/conflicting/web/javascript/reference/operators/spread_syntax/index.html deleted file mode 100644 index 99eb2d84ce..0000000000 --- a/files/pl/conflicting/web/javascript/reference/operators/spread_syntax/index.html +++ /dev/null @@ -1,231 +0,0 @@ ---- -title: Spread syntax -slug: conflicting/Web/JavaScript/Reference/Operators/Spread_syntax -tags: - - ECMAScript 2015 - - Iterator - - JavaScript - - Operator Rozwinięcia -translation_of: Web/JavaScript/Reference/Operators/Spread_syntax -translation_of_original: Web/JavaScript/Reference/Operators/Spread_operator -original_slug: Web/JavaScript/Referencje/Operatory/Spread_operator ---- -
{{jsSidebar("Operators")}}
- -

Operator spread umożliwia rozwinięcie wyrażenia. Składnia rozwinięcia pozwala na rozwinięcie wyrażenia w miejscach, w których potrzebne jest wiele argumentów (do wywołań funkcji), wiele elementów (do literałów tablicowych) lub wiele zmiennych ().

- -

Składnia

- -

Do wywołań funkcji:

- -
mojaFunkcja(...iterowalnyObiekt);
-
- -

Do literałów tablicowych:

- -
[...iterowalnyObiekt, 4, 5, 6]
- -

 

- -

Do przypisań destrukturyzujących:

- -
var [glowa, ...ogon] = [1, 2, 3, 4]
- -

Przykłady

- -

Lepsze zastosowanie

- -

Przykład: powszechne jest użycie {{jsxref( "Function.prototype.apply")}} w przypadkach, gdy chcesz użyć tablic jako argumentów funkcji.

- -
function mojaFunkcja(x, y, z) { }
-var args = [0, 1, 2];
-mojaFunkcja.apply(null, args);
- -

Ze składnią rozwinięcia (spread) ES2015 powyższy kod można zapisać jako:

- -
function mojaFunkcja(x, y, z) { }
-var args = [0, 1, 2];
-mojaFunkcja(...args);
- -

Dowolny argument w liście argumentów może użyć składni rozwinięcia i może być użyty wiele razy.

- -
function myFunction(v, w, x, y, z) { }
-var args = [0, 1];
-myFunction(-1, ...args, 2, ...[3]);
- -

Potężniejszy literał tablicowy

- -

Przykład: Jeżeli masz tablicę i chcesz utworzyć nową tablicę z tą tablicą jako jej częścią, składnia literału tablicowego nie jest już wystarczająca i należy cofnąć się do programowania imperatywnego, użyć kombinacji push, splice, concat, itp. Z użyciem składni rozwinięcia wygląda to dużo prościej:

- -
var czesci = ['ramiona', 'kolana'];
-var rymowanka = ['glowa', ...czesci, 'i', 'palce']; // ["glowa", "ramiona", "kolana", "i", "palce"]
-
- -

Tak samo jak rozwinięcie może być użyte do list argumentów, ... mogą być użyte wszędzie w literale tablicowym, także wiele razy.

- -

Zastosowanie z new

- -

Przykład: W ES5 nie jest możliwa kompozycja new z apply. (W ES5, apply wykonuje [[Call]], a nie [[Construct]].) W ES2015 składnia rozwinięcia wygląda następująco:

- -
var daty = czytajDaty(bazaDanych);
-var d = new Date(...daty);
- -

Kopiowanie tablicy

- -
var tablica = [1,2,3];
-var tablica2 = [...tablica]; // jak tablica.slice()
-tablica2.push(4); // tablica2 staje się [1,2,3,4], tablica pozostaje niezmieniona
-
-
- -

Ulepszone push

- -

Przykład: {{jsxref("Global_Objects/Array/push", "push")}} jest często używany, by dodać tablicę na koniec innej tablicy. W ES5 jest to często osiągane przez:

- -
var tablica1 = [0, 1, 2];
-var tablica2 = [3, 4, 5];
-// Dodaj wszystkie elementy z tablica2 do tablica1
-Array.prototype.push.apply(tablica1, tablica2);
- -

W ES2015 z rozwinięciem wygląda to następująco:

- -
var tablica1 = [0, 1, 2];
-var tablica2 = [3, 4, 5];
-tablica1.push(...tablica2);
- -

Użycie jedynie dla obiektów iterowalnych

- -
var obiekt = {"klucz1":"wartosc1"};
-function mojaFunkcja(x) {
-   /* ... */
-}
-// proba rozwinięcia nieiterowalnego elementu
-// spowoduje błąd
-mojaFunkcja(...obiekt);
-var args = [...obiekt];
-// TypeError: obiekt is not iterable
- -

Operator reszty

- -

Operator reszty, który wygląda dokładnie jak składnia rozwinięcia (spread), jest używany do destrukturyzacji obiektów i tablic. W pewnym stopniu, elementy reszty są przeciwieństwem elementów rozwinięcia: rozwinięcie 'rozbija' tablicę na elementy, natomiast reszta zbiera wiele elementów i 'zwija' je w jeden element.

- -

Specyfikacje

- - - - - - - - - - - - - - - - - - - - - -
SpecyfikacjaStanKomentasz
{{SpecName('ES2015', '#sec-array-initializer')}}{{Spec2('ES2015')}}Zdefiniowany w kilku sekcjach specyfikacji: Array Initializer, Argument Lists
{{SpecName('ESDraft', '#sec-array-initializer')}}{{Spec2('ESDraft')}} 
- -

Kompatybilność przeglądarek

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FunkcjaChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Operacja rozwinięcia w literałach tablicowych{{CompatChrome("46")}}{{ CompatGeckoDesktop("16") }}{{CompatIE("Edge")}}{{CompatNo}}7.1
Operacja rozwinięcia w wywołaniach funkcji{{CompatChrome("46")}}{{ CompatGeckoDesktop("27") }}{{CompatIE("Edge")}}{{CompatNo}}7.1
Operacja rozwinięcia w destrukturyzacji{{CompatChrome("49")}}{{ CompatGeckoDesktop("34") }}{{CompatNo}}{{CompatUnknown}}{{CompatUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FunkcjaAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Operacja rozwinięcia w literałach tablicowych{{CompatNo}}{{CompatChrome("46")}}{{ CompatGeckoMobile("16") }}{{CompatNo}}{{CompatNo}}8{{CompatChrome("46")}}
Operacja rozwinięcia w wywołaniach funkcji{{CompatNo}}{{CompatChrome("46")}}{{ CompatGeckoMobile("27") }}{{CompatNo}}{{CompatNo}}8{{CompatChrome("46")}}
Operacja rozwinięcia w destrukturyzacji{{CompatNo}}{{CompatNo}}{{ CompatGeckoDesktop("34") }}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatNo}}
-
- -

Zobacz też

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