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 --- .../index.html" | 20 + .../instrukcje_manipulacji_obiektem/index.html" | 50 ++ .../index.html" | 42 + .../instrukcja_throw/index.html" | 45 + .../instrukcja_try...catch/index.html" | 114 +++ .../instrukcja_break/index.html" | 27 + .../instrukcja_continue/index.html" | 51 ++ .../instrukcja_do_...while/index.html" | 23 + .../instrukcja_for/index.html" | 56 ++ .../instrukcja_label/index.html" | 23 + .../instrukcja_while/index.html" | 38 + .../o_tym_przewodniku/index.html" | 159 ++++ .../obiekt_array/index.html" | 94 +++ .../obiekt_boolean/index.html" | 14 + .../obiekty_predefiniowane/obiekt_date/index.html" | 87 ++ .../obiekt_function/index.html" | 50 ++ .../obiekty_predefiniowane/obiekt_math/index.html" | 72 ++ .../obiekt_number/index.html" | 83 ++ .../obiekt_regexp/index.html" | 12 + .../obiekt_string/index.html" | 92 +++ .../operatory/operatory_przypisania/index.html" | 67 ++ .../podgl\304\205d_klas_liveconnect/index.html" | 47 ++ .../praca_z_przyk\305\202adem/index.html" | 37 + .../tworzenie_hierarchii/index.html" | 149 ++++ .../dodawanie_w\305\202asno\305\233ci/index.html" | 23 + .../index.html" | 33 + .../w\305\202asno\305\233ci_obiektu/index.html" | 19 + .../index.html" | 122 +++ .../praca_z_zamkni\304\231ciami/index.html" | 286 +++++++ .../definiowanie_metod/index.html" | 48 ++ .../index.html" | 19 + .../index.html" | 16 + .../tworzenie_nowych_obiekt\303\263w/index.html" | 22 + .../usuwanie_w\305\202asno\305\233ci/index.html" | 26 + .../u\305\274ywanie_inicjacji_obiektu/index.html" | 36 + .../index.html" | 32 + .../index.html" | 62 ++ .../index.html" | 43 + .../index.html" | 215 +++++ .../zastosowanie_obiektu_arguments/index.html" | 41 + .../web/javascript/na_pocz\304\205tek/index.html" | 903 +++++++++++++++++++++ .../global_objects/array/prototype/index.html | 12 + .../konwencje_formatowania_tekstu/index.html | 31 + 43 files changed, 3441 insertions(+) create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/dodawanie_obiektom_nowej_funkcjonalno\305\233ci/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_manipulacji_obiektem/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/instrukcja_throw/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/instrukcja_try...catch/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_break/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_continue/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_do_...while/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_for/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_label/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_while/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/o_tym_przewodniku/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_array/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_boolean/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_date/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_function/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_math/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_number/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_regexp/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_string/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/operatory/operatory_przypisania/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/podgl\304\205d_klas_liveconnect/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/tworzenie_hierarchii/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/dodawanie_w\305\202asno\305\233ci/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/dziedziczenie_w\305\202asno\305\233ci/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_wyra\305\274eniami_regularnymi/przyk\305\202ady_wyra\305\274e\305\204_regularnych/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_zamkni\304\231ciami/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/definiowanie_metod/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/definiowanie_w\305\202asno\305\233ci_typu_obiektu/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/indeksowanie_w\305\202asno\305\233ci_obiektu/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/usuwanie_w\305\202asno\305\233ci/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/u\305\274ywanie_inicjacji_obiektu/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/zastosowanie_'this'_do_obiektu_referencji/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/zastosowanie_konstruktor\303\263w_funkcji/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_wyra\305\274enia_regularnego/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/zapisywanie_wzorca_wyra\305\274enia_regularnego/index.html" create mode 100644 "files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/zastosowanie_obiektu_arguments/index.html" create mode 100644 "files/pl/orphaned/web/javascript/na_pocz\304\205tek/index.html" create mode 100644 files/pl/orphaned/web/javascript/reference/global_objects/array/prototype/index.html create mode 100644 files/pl/orphaned/web/javascript/referencje/o_tym_dokumencie/konwencje_formatowania_tekstu/index.html (limited to 'files/pl/orphaned/web/javascript') diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/dodawanie_obiektom_nowej_funkcjonalno\305\233ci/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/dodawanie_obiektom_nowej_funkcjonalno\305\233ci/index.html" new file mode 100644 index 0000000000..9ba9895af5 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/dodawanie_obiektom_nowej_funkcjonalno\305\233ci/index.html" @@ -0,0 +1,20 @@ +--- +title: Dodawanie obiektom nowej funkcjonalności. +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Dodawanie_obiektom_nowej_funkcjonalności. +--- +

Każdy obiekt JavaScriptu posiada zadeklarowane, właściwe dla siebie funkcje, jak np. obiekt String posiada takie funkcje jak toUpperCase() czy toLowerCase(), które odpowiadają odpowiednio za przekonwertowanie liter na duże i małe. Za pomocą prototypów możemy dodać własne funkcje. Poniżej przedstawiony został kod, który zwraca pierwszą literę łańcucha znaków, na którym została wykonana nasza metoda.

+

 

+

String.prototype.firstLetter = function() {

+

 var callObject = this;

+

 return callObject.charAt(0);
+

+

};

+

 

+

Dysponując tak przygotowanym kodem, możemy teraz użyć naszej metody firstLetter() na dowolnym łańcuchu znaków.

+

 

+

alert("hello".firstLetter());

+

 

+

Powyższy kod wyświetli w okienku dialogowym typu alert literę h.

+

 

+

 

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_manipulacji_obiektem/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_manipulacji_obiektem/index.html" new file mode 100644 index 0000000000..45442f2c63 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_manipulacji_obiektem/index.html" @@ -0,0 +1,50 @@ +--- +title: Instrukcje manipulacji obiektem +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_manipulacji_obiektem +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Instrukcja manipulacji obiektem

+

JavaScript używa instrukcji for...in i with do manipulacji obiektami.

+

Instrukcja for...in

+

Instrukcja for...in cyklicznie powtarza specyficzną wartość wszystkich właściwości obiektu. Dla każdej oddzielnej właściwości, JavaScript wykonuje specyficzna instrukcję. Instrukcja for...in wygląda jak pętle:

+
for (variable in object) {
+   instrukcje
+}
+
+

Przykład
+ Następujaca funkcja pobiera obiekt i jego nazwę jako argument. Następnie iteruje ją nad wszystkimi właściwościami obiektu i zwraca łańcuch, którym jest lista właściwościami nazw i ich wartości.

+
function dump_props(obj, obj_name) {
+   var result = "";
+   for (var i in obj) {
+      result += obj_name + "." + i + " = " + obj[i] + "<BR>"
+   }
+   result += "<HR>";
+   return result;
+}
+
+

Dla obiektu car z właściwościami make i model, będzie rezultat:

+
car.make = Ford
+car.model = Mustang
+
+

Instrukcja with

+

Instrukcja with nawiązuje z domyślnym obiektem for ustawienia instrukcji. W JavaScript jakikolwiek z niewykwalifikowanych nazw bez ustawień instrukcji określającej domyślny obraz. Jeśli niewykwalifikowana nazwa odpowiada właściwości, to właściwość jest użyta w instrukcji; w przeciwnym wypadku zostanie użyta, zmienna lokalna lub globalna.

+

Składnia pętli with wygląda:

+
with (object){
+   instrukcja
+}
+
+

Przykład
+ Następująca instrukcja with określa, że obiekt Math jest obiektem domyślnym. Następująca instrukcja with odwołuje sie do właściwości instrukcji metod PI i cos i sin, bez specyficznego obiektu. JavaScript bierze na siebie obiekt Math dla tych referencji.

+
var a, x, y;
+var r=10
+with (Math) {
+   a = PI * r * r;
+   x = r * cos(PI);
+   y = r * sin(PI/2);
+}
+
+

Nota: Używając instrukcji with znacząco spowolniasz jego działanie.

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/index.html" new file mode 100644 index 0000000000..a31e3144d3 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/index.html" @@ -0,0 +1,42 @@ +--- +title: Instrukcje obsługi wyjątków +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_obsługi_wyjątków +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Instrukcje obsługi wyjątków

+

Możesz wywoływać wyjątki używając instrukcji throw i obsługiwać je za pomocą instrukcji try...catch.

+

Instrukcji try...catch używa się również do obsługi wyjątków Javy. Zobacz Obsługa wyjątków Javy w JavaScript i Komunikacja między Java a JavaScript, aby uzyskać więcej informacji.

+ +

Typy wyjątków

+

Niemal każdy wyjątek może zostać wywołany w JavaScripcie. Niemniej jednak nie wszystkie wywołane obiekty są tworzone jako równe. Choć częste jest wyświetlanie liczb lub łańcuchów znaków jako błędów, użycie jednego z typów wyjątków stworzonych szczególnie do tego celu jest bardziej efektywne:

+ +

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Instrukcje komentarzy", "Przewodnik po języku JavaScript 1.5:Instrukcje obsługi wyjątków:Instrukcja throw") }}

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/instrukcja_throw/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/instrukcja_throw/index.html" new file mode 100644 index 0000000000..d09220143a --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/instrukcja_throw/index.html" @@ -0,0 +1,45 @@ +--- +title: Instrukcja throw +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_obsługi_wyjątków/Instrukcja_throw +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +
+

Instrukcja throw

+

Użyj instrukcji throw, aby wywołać wyjątek. Gdy wywołujesz wyjątek, określasz wyrażenie zawierające wartość, która ma zostać wywołana:

+ 
throw wyrazenie;
+
+

Możesz wywołać dowolne wyrażenie, nie tylko wyrażenie konkretnego typu. Poniższy kod wywołuje kilka wyjątków różnych typów:

+ 
throw "Error2";
+throw 42;
+throw true;
+throw {toString: function() { return "Jestem obiektem!"; } };
+
+
+ Uwaga: Możesz określić obiekt podczas wywoływania wyjątku. Można się wtedy odnieść do własności obiektu w bloku catch. Poniższy przykład tworzy obiekt myUserException typu UserException i używa go w instrukcji throw.
+

 

+ 
// Utwórz obiekt typu UserException
+function UserException (message)
+{
+  this.message=message;
+  this.name="UserException";
+}
+
+// Przekonwertuj wyjątek do ładnego łańcucha znaków,
+// gdy ma on zostać użyty jako łańcuch znaków (np. przez konsolę błędów)
+UserException.prototype.toString = function ()
+{
+  return this.name + ': "' + this.message + '"';
+}
+
+// Utwórz instancję typu obiektu i wywołaj ją
+throw new UserException("Za duża wartość");
+
+
+

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Instrukcje obsługi wyjątków", "Przewodnik po języku JavaScript 1.5:Instrukcje obsługi wyjątków:Instrukcja try...catch") }}

+
+
+

 

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/instrukcja_try...catch/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/instrukcja_try...catch/index.html" new file mode 100644 index 0000000000..229633025c --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_obs\305\202ugi_wyj\304\205tk\303\263w/instrukcja_try...catch/index.html" @@ -0,0 +1,114 @@ +--- +title: Instrukcja try...catch +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_obsługi_wyjątków/Instrukcja_try...catch +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Instrukcja try...catch

+

Instrukcja try...catch śledzi blok instrukcji try, i określa jedną lub więcej odpowiedzi które powinny wyrzucić wyjątki. Jeśli wyjątek jest rzucony, instrukcja try...catch go łapie.

+

Instrukcja try...catch stanowi blok try, który stanowi jedną lub więcej instrukcji, i zero lub więcęj bloków stanowiących catch, instrukcję, który określa będzie wykonana jeśli wyjątek wystąpi w bloku try. To jest, to co nastąpi w bloku try, i jeśli nie nastąpi, chcesz przejąć kontrolę bloku catch. Jeśli jakakolwiek instrukcja bez bloku try (lub w nazwie funkcji nie występuje blok try) wyrzucany jest wyjątek, kontrola natychmiastowo wraca do bloku wyjątku, catch. Jeśli nie jest wyrzucony wyjątek w następującym bloku try, blok catch zostanie opuszczony. Blok kończący (finall) wykonany jest po wykonanych blokach try i catch przed instrukcjami następująca instrukcja try...catch.

+

Następujący przykład używa instrukcji try...catch. Przykład nazywa się funkcją, która odzyskuje nazwę miesiąca z tablicy, która jest ulokowana w wartości przychodzącej do funkcji. Jeśli wartość nie jest przesyłana jako numer miesiąca (1-12), wyrzucony jest wyjątek wartości InvalidMonthNo i instrukcje w bloku catch ustawiają zmienną monthName na unknown.

+
function getMonthName (mo) {
+    mo=mo-1; // Adjust month number for array index (1=Jan, 12=Dec)
+    var months=new Array("Jan","Feb","Mar","Apr","May","Jun","Jul",
+          "Aug","Sep","Oct","Nov","Dec");
+    if (months[mo] != null) {
+       return months[mo]
+    } else {
+       throw "InvalidMonthNo"
+    }
+}
+
+try {
+// statements to try
+    monthName=getMonthName(myMonth) // function could throw exception
+}
+catch (e) {
+    monthName="unknown"
+    logMyErrors(e) // pass exception object to error handler
+}
+
+

Blok catch

+

Użyj pojedyńczego bloku catch do uchwytu wszystkich wyjątków, które mogą generować w bloku try, lub Ty potrafisz użyć separatora bloków catch, każdego, którego uchwyty są szczególnym typem wyjątku.

+

Pojedyńczy blok catch
+ Użyj pojedyńczej instrukcji try...catch, bloku catch (odzyskanie bloku) wykonane kodu błędu uchwytu dla kazdego wyjątku wyrzuconego w bloku try.

+

Pojedyńczy blok catch ma następującą składnie:

+
catch (catchID) {
+  statements
+}
+
+

Blok catch wyszczególnia identyfikatory (catchID w poprzedzającej składni), którego wartość jest trzymana w bliżej określnonej instrukcji throw; użyj tego identyfikatora do pobrania informacji o wyjątku, który był zrzucony. JavaScript tworzy ten identyfikator, kiedy catch jest wstępem; ostatni identyfikator tylko dla czasu działanaia bloku catch; po bloku catch kończy wykonywanie identyfikatora, który jest nie długo dostępny.

+

Na przykład, następujący kod wyrzuca wyjątek. Kiedy wyjątek ma miejsce kontrolne cesje są w bloku catch.

+
try {
+   throw "myException" // generuje wyjątek
+}
+catch (e) {
+// instrukcja trzymająca jakikolwiek wyjątek
+   logMyErrors(e) // przechodzi z obiektu wyjątku exception object to error handler
+}
+
+

Wielokrotne bloki catch
+ Pojedyńcza instrukcja try stanowi wielokrotny warunkowe bloki catch, każdy który trzyma określony typ wyjątku. W tym przypadku przywłaszcza odpowiedni warunek blok catch jest możliwy wstęp tylko kiedy wyjątek określa, który blok jest wyrzucony. Mozesz także opcjonalnie dla wszystkich bliżej nieokreślonych bloku wyjątków catch-all catch jako finalnego bloku w instrukcji bloku catch.

+

Na przykład, nstępująca instrukcja powołuje się na trzy inne funkcje (deklarując je gdziekolwiek) który waliduje jego argumenty. Jeśli funkcja walidacji decyduje który komponent jest sprawdzany to wskazuje który nie przechodzi walidacji, to zwraca 0, wywołując odpowiednia wyskok szczególnego wątku.

+
function getCustInfo(name, id, email)
+{
+   var n, i, e;
+
+   if (!validate_name(name))
+       throw "InvalidNameException"
+   else
+       n = name;
+       if (!validate_id(id))
+          throw "InvalidIdException"
+       else
+          i = id;
+       if (!validate_email(email))
+          throw "InvalidEmailException"
+       else
+          e = email;
+       cust = (n + " " + i + " " + e);
+       return (cust);
+}
+
+

Blok warunkowy catch kontroluje drogę dobierając odpowiedni uchwyt wyjątku.

+
try {
+// funkcja wyrzucająca trzy wyjątki
+   getCustInfo("Lee", 1234, "lee@netscape.com")
+}
+
+catch (e if e == "InvalidNameException") {
+// nazwa uchwytu dla niepoprawnej nazwy
+   bad_name_handler(e)
+}
+
+catch (e if e == "InvalidIdException") {
+// nazwa uchwytu dla błędnych id
+   bad_id_handler(e)
+}
+
+catch (e if e == "InvalidEmailException") {
+// nazwa uchwytu dla błednego adresu email
+   bad_email_handler(e)
+}
+
+catch (e){
+// nie wiadomo co robi, ale się loguje
+   logError(e)
+}
+
+

Blok finally

+

Blok finally stanowi instrukcja wykonywana po sprawdzeniu i wykonaniu bloku catch, ale przed następującą instrukcją try...catch. Blok finally wykonany gdziekolwiek lub nie jest wyjątkiem thrown. Jeśli wyjątek jest thrown, instrukcje w bloku finally wykonane równo, jeśli blok catch trzyma wyjątek.

+

Możesz używać bloku finally do zrobienia Twojego błędnego skryptu, kiedy ma miejsce wyjątku; na przykład, możesz potrzebować zwolnić źródło, którego Twój skrypt ma powiązanego. Następujący przykład otwiera plik i następnie wykonuje instrukcję, która użyje pliku (server-side pozwoli Ci w JavaScript uzyskać dostęp do pliku). Jeśli wyjątek jest rzucony, gdy plik jest otwarty, a blok finally zamyka pliki przed danymi skryptami.

+
openMyFile();
+try {
+   writeMyFile(theData)
+}
+finally {
+   closeMyFile() // zawsze zamykaj źródło
+}
+
+

Zagnieżdżanie instrukcji try...catch

+

Żądaj jeden lub więcej instrukcji try...catch. Jeśli wewnętrzna instrukcja try...catch nie ma bloku catch, otoczamy blok catch i instrukcja try...catch jest zaznaczona dla danej wartości.

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_break/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_break/index.html" new file mode 100644 index 0000000000..108f315058 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_break/index.html" @@ -0,0 +1,27 @@ +--- +title: Instrukcja break +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_break +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Instrukcja break

+

Użyjemy instrukcji break chcąc zakończyć jedną z instrukcji pętli switch, lub label .

+ +

Składnia instrukcji break wygląda jak poniższy przykład:

+
1. break
+2. break label
+
+

Pierwsza forma składni przerywa najgłębszą otoczoną nawiasami lub instrukcje pętlę switch; druga forma składni przerywa specjalnie pętlę zamkniętą i oznaczoną etykietę instrukcji.

+

Przykład
+ Następujący przykład powtarza pętle poprzez elementy w tablicy aż do momentu, znalezienia element indeksu, który jest wartością theValue:

+
for (i = 0; i < a.length; i++) {
+   if (a[i] = theValue)
+      break;
+}
+
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_continue/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_continue/index.html" new file mode 100644 index 0000000000..dee2eda4ee --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_continue/index.html" @@ -0,0 +1,51 @@ +--- +title: Instrukcja continue +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_continue +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Instrukcja continue

+

Instrukcja continue możemy użyć do ponownego uruchomienia instrukcji while, do-while, for, lub label tzw. etykiety.

+ +

Składnia instrukcji continue wygląda następująco:

+
    +
  1. continue
    2. +
  2. continue label
    3. +
+

Przykład 1
+ Następujący przykład pokazuje pętlę while z instrukcja continue, która jest wykonana wtedy, gdy wartość i jest liczbą trzy. W ten sposób, n pobiera wartości jeden, trzy, siedem, dwanaście.

+
i = 0;
+n = 0;
+while (i < 5) {
+   i++;
+   if (i == 3)
+      continue;
+   n += i;
+}
+
+

Przykład 2
+ Etykieta instrukcji checkiandj stanowi etykietę instrukcji checkj. Jeśli continue zostanie napotkane, program przerwie aktualnie wykonywaną iterację checkj i rozpocznie następną iterację. Za każdym razem, gdy continue zostanie napotkane, checkj wykonuje ponownie iterację aż do momentu, gdy warunek stanie się nieprawdziwy. Kiedy został napotkany nieprawdziwy warunek, to powtarza, reszta instrukcji checkiandj jest dopełniona, i checkiandj ponownie iteruje aż jego warunek zwróci wartość nieprawdziwą. Kiedy false jest zwracany, to program kontynuuje następującą instrukcję checkiandj.

+

Jeśli continue miało pętlę checkiandj, to program będzie kontynuował instrukcję checkiandj, aż osiągnie jej najwyższą wartość.

+
checkiandj :
+   while (i < 4) {
+      document.write(i + "<br/>");
+      i += 1;
+      checkj :
+         while (j > 4) {
+            document.write(j + "<br/>");
+            j -= 1;
+            if ((j % 2) == 0)
+               continue checkj;
+            document.write(j + " is odd.<br/>");
+         }
+      document.write("i = " + i + "<br/>");
+      document.write("j = " + j + "<br/>");
+   }
+
+

 

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_do_...while/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_do_...while/index.html" new file mode 100644 index 0000000000..6c770f4ae6 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_do_...while/index.html" @@ -0,0 +1,23 @@ +--- +title: Instrukcja do ...while +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_do_...while +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Instrukcja do...while

+

Instrukcja do...while powtarza specyficzny warunek, aż do momentu, kiedy uzna go za fałszywy. Instrukcja do...while wygląda następująco:

+
do
+   statement
+while (condition);
+
+

Instrukcja (statement zostanie wykonany raz, zanim warunek zostanie sprawdzony. Jeśli warunek (condition) jest prawdziwy (true), instrukcja zostanie wykonana ponownie. Warunek jest sprawdzany na końcu każdego wykonania. Kiedy warunek jest fałszywy (false), wykonanie zostaje zatrzymane i kontrola jest przekazywana do instrukcji następującej po pętli do...while.

+

Przykład
+ W następnym przykładzie, pętla iteracyjna wykonuje się, co najmniej raz, i powraca wykonując pętlę iteracyjną dopóki wartość i jest mniejsza niż 5.

+
do {
+   i += 1;
+   document.write(i);
+} while (i < 5);
+
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_for/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_for/index.html" new file mode 100644 index 0000000000..c13c4558fb --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_for/index.html" @@ -0,0 +1,56 @@ +--- +title: Instrukcja for +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_for +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Instrukcja for

+

Pętla for jest powtarzana aż do momentu, kiedy testowany warunek staje się fałszywy. W JavaScript pętla for jest podobna do pętli w Java i C. Instrukcja pętli for wygląda następująco:

+
for ([przypisanie]; [warunek]; [zmiana]) {
+   Instrukcje
+}
+
+

Kiedy pętla for jest wykonywana to mają miejsce:

+
    +
  1. Inicjalizacja wyrażenia przypisanie, jeśli coś jest wykonywane. To wyrażenie często inicjuje jedną lub więcej pętli, ale kod pozwala na wyrażenia o różnym stopniu złożoności. To wyrażenie może deklarować zmienne.
    2. +
  2. Wyrażenie warunek jest wykonane. Jeśli wartość warunek jest prawdziwa, instrukcja pętli jest wykonana. Jeśli wartość warunek jest fałszywa, pętla for jest przerwana. Jeśli wyrażenie warunek jest w całości opuszczone, warunek to bierze na siebie, jeśli jest prawdziwy.
    3. +
  3. Wykonuje instrukcje.
    4. +
  4. Aktualizuje wyrażenia zmiana, jeśli jedna wykonywana to kontrola jest przekazywana do kroku drugiego.
    5. +
+

Przykład
+ Następująca funkcja stanowi instrukcję for, która to tworzy licznik zaznaczonych opcji w liście przewijanej (obiekt Select, który pozwala na wielokrotne zaznaczenia). Instrukcja for deklaruje zmienną i i inicjuje ją od zera. Sprawdza, które i jest mniejsze niż liczba opcji w obiekcie Select wykonując kolejną instrukcję if, i zwiększa i o jeden po każdej wykonanej pętli.

+
<script type="text/javascript">//<![CDATA[
+
+function howMany(selectObject) {
+   var numberSelected = 0;
+   for (var i = 0; i < selectObject.options.length; i++) {
+      if (selectObject.options[i].selected)
+         numberSelected++;
+   }
+   return numberSelected;
+}
+
+//]]></script>
+<form name="selectForm">
+   <p>
+      <strong>Choose some music types, then click the button below:</strong>
+      <br/>
+      <select name="musicTypes" multiple="multiple">
+         <option selected="selected">R&B</option>
+         <option>Jazz</option>
+         <option>Blues</option>
+         <option>New Age</option>
+         <option>Classical</option>
+         <option>Opera</option>
+      </select>
+   </p>
+   <p>
+      <input type="button" value="How many are selected?"
+         onclick="alert ('Number of options selected: ' + howMany(document.selectForm.musicTypes))"/>
+   </p>
+</form>
+
+

 

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_label/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_label/index.html" new file mode 100644 index 0000000000..e95a452b8f --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_label/index.html" @@ -0,0 +1,23 @@ +--- +title: Instrukcja label +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_label +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Instrukcja label

+

Instrukcja label dostarcza instrukcję wraz z identyfikatorem, który odnosi się całkiem gdzie indziej w Twoim programie. Na przykład, możesz użyć label do zidentyfikowania pętli i następnie w niej użyć instrukcję break lub continue, do wskazania miejsca gdzie program powinien zinterpretować pętlę lub kontynuować jego wykonanie.

+

Składnia instrukcji label wygląda następująco:

+
label :
+   Instrukcja
+
+

Wartością label może być w JavaScript identyfikator, który jest nie zarezerwowanym słowem. Instrukcja to identyfikujesz z etykietą, która może być jakąś instrukcją.

+

Przykład
+ W tym przykładzie, etykieta markLoop identyfikuje pętle while.

+
markLoop:
+while (theMark == true)
+   doSomething();
+}
+
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_while/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_while/index.html" new file mode 100644 index 0000000000..48ecacaa70 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/instrukcje_p\304\231tli/instrukcja_while/index.html" @@ -0,0 +1,38 @@ +--- +title: Instrukcja while +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_while +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Instrukcja while

+

Instrukcja while wykonuje instrukcje tak długo, dopóki warunek będzie prawdziwy. Instrukcja pętli while wygląda następująco:

+
while (warunek) {
+   instrukcje
+}
+
+

Jeśli warunek stanie się fałszywy, instrukcja wewnątrz pętli zatrzyma wykonywanie i identyfikatorach kontroli w instrukcji następującej pętli.

+

Test warunku ma miejsce przed wykonaniem pętli instrukcji. Jeśli warunek będzie prawdziwy, instrukcje są wykonywane i ponownie jest wykonywany test warunku. Jeśli warunek będzie fałszywy, wykonywanie pętli jest zatrzymanie i przejście kontroli do następującej instrukcji while.

+

Przykład 1
+ Następująca pętla while wykonuje iterację (powtarza) tak długo aż n jest mniejsze od trzech:

+
n = 0;
+x = 0;
+while( n < 3 ) {
+   n ++;
+   x += n;
+}
+
+

Do każdej wykonanej pętli iteracji, przyrost pętli n i dodanie te wartości x. Dlatego, x i n pobierają następujące wartości:

+ +

Po uzupełnieniu trzeciego przejścia, warunek n < 3 jest wartość prawdziwa, więc pętla zostanie przerwana.

+

Przykład 2
+ Nieskończoność pętli. Upewnij się czy warunek pętli ostatecznie staje się fałszywym; innym razem, pętla nigdy nie zostanie przerwana. Instrukcja w następującej pętli while występuje bezustannie, ponieważ warunek nigdy nie stanie się fałszywy.

+
while (true) {
+   alert("Hello, world") }
+
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/o_tym_przewodniku/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/o_tym_przewodniku/index.html" new file mode 100644 index 0000000000..0fd0f2ec8a --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/o_tym_przewodniku/index.html" @@ -0,0 +1,159 @@ +--- +title: O tym przewodniku +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/O_tym_przewodniku +tags: + - JavaScript + - Przewodnik_JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +--- +

Nowe możliwości wersji JavaScriptu

+ + + +

Co już powinieneś wiedzieć

+ +

Ten dokument zakłada, że jego czytelnik ma podstawowe pojęcie na temat niżej wymienionych dziedzin:

+ + + +

Przydatne, aczkolwiek nie wymagane, jest doświadczenie w językach programowania takich jak C czy Visual Basic.

+ +

Wersje JavaScriptu

+ +

Każda wersja przeglądarek Netscape Navigator, Mozilla i Mozilla Firefox obsługuje różne wersje języka JavaScript. Aby ułatwić pisanie skryptów zgodnych z różnymi wersjami przeglądarek Netscape/Mozilla/Firefox, w każdym rozdziale poświęconym danej możliwości języka podajemy listę wersji JavaScriptu obsługujących daną funkcjonalność.

+ +

Poniższa tabela zawiera numery wersji JavaScriptu i odpowiadające im numery wersji przeglądarek te wersje obsługujących. Wersje Netscape Navigatora starsze niż 2.0 nie obsługują JavaScriptu.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Wersja JavaScriptWersja 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 (przeglądarka open source)
JavaScript 1.6Firefox 1.5, other Mozilla 1.8-based products
JavaScript 1.7Firefox 2, other Mozilla 1.8.1-based products
JavaScript 1.8Firefox 3, other Gecko 1.9-based products
+ +

Tablica 1: Wersje JavaScriptu oraz Navigatora
+  

+ +

Każda wersja serwera Netscape Enterprise Server także obsługuje inną wersję JavaScriptu. Aby ułatwić pisanie skryptów zgodnych z różnymi wersjami Enterprise Server, w każdym rozdziale poświęconym danej możliwości języka podajemy wersję NES/FES, w której zaimplementowano daną funkcjonalność.

+ + + + + + + + + + + + + + + + +
SkrótWersja Enterprise Server
NES 2.0Netscape Enterprise Server 2.0
NES 3.0Netscape Enterprise Server 3.0
+ +

Tablica 2: Skróty oraz wersje Netscape Enterprise Server

+ +

Gdzie szukać informacji o JavaScripcie

+ +

Na kompletną bazę informacji o języku JavaScript składają się następujące dokumenty:

+ + + +

Jeśli JavaScript stanowi dla Ciebie nowość, zacznij od Przewodnika po języku JavaScript 1.5. Kiedy posiądziesz już podstawową wiedzę, możesz skorzystać z Dokumentacji języka JavaScript 1.5, by szybko odnaleźć konkretne informacje na temat obiektów i poleceń.

+ +

Wskazówki do nauki JavaScript

+ +

Rozpoczęcie pracy z JavaScript jest proste: wszystko czego potrzebujecie to nowoczesna przeglądarka internetowa. Ten przewodnik zawiera elementy JavaScript, które są rozpoznawalne jedynie w ostatnich najnowszych wersji przeglądarki Firefox (lub w innych opartych na silniku Gecko przeglądarkach), dlatego zaleca się używanie jak najnowszej wersji przeglądarki Firefox.

+ +

Interaktywny interpreter

+ +

Do nauki języka zachęca wspaniały interpreter, który umożliwia pełną interaktywność bez zapisywania i odświeżania strony. Konsola błędów Firefox, dostępna w menu narzędzia, oferuje łatwy, interaktywny, sposób wykonywania skryptów JavaScript: po prostu wejdź na linię kodu oraz kliknij przycisk "Evaluate".

+ +

Image:ErrorConsole.png

+ +

Firebug

+ +

Bardziej zaawansowana interaktywna podpowiedź dostępna jest pod adresem: Firebug, trzecia część rozszerzenia Firefox. Firebug dostarcza zarówno zaawansowany kontroler DOM, jak i debuger JavaScript oraz przydatne narzędzia i różne inne programy użytkowe:

+ +

Image:Firebug.png

+ +

jedno z najbardziej użytecznych ułatwień oferowanych przez Firebug w console.log(), funkcja która zapisuje jego argumenty do konsoli Firebug. W przeciwieństwie do innych języków programowania w JavaScript nie ma możliwości pisania na standardowym wyjściu. console.log() stanowi pożyteczną alternatywę obserwowania bardzo łatwo tego co twój program robi.

+ +

Wiele przykładów w tym przewodniku używa alert() do zobaczenia komunikatów z ich wykonania. Jeśli masz zainstalowanego Firebug możesz użyć console.log() w miejsce alert() w czasie działania tych przykładów.

+ +

Konwencje dokumentu

+ +

Aplikacje JavaScript działają pod wieloma systemami operacyjnymi; informacje zawarte w tym przewodniku dotyczą ich wszystkich. Ścieżki plików i katalogów są podane w formacie Windows (z odwrotnym ukośnikiem oddzielającym nazwy folderów). Pod Uniksami ścieżki są te same, wystarczy jedynie zastąpić odwrotny ukośnik\ zwykłym ukośnikiem/ .

+ +

Przewodnik ten używa uniform resource locators (adresów URL) w następującej formie:

+ +

http://server.domain/path/file.html

+ +

W tym adresie URL, "serwer" reprezentowany jest poprzez nazwę znajdującą się na serwerze w której uruchomisz aplikacje, także jako poszukiwane słowo lub strona WWW; "domena" reprezentowana jest poprzez twoją nazwę domeny w internecie, tak jak netscape.com lub uiuc.edu; "ścieżki" reprezentują strukturę katalogów na tym serwerze, a "file.html" reprezentuje indywidualną nazwę pliku. Generalnie pozycje, które mają w ścieżce kursywę, która jest osadzona i jest ona normalną czcionką literową. Jeśli twój serwer posiada Secure Sockets Layer (SSL), będziesz używał protokołu https zamiast http w adresie URL.

+ +

Przewodnik ten stosuje z następującą konwencją czcionki:

+ +
+
Czcionka monospace
+
Jest użyta do prostych kodów oraz ich listingów, API i elementy języka (także jako metody i nazwy własności), nazwa pliku, nazwa ścieżki, nazwa katalogu, tagi HTML i jakiś tekst musi być zadeklarowany przy wyświetlaniu. (Kursywa czcionki Monospace jest użyta w osadzonych miejscach klasera w kodzie strony).
+
Kursywa 
+
Jest użyta dla tytułów, nagłówków, zmiennych i specjalnych miejscach, i słów użytych w dosłownym znaczeniu.
+
Boldface 
+
Typ używany do terminów słownikowych.
+
+ +

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

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_array/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_array/index.html" new file mode 100644 index 0000000000..9befbd17cc --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_array/index.html" @@ -0,0 +1,94 @@ +--- +title: Obiekt Array +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Array +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Obiekt Array

+

JavaScript nie ma wyraźnych danych typu + + array + . Jednakże, możesz użyć predefiniowanego obiektu Array i jego metod do pracy z tabelami w twojej aplikacji. Obiekt Array posiada metody do manipulacji tablicami w zmiennych przypadkach, także jako łączyć, odwraca je na lewą stronę, i sortuje je. Decydując o długości + + array + i innych właściwości użytych w wyrażeniach regularnych.

+

+ + array + jest uporządkowane ustawienia wartości, które odsyłają do nazwy i indeksu. Na przykład, możesz mieć tablice nazwaną emp, która stanowi nazwę indeksu przez jego numer pracownika. Więc emp{{ mediawiki.external(1) }} będzie pracownik z numerem jeden, emp{{ mediawiki.external(2) }} pracownik z numerem dwa i tak dalej.

+

Tworzenie tablicy

+

Utwórz obiekt Array:

+
1. arrayObjectName = new Array(element0, element1, ..., elementN)
+2. arrayObjectName = new Array(arrayLength)
+
+

arrayObjectName jest nazwą nowego obiektu lub właściwości istniejącego obiektu. Kiedy używamy właściwości i metody Array, arrayObjectName jest nazwą istniejącego obiektu Array lub właściwość istniejącego obiektu.

+

element0, element1, ..., elementN jest listą wartości dla elementów tablicowych. Kiedy ta forma określa, inicjowanie tablicy z określoną wartością jako jego elementy i właściwości długości tablicowej, która jest ustawiona jako liczby lub argumenty.

+

arrayLength jest inicjowanie długości w tablicy. Następujący kod tworzy tablice na pięć elementów:

+
billingMethod = new Array(5)
+
+

Literały Array sa także obiektami Array; na przykład, następujący literał jest obiektem Array. Zobacz Literały tablicy aby uzyskać więcej szczegółów.

+
coffees = ["French Roast", "Columbian", "Kona"]
+
+

Zapełnienie tablicy

+

Możesz wypełnić tablicę przydzielonymi wartościami elementów. Na przykład,

+
emp[1] = "Casey Jones"
+emp[2] = "Phil Lesh"
+emp[3] = "August West"
+
+

Możesz także wypełnić tablicę jeśli utworzysz:

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

Kierowanie do elementu tablicy

+

Kierowanie do elementu tablicy używając przypisanie numeru odpowiedniemu elementowi. Na przykład, przypuśćmy, że zdefiniujesz następującą tablice:

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

Następnie kieruje się do pierwszego elementu tablicy jako myArray{{ mediawiki.external(0) }} i drugi element tablicy jako myArray{{ mediawiki.external(1) }}. Indeks elementów zaczyna się wraz z zerem (0), ale długość tablicy (na przykład, myArray.length) odzwierciedla numer elementów w tablicy.

+

Metody

+

Obiekt Array posiada następujące metody:

+ +

Na przykład, przypuśćmy, że zdefiniujemy następującą tablice:

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

myArray.join() zwraca "Wiatr","Deszcz","Ogień"; myArray.reverse transportuje tablicę więc, który myArray[0] jest "Ogień", myArray{{ mediawiki.external(1) }} jest "Deszcz", i myArray{{ mediawiki.external(2) }} jest "Wiatr". myArray.sort sortuje tablicę więc, który myArray{{ mediawiki.external(0) }} jest "Ogień", myArray{{ mediawiki.external(1) }} jest "Deszcz", i myArray{{ mediawiki.external(2) }} jest "Wiatr".

+

Tablice dwuwymiarowe

+

Następujący kod tworzy tablicę dwuwymiarową.

+
a = new Array(4)
+for (i=0; i < 4; i++) {
+   a[i] = new Array(4)
+   for (j=0; j < 4; j++) {
+      a[i][j] = "["+i+","+j+"]"
+   }
+}
+
+

Ten przykład tworzy tablicę z następującymi wierszami:

+
Row 0:[0,0][0,1][0,2][0,3]
+Row 1:[1,0][1,1][1,2][1,3]
+Row 2:[2,0][2,1][2,2][2,3]
+Row 3:[3,0][3,1][3,2][3,3]
+
+

Tablice i wyrażenia regularne

+

Kiedy + + array + jest rezultatem pomiędzy wyrażeniami regularnymi i łańcucha, + + array + zwraca właściwości i elementy, które dostarczają informacji o odpowiedniku. Wartość + + array + jest zwracany RegExp.exec, String.match, i String.split. Dla uzyskania informacji, jak używać tablicę z wyrażeniami regularnymi Wyrażenia regularne.

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_boolean/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_boolean/index.html" new file mode 100644 index 0000000000..ff6e5b774a --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_boolean/index.html" @@ -0,0 +1,14 @@ +--- +title: Obiekt Boolean +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Boolean +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Obiekt Boolean

+

Obiekt Boolean jest otoczeniem wokół prymitywnych danych typu Boolean. Użyj następującej składni do utworzenia obiektu Boolean:

+
booleanObjectName = new Boolean(wartość)
+
+

Nie pomieszaj prymitywnej wartości Boolean true i false z wartościami true i false obiektu Boolean. Jakikolwiek obiekt którego wartość obiektu jest nie undefined , null, 0, NaN, lub pusty łańcuch, włączając obiekt Boolean, którego wartość jest nieprawdziwa (false), ocenia jako prawdziwy (true), kiedy przechodzi do instrukcji warunkowej. Zobacz artykuł Instrukcja if...else aby zdobyć więcej informacji.

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_date/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_date/index.html" new file mode 100644 index 0000000000..e0dc4845d8 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_date/index.html" @@ -0,0 +1,87 @@ +--- +title: Obiekt Date +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Date +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Obiekt Date

+

JavaScript nie posiada danych typu date. Jednakże, możesz użyć obiektu Date i jego metod do pracy z datami i czasem w swoich aplikacjach. Obiekt Date posiada wiele metod do ustawiania, pobierania i manipulacji datami. Nie posiada żadnych właściwości.

+

W JavaScript uchwyty dat są podobne jak w Java. Oba języki mają wiele takich samych metod i oba języki przechowują daty w liczbie milisekund od 1-ego stycznia 1970, 00:00:00.

+

Obiekt Date jest z zakresu -100,000,000 dni do 100,000,000 dni odnosząc się do 01 stycznia, 1970 UTC.

+

Do utworzenia obiektu Date służy:

+
dateObjectName = new Date([parameters])
+
+

gdzie: dateObjectName jest nazwą tworzonego obiektu; Date potrafi też być nowym obiektem lub właściwością już istniejącego obiektu.

+

W poprzedniej składni parameters mogły być:

+ +

JavaScript 1.2 i wcześniejsze
+ Obiekt Date postępuje następująco:

+ +

Metody obiektu Date

+

Metody obiektu Date są do obsługi daty i czasu zawartego w tych obszernych kategoriach:

+ +

Z metodami "get" i "set" możemy pobrać i ustawić sekundy, minuty, godziny, dni miesiąca, dni tygodnia, miesiące, jak i poszczególne lata. Istnieje metoda getDay, która zwraca dzień tygodnia, ale nie współpracuje z metodą setDay, ponieważ dzień tygodnia jest ustawiany automatycznie. Te metody używają liczb całkowitych do reprezentacji następujących wartości:

+ +

Na przykład, przypuśćmy, że zdefiniowałeś następującą datę:

+
Xmas95 = new Date("December 25, 1995")
+
+

Następnie Xmas95.getMonth() zwraca 11, i Xmas95.getFullYear() zwraca 1995.

+

Metody getTime i setTime są użyteczne dla porównania dat. Metoda getTime zwraca liczbę milisekund od 1 stycznia 1970, 00:00:00 ( + + January 1, 1970, 00:00:00 + ) dla obiektu Date.

+

Na przykład, następujący kod wyświetla liczbę dni opuszczonych w aktualnym roku:

+
today = new Date()
+endYear = new Date(1995,11,31,23,59,59,999) // Ustawia dni i miesiące
+endYear.setFullYear(today.getFullYear()) // Ustawia ilość lat '''(?)'''
+msPerDay = 24 * 60 * 60 * 1000 // Liczba milisekund na dzień
+daysLeft = (endYear.getTime() - today.getTime()) / msPerDay
+daysLeft = Math.round(daysLeft) //zwraca dni opuszczone dni w roku
+
+

Ten przykład stworzył obiekt Date nazywany today, który stanowi dzisiejszą datę. Następnie utworzył obiekt Date nazwany endYear i ustawi się od roku do aktualnego roku. Następnie, użyje liczbę milisekund na dzień, to obliczy liczbę dni pomiędzy dzisiejszym dniem today a endYear, używających getTime i zaokrąglenie do liczby dni.

+

Metoda parse jest użyteczna dla przydzielania wartości z łańcucha daty do wykorzystania przez obiekty Date. Na przykład, następujący kod używa parse i setTime do przydzielenia wartości obiektu IPOdate:

+
IPOdate = new Date()
+IPOdate.setTime(Date.parse("Aug 9, 1995"))
+
+

Używanie obiektu Date: Przykład

+

W następującym przykładzie, funkcja JSClock() zwraca czas w formacie zegara cyfrowego.

+
function JSClock() {
+   var time = new Date()
+   var hour = time.getHours()
+   var minute = time.getMinutes()
+   var second = time.getSeconds()
+   var temp = "" + ((hour > 12) ? hour - 12 : hour)
+   if (hour == 0)
+      temp = "12";
+   temp += ((minute < 10) ? ":0" : ":") + minute
+   temp += ((second < 10) ? ":0" : ":") + second
+   temp += (hour >= 12) ? " P.M." : " A.M."
+   return temp
+}
+
+

Pierwsza funkcja JSClock tworzy nowy obiekt Date, który nazywany jest time; nie dający argumentów, czas jest tworzony z aktualną datą i czasem. Następnie metody getHours, getMinutes, i getSeconds przypisują wartości aktualnej godziny, minuty i sekundy do hour, minute, i second.

+

Następne cztery linijki instrukcji budują łańcuch wartości oparty na czasie. Pierwsza instrukcja tworzy zmienne temp, przydzielając jej wartość używanego warunku wyrażenia; jeśli hour jest wyższa niż 12, (godzina - 12), w innym przypadku prosta godzina, chyba że jest godzina 0, która to staje się 12.

+

Następna instrukcja przypisuje wartość minute do temp. Jeśli wartość minute jest mniejsza niż 10, wyrażenie warunkowe dodaje łańcuch z poprzedzającym ją zerem; w innym przypadku dodaje rozgraniczający dwukropek. Następnie instrukcja dołącza sekundy do temp w ten sam sposób.

+

Kończąc, wyrażenie warunkowe dołącza "PM" do temp, jeśli hour posiada wartość 12 lub wyższą; w innym przypadku, to dołącza "AM" do temp.

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_function/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_function/index.html" new file mode 100644 index 0000000000..02eef23d82 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_function/index.html" @@ -0,0 +1,50 @@ +--- +title: Obiekt function +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_function +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Obiekt Function

+

Predefiniowany obiekt Function określa łańcuch znaków do skompilowania jako funkcja.

+

Aby utworzyć obiekt Function:

+
nazwaObiektuFunkcji = new Function ([arg1, arg2, ... argn], cialoFunkcji)
+
+

nazwaObiektuFunkcji jest nazwą zmiennej lub własności istniejącego obiektu. Może to być również obiekt, po którym następuje zapisana małymi literami nazwa uchwytu zdarzenia, jak np. window.onerror.

+

arg1, arg2, ... argn są argumentami, które mają być użyte przez funkcję jako formalne nazwy argumentów. Każda z nich musi być łańcuchem znaków spełniającym zasady poprawnego identyfikatora JavaScript; przykładowo "x" lub "theForm".

+

cialoFunkcji jest łańcuchem znaków określającym kod JavaScript, który ma zostać skompilowany jako ciało funkcji.

+

Obiekty Function są przetwarzane przy każdym użyciu. Jest to mniej skutecznie niż deklarowanie funkcji i wywoływanie jej wewnątrz kodu, ponieważ zadeklarowane funkcje są kompilowane.

+

Oprócz definiowania funkcji w sposób opisany tutaj, możesz również użyć instrukcji function i wyrażenia funkcji. Zobacz Dokumentacja języka JavaScript 1.5, aby uzyskać więcej informacji.

+

Poniższy kod przypisuje funkcję do zmiennej ustawKolorTla. Funkcja ta ustawia obecny kolor tła dokumentu.

+
var ustawKolorTla = new Function("document.bgColor='antiquewhite'")
+
+

Aby wywołać obiekt Function, możesz określić nazwę zmiennej tak, jak gdyby była to funkcja. Poniższy kod wykonuje funkcję określoną przez zmienną ustawKolorTla:

+
var wyborKoloru="antiquewhite"
+if (wyborKoloru=="antiquewhite") {ustawKolorTla()}
+
+

Możesz przypisać funkcję do uchwytu zdarzenia w jeden z następujących sposobów:

+
1. document.form1.colorButton.onclick=ustawKolorTla
+2. <INPUT NAME="kolorPrzycisku" TYPE="button"
+      VALUE="Zmień kolor tła"
+      onClick="ustawKolorTla()">
+
+

Tworzenie zmiennej ustawKolorTla pokazane powyżej jest podobne do deklarowania następującej funkcji:

+
function ustawKolorTla() {
+   document.bgColor='antiquewhite'
+}
+
+

Przypisywanie funkcji do zmiennej jest podobne do deklarowania funkcji, są jednak pewne różnice:

+ +

Możesz zagnieździć funkcję wewnątrz funkcji. Zagnieżdżona (wewnętrzna) funkcja jest prywatna do zawierającej ją (zewnętrznej) funkcji:

+ +
+  
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_math/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_math/index.html" new file mode 100644 index 0000000000..b09ad2f801 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_math/index.html" @@ -0,0 +1,72 @@ +--- +title: Obiekt Math +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Math +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Obiekt Math

+

Obiekt predefiniowany Math posiada właściwości i metody dla stałych matematycznych i funkcji. Na przykład: obiekt Math PI pi posiada wartość (3.141...), który będzie używany w aplikacji jako:

+
Math.PI
+
+

Podobnie, standardowe funkcje matematyczne są metodami Math. Włączając trygonometryczne, logarytmiczne, wykładnicze i inne funkcje. Na przykład, jeśli chcesz użyć funkcji trygonometryczej sine, musisz napisać:

+
Math.sin(1.56)
+
+

Wszystkie metody trygonometryczne Math pobierają argumenty w radianach.

+

Następująca tabela podsumowuje metodę Math.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
MetodaOpis
absWartość bezwzględna argumentu
sin, cos, tanStandardowe funkcje trygonometryczne; argumenty w radianach
acos, asin, atan, atan2Odwrotne funkcje trygonometryczne; zwracają wartość w radianach
exp, logWykładniczy i naturalny logarytm, podstawą jest e
ceilZwraca najmniejszą liczbę całkowitą większą bądź równą argumentowi
floorZwraca największą liczbę całkowitą mniejszą bądź równą argumentowi
min, maxZwraca większą lub mniejeszą (jedną z podanych) z dwóch argumentów
powWykładniczy; pierwszy argument jest podstawą, drugi jest wykładnikiem
randomZwraca przypadkową liczbę pomiędzy 0 i 1.
roundZwraca argumenty najbliższe liczbie całkowitej
sqrtZwraca pierwiastek kwadratowy argumentu
+

Tabela: Metody Math

+

Wiele innych niepodobnych obiektów, nigdy nie utworzy dla siebie obiektu Math. Zawsze używaj predefiniowanego obiektu Math.

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_number/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_number/index.html" new file mode 100644 index 0000000000..d66696774b --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_number/index.html" @@ -0,0 +1,83 @@ +--- +title: Obiekt Number +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Number +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Obiekt Number

+

Obiekt Number posiada własności dla stałych liczbowych, takie jak wartość maksymalna, not-a-number (nie-liczba) i nieskończoność. Nie możesz zmieniać wartości tych własności. Używa się ich następująco:

+
biggestNum = Number.MAX_VALUE
+smallestNum = Number.MIN_VALUE
+infiniteNum = Number.POSITIVE_INFINITY
+negInfiniteNum = Number.NEGATIVE_INFINITY
+notANum = Number.NaN
+
+

Możesz zawsze odwołać się do własności predefiniowanego obiektu Number w sposób pokazany powyżej, lecz nie jako własności obiektu Number, który sam utworzyłeś.

+

Poniższa tabela podsumowuje własności obiektu Number .

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
WłasnośćOpis
MAX_VALUENajwiększa możliwa do przedstawienia liczba
MIN_VALUENajmniejsza możliwa do przedstawienia liczba
NaNSpecjalna wartość "nieliczbowa"
NEGATIVE_INFINITYSpecjalna wartość nieskończoności; zwracana przy przepełnieniu
POSITIVE_INFINITYSpecjalna wartość ujemnej nieskończoności; zwracana przy przepełnieniu
+

Tabela 7.2: Własności obiektu Number

+

Prototyp Number dostarcza metod używanych w celu uzyskiwania w różnych formatach informacji z obiektów Number. Poniższa tabelka podsumowuje metody Number.prototype.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
MetodaOpis
toExponentialZwraca łańcuch znaków reprezentujący liczbę w notacji wykładniczej.
toFixedZwraca łańcuch znaków reprezentujący liczbę w notacji stałoprzecinkowej.
toPrecisionZwraca łańcuch znaków reprezentujący z określoną dokładnością w notacji stałoprzecinkowej.
toSourceZwraca obiekt literałowy reprezentujący określony obiekt Number; możesz użyć tej wartości do stworzenia nowego obiektu. Nadpisuje metodę Object.toSource.
toStringZwraca łańcuch znaków reprezentujący dany obiekt. Nadpisuje metodę Object.toString.
valueOfZwraca pierwotną wartość określonego obiektu. Nadpisuje metodę Object.valueOf.
+

Tabela: Metody Number.prototype {{ PreviousNext("Przewodnik po języku JavaScript 1.5:Obiekty predefiniowane:Obiekt Math", "Przewodnik po języku JavaScript 1.5:Obiekty predefiniowane:Obiekt RegExp") }}

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_regexp/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_regexp/index.html" new file mode 100644 index 0000000000..120abc3cb9 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_regexp/index.html" @@ -0,0 +1,12 @@ +--- +title: Obiekt RegExp +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_RegExp +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Obiekt RegExp

+

Obiekt RegExp umożliwia działanie na wyrażeniach regularnych. Został on opisany w Rozdziale 4, Wyrażenia regularne. {{ PreviousNext("Przewodnik po języku JavaScript 1.5:Obiekty predefiniowane:Obiekt Number", "Przewodnik po języku JavaScript 1.5:Obiekty predefiniowane:Obiekt String") }}

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_string/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_string/index.html" new file mode 100644 index 0000000000..dc7aa33326 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/obiekty_predefiniowane/obiekt_string/index.html" @@ -0,0 +1,92 @@ +--- +title: Obiekt String +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_String +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Obiekt String

+

Obiekt String ma jedną własność, length, która wskazuje liczbę znaków w łańcuchu znaków. Przykładowo, poniższy kod przypisuje zmiennej x wartość 13, ponieważ "Hello, World!" ma 13 znaków:

+
myString = "Hello, World!"
+x = mystring.length
+
+

Obiekt String posiada dwa typy metod: zwracające zmienność samego łańcucha znaków, takie jak substring i toUpperCase oraz te, które zwracają wersję łańcucha sformatowaną jako kod HTML, takie jak bold i link.

+

Na przykład używając poprzedniego przykładu, zarówno mystring.toUpperCase() jak i "hello, world!".toUpperCase() zwrócą łańcuch "HELLO, WORLD!"

+

Metoda substring pobiera dwa argumenty i zwraca podzbiór łańcucha znaków pomiędzy tymi dwoma argumentami. Posługując się powyższym przykładem, mystring.substring(4, 9) zwróci łańcuch "o, Wo". Zobacz metodę substring obiektu String w Dokumentacja języka JavaScript 1.5, aby uzyskać więcej informacji.

+

Obiekt String posiada również wiele metod do automatycznego formatowania kodu HTML, takie jak bold do tworzenia pogrubionego tekstu i link do tworzenia hiperłącz. Przykładowo, możesz utworzyć hiperłącze do hipotetycznego adresu URL przy użyciu metody link w następujący sposób:

+
mystring.link("http://www.helloworld.com")
+
+

Poniższe tabela podsumowuje metody obiektu String.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
MetodyOpis
anchorTworzy nazwaną kotwicę HTML.
big, blink, bold, fixed, italics, small, strike, sub, supTworzy w HTML sformatowany łańcuch znaków.
charAt, charCodeAtZwraca znak lub kod znaku znajdującego się na określonej pozycji łańcucha znaków.
indexOf, lastIndexOfZwraca odpowiednio pozycję określonego podciągu w łańcuchu znaków lub ostatnią pozycję określonego podciągu.
linkTworzy odnośnik HTML.
concatŁączy tekst z dwóch łańcuchów i zwraca nowy łańcuch znaków.
fromCharCodeBuduje łańcuch znaków z określonej sekwencji wartości Unicode. Jest metoda klasy String, a nie instancji String.
splitDzieli obiekt String na tablicę łańcuchów poprzez rozdzielenie łańcucha znaków na podciągi.
sliceWycina fragment łańcucha znaków i zwraca nowy łańcuch.
substring, substrZwraca określony podciąg łańcucha znaków, poprzez określenie indeksów początkowych i końcowych lub też określenie indeksu początkowego i długości.
match, replace, searchPracuje z wyrażeniami regularnymi.
toLowerCase, toUpperCaseZwraca łańcuch znaków odpowiednio z wszystkimi małymi lub wszystkimi dużymi znakami.
+

Tabela 7.4: Metody instancji String

+

Literały znakowe nie są obiektami String

+

Obiekt String jest obiektem opakowującym wokół pierwotnego typu danych łańcuchu znaków. Nie myl literału znakowego z obiektem String. Na przykład poniższy kod tworzy literał s1, jak również obiekt String s2:

+
s1 = "foo" //tworzy wartość literału znakowego
+s2 = new String("foo") //tworzy obiekt String
+
+

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. 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, ponieważ obiekty String mogą zachowywać się nieintuicyjnie. Przykładowo:

+
s1 = "2 + 2" //tworzy wartość literału znakowego
+s2 = new String("2 + 2")//tworzy obiekt String
+eval(s1) //zwraca liczbę 4
+eval(s2) //zwraca łańcuch "2 + 2"
+
+

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Obiekty predefiniowane:Obiekt RegExp", "Przewodnik po języku JavaScript 1.5:Języki oparte na klasach vs. oparte na prototypach") }}

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/operatory/operatory_przypisania/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/operatory/operatory_przypisania/index.html" new file mode 100644 index 0000000000..8af382eee6 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/operatory/operatory_przypisania/index.html" @@ -0,0 +1,67 @@ +--- +title: Operatory przypisania +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_przypisania +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Operatory przypisania

+

Operator przypisania przypisuje wartość do jego lewego argumentu bazującego na wartości z jego prawego argumentu. Zasadnicze znaczenie posiada operator (=), który znaczy 'Przypisanie' i przypisuje wartość prawego argumentu do lewego. Jest to: x = y przypisanie wartości y do x.

+

Inne operatory przypisania są stenografią dla standardowych operacji, jakie widzimy w poniższej tabeli.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Skrócony operatorZnaczenie
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
+

Tabela: Operatory 'Przypisanie'

+

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

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/podgl\304\205d_klas_liveconnect/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/podgl\304\205d_klas_liveconnect/index.html" new file mode 100644 index 0000000000..2dd4acf285 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/podgl\304\205d_klas_liveconnect/index.html" @@ -0,0 +1,47 @@ +--- +title: Podgląd klas LiveConnect +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

+

+

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 +
+
+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/LiveConnect_Overview", "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_general_de_LiveConnect", "ja": "ja/Core_JavaScript_1.5_Guide/LiveConnect_Overview" } ) }} diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/index.html" new file mode 100644 index 0000000000..28e5f9255c --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/index.html" @@ -0,0 +1,37 @@ +--- +title: Praca z przykładem +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Przykład obiektu Pracownik

+

Dalsza część tego rozdziału opiera się na hierarchii pracowników przedstawionej na poniższym rysunku.

+

Grafika:hier01.png

+

Rysunek 8.1: Prosta hierarchia obiektu

+

W przykładzie tym zostały użyte następujące obiekty:

+ +

Pozostała część przykładu:

+ +
+

{{ PreviousNext("Przewodnik_po_języku_JavaScript_1.5:Języki_oparte_na_klasach_vs._oparte_na_prototypach", "Przewodnik_po_języku_JavaScript_1.5:Praca_z_przykładem:Tworzenie_hierarchii") }}

+
+

 

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/tworzenie_hierarchii/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/tworzenie_hierarchii/index.html" new file mode 100644 index 0000000000..a15422c92d --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/tworzenie_hierarchii/index.html" @@ -0,0 +1,149 @@ +--- +title: Tworzenie hierarchii +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem/Tworzenie_hierarchii +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Tworzenie hierarchii

+

Istnieje kilka sposobów zdefiniowania odpowiednich funkcji konstruktora do zaimplementowania hierarchii Pracownik. To w jaki sposób zdecydujesz się je zdefiniować zależy głównie od tego, co chcesz zrobić w swojej aplikacji.

+

Ten fragment pokazuje jak użyć prostych (i stosunkowo mało elastycznych) definicji w celu zademonstrowania dziedziczenia. W tych definicjach nie możesz określić żadnych wartości własności podczas tworzenia obiektu. Nowo utworzony obiekt po prostu otrzymuje wartości domyślne, które możesz zmienić później. Rysunek 8.2 ilustruje hierarchię wraz z tymi prostymi definicjami.

+

W prawdziwej aplikacji zdefiniowałbyś prawdopodobnie konstruktory, które pozwoliłyby Ci na zapewnienie własnościom wartości w czasie tworzenia obiektu (zobacz więcej elastycznych konstruktorów, aby uzyskać więcej informacji). Na chwilę obecną te proste definicje zademonstrują jak objawia się dziedziczenie.

+

Grafika:hier02.png
+ Rysunek 8.2: Definicje obiektu Pracownik

+

Poniższe definicje obiektu Pracownik w Javie i JavaScripcie są podobne. Różnią się one jedynie tym, że w Javie musisz określić typ każdej własności (w przeciwieństwie do JavaScriptu) oraz musisz stworzyć wyraźną metodę konstruktora dla klasy Javy.

+

</tr>

+ + + + + + + + + + + +
JavaScriptJava
+ 
+function Pracownik () {
+this.imie = "";
+this.dept = "ogólny";
+}
+
+ 		+ 
+public class Pracownik {
+   public String imie;
+   public String dept;
+   public Pracownik () {
+      this.imie = "";
+      this.dept = "ogólny";
+   }
+}
+
+
+

Definicje Manager i Robotnik pokazuję różnicę w sposobie określania następnego obiektu wyższego w łańcuchu dziedziczenia. W JavaScripcie dodajesz instancję prototypową jako wartość własności prototypu funkcji konstruktora. Możesz do zrobić w dowolnej chwili po zdefiniowaniu konstruktora. W Javie określasz superklasę wewnątrz definicji klasy. Nie możesz zmienić superklasy spoza definicji klasy.

+

</tr>

+ + + + + + + + + + + +
JavaScriptJava
+ 
+function Manager () {
+this.raporty = [];
+}
+Manager.prototype = new Pracownik;
+
+function Robotnik () {
+this.projekty = [];
+}
+Robotnik.prototype = new Pracownik;
+
+ 		+ 
+public class Manager extends Pracownik {
+   public Employee[] raporty;
+   public Manager () {
+      this.raporty = new Pracownik[0];
+   }
+}
+
+public class Robotnik extends Pracownik {
+   public String[] projekty;
+   public Robotnik () {
+      this.projekty = new String[0];
+   }
+}
+
+
+

Definicje Inzynier i Sprzedawca tworzą obiekty, które pochodzą od Robotnik a stamtąd od Pracownik. Obiekt tych typów posiada własności wszystkich obiektów znajdujących się ponad nim w łańcuchu. W dodatku definicje te nadpisują dziedziczoną własność dept nowymi wartościami specyficznymi dla tych obiektów.

+ + + + + + + + + + + +
JavaScriptJava
+ 
+function Sprzedawca () {
+   this.dept = "sprzedaż";
+   this.przydzial = 100;
+}
+Sprzedawca.prototype = new Robotnik;
+
+function Inzynier () {
+   this.dept = "inżynieria";
+   this.maszyna = "";
+}
+Inzynier.prototype = new Robotnik;
+
+ 		+ 
+public class Sprzedawca extends Robotnik {
+   public double przydzial;
+   public Sprzedawca () {
+      this.dept = "sprzedaż";
+      this.przydzial = 100.0;
+   }
+}
+
+public class Inzynier extends Robotnik {
+   public String maszyna;
+   public Inzynier () {
+      this.dept = "inżynieria";
+      this.maszyna = "";
+   }
+}
+
+
+

Używając tych definicji możesz stworzyć instancje tych obiektów, których własności otrzymują domyślne wartości. Rysunek 8.3 ilustruje zastosowanie tych definicji JavaScriptu do zdefiniowania nowych obiektów i pokazuje wartości własności nowych obiektów.

+

Uwaga: Termin + + instancja + posiada określone techniczne znaczenie w językach opartych na klasach. W językach tych instancja jest pojedynczą składową klasy i jest całkowicie różna od klasy. W JavaScripcie "instancja" nie ma takiego technicznego znaczenia, ponieważ JavaScript nie posiada tej różnicy między klasami a instancjami. Jednak, mówiąc o JavaScripcie, "instancja" może być użyta nieformalnie w znaczeniu obiektu utworzonego za pomocą konkretnej funkcji konstruktora. Dlatego w tym przykładzie mógłbyś nieformalnie stwierdzić, że janina jest instancją Inzynier. Podobnie chociaż terminy + + rodzic, dziecko, przodek + i + + potomek + nie mają formalnego znaczenia w JavaScripcie, możesz użyć ich nieformalnie, aby odnieść się do obiektów znajdujących się wyżej lub niżej w łańcuchu prototypu.

+

Grafika:hier03.png
+ Rysunek 8.3: Tworzenie obiektów z prostymi definicjami

+

{{ PreviousNext("Przewodnik_po_języku_JavaScript_1.5:Praca_z_przykładem", "Przewodnik_po_języku_JavaScript_1.5:Praca_z_przykładem:Własności_obiektu") }}

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/dodawanie_w\305\202asno\305\233ci/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/dodawanie_w\305\202asno\305\233ci/index.html" new file mode 100644 index 0000000000..ec2e836159 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/dodawanie_w\305\202asno\305\233ci/index.html" @@ -0,0 +1,23 @@ +--- +title: Dodawanie własności +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem/Własności_obiektu/Dodawanie_własności +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Dodawanie własności

+

W JavaScripcie możesz dodawać własności do dowolnego obiektu w momencie uruchomienia. Nie jesteś zmuszony używać tylko własności dostarczonych przez funkcję konstruktora. Aby dodawać własność, która jest specyficzna dla pewnego obiektu, przypisz wartość do tego obiektu w następujący sposób:

+
mark.bonus = 3000;
+
+

Teraz obiekt mark posiada własność bonus, lecz nie posiadają jej inne obiekty WorkerBee.

+

Jeśli dodasz nową własność do obiektu, który jest używany jako prototyp w funkcji konstruktora, dodajesz tę własność do wszystkich obiektów, które dziedziczą własności tego prototypu. Przykładowo, możesz dodać własność specialty dla wszystkich obiektów employee za pomocą następującej instrukcji:

+
Employee.prototype.specialty = "none";
+
+

Gdy tylko JavaScript wykona tę instrukcję, obiekt mark również będzie posiadał własność specialty wraz z wartością "none". Poniższy rysunek pokazuje efekt dodania tej własności do prototypu Employee oraz następnie nadpisania jej prototypem Engineer.

+

Grafika:hier04.gif
+ Rysunek 8.4: Dodawanie własności {{ PreviousNext("Przewodnik po języku JavaScript 1.5:Praca z przykładem:Własności obiektu:Dziedziczenie własności", "Przewodnik po języku JavaScript 1.5:Praca z przykładem:Więcej elastycznych konstruktorów") }}

+
+  
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/dziedziczenie_w\305\202asno\305\233ci/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/dziedziczenie_w\305\202asno\305\233ci/index.html" new file mode 100644 index 0000000000..8287857c63 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/dziedziczenie_w\305\202asno\305\233ci/index.html" @@ -0,0 +1,33 @@ +--- +title: Dziedziczenie własności +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem/Własności_obiektu/Dziedziczenie_własności +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Dziedziczenie własności

+

Przypuśćmy, że utworzyłeś obiekt marek jako Robotnik, tak jak pokazano na Rysunku 8.3, za pomocą poniższej instrukcji:

+
marek = new Robotnik;
+
+

Gdy JavaScript napotyka na operator new, tworzy nowy ogólny obiekt i przekazuje go jako wartość słowa kluczowego this funkcji konstruktora Robotnik. Funkcja konstruktora bezpośrednio nadaje wartość własności projekty i bezwzględnie ustala wartość wewnętrznej własności __proto__ jako Robotnik.prototype (ta nazwa własności posiada dwa znaki podkreślenia na początku i dwa na końcu). Własność __proto__ decyduje o łańcuchu prototypu używanym do zwracania wartości własności. Gdy tylko własności te są ustalone, JavaScript zwraca nowy obiekt, a instrukcja przypisania przypisuje zmienną marek do tego obiektu.

+

Proces ten nie umieszcza wartości bezpośrednio w obiekcie marek (wartości + + lokalne + ) dla własności, które marek dziedziczy z łańcucha prototypu. Gdy pytasz o wartość własności, JavaScript najpierw sprawdza czy wartość istnieje w tym obiekcie. Jeśli tak, zwraca tę wartość. Jeśli wartość nie istnieje tam lokalnie, JavaScript sprawdza łańcuch prototypu (używając własności __proto__). Jeśli obiekt w łańcuchu prototypu posiada wartość tej własności, jest ona zwracana. Jeśli własność nie zostanie znaleziona, JavaScript zgłasza, że obiekt nie posiada własności. W tym przypadku obiekt mark posiada następujące własności i wartości:

+
marek.imie = "";
+marek.dept = "ogólny";
+marek.projekty = [];
+
+

Obiekt mark dziedziczy wartości własności imie i dept z obiektu prototypowego w mark.__proto__. Ma on również przypisaną przez konstruktor Robotnik wartość własności projekty. Dzięki temu otrzymujesz dziedziczenie własności i ich wartości w JavaScripcie. Niektóre subtelności tego procesu zostały przedyskutowane w Powrót dziedziczenia własności.

+

Ponieważ konstruktory te nie pozwalają na dostarczenie wartości specyficznych dla instancji, informacje te są ogólne. Wartościami własności są te domyślnie dzielone przez wszystkie nowe obiekty utworzone z Robotnik. Możesz oczywiście zmienić wartości dowolnej z tych własności. Mógłbyś podać określone informacje dla marek tak jak pokazano poniżej:

+
marek.imie = "Doe, Marek";
+marek.dept = "administrator";
+marek.projekty = ["navigator"];
+
+
+

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Praca z przykładem:Własności obiektu", "Przewodnik po języku JavaScript 1.5:Praca z przykładem:Własności obiektu:Dodawanie własności") }}

+
+

 

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/index.html" new file mode 100644 index 0000000000..85957fa7fc --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_przyk\305\202adem/w\305\202asno\305\233ci_obiektu/index.html" @@ -0,0 +1,19 @@ +--- +title: Własności obiektu +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem/Własności_obiektu +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Własności obiektu

+

Ten artykuł omawia jak obiekty dziedziczą własności z innych obiektów w łańcuchu prototypu i co się stanie, gdy dodasz własność w momencie uruchomienia.

+ +

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Praca z przykładem:Tworzenie hierarchii", "Przewodnik po języku JavaScript 1.5:Praca z przykładem:Własności obiektu:Dziedziczenie własności") }}

+
+  
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_wyra\305\274eniami_regularnymi/przyk\305\202ady_wyra\305\274e\305\204_regularnych/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_wyra\305\274eniami_regularnymi/przyk\305\202ady_wyra\305\274e\305\204_regularnych/index.html" new file mode 100644 index 0000000000..f615d23035 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_wyra\305\274eniami_regularnymi/przyk\305\202ady_wyra\305\274e\305\204_regularnych/index.html" @@ -0,0 +1,122 @@ +--- +title: Przykłady wyrażeń regularnych +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Praca_z_wyrażeniami_regularnymi/Przykłady_wyrażeń_regularnych +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Przykłady

+

Poniższe przykłady prezentują niektóre użycia wyrażeń regularnych.

+

Zmiana kolejności w łańcuchu znaków wejścia

+

Następujący przykład ilustruje tworzenie wyrażeń regularnych i użycie string.split() i string.replace(). Czyści on bezwzględnie wejściowy łańcuch znaków zawierający imiona (pierwsze imię jest pierwsze) oddzielone odstępem, tabulatorem i dokładnie jednym średnikiem. Na koniec odwraca on kolejność imion (ostatnie imię jest pierwsze) i sortuje listę.

+
<script type="text/javascript">
+
+// Łańcuch znaków z imionami zawiera wiele spacji i tabulatorów,
+// może również zawierać wiele spacji pomiędzy pierwszym a ostatnim imieniem.
+var imiona = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";
+
+var output = new Array(
+  "---------- Oryginalny łańcuch znaków<br><br>",
+  imiona + "<br><br>");
+
+// Przygotuj dwa wzorce wyrażeń regularnych i tablicę do przechowywania.
+// Podziel łańcuch na elementy tablicy.
+
+// wzorzec: możliwe białe znaki, następnie średnik, potem znów możliwe białe
+var wzor = /\s*;\s*/;
+
+// Rozbij łańcuch znaków na części oddzielone przez powyższy wzorzec
+// i przechowaj je w tablicy o nazwie listaImion
+var listaImion = imiona.split(wzor);
+
+// Nowy wzorzec: jeden lub więcej znaków, następnie spacje, następnie znów znaki.
+// Użyj nawiasów, by "zapamiętać" porcje wzorca.
+// Zapamiętane porcje przydadzą się później.
+var wzor = /(\w+)\s+(\w+)/;
+
+// Nowa tablica do przechowywania przetwarzanych imion.
+var ListaWgNazwisk = new Array();
+
+// Wyświetl nazwę tablicy i wypełnij nową tablicę
+// imionami oddzielonymi za pomocą przecinka, zaczynając od ostatniego.
+//
+// Metoda "zamien" usuwa wszystko pasujące do wzorca
+// i zamienia to z zapamiętanymi porcjami.
+//
+// Zmienne $1 i $2 odwołują się do zapamiętanych porcji
+// podczas porównywania wzorca.
+
+output.push("---------- Po rozdzieleniu przez wyrażenie regularne<BR>");
+
+var i, len;
+for (i = 0, len = listaImion.length; i < len; i++)
+{
+  output.push(nameList[i] + "<br>");
+  ListaWgNazwisk[i] = listaImion[i].replace(wzor, "$2, $1")
+}
+
+// Wyświetl nową tablicę.
+output.push("---------- Odwrócone imiona<br>");
+for (i = 0, len = ListaWgNazwisk.length; i < len; i++)
+{
+  output.push(ListaWgNazwisk[i] + "<br>")
+}
+
+// Sortuj według ostatniego imienia, następnie wyświetl posortowaną tablicę.
+ListaWgNazwisk.sort();
+output.push("---------- Posortowano<br>");
+for (i = 0, len = ListaWgNazwisk.length; i < len; i++)
+{
+  output.push(ListaWgNazwisk[i] + "<br>")
+}
+
+output.push("---------- Koniec<br>");
+
+document.write(output.join("\n"));
+
+</script>
+
+

Używanie specjalnych znaków do sprawdzenia wejścia

+

W następującym przykładzie, użytkownik wprowadza numer telefonu. Gdy użytkownik naciśnie klawisz Enter, skrypt sprawdzi poprawność numeru. Jeśli numer jest poprawny (pasuje do sekwencji znaków określonej przez wyrażenie regularne), skrypt wywoła okno z podziękowaniem użytkownikowi i zatwierdza numer. Jeśli numer nie jest poprawny, skrypt wywoła okno informacji o nieprawidłowym numerze telefonu.

+

Wyrażenie regularne szuka zera lub jednego nawiasu otwartego \(?, po którym następują trzy cyfry \d{3}, następnie znów zero lub jeden nawias zamknięty \)?, potem jednego myślnika, ukośnika lub znaku dziesiętnego, a gdy je znajdzie zapamiętuje znaki (-\\/\\.), następujące po nich trzy cyfry i ciąg składający się z myślnika, ukośnika lub znaku dziesiętnego \1 i następujących potem czterech cyfr \d{4}.

+

Zdarzenie Change zostaje aktywowane, kiedy użytkownik naciśnie klawisz Enter ustawiając wartość RegExp.input.

+
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+  "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-2">
+    <meta http-equiv="Content-Script-Type" content="text/javascript">
+    <script type="text/javascript">
+      var re = /\(?\d{3}\)?([-\/\.])\d{3}\1\d{4}/;
+
+      function testInfo(phoneInput)
+      {
+        var OK = re.exec(phoneInput.value);
+
+        if (!OK)
+        {
+          window.alert(RegExp.input + " nie jest wprowadzony numerem kierunkowy!");
+        }
+        else
+        {
+          window.alert("Dziękuję, Twój numer telefonu to " + OK[0]);
+        }
+      }
+    </script>
+  </head>
+
+  <body>
+    <p>Wprowadź numer telefonu (z numerem kierunkowym), a następnie naciśnij klawisz Enter.</p>
+    <form action="">
+      <input name="phone" onchange="testInfo(this);">
+    </form>
+  </body>
+</html>
+
+
+

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Praca z wyrażeniami regularnymi:Globalne wyszukiwanie, wielkość znaków, wieloliniowe wejście", "Przewodnik po języku JavaScript 1.5:Blok instrukcji") }}

+
+

 

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_zamkni\304\231ciami/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_zamkni\304\231ciami/index.html" new file mode 100644 index 0000000000..fc71b64cad --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/praca_z_zamkni\304\231ciami/index.html" @@ -0,0 +1,286 @@ +--- +title: Praca z zamknięciami +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Praca_z_zamknięciami +--- +

Praca z zamknięciami

+ +

Zamknięcia są często uważane za zaawansowaną właściwość JavaScript, ale zrozumienie ich jest niezbędne do opanowania tego języka.

+ +

Rozważmy następującą funkcję:

+ +
function init() {
+  var name = "Mozilla";
+  function displayName() {
+    alert(name);
+  }
+  displayName();
+}
+
+ +

Funkcja init() tworzy lokalną zmienną o nazwie name, i następnie definiuje funkcję nazwaną displayName(). displayName() jest wewnętrzną funkcją - jest zdefiniowana wewnątrz funkcji init(), i jest dostępna jedynie w zasięgu ciała tej funkcji. displayName() nie posiada własnych lokalnych zmiennych, ale używa zmiennej name zadeklarowanej w funkcji zewnętrznej.

+ +

Działa to całkiem nieźle - spróbujmy wykonać kod, aby zobaczyć co się stanie. To jest przykład leksykalnego zasięgu: w JavaScript, zasięg zmiennej jest zdefiniowany przez jej położenie w kodzie źródłowym, i zagnieżdżone funkcje mają dostęp do zmiennych zadeklarowanych w ich zewnętrznym obszarze.

+ +

Teraz rozważmy następny przykład:

+ +
function makeFunc() {
+  var name = "Mozilla";
+  function displayName() {
+    alert(name);
+  }
+  return displayName;
+}
+
+var myFunc = makeFunc();
+myFunc();
+
+ +

Po wykonaniu kodu otrzymamy identyczny efekt jak poprzedni przykład z funkcją init(): łańcuch "Mozilla" zostanie wyświetlony w oknie alertowym JavaScript. Jaka jest różnica - i co ciekawsze - Czy wewnętrzna funkcja displayName() została zwrócona z zewnętrznej funkcji zanim została wykonana?

+ +

Kod działa, lecz może się on wydawać nieintuicyjny. Normalnie, lokalne zmienne wewnątrz funkcji istnieją tylko podczas jej wykonywania. Kiedy makeFunc() została wykonana, spodziewamy się - i ma to sens - że zmienna name nie będzie więcej potrzebna. Skoro kod wykonuje oczekiwaną pracę, oczywiście nie ma mowy o przypadku.

+ +

Rozwiązaniem tej zagadki jest fakt, że funkcja myFunc zostaje zamknięciem. Zamknięcie jest specjalnym rodzajem obiektu, który łączy dwie rzeczy: funkcję i środowisko, w którym ta funkcja została utworzona. The environment consists of any local variables that were in-scope at the time that the closure was created. In this case, myFunc is a closure that incorporates both the displayName function and the "Mozilla" string that existed when the closure was created.

+ +

Here's a slightly more interesting example - a makeAdder function:

+ +
function makeAdder(x) {
+  return function(y) {
+    return x + y;
+  };
+}
+
+var add5 = makeAdder(5);
+var add10 = makeAdder(10);
+
+print(add5(2));  // 7
+print(add10(2)); // 12
+
+ +

In this example, we have defined a function makeAdder(x) which takes a single argument x and returns a new function. The function it returns takes a single argument y, and returns the sum of x and y.

+ +

In essence, makeAdder is a function factory - it creates functions which can add a specific value to their argument. In the above example we use our function factory to create two new functions - one that adds 5 to its argument, and one that adds 10.

+ +

add5 and add10 are both closures. They share the same function body definition, but store different environments. In add5's environment, x is 5. As far as add10 is concerned, x is 10.

+ +

Praktyczne zamknięcia

+ +

That's the theory out of the way - but are closures actually useful? Let's consider their practical implications. A closure lets you associate some data (the environment) with a function that operates on that data. This has obvious parallels to object oriented programming, where objects allow us to associate some data (the object's properties) with one or more methods.

+ +

Consequently, you can use a closure anywhere that you might normally use an object with only a single method.

+ +

Situations where you might want to do this are particularly common on the web. Much of the code we write in web JavaScript is event-based - we define some behavior, then attach it to an event that is triggered by the user (such as a click or a keypress). Our code is generally attached as a callback: a single function which is executed in response to the event.

+ +

Here's a practical example: suppose we wish to add to a page buttons that adjust the size of the page text. One way of doing this is to specify the font-size of the body element in pixels, then set the size of the other elements on the page (such as headers) using the relative em unit:

+ +
body {
+  font-family: Helvetica, Aria, sans-serif;
+  font-size: 12px;
+}
+
+h1 {
+  font-size: 1.5em;
+}
+h2 {
+  font-size: 1.2em;
+}
+
+ +

Our interactive text size buttons can change the font-size property of the body element, and the adjustments will be picked up by other elements on the page thanks to the relative units.

+ +

Here's the JavaScript:

+ +
function makeSizer(size) {
+  return function() {
+    document.body.style.fontSize = size + 'px';
+  };
+}
+
+var size12 = makeSizer(12);
+var size14 = makeSizer(14);
+var size16 = makeSizer(16);
+
+ +

size12, size14 and size16 are now functions which will resize the body text to 12, 14, and 16 pixels, respectively. We can attach them to buttons (in this case links) as follows:

+ +
function setupButtons() {
+  document.getElementById('size-12').onclick = size12;
+  document.getElementById('size-14').onclick = size14;
+  document.getElementById('size-16').onclick = size16;
+}
+ +
<a href="#" id="size-12">12</a>
+<a href="#" id="size-14">14</a>
+<a href="#" id="size-16">16</a>
+
+ +

Emulating private methods with closures

+ +

Languages such as Java provide the ability to declare methods private, meaning that they can only be called by other methods in the same class.

+ +

JavaScript does not provide a native way of doing this, but it is possible to emulate private methods using closures. Private methods aren't just useful for restricting access to code: they also provide a powerful way of managing your global namespace, keeping non-essential methods from cluttering up the public interface to your code.

+ +

Here's how to define some public functions that can access private functions and variables, using closures:

+ +
var Counter = (function() {
+  var privateCounter = 0;
+  function changeBy(val) {
+    privateCounter += val;
+  }
+  return {
+    increment: function() {
+      changeBy(1);
+    },
+    decrement: function() {
+      changeBy(-1);
+    },
+    value: function() {
+      return privateCounter;
+    }
+  }
+})();
+
+alert(Counter.value()); /* Alerts 0 */
+Counter.increment();
+Counter.increment();
+alert(Counter.value()); /* Alerts 2 */
+Counter.decrement();
+alert(Counter.value()); /* Alerts 1 */
+
+ +

There's a lot going on here. In previous examples each closure has had its own environment; here we create a single environment which is shared by three functions: Counter.increment, Counter.decrement and Counter.value.

+ +

The shared environment is created in the body of an anonymous function, which is executed as soon as it has been defined. The environment contains two private items: a variable called privateCounter and a function called changeBy. Neither of these private items can be accessed directly from outside the anonymous function. Instead, they must be accessed by the three public functions that are returned from the anonymous wrapper.

+ +

Those three public functions are closures that share the same environment. Thanks to JavaScript's lexical scoping, they each have access to the privateCounter variable and changeBy function.

+ +

Using closures in this way provides a number of benefits that are normally associated with object oriented programming, in particular data hiding and encapsulation.

+ +

Creating closures in loops: A common mistake

+ +

Prior to the introduction of the let keyword in JavaScript 1.7, a common problem with closures occurred when they were created inside a loop. Consider the following example:

+ +
<p id="help">Helpful notes will appear here</p>
+<p>E-mail: <input type="text" id="email" name="email"></p>
+<p>Name: <input type="text" id="name" name="name"></p>
+<p>Age: <input type="text" id="age" name="age"></p>
+
+ +
function showHelp(help) {
+  document.getElementById('help').innerHTML = help;
+}
+
+function setupHelp() {
+  var helpText = [
+      {'id': 'email', 'help': 'Your e-mail address'},
+      {'id': 'name', 'help': 'Your full name'},
+      {'id': 'age', 'help': 'Your age (you must be over 16)'}
+    ];
+
+  for (var i = 0; i < helpText.length; i++) {
+    var item = helpText[i];
+    document.getElementById(item.id).onfocus = function() {
+      showHelp(item.help);
+    }
+  }
+}
+
+ +

The helpText array defines three helpful hints, each associated with the ID of an input field in the document. The loop cycles through these definitions, hooking up an onfocus event to each one that shows the associated help method.

+ +

If you try this code out, you'll see that it doesn't work as expected. No matter what field you focus on, the message about your age will be displayed.

+ +

The reason for this is that the functions assigned to onfocus are closures; they consist of the function definition and the captured environment from the setupHelp function's scope. Three closures have been created, but each one shares the same single environment. By the time the onfocus callbacks are executed, the loop has run its course and the item variable (shared by all three closures) has been left pointing to the last entry in the helpText list.

+ +

One solution in this case is to use more closures: in particular, to use a function factory as described earlier on:

+ +
function showHelp(help) {
+  document.getElementById('help').innerHTML = help;
+}
+
+function makeHelpCallback(help) {
+  return function() {
+    showHelp(help);
+  };
+}
+
+function setupHelp() {
+  var helpText = [
+      {'id': 'email', 'help': 'Your e-mail address'},
+      {'id': 'name', 'help': 'Your full name'},
+      {'id': 'age', 'help': 'Your age (you must be over 16)'}
+    ];
+
+  for (var i = 0; i < helpText.length; i++) {
+    var item = helpText[i];
+    document.getElementById(item.id).onfocus = makeHelpCallback(item.help);
+  }
+}
+
+ +

This works as expected. Rather than the callbacks all sharing a single environment, the makeHelpCallback function creates a new environment for each one in which help refers to the corresponding string from the helpText array.

+ +

If you are using JavaScript 1.7 or higher, you can solve this problem by using the let keyword to create a variable that has block level scope:

+ +
  for (var i = 0; i < helpText.length; i++) {
+    let item = helpText[i];
+    document.getElementById(item.id).onfocus = function() {
+      showHelp(item.help);
+    }
+  }
+
+ +

The let keyword causes the item variable to be created with block level scope, causing a new reference to be created for each iteration of the for loop. This means that a separate variable is captured for each closure, solving the problem caused by the shared environment.

+ +

Performance considerations

+ +

It is unwise to unnecessarily create functions within other functions if closures are not needed for a particular task as it will negatively affect script performance.

+ +

For instance, when creating a new object/class, methods should normally be associated to the object's prototype rather than defined into the object constructor. The reason is that whenever the constructor is called the methods would get reassigned (that is, for every object creation).

+ +

Consider the following impractical but demonstrative case:

+ +
function MyObject(name, message) {
+  this.name = String(name);
+  this.message = String(message);
+  this.getName = function() {
+    return this.name;
+  };
+
+  this.getMessage = function() {
+    return this.message;
+  };
+}
+
+ +

The previous code does not take advantage of the benefits of closures and thus should instead be formulated:

+ +
function MyObject(name, message) {
+  this.name = String(name);
+  this.message = String(message);
+}
+MyObject.prototype = {
+  getName: function() {
+    return this.name;
+  },
+  getMessage: function() {
+    return this.message;
+  }
+};
+
+ +

Or as follows:

+ +
function MyObject(name, message) {
+  this.name = String(name);
+  this.message = String(message);
+}
+MyObject.prototype.getName = function() {
+  return this.name;
+};
+MyObject.prototype.getMessage = function() {
+  return this.message;
+};
+
+ +

In the two previous examples, the inherited prototype can be shared by all objects and the method definitions need not occur at every object creation. See Core_JavaScript_1.5_Guide#Details_of_the_Object_Model for more details.

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/definiowanie_metod/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/definiowanie_metod/index.html" new file mode 100644 index 0000000000..64b164df13 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/definiowanie_metod/index.html" @@ -0,0 +1,48 @@ +--- +title: Definiowanie metod +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Definiowanie_metod +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Definiowanie metod

+

Funkcja + + method + jest funkcją łączącą z obiektem. Definiujesz metodę w ten sam sposób jak definiujesz standardową funkcje. Użyj następującej składni do połączenia funkcji z istniejącym obiektem:

+
object.methodname = function_name
+
+

gdzie: object jest to istniejący obiekt, methodname jest nazwą przydzielonej metody i function_name jest nazwą funkcji.

+

Możesz nazwać metodę w kontekście obiektu jako następujące:

+
object.methodname(params);
+
+

Możesz definiować metody dla typów obiektu włączając do tego definiowanie metody w funkcji konstruktora obiektowego. Na przykład, możesz zdefiniować funkcję która będzie formatowała i wyświetlała własności poprzednio-definiowanych obiektów car, na przykład:

+
function displayCar() {
+   var result = "A Beautiful " + this.year + " " + this.make
+      + " " + this.model;
+   pretty_print(result);
+}
+
+

gdzie: pretty_print jest funkcją wyświetlającą wg poziomej reguły i łańcuch znaków. Uwaga przy użyciu this odnoszącego się do obiektu, do której metody należą.

+

Tworzymy funkcję metody car, poprzez dodanie instrukcji:

+
this.displayCar = displayCar;
+
+

Do definicji obiektu. Więc, pełna definicja car będzie wyglądała jak

+
function car(make, model, year, owner) {
+   this.make = make;
+   this.model = model;
+   this.year = year;
+   this.owner = owner;
+   this.displayCar = displayCar;
+}
+
+

Teraz możemy nazwać metodę displayCar dla każdego następującego kodu:

+
car1.displayCar()
+car2.displayCar()
+
+

Efektem będzie produkcja wyjściowa następującego przykładu.

+

Grafika:Obja.gif
+ Przykład: Wyświetlanie metody po jej wykonaniu

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/definiowanie_w\305\202asno\305\233ci_typu_obiektu/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/definiowanie_w\305\202asno\305\233ci_typu_obiektu/index.html" new file mode 100644 index 0000000000..e52ead3f93 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/definiowanie_w\305\202asno\305\233ci_typu_obiektu/index.html" @@ -0,0 +1,19 @@ +--- +title: Definiowanie własności typu obiektu +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Definiowanie_własności_typu_obiektu +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Definiowanie własności typu obiektu

+

Dodaj własność do poprzednio zdefiniowanego typu obiektu stosując własności prototype. Zdefiniuje te własności, które współdzielą wszystkie obiekty określonego typu, raczej niż tylko jeden przypadek obiektu. Następnie dodajemy kod własności color do wszystkich obiektów typu car i potem przydziela wartość do własności color obiektu car1.

+
Car.prototype.color=null;
+car1.color="black";
+
+

Zobacz własności prototype z funkcji obiektu w dokumentacji języka JavaScript, aby uzyskać dodatkowe informacje.

+
+  
+

 

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/indeksowanie_w\305\202asno\305\233ci_obiektu/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/indeksowanie_w\305\202asno\305\233ci_obiektu/index.html" new file mode 100644 index 0000000000..c7d904e907 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/indeksowanie_w\305\202asno\305\233ci_obiektu/index.html" @@ -0,0 +1,16 @@ +--- +title: Indeksowanie własności obiektu +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Indeksowanie_własności_obiektu +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Indeksowanie własności obiektu

+

W JavaScripcie 1.0 możesz odwołać się do własności obiektu poprzez nazwę własności lub jej indeks porządkowy. Jednakże w JavaScripcie 1.1 i późniejszych, jeśli zdefiniujesz początkowo własność poprzez jej nazwę, musisz zawsze odwoływać się do niej poprzez nazwę, zaś jeśli zdefiniujesz własność poprzez indeks, musisz zawsze odwoływać się do niej poprzez ten indeks.

+

Dotyczy to sytuacji, gdy tworzysz obiekt i jego własności poprzez funkcję konstruktora, tak jak w powyższym przykładzie obiektu typu Auto oraz gdy definiujesz samodzielnie własności w sposób jawny (na przykład mojeAuto.kolor = "czerwony"). Dlatego jeśli definiujesz początkowo własności obiektu z indeksem, tak jak mojeAuto{{ mediawiki.external(5) }} = "25 mpg", możesz później odwołać się do własności poprzez myCar{{ mediawiki.external(5) }}.

+

Wyjątkiem od tej reguły są obiekty zaczerpnięte z języka HTML, jak na przykład tablica forms. Możesz zawsze odwoływać się do obiektów w tych tablicach zarówno poprzez ich liczbę porządkową (w zależności od tego, w jakiej kolejności pojawiają się w dokumencie) lub poprzez ich nazwę (jeśli jest zdefiniowana). Przykładowo, jeśli drugi znacznik <FORM> w dokumencie posiada atrybut NAME o wartości "mojFormularz", możesz się odwołać do formularza przez document.forms{{ mediawiki.external(1) }} lub document.forms{{ mediawiki.external('\"mojFormularz\"') }} lub też document.mojFormularz. {{ PreviousNext("Przewodnik po języku JavaScript 1.5:Tworzenie nowych obiektów:Zastosowanie konstruktorów funkcji", "Przewodnik po języku JavaScript 1.5:Tworzenie nowych obiektów:Definiowanie własności typu obiektu") }}

+
+  
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/index.html" new file mode 100644 index 0000000000..44ccf12523 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/index.html" @@ -0,0 +1,22 @@ +--- +title: Tworzenie nowych obiektów +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Tworzenie nowych obiektów

+

JavaScript ma liczbę obiektów predefiniowanych. W dodatku, możesz tworzyć swoje własne obiekty. W JavaScript 1.2 i późniejszych wersjach, możesz tworzyć obiekt używając inicjatora obiektu. Alternatywą, jest pierwszy tworzony konstruktor funkcji i następna instancja używanego obiektu funkcji i operatora new.

+ diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/usuwanie_w\305\202asno\305\233ci/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/usuwanie_w\305\202asno\305\233ci/index.html" new file mode 100644 index 0000000000..ade0f3875e --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/usuwanie_w\305\202asno\305\233ci/index.html" @@ -0,0 +1,26 @@ +--- +title: Usuwanie własności +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Usuwanie_własności +tags: + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Usuwanie właściwości

+

Możesz usunąć właściwość używając operatora delete Poniższy kod pokazuje jak usunąć właściwość.

+
//Tworzymy nową własność, myobj, z właściwościami a i b.
+myobj = new Object;
+myobj.a=5;
+myobj.b=12;
+
+//Usuwamy właściwość, opuszczając myobj z właściwością tylko b.
+delete myobj.a;
+
+

Możesz także użyć delete do usunięcia globalnych zmiennych jeśli słowo kluczowe var nie było użyte do zadeklarowania zmiennej:

+
g = 17;
+delete g;
+
+

Zobacz delete aby uzyskać więcej informacji.

+
+  
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/u\305\274ywanie_inicjacji_obiektu/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/u\305\274ywanie_inicjacji_obiektu/index.html" new file mode 100644 index 0000000000..b1b38112d9 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/u\305\274ywanie_inicjacji_obiektu/index.html" @@ -0,0 +1,36 @@ +--- +title: Używanie inicjacji obiektu +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Używanie_inicjacji_obiektu +tags: + - JavaScript + - Przewodnik_JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +--- +

Zastosowanie inicjacji obiektu

+ +

Uzupełnieniem możliwości tworzenia obiektów poprzez konstruktora funkcji, jest inicjator obiektów. Używanie inicjatora obiektów jest czasami wiązane z tworzeniem obiektów poprzez oznaczanie literowe. "Inicjator obiektu" jest nazwą zaczerpniętą ze standardów języka C++.

+ +

Składnia tworząca obiekt, używając inicjatora obiektu jest następująca:

+ +
objectName = {własność1:wartość2, własność2:wartość2,..., własnośćN:wartośćN}
+
+ +

gdzie objectName jest nazwą obiektu, każda własność jest identyfikatorem (nazwą, liczbą lub ciągiem znaków) a każda wartość jest wyrażeniem, którego wartość jest przypisana do własności. objectName jak i przypisanie są opcjonalne. Jeśli w pozostałej części kodu nie potrzebujesz odwoływać się do tego obiektu, nie musisz go przypisywać do zmiennej.

+ +

Jeśli obiekt został utworzony z użyciem inicjatora obiektu w głównym skrypcie, JavaScript interpretuje go za każdym razem, gdy ten przetwarza wyrażenie zawierające literał obiektu. Dodatkowo, inicjator użyty w funkcji, jest tworzony przy każdym jej wywołaniu.

+ +

Poniższa instrukcja tworzy obiekt i przypisuje go do zmiennej x, tylko w przypadku, gdy warunek jest prawdziwy.

+ +
if (warunek) x = {a:"witaj"}
+
+ +

Poniższy przykład tworzy obiekt mojaHonda z trzema własnościami. Należy zwrócić uwagę, iż silnik jest również obiektem z jego własnymi własnościami.

+ +
mojaHonda = {kolor:"czerwony", koła:4, silnik:{ilośćCylindrów:4, objętość:2.2}}
+
+ +

Inicjatorów możesz użyć również do tworzenia tablic. Zobacz literały tablic.

+ +

JavaScript 1.1 i wcześniejsze. Nie możesz używać inicjatorów obiektów. Możesz tworzyć obiekty tylko używając ich konstruktorów lub funkcji udostępnianych przez inne obiekty w tym celu. Zobacz Zastosowanie konstruktorów funkcji.

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/zastosowanie_'this'_do_obiektu_referencji/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/zastosowanie_'this'_do_obiektu_referencji/index.html" new file mode 100644 index 0000000000..2b4ad01835 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/zastosowanie_'this'_do_obiektu_referencji/index.html" @@ -0,0 +1,32 @@ +--- +title: Zastosowanie 'this' do obiektu referencji +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Zastosowanie_'this'_do_obiektu_referencji +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Zastosowanie this do obiektu referencji

+

JavaScript posiada specjalne słowo kluczowe this, które możemy użyć wewnątrz metody wskazującej nam aktualny obiekt. Na przykład: przypuśćmy, że mamy funkcję nazywającą się validate, która waliduje wartość własności obiektów, nadając im wartość wyższą lub niższą:

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

Następnie, możesz nazwać/powiedzieć, że funkcja validate, w każdym elemencie formularza, onChange posiada uchwyt, którego używa do przejścia do określonego elementu formularza, jak w następującym przykładzie:

+
<INPUT TYPE="text" NAME="age" SIZE=3
+   onChange="validate(this, 18, 99)">
+
+

Generalnie, this jest referencją do nazwy obiektu w metodzie.

+

Kiedy połączymy właściwości form, this który potrafi się odwołać do bieżącego obiektu formularza będącego jego 'rodzicem'. W poniższym przykładzie, formularz myForm składa się z obiektu Text oraz przycisku. Kiedy użytkownik kliknie przycisk, wartość obiektu Text jest ustawiana do nazwy formularza. Przyciski wywołują uchwyt zdarzenia onClick poprzez zastosowanie this.form w celu wskazania formularza będącego 'rodzicem', 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>
+
+
+  
diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/zastosowanie_konstruktor\303\263w_funkcji/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/zastosowanie_konstruktor\303\263w_funkcji/index.html" new file mode 100644 index 0000000000..1c5d6cdbda --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_nowych_obiekt\303\263w/zastosowanie_konstruktor\303\263w_funkcji/index.html" @@ -0,0 +1,62 @@ +--- +title: Zastosowanie konstruktorów funkcji +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Zastosowanie_konstruktorów_funkcji +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Zastosowaniem konstruktorów funkcji

+

Alternatywnie, możesz utworzyć obiekt w dwóch krokach:

+
    +
  1. Zdefiniować typ obiektu poprzez napisanie konstruktora funkcji.
    2. +
  2. Utworzyć natychmiast nowy obiekt.
    3. +
+

Do zdefiniowania typu obiektu, tworzymy funkcję dla typu obiektu który określa nazwę, właściwości i metody. Na przykład, sądząc, że chcesz utworzyć typ obiektu dla samochodów. Chcesz ten typ obiektu nazwać car i chcesz posiadać właściwości do zrobienia make , model, year i color. Aby to zrobić, powinieneś napisać następującą funkcje:

+
function car(make, model, year) {
+   this.make = make;
+   this.model = model;
+   this.year = year;
+}
+
+

Uwaga, użycie this pozwala wartości własności obiektów opartych na wartościach pasujących do tej funkcji.

+

Teraz możesz utworzyć obiekt nazwany mycar w następującym kodzie:

+
mycar = new car("Eagle", "Talon TSi", 1993);
+
+

Instrukcja ta tworzy mycar i dopuszcza to do określonych wartości. Potem wartość mycar.make jest łańcuchem "Eagle", mycar.year jest liczba całkowita 1993, w ten sposób(?).

+

Utwórz jakis numer obiektu car nazywając new. Na przykład,

+
kenscar = new car("Nissan", "300ZX", 1992);
+vpgscar = new car("Mazda", "Miata", 1990);
+
+

obiekt posiada właściwość która sama w sobie posiada jeszcze jeden obiekt. Na przykład; przypuśćmy, że zdefiniujemy obiekt nazwany następująco person:

+
function person(name, age, sex) {
+   this.name = name
+   this.age = age
+   this.sex = sex
+}
+
+

i potem przypisze nowe obiekty person jako następujące:

+
rand = new person("Rand McKinnon", 33, "M");
+ken = new person("Ken Jones", 39, "M");
+
+

Potem znów zapisz definicję car włączając własne właściwości, które pobierają obiekt person, jak następująco:

+
function car(make, model, year, owner) {
+   this.make = make;
+   this.model = model;
+   this.year = year;
+   this.owner = owner
+}
+
+

Błyskawiczne nowe obiekty, następnie użyjesz:

+
car1 = new car("Eagle", "Talon TSi", 1993, rand);
+car2 = new car("Nissan", "300ZX", 1992, ken);
+
+

Uwaga, która zamiast przechodzić z wartości literału string lub integer kiedy są tworzone nowe obiekty, powyższe instrukcje dzieją się w obiektach rand i ken jako argumenty dla właściciela. Potem jeśli chcesz przekonać się do nazwy właściciela car2 , możesz zaakceptować następujące warunki:

+
car2.owner.name
+
+

Notuj wszystko co możesz zawsze dodać do poprzedniego zdefiniowanego obiektu. Na przykład, instrukcja

+
car1.color = "black"
+
+

dodawaj właściwości color do car1, i przydziel tą wartość "black." Jednakże, to nie wpływa na pozostałe obiekty. Dodaj nową właściwość do wszystkich obiektów tego samego typu, musisz mieć dodaną właściwość do definicji obiektu typu car.

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_wyra\305\274enia_regularnego/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_wyra\305\274enia_regularnego/index.html" new file mode 100644 index 0000000000..e6a76041a3 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/tworzenie_wyra\305\274enia_regularnego/index.html" @@ -0,0 +1,43 @@ +--- +title: Tworzenie wyrażenia regularnego +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_wyrażenia_regularnego +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Tworzenie wyrażenia regularnego

+

Wyrażenie regularne możemy skonstruować na jeden z dwóch sposobów:

+ +
 re = /ab+c/;
+
+
+
+
+ Literały wyrażeń regularnych są kompilowane w czasie czytania skryptu ( + + script evaluation + ). Gdy wyrażenie regularne nie będzie się zmieniać, sposób ten zapewni lepszą wydajność.
+
+
+
+ +
 re = new RegExp("ab+c");
+
+
+
+
+ Użycie konstruktora powoduje kompilację wyrażenia regularnego w czasie wykonywania ( + + runtime + ). Użyj konstruktora, jeśli wiadomo, że wyrażenie regularne będzie się zmieniało lub, gdy nie będzie znane i zostanie podane z innego źródła, np. przez użytkownika.
+
+
+
+

{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory", "Przewodnik po języku JavaScript 1.5:Zapisywanie wzorca wyrażenia regularnego") }}

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/zapisywanie_wzorca_wyra\305\274enia_regularnego/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/zapisywanie_wzorca_wyra\305\274enia_regularnego/index.html" new file mode 100644 index 0000000000..65c13b3816 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/zapisywanie_wzorca_wyra\305\274enia_regularnego/index.html" @@ -0,0 +1,215 @@ +--- +title: Zapisywanie wzorca wyrażenia regularnego +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Zapisywanie_wzorca_wyrażenia_regularnego +tags: + - JavaScript + - Przewodnik_JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +--- +

Zapisywanie wzorca wyrażenia regularnego

+ +

Wzorzec wyrażenia regularnego składa się ze znaków prostych takich jak /abc/ lub kombinacji znaków prostych i specjalnych, jak np. /ab*c/ lub /Rozdział (\d+)\.\d*/. Ostatni przykład zawiera nawiasy, które działają jak urządzenie pamięci. Wzorzec w nawiasie użyty w tym porównaniu jest zapamiętywany w celu umożliwienia ponownego użycia, tak jak zostało to opisane w Using Parenthesized Substring Matches.

+ +

 

+ +

Używanie prostych wzorców

+ +

Proste wzorce tworzone są za pomocą znaków, z których ma składać się poszukiwany wynik. Przykładowo wzorzec /abc/ pasuje do kombinacji znaków w łańcuchach znaków tylko wtedy, gdy znaki 'abc' pojawiają się razem i dokładnie w takiej kolejności. Sukcesem zakończy się poszukiwanie tych znaków w łańcuchu "Cześć, znasz literki abc?" i "Najnowszym modelem samolotu jest slabcraft". W obydwu przypadkach występuje podciąg 'abc'. Nie zostaną za to zwrócone żadne wyniki w łańcuchu "abecadło z nieba spadło", ponieważ nie zawiera on podciągu 'abc'.

+ +

Używanie znaków specjalnych

+ +

When the search for a match requires something more than a direct match, such as finding one or more b's, or finding white space, the pattern includes special characters. For example, the pattern /ab*c/ matches any character combination in which a single 'a' is followed by zero or more 'b's (* means 0 or more occurrences of the preceding item) and then immediately followed by 'c'. In the string "cbbabbbbcdebc," the pattern matches the substring 'abbbbc'.

+ +

Poniższa tabela zawiera kompletny wykaz znaków specjalnych wraz z opisem stosowanych w wyrażeniach regularnych.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ZnakZnaczenie
\jedno z poniższych: +
    +
  • przed znakami rozumianymi zazwyczaj dosłownie oznacza, że znak ten jest znakiem specjalnym i nie jest rozumiany dosłownie. Na przykład /b/ oznacza znak 'b'. Umieszczenie przed 'b' ukośnika lewego (backslash ) powoduje, że znak ten oznacza ogranicznik słowa.
    • +
+ +
    +
  • przed znakami specjalnymi oznacza, że znak ten nie jest specjalny i jest rozumiany dosłownie. Na przykład * jest znakiem specjalnym, który oznacza 0 lub więcej wystąpień znaku poprzedzającego; np. /a*/ oznacza 0 lub więcej znaków 'a'. Aby uzyskać znak dosłowny *, należy poprzedzić go ukośnikiem lewym; np. /a\*a/ oznacza 'a*a'.
    • +
+
^Pasuje do początku wpisywanego tekstu. Jeśli flaga multiline (wiele linii) jest ustawiona na true, dodatkowo pasuje do każdej nowej linii. +

Np. /^A/ nie da nam w efekcie 'A' w łańcuchu "an A", ale da nam 'A' w łańcuchu "An A"

+
$Pasuje do końca wprowadzanych danych. Jeśli flaga multiline jest ustawiona na true, to pasuje również do każdego zakończenia linii. Np. /t$/ zwróci 't' z "eat", ale nie z "eater"
*Pasuje jeśli poprzedzający znak wystąpił 0 bądź więcej razy. +

Np. /bo*/ zwróci 'boooo' z "A Ghost booooed" oraz 'b' z "A bird warbled", ale nie zwróci nic z łańcucha "A goat grunted".

+
+Pasuje jeśli poprzedzający znak wystąpił 1 lub więcej razy. Równoważne z {1,} Np. /a+/ dopasuje 'a' z łańcucha "candy" oraz wszystkie literki a w "caaaaaaandy".
?Pasuje jeśli poprzedzający znak wystąpił raz lub nie wystąpił wcale. +

Np. /e?le?/ dopasuje 'el' w łańcuchu "angel" oraz 'le' w "angle".

+ +

Jeśli ? wystąpi zaraz za *, +, ? lub {}, to znaki te będą zwracały najkrótsze możliwe dopasowania, w przeciwieństwie do zwykłego zachowania, które możemy określić jako zachłanne (zwraca najdłuższe możliwe dopasowania).

+ +

Np. /bo*?/ zwróci 'b' z "A Ghost booooed".

+ Znak ten używamy też wlookahead assertions , wyjaśnione w komórkach x(?=y) i x(?!y) w tej tabeli.
.(kropka) pasuje do każdego pojedynczego znaku oprócz znaku nowej linii. Np. /.n/ z łańcucha "nay, an apple is on the tree", dopasuje 'an' i 'on', ale nie 'nay'.
(x)Matches 'x' and remembers the match. These are called capturing parentheses. For example, /(foo)/ matches and remembers 'foo' in "foo bar." The matched substring can be recalled from the resulting array's elements 1, ..., n.
(?:x)Matches 'x' but does not remember the match. These are called non-capturing parentheses. The matched substring can not be recalled from the resulting array's elements 1, ..., n.
x(?=y)Matches 'x' only if 'x' is followed by 'y'. For example, /Jack(?=Sprat)/ matches 'Jack' only if it is followed by 'Sprat'. /Jack(?=Sprat|Frost)/ matches 'Jack' only if it is followed by 'Sprat' or 'Frost'. However, neither 'Sprat' nor 'Frost' is part of the match results.
x(?!y)Matches 'x' only if 'x' is not followed by 'y'. For example, /\d+(?!\.)/ matches a number only if it is not followed by a decimal point. The regular expression /\d+(?!\.)/.exec("3.141") matches '141' but not '3.141'.
x|yoznacza 'x' lub 'y'. Na przykład /green|red/ pasuje do 'green' w "green apple" i do 'red' w "red apple."
{n}gdzie n jest liczbą całkowitą dodatnią. Oznacza dokładnie n wystąpień znaku poprzedzającego. Na przykład /a{2}/ nie pasuje do 'a' w "candy,", za to pasuje do wszystkich znaków 'a' w "caandy," i pierwszych dwóch znaków 'a' w "caaandy."
{n,}Where n is a positive integer. Matches at least n occurrences of the preceding character. For example, /a{2,}/ doesn't match the 'a' in "candy", but matches all of the a's in "caandy" and in "caaaaaaandy."
{n,m}Where n and m are positive integers. Matches at least n and at most m occurrences of the preceding character. For example, /a{1,3}/ matches nothing in "cndy", the 'a' in "candy," the first two a's in "caandy," and the first three a's in "caaaaaaandy" Notice that when matching "caaaaaaandy", the match is "aaa", even though the original string had more a's in it.
xyzzestaw znaków. Pasuje do każdego znaku w nawiasie. Można określić zakres znaków za pomocą łącznika. Na przykład abcd oznacza to samo co a-d. Pasują one do 'b' w "brisket" i do 'c' w "ache".
^xyzA negated or complemented character set. That is, it matches anything that is not enclosed in the brackets. You can specify a range of characters by using a hyphen. For example, ^abc is the same as ^a-c. They initially match 'r' in "brisket" and 'h' in "chop."
\\bMatches a backspace. (Not to be confused with \b.)
\bMatches a word boundary, such as a space or a newline character. (Not to be confused with \\b.) For example, /\bn\w/ matches the 'no' in "noonday";/\wy\b/ matches the 'ly' in "possibly yesterday."
\BMatches a non-word boundary. For example, /\w\Bn/ matches 'on' in "noonday", and /y\B\w/ matches 'ye' in "possibly yesterday."
\cXWhere X is a control character. Matches a control character in a string. For example, /\cM/ matches control-M in a string.
\dMatches a digit character. Equivalent to 0-9. For example, /\d/ or /0-9/ matches '2' in "B2 is the suite number."
\DMatches any non-digit character. Equivalent to ^0-9. For example, /\D/ or /^0-9/ matches 'B' in "B2 is the suite number."
\fMatches a form-feed.
\nMatches a linefeed.
\rMatches a carriage return.
\sMatches a single white space character, including space, tab, form feed, line feed. Equivalent to +

\\f\\n\\r\\t\\v\\u00A0\\u2028\\u2029.

+ For example, /\s\w*/ matches ' bar' in "foo bar."
\SMatches a single character other than white space. Equivalent to +

^ \\f\\n\\r\\t\\v\\u00A0\\u2028\\u2029.

+ For example, /\S\w*/ matches 'foo' in "foo bar."
\tMatches a tab.
\vMatches a vertical tab.
\wMatches any alphanumeric character including the underscore. Equivalent to A-Za-z0-9_. For example, /\w/ matches 'a' in "apple," '5' in "$5.28," and '3' in "3D."
\WMatches any non-word character. Equivalent to ^A-Za-z0-9_. For example, /\W/ or /^A-Za-z0-9_/ matches '%' in "50%."
\nWhere n is a positive integer. A back reference to the last substring matching the n parenthetical in the regular expression (counting left parentheses). For example, /apple(,)\sorange\1/ matches 'apple, orange,' in "apple, orange, cherry, peach."
\0Matches a NUL character. Do not follow this with another digit.
\xhhMatches the character with the code hh (two hexadecimal digits)
\uhhhhMatches the character with the code hhhh (four hexadecimal digits).
+ +

Tabela 4.1: Znaki specjalne w wyrażeniach regularnych.

+ +

Używanie nawiasów

+ +

Parentheses around any part of the regular expression pattern cause that part of the matched substring to be remembered. Once remembered, the substring can be recalled for other use, as described in Using Parenthesized Substring Matches.

+ +

For example, the pattern /Chapter (\d+)\.\d*/ illustrates additional escaped and special characters and indicates that part of the pattern should be remembered. It matches precisely the characters 'Chapter ' followed by one or more numeric characters (\d means any numeric character and + means 1 or more times), followed by a decimal point (which in itself is a special character; preceding the decimal point with \ means the pattern must look for the literal character '.'), followed by any numeric character 0 or more times (\d means numeric character, * means 0 or more times). In addition, parentheses are used to remember the first matched numeric characters.

+ +

This pattern is found in "Open Chapter 4.3, paragraph 6" and '4' is remembered. The pattern is not found in "Chapter 3 and 4", because that string does not have a period after the '3'.

+ +

To match a substring without causing the matched part to be remembered, within the parentheses preface the pattern with ?:. For example, (?:\d+) matches one or more numeric characters but does not remember the matched characters.

+ +


+ {{ PreviousNext("Przewodnik_po_języku_JavaScript_1.5:Tworzenie_wyrażenia_regularnego", "Przewodnik_po_języku_JavaScript_1.5:Praca_z_wyrażeniami_regularnymi") }}

diff --git "a/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/zastosowanie_obiektu_arguments/index.html" "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/zastosowanie_obiektu_arguments/index.html" new file mode 100644 index 0000000000..8422fdf2c0 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/guide/obsolete_pages/przewodnik_po_j\304\231zyku_javascript_1.5/zastosowanie_obiektu_arguments/index.html" @@ -0,0 +1,41 @@ +--- +title: Zastosowanie obiektu arguments +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Zastosowanie_obiektu_arguments +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +--- +

 

+

Zastosowanie obiektu arguments

+

Argumenty funkcji będą je utrzymywać je w tablicy. Wewnątrz funkcji, możemy zaadresować lub przydzielić argumenty w następujący sposób:

+
arguments[i]
+
+

gdzie: i jest kolejną liczbą porządkową znajdującą się wewnątrz funkcji, pierwszym argumentem zawsze jest 0 (zero). Więc, pierwszy argument funkcji to arguments{{ mediawiki.external(0) }}. Łączna liczba argumentów jest podana w arguments.length.

+

Używając argumentów tablicy (arguments) możesz nazwać większość funkcji wraz ze swoimi argumentami niż formalna deklaracja akceptującą. Często jeśli nie wiesz jak wiele będzie potrzebnych argumentów funkcji. Używaj arguments.length do określenie aktualnie argumentów do funkcji, potrzebnych do opisania każdego argumentu w tablicy arguments.

+

Na przykład, stanowią one funkcje, które powiążą kilka łańcuchów danych. Tylko oficjalny argument dla funkcji jest łańcuch, którego specyficzne znaki separacji powiążą odpowiednie elementy. Funkcja jest definiowana następująco:

+
function myConcat(separator) {
+   var result="" // initialize list
+   // iterate through arguments
+   for (var i=1; i<arguments.length; i++) {
+      result += arguments[i] + separator
+   }
+   return result
+}
+
+

Możemy podawać jakiekolwiek liczby argumentów funkcji, i to zostanie utworzona lista używająca każdej pozycji zawartej na liście.

+
// zwraca "red, orange, blue, "
+myConcat(", ","red","orange","blue")
+
+// zwraca "elephant; giraffe; lion; cheetah; "
+myConcat("; ","elephant","giraffe","lion", "cheetah")
+
+// zwraca "sage. basil. oregano. pepper. parsley. "
+myConcat(". ","sage","basil","oregano", "pepper", "parsley")
+
+

Zobacz: Funkcja obiektu w dokumentacji języka JavaScript, aby uzyskać więcej informacji.

+

JavaScript 1.3 i wersje wcześniejsze
+ Argument tablicy jest właściwością obiektu Function i może on być umieszczony przed nazwą funkcji, tak jak poniżej:

+

functionName.arguments(i)

+

 

diff --git "a/files/pl/orphaned/web/javascript/na_pocz\304\205tek/index.html" "b/files/pl/orphaned/web/javascript/na_pocz\304\205tek/index.html" new file mode 100644 index 0000000000..44f95f6c62 --- /dev/null +++ "b/files/pl/orphaned/web/javascript/na_pocz\304\205tek/index.html" @@ -0,0 +1,903 @@ +--- +title: Na początek +slug: Web/JavaScript/Na_początek +tags: + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +--- +
UWAGA, UWAGA!: Pomimo tego, że artykuł jest wywieszony jako artykuł do dopracowania, to mimo to, PROSZĘ go na razie NIE TŁUMACZYĆ. Powodem jest to, że tekst w sporej mierze jest już przetłumaczony. Więc po prostu szkoda zapału i zużywania energii na coś co już jest w wersji PL. W ramach tego samego czasu możecie przetłumaczyć coś, czego nie ma na 100% w dopracowanych. Ptak82 17:18, 13 mar 2007 (PDT)
+ +

Wprowadzenie

+ +

Dlaczego ponowne wprowadzenie? Bo JavaScript można śmiało określić jako najbardziej błędnie rozumiany język programowania (en). Często wyszydzany, nazywany zabawką, pod swoją kuszącą prostotą chowa on szerokie możliwości. W roku 2005 pojawił się szereg wysokiej jakości aplikacji w JavaScripcie, dowodzących, że pogłębiona znajomość tej technologii to to, czym powinien móc się pochwalić każdy twórca serwisów internetowych.

+ +

Wygodnie będzie zacząć od kilku słów na temat historii języka. JavaScript stowrzył w roku 1995 Brendan Eich, programista firmy Netscape. Pierwszą przeglądarką z obsługą JavaScriptu była Netscape 2, wydana na początku 1996 r. Pierwotnie język ten miał się nazywać LiveScript, ale nazwę nieszczęśliwie zmieniono z przyczyn marketingowych - chciano skorzystać z popularności Javy, języka firmy Sun Microsystems, mimo że oba te języki niewiele ze sobą łączy. Nazwa "JavaScript" do dziś jest przyczyną wielu nieporozumień.

+ +

Microsoft wydał prawie kompatybilną wersję tego języka pod nazwą JScript razem z przeglądarką Internet Explorer 3 kilka miesięcy później. Firma Netscape zgłosiła język do europejskiej organizacji standaryzacyjnej Ecma International, skutkiem czego było pierwsze wydanie standardu ECMAScript w roku 1997. Specyfikację tę szeroko uzupełniono i rozbudowano w roku 1999 i opublikowano jako ECMAScript wydanie 3 i od tej pory język ten był w miarę stabilny, nie przechodził większych rewolucji, choć obecnie trwają prace nad wydaniem czwartym.

+ +

Stabilność ta to dobra wiadomość dla programistów, jako że wszystkie implementacje miały wiele czasu, by w pełni dojść do w miarę zgodnego stanu. W tym artykule skupiam się wyłącznie na dialekcie z wydania trzeciego. Dla uproszczenia pozostanę w tym artykule przy terminie "JavaScript".

+ +

W przeciwieństwie do większości języków, JavaScript nie posiada koncepcji wejścia/wyjścia. Zaprojektowany został jako język skryptowy dla maszyny wirtualnej i to ta maszyna wirtualna ma za zadanie zapewnić mechanizmy komunikacji ze światem zewnętrznym. Najbardziej popularną maszyną wirtualną jest przeglądarka, ale interpretery JavaScriptu można znaleźć np. w programach Adobe Acrobat, Photoshop, silniku Yahoo! Widget i innych.

+ +

Przegląd

+ +

Zacznijmy od fundamentów każdego języka programowania: typów danych. Programy w JavaScripcie manipulują wartościami, z których każda należy do konkretnego typu. Typy w JavaScripcie to:

+ + + +

a także Undefined (wartość niezdefiniowana) i Null, które można uważać za nieco dziwne. Ponadto mamy do dyspozycji tablice - Array - które są szczególnym rodzajem obiektu. Oprócz tego daty - Date i wyrażenia regularne, które także są obiektami. Gwoli ścisłości, funkcje także są szczególnymi obiektami.

+ +

Diagram typów wygląda zatem następująco:

+ + + +

Istnieją także podtypy typu Error, ale pomińmy je, żeby za bardzo nie mieszać i pozostańmy przy pierwszym diagramie.

+ +

Liczby

+ +

Zgodnie ze specyfikacją, liczby w JavaScripcie są "64-bitowymi wartościami podwójnej precyzji w formacie IEEE 754". Ma to ciekawe skutki. Na przykład, w JavaScripcie nie ma czegoś takiego jak liczba całkowita, dlatego trzeba zachować nieco ostrożności przy operacjach arytmetycznych, zwłaszcza jeśli przyzwyczajeni jesteśmy do C lub Javy. Należy uważać na takie sytuacje:

+ +
0.1 + 0.2 = 0.30000000000000004
+
+ +

Dostępne są standardowe operatory arytmetyczne, w tym oczywiście dodawanie, odejmowanie, modulo (reszta z dzielenia) itd. Jest także specjalny obiekt Math pozwalający na stosowanie bardziej zaawansowanych funkcji i stałych matematycznych:

+ +
Math.sin(3.5);
+d = Math.PI * r * r;
+
+ +

Ciąg znaków można skonwertować do liczby korzystając z wbudowanej funkcji parseInt(). Funkcja ta może posiadać dodatkowy, drugi argument, który określa podstawę systemu dla tej konwersji. Ten argument warto jednak zawsze podawać:

+ +
> parseInt("123", 10)
+123
+> parseInt("010", 10)
+10
+
+ +

...żeby nie dostać nieoczekiwanych wyników:

+ +
> parseInt("010")
+8
+
+ +

Taki wynik otrzymaliśmy dlatego, że funkcja parseInt uznała liczbę w naszym ciągu znaków za ósemkową, bo rozpoczęliśmy ją od znaku "0".

+ +

Jeśli chcesz skonwertować liczbę binarną do dziesiętnej, wystarczy zmienić podstawę:

+ +
> parseInt("11", 2)
+3
+
+ +

Funkcja zwraca specjalną wartość NaN (skrót ang. "Not a Number" - "To nie jest liczba"), jeśli dany ciąg znaków nie jest liczbą:

+ +
> parseInt("witaj", 10)
+NaN
+
+ +

NaN jest toksyczna: wprowadzenie jej do jakiejkolwiek operacji matematycznej spowoduje, że jej wynikiem również będzie NaN:

+ +
> NaN + 5
+NaN
+
+ +

Aby sprawdzić, czy dana wartość jest NaN, można użyć wbudowanej funkcji isNaN():

+ +
> isNaN(NaN)
+true
+
+ +

(NaN nie jest bowiem równe nawet samo sobie, NaN!=NaN - przyp. tłum.)

+ +

W JavaScripcie istnieją także specjalne wartości reprezentujące plus i minus nieskończoność: Infinity and -Infinity:

+ +
> 1 / 0
+Infinity
+> -1 / 0
+-Infinity
+
+ +

Ciągi znaków

+ +

Teksty w JavaScripcie to sekwencje znaków. Dokładniej rzecz biorąc, są to sekwencje znaków Unicode, w których każdy znak reprezentowany jest przez liczbę 16-bitową. To dobra wiadomość dla wszystkich osób zajmujących się internacjonalizacją.

+ +

Jeśli zajdzie potrzeba reprezentowania pojedynczego znaku, stosuje się po prostu ciąg o długości równej 1.

+ +

Aby odnaleźć długość ciągu, należy skorzystać z jego własności length:

+ +
> "witaj".length
+5
+
+ +

To nasze pierwsze spotkanie z obiektami JavaScriptu! Czy wspomniałem, że ciągi są też obiektami? Naturalnie, mają też metody:

+ +
> "witaj".charAt(0)
+w
+> "witaj, świecie".replace("witaj", "do zobaczenia")
+do zobaczenia, świecie
+> "witaj".toUpperCase()
+WITAJ
+
+ +

Other types

+ +

JavaScript distinguishes between null, which is an object of type 'object' that indicates a deliberate non-value, and undefined, which is an object of type 'undefined' that indicates an uninitialized value — that is, a value hasn't even been assigned yet. We'll talk about variables later, but in JavaScript it is possible to declare a variable without assigning a value to it. If you do this, the variable's type is undefined.

+ +

JavaScript has a boolean type, with possible values true and false (both of which are keywords). Any value can be converted to a boolean according to the following rules:

+ +
    +
  1. false, 0, the empty string (""), NaN, null, and undefined all become false
    2. +
  2. all other values become true
    3. +
+ +

You can perform this conversion explicitly using the Boolean() function:

+ +
> Boolean("")
+false
+> Boolean(234)
+true
+
+ +

However, this is rarely necessary, as JavaScript will silently perform this conversion when it expects a boolean, such as in an if statement (see below). For this reason, we sometimes speak simply of "true values" and "false values," meaning values that become true and false, respectively, when converted to booleans. Alternatively, such values can be called "truthy" and "falsy," respectively.

+ +

Boolean operations such as && (logicaland), || (logicalor), and ! (logicalnot) are supported; see below.

+ +

Variables

+ +

New variables in JavaScript are declared using the var keyword:

+ +
var a;
+var name = "simon";
+
+ +

If you declare a variable without assigning any value to it, its type is undefined. should note the absence of block-scoping in JS

+ +

Operators

+ +

JavaScript's numeric operators are +, -, *, / and % - which is the remainder operator. Values are assigned using =, and there are also compound assignment statements such as += and -=. These extend out to x = xoperator y.

+ +
x += 5
+x = x + 5
+
+ +

You can use ++ and -- to increment and decrement respectively. These can be used as prefix or postfix operators.

+ +

The + operator also does string concatenation:

+ +
> "hello" + " world"
+hello world
+
+ +

If you add a string to a number (or other value) everything is converted in to a string first. This might catch you out:

+ +
> "3" + 4 + 5
+345
+> 3 + 4 + "5"
+75
+
+ +

Adding an empty string to something is a useful way of converting it.

+ +

Comparisons in JavaScript can be made using <, >, <= and >=. These work for both strings and numbers. Equality is a little less straightforward. The double-equals operator performs type coercion if you give it different types, with sometimes interesting results:

+ +
> "dog" == "dog"
+true
+> 1 == true
+true
+
+ +

To avoid type coercion, use the triple-equals operator:

+ +
> 1 === true
+false
+> true === true
+true
+
+ +

There are also != and !== operators.

+ +

JavaScript also has bitwise operations. If you want to use them, they're there.

+ +

Control structures

+ +

JavaScript has a similar set of control structures to other languages in the C family. Conditional statements are supported by if and else; you can chain them together if you like:

+ +
var name = "kittens";
+if (name == "puppies") {
+  name += "!";
+} else if (name == "kittens") {
+  name += "!!";
+} else {
+  name = "!" + name;
+}
+name == "kittens!!"
+
+ +

JavaScript has while loops and do-while loops. The first is good for basic looping; the second for loops where you wish to ensure that the body of the loop is executed at least once:

+ +
while (true) {
+  // an infinite loop!
+}
+
+do {
+  var input = get_input();
+} while (inputIsNotValid(input))
+
+ +

JavaScript's for loop is the same as that in C and Java: it lets you provide the control information for your loop on a single line.

+ +
for (var i = 0; i < 5; i++) {
+  // Will execute 5 times
+}
+
+ +

The && and || operators use short-circuit logic, which means whether they will execute their second operand is dependent on the first. This is useful for checking for null objects before accessing their attributes:

+ +
var name = o && o.getName();
+
+ +

Or for setting default values:

+ +
var name = otherName || "default";
+
+ +

JavaScript has a tertiary operator for one-line conditional statements:

+ +
var allowed = (age > 18) ? "yes" : "no";
+
+ +

The switch statement can be used for multiple branches based on a number or string:

+ +
switch(action) {
+    case 'draw':
+        drawit();
+        break;
+    case 'eat':
+        eatit();
+        break;
+    default:
+        donothing();
+}
+
+ +

If you don't add a break statement, execution will "fall through" to the next level. This is very rarely what you want - in fact it's worth specifically labelling deliberate fallthrough with a comment if you really meant it to aid debugging:

+ +
switch(a) {
+    case 1: // fallthrough
+    case 2:
+        eatit();
+        break;
+    default:
+        donothing();
+}
+
+ +

The default clause is optional. You can have expressions in both the switch part and the cases if you like; comparisons take place between the two using the === operator:

+ +
switch(1 + 3):
+    case 2 + 2:
+        yay();
+        break;
+    default:
+        neverhappens();
+}
+
+ +

Objects

+ +

JavaScript objects are simply collections of name-value pairs. As such, they are similar to:

+ + + +

The fact that this data structure is so widely used is a testament to its versatility. Since everything (bar core types) in JavaScript is an object, any JavaScript program naturally involves a great deal of hash table lookups. It's a good thing they're so fast!

+ +

The "name" part is a JavaScript string, while the value can be any JavaScript value - including more objects. This allows you to build data structures of arbitrary complexity.

+ +

There are two basic ways to create an empty object:

+ +
var obj = new Object();
+
+ +

And:

+ +
var obj = {};
+
+ +

These are semantically equivalent; the second is called object literal syntax, and is more convenient. Object literal syntax was not present in very early versions of the language which is why you see so much code using the old method.

+ +

Once created, an object's properties can again be accessed in one of two ways:

+ +
obj.name = "Simon"
+var name = obj.name;
+
+ +

And...

+ +
obj["name"] = "Simon";
+var name = obj["name"];
+
+ +

These are also semantically equivalent. The second method has the advantage that the name of the property is provided as a string, which means it can be calculated at run-time. It can also be used to set and get properties with names that are reserved words:

+ +
obj.for = "Simon"; // Syntax error, because 'for' is a reserved word
+obj["for"] = "Simon"; // works fine
+
+ +

Object literal syntax can be used to initialise an object in its entirety:

+ +
var obj = {
+    name: "Carrot",
+    "for": "Max",
+    details: {
+        color: "orange",
+        size: 12
+    }
+}
+
+ +

Attribute access can be chained together:

+ +
> obj.details.color
+orange
+> obj["details"]["size"]
+12
+
+ +

Arrays

+ +

Arrays in JavaScript are actually a special type of object. They work very much like regular objects (numerical properties can naturally be accessed only using [] syntax) but they have one magic property called 'length'. This is always one more than the highest index in the array.

+ +

The old way of creating arrays is as follows:

+ +
> var a = new Array();
+> a[0] = "dog";
+> a[1] = "cat";
+> a[2] = "hen";
+> a.length
+3
+
+ +

A more convenient notation is to use an array literal:

+ +
> var a = ["dog", "cat", "hen"];
+> a.length
+3
+
+ +

Leaving a trailing comma at the end of an array literal is inconsistent across browsers, so don't do it.

+ +

Note that array.length isn't necessarily the number of items in the array. Consider the following:

+ +
> var a = ["dog", "cat", "hen"];
+> a[100] = "fox";
+> a.length
+101
+
+ +

Remember - the length of the array is one more than the highest index.

+ +

If you query a non-existent array index, you get undefined:

+ +
> typeof(a[90])
+undefined
+
+ +

If you take the above into account, you can iterate over an array using the following:

+ +
for (var i = 0; i < a.length; i++) {
+    // Do something with a[i]
+}
+
+ +

This is slightly inefficient as you are looking up the length property once every loop. An improvement is this:

+ +
for (var i = 0, len = a.length; i < len; i++) {
+    // Do something with a[i]
+}
+
+ +

An even nicer idiom is:

+ +
for (var i = 0, item; item = a[i]; i++) {
+    // Do something with item
+}
+
+ +

Here we are setting up two variables. The assignment in the middle part of the for loop is also tested for truthfulness - if it succeeds, the loop continues. Since i is incremented each time, items from the array will be assigned to item in sequential order. The loop stops when a "falsy" item is found (such as undefined).

+ +

Note that this trick should only be used for arrays which you know do not contain "falsy" values (arrays of objects or DOM nodes for example). If you are iterating over numeric data that might include a 0 or string data that might include the empty string you should use the i, j idiom instead.

+ +

Another way to iterate is to use the for...in loop. Note that if someone added new properties to Array.prototype, they will also be iterated over by this loop:

+ +
for (var i in a) {
+  // Do something with a[i]
+}
+
+ +

If you want to append an item to an array, the safest way to do it is like this:

+ +
a[a.length] = item;                 // same as a.push(item);
+
+ +

Since a.length is one more than the highest index, you can be assured that you are assigning to an empty position at the end of the array.

+ +

Arrays come with a number of methods:

+ +
a.toString(), a.toLocaleString(), a.concat(item, ..), a.join(sep),
+a.pop(), a.push(item, ..), a.reverse(), a.shift(), a.slice(start, end),
+a.sort(cmpfn), a.splice(start, delcount, [item]..), a.unshift([item]..)
+
+ + + +

Functions

+ +

Along with objects, functions are the core component in understanding JavaScript. The most basic function couldn't be much simpler:

+ +
function add(x, y) {
+    var total = x + y;
+    return total;
+}
+
+ +

This demonstrates everything there is to know about basic functions. A JavaScript function can take 0 or more named parameters. The function body can contain as many statements as you like, and can declare its own variables which are local to that function. The return statement can be used to return a value at any time, terminating the function. If no return statement is used (or an empty return with no value), JavaScript returns undefined.

+ +

The named parameters turn out to be more like guidelines than anything else. You can call a function without passing the parameters it expects, in which case they will be set to undefined.

+ +
> add()
+NaN // You can't perform addition on undefined
+
+ +

You can also pass in more arguments than the function is expecting:

+ +
> add(2, 3, 4)
+5 // added the first two; 4 was ignored
+
+ +

That may seem a little silly, but functions have access to an additional variable inside their body called arguments, which is an array-like object holding all of the values passed to the function. Let's re-write the add function to take as many values as we want:

+ +
function add() {
+    var sum = 0;
+    for (var i = 0, j = arguments.length; i < j; i++) {
+        sum += arguments[i];
+    }
+    return sum;
+}
+
+> add(2, 3, 4, 5)
+14
+
+ +

That's really not any more useful than writing 2 + 3 + 4 + 5 though. Let's create an averaging function:

+ +
function avg() {
+    var sum = 0;
+    for (var i = 0, j = arguments.length; i < j; i++) {
+        sum += arguments[i];
+    }
+    return sum / arguments.length;
+}
+> avg(2, 3, 4, 5)
+3.5
+
+ +

This is pretty useful, but introduces a new problem. The avg() function takes a comma separated list of arguments - but what if you want to find the average of an array? You could just rewrite the function as follows:

+ +
function avgArray(arr) {
+    var sum = 0;
+    for (var i = 0, j = arr.length; i < j; i++) {
+        sum += arr[i];
+    }
+    return sum / arr.length;
+}
+> avgArray([2, 3, 4, 5])
+3.5
+
+ +

But it would be nice to be able to reuse the function that we've already created. Luckily, JavaScript lets you call a function and call it with an arbitrary array of arguments, using the apply() method of any function object.

+ +
> avg.apply(null, [2, 3, 4, 5])
+3.5
+
+ +

The second argument to apply() is the array to use as arguments; the first will be discussed later on. This emphasizes the fact that functions are objects too.

+ +

JavaScript lets you create anonymous functions.

+ +
var avg = function() {
+    var sum = 0;
+    for (var i = 0, j = arguments.length; i < j; i++) {
+        sum += arguments[i];
+    }
+    return sum / arguments.length;
+}
+
+ +

This is semantically equivalent to the function avg() form. It's extremely powerful, as it lets you put a full function definition anywhere that you would normally put an expression. This enables all sorts of clever tricks. Here's a way of "hiding" some local variables - like block scope in C:

+ +
> var a = 1;
+> var b = 2;
+> (function() {
+    var b = 3;
+    a += b;
+})();
+> a
+4
+> b
+2
+
+ +

JavaScript allows you to call functions recursively. This is particularly useful for dealing with tree structures, such as you get in the browser DOM.

+ +
function countChars(elm) {
+    if (elm.nodeType == 3) { // TEXT_NODE
+        return elm.nodeValue.length;
+    }
+    var count = 0;
+    for (var i = 0, child; child = elm.childNodes[i]; i++) {
+        count += countChars(child);
+    }
+    return count;
+}
+
+ +

This highlights a potential problem with anonymous functions: how do you call them recursively if they don't have a name? The answer lies with the arguments object, which in addition to acting as a list of arguments also provides a property called arguments.callee. This always refers to the current function, and hence can be used to make recursive calls:

+ +
var charsInBody = (function(elm) {
+    if (elm.nodeType == 3) { // TEXT_NODE
+        return elm.nodeValue.length;
+    }
+    var count = 0;
+    for (var i = 0, child; child = elm.childNodes[i]; i++) {
+        count += arguments.callee(child);
+    }
+    return count;
+})(document.body);
+
+ +

Since arguments.callee is the current function, and all functions are objects, you can use arguments.callee to save information across multiple calls to the same function. Here's a function that remembers how many times it has been called:

+ +
function counter() {
+    if (!arguments.callee.count) {
+        arguments.callee.count = 0;
+    }
+    return arguments.callee.count++;
+}
+
+> counter()
+0
+> counter()
+1
+> counter()
+2
+
+ +

Custom objects

+ +

In classic Object Oriented Programming, objects are collections of data and methods that operate on that data. Let's consider a person object with first and last name fields. There are two ways in which their name might be displayed: as "first last" or as "last, first". Using the functions and objects that we've discussed previously, here's one way of doing it:

+ +
function makePerson(first, last) {
+    return {
+        first: first,
+        last: last
+    }
+}
+function personFullName(person) {
+    return person.first + ' ' + person.last;
+}
+function personFullNameReversed(person) {
+    return person.last + ', ' + person.first
+}
+> s = makePerson("Simon", "Willison");
+> personFullName(s)
+Simon Willison
+> personFullNameReversed(s)
+Willison, Simon
+
+ +

This works, but it's pretty ugly. You end up with dozens of functions in your global namespace. What we really need is a way to attach a function to an object. Since functions are objects, this is easy:

+ +
function makePerson(first, last) {
+    return {
+        first: first,
+        last: last,
+        fullName: function() {
+            return this.first + ' ' + this.last;
+        },
+        fullNameReversed: function() {
+            return this.last + ', ' + this.first;
+        }
+    }
+}
+> s = makePerson("Simon", "Willison")
+> s.fullName()
+Simon Willison
+> s.fullNameReversed()
+Willison, Simon
+
+ +

There's something here we haven't seen before: the 'this' keyword. Used inside a function, 'this' refers to the current object. What that actually means is specified by the way in which you called that function. If you called it using dot notation or bracket notation on an object, that object becomes 'this'. If dot notation wasn't used for the call, 'this' refers to the global object. This is a frequent cause of mistakes. For example:

+ +
> s = makePerson("Simon", "Willison")
+> var fullName = s.fullName;
+> fullName()
+undefined undefined
+
+ +

When we call fullName(), 'this' is bound to the global object. Since there are no global variables called first or last we get undefined for each one.

+ +

We can take advantage of the 'this' keyword to improve our makePerson function:

+ +
function Person(first, last) {
+    this.first = first;
+    this.last = last;
+    this.fullName = function() {
+        return this.first + ' ' + this.last;
+    }
+    this.fullNameReversed = function() {
+        return this.last + ', ' + this.first;
+    }
+}
+var s = new Person("Simon", "Willison");
+
+ +

We've introduced another keyword: 'new'. new is strongly related to 'this'. What it does is it creates a brand new empty object, and then calls the function specified, with 'this' set to that new object. Functions that are designed to be called by 'new' are called constructor functions. Common practise is to capitalise these functions as a reminder to call them with new.

+ +

Our person objects are getting better, but there are still some ugly edges to them. Every time we create a person object we are creating two brand new function objects within it - wouldn't it be better if this code was shared?

+ +
function personFullName() {
+    return this.first + ' ' + this.last;
+}
+function personFullNameReversed() {
+    return this.last + ', ' + this.first;
+}
+function Person(first, last) {
+    this.first = first;
+    this.last = last;
+    this.fullName = personFullName;
+    this.fullNameReversed = personFullNameReversed;
+}
+
+ +

That's better: we are creating the method functions only once, and assigning references to them inside the constructor. Can we do any better than that? The answer is yes:

+ +
function Person(first, last) {
+    this.first = first;
+    this.last = last;
+}
+Person.prototype.fullName = function() {
+    return this.first + ' ' + this.last;
+}
+Person.prototype.fullNameReversed = function() {
+    return this.last + ', ' + this.first;
+}
+
+ +

Person.prototype is an object shared by all instances of Person. It forms part of a lookup chain (that has a special name, "prototype chain"): any time you attempt to access a property of Person that isn't set, JavaScript will check Person.prototype to see if that property exists there instead. As a result, anything assigned to Person.prototype becomes available to all instances of that constructor via the this object.

+ +

This is an incredibly powerful tool. JavaScript lets you modify something's prototype at any time in your program, which means you can add extra methods to existing objects at runtime:

+ +
> s = new Person("Simon", "Willison");
+> s.firstNameCaps();
+TypeError on line 1: s.firstNameCaps is not a function
+> Person.prototype.firstNameCaps = function() {
+    return this.first.toUpperCase()
+}
+> s.firstNameCaps()
+SIMON
+
+ +

Interestingly, you can also add things to the prototype of built-in JavaScript objects. Let's add a method to String that returns that string in reverse:

+ +
> var s = "Simon";
+> s.reversed()
+TypeError on line 1: s.reversed is not a function
+> String.prototype.reversed = function() {
+    var r = "";
+    for (var i = this.length - 1; i >= 0; i--) {
+        r += this[i];
+    }
+    return r;
+}
+> s.reversed()
+nomiS
+
+ +

Our new method even works on string literals!

+ +
> "This can now be reversed".reversed()
+desrever eb won nac sihT
+
+ +

As I mentioned before, the prototype forms part of a chain. The root of that chain is Object.prototype, whose methods include toString() - it is this method that is called when you try to represent an object as a string. This is useful for debugging our Person objects:

+ +
> var s = new Person("Simon", "Willison");
+> s
+[object Object]
+> Person.prototype.toString = function() {
+    return '<Person: ' + this.fullName() + '>';
+}
+> s
+<Person: Simon Willison>
+
+ +

Remember how avg.apply() had a null first argument? We can revisit that now. The first argument to apply() is the object that should be treated as 'this'. For example, here's a trivial implementation of 'new':

+ +
function trivialNew(constructor) {
+    var o = {}; // Create an object
+    constructor.apply(o, arguments);
+    return o;
+}
+
+ +

This isn't an exact replica of new as it doesn't set up the prototype chain. apply() is difficult to illustrate - it's not something you use very often, but it's useful to know about.

+ +

apply() has a sister function named call, which again lets you set 'this' but takes an expanded argument list as opposed to an array.

+ +
function lastNameCaps() {
+    return this.last.toUpperCase();
+}
+var s = new Person("Simon", "Willison");
+lastNameCaps.call(s);
+// Is the same as:
+s.lastNameCaps = lastNameCaps;
+s.lastNameCaps();
+
+ +

Inner functions

+ +

JavaScript function declarations are allowed inside other functions. We've seen this once before, with an earlier makePerson() function. An important detail of nested functions in JavaScript is that they can access variables in their parent function's scope:

+ +
function betterExampleNeeded() {
+    var a = 1;
+    function oneMoreThanA() {
+        return a + 1;
+    }
+    return oneMoreThanA();
+}
+
+ +

This provides a great deal of utility in writing more maintainable code. If a function relies on one or two other functions that are not useful to any other part of your code, you can nest those utility functions inside the function that will be called from elsewhere. This keeps the number of functions that are in the global scope down, which is always a good thing.

+ +

This is also a great counter to the lure of global variables. When writing complex code it is often tempting to use global variables to share values between multiple functions - which leads to code that is hard to maintain. Nested functions can share variables in their parent, so you can use that mechanism to couple functions together when it makes sense without polluting your global namespace - 'local globals' if you like. This technique should be used with caution, but it's a useful ability to have.

+ +

Closures

+ +

This leads us to one of the most powerful abstractions that JavaScript has to offer - but also the most potentially confusing. What does this do?

+ +
function makeAdder(a) {
+    return function(b) {
+        return a + b;
+    }
+}
+x = makeAdder(5);
+y = makeAdder(20);
+x(6)
+?
+y(7)
+?
+
+ +

The name of the makeAdder function should give it away: it creates new 'adder' functions, which when called with one argument add it to the argument that they were created with.

+ +

What's happening here is pretty much the same as was happening with the inner functions earlier on: a function defined inside another function has access to the outer function's variables. The only difference here is that the outer function has returned, and hence common sense would seem to dictate that its local variables no longer exist. But theydo still exist - otherwise the adder functions would be unable to work. What's more, there are two different "copies" of makeAdder's local variables - one in which a is 5 and one in which a is 20.

+ +

Here's what's actually happening. Whenever JavaScript executes a function, a 'scope' object is created to hold the local variables created within that function. It is initialised with any variables passed in as function parameters. This is similar to the global object that all global variables and functions live in, but with a couple of important differences: firstly, a brand new scope object is created every time a function starts executing, and secondly, unlike the global object (which in browsers is accessible as window) these scope objects cannot be directly accessed from your JavaScript code. There is no mechanism for iterating over the properties of the current scope object for example.

+ +

So when makeAdder is called, a scope object is created with one property: a, which is the argument passed to the makeAdder function. makeAdder then returns a newly created function. Normally JavaScript's garbage collector would clean up the scope object created for makeAdder at this point, but the returned function maintains a reference back to that scope object. As a result, the scope object will not be garbage collected until there are no more references to the function object that makeAdder returned.

+ +

Scope objects form a chain called the scope chain, similar to the prototype chain used by JavaScript's object system.

+ +

A closure is the combination of a function and the scope object in which it was created.

+ +

Closures let you save state - as such, they can often be used in place of objects.

+ +

Memory leaks

+ +

An unfortunate side effect of closures is that they make it trivially easy to leak memory in Internet Explorer. JavaScript is a garbage collected language - objects are allocated memory upon their creation and that memory is reclaimed by the browser when no references to an object remain. Objects provided by the host environment are handled by that environment.

+ +

Browser hosts need to manage a large number of objects representing the HTML page being presented - the objects of the DOM. It is up to the browser to manage the allocation and recovery of these.

+ +

Internet Explorer uses its own garbage collection scheme for this, separate from the mechanism used by JavaScript. It is the interaction between the two that can cause memory leaks.

+ +

A memory leak in IE occurs any time a circular reference is formed between a JavaScript object and a native object. Consider the following:

+ +
function leakMemory() {
+    var el = document.getElementById('el');
+    var o = { 'el': el };
+    el.o = o;
+}
+
+ +

The circular reference formed above creates a memory leak; IE will not free the memory used by el and o until the browser is completely restarted.

+ +

The above case is likely to go unnoticed; memory leaks only become a real concern in long running applications or applications that leak large amounts of memory due to large data structures or leak patterns within loops.

+ +

Leaks are rarely this obvious - often the leaked data structure can have many layers of references, obscuring the circular reference.

+ +

Closures make it easy to create a memory leak without meaning to. Consider this:

+ +
function addHandler() {
+    var el = document.getElementById('el');
+    el.onclick = function() {
+        this.style.backgroundColor = 'red';
+    }
+}
+
+ +

The above code sets up the element to turn red when it is clicked. It also creates a memory leak. Why? Because the reference to el is inadvertently caught in the closure created for the anonymous inner function. This creates a circular reference between a JavaScript object (the function) and a native object (el).

+ +

There are a number of workarounds for this problem. The simplest is this:

+ +
function addHandler() {
+    var el = document.getElementById('el');
+    el.onclick = function() {
+        this.style.backgroundColor = 'red';
+    }
+    el = null;
+}
+
+ +

This works by breaking the circular reference.

+ +

Surprisingly, one trick for breaking circular references introduced by a closure is to add another closure:

+ +
function addHandler() {
+    var clickHandler = function() {
+        this.style.backgroundColor = 'red';
+    }
+    (function() {
+        var el = document.getElementById('el');
+        el.onclick = clickHandler;
+    })();
+}
+
+ +

The inner function is executed straight away, and hides its contents from the closure created with clickHandler.

+ +

Another good trick for avoiding closures is breaking circular references during the window.onunload event. Many event libraries will do this for you. Note that doing so disables bfcache in Firefox 1.5, so you should not register an unload listener in Firefox, unless you have other reasons to do so.

+ +
+

Original Document Information

+ + +
diff --git a/files/pl/orphaned/web/javascript/reference/global_objects/array/prototype/index.html b/files/pl/orphaned/web/javascript/reference/global_objects/array/prototype/index.html new file mode 100644 index 0000000000..94cbd2b287 --- /dev/null +++ b/files/pl/orphaned/web/javascript/reference/global_objects/array/prototype/index.html @@ -0,0 +1,12 @@ +--- +title: Array.prototype +slug: Web/JavaScript/Referencje/Obiekty/Array/prototype +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Podsumowanie

+ +

Reprezentuje prototyp tego obiektu. Pozwala na dodawanie własności lub metod do wszystkich instancji obiektu. Zobacz {{jsxref("Object.prototype")}}, aby uzyskać więcej informacji.

diff --git a/files/pl/orphaned/web/javascript/referencje/o_tym_dokumencie/konwencje_formatowania_tekstu/index.html b/files/pl/orphaned/web/javascript/referencje/o_tym_dokumencie/konwencje_formatowania_tekstu/index.html new file mode 100644 index 0000000000..3dbff8627a --- /dev/null +++ b/files/pl/orphaned/web/javascript/referencje/o_tym_dokumencie/konwencje_formatowania_tekstu/index.html @@ -0,0 +1,31 @@ +--- +title: Konwencje formatowania tekstu +slug: Web/JavaScript/Referencje/O_tym_dokumencie/Konwencje_formatowania_tekstu +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +--- +

 

+

Aplikacje w języku JavaScript działają na różnych systemach operacyjnych; informacje zawarte w tym dokumencie dotyczą wszystkich wersji. Nazwy plików i katalogów podawane są w stylu Windows (tzn. do rozdzielania katalogów stosowane są wsteczne ukośniki). Dla wersji Unix ścieżki są takie same, należy tylko zamienić ukośniki wsteczne na ukośniki zwykłe.

+

W dokumencie tym uniwersalne lokalizatory zasobów (adresy URL) podawane są w postaci:

+

http://serwer.domena/ścieżka/plik.html

+

W tych adresach URL:

+ +

Ogólnie rzecz biorąc, elementy pochylone w adresach URL są placeholderami, a elementy w normalnej czcionce o stałej szerokości - literałami.

+

W dokumencie tym stosowane są następujące konwencje dotyczące czcionek:

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