From de5c456ebded0e038adbf23db34cc290c8829180 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:49:24 +0100 Subject: unslug pl: move --- .../control_flow_and_error_handling/index.html | 42 + .../index.html | 24 + .../index.html | 90 +++ .../index.html | 27 + .../guide/details_of_the_object_model/index.html | 73 ++ .../guide/expressions_and_operators/index.html | 18 + .../index.html | 73 ++ .../index.html | 74 ++ .../index.html | 49 ++ .../index.html | 228 ++++++ .../index.html | 23 + .../web/javascript/guide/functions/index.html | 62 ++ .../index.html | 27 + .../index.html | 25 + .../index.html | 46 ++ .../index.html | 28 + .../index.html | 30 + .../index.html | 21 + .../index.html | 29 + .../index.html | 24 + .../javascript/guide/grammar_and_types/index.html | 208 +++++ .../index.html | 111 +++ .../index.html | 64 ++ .../index.html | 47 ++ .../index.html | 30 + .../pl/conflicting/web/javascript/guide/index.html | 11 + .../web/javascript/guide/introduction/index.html | 139 ++++ .../index.html | 25 + .../index.html | 876 +++++++++++++++++++++ .../reference/global_objects/boolean/index.html | 49 ++ .../reference/global_objects/date/index.html | 19 + .../index.html | 116 +++ .../reference/global_objects/error/index.html | 114 +++ .../reference/global_objects/number/index.html | 23 + .../reference/global_objects/object/index.html | 219 ++++++ .../reference/global_objects/rangeerror/index.html | 124 +++ .../reference/global_objects/regexp/index.html | 54 ++ .../reference/global_objects/string/index.html | 221 ++++++ .../reference/lexical_grammar/index.html | 18 + .../web/javascript/reference/operators/index.html | 559 +++++++++++++ .../reference/operators/spread_syntax/index.html | 230 ++++++ .../index.html | 35 + .../index.html | 268 +++++++ .../index.html | 130 +++ .../index.html | 254 ++++++ .../index.html | 75 ++ .../reference/statements/switch/index.html | 121 +++ 47 files changed, 5153 insertions(+) create mode 100644 files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_1a7d2f7d8b159dce08254c88948bc74a/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_8f58cc44e17308f295c610e8acad2d99/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_b955d4d09ed7fa71268639ed589f8702/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/details_of_the_object_model/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/expressions_and_operators/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/expressions_and_operators_173cc0f9e32f34b0483b45a29fa462e4/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/expressions_and_operators_510ae1f584cbdb5ca760b545f90c72ed/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/expressions_and_operators_605f6491d97a62449200a9401cba82c7/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/expressions_and_operators_a3ce80967ffc4f60314caa4b05ec9c47/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/expressions_and_operators_c278b67ddd602343b8c21711abc1b17c/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/functions/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/functions_14ccabf533660cb9d0794a5a93287159/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/functions_2af756c37808c2f8e09add6cc9618178/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/functions_403e991db3105a03e0afc1a3cc821a01/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/functions_74f4afa40d626fed3cf9277e30d6d211/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/functions_8b84da88e673c0774c4f504a9be67268/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/functions_90ea47f6d07003af2efc0a1756da41e2/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/functions_915be6bbaf2578afefb6927c899d5f3d/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/functions_b0ff3e89089de1f0a22029bbde807073/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/grammar_and_types/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/grammar_and_types_0f7acbcd2fa8bfb327628638da4e5166/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/grammar_and_types_14ae50e0032f9c0db4fe484288797da6/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/grammar_and_types_1d6d13b355b9483ad46cf81082b7c261/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/grammar_and_types_d86447bbdab858af0abf9b17c9ec9dc9/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/index.html create mode 100644 files/pl/conflicting/web/javascript/guide/introduction/index.html create mode 100644 files/pl/conflicting/web/javascript/guide_1093f218406d2d64ec91bb7a6bda93ce/index.html create mode 100644 files/pl/conflicting/web/javascript/guide_a026fc5d05de582c88d39cf9fd37870d/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/boolean/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/date/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/date_73c046d653c590f4914731d078f3b2c5/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/error/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/number/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/object/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/rangeerror/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/regexp/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/global_objects/string/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/lexical_grammar/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/operators/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/operators/spread_syntax/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/operators_1d09774e621bf2431a4f5594a248dd21/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/operators_1f6634ff6e3ccef661281d6e50002147/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/operators_5ba63337c20d72b8f8747a954b9b6c94/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/operators_de3666cd349851054926d5e52fced70d/index.html create mode 100644 files/pl/conflicting/web/javascript/reference/statements/switch/index.html (limited to 'files/pl/conflicting/web/javascript') diff --git a/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling/index.html b/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling/index.html new file mode 100644 index 0000000000..c1da46484b --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling/index.html @@ -0,0 +1,42 @@ +--- +title: Blok instrukcji +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Blok_instrukcji +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Block_Statement +--- +

+

+

Blok instrukcji

+

Blok instrukcji jest użyty do grupowania instrukcji. Blok zawarty jest w klamrach: +

+
{
+   instrukcja_1
+   instrukcja_2
+   .
+   .
+   .
+   instrukcja_n
+}
+
+

Przykład
+Blok instrukcji są zazwyczaj używane z instrukcją kontrolną (np. if, for, while). +

+
while (x < 10) {
+   x++;
+}
+
+

Tutaj, { x++; } jest blokiem instrukcji. +

Ważne: JavaScript nie ma zakresu blokowego. Zmienne przedstawione z blokiem są zakresem stanowiącym zawartość funkcji i skryptu, efektem ustawień ich i trwania ponad własny blok. Nie chcesz używać bloków "samodzielnych/wolnostojących" w JavaScript, ponieważ one nie robią tego co myślisz, że robią, jeśli myślisz, że robią cokolwiek tak jak bloki w C lub Javie. Na przykład: +

+
var x = 1;
+{
+   var x = 2;
+}
+alert(x); // wyświetli wartość drugiej zmiennej 2
+
+

Zostanie wyświetlona wartość drugiej zmiennej ponieważ instrukcja var x wewnątrz warunku posiada ten sam zakres co instrukcja var x przed instrukcją warunkową. W C lub Java, równoważny kod miałby wartość pierwszej zmiennej. +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Block_Statement", "fr": "fr/Guide_JavaScript_1.5/D\u00e9claration_de_blocs", "ja": "ja/Core_JavaScript_1.5_Guide/Block_Statement" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_1a7d2f7d8b159dce08254c88948bc74a/index.html b/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_1a7d2f7d8b159dce08254c88948bc74a/index.html new file mode 100644 index 0000000000..94a07dc3f0 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_1a7d2f7d8b159dce08254c88948bc74a/index.html @@ -0,0 +1,24 @@ +--- +title: Instrukcje pętli +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Loop_Statements +--- +

+

+

Instrukcje pętli

+

Pętle są to specjalnie ustawione polecenia, które wykonują wielokrotnie kod, aż do spotkania specyficznych wartości. JavaScript wspiera instrukcję pętli for, do while, i while, albo well albo label (etykieta nie instrukcją pętli, ale jest często użyta z tą instrukcjami). Uzupełniając, możesz użyć instrukcji break i continue wewnątrz instrukcji pętli.

Następna instrukcja, for...in, wykonuje wielokrotnie ale jest użyta do manipulacji obiektem. Zobacz Instrukcje manipulacji obiektem. +

Instrukcjami pętli są:
+

+ +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Loop_Statements", "es": "es/Gu\u00eda_JavaScript_1.5/Sentencias_de_bucle", "fr": "fr/Guide_JavaScript_1.5/Boucles", "ja": "ja/Core_JavaScript_1.5_Guide/Loop_Statements" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_8f58cc44e17308f295c610e8acad2d99/index.html b/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_8f58cc44e17308f295c610e8acad2d99/index.html new file mode 100644 index 0000000000..ce106856b6 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_8f58cc44e17308f295c610e8acad2d99/index.html @@ -0,0 +1,90 @@ +--- +title: Instrukcje warunkowe +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_warunkowe +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Conditional_Statements +--- +

+

+

Instrukcja warunkowa

+

Instrukcja warunkowa jest zestawem poleceń wykonywanych, jeżeli dany warunek jest spełniony JavaScript obsługuje dwie instrukcje warunkowe:if...else i switch. +

+

Instrukcja if...else

+

Instrukcja if powoduje wykonanie kodu źródłowego instrukcja1 tylko wtedy, gdy warunek logiczny jest spełniony. Jeżeli zostanie użyty poszerzony wariant instrukcji if, to po spełnieniu warunku zostanie wykonany kod instrukcja1 lecz w przeciwnym wypadku zostanie wykonany kod instrukcja2. Instrukcja if ma postać: +

+
if (warunek) {
+   instrukcja1
+}
+[else {
+   instrukcja2
+} ]
+
+

Jakiekolwiek wyrażenie w JavaScript może mieć warunek, który jest oceniany czy jest on prawdziwy lub fałszywy. Instrukcja wykonuje jakąkolwiek instrukcję zawartą w JavaScript, włączając pomoc zagnieżdżonym instrukcjom if. Jeśli chcesz użyć więcej niż po instrukcji if lub instrukcji else musisz otoczyć instrukcję nawiasami klamrowymi, {}. +

Nie powinieneś używać prostych zadań używając instrukcji warunkowej. Na przykład, nie używaj następującego kodu:

+
if(x = y)
+{
+   /* coś jest wykonywane */
+}
+
+

Jeśli potrzebujesz użyć instrukcji warunkowej, aby wykonać zadanie, wstaw dodatkowy nawias wokół zadania. Na przykład, użyj if( (x = y) ). +

Nie pomieszaj wartości prymitywnej logicznej true i false z true i false wartości logicznej obiektu. Jakikolwiek obiekt, którego wartość nie jest zidentyfikowana, null, zero, NaN, lub pusty łańcuch znaków, włączając obiekt logiczny, którego wartość jest fałszem staje się prawdziwy, kiedy przechodzi w instrukcję warunkową. Na przykład: +

+
var b = new Boolean(false);
+if (b) // ten warunek jest prawdziwy
+
+

Przykład
+Następujący przykład funkcji checkData zwraca true i numer czcionki w obiekcie Text są trzy; W drugą stronę, to wyświetli alert ostrzegawczy i zwróci Ci false. +

+
function checkData () {
+   if (document.form1.threeChar.value.length == 3) {
+      return true
+   } else {
+      alert("Enter exactly three characters. " +
+      document.form1.threeChar.value + " is not valid.")
+      return false
+   }
+}
+
+

Instrukcja switch

+

Instrukcja switch pozwala programowi na sprawdzenie ciągu warunków i próbuje wykonać wartość wyrażenia przypisana do odpowiedniej etykiety case. Jeśli jest to wyrażenie znalezione, program wykonuje załączoną instrukcję. Instrukcja switch wygląda w następujący sposób: +

+
switch (expression){
+   case label :
+      statement;
+      break;
+   case label :
+      statement;
+      break;
+   ...
+   default : statement;
+}
+
+

Najpierw program szuka etykietę odpowiedniego wyrażenia i wykonuje załączoną instrukcję. Jeśli znaleziona zostaje nie odpowiednia etykieta, program szuka domyślnej instrukcji i jeśli znajdzie wykonuje załączoną instrukcję. Jeśli nie domyślna instrukcja jest znaleziona, program kontynuuje wykonywanie instrukcji aż do końca instrukcji switch. +

Opcjonalnie instrukcja break połączona z każdą etykietą case zapewnia przerwanie programu z całego bloku switch odpowiednio raz jak jest wykonana instrukcja i kontynuuje wykonywanie następnej instrukcji switch. Jeśli opuszcza break, program kontynuuje wykonywanie aż do następnej instrukcji w switch. +

Przykład
+W następującym przykładzie, jeśli expr sprawdza "Bananas", program szuka odpowiednią wartość z case "Bananas" i wykonuje załączoną instrukcję. Kiedy napotka break, progaram przerywa switch. Jeśli break zostało opuszczone, instrukcja zostanie wykonana dla case "Cherries". +

+
switch (expr) {
+   case "Oranges" :
+      document.write("Oranges are $0.59 a pound.<BR>");
+      break;
+   case "Apples" :
+      document.write("Apples are $0.32 a pound.<BR>");
+      break;
+   case "Bananas" :
+      document.write("Bananas are $0.48 a pound.<BR>");
+      break;
+   case "Cherries" :
+      document.write("Cherries are $3.00 a pound.<BR>");
+      break;
+   default :
+      document.write("Sorry, we are out of " + i + ".<BR>");
+}
+
+document.write("Is there anything else you'd like?<BR>");
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Conditional_Statements", "fr": "fr/Guide_JavaScript_1.5/Instructions_conditionnelles", "ja": "ja/Core_JavaScript_1.5_Guide/Conditional_Statements" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_b955d4d09ed7fa71268639ed589f8702/index.html b/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_b955d4d09ed7fa71268639ed589f8702/index.html new file mode 100644 index 0000000000..b19c7ddd3f --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/control_flow_and_error_handling_b955d4d09ed7fa71268639ed589f8702/index.html @@ -0,0 +1,27 @@ +--- +title: Instrukcje komentarzy +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_komentarzy +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Comments +--- +

+

+

Komentarze

+

komentarze są notatkami autora, które wyjaśniają co znaczy dany kawałek kodu. Komentarze nie są wczytywane przez przeglądarkę. W JavaScript mamy ten sam styl komentarzy co w Java i C++: +

+ +

Przykład
+Następujący kod pokazuje komentarze: +

+
// To jest pojedyńczy komentarz.
+
+/* To jest komentarz blokowy. Może być dowolnej długości i wstwiać go możemy w
+każdym miejscu, gdzie tylko będziemy chcieli. */
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Comments", "es": "es/Gu\u00eda_JavaScript_1.5/Sentencias_para_comentarios", "fr": "fr/Guide_JavaScript_1.5/Commentaires", "ja": "ja/Core_JavaScript_1.5_Guide/Comments" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/details_of_the_object_model/index.html b/files/pl/conflicting/web/javascript/guide/details_of_the_object_model/index.html new file mode 100644 index 0000000000..493a6b4156 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/details_of_the_object_model/index.html @@ -0,0 +1,73 @@ +--- +title: Wartości lokalne vs. dziedziczone +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Powrót_dziedziczenia_własności/Wartości_lokalne_vs._dziedziczone +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/Local_versus_Inherited_Values +--- +

+

+

Wartości lokalne vs. dziedziczone

+

Gdy korzystasz z dostępu do własności obiektu, JavaScript wykonuje następujące kroki, tak jak opisano w poprzednim rozdziale: +

+
  1. Sprawdza czy wartość istnieje lokalnie. Jeśli tak, to zwraca tę wartość. +
  2. Jeśli wartość lokalna nie istnieje, sprawdza łańcuch prototypu (używając własności __proto__). +
  3. Jeśli obiekt w łańcuchu prototypu posiada wartość dla określonej wartości, zwraca tę wartość. +
  4. Jeśli własność ta nie została odnaleziona, to obiekt nie posiada tej własności. +
+

Rezultat tych kroków zależy od sposobu, w jaki definiujesz rzeczy w kodzie. Oyginalny przykład używał następujących definicji: +

+
function Employee () {
+this.name = "";
+this.dept = "general";
+}
+
+function WorkerBee () {
+this.projects = [];
+}
+WorkerBee.prototype = new Employee;
+
+

Przypuśćmy, że wraz z tymi definicjami utworzyłeś amy jako instancję WorkerBee za pomocą poniższej instrukcji: +

+
amy = new WorkerBee;
+
+

Obiekt amy posiada jedną lokalną własność, projects. Wartości własności name i dept nie są lokalne dla amy i dlatego są pobrane z własności __proto__ obiektu amy. W ten sposób amy posiada następujące wartości własności: +

+
amy.name == "";
+amy.dept = "general";
+amy.projects == [];
+
+

Teraz przypuśćmy, że zmienisz wartość własności name w prototypie powiązanym z Employee: +

+
Employee.prototype.name = "Unknown"
+
+

Na pierwszy rzut oka może Ci sie wydawać, że nowa wartość zostanie przekazana dalej do wszystkich instancji Employee. Nie dzieje się tak. +

Gdy tworzysz dowolną instancję obiektu Employee, instancja ta otrzymuje lokalną wartość dla własności name (pusty ciąg znaków). Oznacza to, że gdy ustawisz prototyp WorkerBee poprzez utworzenie nowego obiektu Employee, WorkerBee.prototype posiada lokalną wartość dla własności name. Dlatego więc, gdy JavaScript sprawdza własność name obiektu amy (instancji WorkerBee), JavaScript znajduje lokalną wartość dla tej własności w WorkerBee.prototype. Dlatego też nie sprawdza on łańcucha dalej aż do Employee.prototype. +

Jeśli chcesz zmienić wartość własności obiektu w momencie uruchomienia i sprawić, by była ona dziedziczona przez wszystkich potomków obiektu, nie możesz zdefiniować własności w funkcji konstruktora obiektu. Zamiast tego dodaj ją do prototypu powiązanego z konstruktorem. Na przykład, zakładając zmianę poprzedniego kodu na poniższy: +

+
function Employee () {
+   this.dept = "general";
+}
+Employee.prototype.name = "";
+
+function WorkerBee () {
+this.projects = [];
+}
+WorkerBee.prototype = new Employee;
+
+amy = new WorkerBee;
+
+Employee.prototype.name = "Unknown";
+
+

W tym wypadku własność name obiektu amy przyjmuje wartość "Unknown". +

Jak pokazuję powyższe przykłady, jeśli chcesz zachować domyślne wartości dla własności obiektu i móc zmienić domyślne wartości w momencie uruchomienia, powinieneś utworzyć własności w prototypie konstruktora, a nie w samej funkcji konstruktora. +{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Powrót dziedziczenia własności", "Przewodnik po języku JavaScript 1.5:Powrót dziedziczenia własności:Określanie wzajemnych relacji obiektu") }} +

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Local_versus_Inherited_Values", "es": "es/Gu\u00eda_JavaScript_1.5/M\u00e1s_sobre_la_herencia_de_propiedades/Valores_locales_frente_a_los_heredados", "ja": "ja/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Local_versus_Inherited_Values" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/expressions_and_operators/index.html b/files/pl/conflicting/web/javascript/guide/expressions_and_operators/index.html new file mode 100644 index 0000000000..1df22570cf --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/expressions_and_operators/index.html @@ -0,0 +1,18 @@ +--- +title: Operacje na łańcuchach +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operacje_na_łańcuchach +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/String_Operators +--- +

+

+

Operatory łańcuchowe

+

Oprócz operatorów porównania łańcuchów istnieje operator konkatenacji (+), który konkatenuje dwa łańcuchy zwracając łańcuch będący połączeniem obu argumentów. Na przykład "my " + "string" zwraca łańcuch znaków "my string". +

Skróconego operatora += też można używać do konkatenacji łańcuchów. Na przykład jeśli zmienna mystring ma wartość "alpha", to wyrażenie mystring += "bet" przyjmuje wartość "alphabet" i wartość ta jest nadawana zmiennej mystring. +

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operatory logiczne", "Przewodnik po języku JavaScript 1.5:Operatory:Operatory specjalne") }} +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/String_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_de_cadenas_de_caracteres_(string)", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_li\u00e9s_aux_cha\u00eenes", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/String_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/String_Operators" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/expressions_and_operators_173cc0f9e32f34b0483b45a29fa462e4/index.html b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_173cc0f9e32f34b0483b45a29fa462e4/index.html new file mode 100644 index 0000000000..8b6b2c3751 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_173cc0f9e32f34b0483b45a29fa462e4/index.html @@ -0,0 +1,73 @@ +--- +title: Operatory logiczne +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_logiczne +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Logical_Operators +--- +

+

+

Operatory logiczne

+

Operatory logiczne są typem użytym z wartością Boolean (logiczną); zwracają one wartość logiczną (true lub false). Jednakże, operatory && i || aktualnie zwracają wartość jednego ze określonych argumentów, więc jeśli któryś z tych operatorów jest użyty z wartością nielogiczną, to zwróci wartość nie-logiczną. Operatory logiczne są opisane w następującej tablicy. +

+ + + + + + + + + + + + + + + + + + + + + +
OperatoryUżycieOpis
&&expr1 && expr2(Iloczyn logiczny AND) Zwraca expr1, jeśli jest konwertowany do false; w innym przypadku, zwraca expr2. Tak więc, kiedy użyjemy wartość logiczną, && zwróci true jeśli oba argumenty są true; w innym przypadku, zwróci false.
||expr1 || expr2(Suma logiczna OR) Zwróć expr1, jeśli jest konwertowany do true; w innym wypadku, zwróci expr2 logiczną. Tak więc, kiedy użyjemy wartość || zwróci true, jeśli oba argumenty są prawdziwe; jeśli oba są fałszywe, zwróci false.
!!expr(Negacja logiczna NOT) Zwraca false, jeśli jest pojedynczy argument konwertuje do true; w innym przypadku, zwróci true.
+

Tabela: Operatory logiczne +

Przykłady wyrażeń, które potrafią być konwertowane do false, są to te, które prawie są ocenione do null, 0, pusty łańcuch (""), lub niezidentyfikowany. +

Następujący kod pokazuje przykład operatora && (logiczny 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
+
+

Następujący kod pokazuje przykład operatora || (logiczny 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
+
+

Następujący kod pokazuje przykład operatora ! (logiczny NOT). +

+
n1=!true              // !t zwraca false
+n2=!false             // !f zwraca true
+n3=!"Cat"             // !t zwraca false
+
+

Skrócona ocena

+

Wyrażenia logiczne są oceniane od lewego do prawego, są one testowane dla ewentualnych "skrótów" potrafiących wykonać wyrażenie wykonując następujące reguły:

+ +

Zasady te są gwarancją, która te ewolucje zawsze poprawi. Notatka, która część coś_tam z powyższego wyrażenia jest nieoceniana, więc któraś strona nie wykona w pełni warunku jaki został założony. +

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operatory bitowe", "Przewodnik po języku JavaScript 1.5:Operatory:Operacje na łańcuchach") }} +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Logical_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_l\u00f3gicos", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_logiques", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Logical_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Logical_Operators" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/expressions_and_operators_510ae1f584cbdb5ca760b545f90c72ed/index.html b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_510ae1f584cbdb5ca760b545f90c72ed/index.html new file mode 100644 index 0000000000..304b64d5d6 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_510ae1f584cbdb5ca760b545f90c72ed/index.html @@ -0,0 +1,74 @@ +--- +title: Operatory porównania +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_porównania +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Comparison_Operators +--- +

+

+

Operatory porównania

+

Operator porównania porównuje jego argumenty i zwraca logiczna wartość bazującą na sprawdzeniu czy wartość jest prawdziwa (true). Argumenty są wartościami liczbowymi, łańcuchowymi, logicznymi lub obiektowymi. Wartości łańcuchowe są porównywane z zasadami opartymi na zasadach zawartych w leksykonach, używając wartości Unicode. Poniższa tabela opisuje operatory porównania. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorOpisPrzykłady powrotu true1
Jest równe (==)Zwraca true, jeśli argumenty są równe. Jeśli dwa argumenty nie są tego samego typu, JavaScript próbuje konwertować argument do odpowiedniego typu dla porównania.3 == var1
+

"3" == var1
+

+3 == '3'
Nie jest równe (!=)Zwraca true, jeśli argumenty nie są równe. Jeśli dwa argumenty nie są tego samego typu, JavaScript próbuje konwertować argument do odpowiedniego typu dla porównania.var1 != 4
+var2 != "3"
Ściśle równe (===)Zwraca true, jeśli argumenty są równe i są tego samego typu.3 === var1
Ściśle nie jest równe (!==)Zwraca true, jeśli argumenty nie są równe i/lub nie są tego samego typu.var1 !== "3"
+3 !== '3'
Jest większe (>)Zwraca true, jeśli lewy argument jest większy niż prawy argument.var2 > var1
Jest większe lub równe (>=)Zwraca true, jeśli lewy argument jest większy lub równy prawemu argumentowi.var2 >= var1
+var1 >= 3
Jest mniejsze (<)Zwraca true, jeśli lewy argument jest mniejszy niż prawy argument.var1 < var2
Jest mniejsze lub równe (<=)Zwraca true, jeśli lewy argument jest mniejszy lub równy prawemu argumentowi. var1 <= var2
+var2 <= 5
+

Tabela: Operatory porównania +

1Ten przykład podsumowuje, że var1 ma przydzieloną wartość 3 i var2 ma przydzieloną wartość 4. +

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operatory przypisania", "Przewodnik po języku JavaScript 1.5:Operatory:Operatory arytmetyczne") }} +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Comparison_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_de_comparaci\u00f3n", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_de_comparaison", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Comparison_Operators" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/expressions_and_operators_605f6491d97a62449200a9401cba82c7/index.html b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_605f6491d97a62449200a9401cba82c7/index.html new file mode 100644 index 0000000000..e7e7099052 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_605f6491d97a62449200a9401cba82c7/index.html @@ -0,0 +1,49 @@ +--- +title: Operatory arytmetyczne +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_arytmetyczne +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Arithmetic_Operators +--- +

+

+

Operatory arytmetyczne

+

Operatory arytmetyczne pobierają wartości liczbowe (albo literowy lub zmienny) jako własne argumenty i zwracają pojedynczą wartość liczbową. Podstawowymi operatorami arytmetycznymi są dodawanie (+), odejmowanie (-), mnożenie (*), i dzielenie (/). Wspomniane operatory działają także w innych językach programowania (oprócz operatora /, który zwraca wynik dzielenia w wartościach dziesiętnych w JavaScript), dzielenie nie zaokrągla wartości dziesiętnej, jak to robi w językach programowania, takich jak C i Java. Na przykład: +

+
1/2 //zwraca 0.5 w JavaScript
+1/2 //zwraca 0 w Java
+
+

Uzupełniając, JavaScript dostarcza operatory arytmetyczne wyliczone w poniższej tabeli. +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorOpisPrzykład
%
(Modulo)		Operator bitowy. Zwraca liczbę całkowitą z resztą podczas dzielenie dwóch argumentów. 12 % 5 zwraca 2.
++
(Inkrementacji)		Operator unarny. Zwiększa o jeden argument. Jeśli użyjemy operator z przedrostkiem (++x), zwróci wartość argumentu zwiększonego o jeden; jeśli użyjemy argumentu i za nim przedrostek (x++), zwróci wartość argumentu z przed zwiększenia o jeden.Jeśli x jest 3, potem ++x ustawia x na 4 i zwraca 4, podczas gdy x++ ustawia x na 4 i zwraca 3.
--
(Dekrementacji)		Operator unarny. Zmniejszy o jeden argument. Zwracana wartość jest analogiczna do zapisu operatora inkrementacji.Jeśli x jest 3, potem --x ustawia x na 2 i zwraca 2, podczas gdy x++ ustawia x na 2 i zwraca 3.
-
(Negacja unarna)		Operator unarny. Zwraca negacje tego argumentu.Jeśli x jest 3, potem -x zwraca -3.
+

Tabela: Operatory arytmetyczne +

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operatory porównania", "Przewodnik po języku JavaScript 1.5:Operatory:Operatory bitowe") }} +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Arithmetic_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_aritm\u00e9ticos", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_arithm\u00e9tiques", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Arithmetic_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Arithmetic_Operators" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/expressions_and_operators_a3ce80967ffc4f60314caa4b05ec9c47/index.html b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_a3ce80967ffc4f60314caa4b05ec9c47/index.html new file mode 100644 index 0000000000..8ce2683d3f --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_a3ce80967ffc4f60314caa4b05ec9c47/index.html @@ -0,0 +1,228 @@ +--- +title: Operatory specjalne +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_specjalne +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Special_Operators +--- +

+

+

Operatory specjalne

+

JavaScript udostępnia następujące operatory specjalne: +

+ +

Operator warunkowy

+

Operator warunkowy jest tylko operatorem JavaScript, który pobiera trzy argumenty. Operator może mieć jedną lub dwie wartości oparte na warunku. Składnia: +

+
condition ? val1 : val2
+
+

Jeśli condition (warunek) jest prawdziwy (true), operator ma wartość val1. W przeciwnym razie posiada wartość val2. Możesz użyć operatora warunkowego wszędzie, gdzie będziesz używał operatorów standardowych. +

Na przykład: +

+
status = (age >= 18) ? "adult" : "minor"
+
+

Ta instrukcja przydziela wartość "adult" do status, jeśli posiada osiemnaście lub więcej lat. Z drugiej strony przydzielasz "minor" do status. +

+

Operator przecinka

+

Operator przecinka, prosty poszukujący obu argumentów zwracających drugi argument. Ten operator początkowo używany był wewnątrz pętli for. Pozwalał wielokrotnie na aktualizację zmiennych, za każdym razem kiedy pętla jest wykonywana.

Na przykład, jeśli a jest 2-u wymiarową tablicą z 10 elementami na stronę, następujący operator przecinkowy to kod użytkownika będący przyrostem dwóch zmiennych na raz. Kod drukuje wartości diagonalne elementów w tablicy: +

+
for (var i=0, j=9; i <= 9; i++, j--)
+   document.writeln("a["+i+","+j+"]= " + a[i*10 +j])
+
+

Uwaga te dwuwymiarowe tablice są już nie wspierane. Ten przykład emuluje dwuwymiarowe tablice używając jedno wymiarowej tablicy. +

+

delete

+

Operator delete usuwa obiekty, własności obiektów, lub elementy określone w indeksie tablicy. Składnia: +

+
delete objectName
+delete objectName.property
+delete objectName[index]
+delete property // legal only within a with statement
+
+

gdzie: objectName jest nazwą obiektu, property są to istniejące własności i index reprezentuje liczbę całkowita w lokalizacji z elementem tablicy.

Czwarta forma jest dopuszczalna tylko wewnątrz instrukcji with, aby usunąć własności z obiektu. +

Możesz użyć operator delete do usunięcia zmiennych zadeklarowanych bez zastrzeżeń, ale nie te z deklaracją instrukcji var. +

Jeśli operator delete jest prawidłowy, to ustawienia własności lub usuniętego elementu są nieczytelne (undefined). Operator delete zwraca true, jeśli operacja jest możliwa; zwraca false, jeżeli operacja nie jest możliwa.

+
x=42
+var y= 43
+myobj=new Number()
+myobj.h=4      // tworzy własności h
+delete x       // zwraca true (potrafi usunąć, jeśli zadeklarujemy brak zastrzeżeń)
+delete y       // zwraca false (nie potrafi usunąć jeśli zadeklarujemy z var)
+delete Math.PI // zwraca false (nie potrafi usunąć predefiniowanych własności)
+delete myobj.h // zwraca true (potrafi usunąć własności zdefiniowane przez użytkownika)
+delete myobj   // zwraca true (potrafi usunąć, jeśli zadeklarujemy brak zastrzeżeń)
+
+

Usuwanie tablicy elementów
+Kiedy operator delete usunie elementy tablicy, długość tablicy będzie nadal taka sama. Na przykład, jeśli usuniemy a{{ mediawiki.external(3) }}, a{{ mediawiki.external(4) }} to wciąż jest a{{ mediawiki.external(4) }} i a{{ mediawiki.external(3) }} ale niezdefiniowane. +

Kiedy operator delete usuwa element, który jest elementem tablicowym, taki element nie jest dłuższy w tablicy. W następnym przykładzie, trees{{ mediawiki.external(3) }} jest usunięty z delete. +

+
trees=new Array("redwood","bay","cedar","oak","maple")
+delete trees[3]
+if (3 in trees) {
+   // to nie zadziała
+}
+
+

Jeśli chcesz, aby element tablicy istniał, ale masz nieznaną wartość, użyj słowa kluczowego undefined zamiast operatora delete. W następnym przykładzie, jest przydzielona niezidentyfikowana wartość trees{{ mediawiki.external(3) }}, ale element tablicy nadal istnieje:

+
trees=new Array("redwood","bay","cedar","oak","maple")
+trees[3]=undefined
+if (3 in trees) {
+   // to zadziała
+}
+
+

in

+

Operator in zwraca true, jeśli specyficzne właściwości są w specyficznym obiekcie. Składnia:

+
propNameOrNumber in objectName
+
+

gdzie: propNameOrNumber jest łańcuchem znaków lub wyrażeniem liczbowym reprezentującym własności nazwy lub index tablicy, objectName jest nazwą obiektu. +

Następujący przykład używa operatora in. +

+
// Tablice
+trees=new Array("redwood","bay","cedar","oak","maple")
+0 in trees        // zwracają true
+3 in trees        // zwracają true
+6 in trees        // zwracają false
+"bay" in trees    // zwracają false (musisz mieć specyficzny numer indeksu,
+                  // nie ma wartości w tym indeksie)
+"length" in trees // zwracają true (długość jest własnością tablicy)
+
+// obiekty predefiniowane
+"PI" in Math          // zwracają true
+myString=new String("coral")
+"length" in myString  // zwracają true
+
+// obiekty użytkownika
+mycar = {make:"Honda",model:"Accord",year:1998}
+"make" in mycar  // zwracają true
+"model" in mycar // zwracają true
+
+

instanceof

+

Operator instanceof zwraca true, jeśli konkretny obiekt jest obiektem konkretnego typu. Składnia:

+
objectName instanceof objectType
+
+

gdzie: objectName jest nazwą obiektu do porównania z objectType a objectType jest typem obiektu, jak naprzykład Date lub Array. +

Używamy instanceof, kiedy potrzebujemy porównać typy uruchomionych obiektów. Na przykład, kiedy wystąpi wyjątek, to można, w zależności od zgłoszonego typu wyjątku rozgałęzić różną obsługę tego wyjątku. +

Na przykład, następujący kod używa instanceof do określenia czy theDay jest obiektem Date. Ponieważ theDay jest obiektem Date, instrukcja w if jest wykonywana. +

+
theDay=new Date(1995, 12, 17)
+if (theDay instanceof Date) {
+   // instrukcja do wykonania
+}
+
+

new

+

Użyj operatora new, aby utworzyć przykład definicji użytkownika typu obiektowego lub jednego z predefiniowanego typu obiektowego Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp, lub String. Na serwerze możesz, używać także z DbPool, Lock, File lub SendMail. Użyj new w następującym kodzie: +

+
objectName = new objectType ( param1 [,param2] ...[,paramN] )
+
+

Możemy także tworzyć obiekty używając inicjatorów obiektu opisanych na stronie Używanie inicjacji obiektu. +

Zobacz więcej na temat operatora new w dokumentacji JavaScript. +

+

this

+

Użyj słowa kluczowego this do wskazania aktualnego obiektu. Generalnie, this wskazuje nazwę obiektu w metodzie. Używamy go następująco:

+
this[.propertyName]
+
+

Przykład 1.
+Załóżmy że funkcja validate zatwierdza właściwą wartość, przekazując obiekt oraz górny i dolny zakres.

+
function validate(obj, lowval, hival) {
+   if ((obj.value < lowval) || (obj.value > hival))
+      alert("Invalid Value!")
+}
+
+

Teraz możesz wywoływać validate w każdym formularzu korzystając z zdarzenia onChange. +Używamy this do przekazania elementu w formularz, tak jak w przykładzie: +

+
<B>Wprowadź liczbę pomiędzy 18 i 99:</B>
+<INPUT TYPE = "text" NAME = "age" SIZE = 3
+   onChange="validate(this, 18, 99)">
+
+

Przykład 2.
+Kiedy kombinujesz z własnościami form, zostaniesz skierowany do tymczasowego obiektu znajdującego się w obrębie tego formularza. W następującym przykładzie, formularz myForm składa się z obiektu Text i przycisku. Kiedy użytkownik kliknie w przycisk, wartość obiektu Text ustawia się na nazwę formularza. Przycisk zawiera zdarzenie onClick używane za pomocą uchwytu this.form do wywołania go w tym samym formularzu, myForm. +

+
<FORM NAME="myForm">
+Form name:<INPUT TYPE="text" NAME="text1" VALUE="Beluga">
+<P>
+<INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
+   onClick="this.form.text1.value=this.form.name">
+</FORM>
+
+

typeof

+

Operator typeof jest użyty w jednej z dwóch sytuacji: +

+
1. typeof operand
+2. typeof (operand)
+
+

Operator typeof zwraca łańcuch zwracający typ nie ocenionego argumentu. Argumentem (operand) jest łańcuch, zmienna, słowo kluczowe lub obiekt, dla którego ten typ będzie zwracany. Nawiasy są opcjonalne.

Przypuśćmy, że zdefiniujemy następujące zmienne:

+
var myFun = new Function("5+2")
+var shape="round"
+var size=1
+var today=new Date()
+
+

Operator typeof zwraca następujący rezultat dla tych zmiennych:

+
typeof myFun is function
+typeof shape is string
+typeof size is number
+typeof today is object
+typeof dontExist is undefined
+
+

Dla słowa kluczowego true i null, operator typeof zwraca następujący rezultat:

+
typeof true is boolean
+typeof null is object
+
+

Dla liczby lub łańcucha znaków, operator typeof zwraca następujący rezultat: +

+
typeof 62 is number
+typeof 'Hello world' is string
+
+

Dla wartości własności, operator typeof zwraca właściwość stanowiącą typ zmiennej: +

+
typeof document.lastModified is string
+typeof window.length is number
+typeof Math.LN2 is number
+
+

Dla metod lub funkcji, operator typeof zwraca następujący rezultat: +

+
typeof blur is function
+typeof eval is function
+typeof parseInt is function
+typeof shape.split is function
+
+

Dla obiektów predefiniowanych, operator typeof zwraca następujący rezultat:

+
typeof Date is function
+typeof Function is function
+typeof Math is function
+typeof Option is function
+typeof String is function
+
+

void

+

Operator void jest użyty w jednym z następujących przypadków: +

+
1. void (expression)
+2. void expression
+
+

Operator void określa wykonane wyrażenie bez zwracania wartości. expression jest wyrażeniem JavaScript do wykonania. Nawiasy otaczające wyrażenie są opcjonalne, jednak dobrym stylem jest ich stosowanie. +

Możemy zastosować operator void do określenia wyrażenia jako hipertekstowy odnośnik. Wyrażenie jest wykonywane ale nie jest wczytywane w miejsce bieżącego dokumentu. +

Następujący kod tworzy odnośnik hipertekstowy, który nic nie wywoła w momencie, kiedy użytkownik go kliknie. Kiedy użytkownik kliknie w odnośnik, to wykonane zostanie niezidentyfikowane wyrażenie void(0), które nie ma żadnego efektu w języku JavaScript. +

+
<a href="javascript:void(0)">Kliknij tu, nie robiąc nic</a>
+
+

Następujący kod tworzy odnośnik, który przedłoży (prześle) zawartość formularza w momencie, kiedy użytkownik naciśnie przycisk formularza. +

+
<a href="javascript:void(document.form.submit())">Kliknij tutaj, aby przesłać zawartość formularza</a>
+
+

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operacje na łańcuchach", "Przewodnik_po_j%C4%99zyku_JavaScript_1.5:Operatory#Pierwszeństwo_operatorów") }} +

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_especiales", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_sp\u00e9ciaux", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Special_Operators" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/expressions_and_operators_c278b67ddd602343b8c21711abc1b17c/index.html b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_c278b67ddd602343b8c21711abc1b17c/index.html new file mode 100644 index 0000000000..b3d0303eba --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/expressions_and_operators_c278b67ddd602343b8c21711abc1b17c/index.html @@ -0,0 +1,23 @@ +--- +title: Wyrażenia +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Wyrażenia +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Expressions +--- +

+

+

Wyrażenia

+

Wyrażenia (expression) są ważnym ustawieniem literałów, zmiennych, operatorów oraz wyrażeń które są wykonywane dla pojedynczej wartości; wartością tą może być liczba, znak, lub wartość logiczną.

Konceptualnie, są dwa typy wyrażeń: te, które próbują przypisać wartość do zmiennych, i te, które po prostu posiadają wartość. Na przykład, wyrażenie x=7 jest wyrażeniem, które przydziela 7 wartości x. Wyrażenie to samo sprawdza liczbę siedem, podobnie także zachowuje się wyrażenie użyte w "przydzielonych operatorach". Z drugiej strony, możemy powiedzieć, że wyrażenie proste 3 + 4 staje się siódemką; lecz w taki sposób nie można dokonać przydzielenia. Operatory użyte jak wyrażenia są kierowane prosto jako operatory. +

JavaScript posiada następujące typy wyrażeń: +

+ +

{{ PreviousNext("Przewodnik_po_j%C4%99zyku_JavaScript_1.5:Unicode#Wy.C5.9Bwietlanie_czcionek_z_Unicode", "Przewodnik po języku JavaScript 1.5:Operatory") }} +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Expressions", "fr": "fr/Guide_JavaScript_1.5/Expressions", "ja": "ja/Core_JavaScript_1.5_Guide/Expressions" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/functions/index.html b/files/pl/conflicting/web/javascript/guide/functions/index.html new file mode 100644 index 0000000000..7a3fc26637 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/functions/index.html @@ -0,0 +1,62 @@ +--- +title: Definiowanie funkcji +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Definiowanie_funkcji +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Defining_Functions +--- +

Definiowanie funkcji

+

Na definicję funkcji składają się słowa:

+ +

Na przykład, następujący kod definiuje prostą funkcję nazwaną square:

+
function square(number) {
+   return number * number;
+}
+
+

Funkcja square bierze jeden argument, nazwany number. Funkcja składa się z jednej instrukcji, która sygnalizuje zwrot argumentu funkcji pomnożonej przez samą siebie. Instrukcja return określa wartość zwracanej funkcji.

+
return number * number
+
+

Wszystkie parametry są przekazywane do funkcji przez wartość; wartość zostaje przekazana do funkcji, ale jeżeli w funkcji wartość parametru zostanie zmieniona, zmiana ta nie będzie widoczna globalnie an. Jednakże, jeżeli przekażesz obiekt jako parametr funkcji, a funkcja zmieni właściwości obiektu, zmiana ta będzie widoczna poza funkcją, tak jak w następującym przykładzie:

+
function myFunc(theObject) {
+   theObject.make="Toyota"
+}
+
+mycar = {make:"Honda", model:"Accord", year:1998};
+x=mycar.make;     // zwraca Honda
+myFunc(mycar);    // przechodzi obiekt mycar do funkcji
+y=mycar.make;     // zwraca Toyota (porada: was changed by the function)
+
+

Zdefiniowana funkcja jest oparta na warunku. Na przykład, dając następującą definicje funkcji:

+
if (num == 0)
+{
+   function myFunc(theObject) {
+   theObject.make="Toyota"
+   }
+}
+
+

Funkcja myFunc jest tylko zdefiniowana jeśli zmienna num równa się 0. Jeśli num nie jest równe 0, funkcja nie jest zdefiniowana i jakiekolwiek inne próby nie zostaną wykonane.

+

Oprócz opisanego tu definiowania funkcji, możliwe jest także definiowanie Function objects.

+

Metoda jest to połączenie funkcji z obiektem. Możesz się nauczyć więcej o obiektach i metodach w Obiekt function

+

Funkcja może być także zdefiniowana wewnątrz wyrażenia. Jest to nazwane wyrażeniem funkcyjnym. Typowo takie funkcje są anonimowe - nie mają nazwy. Na przykład, funkcja square może być zdefiniowana jako:

+
const square = function(number) {return number * number};
+
+

To jest konwencja kiedy przekazujesz jako funkcję jako argument do następnej funkcji. Następujący przykład pokazuje mapę funkcji będących zdefiniowanymi i następnie nazwane z funkcją, a jako pierwszą funkcją będzie parametr:

+
function map(f,a) {
+   var result=new Array;
+   for (var i = 0; i != a.length; i++)
+      result[i] = f(a[i]);
+   return result;
+}
+
+

Wywołuje:

+
map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]);
+
+

Zwraca {{ mediawiki.external('0, 1, 8, 125, 1000') }}.

diff --git a/files/pl/conflicting/web/javascript/guide/functions_14ccabf533660cb9d0794a5a93287159/index.html b/files/pl/conflicting/web/javascript/guide/functions_14ccabf533660cb9d0794a5a93287159/index.html new file mode 100644 index 0000000000..30a279079a --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/functions_14ccabf533660cb9d0794a5a93287159/index.html @@ -0,0 +1,27 @@ +--- +title: Funkcje escape i unescape +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_escape_i_unescape +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/escape_and_unescape_Functions +--- +

+

+

Funkcje escape i unescape

+

Funkcje escape i unescape kodują i dekodują wartość łańcuchową. Funkcja escape zwraca kodowanie szesnastkowe argumentu ustawiając czcionki ISO Latin. Funkcja unescape zwraca wartość łańcuchową jako ASCII - czyli specyficzną wartością kodowania szesnastkowego. +

Składnia tych funkcji: +

+
escape(string)
+unescape(string)
+
+

Funkcje używamy przede wszystkim po stronie serwera, JavaScript koduje i dekoduje nazwy/wartości par w URL. +

Funkcje escape i unescape nie pracują dla znaków nie znajdujących się w ASCII, które są deprecated. W JavaScript 1.5 i późniejszych wydaniach, używają encodeURI, decodeURI, encodeURIComponent, i decodeURIComponent. +

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/escape_and_unescape_Functions", "es": "es/Gu\u00eda_JavaScript_1.5/Funciones_predefinidas/Funciones_escape_y_unescape", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/Les_fonctions_escape_et_unescape", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/escape_and_unescape_Functions" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/functions_2af756c37808c2f8e09add6cc9618178/index.html b/files/pl/conflicting/web/javascript/guide/functions_2af756c37808c2f8e09add6cc9618178/index.html new file mode 100644 index 0000000000..1f5191c526 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/functions_2af756c37808c2f8e09add6cc9618178/index.html @@ -0,0 +1,25 @@ +--- +title: Funkcja isFinite +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isFinite +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/isFinite_Function +--- +

+

+

Funkcja isFinite

+

Funkcja isFinite sprawdza argument do momentu ustalenia czy jest liczbą skończona. Składnia isFinite: +

+
isFinite(number)
+
+

gdzie: number jest liczbą, która jest sprawdzana.

Jeśli argument jest NaN, plus nieskończoność lub minus nieskończoność, to ta metoda zwraca false, w innych przypadkach zwraca true. +

Następujący kod sprawdza klienta wejścia i ustala czy to jest liczba skończona.

+
if(isFinite(ClientInput) == true)
+{
+   /* wykonaj odpowiednie kroki */
+}
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/isFinite_Function", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/La_fonction_isFinite", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/isFinite_Function" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/functions_403e991db3105a03e0afc1a3cc821a01/index.html b/files/pl/conflicting/web/javascript/guide/functions_403e991db3105a03e0afc1a3cc821a01/index.html new file mode 100644 index 0000000000..8a9cd42575 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/functions_403e991db3105a03e0afc1a3cc821a01/index.html @@ -0,0 +1,46 @@ +--- +title: Wywołanie funkcji +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Wywołanie_funkcji +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Calling_Functions +--- +

 

+ +

Wywołanie funkcji

+ +

Definiowanie funkcji nie powoduje ich wykonania. Definiowanie funkcji po prostu ją wywołuje oraz określa co dana funkcja ma robić po wywołaniu. Wywołanie funkcji określa właściwą akcje z ustalonymi parametrami. Dla przykładu, gdy chcesz zdefiniować funkcje potęgowania należałoby wywołać ją następująco:

+ +
square(5)
+
+ +

Powyższe stwierdzenie wywołuje funkcje z argumentem 5. Funkcja zostaje wykonana i zwraca wartość równą 25.

+ +

Argumenty funkcji nie ograniczają się wyłącznie do łańcuchów znaków lub liczb. Można również przekazywać całe obiekty. Funkcja show_props (zdefiniowane w obiekty i własności) może posłużyć za przykład funkcji, gdzie argumentem jest obiekt.

+ +

Funkcja może być rekurencyjna  tj. wywoływać samą siebie. Przykładem może być funkcja licząca silnię:

+ +
function silnia(n) {
+   if ((n == 0) || (n == 1))
+      return 1
+   else {
+      var result = (n * silnia(n-1) );
+      return result
+   }
+}
+
+ +

Można policzyć silnię od 1 do 5:

+ +
a=silnia(1) // zwraca 1
+b=silnia(2) // zwraca 2
+c=silnia(3) // zwraca 6
+d=silnia(4) // zwraca 24
+e=silnia(5) // zwraca 120
+
+ +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Calling_Functions", "fr": "fr/Guide_JavaScript_1.5/Appel_de_fonctions", "ja": "ja/Core_JavaScript_1.5_Guide/Calling_Functions" } ) }}

diff --git a/files/pl/conflicting/web/javascript/guide/functions_74f4afa40d626fed3cf9277e30d6d211/index.html b/files/pl/conflicting/web/javascript/guide/functions_74f4afa40d626fed3cf9277e30d6d211/index.html new file mode 100644 index 0000000000..c474f760c8 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/functions_74f4afa40d626fed3cf9277e30d6d211/index.html @@ -0,0 +1,28 @@ +--- +title: Funkcje Number i String +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_Number_i_String +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/Number_and_String_Functions +--- +

+

+

Funkcje Number i String

+

Funkcja Number i String przekonwertuje na obiekt numeryczny lub łańcuch znaków. Składnia tej funkcji to: +

+
Number(objRef)
+String(objRef)
+
+

gdzie: objRef jest wskaźnikiem funkcji. +

Następny przykład przekonwertuje obiekt Date na możliwy do odczytu łańcuch znaków. +

+
D = new Date (430054663215)
+// Następnie zwraca
+// "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983"
+x = String(D)
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/Number_and_String_Functions", "es": "es/Gu\u00eda_JavaScript_1.5/Funciones_predefinidas/Funciones_Number_y_String", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/Les_fonctions_Number_et_String", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/Number_and_String_Functions" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/functions_8b84da88e673c0774c4f504a9be67268/index.html b/files/pl/conflicting/web/javascript/guide/functions_8b84da88e673c0774c4f504a9be67268/index.html new file mode 100644 index 0000000000..a4aa3da4be --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/functions_8b84da88e673c0774c4f504a9be67268/index.html @@ -0,0 +1,30 @@ +--- +title: Funkcja isNaN +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isNaN +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/isNaN_Function +--- +

+

+

Funkcja isNaN

+

Funkcja isNaN ocenia argument do określenia jeśli jest "NaN" (nie numer). Składnia isNaN: +

+
isNaN(testValue)
+
+

gdzie: testValue jest wartością do oceny. +

Funkcje parseFloat i parseInt zwracają "NaN", kiedy ocenią wartość, że to nie jest numer. isNaN zwraca true jeśli przyjmie "NaN," i false w przeciwnym wypadku. +

Następujący kod sprawdza wartość floatValue, potrafi określić czy to jest liczba, a następnie nazywa odpowiednią procedurę: +

+
floatValue=parseFloat(toFloat)
+
+if (isNaN(floatValue)) {
+   notFloat()
+} else {
+   isFloat()
+}
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/isNaN_Function", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/La_fonction_isNaN", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/isNaN_Function" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/functions_90ea47f6d07003af2efc0a1756da41e2/index.html b/files/pl/conflicting/web/javascript/guide/functions_90ea47f6d07003af2efc0a1756da41e2/index.html new file mode 100644 index 0000000000..dc80cd2a98 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/functions_90ea47f6d07003af2efc0a1756da41e2/index.html @@ -0,0 +1,21 @@ +--- +title: Funkcja eval +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_eval +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/eval_Function +--- +

+

+

Funkcja eval

+

Funkcja eval ocenia łańcuch znaków w kodzie JavaScript bez odniesienia do osobliwego obiektu. Składnia eval: +

+
eval(expr)
+
+

gdzie: expr jest ocenianym łańcuchem znaków. +

Jeśli łańcuch znaków reprezentuje wyrażenie, eval je ocenia. Jeśli argument reprezentuje jedną lub więcej instrukcji JavaScript, eval wykonuje instrukcję. Nie nazywaj eval oceniane wyrażenia arytmetyczne, gdyż JavaScript oceni wyrażenia arytmetyczne automatycznie. +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/eval_Function", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/La_fonction_eval", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/eval_Function" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/functions_915be6bbaf2578afefb6927c899d5f3d/index.html b/files/pl/conflicting/web/javascript/guide/functions_915be6bbaf2578afefb6927c899d5f3d/index.html new file mode 100644 index 0000000000..2badc2fb2d --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/functions_915be6bbaf2578afefb6927c899d5f3d/index.html @@ -0,0 +1,29 @@ +--- +title: Funkcje parseInt i parseFloat +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_parseInt_i_parseFloat +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/parseInt_and_parseFloat_Functions +--- +

+

+

Funkcja parseInt i parseFloat

+

Dwie funkcje "parse", parseInt i parseFloat, zwracają wartość liczbową, gdy podano łańcuch znaków jako argument.

Składnia parseFloat +

+
parseFloat(str)
+
+

gdzie parseFloat analizuje swój argument, łańcuch znaków str i próbuje zwrócić liczbę zmiennoprzecinkową. W razie napotkania symbolu innego niż znak (+ lub -), liczby (0-9), znaku dziesiętnego lub wykładnika, funkcja zwraca wartość do momentu jego wystąpienia ignorując sam symbol i wszystkie inne po nim następujące. Jeśli pierwszy znak nie może być przekonwertowany do liczby, zwrócona zostaje wartość "NaN" (nie liczba). +

Składnia parseInt

+
parseInt(str [, radix])
+
+

parseInt analizuje swój pierwszy argument, łańcuch znaków str i próbuje zwrócić liczbę całkowitą o podstawie wskazanej przez drugi, opcjonalny argument radix. Na przykład, podstawa o wartości 10 wskazuje konwersję do liczby dziesiętnej, podstawa równa 8 do liczby ósemkowej, 16 do heksadecymalnej itd. Dla podstawy większej od 10 litery alfabetu wskazują liczby większe od 9. Na przykład, dla liczb heksadecymalnych (podstawa 16), używane są litery od A do F. +

Jeśli parseInt napotka w podanej podstawie symbolu, który nie jest liczbą, funkcja zwraca wartość całkowitą do momentu jego wystąpienia ignorując sam symbol i wszystkie inne po nim następujące. Jeśli pierwszy znak nie może być przekonwertowany do liczby, zwrócona zostaje wartość "NaN". Funkcja parseInt skraca łańcuchy znaków do wartości całkowitych. +

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/parseInt_and_parseFloat_Functions", "es": "es/Gu\u00eda_JavaScript_1.5/Funciones_predefinidas/Funciones_parseInt_y_parseFloat", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/Les_fonctions_parseInt_et_parseFloat", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/parseInt_and_parseFloat_Functions" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/functions_b0ff3e89089de1f0a22029bbde807073/index.html b/files/pl/conflicting/web/javascript/guide/functions_b0ff3e89089de1f0a22029bbde807073/index.html new file mode 100644 index 0000000000..2048814532 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/functions_b0ff3e89089de1f0a22029bbde807073/index.html @@ -0,0 +1,24 @@ +--- +title: Funkcje predefiniowane +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions +--- +

+

+

Funkcje predefiniwane

+

JavaScript ma kilka predefiniowanych funkcji: +

+ +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/grammar_and_types/index.html b/files/pl/conflicting/web/javascript/guide/grammar_and_types/index.html new file mode 100644 index 0000000000..500db9cae6 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/grammar_and_types/index.html @@ -0,0 +1,208 @@ +--- +title: Literały +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Literały +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Literals +--- +

+

+

Literały

+

Literałów używa się w celu przedstawiania wartości w JavaScript. Są one ustalonymi wartościami (a nie zmiennymi), które dosłownie podajesz w swoim skrypcie. Ten fragment opisuje następujące typy literałów:

+ +

Literały tablicy

+

Literał tablicy jest listą składającą się z zera lub większej liczby wyrażeń, z których każdy reprezentuje element tablicy, a które zamknięte są w nawiasach kwadratowych ([]). Tablica tworzona za pomocą literału tablicy zostaje zainicjalizowana podanymi wartościami jako jej elementami, a jej długość jest ustalone według liczby podanych argumentów. +

Poniższy przykład tworzy tablicę kawy z trzema elementami i o długości trzy: +

+
kawy = ["Arabica", "Columbiana", "Zbożowa"]
+

Uwaga Literał tablicy jest typem inicjatora obiektu. Zobacz Używanie inicjatorów obiektu. +

Jeśli tablica została utworzona przy pomocy literału w skrypcie najwyższego poziomu, JavaScript interpretuje tablicę za każdym razem, gdy przelicza wyrażenie zawierające literał tablicowy. Dodatkowo literał użyty w funkcji jest tworzony przy każdym wywołaniu funkcji. +

Literały tablicy są także obiektami Array. Zobacz obiekt Array, aby uzyskać więcej informacji o obiektach Array. +

Dodatkowe przecinki w literale tablicy +

Nie musisz określać w literale tablicy wszystkich elementów. Jeśli postawisz kolejno dwa przecinki, zostanie utworzony obiekt array z pustym miejscem dla niesprecyzowanych elementów. Poniższy przykład tworzy tablicę ryba: +

+
ryba = ["Piła", , "Młot"]
+

Tablica ta posiada dwa elementy z wartościami i jeden pusty element (wartość ryba{{ mediawiki.external(0) }} to "Piła", ryba{{ mediawiki.external(1) }} jest niezdefiniowana, a ryba{{ mediawiki.external(2) }} to "Młot"): +

Jeśli na końcu listy elementów umieścisz dodatkowy przecinek, jest on ignorowany. W poniższym przykładzie długość tablicy jest równa trzy. Nie istnieje mojaLista{{ mediawiki.external(3) }}. Wszystkie inne przecinki w liście wskazują nowy element.

+
mojaLista = ['dom', , 'szkoła', ];
+

W kolejnym przykładzie długość tablicy jest równa cztery; nie zdefiniowano wartości dla mojaLista{{ mediawiki.external(0) }} i mojaLista{{ mediawiki.external(2) }}. +

+
mojaLista = [ , 'dom', , 'szkoła'];
+

W ostatnim przykładzie długość tablicy wynosi cztery i brakuje mojaLista{{ mediawiki.external(1) }} i mojaLista{{ mediawiki.external(3) }}. Tylko ostatni przecinek jest ignorowany. Jest on opcjonalny. +

+
mojaLista = ['dom', , 'szkoła', , ];
+

Literały logiczne

+

Typ logiczny posiada dwie wartości: true i false. +

Nie wolno mylić pierwotnych wartości logicznych true i false z wartościami prawda i fałsz (true/false) obiektu logicznego. Obiekt logiczny jest obiektem opakowującym pierwotnego typu danych logicznych. Zobacz obiekt Boolean, aby uzyskać więcej informacji. +

+

Literały całkowite

+

Liczby całkowite mogą być wyrażane jako dziesiętne (podstawa 10), szesnastkowe (podstawa 16) i ósemkowe (podstawa 8). Dziesiętny literał całkowity składa się z sekwencji cyfr bez czołowego 0 (zera). Czołowe 0 (zero) w literale całkowitym wskazuje na literał ósemkowy; Czołowe 0x (lub 0X) wskazuje na literał szesnastkowy. Liczby szesnastkowe mogą zawierać cyfry od 0 do 9 oraz litery a-f lub A-F. Ósemkowe literały całkowite mogą zawierać tylko cyfry od 0 do 7. +

Ósemkowe literały całkowite są wycofywane i zostały usunięte ze 3 edycji standardu ECMA-262. JavaScript 1.5 wciąż wspiera je dla kompatybilności wstecznej. +

Przykładami literałów całkowitych są: +

+
0, 117 i -345 (dziesiętne, podstawa 10)
+015, 0001 i -077 (ósemkowe, podstawa 8)
+0x1123, 0x00111 i -0xF1A7 (szesnastkowe, "hex" lub podstawa 16)
+
+

Literały zmiennoprzecinkowe

+

Literały zmiennoprzecinkowe mogą mieć następujące części: +

+ +

Wykładnik stanowi "e" lub "E", po którym następuje liczba całkowita mogąca posiadać znak (poprzedzona przez "+" lub "-"). Literały zmiennoprzecinkowe muszą posiadać co najmniej jedną cyfrę; muszą także posiadać "e" (lub "E") bądź znak dziesiętny. +

Przykładami literałów zmiennoprzecinkowych są 3.1415, -3.1E12, .1e12 i 2E-12. +

Ściślej, składnia jest następująca: +

+
[cyfry][.cyfry][(E|e)[(+|-)]cyfry]
+
+

Na przykład: +

+
3.14
+2345.789
+.3333333333333333333
+
+

Literały obiektu

+

Literał obiektu stanowi ujęta w nawias klamrowy ({}) lista składająca się z zera lub większej liczby par, które stanowią nazwa własności obiektu oraz przypisana jej wartość. Nie powinno się używać literału obiektu na początku instrukcji. Doprowadzi to do wystąpienia błędu lub nieoczekiwanych zachowań, gdyż { zostanie zinterpretowany jako początek bloku. +

Poniżej podany jest przykład literału obiektu. Pierwszy element obiektu auto definiuje własność mojeAuto; drugi element, własność pobierzAuto, wywołuje funkcję (TypyAut("Polonez")); trzeci element, własność specjalne, używa istniejącej zmiennej (Sprzedaz). +

+
var Sprzedaz = "Toyota";
+
+function TypyAut(nazwa) {
+   if(nazwa == "Polonez")
+      return nazwa;
+   else
+      return "Przykro nam, ale nie sprzedajemy marki " + nazwa + ".";
+}
+
+auto = {mojeAuto: "Caro", pobierzAuto: TypyAut("Polonez"), specjalne: Sprzedaz}
+
+document.write(auto.mojeAuto); // Caro
+document.write(auto.pobierzAuto); // Polonez
+document.write(auto.specjalne); // Toyota
+

Dodatkowo, możesz użyć literału znakowego lub liczbowego jako nazwy własności lub zagnieździć obiekt wewnątrz innego. Ilustruje to poniższy przykład. +

+
auto = {wieleAut: {a: "Saab", b: "Jeep"}, 7: "Mazda"}
+
+document.write(auto.wieleAut.b); // Jeep
+document.write(auto[7]); // Mazda
+
+

Zauważ: +

+
foo = {a: "alfa", 2: "dwa"}
+document.write (foo.a)    // alfa
+document.write (foo[2])   // dwa
+//document.write (foo.2)  // Błąd: brakuje ) po liście argumentów
+//document.write (foo[a]) // Błąd: a nie jest zdefiniowane
+document.write (foo["a"]) // alfa
+document.write (foo["2"]) // dwa
+
+

Literały znakowe

+

Literały znakowe to zero lub więcej znaków zamkniętych w podwójnych (") lub pojedynczych (') znacznikach cytatu. Łańcuch znaków musi być ograniczony przez znaczniki tego samego typu, a więc obydwa pojedyncze lub obydwa podwójne znaki cytatu. Poniżej umieszczono przykłady literałów znakowych: +

+ +

Możesz wywołać dowolną metodę obiektu String na wartości literału znakowego - JavaScript automatycznie skonwertuje literał znakowy do tymczasowego obiektu String, wywoła metodę, a następnie pozbędzie się tymczasowego obiektu String. Możesz również użyć własności String.length z literałem znakowym: +

+ +

Powinieneś użyć literału znakowego, chyba że potrzebujesz szczególnie obiektu String. Zobacz obiekt String, aby uzyskać szczegółowe informacje o obiektach String. +

+
Używanie specjalnych znaków w łańcuchach
+

Dodatkowo oprócz znaków zwykłych możesz także włączyć do łańcuchów specjalne znaki, tak jak pokazano w przykładzie:

+
"pierwsza linia \n następna linia"
+

Poniższa tabela przedstawia znaki specjalne, które możesz użyć w łańcuchach znaków JavaScript. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ZnakZnaczenie
\bBackspace
\fNowa strona
\nNowa linia
\rPowrót karetki
\tTabulacja
\vTabulacja pionowa
\'Apostrof lub pojedynczy cudzysłów
\"Podwójny cudzysłów
\\Lewy ukośnik (\).
\XXXZnaki z kodowaniem Latin-1 określone przez do trzech cyfrósemkowych XXX pomiędzy 0 i 377. Na przykład \251 jest sekwencją ósemkową dla symbolu copyright.
\xXXZnaki z kodowaniem Latin-1 określone przez dwie cyfry szesnastkowe XX pomiędzy 00 i FF. Na przykład \xA9 jest szesnastkową sekwencją dla symbolu copyright.
\uXXXXZnak Unicode określony przez cztery cyfry szesnastkowe XXXX. Na przykład \u00A9 jest sekwencją Unicode dla symbolu copyright. Zobacz Sekwencje ucieczki do Unicode.
+

Tabela 2.1: Znaki specjalne w JavaScript +

+
Znaki ucieczki
+

Dla znaków niewymienionych w tabeli powyżej, poprzedzający znak backslash jest ignorowany, ale użycie tego jest wycofywane i powinno być unikane. +

Możesz wstawić znak cudzysłowu wewnątrz łańcucha znaków poprzedzając go znakiem backslash. Znane jest to jako kodowanie (escaping) znaków cudzysłowu. Na przykład: +

+
var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service."
+document.write(quote)
+
+

Rezultatem tego będzie: +

+
He read "The Cremation of Sam McGee" by R.W. Service.
+
+

Aby użyć literału backslash w łańcuchu znaków, musisz zastosować znak backslash. Na przykład, aby przydzielić plikowi ścieżkę c:\temp do łańcucha znaków, użyj następującej konstrukcji: +

+
var home = "c:\\temp "
+
+

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Stałe", "Przewodnik po języku JavaScript 1.5:Unicode") }} +


+

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Literals", "es": "es/Gu\u00eda_JavaScript_1.5/Literales", "fr": "fr/Guide_JavaScript_1.5/Constantes_litt\u00e9rales", "ja": "ja/Core_JavaScript_1.5_Guide/Literals", "ko": "ko/Core_JavaScript_1.5_Guide/Literals", "zh-cn": "cn/Core_JavaScript_1.5_Guide/\u6587\u672c\u5316" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/grammar_and_types_0f7acbcd2fa8bfb327628638da4e5166/index.html b/files/pl/conflicting/web/javascript/guide/grammar_and_types_0f7acbcd2fa8bfb327628638da4e5166/index.html new file mode 100644 index 0000000000..2ab37e779b --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/grammar_and_types_0f7acbcd2fa8bfb327628638da4e5166/index.html @@ -0,0 +1,111 @@ +--- +title: Unicode +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Unicode +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Unicode +--- +

+

+

Unicode

+

Unicode jest uniwersalnym standardem kodowania znaków, dzięki któremu można wyświetlać znaki charakterystyczne dla różnych języków. Obejmuje języki Ameryki, Europy, Środkowego wschodu, Afryki, Indii, Azji i języki pacyficzne (ponadregionalne), ale również inne symbole historyczne czy techniczne. Unicode zamienia, konwertuje i wyświetla wielojęzyczne teksty, symbole techniczne i matematyczne a dzięki temu rozwiązuje wiele międzynarodowych problemów językowych w systemach obliczeniowych związanych ze standardami charakterystycznymi dla konkretnych narodów. Jednak nie wszystkie nowoczesne lub archaiczne języki są obecnie wspierane. +

Zestaw znaków Unicode może być używany praktycznie we wszystkich znanych typach kodowania. Unicode jest modelowany podobnie jak w zestawach znaków ASCII (Amerykański standardowy kod wymiany informacji). Używa opisu literowego i liczbowej wartości dla każdego kodowanego znaku. 16 bitowa wartość jest definiowana jako liczba w systemie szesnastkowym wraz z przedrostkiem U na przykład , U+0041 przedstawia A, a unikalna nazw dla tej wartości to LATIN CAPITAL LETTER A.

Nie jest wspierany w wersjach JavaScript wcześniejszych niż 1.3.

+

Unicode zgodny z ASCII i ISO

+

Unicode jest zgodny z kodami ASCII i jest wspierany przez wiele programów. Pierwsze 128 znaków Unicode odpowiadają kodom ASCII i mają tę samą wartość bajtu. W Unicode, przykładowo, znaki U+0020 i U+007E są równoważne w ASCII znakom 0x20 i 0x7E . Nieco inaczej jest w ASCII, który wspiera łaciński alfabet i używa siedmiobitowego zestawu znaków. Unicode używa szesnastobitowych wartości dla każdego znaku i uwzględnia dziesięć tysięcy znaków. Rozszerzony mechanizm UTF 16, uwzględnia kodowanie miliona znaków więcej, przez używanie 16 bitowych par.

Unicode jest w pełni zgodny z międzynarodowym standardowym ISO/IEC 10646 1; 1993 , który jest podzbiorem ISO 10646 i wspiera ISO Ucs 2, który używa dwu oktetów (dwóch bajtów albo 16 bitów).

JavaScript i Nawigator wspiera Unicode dzięki czemu można używać w JavaScript-ie niełacińskich, międzynarodowych i lokalnych znaków, oraz specjalistycznych symboli technicznych oraz pozwala kodować wielojęzyczny tekst. Odkąd Unicode jest zgodny z ASCII, programy mogą używać znaków ASCII. W komentarzach używać możemy znaków Unicode nie ASCII, literałów string, identyfikatorów i wcześniejszych wyrażeń, i wyrażeń regularnych JavaScript-u. +

+

Sekwencje ucieczki do Unicode

+

Możesz użyć sekwencje ucieczki do Unicode w literałach łańcuchowych, wyrażeniach regularnych i identyfikatorach. Sekwencja ucieczki sześciu znaków ASCII: \u i czterocyfrowa liczba heksadecymalna. Na przykład, \u00A9 reprezentuje symbol copyright. Każda sekwencja ucieczki Unicode w JavaScript-ie jest interpretowana jako jeden znak. +

Następujący kod zawiera symbol copyright i napis "Netscape Communications". +

+
x="\u00A9 Netscape Communications"
+

Następująca tabela jest listą często używanych specjalnych znaków i ich wartości Unicode.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
KategoriaWartość UnicodeNazwaNazwa formatowania
Białe spacje\u0009Tab<TAB>
 \u000BPionowy tabulator<VT>
 \u000CZ kanału<FF>
 \u0020Spacja<SP>
Linia kończąca wartość\u000ALine Feed<LF>
 \u000DPowrót karetki<CR>
Dodatkowe znaki ucieczki Unicode\u0008Backspace<BS>
 \u0009Poziomy tabulator<HT>
 \u0022Podwójny cudzysłów"
 \u0027Pojedynczy cudzysłów'
 \u005C Backslash\
+

Tabela: Wartości Unicode dla specjalnych czcionek +

JavaScript używa sekwencje znaku ucieczki Unicode i jest ona inna niż w Javie. W JavaScript-ie, sekwencja ucieczki nigdy nie interpretuje jako pierwsza znaków specjalnych. Przykładowo, znak końca linii sekwencji ucieczki nie zakańcza ciągu zanim nie jest on zinterpretowany przez funkcje. JavaScript ignoruje każdą sekwencje ucieczki, jeśli jest ona użyta w komentarzu. W Javie, jeśli sekwencja ucieczki używana jest w pojedynczej linii komentarza interpretowana jest wtedy jako znak Unicode. W ciągu literałów kompilator Javy interpretuje wpierw sekwencje ucieczki. Przykładowo, w przypadku użycia w Javie znaku końca linii (\u000A), zakańcza on literał ciągu. W Javie doprowadza to do wystąpienia błędu, ponieważ znaki końca linii nie są dozwolone w literałach ciągów. Musisz użyć \n do zakończenia linii w literałach. W JavaScript-ie sekwencja ucieczki działa tak samo jak \n. +

+
Program do konwersji długich ciągów znaków Hot-Tips' Unicode Converter, autorstwa Bob Foley.
+

Wyświetlanie czcionek z Unicode

+

Można używać Unicode do wyświetlania znaków w rożnych językach lub technicznych symboli. Dla poprawnego wyświetlania klient tj. Netscape Navigator 4.x lub Netscape 6 musi wspomagać Unicode. Dodatkowo odpowiednia czcionka Unicode musi być dostępna dla klienta, jak i platforma klienta musi wspomagać Unicode. Często zdarza się, że czcionki Unicode nie wyświetlają wszystkich znaków. Niektóre platformy tj. Windows 95 posiadają tylko częściowe wsparcie Unicode. +

W celu pobrania znaku typu non-ASCII klient musi go wysłać w kodzie Unicode. Używając standardowej rozszerzonej klawiatury klient nie może łatwo wyświetlić dodatkowych znaków wspieranych przez Unicode. Czasami jedynym sposobem na wyświetlenie znaków w kodzie Unicode jest użycie sekwencji ucieczki Unicode. +

Więcej informacji o Unicode, zobacz Unicode Consortium Web site i The Unicode Standard, Version 2.0, wydane przez Addison-Wesley, 1996. +

{{ PreviousNext("Przewodnik_po_j%C4%99zyku_JavaScript_1.5:Litera%C5%82y#Litera.C5.82y_znakowe", "Przewodnik po języku JavaScript 1.5:Wyrażenia") }} +

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Unicode", "es": "es/Gu\u00eda_JavaScript_1.5/Unicode", "fr": "fr/Guide_JavaScript_1.5/Unicode", "ja": "ja/Core_JavaScript_1.5_Guide/Unicode", "ko": "ko/Core_JavaScript_1.5_Guide/Unicode" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/grammar_and_types_14ae50e0032f9c0db4fe484288797da6/index.html b/files/pl/conflicting/web/javascript/guide/grammar_and_types_14ae50e0032f9c0db4fe484288797da6/index.html new file mode 100644 index 0000000000..3aad9ebd60 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/grammar_and_types_14ae50e0032f9c0db4fe484288797da6/index.html @@ -0,0 +1,64 @@ +--- +title: Zmienne +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Zmienne +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Variables +--- +

 

+

Trzeba całość wyczyścić i uzgodnić z wersją EN: zmiany 06-2006

+

Zmienne

+

Zmiennych używa się jako symbolicznych nazw dla wartości w Twojej aplikacji. Nazwy zmiennych, nazywane identyfikatorami, podporządkowane są pewnym regułom.

+

Identyfikator JavaScript musi zaczynać się literą, podkreśleniem (_) lub znakiem dolara ($); kolejne znaki mogą być cyframi (0-9). Ponieważ JavaScript rozróżnia duże/małe litery, litery oznaczają znaki od "A"do "Z" (duże litery) oraz znaki od "a" do "z" (małe litery).

+

Poczynając od JavaScript 1.5, w identyfikatorze możesz używać znaków ISO 8859-1 lub Unicode takich jak å czy ą. Jako znaków w identyfikatorze możesz także używać \uXXXX - sekwencji ucieczki Unicode wypisanych na stronie Sekwencje ucieczki do Unicode.

+

Niektóre przykłady prawidłowych nazw to Number_hits, temp99 i _name.

+

Deklaracja zmiennych

+

Możesz zadeklarować zmienne na dwa sposoby:

+ +

Ocena zmiennych

+

Zmienna lub element tablicy, którym nie przypisano wartości, mają wartość undefined. Rezultat oceny nieprzydzielonej zmiennej zależny jest od sposobu jej deklaracji:

+ +

Poniższy kod demonstruje ocenę nieprzydzielonych zmiennych.

+
function f1() {
+   return y - 2;
+}
+f1() //Powoduje runtime error
+
+function f2() {
+   return var y - 2;
+}
+f2() //zwraca NaN
+
+

Aby określić, czy zmienna posiada wartość, możesz użyć undefined. W poniższym kodzie zmienna input nie posiada przypisanej wartości, więc instrukcja if przyjmuje wartość true.

+
var input;
+if(input === undefined){
+   doThis();
+} else {
+   doThat();
+}
+

Wartość undefined zachowuje sie jak logiczne false w odpowiednim kontekście (boolean). Poniższy kod wykonuje funkcję myFunction, ponieważ element array nie został zdefiniowany:

+
myArray=new Array()
+if (!myArray[0])
+   myFunction()
+

Podczas oceny wartości zmiennej null, wartość null zachowuje się jak 0 w kontekście numerycznym oraz jako false w kontekście logicznym (boolean). Na przykład:

+
var n = null
+n * 32 //zwraca 0
+

Zakres zmiennych

+

Zmienna zadeklarowana poza jakąkolwiek funkcją nazywana jest zmienną globalną (global); staje się ona dostępna dla dowolnego kodu w bieżącym dokumencie. Zmienna zadeklarowana wewnątrz funkcji staje się zmienną lokalną (local) i dostępna będzie jedynie wewnątrz tej funkcji.

+

Użycie var do zadeklarowania zmiennej global jest opcjonalne. Jednakże, musisz użyć var do zadeklarowania zmiennej wewnątrz funkcji.

+

Masz dostęp do zmiennych globalnych zadeklarowanych w jednym oknie lub ramce z innego okna/ramki poprzez podanie nazwy okna/ramki. Na przykład, jeśli zmienna phoneNumber jest zadeklarowana w dokumencie FRAMESET, to można się do niej odwołać z dokumentu potomnego poprzez parent.phoneNumber.

+

Zmienne globalne

+

Zmienne globalne są w istocie własnościami obiektu globalnego. W stronach internetowych obiektem globalnym jest window. +dodać link wewnętrzny Możesz wiec ustawiać i odczytywać zmienne globalne przy użyciu składni window.zmienna. Analogicznie, podając nazwę ramki lub okna, możesz uzyskać dostęp do zmiennych zadeklarowanych w tym oknie lub ramce z innego okna lub ramki. Przykładowo: jeśli zmienna nazwana numerTelefonu została zadeklarowana w dokumencie FRAMESET, możesz odwołać się do tej zmiennej z ramki podrzędnej poprzez parent.numerTelefonu.

+


+{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Wartości", "Przewodnik po języku JavaScript 1.5:Stałe") }}

+


+

+ +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Variables", "es": "es/Gu\u00eda_JavaScript_1.5/Variables", "fr": "fr/Guide_JavaScript_1.5/Variables", "ja": "ja/Core_JavaScript_1.5_Guide/Variables", "ko": "ko/Core_JavaScript_1.5_Guide/Variables", "zh-cn": "cn/Core_JavaScript_1.5_Guide/\u53d8\u91cf" } ) }}

diff --git a/files/pl/conflicting/web/javascript/guide/grammar_and_types_1d6d13b355b9483ad46cf81082b7c261/index.html b/files/pl/conflicting/web/javascript/guide/grammar_and_types_1d6d13b355b9483ad46cf81082b7c261/index.html new file mode 100644 index 0000000000..7ee3aa056c --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/grammar_and_types_1d6d13b355b9483ad46cf81082b7c261/index.html @@ -0,0 +1,47 @@ +--- +title: Wartości +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Wartości +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Values +--- +

+

+

Wartości

+

JavaScript rozróżnia następujące typy: +

+ +

Ten względnie niewielki zestaw typów wartości - lub typów danych - pozwala wyposażyć Twoją aplikację w wiele użytecznych funkcji. Nie występuje wyraźna różnica pomiędzy liczbami całkowitymi a wartościami rzeczywistymi, tak jak i w JavaScript nie ma w ogóle jawnego rozróżnienia typów danych. Możesz jednak, przykładowo, użyć obiektu Date oraz jego metod do obsługi dat. +

Obiekty i funkcje to inne podstawowe elementy języka. Obiekty można sobie wyobrazić jako nazwane pojemniki na wartości, a funkcje jako procedury, które są wykonywane przez Twoją aplikację. +

+

Konwersja typu danych

+

JavaScript jest językiem programowania o dynamicznych typach. Oznacza to, że przy deklaracji zmiennej nie musisz określać jej typu. Typy danych w razie potrzeby są automatycznie konwertowane w trakcie wykonywania skryptu. Możemy, przykładowo, zadeklarować zmienną następująco:

+
var odpowiedz = 42
+
+

a później przypisać tej samej zmiennej wartość tekstową, na przykład: +

+
odpowiedz = "Dziękuję za wszystkie ryby..."
+
+

Ponieważ JavaScript posiada dynamiczne typy, przypisanie to nie powoduje komunikatu błędu. +

W wyrażeniach z operatorem + zawierających wartość tekstową oraz numeryczną, JavaScript konwertuje wartości numeryczne na tekst. Przyjrzyjmy się następującym instrukcjom.

+
x = "Odpowiedzią jest " + 42 // zwraca "Odpowiedzią jest 42"
+y = 42 + " jest odpowiedzią" // zwraca "42 jest odpowiedzią"
+
+

W wyrażeniach z innymi operatorami, JavaScript nie konwertuje wartości numerycznej do postaci tekstowej. Na przykład:

+
"37" - 7 // zwraca 30
+"37" + 7 // zwraca 377
+
+


+{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Przegląd JavaScriptu", "Przewodnik po języku JavaScript 1.5:Zmienne") }} +

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Values", "es": "es/Gu\u00eda_JavaScript_1.5/Valores", "fr": "fr/Guide_JavaScript_1.5/Valeurs", "ja": "ja/Core_JavaScript_1.5_Guide/Values", "ko": "ko/Core_JavaScript_1.5_Guide/Values", "zh-cn": "cn/Core_JavaScript_1.5_Guide/Values" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide/grammar_and_types_d86447bbdab858af0abf9b17c9ec9dc9/index.html b/files/pl/conflicting/web/javascript/guide/grammar_and_types_d86447bbdab858af0abf9b17c9ec9dc9/index.html new file mode 100644 index 0000000000..2629bdaafc --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/grammar_and_types_d86447bbdab858af0abf9b17c9ec9dc9/index.html @@ -0,0 +1,30 @@ +--- +title: Stałe +slug: Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Stałe +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Constants +--- +

 

+

Stałe

+

Możesz utworzyć stałą (nazwaną i tylko do odczytu) za pomocą słowa kluczowego const. Składnia identyfikatora stałej jest taka sama, jak dla identyfikatora zmiennej: musi zaczynać się literą lub znakiem podkreślenia i obejmować znaki alfabetu lub cyfry.

+
const prefix = '212';
+

Stałe nie mogą podczas wykonywania skryptu zmieniać swojej wartości, ani być ponownie deklarowane.

+

Reguły zasięgu dotyczące stałych są takie same jak dla zmiennych, z wyjątkiem tego, że słowo kluczowe const jest wymagane zawsze, nawet dla stałych globalnych. W przypadku braku słowa kluczowego przyjmuje się, że identyfikator oznacza zmienną.

+

Nie można deklarować stałych o nazwie identycznej z nazwą zmiennej występującej w zasięgu tej samej funkcji. Na przykład:

+
//TO SPOWODUJE BŁĄD
+function f{};
+const f = 5;
+
+//TO RÓWNIEŻ SPOWODUJE BŁĄD
+function f{
+const g=5;
+var g;
+
+//instrukcje
+}
+

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Zmienne", "Przewodnik po języku JavaScript 1.5:Literały") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Constants", "es": "es/Gu\u00eda_JavaScript_1.5/Constantes", "fr": "fr/Guide_JavaScript_1.5/Constantes", "ja": "ja/Core_JavaScript_1.5_Guide/Constants", "ko": "ko/Core_JavaScript_1.5_Guide/Constants" } ) }}

diff --git a/files/pl/conflicting/web/javascript/guide/index.html b/files/pl/conflicting/web/javascript/guide/index.html new file mode 100644 index 0000000000..8b98a8450f --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/index.html @@ -0,0 +1,11 @@ +--- +title: Obsolete Pages +slug: Web/JavaScript/Guide/Obsolete_Pages +tags: + - NeedsTranslation + - TopicStub +translation_of: Web/JavaScript/Guide +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages +--- +

This is a list of pages that have been merged into chapters (in alphabetical order):

+

{{ tree() }}

diff --git a/files/pl/conflicting/web/javascript/guide/introduction/index.html b/files/pl/conflicting/web/javascript/guide/introduction/index.html new file mode 100644 index 0000000000..1f54eaca0f --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide/introduction/index.html @@ -0,0 +1,139 @@ +--- +title: O tym przewodniku +slug: Web/JavaScript/Guide/o_tym_przewodniku +translation_of: Web/JavaScript/Guide/Introduction +translation_of_original: Web/JavaScript/Guide/About +--- +

JavaScript jest międzyplatformowym, zorientowanym obiektowo językiem skryptowym. Poniższy przewodnik tłumaczy wszystko, co powinieneś wiedzieć abyś mógł posługiwać się JavaScriptem.

+ +

Nowe opcje w JavaScripcie

+ +

 

+ + + +

 

+ +

Co już powinieneś wiedzieć

+ +

Ten przewodnik zakłada że masz poniższe podstawy:

+ + + +

Wersje JavaScriptu

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Tabela 1 JavaScript i wersje Navigatora
Wersja JavaScriptuWersja Navigatora
JavaScript 1.0Navigator 2.0
JavaScript 1.1Navigator 3.0
JavaScript 1.2Navigator 4.0-4.05
JavaScript 1.3Navigator 4.06-4.7x
JavaScript 1.4 
JavaScript 1.5Navigator 6.0
+ Mozilla (open sourceowa przeglądarka)
JavaScript 1.6Firefox 1.5, inne przeglądarki oparte na Mozilli 1.8
JavaScript 1.7Firefox 2, inne przeglądarki oparte na Mozilli 1.8.1
JavaScript 1.8Firefox 3, inne przeglądarki oparte na Gecko 1.9
+ +

Gdzie znaleźć informacje o JavaScripcie

+ +

Dokumentacja JavaScript zawiera następujące książki:

+ + + +

Jeżeli dopiero zaczynasz swoją przygodę z JavaScriptem, zacznij od Przewodnika JavaScript. Jeżeli posiądziesz już podstawowe umiejętności, możesz przejśc do JavaScript Reference aby zdobyć bardziej szczegółową, dogłębną wiedzę.

+ +

Jak się uczyć JavaScriptu

+ +

Rozpoczęcie nauki JavaScriptu jest proste: wszystko czego potrzebujesz to nowoczesna przeglądarka internetowa. Ten przewodnik zawiera skrypty działające jedynie w najnowszej wersji Firefoxa (i innych przeglądarkach opartych na Gecko), także sugerujemy używanie jego najnowszej wersji.

+ +

Interaktywny interpreter

+ +

Interaktywna konsola JavaScriptowa stanowi nieocenioną pomoc przy nauce, pozwala ona testować skrypty bez zapisywania plików i odświeżania okna przeglądarki. Konsola błędów w Firefoxie (Narzędzia-Dla twórców WWW-Konsola WWW lub też Ctrl+Shift+K) dostarcza prosty sposób by przetesować JavaScript: poprostu wpisz linijkę kodu i zatwierdź ją Enterem.

+ +

Konsola www w Firefoxie 25.0.1

+ +

 

+ +

Firebug

+ +

Bardziej zaawansowana konsola dostępna jest po zainstalowaniu dodatku do Firefoxa o nazwie Firebug. Wyrażenia, które wprowadzisz są interpretowane jako obiekty i są połączone z innymi częsciami Firebuga. Prosty przykład: 

+ +

+ +

 

+ +

Użycie strzałki znajdującej się w prawym, dolnym rogu pozwala wprowadzać wielolinijkowy kod.

+ +

Firebug udostępnia również zaawansowany inspektor DOM, debugger JavaScriptu oraz wiele innych, użytecznych funkcji. Kod JavaScript działający na stronie może użyć funkcji console.log(), służącej do wyświewtlania zawartości w konsoli Firebuga.

+ +

Konwencje tekstowe w tym dokumencie

+ +

Aplikacje JavaScriptu działają na wielu systemach operacyjnych, informacje zawarte w tej książce odnoszą się do wszystkich tych wersji. Ścierzki do plików i katalogów zapisane są w formacie Windowsowym (z backslashami oddzielającymi nazwy folderów). Wsystemach Unixowych backslashe nalezy zastąpić slashami. 

+ +

Adresy URL w tym przewodniku mają następującą formę:

+ +

http://serwer.domena/sciezka/plik.html

+ +

W tych URLach serwer reprezentuje nazwę serwera, którego używasz, np. test1 czy www; domena to nazwa Twojej domeny np. netscape.com czy uiuc.edu; sciezka odpowiada za lokalizację pliku na twoim serwerze zaś plik.html to konkretna nazwa pliku. Ogólnie rzecz ujmując w adresie URL teksty pisane czcionką pochyłą oznacza lokalizację pliku zaś te pisane czcionką o stałej szerokości to literały. Jeżeli twój serwer ma włączony protokół SSL, zamiast używać przedrostka http, posługiwać się będziesz https.

+ +

Przewodnik ten używa następujących konwencji tekstowych:

+ + diff --git a/files/pl/conflicting/web/javascript/guide_1093f218406d2d64ec91bb7a6bda93ce/index.html b/files/pl/conflicting/web/javascript/guide_1093f218406d2d64ec91bb7a6bda93ce/index.html new file mode 100644 index 0000000000..7a1b84d5a1 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide_1093f218406d2d64ec91bb7a6bda93ce/index.html @@ -0,0 +1,25 @@ +--- +title: Obiekty predefiniowane +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Core_Objects +--- +

+

+

Obiekty predefiniowane

+

Artykuł opisuje obiekty predefiniowane w JavaScript:

+ +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "es": "es/Gu\u00eda_JavaScript_1.5/Objetos_base_predefinidos", "fr": "fr/Guide_JavaScript_1.5/Objets_pr\u00e9d\u00e9finis", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "ko": "ko/Core_JavaScript_1.5_Guide/Predefined_Core_Objects" } ) }} diff --git a/files/pl/conflicting/web/javascript/guide_a026fc5d05de582c88d39cf9fd37870d/index.html b/files/pl/conflicting/web/javascript/guide_a026fc5d05de582c88d39cf9fd37870d/index.html new file mode 100644 index 0000000000..3e5a4b8609 --- /dev/null +++ b/files/pl/conflicting/web/javascript/guide_a026fc5d05de582c88d39cf9fd37870d/index.html @@ -0,0 +1,876 @@ +--- +title: Przewodnik po języku JavaScript 1.5 +slug: Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5 +tags: + - AJAX + - JavaScript + - Projekt_MDC + - Przewodnik_JavaScript + - Strony_do_aktualizacji + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Table_of_Contents_2.0 +--- +

O tym przewodniku

+ +
+
Nowe możliwości tego wydania
+
+ +
+
Co już powinieneś wiedzieć
+
+ +
+
Wersje JavaScriptu
+
+ +
+
Gdzie szukać informacji o JavaScripcie
+
+ +
+
Konwencje dokumentu
+
+ +

Przegląd JavaScriptu

+ +
+
Czym jest JavaScript?
+
+ +
+
JavaScript i Java
+
+ +
+
JavaScript i specyfikacja ECMA
+
+ +
+
+
+
Związek pomiędzy JavaScript, a wersją ECMA
+
+
+
+ +
+
+
+
Dokumentacja JavaScript w porównaniu ze specyfikacją ECMA
+
+
+
+ +
+
+
+
Terminologia JavaScriptu i ECMA
+
+
+
+ +

Funkcjonalność języka

+ +
+
Wartości
+
+ +
+
+
+
Konwersja typu danych
+
+
+
+ +
+
Zmienne
+
+ +
+
+
+
Deklaracja zmiennych
+
+
+
+ +
+
+
+
Ocena zmiennych
+
+
+
+ +
+
+
+
Zakres zmiennych
+
+
+
+ +
+
Stałe
+
+ +
+
Literały
+
+ +
+
+
+
Literały tablicy
+
+
+
+ +
+
+
+
Literały logiczne
+
+
+
+ +
+
+
+
Literały całkowite
+
+
+
+ +
+
+
+
Literały zmiennoprzecinkowe
+
+
+
+ +
+
+
+
Literały obiektu
+
+
+
+ +
+
+
+
Literały znakowe
+
+
+
+ +
+
Unicode
+
+ +
+
+
+
Unicode zgodny z ASCII i ISO
+
+
+
+ +
+
+
+
Sekwencje ucieczki do Unicode
+
+
+
+ +
+
+
+
Wyświetlanie czcionek z Unicode
+
+
+
+ +

Wyrażenia i operatory

+ +
+
Wyrażenia
+
+ +
+
Operatory
+
+ +
+
+
+
Operatory przypisania
+
+
+
+ +
+
+
+
Operatory porównania
+
+
+
+ +
+
+
+
Operatory arytmetyczne
+
+
+
+ +
+
+
+
Operatory bitowe
+
+
+
+ +
+
+
+
Operatory logiczne
+
+
+
+ +
+
+
+
Operacje na łańcuchach
+
+
+
+ +
+
+
+
Operatory specjalne
+
+
+
+ +
+
+
+
Pierwszeństwo operatorów
+
+
+
+ +

Wyrażenia regularne

+ +
+
Tworzenie wyrażenia regularnego
+
+ +
+
Zapisywanie wzorca wyrażenia regularnego
+
+ +
+
+
+
Używanie prostego wzoru
+
+
+
+ +
+
+
+
Używanie specjalnych znaków
+
+
+
+ +
+
+
+
Używanie nawiasów
+
+
+
+ +
+
Praca z wyrażeniami regularnymi
+
+ +
+
+
+
Użycie odpowiedniego znaku
+
+
+
+ +
+
+
+
Globalne wyszukiwanie, wielkość znaków, wieloliniowe wejście
+
+
+
+ +
+
+
+
Przykłady
+
+
+
+ +

Instrukcje

+ +
+
Blok instrukcji
+
+ +
+
Instrukcje warunkowe
+
+ +
+
+
+
Instrukcja if...else
+
+
+
+ +
+
+
+
Instrukcja switch
+
+
+
+ +
+
Instrukcje pętli
+
+ +
+
+
+
Instrukcja for
+
+
+
+ +
+
+
+
Instrukcja do...while
+
+
+
+ +
+
+
+
Instrukcja while
+
+
+
+ +
+
+
+
Instrukcja label
+
+
+
+ +
+
+
+
Instrukcja break
+
+
+
+ +
+
+
+
Instrukcja continue
+
+
+
+ +
+
Instrukcje manipulacji obiektem
+
+ +
+
+
+
Instrukcja for...in
+
+
+
+ +
+
+
+
Instrukcja with
+
+
+
+ +
+
Komentarze
+
+ +
+
Instrukcje obsługi wyjątków
+
+ +
+
+
+
Instrukcja throw
+
+
+
+ +
+
+
+
Instrukcja try...catch
+
+
+
+ +

Funkcje

+ +
+
Definiowanie funkcji
+
+ +
+
Wywołanie funkcji
+
+ +
+
Zastosowanie obiektu arguments
+
+ +
+
Funkcje predefiniowane
+
+ +
+
+
+
Funkcja eval
+
+
+
+ +
+
+
+
Funkcja isFinite
+
+
+
+ +
+
+
+
Funkcja isNaN
+
+
+
+ +
+
+
+
Funkcje parseInt i parseFloat
+
+
+
+ +
+
+
+
Funkcje Number i String
+
+
+
+ +
+
+
+
Funkcje escape i unescape
+
+
+
+ +
+
Praca z zamknięciami
+
+ +

Praca z obiektami

+ +
+
Obiekty i własności
+
+ +
+
Tworzenie nowych obiektów
+
+ +
+
+
+
Używanie inicjacji obiektu
+
+
+
+ +
+
+
+
Używanie konstruktorów funkcji
+
+
+
+ +
+
+
+
Indeksowanie własności obiektu
+
+
+
+ +
+
+
+
Definiowanie własności typu obiektu
+
+
+
+ +
+
+
+
Definiowanie metod
+
+
+
+ +
+
+
+
Używanie 'this' do obiektu referencji
+
+
+
+ +
+
+
+
Definiowanie metod pobierania i ustawiania
+
+
+
+ +
+
+
+
Usuwanie własności
+
+
+
+ +
+
Obiekty predefiniowane
+
+ +
+
+
+
Obiekt Array
+
+
+
+ +
+
+
+
Obiekt Boolean
+
+
+
+ +
+
+
+
Obiekt Date
+
+
+
+ +
+
+
+
Obiekt function
+
+
+
+ +
+
+
+
Obiekt Math
+
+
+
+ +
+
+
+
Obiekt Number
+
+
+
+ +
+
+
+
Obiekt RegExp
+
+
+
+ +
+
+
+
Obiekt String
+
+
+
+ +

Detale modelu obiektowego

+ +
+
Języki oparte na klasach vs. oparte na prototypach
+
+ +
+
+
+
Definiowanie klasy
+
+
+
+ +
+
+
+
Podklasy i dziedziczenie
+
+
+
+ +
+
+
+
Dodawanie i usuwanie własności
+
+
+
+ +
+
+
+
Różnice
+
+
+
+ +
+
Praca z przykładem
+
+ +
+
+
+
Tworzenie hierarchii
+
+
+
+ +
+
+
+
Własności obiektu
+
+
+
+ +
+
+
+
+
+
Dziedziczenie własności
+
+
+
+
+
+ +
+
+
+
+
+
Dodawanie własności
+
+
+
+
+
+ +
+
+
+
Więcej elastycznych konstruktorów
+
+
+
+ +
+
Powrót dziedziczenia własności
+
+ +
+
+
+
Wartości lokalne vs. dziedziczone
+
+
+
+ +
+
+
+
Określanie wzajemnych relacji obiektu
+
+
+
+ +
+
+
+
Globalne informacje w konstruktorach
+
+
+
+ +
+
+
+
Brak wielokrotnego dziedziczenia
+
+
+
+ +

Podgląd klas LiveConnect

+ +
+
Praca z klasą opakowującą
+
+ +
+
Komunikacja między JavaScript a Java
+
+ +
+
+
+
Obiekt opakowujący
+
+
+
+ +
+
+
+
Praca z tablicami w Javie
+
+
+
+ +
+
+
+
Referencja paczki i klasy
+
+
+
+ +
+
+
+
Argumenty typu char
+
+
+
+ +
+
+
+
Obsługa wyjątków Javy w JavaScript
+
+
+
+ +
+
Komunikacja między Java a JavaScript
+
+ +
+
+
+
Używanie klas LiveConnect
+
+
+
+ +
+
Konwersja typu danych
+
+ +
+
+
+
Konwersja JavaScript do Java
+
+
+
+ +
+
+
+
Konwersja Java do JavaScript
+
+
+
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 new file mode 100644 index 0000000000..26fe611df4 --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/global_objects/boolean/index.html @@ -0,0 +1,49 @@ +--- +title: Boolean.prototype +slug: Web/JavaScript/Referencje/Obiekty/Boolean/prototype +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 +--- +
{{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 new file mode 100644 index 0000000000..e95fcabc0c --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/global_objects/date/index.html @@ -0,0 +1,19 @@ +--- +title: constructor +slug: Web/JavaScript/Referencje/Obiekty/Date/constructor +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 +--- +

+

+

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 new file mode 100644 index 0000000000..209f7b25a8 --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/global_objects/date_73c046d653c590f4914731d078f3b2c5/index.html @@ -0,0 +1,116 @@ +--- +title: Date.prototype +slug: Web/JavaScript/Referencje/Obiekty/Date/prototype +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 +--- +

{{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 new file mode 100644 index 0000000000..9bb3ccbf13 --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/global_objects/error/index.html @@ -0,0 +1,114 @@ +--- +title: Error.prototype +slug: Web/JavaScript/Referencje/Obiekty/Error/prototype +tags: + - Error + - JavaScript + - Właściwość +translation_of: Web/JavaScript/Reference/Global_Objects/Error +translation_of_original: Web/JavaScript/Reference/Global_Objects/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 new file mode 100644 index 0000000000..11b7dbe2de --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/global_objects/number/index.html @@ -0,0 +1,23 @@ +--- +title: constructor +slug: Web/JavaScript/Referencje/Obiekty/Number/constructor +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 +--- +

+

+

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 new file mode 100644 index 0000000000..85fbee9f9b --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/global_objects/object/index.html @@ -0,0 +1,219 @@ +--- +title: Object.prototype +slug: Web/JavaScript/Referencje/Obiekty/Object/prototype +tags: + - JavaScript + - Obiekt + - Object + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object +translation_of_original: Web/JavaScript/Reference/Global_Objects/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 new file mode 100644 index 0000000000..38c00cc45b --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/global_objects/rangeerror/index.html @@ -0,0 +1,124 @@ +--- +title: RangeError.prototype +slug: Web/JavaScript/Referencje/Obiekty/RangeError/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/RangeError +translation_of_original: Web/JavaScript/Reference/Global_Objects/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 new file mode 100644 index 0000000000..84a0d73ccc --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/global_objects/regexp/index.html @@ -0,0 +1,54 @@ +--- +title: RegExp.prototype +slug: Web/JavaScript/Referencje/Obiekty/RegExp/prototype +tags: + - JavaScript + - Property + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +translation_of_original: Web/JavaScript/Reference/Global_Objects/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 new file mode 100644 index 0000000000..7785d0b34b --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,221 @@ +--- +title: String.prototype +slug: Web/JavaScript/Referencje/Obiekty/String/prototype +tags: + - JavaScript + - Property + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +translation_of_original: Web/JavaScript/Reference/Global_Objects/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 new file mode 100644 index 0000000000..38b693de3a --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/lexical_grammar/index.html @@ -0,0 +1,18 @@ +--- +title: Słowa zarezerwowane +slug: Web/JavaScript/Referencje/Słowa_zarezerwowane +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Lexical_grammar#Keywords +translation_of_original: Web/JavaScript/Reference/Reserved_Words +--- +

 

+

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 new file mode 100644 index 0000000000..2f4eddc1e9 --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/operators/index.html @@ -0,0 +1,559 @@ +--- +title: Operatory bitowe +slug: Web/JavaScript/Referencje/Operatory/Bitwise_Operators +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/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 new file mode 100644 index 0000000000..c8cc1533f8 --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/operators/spread_syntax/index.html @@ -0,0 +1,230 @@ +--- +title: Spread syntax +slug: Web/JavaScript/Referencje/Operatory/Spread_operator +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 +--- +
{{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 new file mode 100644 index 0000000000..5b2c216efd --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/operators_1d09774e621bf2431a4f5594a248dd21/index.html @@ -0,0 +1,35 @@ +--- +title: Operatory działające na ciągach znaków +slug: Web/JavaScript/Referencje/Operatory/Operatory_działające_na_ciągach_znaków +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 +--- +

+

+

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 new file mode 100644 index 0000000000..474545150a --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/operators_1f6634ff6e3ccef661281d6e50002147/index.html @@ -0,0 +1,268 @@ +--- +title: Operatory arytmetyczne +slug: Web/JavaScript/Referencje/Operatory/Operatory_arytmetyczne +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators +--- +
+
{{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 new file mode 100644 index 0000000000..0184512551 --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/operators_5ba63337c20d72b8f8747a954b9b6c94/index.html @@ -0,0 +1,130 @@ +--- +title: Operatory porównania +slug: Web/JavaScript/Referencje/Operatory/Operatory_porównania +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators +--- +
{{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 new file mode 100644 index 0000000000..e690c5a24d --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html @@ -0,0 +1,254 @@ +--- +title: Operatory logiczne +slug: Web/JavaScript/Referencje/Operatory/Logical_Operators +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/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 new file mode 100644 index 0000000000..8c1e9b85f3 --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/operators_de3666cd349851054926d5e52fced70d/index.html @@ -0,0 +1,75 @@ +--- +title: Operatory przypisania +slug: Web/JavaScript/Referencje/Operatory/Operatory_przypisania +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators#Assignment_operators +translation_of_original: Web/JavaScript/Reference/Operators/Assignment_Operators +--- +
{{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 new file mode 100644 index 0000000000..39641836b8 --- /dev/null +++ b/files/pl/conflicting/web/javascript/reference/statements/switch/index.html @@ -0,0 +1,121 @@ +--- +title: default +slug: Web/JavaScript/Referencje/Polecenia/default +tags: + - JavaScript + - słowo kluczowe +translation_of: Web/JavaScript/Reference/Statements/switch +translation_of_original: Web/JavaScript/Reference/Statements/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