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) --- .../reference/global_objects/boolean/index.html | 50 -- .../reference/global_objects/date/index.html | 20 - .../index.html | 118 ----- .../reference/global_objects/error/index.html | 115 ----- .../reference/global_objects/number/index.html | 24 - .../reference/global_objects/object/index.html | 220 -------- .../reference/global_objects/rangeerror/index.html | 125 ----- .../reference/global_objects/regexp/index.html | 55 -- .../reference/global_objects/string/index.html | 222 -------- .../reference/lexical_grammar/index.html | 19 - .../web/javascript/reference/operators/index.html | 560 --------------------- .../reference/operators/spread_syntax/index.html | 231 --------- .../index.html | 37 -- .../index.html | 270 ---------- .../index.html | 132 ----- .../index.html | 256 ---------- .../index.html | 77 --- .../reference/statements/switch/index.html | 122 ----- 18 files changed, 2653 deletions(-) delete mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/boolean/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/date/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/date_73c046d653c590f4914731d078f3b2c5/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/error/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/number/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/object/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/rangeerror/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/regexp/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/string/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/lexical_grammar/index.html 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 delete mode 100644 files/pl/conflicting/web/javascript/reference/operators_1d09774e621bf2431a4f5594a248dd21/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/operators_1f6634ff6e3ccef661281d6e50002147/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/operators_5ba63337c20d72b8f8747a954b9b6c94/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/operators_de3666cd349851054926d5e52fced70d/index.html delete mode 100644 files/pl/conflicting/web/javascript/reference/statements/switch/index.html (limited to 'files/pl/conflicting/web/javascript/reference') diff --git a/files/pl/conflicting/web/javascript/reference/global_objects/boolean/index.html b/files/pl/conflicting/web/javascript/reference/global_objects/boolean/index.html deleted file mode 100644 index d736bbcb1f..0000000000 --- a/files/pl/conflicting/web/javascript/reference/global_objects/boolean/index.html +++ /dev/null @@ -1,50 +0,0 @@ ---- -title: Boolean.prototype -slug: conflicting/Web/JavaScript/Reference/Global_Objects/Boolean -tags: - - Dokumentacja_JavaScript - - Dokumentacje - - JavaScript - - Strony_wymagające_dopracowania - - Wszystkie_kategorie -translation_of: Web/JavaScript/Reference/Global_Objects/Boolean -translation_of_original: Web/JavaScript/Reference/Global_Objects/Boolean/prototype -original_slug: Web/JavaScript/Referencje/Obiekty/Boolean/prototype ---- -
{{JSRef}}
- -

Podsumowanie

- -

Reprezentuje prototyp konstruktora {{jsxref("Boolean")}}.

- -

Opis

- -

Instancje {{jsxref("Boolean")}} dziedziczą z Boolean.prototype. Możesz użyć obiektu prototypu konstruktora, by dodać własności lub metody do wszystkich instancji {{jsxref("Boolean")}}.

- -

Własności

- -
-
Boolean.prototype.constructor
-
Zwraca funkcję, która tworzy instancję prototypu. Jest to domyślnie funkcja {{jsxref("Boolean")}}.
-
- -
{{jsOverrides("Object", "properties", "constructor")}}
- -

Metody

- -
-
{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}}
-
Zwraca ciąg zawierający źródło obiektu Boolean; możesz użyć tego ciągu, by stworzyć równoważny obiekt. Przesłania metodę {{jsxref("Object.prototype.toSource()")}}.
-
- -
-
{{jsxref("Boolean.prototype.toString()")}}
-
Zwraca ciąg "true" albo "false", zależnie od wartości obiektu. Przesłania metodę {{jsxref("Object.prototype.toString()")}}.
-
- -
-
{{jsxref("Boolean.prototype.valueOf()")}}
-
Zwraca prostą wartość obiektu Boolean. Przesłania metodę {{jsxref("Object.prototype.valueOf()")}}.
-
- -
{{jsOverrides("Object", "methods", "toSource", "toString", "valueOf")}}
diff --git a/files/pl/conflicting/web/javascript/reference/global_objects/date/index.html b/files/pl/conflicting/web/javascript/reference/global_objects/date/index.html deleted file mode 100644 index 86570633a1..0000000000 --- a/files/pl/conflicting/web/javascript/reference/global_objects/date/index.html +++ /dev/null @@ -1,20 +0,0 @@ ---- -title: constructor -slug: conflicting/Web/JavaScript/Reference/Global_Objects/Date -tags: - - Dokumentacja_JavaScript - - Dokumentacje - - JavaScript - - Wszystkie_kategorie -translation_of: Web/JavaScript/Reference/Global_Objects/Date -translation_of_original: Web/JavaScript/Reference/Global_Objects/Date/constructor -original_slug: Web/JavaScript/Referencje/Obiekty/Date/constructor ---- -

-

-

Podsumowanie

-

Zwraca referencję do funkcji Date, która tworzy prototyp instancji. Należy pamiętać, że wartość tej własności jest referencją do samej funkcji, nie zaś łańcuchem znaków zawierającym nazwę funkcji.

- -
Własność obiektu: Date
Zaimplementowane w: JavaScript 1.1, NES 2.0
Wersja ECMA: ECMA-262

Opis

-

Zobacz Object.constructor. -

{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Date/constructor", "ja": "ja/Core_JavaScript_1.5_Reference/Global_Objects/Date/constructor" } ) }} diff --git a/files/pl/conflicting/web/javascript/reference/global_objects/date_73c046d653c590f4914731d078f3b2c5/index.html b/files/pl/conflicting/web/javascript/reference/global_objects/date_73c046d653c590f4914731d078f3b2c5/index.html deleted file mode 100644 index 1a72939d23..0000000000 --- a/files/pl/conflicting/web/javascript/reference/global_objects/date_73c046d653c590f4914731d078f3b2c5/index.html +++ /dev/null @@ -1,118 +0,0 @@ ---- -title: Date.prototype -slug: >- - conflicting/Web/JavaScript/Reference/Global_Objects/Date_73c046d653c590f4914731d078f3b2c5 -tags: - - Dokumentacja_JavaScript - - Dokumentacje - - JavaScript - - Wszystkie_kategorie -translation_of: Web/JavaScript/Reference/Global_Objects/Date -translation_of_original: Web/JavaScript/Reference/Global_Objects/Date/prototype -original_slug: Web/JavaScript/Referencje/Obiekty/Date/prototype ---- -

{{JSRef}}

- -

Podsumowanie

- -

Reprezentuje prototyp dla tej klasy. Można używać prototypu do dodawania własności lub metod wszystkim instancjom klasy. Aby uzyskać więcej informacji o prototypach, zobacz {{jsxref("Function.prototype")}}.

- -

Własności

- -
-
Date.prototype.constructor
-
Określa funkcję, która tworzy prototyp obiektu.
-
- -
{{jsOverrides("Object", "properties", "constructor")}}
- -

Metody

- -
-
{{jsxref("Date.prototype.getDate()")}}
-
Zwraca dzień miesiąca dla określonej daty, stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.getDay()")}}
-
Zwraca dzień tygodnia dla określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.getFullYear()")}}
-
Zwraca rok określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.getHours()")}}
-
Zwraca godzinę określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.getMilliseconds()")}}
-
Zwraca milisekundy określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.getMinutes()")}}
-
Zwraca minuty w określonej dacie czasu lokalnego.
-
{{jsxref("Date.prototype.getMonth()")}}
-
Zwraca miesiąc w określonej dacie czasu lokalnego.
-
{{jsxref("Date.prototype.getSeconds()")}}
-
Zwraca sekundy określone w dacie stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.getTime()")}}
-
Zwraca wartość numeryczną przesyłając czas określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.getTimezoneOffset()")}}
-
Zwraca czas przesunięcia wg strefy czasowej dla aktualnego czasu lokalnego. .
-
{{jsxref("Date.prototype.getUTCDate()")}}
-
Zwraca dzień (date) miesiąca określonej daty stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.getUTCDay()")}}
-
Zwraca dzień tygodnia określone w dacie stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.getUTCFullYear()")}}
-
Zwraca rok określony w dacie stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.getUTCHours()")}}
-
Zwraca godziny określone w dacie stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.getUTCMilliseconds()")}}
-
Zwraca milisekundy określone w dacie stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.getUTCMinutes()")}}
-
Zwraca minuty określone w dacie stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.getUTCMonth()")}}
-
Zwraca nazwę miesięcy określone w dacie stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.getUTCSeconds()")}}
-
Zwraca sekundy określonej daty stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.getYear()")}} {{deprecated_inline}}
-
Zwraca rok określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.setDate()")}}
-
Ustawia dzień miesiąca dla określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.setFullYear()")}}
-
Ustawia pełny rok dla określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.setHours()")}}
-
Ustawia godziny dla określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.setMilliseconds()")}}
-
Ustawia milisekundy dla określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.setMinutes()")}}
-
Ustawia minuty dla określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.setMonth()")}}
-
Ustawia nazwę miesiąca dla określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.setSeconds()")}}
-
Ustawia sekundy dla określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.setTime()")}}
-
Ustawia wartość obiektu Date stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.setUTCDate()")}}
-
Ustawia dzień miesiąca dla określonej daty stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.setUTCFullYear()")}}
-
Ustawia pełen rok dla określonej daty stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.setUTCHours()")}}
-
Ustawia godzinę dla określonej daty stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.setUTCMilliseconds()")}}
-
Ustawia milisekundy dla określonej daty stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.setUTCMinutes()")}}
-
Ustawia minuty dla określonej daty stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.setUTCMonth()")}}
-
Ustawia miesiąc dla określonej daty stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.setUTCSeconds()")}}
-
Ustawia sekundy dla określonej daty stosownie do czasu uniwersalnego.
-
{{jsxref("Date.prototype.setYear()")}} {{deprecated_inline}}
-
Ustawia rok dla określonej daty stosownie do czasu lokalnego.
-
{{jsxref("Date.prototype.toGMTString()")}} {{deprecated_inline}}
-
Konwertuje datę na łańcuch znaków, używając konwencji czasu GMT.
-
{{jsxref("Date.prototype.toLocaleString()")}}
-
Konwertuje datę na łańcuch znaków (string), używając aktualnej lokalnej konwencji. Przesłania metodę {{jsxref("Object.prototype.toLocaleString()")}}.
-
{{jsxref("Date.prototype.toLocaleDateString()")}}
-
Zwraca datę (bez godziny) z obiektu Date jako ciąg znaków z wykorzystaniem lokalnych konwencji.
-
{{jsxref("Date.prototype.toLocaleTimeString()")}}
-
Zwraca godzinę (bez daty) z obiektu Date jako ciąg znaków z wykorzystaniem lokalnych konwencji.
-
{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}}
-
Zwraca obiekt literału reprezentujący określony obiekt Date; możesz użyć tej wartości do tworzenia nowych obiektów. Przesłania metodę {{jsxref("Object.prototype.toSource()")}}.
-
{{jsxref("Date.prototype.toString()")}}
-
Zwraca łańcuch znaków, reprezentujący określony obiekt Date. Przesłania metodę {{jsxref("Object.prototype.toString()")}}.
-
{{jsxref("Date.prototype.toUTCString()")}}
-
Konwertuje datę na łańcuch znaków, używając do konwencji czasu uniwersalnego.
-
{{jsxref("Date.prototype.valueOf()")}}
-
Zwraca wartość prostą obiektu Date. Przesłania metodę {{jsxref("Object.prototype.valueOf()")}}.
-
diff --git a/files/pl/conflicting/web/javascript/reference/global_objects/error/index.html b/files/pl/conflicting/web/javascript/reference/global_objects/error/index.html deleted file mode 100644 index 034b1c0fc9..0000000000 --- a/files/pl/conflicting/web/javascript/reference/global_objects/error/index.html +++ /dev/null @@ -1,115 +0,0 @@ ---- -title: Error.prototype -slug: conflicting/Web/JavaScript/Reference/Global_Objects/Error -tags: - - Error - - JavaScript - - Właściwość -translation_of: Web/JavaScript/Reference/Global_Objects/Error -translation_of_original: Web/JavaScript/Reference/Global_Objects/Error/prototype -original_slug: Web/JavaScript/Referencje/Obiekty/Error/prototype ---- -
{{JSRef}}
- -

Właściwość Error.prototype reprezentuje prototyp dla konstruktora {{jsxref("Error")}}.

- -
{{js_property_attributes(0, 0, 0)}}
- -

Opis

- -

Wszystkie instancje klasy {{jsxref("Error")}} oraz instancje {{jsxref("Global_Objects/Error", "non-generic errors", "#Error_types", 1)}} dziedziczą po Error.prototype. As with all constructor functions, you can use the prototype of the constructor to add properties or methods to all instances created with that constructor.

- -

Właściwości

- -

Właściwości standardowe

- -
-
Error.prototype.constructor
-
Określa funkcję tworzącą instancję prototypu.
-
{{jsxref("Error.prototype.message")}}
-
Wiadomość błędu.
-
{{jsxref("Error.prototype.name")}}
-
Nazwa błędu.
-
- -

Rozszerzenia zależne od dostawcy

- -
{{non-standard_header}}
- -

Microsoft

- -
-
{{jsxref("Error.prototype.description")}}
-
Opis błędu. Podobne do {{jsxref("Error.prototype.message", "message")}}.
-
{{jsxref("Error.prototype.number")}}
-
Numer błędu.
-
- -

Mozilla

- -
-
{{jsxref("Error.prototype.fileName")}}
-
Ścieżka do pliku, w którym wywołany został wyjątek.
-
{{jsxref("Error.prototype.lineNumber")}}
-
Numer linijki w pliku, która wywołała wyjątek.
-
{{jsxref("Error.prototype.columnNumber")}}
-
Numer znaku w wierszu, w którym został wywołany wyjątek.
-
{{jsxref("Error.prototype.stack")}}
-
Stack trace.
-
- -

Metody

- -
-
{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}
-
Zwraca łańcuch znaków zawierający źródło wybranego obiektu {{jsxref("Error")}}; możesz użyć tej. Overrides the {{jsxref("Object.prototype.toSource()")}} method.
-
{{jsxref("Error.prototype.toString()")}}
-
Zwraca ciąg znaków reprezentujący wybrany obiekt. Nadpisuje metodę {{jsxref("Object.prototype.toString()")}}.
-
- -

Specyfikacja

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Początkowa definicja. Zaimplementowana w JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-error.prototype', 'Error')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}{{Spec2('ESDraft')}} 
- -

Kompatybilność

- -
- - -

{{Compat("javascript.builtins.Error.prototype")}}

-
- -

Zobacz też

- - diff --git a/files/pl/conflicting/web/javascript/reference/global_objects/number/index.html b/files/pl/conflicting/web/javascript/reference/global_objects/number/index.html deleted file mode 100644 index c4e66d6674..0000000000 --- a/files/pl/conflicting/web/javascript/reference/global_objects/number/index.html +++ /dev/null @@ -1,24 +0,0 @@ ---- -title: constructor -slug: conflicting/Web/JavaScript/Reference/Global_Objects/Number -tags: - - Dokumentacja_JavaScript - - Dokumentacje - - JavaScript - - Wszystkie_kategorie -translation_of: Web/JavaScript/Reference/Global_Objects/Number -translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/constructor -original_slug: Web/JavaScript/Referencje/Obiekty/Number/constructor ---- -

-

-

Podsumowanie

-

Własność obiektu: Number -

Określa funkcję tworzącą prototyp obiektu. Należy pamiętać, że wartość tej własności jest referencją do funkcji, a nie łańcuchem znaków zawierającym jej nazwę. -

-

Opis

-

Zobacz Object.constructor. -

-
-
-{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Number/constructor", "ja": "ja/Core_JavaScript_1.5_Reference/Global_Objects/Number/constructor" } ) }} diff --git a/files/pl/conflicting/web/javascript/reference/global_objects/object/index.html b/files/pl/conflicting/web/javascript/reference/global_objects/object/index.html deleted file mode 100644 index eb43453e16..0000000000 --- a/files/pl/conflicting/web/javascript/reference/global_objects/object/index.html +++ /dev/null @@ -1,220 +0,0 @@ ---- -title: Object.prototype -slug: conflicting/Web/JavaScript/Reference/Global_Objects/Object -tags: - - JavaScript - - Obiekt - - Object - - Property - - Prototype -translation_of: Web/JavaScript/Reference/Global_Objects/Object -translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype -original_slug: Web/JavaScript/Referencje/Obiekty/Object/prototype ---- -

{{JSRef}}

- -

Object.prototype reprezentuje prototyp obiektów klasy {{jsxref("Object")}}.

- -

Podsumowanie

- -

Wszystkie obiekty w języku JavaScript wywodzą się od {{jsxref("Object")}}; wszystkie obiekty dziedziczą metody i pola po Object.prototype, chociaż mogą one zostać przeciążone (z wyjątkiem Object'u o prototypie null, tj. Object.create(null)). Na przykład, prototypy innych konstruktorów przeciążają pole constructor i zapewniają swoje własne wersje metod {{jsxref("Object.prototype.toString()", "toString()")}}. Zmiany do prototypu Object propagowane są do wszystkich obiektów, chyba że dane metody i pola zostały przeciążone w prototypie którejś z klas bazowych.

- -

Własności

- -
-
{{jsxref("Object.prototype.constructor")}}
-
Określa konstruktor obiektu - funkcję, która tworzy prototyp obiektu.
-
{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}
-
Wskazuje na obiekt który był użyty jako prototyp, kiedy dany obiekt był inicjalizowany.
-
{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}
-
Pozwala zdefiniować funkcję, która będzie wykonana kiedy niezdefiniowany element obiektu zostanie wywołany jako metoda.
-
{{jsxref("Object.prototype.__count__")}} {{obsolete_inline}}
-
Własność zwracała liczbę właściwości tzw. enumerable posiadanych przez zdefiniowany przez użytkownika obiekt. Własność ta została usunięta.
-
{{jsxref("Object.prototype.__parent__")}} {{obsolete_inline}}
-
Była używana do wskazywania kontwkstu obiektu. Własność ta została usunięta.
-
- -

Metody

- -
-
{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
-
Przypisuje funkcję do pola, do którego odwołanie wywoła tę funkcję, która zwróci odpowiednią wartość.
-
{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
-
Przypisuje funkcję do pola, którego ustawienie wywoła tę funkcję, która zmodyfikuje wartość pola.
-
{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
-
Zwraca funkcję powiązaną z danym polem poprzez metodę {{jsxref("Object.defineGetter", "__defineGetter__")}}.
-
{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
-
Zwraca funkcję powiązaną z danym polem poprzez metodę {{jsxref("Object.defineSetter", "__defineSetter__")}}.
-
{{jsxref("Object.prototype.hasOwnProperty()")}}
-
Zwraca wartość boolean wskazującą czy obiekt posiada dane pole (wykluczając przypadki, gdy pole jest odziedziczone).
-
{{jsxref("Object.prototype.isPrototypeOf()")}}
-
Zwraca wartość boolean wskazującą czy dany obiekt znajduje się w łańcuchu prototypów obiektu podanego jako parametr funkcji.
-
{{jsxref("Object.prototype.propertyIsEnumerable()")}}
-
Zwraca wartość boolean wskazującą czy ustawiony jest atrybut ECMAScript DontEnum attribute.
-
{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}
-
Zwraca literał obiektowy reprezentujący dany obiekt; można go użyć do utworzenia nowego obiektu.
-
{{jsxref("Object.prototype.toLocaleString()")}}
-
Wywołuje {{jsxref("Object.toString", "toString()")}}.
-
{{jsxref("Object.prototype.toString()")}}
-
Zwraca łańcuch znaków reprezentujący dany obiekt.
-
{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}
-
Usuwa funkcję monitorującą daną własność obiektu.
-
{{jsxref("Object.prototype.valueOf()")}}
-
Zwraca wartość prostą danego obiektu.
-
{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}
-
Dodaje funkcję monitorującą daną własność obiektu.
-
{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}
-
Wykonuje kod JavaScriptu zawarty w łańcuchu znaków w kontekście danego obiektu.
-
- -

Przykłady

- -

Jako, iż JavaScript nie posiada typowego rozróżnienia na klasę bazową i dziedziczącą,  prototype jest przydatnym obejściem pozwalającym na utworzenie “klasy bazowej” z pewnych funkcji, które działają jak obiekty. Na przykład:

- -
var Osoba = function() {
-  this.umieMowic = true;
-};
-
-Osoba.prototype.powitaj = function() {
-  if (this.umieMowic) {
-    console.log('Hej, jestem ' + this.imie);
-  }
-};
-
-var Pracownik = function(imie, tytul) {
-  Osoba.call(this);
-  this.imie = imie;
-  this.tytul = tytul;
-};
-
-Pracownik.prototype = Object.create(Osoba.prototype);
-Pracownik.prototype.constructor = Pracownik;
-
-Pracownik.prototype.powitaj = function() {
-  if (this.umieMowic) {
-    console.log('Hej, jestem ' + this.imie + ', ' + this.tytul);
-  }
-};
-
-var Klient = function(imie) {
-  Osoba.call(this);
-  this.imie = imie;
-};
-
-Klient.prototype = Object.create(Osoba.prototype);
-Klient.prototype.constructor = Klient;
-
-var Mim = function(imie) {
-  Osoba.call(this);
-  this.imie = imie;
-  this.umieMowic = false;
-};
-
-Mim.prototype = Object.create(Osoba.prototype);
-Mim.prototype.constructor = Mim;
-
-var bob = new Pracownik('Bob', 'Builder');
-var joe = new Klient('Joe');
-var rg = new Pracownik('Red Green', 'Handyman');
-var mike = new Klient('Mike');
-var mim = new Mim('Mim');
-
-bob.powitaj();
-// Hej, jestem Bob, Builder
-
-joe.powitaj();
-// Hej, jestem Joe
-
-rg.powitaj();
-// Hej, jestem Red Green, Handyman
-
-mike.powitaj();
-// Hej, jestem Mike
-
-mim.powitaj();
-
- -

Specyfikacje

- - - - - - - - - - - - - - - - - - - - - - - - -
SpecyfikacjaStatusKomentarz
{{SpecName('ES1')}}{{Spec2('ES1')}}Początkowa definicja. Zaimplementowano w JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}{{Spec2('ES6')}} 
- -

Kompatybilność

- -
{{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 też

- - diff --git a/files/pl/conflicting/web/javascript/reference/global_objects/rangeerror/index.html b/files/pl/conflicting/web/javascript/reference/global_objects/rangeerror/index.html deleted file mode 100644 index ff970fa335..0000000000 --- a/files/pl/conflicting/web/javascript/reference/global_objects/rangeerror/index.html +++ /dev/null @@ -1,125 +0,0 @@ ---- -title: RangeError.prototype -slug: conflicting/Web/JavaScript/Reference/Global_Objects/RangeError -translation_of: Web/JavaScript/Reference/Global_Objects/RangeError -translation_of_original: Web/JavaScript/Reference/Global_Objects/RangeError/prototype -original_slug: Web/JavaScript/Referencje/Obiekty/RangeError/prototype ---- -
{{JSRef}}
- -

Właściwość RangeError.prototype reprezentuje prototyp konstuktora {{jsxref("RangeError")}}.

- -
{{js_property_attributes(0, 0, 0)}}
- -

Opis 

- -

Wszystkie instancje {{jsxref("RangeError")}} dziedziczą z prototyup RangeError. Możesz użyć prototypu, by dodać właściwości lub metody do wszystkich instancji.

- -

Właściwości

- -
-
RangeError.prototype.constructor
-
Funkcja, która tworzy prototyp instancji.
-
{{jsxref("Error.prototype.message", "RangeError.prototype.message")}}
-
Wiadomość błędu. Chociaż specyfikacja ECMA-262 mówi,  że {{jsxref("RangeError")}} powinien dostarczyć swoją własną właściwość message, w SpiderMonkey, dziedziczy z {{jsxref("Error.prototype.message")}}.
-
{{jsxref("Error.prototype.name", "RangeError.prototype.name")}}
-
Nazwa błędu, dziedziczona z {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.fileName", "RangeError.prototype.fileName")}}
-
Ścieżka do pliku, w którym wywołany został błąd. Dziedziczone z {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.lineNumber", "RangeError.prototype.lineNumber")}}
-
Numer linii, gdzie wywołany został błąd. Dziedziczone z {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.columnNumber", "RangeError.prototype.columnNumber")}}
-
Numer kolumny w linii, gdzie wywołany został błąd. Dziedziczone z {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.stack", "RangeError.prototype.stack")}}
-
Ślad stosu. Dziedziczone z {{jsxref("Error")}}.
-
- -

Metody

- -

Chociaż prototyp {{jsxref("RangeError")}} nie zawiera metod jako taki, instancja {{jsxref("RangeError")}} dziedziczy pewne metody z łańcucha prototypów.

- -

Specyfikacje

- - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Defined as NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Defined as NativeError.prototype.
- -

Kompatybilność z przeglądarkami

- -
{{CompatibilityTable}}
- -
- - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Bazowe wsparcie{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Bazowe wsparcie{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -

Zobacz także

- - diff --git a/files/pl/conflicting/web/javascript/reference/global_objects/regexp/index.html b/files/pl/conflicting/web/javascript/reference/global_objects/regexp/index.html deleted file mode 100644 index 9f89b08978..0000000000 --- a/files/pl/conflicting/web/javascript/reference/global_objects/regexp/index.html +++ /dev/null @@ -1,55 +0,0 @@ ---- -title: RegExp.prototype -slug: conflicting/Web/JavaScript/Reference/Global_Objects/RegExp -tags: - - JavaScript - - Property - - Prototype - - RegExp -translation_of: Web/JavaScript/Reference/Global_Objects/RegExp -translation_of_original: Web/JavaScript/Reference/Global_Objects/RegExp/prototype -original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/prototype ---- -

{{JSRef}}

- -

Podsumowanie

- -

Reprezentuje prototyp obiektów danej klasy. Pozwala na dodawanie własności i metod do wszystkich instancji tej klasy.

- -

Własności

- -

Zauważ, że niektóre własności obiektu RegExp mają dwie nazwy: długą i krótką (Perlową). Obydwie nazwy zawsze odwołują się do tej samej wartości. Perl jest językiem programowania, z którego uformowały się wyrażenia regularne JavaScriptu.

- -
-
RegExp.prototype.constructor
-
Określa funkcję, która tworzy prototyp obiektu.
-
{{jsxref("RegExp.prototype.flags")}} {{experimental_inline}}
-
A string that contains the flags of the RegExp object.
-
{{jsxref("RegExp.prototype.global")}}
-
Czy przeszukiwać cały ciąg w poszukiwaniu wszystkich możliwych dopasowań czy tylko w poszukiwaniu pierwszego.
-
{{jsxref("RegExp.prototype.ignoreCase")}}
-
Czy ignorować wielkość liter podczas wyszukiwania.
-
{{jsxref("RegExp.prototype.multiline")}}
-
Czy w ciągach z wieloma liniami, szukać w wielu liniach.
-
{{jsxref("RegExp.prototype.source")}}
-
Tekst wzoru.
-
{{jsxref("RegExp.prototype.sticky")}} {{experimental_inline}}
-
Whether or not the search is sticky.
-
{{jsxref("RegExp.prototype.unicode")}} {{experimental_inline}}
-
Whether or not Unicode features are enabled.
-
- -

Metody

- -
-
{{jsxref("RegExp.prototype.compile()")}} {{deprecated_inline}}
-
(Re-)compiles a regular expression during execution of a script.
-
{{jsxref("RegExp.prototype.exec()")}}
-
Uruchamia wyszukiwanie dopasowania w ciągu podanym poprzez parametr tej metody.
-
{{jsxref("RegExp.prototype.test()")}}
-
Testuje dopasowanie w ciągu podanym poprzez parametr tej metody.
-
{{jsxref("RegExp.prototype.toSource()")}} {{non-standard_inline}}
-
Zwraca literał obiektu reprezentujący podany obiekt; możesz użyć tej wartości do utworzenia nowego obiektu. Przesłania metodę Object.toSource.
-
{{jsxref("RegExp.prototype.toString()")}}
-
Zwraca ciąg znaków reprezentujący podany obiekt. Przesłania metodę Object.toString.
-
diff --git a/files/pl/conflicting/web/javascript/reference/global_objects/string/index.html b/files/pl/conflicting/web/javascript/reference/global_objects/string/index.html deleted file mode 100644 index 6711b8603c..0000000000 --- a/files/pl/conflicting/web/javascript/reference/global_objects/string/index.html +++ /dev/null @@ -1,222 +0,0 @@ ---- -title: String.prototype -slug: conflicting/Web/JavaScript/Reference/Global_Objects/String -tags: - - JavaScript - - Property - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String -translation_of_original: Web/JavaScript/Reference/Global_Objects/String/prototype -original_slug: Web/JavaScript/Referencje/Obiekty/String/prototype ---- -

{{JSRef}}

- -

Podsumowanie

- -

Reprezentuje prototyp obiektów danej klasy. Pozwala na dodawanie własności i metod do wszystkich instancji tej klasy.

- -
{{js_property_attributes(0, 0, 0)}}
- -

Opis

- -

Wszystkie instancje {{jsxref("Global_Objects/String", "String")}} dziedziczą z  String.prototype. Zmiany w prototypie obiektu String są propagowane do wszystkich instancji {{jsxref("Global_Objects/String", "String")}}.

- -

Własności

- -
-
String.prototype.constructor
-
Oznacza funkcję, która tworzy prototyp obiektu.
-
{{jsxref("String.prototype.length")}}
-
Odzwierciedla długość łańcucha znaków.
-
N
-
Używane celem uzyskania dostępu do znaku na pozycji N-tej gdzie  N jest dodatnią liczbą całkowitą między 0 a o jeden mniejszą od {{jsxref("String.length", "length")}}. Własności te są tylko do odczytu.
-
- -

Metody

- -

Metody niezwiązane z HTML

- -
-
{{jsxref("String.prototype.charAt()")}}
-
Zwraca znak o podanym indeksie.
-
{{jsxref("String.prototype.charCodeAt()")}}
-
Zwraca liczbę oznaczającą wartość Unicode znaku o podanym indeksie.
-
{{jsxref("String.prototype.codePointAt()")}} {{experimental_inline}}
-
Returns a non-negative integer that is the UTF-16 encoded code point value at the given position.
-
{{jsxref("String.prototype.concat()")}}
-
Łączy dwa łańcuchy znaków i zwraca nowy łańcuch.
-
{{jsxref("String.prototype.includes()")}} {{experimental_inline}}
-
Determines whether one string may be found within another string.
-
{{jsxref("String.prototype.endsWith()")}} {{experimental_inline}}
-
Determines whether a string ends with the characters of another string.
-
{{jsxref("String.prototype.indexOf()")}}
-
Zwraca indeks pierwszego wystąpienia podanego znaku w obiekcie String lub -1, gdy niczego nie znaleziono.
-
{{jsxref("String.prototype.lastIndexOf()")}}
-
Zwraca indeks ostatniego wystąpienia podanego znaku w obiekcie String lub -1, gdy niczego nie znaleziono.
-
{{jsxref("String.prototype.localeCompare()")}}
-
Returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order.
-
{{jsxref("String.prototype.match()")}}
-
Używane do porównania wyrażenia regularnego z łańcuchem znaków.
-
{{jsxref("String.prototype.normalize()")}} {{experimental_inline}}
-
Returns the Unicode Normalization Form of the calling string value.
-
{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}
-
Wraps the string in double quotes (""").
-
{{jsxref("String.prototype.repeat()")}} {{experimental_inline}}
-
Returns a string consisting of the elements of the object repeated the given times.
-
{{jsxref("String.prototype.replace()")}}
-
Używane do znalezienia podobieństwa pomiędzy wyrażeniem regularnym a łańcuchem znaków, a następnie do podmiany znalezionego podłańcucha nowym podłańcuchem.
-
{{jsxref("String.prototype.search()")}}
-
Uruchamia wyszukiwanie podobieństwa pomiędzy wyrażeniem regularnym a podanym łańcuchem.
-
{{jsxref("String.prototype.slice()")}}
-
Wyciąga kawałek łańcucha i zwraca nowy łańcuch.
-
{{jsxref("String.prototype.split()")}}
-
Dzieli obiekt {{jsxref("String")}} na tablicę łańcuchów poprzez dzielenie łańcucha na podłańcuchy.
-
{{jsxref("String.prototype.startsWith()")}} {{experimental_inline}}
-
Determines whether a string begins with the characters of another string.
-
{{jsxref("String.prototype.substr()")}}
-
Zwraca podłańcuch znaków z łańcucha, zaczynający się w podanym miejscu i podanej długości znaków.
-
{{jsxref("String.prototype.substring()")}}
-
Zwraca znaki w podłańcuchu pomiędzy dwoma indeksami w łańcuchu.
-
{{jsxref("String.prototype.toLocaleLowerCase()")}}
-
The characters within a string are converted to lower case while respecting the current locale. For most languages, this will return the same as {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.
-
{{jsxref("String.prototype.toLocaleUpperCase()")}}
-
The characters within a string are converted to upper case while respecting the current locale. For most languages, this will return the same as {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}.
-
{{jsxref("String.prototype.toLowerCase()")}}
-
Zwraca wywołujący łańcuch skonwertowany do małych liter.
-
{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}
-
Zwraca literał obiektu reprezentujący podany obiekt; możesz użyć tej wartości do utworzenia nowego obiektu. Przesłania metodę {{jsxref("Object.prototype.toSource()")}}.
-
{{jsxref("String.prototype.toString()")}}
-
Zwraca łańcuch reprezentujący podany obiekt. Przesłania metodę {{jsxref("Object.prototype.toString()")}}.
-
{{jsxref("String.prototype.toUpperCase()")}}
-
Zwraca wywołujący łańcuch skonwertowany do wielkich liter.
-
{{jsxref("String.prototype.trim()")}}
-
Trims whitespace from the beginning and end of the string. Part of the ECMAScript 5 standard.
-
{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}
-
Trims whitespace from the left side of the string.
-
{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}
-
Trims whitespace from the right side of the string.
-
{{jsxref("String.prototype.valueOf()")}}
-
Zwraca wartość prymitywną podanego obiektu. Przesłania metodę {{jsxref("Object.prototype.valueOf()")}}.
-
{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}} {{experimental_inline}}
-
Returns a new Iterator object that iterates over the code points of a String value, returning each code point as a String value.
-
- -

Metody związane z HTML

- -

These methods are of limited use, as they provide only a subset of the available HTML tags and attributes.

- -
-
{{jsxref("String.prototype.anchor()")}}
-
{{htmlattrxref("name", "a", "<a name=\"name\">")}} (hypertext target)
-
{{jsxref("String.prototype.big()")}} {{deprecated_inline}}
-
{{HTMLElement("big")}}
-
{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}
-
{{HTMLElement("blink")}}
-
{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}
-
{{HTMLElement("b")}}
-
{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}
-
{{HTMLElement("tt")}}
-
{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}
-
{{htmlattrxref("color", "font", "<font color=\"color\">")}}
-
{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}
-
{{htmlattrxref("size", "font", "<font size=\"size\">")}}
-
{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}
-
{{HTMLElement("i")}}
-
{{jsxref("String.prototype.link()")}}
-
{{htmlattrxref("href", "a", "<a href=\"rul\">")}} (link to URL)
-
{{jsxref("String.prototype.small()")}} {{deprecated_inline}}
-
{{HTMLElement("small")}}
-
{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}
-
{{HTMLElement("strike")}}
-
{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}
-
{{HTMLElement("sub")}}
-
{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}
-
{{HTMLElement("sup")}}
-
- -

Specifications

- - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
ECMAScript 1st Edition.StandardInitial definition.
{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}{{Spec2('ES6')}} 
- -

Browser compatibility

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

See also

- - diff --git a/files/pl/conflicting/web/javascript/reference/lexical_grammar/index.html b/files/pl/conflicting/web/javascript/reference/lexical_grammar/index.html deleted file mode 100644 index 73526b9a19..0000000000 --- a/files/pl/conflicting/web/javascript/reference/lexical_grammar/index.html +++ /dev/null @@ -1,19 +0,0 @@ ---- -title: Słowa zarezerwowane -slug: conflicting/Web/JavaScript/Reference/Lexical_grammar -tags: - - Dokumentacja_JavaScript - - Dokumentacje - - JavaScript - - Wszystkie_kategorie -translation_of: Web/JavaScript/Reference/Lexical_grammar#Keywords -translation_of_original: Web/JavaScript/Reference/Reserved_Words -original_slug: Web/JavaScript/Referencje/Słowa_zarezerwowane ---- -

 

-

Słowa zarezerwowane nie mogą być używane jako nazwy zmiennych, funkcji, metod ani obiektów języka JavaScript. Niektóre z nich są słowami kluczowymi języka JavaScript, inne zarezerwowano do przyszłych zastosowań.

- -

 

- -

{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Reserved_Words", "es": "es/Referencia_de_JavaScript_1.5/Palabras_Reservadas", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Mots_r\u00e9serv\u00e9s", "ja": "ja/Core_JavaScript_1.5_Reference/Reserved_Words" } ) }}

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ż

- - diff --git a/files/pl/conflicting/web/javascript/reference/operators_1d09774e621bf2431a4f5594a248dd21/index.html b/files/pl/conflicting/web/javascript/reference/operators_1d09774e621bf2431a4f5594a248dd21/index.html deleted file mode 100644 index 1e4414a9b9..0000000000 --- a/files/pl/conflicting/web/javascript/reference/operators_1d09774e621bf2431a4f5594a248dd21/index.html +++ /dev/null @@ -1,37 +0,0 @@ ---- -title: Operatory działające na ciągach znaków -slug: >- - conflicting/Web/JavaScript/Reference/Operators_1d09774e621bf2431a4f5594a248dd21 -tags: - - Dokumentacja_JavaScript - - Dokumentacje - - JavaScript - - Wszystkie_kategorie -translation_of: Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition -translation_of_original: Web/JavaScript/Reference/Operators/String_Operators -original_slug: Web/JavaScript/Referencje/Operatory/Operatory_działające_na_ciągach_znaków ---- -

-

-

Podsumowanie

-

Oprócz operatorów porównania, których można używać z ciągami znaków, dostępny jest także operator konkatenacji (+), łączący dwie wartości tekstowe w jedną, zwracający nowy ciąg znaków stanowiący połączenie swoich operandów. Na przykład "ciąg " + "znaków" zwróci "ciąg znaków". -

Skrócony operator przypisania += może być również używany do konkatenacji ciągów znaków. Na przykład, jeśli zmienna mojtekst zawiera wartość "alfa", wyrażenie mojtekst += "bet" zostanie wyliczone jako "alfabet", a wartość ta zostanie przypisana do zmiennej mojtekst. -

- - - - - - - - - - - - -
Operator
Zaimplementowany w:JavaScript 1.0
Wersja ECMA:ECMA-262
-


-

-
-
-{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Operators/String_Operators", "es": "es/Referencia_de_JavaScript_1.5/Operadores/String", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Op\u00e9rateurs/Op\u00e9rateurs_de_cha\u00eenes" } ) }} diff --git a/files/pl/conflicting/web/javascript/reference/operators_1f6634ff6e3ccef661281d6e50002147/index.html b/files/pl/conflicting/web/javascript/reference/operators_1f6634ff6e3ccef661281d6e50002147/index.html deleted file mode 100644 index 7c0455c3b9..0000000000 --- a/files/pl/conflicting/web/javascript/reference/operators_1f6634ff6e3ccef661281d6e50002147/index.html +++ /dev/null @@ -1,270 +0,0 @@ ---- -title: Operatory arytmetyczne -slug: >- - conflicting/Web/JavaScript/Reference/Operators_1f6634ff6e3ccef661281d6e50002147 -tags: - - JavaScript - - Operator -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators -original_slug: Web/JavaScript/Referencje/Operatory/Operatory_arytmetyczne ---- -
-
{{jsSidebar("Operators")}}
-
- -

Podsumowanie

- -

Operatory arytmetyczne pobierają wartości liczbowe (w postaci bezpośredniej lub zmiennej) jako ich operandy i zwracają jedna, wynikową wartość liczbową. Typowymi operatorami arytmetycznymi są dodawanie (+), odejmowanie (-), mnożenie (*), i dzielenie (/). Operatory te działają tak samo jak w innych językach programowania, z wyjątkiem operatora dzielenia /, który w JavaScripcie zwraca wynik będący liczbą zmiennoprzecinkową, nie obcinając części ułamkowej, jak to się dzieje w C lub Javie.

- -

Dodawanie (+)

- -

Operator dodawania zwraca sume operandów lub jeśli chociaż jeden operand był łańcuchem znaków, ich konkatenacje.

- -

Składnia

- -
Operator: x + y
- -

Przykłady

- -
// Number + Number -> dodawanie
-1 + 2 // 3
-
-// Boolean + Number -> dodawanie
-true + 1 // 2
-
-// Boolean + Boolean -> dodawanie
-false + false // 0
-
-// Number + String -> konkatenacja
-5 + "foo" // "5foo"
-
-// String + Boolean -> konkatenacja
-"foo" + false // "foofalse"
-
-// String + String -> konkatenacja
-"foo" + "bar" // "foobar"
- -

 

- -

Odejmowanie (-)

- -

Operator odejmowania zwraca różnicę między pierwszym, a drugim operandem.

- -

Składnia

- -
Operator: x - y
-
- -

Przykłady

- -
5 - 3 // 2
-3 - 5 // -2
-5 - true // 4
-"foo" - 3 // NaN
- -

 

- -

Dzielenie (/)

- -

Operator dzielenia zwraca iloraz operandów gdzie ten po lewej stronie jest dzielną, a ten po prawej dzielnikiem.

- -

Składnia

- -
Operator: x / y
-
- -

Przykłady

- -
1 / 2      // zwraca 0.5 w JavaScript
-1 / 2      // zwraca 0 w Java
-
-1.0 / 2.0  // zwraca 0.5 zarówno w JavaScript i Java
-
-2.0 / 0    // zwraca Infinity w JavaScript
-2.0 / 0.0  // zwraca także Infinity
-2.0 / -0.0 // zwraca -Infinity in JavaScript
- -

 

- -

Mnożenie (*)

- -

Operotor mnożenia zwraca wynik mnożenia operandów.

- -

Składnia

- -
Operator: x * y
-
- -

Przykłady

- -
2 * 2 // 4
--2 * 2 // -4
-Infinity * 0 // NaN
-Infinity * Infinity // Infinity
-"foo" * 2 // NaN
-
- -

 

- -

Dzielenie modulo (%)

- -

Operator modulo zwraca resztę z dzielenia pierwszego operandu przez drugi.

- -

Składnia

- -
Operator: var1 % var2
-
- -

Przykłady

- -
12 % 5 // 2
--1 % 2 // -1
-NaN % 2 // NaN
-1 % 2 // 1
-2 % 3 // 2
--4 % 2 // -0
-5.5 % 2 // 1.5
- -

 

- -

Potęgowanie (**)

- -
-

Ta eksperymentalna własnośc, jest częścią propozycji specyfikacji ECMAScript 2016 (ES7).
- Ponieważ specyfikacja tej własność i nie została oficjalnie wdrożona, przed użyciem zapoznaj się z tabelą kompatybilności dla różnych przeglądarek. Warto wspomnieć, że składnia jak i zachowanie eksperymentalnych własności mogą zmieniać się wraz ze zmianami w specyfikacji.

-
- -

Operator ten zwraca wynik gdzie pierwszy operand jest podstawą, a drugi wykładnikiem (var1var2). Operator ten jest asocjacyjny co oznacza, że dopuszalne jest użycie w formie a ** b ** c, co jest równe a ** (b ** c).

- -

Składnia

- -
Operator: var1 ** var2
-
- -

Uwagi

- -

W większości języków programowania które posiadają operator potęgowania (zwykle jako ^ lub **) jak np. PHP czy Python, ma on wyższy priorytet niż operatory jedno argumentowe (oznaczające liczbę dodatnią lub ujemną) + czy -, ale istnieją wyjątki. Np. w Bash ten operator posiada niższy priorytet niż wspomniane wcześniej + czy -.
- W JavaScript niemożliwe jest użycie operatorów jedno argumentowych (+/-/~/!/delete/void/typeof)  bezpośrednio przed podstawą.

- -
-2 ** 2;
-// 4 w Bash, -4 w innych językach.
-// W JavaScript jest to nieprawidłowa próba użycia operatora potęgowania.
-
-
--(2 ** 2); // -4
-5 ** -2 // 0.04
-
- -

Przykłady

- -
2 ** 3 // 8
-3 ** 2 // 9
-3 ** 2.5 // 15.588457268119896
-10 ** -1 // 0.1
-NaN ** 2 // NaN
-
-2 ** 3 ** 2 // 512
-2 ** (3 ** 2) // 512
-(2 ** 3) ** 2 // 64
- -

Aby odwrócić znak zwracanej wartości:

- -
-(2 ** 2) // -4
- -

Sposób na wymuszenie potęgowania ujemnej liczby:

- -
(-2) ** 2 // 4
- -

 

- -

Inkrementacja (++)

- -

Operator inkrementacji zwiększa o 1 wartość operandu i zwraca taką wartość. 

- - - -

Składnia

- -
Operator: x++ lub ++x
-
- -

Examples

- -
// Przyrostek
-var x = 3;
-y = x++; // y = 3, x = 4
-
-// Przedrostek
-var a = 2;
-b = ++a; // a = 3, b = 3
- -

 

- -

Dekrementacja (--)

- -

Operator dekrementacji zmniejsza o 1 wartość operandu i zwraca taką wartość.

- - - -

Składnia

- -
Operator: x-- lub --x
-
- -

Przykłady

- -
// Przyrostek
-var x = 3;
-y = x--; // y = 3, x = 2
-
-// Przedrostek
-var a = 2;
-b = --a; // a = 1, b = 1
- -

 

- -

Negacja (-)

- -

Jednoargumentowy operator negacji zwraca wartość operandu ze zmienionym znakiem.

- -

Składnia

- -
Operator: -x
-
- -

Przykłady

- -
var x = 3;
-y = -x; // y = -3, x = 3
- -

 

- -

Jednoargumentowy plus (+)

- -

Jest to jednoargumentowy operator, który transformuje inne typy zmiennych do typu Number. Jeśli dana wartość nie może zostać przetransformowana, zwracany jest typ NaN.

- -

Składnia

- -
Operator: +x
-
- -

Przykłady

- -
+3     // 3
-+"3"   // 3
-+true  // 1
-+false // 0
-+null  // 0
-
-var x = function(val){
- return val
-}
-+x // NaN
-
diff --git a/files/pl/conflicting/web/javascript/reference/operators_5ba63337c20d72b8f8747a954b9b6c94/index.html b/files/pl/conflicting/web/javascript/reference/operators_5ba63337c20d72b8f8747a954b9b6c94/index.html deleted file mode 100644 index 1f8d01472c..0000000000 --- a/files/pl/conflicting/web/javascript/reference/operators_5ba63337c20d72b8f8747a954b9b6c94/index.html +++ /dev/null @@ -1,132 +0,0 @@ ---- -title: Operatory porównania -slug: >- - conflicting/Web/JavaScript/Reference/Operators_5ba63337c20d72b8f8747a954b9b6c94 -tags: - - JavaScript - - Operator -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators -original_slug: Web/JavaScript/Referencje/Operatory/Operatory_porównania ---- -
{{jsSidebar("Operators")}}
- -

Podsumowanie

- -

Operandy posiadają wartość liczbową lub łańcucha znaków. Łańcuchy znaków są porównywane w oparciu o zasady pisowni, używają wartości Unicode.

- -

Jako rezultat porównania zwracana jest wartość logiczna.

- - - -

Następująca tabela opisuje operatory porównania:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
OperatorOpisPrzykłady zwracające prawdę (true)1
Równy (==)Zwraca true jeżeli operandy są równe. Jeżeli operandy nie są tego samego typu, JavaScript próbuje przekształcić operandy na odpowiedni dla porównania typ. -

3 == var1
- "3" == var1
- 3 == '3'

-
Różny (!=)Zwraca true jeżeli operandy są różne. Jeżeli dwa operandy nie są tego samego typu, JavaScript próbuje przekształcić operandy na odpowiedni dla porównania typ. -

var1 != 4
- var1 != "3"

-
Identyczny (===)Zwraca true jeżeli operandy są równe i tego samego typu. -

3 === var1

-
Nieidentyczny (!==)Zwraca true jeżeli operandy nie są równe i/lub nie są tego samego typu. -

var1 !== 3
- 3 !== '3'

-
Większy niż (>)Zwraca true jeżeli lewy operand jest większy od prawego operandu. -

var2 > var1

-
Większy - równy (>=)Zwraca true jeżeli lewy operand jest większy lub równy prawemu operandowi. -

var2 >= var1
- var1 >= 3

-
Mniejszy niż (<)Zwraca true, jeśli lewy operand jest mniejszy, niż prawy. -

var1 < var2

-
Mniejszy - równy (<=)Zwraca true jeżeli lewy operand jest mniejszy lub równy prawemu operandowi. -

var1 <= var2
- var2 <= 5

-
- -

1 Te przykłady zakładają, że var1 będzie przydzielona wartość 3 i var2 będzie miała przydzieloną wartość 4.

- -

Używanie operatorów porównania

- -

Standardowe operatory(== i !=) porównują dwa operandy bez względu na ich typ. Operatory porównania identyczności(=== i !==) dokonują porównania równości na operandach tego samego typu. Operatorów identyczności używamy jeżeli operandy muszą być określonego typu jak również wartości lub jeśli dokładny typ operandów jest ważny. W przeciwnym razie, używamy standardowych operatorów porównania, które pozwalają na porównać identyczność dwóch operandów nawet jeżeli nie są takiego samego typu.

- -

Kiedy potrzebna jest konwersja, JavaScript następująco przekształca operand Number, Boolean lub Object.

- - - -

You cannot use the standard equality operator (==) to compare instances of JSObject. Use the JSObject.equals method for such comparisons.

- -

Kompatybilność wsteczna

- -

Zachowanie standardowych operatorów porównania (== i !=) zależy od wersji JavaScript.

- -

JavaScript 1.3 i wersje wcześniejsze

- -

You can use either the standard equality operator (==) or JSObject.equals to compare instances of JSObject.

- -

JavaScript 1.2

- -

The standard equality operators (== and !=) do not perform a type conversion before the comparison is made. Operatory identyczności (=== i !==) są niedostępne.

- -

JavaScript 1.1 i wersje wcześniejsze

- -

The standard equality operators (== and !=) perform a type conversion before the comparison is made.Operatory identyczności (=== i !==) są niedostępne.

diff --git a/files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html b/files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html deleted file mode 100644 index 3e1a60bdb4..0000000000 --- a/files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html +++ /dev/null @@ -1,256 +0,0 @@ ---- -title: Operatory logiczne -slug: >- - conflicting/Web/JavaScript/Reference/Operators_8afb1abf2138289c890ee09e799ff26e -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators -original_slug: Web/JavaScript/Referencje/Operatory/Logical_Operators ---- -
{{jsSidebar("Operators")}}
- -
Operatory logiczne są zazwyczaj używane z wartościami typu {{jsxref("Boolean")}} (logicznymi) – wówczas zwracają również wartość typu logicznego. Jednakże operatory && i || w istocie zwracają wartość jednego z podanych operandów, więc jeśli operatory te są używane z wartościami nie-boolowskimi, wtedy mogą również zwracać nie-boolowskie wartości.
- -
- -
{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}
- - - -

Opis

- -

Operatory logiczne są opisane w poniższej tabeli:

- - - - - - - - - - - - - - - - - - - - - - - - -
OperatorUżycieOpis
Logiczne AND (&&)expr1 && expr2Zwraca expr1 jeśli wartość ta może być przekonwertowana na false, w przeciwnym razie zwraca expr2. Zatem, używany z wartościami typu logicznego, operator && zwraca true jeśli obydwa operandy mają wartość true, w przeciwnym razie zwraca false.
Logiczne OR (||)expr1 || expr2Zwraca expr1, jeśli wartość ta może być przekonwertowana na true; w przeciwnym razie zwraca expr2. Tak więc, używany z wartościami typu logicznego, operator || zwraca true którykolwiek z operandów równy jest true.
Logiczne NOT (!)!exprZwraca false jeśli jego operand można przekonwertować na true; w przeciwnym razie zwraca true.
- -

Jeśli dana wartość może być przekonwertowana na true, wówczas jest to tzw. wartość {{Glossary("truthy")}}. Jeśli dana wartość może być przekonwertowana na false, jest to tzw. wartość {{Glossary("falsy")}}.

- -

Przykładami wyrażeń, które mogą być przekonwertowane na false są:

- - - -

Mimo tego, że operatory && i || mogą być używane z wartościami nie-boolowskimi, nadal mogą być uznane za operatory boolowskie (logiczne), gdyż zwracane przez nie wartości mogą być zawsze przekonwertowane na wartości logiczne.

- -

Ewaluacja short-circuit

- -

Ponieważ wyrażenia logiczne są przetwarzane od lewej do prawej, sprawdzana jest najkrótsza możliwa ścieżka, pozwalająca na zwrócenie wyniku całego wyrażenia (tzw. short-circuit evaluation), zgodnie z następującymi zasadami:

- - - -

Zasady logiki gwarantują, że powyższe ewaluacje są zawsze poprawne. Zauważ, że części wyrażeń oznaczone słowem cokolwiek nie są ewaluowane, więc nie pojawią się żadne efekty uboczne. Zauważ też, że część cokolwiek powyższych wyrażeń może być dowolnym pojedynczym wyrażeniem logicznym (co wskazano przez nawiasy).

- -

Dla przykładu, poniższe dwie funkcje są równoważne.

- -
function shortCircuitEvaluation() {
-  // logiczne OR (||)
-  doSomething() || doSomethingElse();
-
-  // logiczne AND (&&)
-  doSomething() && doSomethingElse();
-}
-
-function equivalentEvaluation() {
-
-  // logiczne OR (||)
-  var orFlag = doSomething();
-  if (!orFlag) {
-    doSomethingElse();
-  }
-
-
-  // logiczne AND (&&)
-  var andFlag = doSomething();
-  if (andFlag) {
-    doSomethingElse();
-  }
-}
-
- -

Poniższe wyrażenia nie są jednak równoważne ze względu na pierwszeństwo operatorów, co podkreśla, jak ważne jest, by operator po prawej stronie był pojedynczym wyrażeniem (zgrupowanym w razie potrzeby przy pomocy nawiasów).

- -
false && true  || true      // zwraca true
-false && (true || true)     // zwraca false
- -

Logiczne AND (&&)

- -

Poniżej pokazane są przykłady użycia operatora && (logicznego AND).

- -
a1 = true  && true       // t && t zwraca true
-a2 = true  && false      // t && f zwraca false
-a3 = false && true       // f && t zwraca false
-a4 = false && (3 == 4)   // f && f zwraca false
-a5 = 'Cat' && 'Dog'      // t && t zwraca "Dog"
-a6 = false && 'Cat'      // f && t zwraca false
-a7 = 'Cat' && false      // t && f zwraca false
-a8 = ''    && false      // f && f zwraca ""
-a9 = false && ''         // f && f zwraca false
-
- -

Logiczne OR (||)

- -

Poniżej pokazane są przykłady użycia operatora || (logicznego OR).

- -
o1 = true  || true       // t || t zwraca true
-o2 = false || true       // f || t zwraca true
-o3 = true  || false      // t || f zwraca true
-o4 = false || (3 == 4)   // f || f zwraca false
-o5 = 'Cat' || 'Dog'      // t || t zwraca "Cat"
-o6 = false || 'Cat'      // f || t zwraca "Cat"
-o7 = 'Cat' || false      // t || f zwraca "Cat"
-o8 = ''    || false      // f || f zwraca false
-o9 = false || ''         // f || f zwraca ""
-
- -

Logiczne NOT (!)

- -

Poniżej pokazane są przykłady użycia operatora ! (logicznego NOT).

- -
n1 = !true               // !t zwraca false
-n2 = !false              // !f zwraca true
-n3 = !'Cat'              // !t zwraca false
-
- -

Podwójne NOT (!!)

- -

Jest możliwe użycie kilku operatorów NOT naraz, by wprost wymusić konwersję dowolnej wartości do odpowiedniej wartości boolowskiej. Konwersja bazuje na „prawdziwości” lub „fałszywości” wartości (zobacz {{Glossary("truthy")}} i {{Glossary("falsy")}}).

- -

Taka sama konwersja może być dokonana poprzez funkcję {{jsxref("Boolean")}}.

- -
n1 = !!true                   // !!prawda zwraca true
-n2 = !!{}                     // !!prawda returns true: każdy obiekt jest "prawdą"...
-n3 = !!(new Boolean(false))   // ...nawet obiekty booloweskie z false jako wartością .valueOf()!
-n4 = !!false                  // !!fałsz zwraca false
-n5 = !!""                     // !!fałsz zwraca false
-n6 = !!Boolean(false)         // !!fałsz zwraca false
- -

Zasady przekształcania wyrażeń

- -

Przekształcanie AND na OR

- -

Poniższa operacja na wartościach logicznych:

- -
bCondition1 && bCondition2
- -

jest zawsze równa:

- -
!(!bCondition1 || !bCondition2)
- -

Przekształcanie OR na AND

- -

Poniższa operacja na wartościach logicznych:

- -
bCondition1 || bCondition2
- -

jest zawsze równa:

- -
!(!bCondition1 && !bCondition2)
- -

Przekształcanie NOT

- -

Poniższa operacja na wartościach logicznych:

- -
!!bCondition
- -

jest zawsze równa:

- -
bCondition
- -

Usuwanie zagnieżdżonych wyrażeń z nawiasami

- -

Jako że wyrażenia logiczne są ewaluowane od lewej do prawej, jest zawsze możliwe usunięcie nawiasów ze złożonego wyrażenia przy użyciu pewnych, przedstawionych dalej, reguł.

- -

Usuwanie zagnieżdżonego AND

- -

Następujące wyrażenie złożone na wartościach logicznych:

- -
bCondition1 || (bCondition2 && bCondition3)
- -

jest zawsze równe:

- -
bCondition1 || bCondition2 && bCondition3
- -

Usuwanie zagnieżdżonego OR

- -

Następujące wyrażenie złożone na wartościach logicznych:

- -
bCondition1 && (bCondition2 || bCondition3)
- -

jest zawsze równe:

- -
!(!bCondition1 || !bCondition2 && !bCondition3)
- -

Specyfikacje

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecyfikacjaStatusUwagi
{{SpecName('ES1')}}{{Spec2('ES1')}}Definicja początkowa.
{{SpecName('ES5.1', '#sec-11.11')}}{{Spec2('ES5.1')}}Zdefiniowane w kilku sekcjach specyfikacji: Logical NOT Operator, Binary Logical Operators
{{SpecName('ES6', '#sec-binary-logical-operators')}}{{Spec2('ES6')}}Zdefiniowane w kilku sekcjach specyfikacji: Logical NOT Operator, Binary Logical Operators
{{SpecName('ESDraft', '#sec-binary-logical-operators')}}{{Spec2('ESDraft')}}Zdefiniowane w kilku sekcjach specyfikacji: Logical NOT Operator, Binary Logical Operators
- -

Wsparcie przeglądarek

- - - -

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

- -

Zobacz też

- - diff --git a/files/pl/conflicting/web/javascript/reference/operators_de3666cd349851054926d5e52fced70d/index.html b/files/pl/conflicting/web/javascript/reference/operators_de3666cd349851054926d5e52fced70d/index.html deleted file mode 100644 index 86a341668a..0000000000 --- a/files/pl/conflicting/web/javascript/reference/operators_de3666cd349851054926d5e52fced70d/index.html +++ /dev/null @@ -1,77 +0,0 @@ ---- -title: Operatory przypisania -slug: >- - conflicting/Web/JavaScript/Reference/Operators_de3666cd349851054926d5e52fced70d -tags: - - JavaScript - - Operator -translation_of: Web/JavaScript/Reference/Operators#Assignment_operators -translation_of_original: Web/JavaScript/Reference/Operators/Assignment_Operators -original_slug: Web/JavaScript/Referencje/Operatory/Operatory_przypisania ---- -
{{jsSidebar("Operators")}}
- -

Podsumowanie

- -

Operator przypisania przypisuje wartość swego prawego operandu do operandu lewego.

- -

Podstawowy operator przypisania to znak równości (=), który przypisuje wartość prawego operandu do lewego. To znaczy, że x = y przypisuje wartość zmiennej y do zmiennej x. Pozostałe operatory przypisania to zwykle skróty dla operacji standardowych, jak w poniższej tabeli.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Operator skróconyZnaczenie
x += yx = x + y
x -= yx = x - y
x *= yx = x * y
x /= yx = x / y
x %= yx = x % y
x <<= yx = x << y
x >>= yx = x >> y
x >>>= yx = x >>> y
x &= yx = x & y
x ^= yx = x ^ y
x |= yx = x | y
- -

-

 
-

- -

 

diff --git a/files/pl/conflicting/web/javascript/reference/statements/switch/index.html b/files/pl/conflicting/web/javascript/reference/statements/switch/index.html deleted file mode 100644 index 0563be20c9..0000000000 --- a/files/pl/conflicting/web/javascript/reference/statements/switch/index.html +++ /dev/null @@ -1,122 +0,0 @@ ---- -title: default -slug: conflicting/Web/JavaScript/Reference/Statements/switch -tags: - - JavaScript - - słowo kluczowe -translation_of: Web/JavaScript/Reference/Statements/switch -translation_of_original: Web/JavaScript/Reference/Statements/default -original_slug: Web/JavaScript/Referencje/Polecenia/default ---- -
{{jsSidebar("Statements")}}
- -

Słowo kluczowe default  może być użyte w języku JavaScript w dwóch sytuacjach: w instrukcji {{jsxref("Statements/switch", "switch")}} lub instrukcji {{jsxref("Statements/export", "export")}}.

- -
{{EmbedInteractiveExample("pages/js/statement-default.html")}}
- - - -

Składnia

- -

W instrukcji {{jsxref("Statements/switch", "switch")}}:

- -
switch (wyrażenie) {
-  case wartość1:
-    //Instrukcje wykonywane kiedy wartość1 zgadza się z wartością wyrażenia
-    [break;]
-  default:
-    //Instrukcje wykonywane kiedy żadna z wartości nie zgadza się z wartością wyrażenia
-    [break;]
-}
- -

Z instrukcją {{jsxref("Statements/export", "export")}}:

- -
export default nazwaN
- -

Opis

- -

Po więcej szczegółów zobacz strony instrukcji

- - - -

Przykłady

- -

Użycie default w instrukcji switch

- -

W poniższym przykładzie, jeśli expr przyjmie wartość "Pomarańcze" lub "Jabłka", program dopasuje tę wartość odpowiednio do przypadków (case) "Pomarańcze" i "Jabłka" oraz wykona odpowiednie instrukcje. Słowo kluczowe default zostanie użyte w każdym innym przypadku i pozwoli na wykonanie odpowiedających mu instrukcji.

- -
switch (expr) {
-  case 'Pomarańcze':
-    console.log('Pomarańcze kosztują 3.29 zł za kilogram.');
-    break;
-  case 'Jabłka':
-    console.log('Jabłka kosztują 1.59 zł za kilogram.');
-    break;
-  default:
-    console.log('Przepraszamy, ' + expr + ' niestety się skończyły.');
-}
- -

Użycie default z export

- -

Jeśli chcesz wyeksportować pojednynczą wartość lub potrzebujesz tzw. fallback value dla modułu, może szostać zastosowany domyślny eksport (default export)

- -
// module "my-module.js"
-let cube = function cube(x) {
-  return x * x * x;
-};
-export default cube;
- -

Wtedy, w innym skrypcie, domyślnie wyeksportowana wartość będzie bezpośrednio zaimportowana:

- -
// module "another-module.js"
-import cube from 'my-module';  //"default export" pozwala na napisanie "import cube", zamiast "import cube from 'my-module'"
-console.log(cube(3)); // 27
-
- -

Specyfikacje

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecyfikacjaStatusKomentarz
{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}{{Spec2('ES6')}} 
{{SpecName('ES6', '#sec-exports', 'Exports')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}{{Spec2('ESDraft')}} 
{{SpecName('ESDraft', '#sec-exports', 'Exports')}}{{Spec2('ESDraft')}} 
- -

Wsparcie przeglądarek

- - - -

{{Compat("javascript.statements.default")}}

- -

Zobacz też

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