diff options
Diffstat (limited to 'files/pl/web/javascript/guide')
83 files changed, 7989 insertions, 0 deletions
diff --git a/files/pl/web/javascript/guide/control_flow_and_error_handling/index.html b/files/pl/web/javascript/guide/control_flow_and_error_handling/index.html new file mode 100644 index 0000000000..f7121fa2a5 --- /dev/null +++ b/files/pl/web/javascript/guide/control_flow_and_error_handling/index.html @@ -0,0 +1,380 @@ +--- +title: Przepływ danych i obsługa błędów +slug: Web/JavaScript/Guide/Control_flow_and_error_handling +tags: + - JavaScript + - Początkujący + - Przewodnik +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Grammar_and_types", "Web/JavaScript/Guide/Loops_and_iteration")}}</div> + +<p class="summary">JavaScript jest językiem zawierającym w sobie szeroki wachlarz instrukcji. Część z nich odnosi się do sterowania przepływem programu <em>(</em><em>ang. control flow)</em> i może być pomyślnie użyta w celu nadania Twojej aplikacji kolejnych poziomów interaktywności. W rozdziale tym omówimy te instrukcje.</p> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Statements">JavaScript reference</a> zawiera wyczerpujący opis instrukcji wymienionych w tym artykule. Średnik (;) jest używany do oddzielenia od siebie kolejnych poleceń w języku JavaScript. Chodź w większości przypadków brak średnika na końcu instrukcji nie powoduje błędu, by kod był jak najbardziej semantyczny, należy go tam umieszczać.</p> + +<p>Każde wyrażenie w języku JavaScript jest również instrukcją. <a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators">Expressions and operators</a> zawiera kompletny opis wyrażeń.</p> + +<h2 id="Instrukcja_blokowa">Instrukcja blokowa</h2> + +<p>Najprostszym rodzajem instrukcji jest instrukcja blokowa, która służy do grupowania wyrażeń. Blok jest ograniczony parą nawiasów klamrowych.</p> + +<pre class="syntaxbox">{ wyrazenie_1; wyrazenie_2; . . . wyrazenie_n; } +</pre> + +<h3 id="Przykład"><strong>Przykład</strong></h3> + +<p>Instrukcje blokowe są bardzo często używane w połączeniu z instrukcjami sterującymi (np. <code>if</code>, <code>for</code>, <code>while</code>).</p> + +<pre class="brush: js">while (x < 10) { + x++; +} +</pre> + +<p>W tym przypadku, { x++; } jest instrukcją blokową.</p> + +<p><strong>Ważne</strong>: Blok w JavaScript w wersji do ECMAScript6 nie posiada własnego scope (zasięgu zmiennych). Zmienne zadeklarowane wewnątrz takiego bloku bowiem mają scope (zasięg zmiennych) związany z funkcją lub skryptem, w którym blok się bezpośrednio znajduje. Efektem tego jest to, że każda zmienna zadeklarowana w bloku istnieje również i poza nim. W innych słowach - instrukcje blokowe nie definują nowego scope (zasięgu zmiennych). Samodzielne bloki w JavaScript mogą wyprodukować zupełnie inne wyniki od tych, których moglibyśmy się spodziewać w językach takich jak C czy Java. Przykład:</p> + +<pre class="brush: js">var x = 1; +{ + var x = 2; +} +console.log(x); // wypisze 2 +</pre> + +<p>Wypisane zostanie 2 ponieważ wyrażenie var x wewnątrz bloku dzieli scope (zasięg zmiennych) z wyrażeniem var x na zewnątrz bloku. W C lub Javie, równoważny kod wypisałby 1.</p> + +<p>Począwszy od specyfikacji ECMAScript 6, za pomocą słowa kluczowego <code>let</code> mamy mozliwość tworzenia zmiennych o zasięgu blokowym. </p> + +<h2 id="Instrukcje_warunkowe">Instrukcje warunkowe</h2> + +<p>Instrukcje warunkowe są zbiorem instrukcji, które pozwalają na wykonywanie danej porcji kodu gdy warunki (parametry instrukcji) zwracają wartość true. JavaScript wspiera dwa rodzaje instrukcji warunkowych:<strong> </strong><code>if . . . else</code> oraz <code>switch</code><strong>.</strong></p> + +<h3 id="Instrukcje_if...else">Instrukcje <code>if...else</code></h3> + +<p>Instrukcja <code>if</code><strong> </strong>wykonuje blok instrukcji jeżeli jej warunki zwrócą wartość <code>true</code>. Aby obsłużyć sytuacje gdy warunki nie zostały spełnione i zwracają <code>false</code>, można posłużyć się np. instrukcją <code>else</code><strong>:</strong></p> + +<pre class="syntaxbox">if (warunki) { + intrukcja_1; +} +else { + instrukcja_2; +}</pre> + +<p>Warunkami mogą być wszystkie twierdzania które można przekształcić do typu boolean (<code>true</code> lub <code>false</code>). W powyższym przykładzie <code>instrukcja_1</code> wykona się jeśli warunki zwrócą <code>true</code>, w przeciwnym wypadku wykonana zostanie <code>instrukcja_2</code>.<br> + <br> + Za pomocą <code>else if</code><strong> </strong>można tworzyć złożone sekwencyjnie testowe oparte na wielu instrukcjach warunkowych. Jeśli <code>warunek_1</code> nie zostanie spełniony, skrypt sprawdza kolejne warianty:</p> + +<pre class="syntaxbox">if (warunek_1) { instrukcja_1; } +else if (warunek_2) { instrukcja_2; } +else if (warunek_n) { instrukcja_n; } +else { ostatnia_instrukcja; } +</pre> + +<p>Aby wykonać wiele instrukcji można je zgrupować za pomocą deklaracji bloku (<code>{ ... }</code>). Mimo, że nie jest wymagane by pojedyncze instrukcje byly zawierane w bloku, warto stosować to rozwiązanie dla lepszej czytelności kodu:</p> + +<pre class="syntaxbox">if (warunek_1) { + instrukcja_1; + instrukcja_2; +} +else if (warunek_2) { + instrukcja_3; +} +else + instrukcja_4; + // Pojedyńcze instrukcje nie wymagają zawierania ich w nawiasy. + +</pre> + +<div>Wskazane jest, by nie używać przypisywania w wyrażeniu warunków:<br> + </div> + +<pre class="example-bad brush: js">if (x = y) { + /* instrukcje */ +}</pre> + +<p>Jeśli konieczne jest użycie operatora przypisania w wyrażeniu warunku, najczęściej stosowaną praktyką jest zawieranie przypisania w dodatkowe nawiasy:</p> + +<pre class="brush: js">if ((x = y)) { + /* statements here */ +} +</pre> + +<h4 id="Wartości_false">Wartości false</h4> + +<p>Poniższe wartości użyte w wyrażeniu warunku zostaną przekształcone w wartość <code>false</code>:</p> + +<ul> + <li><code>false</code>, zmienna typu Boolean</li> + <li><code>undefined</code></li> + <li><code>null</code></li> + <li><code>0</code>, zmienna typu Number</li> + <li><code>NaN</code>, zmienna typu Number</li> + <li><code>""</code>, zmienna typu String</li> +</ul> + +<p>Wszystkie inne wartości, włączając w to wszystkie obiekty, zostają przekształcone do wartości <code>true</code>.</p> + +<p>Nie należy mylić pierwotnych wartości <code>true</code> i <code>false</code> z wartościami <code>true</code> i <code>false</code> obiektu {{jsxref("Boolean")}}:</p> + +<pre class="brush: js">var b = new Boolean(false); +if (b) // Warunek zwróci wartość true gdyż zmienna b jest obiektem +if (b == true) // Warunek zwróci wartość false +</pre> + +<h4 id="Przykład_2"><strong>Przykład</strong></h4> + +<p>Następujący przykład przedstawia funkcje <code>checkData</code>, która zwróci <code>true</code> jeżeli liczba znaków w wartości elementu <code>threeChar</code> jest równa <code>3</code>, w przeciwnym wypadku zostanie wyświetlony alert i zwrócona wartość <code>false</code>.</p> + +<pre class="brush: js">function checkData() { + if (document.form1.threeChar.value.length == 3) { + return true; + } else { + alert("Enter exactly three characters. " + + document.form1.threeChar.value + " is not valid."); + return false; + } +} +</pre> + +<h3 id="Instrukcja_switch">Instrukcja <code>switch</code></h3> + +<p>Instrukcja <code>switch</code> pozwala na wykonanie bloku instrukcji jeśli podana wyrażenie zgadza się z identyfikatorem danego bloku. Gdy użyte zostanie słowo kluczowe <code>break</code>, switch wykonuje tylko instrukcje dopasowanego bloku. Bez niego wykonywane są wszystkie bloki poniżej dopasowania. Taka kaskadowość jest w wielu sytuacjach użyteczna.<br> + W przypadku gdy wyrażenie nie zostanie dopasowane do żadnego identyfikatora, wykonywany jest kod z bloku o identyfikatorze <code>default</code>. Default nie jest obowiązkowy i może zostać pominięty.</p> + +<pre class="syntaxbox">switch (wyrażenie) { + case identyfikator_1: + instruckje_1 + [break;] + case identyfikator_2: + instrukcje_2 + [break;] + ... + default: + instruckje_def + [break;] +} + +</pre> + +<h4 id="Przykład_3"><strong>Przykład</strong></h4> + +<p>W następującym przykładzie, jeśli <code>fruittype</code> przekaże wartość "Bananas", program dopasuje ją do bloku z identyfikatorem "Bananas" i wykona instrukcje które zostały w tym bloku zdefiniowane. Po napotkaniu i wykonaniu instrukcji <code>break</code>, program przerywa działanie instrukcji switch. Gdyby w bloku "Bananas" nie występował break, zostałyby wykonane również instrukcje dla bloku "Cherries" i zatrzymały na tam napotkanej instrukcji <code>break</code>.</p> + +<pre class="brush: js">switch (fruittype) { + case "Oranges": + console.log("Oranges are $0.59 a pound."); + break; + case "Apples": + console.log("Apples are $0.32 a pound."); + break; + case "Bananas": + console.log("Bananas are $0.48 a pound."); + break; + case "Cherries": + console.log("Cherries are $3.00 a pound."); + break; + case "Mangoes": + console.log("Mangoes are $0.56 a pound."); + break; + case "Papayas": + console.log("Mangoes and papayas are $2.79 a pound."); + break; + default: + console.log("Sorry, we are out of " + fruittype + "."); +} +console.log("Is there anything else you'd like?");</pre> + +<h2 id="Instrukcje_obsługi_wyjątków">Instrukcje obsługi wyjątków</h2> + +<p>Możliwe jest wywoływanie wyjątków za pomocą <code>throw</code> i ich późniejsza obsługa za pomocą instrukcji <code><font face="Consolas, Liberation Mono, Courier, monospace">try...catch.</font></code></p> + +<ul> + <li><a href="#throw_statement"><code>throw</code> statement</a></li> + <li><a href="#try_catch_statement"><code>try...catch</code> statement</a></li> +</ul> + +<h3 id="Typy_wyjątków">Typy wyjątków</h3> + +<p>Praktycznie każda wartość czy obiekt może posłużyć do wygenerowania wyjątku w JavaScript. Nie mniej jednak bardziej efektywne jest skorzystanie z już wbudowanych, specjalnie do tego przygotowanych typów jak np.</p> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Referencje/Obiekty/Error">Error</a></li> +</ul> + +<h3 id="Instrukcja_throw">Instrukcja <code>throw</code></h3> + +<p><code>throw</code> tworzy wyjątek. Kiedy wywołujesz wyjątek, musisz podać w danym wyrażeniu wartość, którą ma ten wyjątek zwrócić:</p> + +<pre class="syntaxbox">throw wyrażenie; +</pre> + +<p>Możesz wywoływać wyjątek z jakąkolwiek wartością. Podany kod rzuca wyjątki z wartościami różnych typów:</p> + +<pre class="brush: js">throw "Error2"; // Ciąg znaków +throw 42; // Typ liczbowy +throw true; // Wartość Boolean +throw {toString: function() { return "I'm an object!"; } }; +</pre> + +<div class="note"> +<p><strong>Notatka:</strong> Za pomocą instrukcji throw możesz zwrócić rówież obiekt. Możliwe jest osniesienie wartości objektu do właściwości bloku <code>catch</code>. Poniższy przykład tworzy obiekt <code>myUserException</code> typu <code>UserException</code> i używa go w instrukcji throw.</p> +</div> + +<pre class="brush: js">// Create an object type UserException +function UserException(message) { + this.message = message; + this.name = "UserException"; +} + +// Make the exception convert to a pretty string when used as a string +// (e.g. by the error console) +UserException.prototype.toString = function() { + return this.name + ': "' + this.message + '"'; +} + +// Create an instance of the object type and throw it +throw new UserException("Value too high");</pre> + +<h3 id="Instrukcja_try...catch">Instrukcja <code>try...catch</code></h3> + +<p><code>try...catch </code>jest instrukcją wykonującą pewien blok kodu i wyłąpującą w nim ewentualne wyjątki i błędy, które mogą zostać odpowiednio obsłużone.</p> + +<p>Instrukcja <code>try...catch </code>zawiera blok <code>try</code>, w którym znajduje się jedna bądź więcej instrukcji i zero lub więcej bloków <code>catch</code> określających zachowanie programu w przypadku napotkania w bloku <code>try</code> jakiegoś wyjątku. Blok <code>try</code> testuje nie tylko bezpośrednio wywołane instrukcje, ale cały stos wywołań użytych funkcji.</p> + +<pre class="brush: js">function test1() { + test2(); +}; + +function test2() { + console.log(name); +}; + +try{ + test1(); +} +catch(e){ + console.error(e); //ReferenceError: name is not defined +}</pre> + +<pre class="brush: js">function getMonthName(mo) { + mo = mo - 1; // Adjust month number for array index (1 = Jan, 12 = Dec) + var months = ["Jan","Feb","Mar","Apr","May","Jun","Jul", + "Aug","Sep","Oct","Nov","Dec"]; + if (months[mo]) { + return months[mo]; + } else { + throw "InvalidMonthNo"; //throw keyword is used here + } +} + +try { // statements to try + monthName = getMonthName(myMonth); // function could throw exception +} +catch (e) { + monthName = "unknown"; + logMyErrors(e); // pass exception object to error handler -> your own function +} +</pre> + +<h4 id="Blok_catch">Blok <code><strong>catch</strong></code></h4> + +<p>Możesz użyć bloku <code>catch</code> do obsługi wszystkich wyjątków jakie wystąpią w bloku <code>try</code>.</p> + +<pre class="syntaxbox">catch (catchID) { + instrukcje +} +</pre> + +<p>Blok <code>catch</code> przyjmuje parametr catchID, który jest po prostu wartością wyrzuconą przez wyjątek.</p> + +<h4 id="Blok_finally">Blok <code><strong>finally</strong></code></h4> + +<p>Możliwe jest dodanie bloku <code>finally</code>, który wykona się niezależnie od tego czy kod w bloku <code>try</code> rzucił jakimś wyjątkiem czy nie.</p> + +<pre class="brush: js">function test1(){ + test2(); +}; + +function test2(){ + console.log(name) +}; + +try{ + test1(); +} +catch(e){ + console.error(e) //ReferenceError: name is not defined +} +finally{ + console.log('Taka zmienna nie została zadeklarowana!') +}</pre> + +<h4 id="Nesting_try...catch_Statements" name="Nesting_try...catch_Statements">Zagnieżdzone instrukcje <strong>try...catch</strong></h4> + +<p>W swoim programie możesz użyć wielu zagnieżdzonych bloków <code>try...catch. </code>Jeśli wewnętrzny <code>try...catch </code>nie będzie posiadał bloku <code>catch,</code> wyjątek zostanie przekazany do zewnętrznego<code> try...catch.</code></p> + +<h3 id="Wykorzystanie_obiektu_Error">Wykorzystanie obiektu Error</h3> + +<p>W zależności od rodzaju błędu jaki chcesz wygnerować w swoim programie, możesz skorzystać z pól 'name' i 'message', aby uzyskać bardziej wyrafinowany log. 'name' zabiera nazwe ogólnej klasy błędu (np. 'DOMException'), z kolei 'message' zawiera bardziej szczegółową informacje okolicznościach powstania danego błędu.</p> + +<p>Jeśli chcesz wywoływać własne wyjątki, aby skorzystać z zalet tych pól możesz użyć konstruktora Error:</p> + +<pre class="brush: js">function doSomethingErrorProne () { + if (ourCodeMakesAMistake()) { + throw (new Error('The message')); + } else { + doSomethingToGetAJavascriptError(); + } +} +.... +try { + doSomethingErrorProne(); +} +catch (e) { + console.log(e.name); // logs 'Error' + console.log(e.message); // logs 'The message' or a JavaScript error message) +}</pre> + +<h2 id="Obietnice">Obietnice</h2> + +<p>Począwszy od specyfikacji ECMAScript 6, JavaScript obsługuje obiekty obietnic pozwalające na kontrole przepływu opóźnionych i asynchronicznych operacji.</p> + +<p>Obietnica może znajdować się w jednym z następujących stanów:</p> + +<ul> + <li><em>oczekiwanie</em>: stan początkowy, obietnica nie jest ani spełniona ani odrzucona.</li> + <li><em>spełnienie</em>: operacja zakończona sukcesem.</li> + <li><em>odrzucenie</em>: operacja zakończona niepowodzeniem.</li> + <li><em>rozliczenie</em>: obietnica została spełniona lub odrzucona i nie jest już w stanie oczekiwania.</li> +</ul> + +<p><img alt="" src="https://mdn.mozillademos.org/files/8633/promises.png" style="height: 297px; width: 801px;"></p> + +<h3 id="Ładowanie_zdjęcia_za_pomocą_XHR">Ładowanie zdjęcia za pomocą XHR</h3> + +<p>Prosty przykład użycia <code>Promise and <code><a href="/en-US/docs/Web/API/XMLHttpRequest">XMLHttpRequest</a> </code></code>do załadowania zdjęcia jeśli jest dostępne w MDN GitHub promise-test repozytorium. </p> + +<pre class="brush: js">function imgLoad(url) { + return new Promise(function(resolve, reject) { + var request = new XMLHttpRequest(); + request.open('GET', url); + request.responseType = 'blob'; + request.onload = function() { + if (request.status === 200) { + resolve(request.response); + } else { + reject(Error('Image didn\'t load successfully; error code:' + + request.statusText)); + } + }; + request.onerror = function() { + reject(Error('There was a network error.')); + }; + request.send(); + }); +}</pre> + +<p>Aby dowiedzieć się więcej, sprawdź {{jsxref("Promise")}}.</p> + +<div>{{PreviousNext("Web/JavaScript/Guide/Grammar_and_types", "Web/JavaScript/Guide/Loops_and_iteration")}}</div> diff --git a/files/pl/web/javascript/guide/funkcje/index.html b/files/pl/web/javascript/guide/funkcje/index.html new file mode 100644 index 0000000000..d9e66793ea --- /dev/null +++ b/files/pl/web/javascript/guide/funkcje/index.html @@ -0,0 +1,642 @@ +--- +title: Funkcje +slug: Web/JavaScript/Guide/Funkcje +translation_of: Web/JavaScript/Guide/Functions +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Loops_and_iteration", "Web/JavaScript/Guide/Expressions_and_Operators")}}</div> + +<p class="summary">Funkcje są jednym z podstawowych 'klocków' JavaScriptu. Funkcja jest zbiorem wyrażeń, które wykonują jakieś zadanie, bądź obliczają wartość. Aby użyć funkcji, musisz najpierw zdefiniować ją gdzieś w zasięgu, z którego zostanie wywołana.</p> + +<p>See also the <a href="/en-US/docs/Web/JavaScript/Reference/Functions">exhaustive reference chapter about JavaScript functions</a> to get to know the details.</p> + +<h2 id="Definiowanie_funkcji">Definiowanie funkcji</h2> + +<h3 id="Deklaracje_funkcji">Deklaracje funkcji</h3> + +<p><strong>Definicja funkcji</strong> (zwana też <strong>deklaracją funkcji</strong>, lub <strong>instrukcją funkcji</strong>) składa się ze słowa kluczowego <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function" title="function"><code>function</code></a> oraz:</p> + +<ul> + <li>Nazwy funkcji.</li> + <li>Listy argumentów zamkniętych w nawiasach i oddzielonych przecinkami.</li> + <li>Instrukcji JavaScript, które definiują funkcję, zamkniętych w nawiasach klamrowych, <code>{ }</code>.</li> +</ul> + +<p>Poniższy przykład przedstawia definicję funkcji obliczającej kwadrat liczby:</p> + +<pre class="brush: js">function square(number) { + return number * number; +} +</pre> + +<p>Funkcja <code>square</code> przyjmuje jeden argument, nazwany <code>number</code>. Funkcja składa się z jednej instrukcji, która zwraca argument (<code>number</code>) pomnożony przez siebie. Instrukcja <a href="/en-US/docs/Web/JavaScript/Reference/Statements/return" title="return"><code>return</code></a> oznacza wartość zwracaną przez funkcję.</p> + +<pre class="brush: js">return number * number; +</pre> + +<p>Podstawowe parametry (takie jak liczby) są przekazywane do funkcji <strong>przez wartość</strong>; wartośc przekazywana jest do funkcji, ale jeśli funkcja zmienia wartość, ta zmiana nie jest rejestrowana globalnie, lub w funkcji wywołującej.</p> + +<p>Jeśli przekażesz obiekt (n.p. {{jsxref("Array")}}) jako parametr a funkcja zmieni właściwości obiektu, zmiana ta jest rejestrowana poza funkcją, tak jak jest to pokazane w przykładzie:</p> + +<pre class="brush: js">function myFunc(theObject) { + theObject.make = "Toyota"; +} + +var mycar = {make: "Honda", model: "Accord", year: 1998}; +var x, y; + +x = mycar.make; // x dostaje wartość "Honda" + +myFunc(mycar); +y = mycar.make; // y dodaje wartość "Toyota" + // (właściwość make została zmieniona przez funkcję) +</pre> + +<div class="note"> +<p><strong>Note:</strong> Przypisanie nowego obiektu do parametru <strong>nie</strong> będzie miało żadnego skutku poza funkcją, ponieważ jest to zmiana wartości parametru, a nie zmiana jednej z właściwości obiektu:</p> +</div> + +<pre class="brush: js">function myFunc(theObject) { + theObject = {make: "Ford", model: "Focus", year: 2006}; +} + +var mycar = {make: "Honda", model: "Accord", year: 1998}; +var x, y; + +x = mycar.make; // x dostaje wartość "Honda" + +myFunc(mycar); +y = mycar.make; // y wciąż dostaje wartość "Honda" </pre> + +<h3 id="Wyrażenia_funkcyjne">Wyrażenia funkcyjne</h3> + +<p>Podczas gdy powyższa deklaracja jest syntaktycznie wyrażeniem, funkcje mogą być utworzone także przez <strong>wyrażenie funkcyjne.</strong> Taka funkcja może być <strong>anonimowa;</strong> nie posiadająca nazwy. Dla przykładu, funkcja <code>square </code>może być zdefiniowana następująco:</p> + +<pre class="brush: js">var square = function(number) { return number * number }; +var x = square(4) // x gets the value 16</pre> + +<p>Deklaracja funkcji przy pomocy wyrażenia funkcyjnego nie oznacza, że funkcja musi być anonimowa. Nadal może ona posiadać swoją nazwę, która może przydać się do wywołania samej siebie czy do identyfikacji w śladzie stosu podczas debugowania kodu. </p> + +<pre class="brush: js">var factorial = function fac(n) { return n<2 ? 1 : n*fac(n-1) }; + +console.log(factorial(3)); +</pre> + +<p>Function expressions are convenient when passing a function as an argument to another function. The following example shows a <code>map</code> function being defined and then called with an expression function as its first parameter:</p> + +<pre class="brush: js">function map(f,a) { + var result = [], // Create a new Array + i; + for (i = 0; i != a.length; i++) + result[i] = f(a[i]); + return result; +} +</pre> + +<p>Poniższy kod:</p> + +<pre class="brush: js">map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]); +</pre> + +<p>zwraca [0, 1, 8, 125, 1000].</p> + +<p>In JavaScript, a function can be defined based on a condition. For example, the following function definition defines <code>myFunc</code> only if <code>num</code> equals 0:</p> + +<pre class="brush: js">var myFunc; +if (num == 0){ + myFunc = function(theObject) { + theObject.make = "Toyota" + } +}</pre> + +<p>In addition to defining functions as described here, you can also use the {{jsxref("Function")}} constructor to create functions from a string at runtime, much like {{jsxref("eval()")}}.</p> + +<p>A <strong>method</strong> is a function that is a property of an object. Read more about objects and methods in <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects" title="en-US/docs/JavaScript/Guide/Working with Objects">Working with objects</a>.</p> + +<h2 id="Wywoływanie_funkcji">Wywoływanie funkcji</h2> + +<p>Definicja fukcji nie wykonuje jej. Definiowanie funkcji nazywa fukncję i określa co robić kiedy fukcja zostanie wywołana. <strong>Wywołanie </strong>funkcji inicjiuje wykonanie określonych akcji wraz z wskazanymi parametrami. Na przykład, jeśli zdefiniujesz funkcję square, możesz ją wywołać w następujący sposób:</p> + +<pre class="brush: js">square(5); +</pre> + +<p>Powyższy kod wywołuje funkcję dla argumentu 5. Funkcja wykonuje się i zwraca wartość 25.</p> + +<p>Funkcja musi znajdować się w obecnym zakresie by mogła zostać wywołana. Jej wywołanie może jednak znajdować się powyżej jej deklaracji. Mamy wtedy do czynienia ze zjawiskiem hoistingu. </p> + +<pre class="brush: js">console.log(square(5)); +/* ... */ +function square(n) { return n*n } +</pre> + +<p>Zakres funkcji jest funkcją w której została ona zadeklarowana co oznacza, że deklarując funkcję na najwyższym poziomie programu, znajduje się ona w zakresie globalnym.</p> + +<div class="note"> +<p><strong>Notka:</strong> Zjawisko hoistingu funkcji zachodzi wyłącznie w przypadku powyższego sposobu deklaracji (<code>function funcName(){}</code>). Poniższy kod nie zadziała, w tym przypadku funkcja została zadeklarowana za pomocą wyrażenia.</p> +</div> + +<pre class="brush: js example-bad">console.log(square(5)); +square = function (n) { + return n * n; +} +</pre> + +<p>Argumenty funkcji mogą być nie tylko łańcuchami lub liczbami.Funkcja <code>show_props()</code> (zdefiniowana w <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Objects_and_Properties" title="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Working_with_Objects#Objects_and_Properties">Working with objects</a>) jest przykładem funkcji przyjmującej objekt jako argument.</p> + +<p>Funkcja może wywoływać samą siebie. Na przykład, poniżej mamy funkcję rekurencyjnie obliczającą silnię.</p> + +<pre class="brush: js">function factorial(n){ + if ((n == 0) || (n == 1)) + return 1; + else + return (n * factorial(n - 1)); +} +</pre> + +<p>Poniżej znajdują się wyniki funkcji dla liczb z zakresu 1-5.</p> + +<pre class="brush: js">var a, b, c, d, e; +a = factorial(1); // a gets the value 1 +b = factorial(2); // b gets the value 2 +c = factorial(3); // c gets the value 6 +d = factorial(4); // d gets the value 24 +e = factorial(5); // e gets the value 120 +</pre> + +<p>Istnieją inne sposoby wywołania funkcji. Często zdarzają się sytuacje gdy funkcja musi zostać wywołana dynamicznie, przyjmuje różna liczbę argumentów lub zmienia sie kontekst jej wywołania. Okazuje się, że funkcje są tak naprawdę obiektami, które posiadaja własne metody (sprawdź obiekt {{jsxref("Function")}}). Jednej z tych metod {{jsxref("Function.apply", "apply()")}} możemy użyć do zmiany kontekstu wywołania funkcji.</p> + +<h2 class="deki-transform" id="Zakres_funkcji">Zakres funkcji</h2> + +<p>Zmienne zdefiniowane wewnątrz funkcji nie są dostępne poza nią, ponieważ są zdefiniowane tylko w wewnętrznym zakresie funkcji. Sama funkcja ma dostęp do innych zmiennych i funkcji zdefiniowanych w tym samym zakresie, w którym została zdefiniowana. Innymi słowy, funkcja zdefiniowana w zakresie globalnym ma dostęp do wszystkich zmiennych zdefiniowanych w zakresie globalnym. Funkcja zdefiniowana w innej funkcji ma dostęp do wszystkich zmiennych zdefiniowanych w funkcji macierzystej oraz zmiennych, do których ma dostęp funkcja macierzysta.</p> + +<pre class="brush: js">// Poniższe zmienne są zdefiniowane z zakresie globalnym +var num1 = 20, + num2 = 3, + name = "Chamahk"; + +// Ta funkcja jest zdefiniowana w zakresie globalnym +function multiply() { + return num1 * num2; +} + +multiply(); // Zwraca 60 + +// Przykład funkcji zagnieżdżonej +function getScore () { + var num1 = 2, + num2 = 3; + + function add() { + return name + " scored " + (num1 + num2); + } + + return add(); +} + +getScore(); // Zwraca "Chamahk scored 5" +</pre> + +<h2 id="Zakres_i_stos_funkcji">Zakres i stos funkcji</h2> + +<h3 id="Rekurencja">Rekurencja</h3> + +<p>Funkcja może się odwoływać i wywoływać samą siebie. Istnieją trzy sposoby odwoływania się funkcji do siebie:</p> + +<ol> + <li>przez nazwę funkcji</li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee</a></code></li> + <li>przez zmienną dostępna w zakresie, która odwołuje się do funkcji</li> +</ol> + +<p>Na przykład, rozważ następującą definicję funkcji:</p> + +<pre class="brush: js">var foo = function bar() { + // statements go here +}; +</pre> + +<p>Within the function body, the following are all equivalent:</p> + +<ol> + <li><code>bar()</code></li> + <li><code>arguments.callee()</code></li> + <li><code>foo()</code></li> +</ol> + +<p>Funkcja, która wywołuje samą siebie to <em>funkcja rekurencyjna</em>. W pewnym sensie rekurencja jest analogiczna z pętlą. Zarówno funkcja rekurencyjna, jak i pętla wykonują ten sam kod wiele razy, potrzebują warunku końca (aby uniknąć wiecznej pętli lub bardziej w tym przypadku wiecznej rekurencji). Dla przykładu następująca pętla:</p> + +<pre class="brush: js">var x = 0; +while (x < 10) { // "x < 10" is the loop condition + // zrób jakieś rzeczy + x++; +} +</pre> + +<p>może być przekształcona w funkcję rekurencyjną i wywołanie tej funkcji:</p> + +<pre class="brush: js">function loop(x) { + if (x >= 10) // "x >= 10" is the exit condition (equivalent to "!(x < 10)") + return; + // do stuff + loop(x + 1); // rekurencyjne wywołanie +} +loop(0); +</pre> + +<p>Niektóre algorytmy nie mogą być wykonane w zwykłej iteracji pętli. Dla przykładu, wydobycie wszystkich nodów ze struktury drzewiastej (np. dla <a href="/en-US/docs/DOM">DOM</a>) jest łatwiej wykonać za pomocą rekurencji:</p> + +<pre class="brush: js">function walkTree(node) { + if (node == null) // + return; + // zrób coś z node + for (var i = 0; i < node.childNodes.length; i++) { + walkTree(node.childNodes[i]); + } +} +</pre> + +<p>Porównując do funkcji z pętlą <code>loop</code>, każde rekurencyjne wywołanie wykonuje wiele rekurencyjnych wowołań.</p> + +<p>Każdy algorytm rekurencyjny można zmienić na nie rekurencyjny, lecz logika w tym drugim przypadku jest znacznie bardziej skomplikowana i wymaga użycia stosu. Faktycznie, sama rekurencja używa stosu: stosu funkcyjnego.</p> + +<p>W poniższym przykładzie widać zachowanie przypominające użycie stosu:</p> + +<pre class="brush: js">function foo(i) { + if (i < 0) + return; + console.log('begin:' + i); + foo(i - 1); + console.log('end:' + i); +} +foo(3); + +// Output: + +// begin:3 +// begin:2 +// begin:1 +// begin:0 +// end:0 +// end:1 +// end:2 +// end:3</pre> + +<h3 id="Funkcje_zagnieżdżone_i_domknięcia">Funkcje zagnieżdżone i domknięcia</h3> + +<p>Możesz zagnieżdżać funkcję w funkcji. Zagnieżdżona (wewnętrzna) funkcja jest prywatna dla funkcji (zewnętrznej), która ją zawiera. W ten sposób tworzy się domknięcie (<em>closure)</em>. Domknięcie jest wyrażeniem (zwykle funkcją), które może posiadać dodatkowe zmienne razem ze środowiskiem, które "wiąże" te zmienne (w ten sposób domknięcie jest zamykane).</p> + +<p>Ponieważ funkcja zagnieżdżona jest równocześnie domknięciem, to oznacza, że może "dziedziczyć" wszystkie argumenty i zmienne funkcji, która ją zawiera. Innymi słowy, funkcja wewnętrzna zawiera zakres funkcji zewnętrznej.</p> + +<p>Podsumowując:</p> + +<ul> + <li>Funkcja wewnętrzna może być dostępna tylko przez instrukcje z funkcji zewnętrznej.</li> +</ul> + +<ul> + <li>Funkcja wewnętrzna tworzy domknięcie: może używać argumentów i zmiennych funkcji zewnętrznej, podczas gdy funkcja zewnętrzna nie może używać argumentów i zmiennych funkcji wewnętrznej.</li> +</ul> + +<p>Poniższy przykład obrazuje funkcje zagnieżdżone:</p> + +<pre class="brush: js">function addSquares(a,b) { + function square(x) { + return x * x; + } + return square(a) + square(b); +} +a = addSquares(2,3); // returns 13 +b = addSquares(3,4); // returns 25 +c = addSquares(4,5); // returns 41 +</pre> + +<p>Ponieważ funkcja wewnętrzna tworzy domknięcie, możesz wywołać funkcję zewnętrzną i podać argumenty zarówno dla zewnętrznej, jak i wewnętrznej funkcji:</p> + +<pre class="brush: js">function outside(x) { + function inside(y) { + return x + y; + } + return inside; +} +fn_inside = outside(3); // Think of it like: give me a function that adds 3 to whatever you give it +result = fn_inside(5); // returns 8 + +result1 = outside(3)(5); // returns 8 +</pre> + +<h3 id="Zachowywanie_zmiennych">Zachowywanie zmiennych</h3> + +<p>Zwróć uwagę jak zmienna <code>x</code> jest zachowana, kiedy zwracana jest funkcja <code>inside</code>. Domknięcie musi zachować argumenty i zmienne we wszystkich zakresach, do których się odwołuje. Jako że każde wywołanie potencjalnie dostarcza różne wartości argumentów, przy każdym wywołaniu <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">outside</span></font> jest tworzone nowe domknięcie. Pamięć może być zwolniona, tylko jeśli zwracany <code>inside</code> nie jest więcej dostępny.</p> + +<p>Ten sposób nie różni się od zachowywania referencji w innych obiektach, lecz jest mniej oczywisty, ponieważ referencje nie są tworzone bezpośrednio i nie można ich zweryfikować.</p> + +<h3 id="Wielokrotnie_zagnieżdżone_funkcje">Wielokrotnie zagnieżdżone funkcje</h3> + +<p>Funkcje mogą być zagnieżdżone wielokrotnie, np. funkcja (A) zawierająca funkcję (B) zawierającą funkcję (C). Obydwie funkcje B i C tworzą domknięcia więc B ma dostęp do A a C ma dostęp do B. Dodatkowo, ponieważ C ma dostęp do B która ma dostęp do A, więc C również ma dostęp do A. W ten sposób domknięcia mogą zawierać wiele zakresów; zawierają rekurencyjne zakresy funkcji, które je zawierają. Efekt ten nazywa się <em>wiązaniem zakresów (</em><em>scope chaining)</em>. (Później zostanie wyjaśnione określenie "chaining".)</p> + +<p>Rozważ poniższy przykład:</p> + +<pre class="brush: js">function A(x) { + function B(y) { + function C(z) { + console.log(x + y + z); + } + C(3); + } + B(2); +} +A(1); // logs 6 (1 + 2 + 3) +</pre> + +<p>W tym przykładzie <code>C</code> ma dostęp do zmiennej <code>y</code> w <code>B</code> i <code>x</code> w <code>A</code>. Jest to możliwe, ponieważ:</p> + +<ol> + <li><code>B</code> tworzy domknięcie zawierające <code>A</code> i dlatego <code>B</code> ma dostęp do argumentów i zmiennych <code>A</code>.</li> + <li><code>C</code> tworzy domknięcie zawierające <code>B</code>.</li> + <li>Ponieważ domknięcie <code>B</code> zawiera <code>A</code>, to domknięcie <code>C</code> również zawiera <code>A</code>. <code>C</code> ma dostęp do zmiennych i argumentów zarówno <code>B</code> jak i <code>A</code>. Innymi słowy <code>C</code> wiąże zakresy <code>B</code> i <code>A</code>.</li> +</ol> + +<p>Jednak sytuacja odwrotna nie jest już prawdziwa. <code>A</code> nie ma dostępu do <code>C</code>, ponieważ <code>A</code> nie może dostać się do żadnego argumentu i zmiennej <code>B</code>, dla której <code>C</code> jest zmienną. Zatem <code>C</code> pozostaje prywatny (dostępny) tylko dla <code>B</code>.</p> + +<h3 id="Konflikty_nazw">Konflikty nazw</h3> + +<p>Gdy dwa argumenty lub zmienne w zakresach danego zamknięcia mają tę samą nazwę, wtedy występuje konflikt nazw. Czym bardziej wewnętrzny zakres, tym większe pierwszeństwo, więc najbardziej wewnętrzny zakres ma najwyższy priorytet, a najbardziej zewnętrzny zakres ma najniższy. Sytuacja ta, określana jest wiązaniem zakresów. Pierwszy w łańcuchu to najbardziej wewnętrzny zakres, a ostatni to najbardziej zewnętrzny. Rozważ następujący przykład:</p> + +<pre class="brush: js">function outside() { + var x = 10; + function inside(x) { + return x; + } + return inside; +} +result = outside()(20); // returns 20 instead of 10 +</pre> + +<p>The name conflict happens at the statement <code>return x</code> and is between <code>inside</code>'s parameter <code>x</code> and <code>outside</code>'s variable <code>x</code>. The scope chain here is {<code>inside</code>, <code>outside</code>, global object}. Therefore <code>inside</code>'s <code>x</code> takes precedences over <code>outside</code>'s <code>x</code>, and 20 (<code>inside</code>'s <code>x</code>) is returned instead of 10 (<code>outside</code>'s <code>x</code>).</p> + +<h2 id="Closures">Closures</h2> + +<p>Closures are one of the most powerful features of JavaScript. JavaScript allows for the nesting of functions and grants the inner function full access to all the variables and functions defined inside the outer function (and all other variables and functions that the outer function has access to). However, the outer function does not have access to the variables and functions defined inside the inner function. This provides a sort of security for the variables of the inner function. Also, since the inner function has access to the scope of the outer function, the variables and functions defined in the outer function will live longer than the outer function itself, if the inner function manages to survive beyond the life of the outer function. A closure is created when the inner function is somehow made available to any scope outside the outer function.</p> + +<pre class="brush: js">var pet = function(name) { // The outer function defines a variable called "name" + var getName = function() { + return name; // The inner function has access to the "name" variable of the outer function + } + return getName; // Return the inner function, thereby exposing it to outer scopes +}, +myPet = pet("Vivie"); + +myPet(); // Returns "Vivie" +</pre> + +<p>It can be much more complex than the code above. An object containing methods for manipulating the inner variables of the outer function can be returned.</p> + +<pre class="brush: js">var createPet = function(name) { + var sex; + + return { + setName: function(newName) { + name = newName; + }, + + getName: function() { + return name; + }, + + getSex: function() { + return sex; + }, + + setSex: function(newSex) { + if(typeof newSex == "string" && (newSex.toLowerCase() == "male" || newSex.toLowerCase() == "female")) { + sex = newSex; + } + } + } +} + +var pet = createPet("Vivie"); +pet.getName(); // Vivie + +pet.setName("Oliver"); +pet.setSex("male"); +pet.getSex(); // male +pet.getName(); // Oliver +</pre> + +<p>In the code above, the <code>name</code> variable of the outer function is accessible to the inner functions, and there is no other way to access the inner variables except through the inner functions. The inner variables of the inner function act as safe stores for the inner functions. They hold "persistent", yet secure, data for the inner functions to work with. The functions do not even have to be assigned to a variable, or have a name.</p> + +<pre class="brush: js">var getCode = (function(){ + var secureCode = "0]Eal(eh&2"; // A code we do not want outsiders to be able to modify... + + return function () { + return secureCode; + }; +})(); + +getCode(); // Returns the secureCode +</pre> + +<p>There are, however, a number of pitfalls to watch out for when using closures. If an enclosed function defines a variable with the same name as the name of a variable in the outer scope, there is no way to refer to the variable in the outer scope again.</p> + +<pre class="brush: js">var createPet = function(name) { // Outer function defines a variable called "name" + return { + setName: function(name) { // Enclosed function also defines a variable called "name" + name = name; // ??? How do we access the "name" defined by the outer function ??? + } + } +} +</pre> + +<p>The magical <code>this</code> variable is very tricky in closures. They have to be used carefully, as what <code>this</code> refers to depends completely on where the function was called, rather than where it was defined.</p> + +<h2 id="Using_the_arguments_object">Using the arguments object</h2> + +<p>The arguments of a function are maintained in an array-like object. Within a function, you can address the arguments passed to it as follows:</p> + +<pre class="brush: js">arguments[i] +</pre> + +<p>where <code>i</code> is the ordinal number of the argument, starting at zero. So, the first argument passed to a function would be <code>arguments[0]</code>. The total number of arguments is indicated by <code>arguments.length</code>.</p> + +<p>Using the <code>arguments</code> object, you can call a function with more arguments than it is formally declared to accept. This is often useful if you don't know in advance how many arguments will be passed to the function. You can use <code>arguments.length</code> to determine the number of arguments actually passed to the function, and then access each argument using the <code>arguments</code> object.</p> + +<p>For example, consider a function that concatenates several strings. The only formal argument for the function is a string that specifies the characters that separate the items to concatenate. The function is defined as follows:</p> + +<pre class="brush: js">function myConcat(separator) { + var result = "", // initialize list + i; + // iterate through arguments + for (i = 1; i < arguments.length; i++) { + result += arguments[i] + separator; + } + return result; +} +</pre> + +<p>You can pass any number of arguments to this function, and it concatenates each argument into a string "list":</p> + +<pre class="brush: js">// returns "red, orange, blue, " +myConcat(", ", "red", "orange", "blue"); + +// returns "elephant; giraffe; lion; cheetah; " +myConcat("; ", "elephant", "giraffe", "lion", "cheetah"); + +// returns "sage. basil. oregano. pepper. parsley. " +myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley"); +</pre> + +<div class="note"> +<p><strong>Note:</strong> The <code>arguments</code> variable is "array-like", but not an array. It is array-like in that is has a numbered index and a <code>length</code> property. However, it does not possess all of the array-manipulation methods.</p> +</div> + +<p>See the {{jsxref("Function")}} object in the JavaScript reference for more information.</p> + +<h2 id="Function_parameters">Function parameters</h2> + +<p>Starting with ECMAScript 6, there are two new kinds of parameters: default parameters and rest parameters.</p> + +<h3 id="Default_parameters">Default parameters</h3> + +<p>In JavaScript, parameters of functions default to <code>undefined</code>. However, in some situations it might be useful to set a different default value. This is where default parameters can help.</p> + +<p>In the past, the general strategy for setting defaults was to test parameter values in the body of the function and assign a value if they are <code>undefined</code>. If in the following example, no value is provided for <code>b</code> in the call, its value would be <code>undefined</code> when evaluating <code>a*b</code> and the call to <code>multiple</code> would have returned <code>NaN</code>. However, this is caught with the second line in this example:</p> + +<pre class="brush: js">function multiply(a, b) { + b = typeof b !== 'undefined' ? b : 1; + + return a*b; +} + +multiply(5); // 5 +</pre> + +<p>With default parameters, the check in the function body is no longer necessary. Now, you can simply put <code>1</code> as the default value for <code>b</code> in the function head:</p> + +<pre class="brush: js">function multiply(a, b = 1) { + return a*b; +} + +multiply(5); // 5</pre> + +<p>Fore more details, see <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">default parameters</a> in the reference.</p> + +<h3 id="Rest_parameters">Rest parameters</h3> + +<p>The <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameter</a> syntax allows to represent an indefinite number of arguments as an array. In the example, we use the rest parameters to collect arguments from the second one to the end. We then multiply them by the first one. This example is using an arrow function, which is introduced in the next section.</p> + +<pre class="brush: js">function multiply(multiplier, ...theArgs) { + return theArgs.map(x => multiplier * x); +} + +var arr = multiply(2, 1, 2, 3); +console.log(arr); // [2, 4, 6]</pre> + +<h2 id="Arrow_functions">Arrow functions</h2> + +<p>An <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow function expression</a> (also known as <strong>fat arrow function</strong>) has a shorter syntax compared to function expressions and lexically binds the <code>this</code> value. Arrow functions are always anonymous. See also this hacks.mozilla.org blog post: "<a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">ES6 In Depth: Arrow functions</a>".</p> + +<p>Two factors influenced the introduction of arrow functions: shorter functions and lexical <code>this</code>.</p> + +<h3 id="Shorter_functions">Shorter functions</h3> + +<p>In some functional patterns, shorter functions are welcome. Compare:</p> + +<pre class="brush: js">var a = [ + "Hydrogen", + "Helium", + "Lithium", + "Beryllium" +]; + +var a2 = a.map(function(s){ return s.length }); + +var a3 = a.map( s => s.length );</pre> + +<h3 id="Lexical_this">Lexical <code>this</code></h3> + +<p>Until arrow functions, every new function defined its own <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a> value (a new object in case of a constructor, undefined in strict mode function calls, the context object if the function is called as an "object method", etc.). This proved to be annoying with an object-oriented style of programming.</p> + +<pre class="brush: js">function Person() { + // The Person() constructor defines `<code>this`</code> as itself. + this.age = 0; + + setInterval(function growUp() { + // In nonstrict mode, the growUp() function defines `this` + // as the global object, which is different from the `this` + // defined by the Person() constructor. + this.age++; + }, 1000); +} + +var p = new Person();</pre> + +<p>In ECMAScript 3/5, this issue was fixed by assigning the value in <code>this</code> to a variable that could be closed over.</p> + +<pre class="brush: js">function Person() { + var self = this; // Some choose `that` instead of `self`. + // Choose one and be consistent. + self.age = 0; + + setInterval(function growUp() { + // The callback refers to the `self` variable of which + // the value is the expected object. + self.age++; + }, 1000); +}</pre> + +<h2 id="Predefined_functions">Predefined functions</h2> + +<p>JavaScript has several top-level, built-in functions:</p> + +<dl> + <dt>{{jsxref("Global_Objects/eval", "eval()")}}</dt> + <dd> + <p>The <code><strong>eval()</strong></code> method evaluates JavaScript code represented as a string.</p> + </dd> + <dt>{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline}}</dt> + <dd> + <p>The <code><strong>uneval()</strong></code> method creates a string representation of the source code of an {{jsxref("Object")}}.</p> + </dd> + <dt>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</dt> + <dd> + <p>The global <code><strong>isFinite()</strong></code> function determines whether the passed value is a finite number. If needed, the parameter is first converted to a number.</p> + </dd> + <dt>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</dt> + <dd> + <p>The <code><strong>isNaN()</strong></code> function determines whether a value is {{jsxref("Global_Objects/NaN", "NaN")}} or not. Note: coercion inside the <code>isNaN</code> function has <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN#Description">interesting</a> rules; you may alternatively want to use {{jsxref("Number.isNaN()")}}, as defined in ECMAScript 6, or you can use <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a></code> to determine if the value is Not-A-Number.</p> + </dd> + <dt>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</dt> + <dd> + <p>The <code><strong>parseFloat()</strong></code> function parses a string argument and returns a floating point number.</p> + </dd> + <dt>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</dt> + <dd> + <p>The <code><strong>parseInt()</strong></code> function parses a string argument and returns an integer of the specified radix (the base in mathematical numeral systems).</p> + </dd> + <dt>{{jsxref("Global_Objects/decodeURI", "decodeURI()")}}</dt> + <dd> + <p>The <code><strong>decodeURI()</strong></code> function decodes a Uniform Resource Identifier (URI) previously created by {{jsxref("Global_Objects/encodeURI", "encodeURI")}} or by a similar routine.</p> + </dd> + <dt>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent()")}}</dt> + <dd> + <p>The <code><strong>decodeURIComponent()</strong></code> method decodes a Uniform Resource Identifier (URI) component previously created by {{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent")}} or by a similar routine.</p> + </dd> + <dt>{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}</dt> + <dd> + <p>The <code><strong>encodeURI()</strong></code> method encodes a Uniform Resource Identifier (URI) by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two "surrogate" characters).</p> + </dd> + <dt>{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}</dt> + <dd> + <p>The <code><strong>encodeURIComponent()</strong></code> method encodes a Uniform Resource Identifier (URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two "surrogate" characters).</p> + </dd> + <dt>{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline}}</dt> + <dd> + <p>The deprecated <code><strong>escape()</strong></code> method computes a new string in which certain characters have been replaced by a hexadecimal escape sequence. Use {{jsxref("Global_Objects/encodeURI", "encodeURI")}} or {{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent")}} instead.</p> + </dd> + <dt>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline}}</dt> + <dd> + <p>The deprecated <code><strong>unescape()</strong></code> method computes a new string in which hexadecimal escape sequences are replaced with the character that it represents. The escape sequences might be introduced by a function like {{jsxref("Global_Objects/escape", "escape")}}. Because <code>unescape()</code> is deprecated, use {{jsxref("Global_Objects/decodeURI", "decodeURI()")}} or {{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent")}} instead.</p> + </dd> +</dl> + +<p>{{PreviousNext("Web/JavaScript/Guide/Loops_and_iteration", "Web/JavaScript/Guide/Expressions_and_Operators")}}</p> diff --git a/files/pl/web/javascript/guide/index.html b/files/pl/web/javascript/guide/index.html new file mode 100644 index 0000000000..c4d51fad14 --- /dev/null +++ b/files/pl/web/javascript/guide/index.html @@ -0,0 +1,122 @@ +--- +title: Przewodnik JavaScript +slug: Web/JavaScript/Guide +tags: + - JavaScript + - Przewodnik JavaScript +translation_of: Web/JavaScript/Guide +--- +<div>{{jsSidebar("JavaScript Guide")}}</div> + +<p class="summary">Przewodnik JavaScript pokazuje jak używać <a href="/en-US/docs/Web/JavaScript">JavaScript</a> oraz pokazuje ogólny przegląd języka. Jeśli potrzebujesz wyczerpujących informacji o konkretnej funkcjonalności zajrzyj do <a href="/en-US/docs/Web/JavaScript/Reference">JavaScript reference</a>.</p> + +<h2 id="Rozdziały">Rozdziały</h2> + +<p>Ten przewodnik jest podzielony na kilka rozdziałów:</p> + +<ul class="card-grid"> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Introduction">Wprowadzenie</a></span> + + <p><a href="/en-US/docs/Web/JavaScript/Guide/Introduction#Where_to_find_JavaScript_information">O tym przewodniku</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Introduction#What_is_JavaScript">O JavaScript</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Introduction#JavaScript_and_Java">JavaScript i Java</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Introduction#JavaScript_and_the_ECMAScript_Specification">ECMAScript</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Introduction#Getting_started_with_JavaScript">Narzędzia</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Introduction#Hello_world">Hello World</a></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_types">Gramatyka i typy</a></span> + <p><a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Basics">Podstawy składni i komentarze</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Declarations">Deklaracje</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Variable_scope">Zakres zmiennej</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Variable_hoisting">Podnoszenie (hoisting) zmiennej</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Data_structures_and_types">Struktury i typy danych</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Literals">Literały</a></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Control_flow_and_error_handling">Kontrola przepływu i obsługa błędów</a></span> + <p><code><a href="/en-US/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#if...else_statement">if...else</a></code><br> + <code><a href="/en-US/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#switch_statement">switch</a></code><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#Exception_handling_statements"><code>try</code>/<code>catch</code>/<code>throw</code></a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#Utilizing_Error_objects">Obiekty Error</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#Promises">Obietnice (Promises)</a></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration">Pętle i iteracje</a></span> + <p><code><a href="/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration#for_statement">for</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration#while_statement">while</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration#do...while_statement">do...while</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration#break_statement">break</a>/<a href="/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration#continue_statement">continue</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration#for...in_statement">for..in</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration#for...of_statement">for..of</a></code></p> + </li> +</ul> + +<ul class="card-grid"> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Functions">Funkcje</a></span> + + <p><a href="/en-US/docs/Web/JavaScript/Guide/Functions#Defining_functions">Definiowanie funkcji</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Functions#Calling_functions">Wywołanie funkcji</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Functions#Function_scope">Zakres funkcji</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Functions#Closures">Domknięcia</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Functions#Using_the_arguments_object">Argumenty </a>i <a href="/en-US/docs/Web/JavaScript/Guide/Functions#Function_parameters">parametry</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Functions#Arrow_functions">Funkcje strzałkowe</a></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators">Wyrażenia i operatory</a></span> + <p><a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Assignment_operators">Przypisanie</a> i <a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Comparison_operators">Porównanie</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Arithmetic_operators">Operatory arytmetyczne</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Bitwise_operators">Bitowe</a> i <a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Logical_operators">logiczne operatory</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Conditional_(ternary)_operator">Operator warunkowy (potrójny)</a></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Numbers_and_dates">Numery i daty</a></span><a href="/en-US/docs/Web/JavaScript/Guide/Numbers_and_dates#Numbers"> Literały numeryczne</a> + <p><a href="/en-US/docs/Web/JavaScript/Guide/Numbers_and_dates#Number_object">Obiekt <code>Number</code></a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Numbers_and_dates#Math_object">Obiekt <code>Math</code></a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Numbers_and_dates#Date_object">Obiekt <code>Date</code></a></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Text_formatting">Formatowanie tekstu</a></span> + <p><a href="/en-US/docs/Web/JavaScript/Guide/Text_formatting#String_literals">Literały String</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Text_formatting#String_objects">Obiekt <code>String</code></a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Text_formatting#Multi-line_template_literals">Literały szablonowe</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Text_formatting#Internationalization">Umiędzynarodowienie</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Wyrażenia regularne</a></p> + </li> +</ul> + +<ul class="card-grid"> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections">Kolekcje indeksowane</a></span> + + <p><a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Array_object">Tablice</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Typed_Arrays">Tablice typowane</a></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Keyed_collections">Kolekcje z kluczem (Keyed collections)</a></span> + <p><code><a href="/en-US/docs/Web/JavaScript/Guide/Keyed_collections#Map_object">Map</a></code><br> + <code><a href="/en-US/docs/Web/JavaScript/Guide/Keyed_collections#WeakMap_object">WeakMap</a></code><br> + <code><a href="/en-US/docs/Web/JavaScript/Guide/Keyed_collections#Set_object">Set</a></code><br> + <code><a href="/en-US/docs/Web/JavaScript/Guide/Keyed_collections#WeakSet_object">WeakSet</a></code></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects">Praca z obiektami</a></span> + <p><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Objects_and_properties">Obiekty i właściwości</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">Tworzenie obiektów</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_methods">Definiowanie metiod</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Gettery i settery</a></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model">Szegóły i model obiektowy</a></span> + <p><a href="/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#Class-based_vs._prototype-based_languages">OOP bazujące na prototypach</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#Creating_the_hierarchy">Tworzenie hierarchii obiektów</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#Property_inheritance_revisited">Dziedziczenie</a></p> + </li> +</ul> + +<ul class="card-grid"> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iteratory i generatory</a></span> + + <p><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Iterators">Iteratory</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Iterables">Iterables (Obiekty dające się powtórzyć)</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators">Generatory</a></p> + </li> + <li><span><a href="/en-US/docs/Web/JavaScript/Guide/Meta_programming">Meta programowanie</a></span> + <p><code><a href="/en-US/docs/Web/JavaScript/Guide/Meta_programming#Proxies">Proxy</a></code><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Meta_programming#Handlers_and_traps">Handlery i pułapki</a><br> + <a href="/en-US/docs/Web/JavaScript/Guide/Meta_programming#Revocable_Proxy">Odwołalne Proxy</a><br> + <code><a href="/en-US/docs/Web/JavaScript/Guide/Meta_programming#Reflection">Reflect</a></code></p> + </li> +</ul> + +<p>{{Next("Web/JavaScript/Guide/Introduction")}}</p> diff --git a/files/pl/web/javascript/guide/introduction/index.html b/files/pl/web/javascript/guide/introduction/index.html new file mode 100644 index 0000000000..d223e18f8b --- /dev/null +++ b/files/pl/web/javascript/guide/introduction/index.html @@ -0,0 +1,150 @@ +--- +title: Wstęp +slug: Web/JavaScript/Guide/Introduction +tags: + - JavaScript +translation_of: Web/JavaScript/Guide/Introduction +--- +<p> </p> + +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Grammar_and_types")}}</div> + +<p class="summary">Ten rozdział służy jako wprowadzenie do języka JavaScript i omawia jego fundamentalne koncepcje. </p> + +<h2 id="Co_powinieneś_wiedzieć_by_zacząć">Co powinieneś wiedzieć, by zacząć?</h2> + +<p>Ten poradnik zakłada, że posiadasz podstawową wiedzę w takich obszarach, jak:</p> + +<ul> + <li>Koncepcja Internetu oraz sieci ({{Glossary("WWW")}});</li> + <li>Praktyczne wiadomości na temat języka HyperTextMarkup Language ({{Glossary("HTML")}})</li> + <li>Podstawowe doświadczenie w programowaniu. Jeżeli nigdy dotąd nie miałeś styczności z programowaniem, wypróbuj jeden z naszych poradników na temat języka <a href="/pl/docs/Web/JavaScript" title="/en-US/docs/">JavaScript</a>, który znajdziesz na głównej stronie.</li> +</ul> + +<h2 id="Gdzie_szukać_informacji_na_temat_języka_JavaScript">Gdzie szukać informacji na temat języka JavaScript?</h2> + +<p>Dokumentacja języka JavaScript w MDN zawiera:</p> + +<ul> + <li>Poradnik <a href="/pl/Learn">Learning the Web</a>, który zawiera informacje dla początkujących oraz wprowadza podstawowe pojęcia dotyczące Internetu, a także programowania.</li> + <li>Poradnik <a href="/pl/docs/Web/JavaScript/Guide" title="pl/Core_JavaScript_1.5_Guide">JavaScript Guide</a> (ten poradnik) służy jako przegląd możliwości i celów posługiwania się językiem JavaScript. </li> + <li><a href="/pl/docs/Web/JavaScript/Referencje" title="pl/JavaScript/Reference">JavaScript Reference</a> dostarcza szczegółowych informacji o języku JavaScript.</li> +</ul> + +<p>Jeżeli nigdy nie miałeś kontaktu z językiem Javascript, zacznij od artykułów w <a href="/pl/Learn">strefie nauki</a> i<a href="/en-US/docs/Web/JavaScript/Guide" title="en/Core_JavaScript_1.5_Guide"> JavaScript Guide</a>. Kiedy poznasz fundamentalne zasady działania języka, będziesz mógł poszerzać wiedzę dzięki <a href="/pl/docs/Web/JavaScript/Reference" title="en/JavaScript/Reference">JavaScript Reference</a>, gdzie znajdziesz kody źródłowe i szczegółowe opisy pojedynczych zagadnień.</p> + +<h2 id="Czym_jest_JavaScript">Czym jest JavaScript?</h2> + +<p>JavaScript to wieloplatformowy, zorientowany obiektowo język skryptowy, który cechuje lekkość i szybkość działania. W środowiskach developerskich może zostać połączony z konkretnymi obiektami tak, by zapewnić nad nimi łatwą i przejrzystą kontrolę.</p> + +<p>Język JavaScript zawiera standardową bibliotekę, w której zdefiniowano podstawowe elementy w postaci operatorów, struktur i instrukcji oraz obiektów takich, jak: <code>Array, Date i Math</code>. Standardowa biblioteka może być rozszerzana poprzez dodawanie nowych obiektów tak, by ułatwić programiście dopasowanie języka do jego potrzeb. Na przykład:</p> + +<ul> + <li><em>JavaScript</em> <em>po stronie klienta</em> został rozszerzony poprzez wprowadzenie mechanizmów kontroli przeglądarki i jej modelu DOM. Rozszerzenia te umożliwiają każdej aplikacji umieszczanie elementów w formularzach HTML, a także reakcję na wydarzenia wywoływane przez użytkownika, takie, jak: kliknięcie myszką, wpisywanie danych oraz nawigacja po stronie. </li> + <li><em>JavaScript po stronie serwera </em>został rozszerzony poprzez dodanie elementów, które umożliwiają komunikację z bazą danych, manipulację plikami na serwerze oraz zawierają sposoby na zapewnienie integralności informacji wymienianej między poszczególnymi elementami aplikacji. </li> +</ul> + +<h2 id="JavaScript_and_Java" name="JavaScript_and_Java">JavaScript i Java</h2> + +<p>Języki JavaScript i Java cechuje pewne podobieństwo, lecz dzielą fundamentalne różnice. Kod napisany w JavaScript może początkującemu programiście przypominać język Java, ale w przeciwieństwie do niego nie jest statycznie silnie typowany. Składnia obu języków, a także niektóre konwencje, są zbliżone, dlatego początkowa nazwa języka - LiveScript - została zmieniona na: JavaScript. </p> + +<p>W przeciwieństwie do klasowego, kompilowanego systemu Javy, JavaScript jest językiem interpretowanym, opartym na małej liczbie podstawowych typów danych reprezentujących wartości numeryczne (Boolean i string). Obiektowość w JavaScript bazuje na prototypach, które zapewniają dynamiczne dziedziczenie. Umożliwia to programiście wybieranie konkretnych metod i atrybutów, które mają zostać przekazane. Jest to spora różnica względem Javy, która opiera się na modelu dziedziczenia, w którym główną rolę odgrywają klasy. Różnica między językami zachodzi też w podejściu do funkcji - w JavaScript mogą być one atrybutami obiektów, co powoduje, że traktowane są wtedy jako słabo typowane metody. </p> + +<p>JavaScript daje programiście większą wolność w tworzeniu kodu - nie musimy deklarować wszystkich zmiennych, klas ani metod. Nie musimy też zastanawiać się, czy dana metoda powinna być prywatna, publiczna czy chroniona, ani tworzyć interfejsów. Typy zmiennych, parametrów i zwracanych przez funkcje wartości nie są formalnie zdefiniowane. </p> + +<p>Java służy do budowania aplikacji opartych na klasach, które cechują się szybkością działania i zachowaniem typów danych. Oznacza to, że nie możemy przekazać zmiennej typu integer jako referencji do obiektu, ani uzyskać dostępu do pamięci przez uszkodzenie kodu wykonywalnego Javy. Klasowy model obiektowości w Javie oznacza, że programy zbudowane są wyłącznie z klas i ich metod, a dziedziczenie zaimplementowane w tym języku wymaga ściśle powiązanych ze sobą hierarchi. Wszystkie te cechy sprawiają, że Java jest o wiele bardziej skomplikowanym i wymagającym językiem w porównaniu do JavaScript. </p> + +<p>JavaScript jest duchowym spadkobiercą małych, dynamicznie typowanych języków, takich, jak: HyperTalk i dBASE. Te języki skryptowe oferują narzędzia bardziej dostępne dla przeciętnego programisty ze względu na prostą składnię, wyspecjalizowane funkcjonalności i minimalne wymagania w celu tworzenia nowych obiektów. </p> + +<table class="standard-table"> + <caption>JavaScript w porównaniu do Javy</caption> + <thead> + <tr> + <th scope="col">JavaScript</th> + <th scope="col">Java</th> + </tr> + </thead> + <tbody> + <tr> + <td> + <p>Zorientowany obiektowo. Bez rozróżnienia na typy obiektów. Dziedziczenie poprzez mechanizm prototypów, atrybuty i metody klas mogą być dodawane dynamicznie.</p> + </td> + <td> + <p>Zorientowany klasowo. Obiekty podzielone są na klasy i instancje, z dziedziczeniem poprzez ich hierarchie. Atrybuty i metody klas nie mogą być dodawane dynamicznie. </p> + </td> + </tr> + <tr> + <td> + <p>Typy zmiennych nie są deklarowane (dynamiczne typowanie).</p> + </td> + <td> + <p>Typy zmiennych muszą być deklarowane (statyczne typowanie)</p> + </td> + </tr> + <tr> + <td> + <p>Nie może automatycznie zapisywać danych na dysk twardy.</p> + </td> + <td> + <p>Może automatycznie zapisywać dane na dysk twardy.</p> + </td> + </tr> + </tbody> +</table> + +<p>Więcej informacji na temat różnic między tymi językami znajdziesz w rozdziale: <a href="/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model" title="JavaScript/Guide/Details of the Object Model">Details of the object model</a>.</p> + +<h2 id="JavaScript_and_the_ECMAScript_Specification" name="JavaScript_and_the_ECMAScript_Specification">JavaScript i specyfikacja EMCAScript</h2> + +<p>Specyfikacja JavaScript definiowana jest przez <a class="external" href="http://www.ecma-international.org/">Ecma International</a>, stowarzyszenie zajmujące się standaryzacją systemów informatycznych w Europie. Owa standaryzacja ma na celu zapewnienie jednolitości języka, który powinien zachowywać się w ten sam sposób w każdej aplikacji wspierającej ten standard. Wersja JavaScript działająca według tej specyfikacji zwana jest ECMAScript. Otwarty standard zapewnia możliwość wprowadzania przez firmy swoich implementacji w oparciu o podstawowy model. Pełna specyfikacja standardu ECMAScript została zaprezentowana w dokumencie ECMA-262. Aby dowiedzieć się więcej o wydaniach języka JavaScript i specyfikacji ECMAScript, zajrzyj do artykułu: <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript">New in JavaScript</a>.</p> + +<p>Standard ECMA-262 został zatwierdzony przez <a class="external" href="http://www.iso.ch/">ISO</a> (Międzynarodowa Organizacja Normalizacyjna) jako ISO-16262. Specyfikację możesz znaleźć na <a class="external" href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">stronie stowarzyszenia ECMA</a>, jednakże nie przedstawia ona modelu DOM, który został ustandaryzowany przez <a class="external" href="http://www.w3.org/">World Wide Web Consortium (W3C)</a>. Model ten pełni bardzo ważną funkcję, gdyż definiuje, w jaki sposób elementy dokumentu HTML dostępne są dla twoich skryptów. By znaleźć więcej informacji o różnych technologiach wykorzystywanych podczas pracy z językiem JavaScript, zerknij na artykuł: <a href="/en-US/docs/Web/JavaScript/JavaScript_technologies_overview">JavaScript technologies overview</a>.</p> + +<h3 id="JavaScript_Documentation_versus_the_ECMAScript_Specification" name="JavaScript_Documentation_versus_the_ECMAScript_Specification">Dokumentacja JavaScript kontra specyfikacja ECMAScript</h3> + +<p>Specyfikacja ECMAScript precyzuje zestaw wymagań dla implementacji ECMAScript, co przydaje się, gdy chcemy zgodnie z obowiązującym standardem zaimplementować funkcje języka lub stworzyć własny silnik (taki, jak SpiderMonkey w Firefox lub v8 w przeglądarce Chrome).</p> + +<p>Jednakże dokument ECMAScript nie powstał po to, by pomóc programiście w pisaniu aplikacji - w tym celu wykorzystuj dokumentacje JavaScript.</p> + +<p>W specyfikacji ECMAScript używana składnia i terminologia początkowo mogą być obce dla programisty JavaScript, natomiast nadal jest to ten sam język. JavaScript wspiera każdą funkcjonalność, której ramy zostały nakreślone w tej specyfikacji. </p> + +<p>Dokumentacja JavaScript opisuje wszystkie aspekty języka, które mogą być wykorzystane bezpośrednio przez programistę. </p> + +<h2 id="Pierwsze_kroki_w_języku_JavaScript">Pierwsze kroki w języku JavaScript</h2> + +<p>By zacząć pracę z JavaScript, jedyne, czego potrzebujesz, to nowoczesna przeglądarka. Ten poradnik wykorzystuje funkcje, które są dostępne tylko w najnowszych wersjach Firefox, dlatego zadbaj o to, by twoja wersja przeglądarki była zaktualizowana. </p> + +<p>W Firefox wbudowane zostały dwie funkcje znacząco ułatwiające eksperymentowanie z JavaScript - mowa tutaj o konsoli przeglądarki i brudnopisie. </p> + +<h3 id="Konsola_WWW">Konsola WWW</h3> + +<p>Konsola pozwala obserwować informacje o odwiedzanej przez ciebie stronie i umożliwia wykonywanie skryptów przez wiersz poleceń. </p> + +<p>By otworzyć konsolę, z panelu opcji wybierz: "Narzędzia", a następnie: "Konsola WWW" - wtedy powinna się pojawić na dole twojego okna. Pasek wiersza poleceń, w którym możesz uruchamiać swój kod JavaScript, umieszczony jest na dole konsoli, w miejscu wskazanym na obrazku:</p> + +<p><img alt="" src="https://mdn.mozillademos.org/files/7363/web-console-commandline.png" style="display: block; margin-left: auto; margin-right: auto;"></p> + +<h3 id="Brudnopis">Brudnopis</h3> + +<p>Konsola WWW jest świetna, kiedy chcemy tworzyć pojedyncze linijki skryptów, ale pomimo tego, że możliwe jest wykonywanie dłuższego kodu, rozwiązanie to nie jest wygodne. Konsola nie daje możliwości zapisywania fragmentów kodu, którego używamy. W tym przypadku do pomocy wykorzystamy brudnopis, który stworzony został do pracy z bardziej skomplikowanymi przykładami.</p> + +<p>By otworzyć brudnopis, z panelu opcji wybierz: "Narzędzia", a następnie: "Brudnopis" - powinno się otworzyć nowe okno przeglądarki wraz z edytorem tekstu, który umożliwia pisanie i tworzenie kodu JavaScript bezpośrednio w przeglądarce. Możesz także zapisywać i ładować swoje skrypty prosto z dysku twardego. </p> + +<p>Po naciśnięciu przycisku: "Wyświetl", znajdującego się w górnej części okienka, twój kod zostanie wykonany i umieszczony w edytorze jako komentarz:</p> + +<p><img alt="" src="https://mdn.mozillademos.org/files/7365/scratchpad.png" style="display: block; margin-left: auto; margin-right: auto;"></p> + +<h3 id="Hello_world">Hello world</h3> + +<p>Swoją przygodę z językiem JavaScript rozpocznij od otworzenia konsoli WWW lub brudnopisu i napisania pierwszego skryptu: "Hello world".</p> + +<pre class="brush: js">function greetMe(user) { + return "Witaj " + user; +} + +greetMe("Alice"); // "Witaj Alice" +</pre> + +<p>Na następnych stronach poradnika wprowadzimy cię w składnię JavaScript i pokażemy zestaw możliwości dostarczanych przez ten język, by umożliwić ci napisanie bardziej skomplikowanych aplikacji.</p> + +<p>{{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Grammar_and_types")}}</p> diff --git a/files/pl/web/javascript/guide/iterators_and_generators/index.html b/files/pl/web/javascript/guide/iterators_and_generators/index.html new file mode 100644 index 0000000000..236d360a92 --- /dev/null +++ b/files/pl/web/javascript/guide/iterators_and_generators/index.html @@ -0,0 +1,165 @@ +--- +title: Iterators and generators +slug: Web/JavaScript/Guide/Iterators_and_Generators +tags: + - JavaScript + - Przewodnik +translation_of: Web/JavaScript/Guide/Iterators_and_Generators +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Details_of_the_Object_Model", "Web/JavaScript/Guide/Meta_programming")}}</div> + +<p class="summary">Przetwarzanie każdego elementu w kolekcji jest bardzo popularną operacją. JavaScript daje wiele możliwości iteracji przez elementy kolekcji: od prostej pętli {{jsxref("Polecenia/for","for")}} do {{jsxref("Obiekty/Array/map","map()")}} i {{jsxref("Obiekty/Array/filter","filter()")}}. Iteratory i Generatory wnoszą pojęcie interacji bezpośredno w natywne funkcjonalności języka i dają możliwość do dostosowania zachowania pętli {{jsxref("Polecenia/for...of","for...of")}}.</p> + +<p>Zobacz także:</p> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> + <li>{{jsxref("Polecenia/for...of","for...of")}}</li> + <li>{{jsxref("Polecenia/function*","function*")}} i {{jsxref("Obiekty/Generator","Generator")}}</li> + <li>{{jsxref("Operatory/yield","yield")}} i {{jsxref("Operatory/yield*","yield*")}}</li> +</ul> + +<h2 id="Iteratory">Iteratory</h2> + +<p>Obiekt jest <strong>iteratorem</strong> kiedy wie jak uzyskać dostęp do elementów z kolekcji pojedynczo, podczas gdy śledzi swoją obecną pozycję w tej sekwencji. W języku JavaScript iterator jest obiektem który dostarcza metodę next(), która zwraca następny obiekt w tej sekwencji. Ta metoda zwraca obiekt z dwoma właściwościami: <code>done</code> i <code>value</code>.</p> + +<p>Po utworzeniu, obiekt iteratora może być użyty jawnie przez powtarzanie wywołania metody next().</p> + +<pre class="brush: js">function makeIterator(array) { + var nextIndex = 0; + + return { + next: function() { + return nextIndex < array.length ? + {value: array[nextIndex++], done: false} : + {done: true}; + } + }; +}</pre> + +<p>Po inicjalizacji metoda next() może być wywołana w celu dostępu do par klucz-wartość z obiektu:</p> + +<pre class="brush: js">var it = makeIterator(['yo', 'ya']); +console.log(it.next().value); // 'yo' +console.log(it.next().value); // 'ya' +console.log(it.next().done); // true</pre> + +<h2 id="Generatory">Generatory</h2> + +<p>Pomimo tego, że iteratory są przydatnym narzędziem, ich utworzenie wymaga ostrożnego podejścia, ze względu na potrzebę jawnego utrzymywania ich wewnętrznego stanu. <strong>{{jsxref("Obiekty/Generator","Generators","","true")}}</strong> zapewnia mocną alternatywę: pozwalają one zdefiniować programiście iteratywny algorytm poprzez utworzenie pojedynczej funkcji, która jest wstanie utrzymywać swój wewnętrzny stan.</p> + +<p>Generator jest specjalnym typem funkcji, która działa jako fabryka dla iteratorów. Funkcja staje się generatorem, gdy zawiera przynajmniej jedno{{jsxref("Operatory/yield","yield")}} wyrażenie oraz gdy używa {{jsxref("Polecenia/function*","function*")}}.</p> + +<pre class="brush: js">function* idMaker() { + var index = 0; + while(true) + yield index++; +} + +var gen = idMaker(); + +console.log(gen.next().value); // 0 +console.log(gen.next().value); // 1 +console.log(gen.next().value); // 2 +// ...</pre> + +<h2 id="Iterables">Iterables</h2> + +<p>An object is <strong>iterable</strong> if it defines its iteration behavior, such as what values are looped over in a {{jsxref("Polecenia/for...of", "for..of")}} construct. Some built-in types, such as {{jsxref("Array")}} or {{jsxref("Map")}}, have a default iteration behavior, while other types (such as {{jsxref("Object")}}) do not.</p> + +<p>In order to be <strong>iterable</strong>, an object must implement the <strong>@@iterator</strong> method, meaning that the object (or one of the objects up its <a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">prototype chain</a>) must have a property with a {{jsxref("Symbol.iterator")}} key:</p> + +<h3 id="User-defined_iterables">User-defined iterables</h3> + +<p>We can make our own iterables like this:</p> + +<pre class="brush: js">var myIterable = {}; +myIterable[Symbol.iterator] = function* () { + yield 1; + yield 2; + yield 3; +}; + +for (let value of myIterable) { + console.log(value); +} +// 1 +// 2 +// 3 + +or + +[...myIterable]; // [1, 2, 3] +</pre> + +<h3 id="Built-in_iterables">Built-in iterables</h3> + +<p>{{jsxref("String")}}, {{jsxref("Array")}}, {{jsxref("TypedArray")}}, {{jsxref("Map")}} and {{jsxref("Set")}} are all built-in iterables, because the prototype objects of them all have a {{jsxref("Symbol.iterator")}} method.</p> + +<h3 id="Syntaxes_expecting_iterables">Syntaxes expecting iterables</h3> + +<p>Some statements and expressions are expecting iterables, for example the {{jsxref("Polecenia/for...of","for-of")}} loops, {{jsxref("Operatory/Spread_operator","spread operator","","true")}}, {{jsxref("Operatory/yield*","yield*")}}, and {{jsxref("Operatory/Destructuring_assignment","destructuring assignment","","true")}}.</p> + +<pre class="brush: js">for (let value of ['a', 'b', 'c']) { + console.log(value); +} +// "a" +// "b" +// "c" + +[...'abc']; // ["a", "b", "c"] + +function* gen() { + yield* ['a', 'b', 'c']; +} + +gen().next(); // { value: "a", done: false } + +[a, b, c] = new Set(['a', 'b', 'c']); +a; // "a" + +</pre> + +<h2 id="Advanced_generators">Advanced generators</h2> + +<p>Generators compute their yielded values on demand, which allows them to efficiently represent sequences that are expensive to compute, or even infinite sequences as demonstrated above.</p> + +<p>The {{jsxref("Obiekty/Generator/next","next()")}} method also accepts a value which can be used to modify the internal state of the generator. A value passed to <code>next()</code> will be treated as the result of the last <code>yield</code> expression that paused the generator.</p> + +<p>Here is the fibonacci generator using <code>next(x)</code> to restart the sequence:</p> + +<pre class="brush: js">function* fibonacci() { + var fn1 = 0; + var fn2 = 1; + while (true) { + var current = fn1; + fn1 = fn2; + fn2 = current + fn1; + var reset = yield current; + if (reset) { + fn1 = 0; + fn2 = 1; + } + } +} + +var sequence = fibonacci(); +console.log(sequence.next().value); // 0 +console.log(sequence.next().value); // 1 +console.log(sequence.next().value); // 1 +console.log(sequence.next().value); // 2 +console.log(sequence.next().value); // 3 +console.log(sequence.next().value); // 5 +console.log(sequence.next().value); // 8 +console.log(sequence.next(true).value); // 0 +console.log(sequence.next().value); // 1 +console.log(sequence.next().value); // 1 +console.log(sequence.next().value); // 2</pre> + +<p>You can force a generator to throw an exception by calling its {{jsxref("Obiekty/Generator/throw","throw()")}} method and passing the exception value it should throw. This exception will be thrown from the current suspended context of the generator, as if the <code>yield</code> that is currently suspended were instead a <code>throw <em>value</em></code> statement.</p> + +<p>If a <code>yield</code> is not encountered during the processing of the thrown exception, then the exception will propagate up through the call to <code>throw()</code>, and subsequent calls to <code>next()</code> will result in the <code>done</code> property being <code>true</code>.</p> + +<p>Generators have a {{jsxref("Obiekty/Generator/return","return(value)")}} method that returns the given value and finishes the generator itself.</p> + +<p>{{PreviousNext("Web/JavaScript/Guide/Details_of_the_Object_Model", "Web/JavaScript/Guide/Meta_programming")}}</p> diff --git a/files/pl/web/javascript/guide/loops_and_iteration/index.html b/files/pl/web/javascript/guide/loops_and_iteration/index.html new file mode 100644 index 0000000000..a53f1a9016 --- /dev/null +++ b/files/pl/web/javascript/guide/loops_and_iteration/index.html @@ -0,0 +1,332 @@ +--- +title: Pętle i iteracje +slug: Web/JavaScript/Guide/Loops_and_iteration +translation_of: Web/JavaScript/Guide/Loops_and_iteration +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Control_flow_and_error_handling", "Web/JavaScript/Guide/Functions")}}</div> + +<p class="summary">Za pomocą pętli możemy w łatwy sposób powtarzać pewne czynności. Ten rodział <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a> zapoznaje z różnymi rodzajami pętli, dostępnymi w JavaScript.</p> + +<p>Możesz myśleć o pętli jak o skomputeryzowanej wersji gry w której mówisz komuś, żeby zrobił X kroków w jedym kierunku a następnie Y kroków w innym; przykład "Zrób 5 kroków na zachód" może być wyrażone za pomocą pętli w ten sposób:</p> + +<pre class="brush: js">var step; +for (step = 0; step < 5; step++) { + // Uruchamia się 5 razy, z wartościami od 0 do 4. + console.log('Idę na zachód jeden krok'); +} +</pre> + +<p>Jest wiele różnych rodzajów pętli, lecz zwykle wszystkie robią to samo: powtarzają zadaną akcję pewną ilość razy (liczba powtórzeń może także wynosić 0). Różne mechanizmy pętli oferują różne sposoby określania początku i końca pętli. W różnych sytuacjach łatwiej jest użyć danego typu pętli niż innego.</p> + +<p>Wyrażenia dla pętli obsługiwane w JavaScript:</p> + +<ul> + <li>{{anch("for")}}</li> + <li>{{anch("do...while")}}</li> + <li>{{anch("while")}}</li> + <li>{{anch("label")}}</li> + <li>{{anch("break")}}</li> + <li>{{anch("continue")}}</li> + <li>{{anch("for...in")}}</li> + <li>{{anch("for...of")}}</li> +</ul> + +<h2 id="for"><code>for</code></h2> + +<p>Pętla <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for">for</a></code> powtarza wykonie instrukcji, dopóki dostarczony warunek nie zwraca false. Pętla for w JavaScript jest podobna do tej z języków Java czy C. Składnia tej pętli wygląda następująco:</p> + +<pre class="syntaxbox">for ([wyrażenieInicjalizacji]; [warunek]; [wyrażenieInkrementacji]) + Instrukcja +</pre> + +<p>Podczas wykonywania się pętli for, mają miejsce następujące operacje:</p> + +<ol> + <li> Wykonywane jest wyrażenie <code>wyrażenieInicjalizacji</code>, o ile takie istnieje. Zazwyczaj w tym miejscu inicjalizuje się zmienne, które posłużą później jako liczniki dla pętli.</li> + <li> Sprawdzana jest wartość zwracana przez wyrażenie <code>warunek</code>, jeśli jest to true, pętla będzie wykonywać się dalej. Jeśli z kolei będzie to false, pętla zostanie przerwana. W przypadku nie podania żadnego wyrażenia warunkowego, pętla będzie traktować to jako true.</li> + <li>Wykonuje się <code>Instrukcja</code>. W celu wykonania wielu instrukcji w jednym przebiegu pętli, należy je zgrupować i umieścić w bloku ( <code>{ ... }</code> ).</li> + <li> Wykonywane zostaje <code>wyrażenie inkrementacji</code>, o ile istnieje. W tym miejscu powiększamy wartość licznika pętli.</li> + <li>Zarządzanie pętlą wraca do kroku 2.</li> +</ol> + +<h3 id="Przykład"><strong>Przykład</strong></h3> + +<p>Następująca funkcja zawiera pętle <code>for</code>, która zlicza elementy <option> w rozwijalnej liście <select>. W pętli zostaje zadeklarowana zmienna <code>i</code> z wartością 0. Sprawdza czy <code>i</code> jest mniejsze niż liczba elementów <option>, wykonuje kod wewnątrz i zwiększa wartość <code>i </code>po każdym przebiegu.</p> + +<pre class="brush: html"><form name="selectForm"> + <p> + <label for="musicTypes">Choose some music types, then click the button below:</label> + <select id="musicTypes" 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 id="btn" type="button" value="How many are selected?" /></p> +</form> + +<script> +function howMany(selectObject) { + var numberSelected = 0; + for (var i = 0; i < selectObject.options.length; i++) { + if (selectObject.options[i].selected) { + numberSelected++; + } + } + return numberSelected; +} + +var btn = document.getElementById("btn"); +btn.addEventListener("click", function(){ + alert('Number of options selected: ' + howMany(document.selectForm.musicTypes)) +}); +</script> + +</pre> + +<h2 id="do...while"><code>do...while</code></h2> + +<p><code><font face="Open Sans, Arial, sans-serif">Pętla </font><a href="/en-US/docs/Web/JavaScript/Reference/Statements/do...while">do...while</a></code> powtarza <code>instrukcje</code> wewnątrz, dopóki <code>warunek</code> nie zwróci false. Wygląda to następująco:</p> + +<pre class="syntaxbox">do + instrukcja +while (warunek); +</pre> + +<p>Możemy skorzystać z wyrażenia bloku (<code>{ ... }</code>), by zgrupować wiele instrukcji. Na końcu wykonywania instrukcji sprawdzany jest warunek. Jeśli zwróci on true, Pętla wykonan się po raz kolejny, z kolei false przerwie pętle. Warto zwrócić uwagę, że ze względu na miejsce umieszczenia warunku, zawsze wykona się ona przynajmniej raz.</p> + +<h3 id="Przykład_2"><strong>Przykład</strong></h3> + +<p>W tym przykładzie pętla będzie iterawoć do momentu kiedy licznik <code>i</code> nie będzie większy od 5.</p> + +<pre class="brush: js">do { + i += 1; + console.log(i); +} while (i < 5);</pre> + +<h2 id="while"><code>while</code></h2> + +<p>Pętla <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/while">while</a></code> wykonuje się dopóki podany warunek zwraca true. Składnia jest następująca:</p> + +<pre class="syntaxbox">while (warunek) + instrukcja +</pre> + +<p>Jeśli <code>warunek</code> zwróci false, pętla zostaje zatrzymana. W odróżniu od pętli <code>do ... while</code>, sprawdzania warunku mamy na początku. Oznacza to, że jeśli warunek na start zwraca name false, pętla nie wykona się ani razu.</p> + +<p>W tym przypadku również możemy zgrupować instrukcje za pomocą (<code>{ ... }</code>).</p> + +<h3 id="Przykład_1"><strong>Przykład 1</strong></h3> + +<p>Następująca pętla <code>while</code> iteruje tak długo aż n jest mniejszy od 3:</p> + +<pre class="brush: js">n = 0; +x = 0; +while (n < 3) { + n++; + x += n; +} +</pre> + +<p>Z każdą iteracją, pętla inkrementuje wartość n i dodaje ją do x. W związku z tym x i n przyjmują następujące wartości:</p> + +<ul> + <li>Po pierwszym przebiegu: n = 1 i x = 1</li> + <li>Po drugim przebiegu: n = 2 i x = 3</li> + <li>Po trzecim przebiegu: n = 3 i x = 6</li> +</ul> + +<p>Po wykonaniu trzeciego przebiegu, warunek n < 3 nie zwraca już dłużej true, więc pętla zostaje przerwana.</p> + +<h3 id="Przykład_2_2"><strong>Przykład 2</strong></h3> + +<p>Unikaj nieskończonych pętli. Upewnij się, że podany warunek ma możliwośc zwrócenia false; w przeciwnym razie pętla nigdy nie zostanie przerwana, co w najgorszym razie spowoduje zawieszenie przeglądarki.</p> + +<p>Poniższy przykład przedstawia pętla, która nigdy nie zostanie przerwana, ponieważ podany warunek zawsze zwróci true:</p> + +<pre class="brush: js">while (true) { + console.log("Hello, world"); +}</pre> + +<h2 id="label_statement"><code>label</code> statement</h2> + +<p>A <a href="/en-US/docs/Web/JavaScript/Reference/Statements/label">label</a> provides a statement with an identifier that lets you refer to it elsewhere in your program. For example, you can use a label to identify a loop, and then use the <code>break</code> or <code>continue</code> statements to indicate whether a program should interrupt the loop or continue its execution.</p> + +<p>The syntax of the label statement looks like the following:</p> + +<pre class="syntaxbox">label : + statement +</pre> + +<p>The value of <code><em>label</em></code> may be any JavaScript identifier that is not a reserved word. The <code><em>statement</em></code> that you identify with a label may be any statement.</p> + +<h3 id="Example"><strong>Example</strong></h3> + +<p>In this example, the label <code>markLoop</code> identifies a <code>while</code> loop.</p> + +<pre class="brush: js">markLoop: +while (theMark == true) { + doSomething(); +}</pre> + +<h2 id="break_statement"><code>break</code> statement</h2> + +<p>Use the <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/break">break</a></code> statement to terminate a loop, <code>switch</code>, or in conjunction with a label statement.</p> + +<ul> + <li>When you use <code>break</code> without a label, it terminates the innermost enclosing <code>while</code>, <code>do-while</code>, <code>for</code>, or <code>switch</code> immediately and transfers control to the following statement.</li> + <li>When you use <code>break</code> with a label, it terminates the specified labeled statement.</li> +</ul> + +<p>The syntax of the <code>break</code> statement looks like this:</p> + +<ol> + <li><code>break;</code></li> + <li><code>break <em>label</em>;</code></li> +</ol> + +<p>The first form of the syntax terminates the innermost enclosing loop or <code>switch</code>; the second form of the syntax terminates the specified enclosing label statement.</p> + +<h3 id="Example_1"><strong>Example</strong> <strong>1</strong></h3> + +<p>The following example iterates through the elements in an array until it finds the index of an element whose value is <code>theValue</code>:</p> + +<pre class="brush: js">for (i = 0; i < a.length; i++) { + if (a[i] == theValue) { + break; + } +}</pre> + +<h3 id="Example_2_Breaking_to_a_label"><strong>Example 2: </strong>Breaking to a label</h3> + +<pre class="brush: js">var x = 0; +var z = 0 +labelCancelLoops: while (true) { + console.log("Outer loops: " + x); + x += 1; + z = 1; + while (true) { + console.log("Inner loops: " + z); + z += 1; + if (z === 10 && x === 10) { + break labelCancelLoops; + } else if (z === 10) { + break; + } + } +} +</pre> + +<h2 id="continue_statement"><code>continue</code> statement</h2> + +<p>The <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/continue">continue</a></code> statement can be used to restart a <code>while</code>, <code>do-while</code>, <code>for</code>, or <code>label</code> statement.</p> + +<ul> + <li>When you use <code>continue</code> without a label, it terminates the current iteration of the innermost enclosing <code>while</code>, <code>do-while</code>, or <code>for</code> statement and continues execution of the loop with the next iteration. In contrast to the <code>break</code> statement, <code>continue</code> does not terminate the execution of the loop entirely. In a <code>while</code> loop, it jumps back to the condition. In a <code>for</code> loop, it jumps to the <code>increment-expression</code>.</li> + <li>When you use <code>continue</code> with a label, it applies to the looping statement identified with that label.</li> +</ul> + +<p>The syntax of the <code>continue</code> statement looks like the following:</p> + +<ol> + <li><code>continue;</code></li> + <li><code>continue </code><em><code>label;</code></em></li> +</ol> + +<h3 id="Example_1_2"><strong>Example 1</strong></h3> + +<p>The following example shows a <code>while</code> loop with a <code>continue</code> statement that executes when the value of <code>i</code> is three. Thus, <code>n</code> takes on the values one, three, seven, and twelve.</p> + +<pre class="brush: js">i = 0; +n = 0; +while (i < 5) { + i++; + if (i == 3) { + continue; + } + n += i; +} +</pre> + +<h3 id="Example_2"><strong>Example 2</strong></h3> + +<p>A statement labeled <code>checkiandj</code> contains a statement labeled <code>checkj</code>. If <code>continue</code> is encountered, the program terminates the current iteration of <code>checkj</code> and begins the next iteration. Each time <code>continue</code> is encountered, <code>checkj</code> reiterates until its condition returns <code>false</code>. When <code>false</code> is returned, the remainder of the <code>checkiandj</code> statement is completed, and <code>checkiandj</code> reiterates until its condition returns <code>false</code>. When <code>false</code> is returned, the program continues at the statement following <code>checkiandj</code>.</p> + +<p>If <code>continue</code> had a label of <code>checkiandj</code>, the program would continue at the top of the <code>checkiandj</code> statement.</p> + +<pre class="brush: js">checkiandj: + while (i < 4) { + console.log(i); + i += 1; + checkj: + while (j > 4) { + console.log(j); + j -= 1; + if ((j % 2) == 0) { + continue checkj; + } + console.log(j + " is odd."); + } + console.log("i = " + i); + console.log("j = " + j); + }</pre> + +<h2 id="for...in_statement"><code>for...in</code> statement</h2> + +<p>The <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a> statement iterates a specified variable over all the enumerable properties of an object. For each distinct property, JavaScript executes the specified statements. A <code>for...in</code> statement looks as follows:</p> + +<pre class="syntaxbox">for (variable in object) { + statements +} +</pre> + +<h3 id="Example_3"><strong>Example</strong></h3> + +<p>The following function takes as its argument an object and the object's name. It then iterates over all the object's properties and returns a string that lists the property names and their values.</p> + +<pre class="brush: js">function dump_props(obj, obj_name) { + var result = ""; + for (var i in obj) { + result += obj_name + "." + i + " = " + obj[i] + "<br>"; + } + result += "<hr>"; + return result; +} +</pre> + +<p>For an object <code>car</code> with properties <code>make</code> and <code>model</code>, <code>result</code> would be:</p> + +<pre class="brush: js">car.make = Ford +car.model = Mustang +</pre> + +<h3 id="Arrays"><strong>Arrays</strong></h3> + +<p>Although it may be tempting to use this as a way to iterate over {{jsxref("Array")}} elements, the <strong>for...in</strong> statement will return the name of your user-defined properties in addition to the numeric indexes. Thus it is better to use a traditional <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for">for</a></code> loop with a numeric index when iterating over arrays, because the <strong>for...in</strong> statement iterates over user-defined properties in addition to the array elements, if you modify the Array object, such as adding custom properties or methods.</p> + +<h2 id="for...of_statement"><code>for...of</code> statement</h2> + +<p>The <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code> statement creates a loop Iterating over <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/iterable">iterable objects</a> (including {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a> object and so on), invoking a custom iteration hook with statements to be executed for the value of each distinct property.</p> + +<pre class="syntaxbox">for (<em>variable</em> of <em>object</em>) { + <em>statement +</em>}</pre> + +<p>The following example shows the difference between a <code>for...of</code> loop and a <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in" title="en-US/docs/JavaScript/Reference/Statements/for...in">for...in</a></code> loop. While <code>for...in</code> iterates over property names, <code>for...of</code> iterates over property values:</p> + +<pre class="brush:js">let arr = [3, 5, 7]; +arr.foo = "hello"; + +for (let i in arr) { + console.log(i); // logs "0", "1", "2", "foo" +} + +for (let i of arr) { + console.log(i); // logs "3", "5", "7" +} +</pre> + +<p>{{PreviousNext("Web/JavaScript/Guide/Control_flow_and_error_handling", "Web/JavaScript/Guide/Functions")}}</p> diff --git a/files/pl/web/javascript/guide/o_tym_przewodniku/index.html b/files/pl/web/javascript/guide/o_tym_przewodniku/index.html new file mode 100644 index 0000000000..f4a5756dbc --- /dev/null +++ b/files/pl/web/javascript/guide/o_tym_przewodniku/index.html @@ -0,0 +1,138 @@ +--- +title: O tym przewodniku +slug: Web/JavaScript/Guide/o_tym_przewodniku +translation_of: Web/JavaScript/Guide/Introduction +--- +<p>JavaScript jest międzyplatformowym, zorientowanym obiektowo językiem skryptowym. Poniższy przewodnik tłumaczy wszystko, co powinieneś wiedzieć abyś mógł posługiwać się JavaScriptem.</p> + +<h2 id="Nowe_opcje_w_JavaScripcie">Nowe opcje w JavaScripcie</h2> + +<p> </p> + +<ul> + <li><a class="new" href="/pl/docs/Web/JavaScript/New_in_JavaScript/1.2" rel="nofollow">/pl/docs/Web/JavaScript/New_in_JavaScript/1.2</a></li> + <li><a class="new" href="/pl/docs/Web/JavaScript/New_in_JavaScript/1.3" rel="nofollow">/pl/docs/Web/JavaScript/New_in_JavaScript/1.3</a></li> + <li><a class="new" href="/pl/docs/Web/JavaScript/New_in_JavaScript/1.4" rel="nofollow">/pl/docs/Web/JavaScript/New_in_JavaScript/1.4</a></li> + <li><a class="new" href="/pl/docs/Web/JavaScript/New_in_JavaScript/1.5" rel="nofollow">/pl/docs/Web/JavaScript/New_in_JavaScript/1.5</a></li> + <li><a class="new" href="/pl/docs/Web/JavaScript/New_in_JavaScript/1.6" rel="nofollow">/pl/docs/Web/JavaScript/New_in_JavaScript/1.6</a></li> + <li><a class="new" href="/pl/docs/Web/JavaScript/New_in_JavaScript/1.7" rel="nofollow">/pl/docs/Web/JavaScript/New_in_JavaScript/1.7</a></li> + <li><a class="new" href="/pl/docs/Web/JavaScript/New_in_JavaScript/1.8" rel="nofollow">/pl/docs/Web/JavaScript/New_in_JavaScript/1.8</a></li> + <li><a class="new" href="/pl/docs/Web/JavaScript/New_in_JavaScript/1.8.1" rel="nofollow">/pl/docs/Web/JavaScript/New_in_JavaScript/1.8.1</a></li> + <li><a class="new" href="/pl/docs/Web/JavaScript/New_in_JavaScript/1.8.5" rel="nofollow">/pl/docs/Web/JavaScript/New_in_JavaScript/1.8.5</a></li> +</ul> + +<p> </p> + +<h2 id="Co_już_powinieneś_wiedzieć">Co już powinieneś wiedzieć</h2> + +<p>Ten przewodnik zakłada że masz poniższe podstawy:</p> + +<ul> + <li>Ogólna wiedza o Internecie i sieci WWW.</li> + <li>Dobra znajomość HTML'a (<a href="/en/HTML" title="en/HTML">HTML</a>).</li> + <li>Trochę doświadczenia w programowaniu. Jeżeli go nie posiadasz, spróbuj pobawić się z którymś z tutoriali ze strony <a href="/en-US/docs/JavaScript" title="/en-US/docs/">JavaScript</a></li> +</ul> + +<h2 id="Wersje_JavaScriptu">Wersje JavaScriptu</h2> + +<table class="standard-table"> + <caption>Tabela 1 JavaScript i wersje Navigatora</caption> + <thead> + <tr> + <th scope="col">Wersja JavaScriptu</th> + <th scope="col">Wersja Navigatora</th> + </tr> + </thead> + <tbody> + <tr> + <td>JavaScript 1.0</td> + <td>Navigator 2.0</td> + </tr> + <tr> + <td>JavaScript 1.1</td> + <td>Navigator 3.0</td> + </tr> + <tr> + <td>JavaScript 1.2</td> + <td>Navigator 4.0-4.05</td> + </tr> + <tr> + <td>JavaScript 1.3</td> + <td>Navigator 4.06-4.7x</td> + </tr> + <tr> + <td>JavaScript 1.4</td> + <td> </td> + </tr> + <tr> + <td>JavaScript 1.5</td> + <td>Navigator 6.0<br> + Mozilla (open sourceowa przeglądarka)</td> + </tr> + <tr> + <td>JavaScript 1.6</td> + <td><a href="/en/Firefox_1.5_for_developers" title="en/Firefox_1.5_for_developers">Firefox 1.5</a>, inne przeglądarki oparte na Mozilli 1.8</td> + </tr> + <tr> + <td>JavaScript 1.7</td> + <td><a href="/en/Firefox_2_for_developers" title="en/Firefox_2_for_developers">Firefox 2</a>, inne przeglądarki oparte na Mozilli<span style="line-height: inherit;"> 1.8.1</span></td> + </tr> + <tr> + <td>JavaScript 1.8</td> + <td><a href="/en/Firefox_3_for_developers" title="en/Firefox_3_for_developers">Firefox 3</a>, inne przeglądarki oparte na Gecko 1.9</td> + </tr> + </tbody> +</table> + +<h2 id="Gdzie_znaleźć_informacje_o_JavaScripcie">Gdzie znaleźć informacje o JavaScripcie</h2> + +<p>Dokumentacja JavaScript zawiera następujące książki:</p> + +<ul> + <li><a href="/pl/JavaScript/Przewodnik" title="en/Core_JavaScript_1.5_Guide">Przewodnik JavaScript</a> (ten przewodnik) dostarcza informacji o języku JavaScript i jego obiektach.</li> + <li><a href="/en/JavaScript/Reference" title="en/JavaScript/Reference">JavaScript Reference</a> dostarcza dodatkową wiedzę o języku JavaScript.</li> +</ul> + +<p>Jeżeli dopiero zaczynasz swoją przygodę z JavaScriptem, zacznij od <a href="/en/JavaScript/Guide" title="en/Core_JavaScript_1.5_Guide">Przewodnika JavaScript</a>. Jeżeli posiądziesz już podstawowe umiejętności, możesz przejśc do <a href="/en/JavaScript/Reference" title="en/JavaScript/Reference">JavaScript Reference</a> aby zdobyć bardziej szczegółową, dogłębną wiedzę.</p> + +<h2 id="Jak_się_uczyć_JavaScriptu">Jak się uczyć JavaScriptu</h2> + +<p>Rozpoczęcie nauki JavaScriptu jest proste: wszystko czego potrzebujesz to nowoczesna przeglądarka internetowa<span style="line-height: inherit;">. Ten przewodnik zawiera skrypty działające jedynie w najnowszej wersji Firefoxa (i innych przeglądarkach opartych na Gecko), także sugerujemy używanie jego najnowszej wersji.</span></p> + +<h3 id="Interaktywny_interpreter">Interaktywny interpreter</h3> + +<p>Interaktywna konsola JavaScriptowa stanowi nieocenioną pomoc przy nauce, pozwala ona testować skrypty bez zapisywania plików i odświeżania okna przeglądarki. Konsola błędów w Firefoxie (Narzędzia-Dla twórców WWW-Konsola WWW lub też Ctrl+Shift+K) dostarcza prosty sposób by przetesować JavaScript: poprostu wpisz linijkę kodu i zatwierdź ją Enterem.</p> + +<p><img alt="Konsola www w Firefoxie 25.0.1" src="https://mdn.mozillademos.org/files/6491/konsola.jpg" style="height: 252px; width: 803px;"></p> + +<p> </p> + +<h3 id="Firebug">Firebug</h3> + +<p>Bardziej zaawansowana konsola dostępna jest po zainstalowaniu dodatku do Firefoxa o nazwie <a class="external" href="http://www.getfirebug.com/">Firebug</a>. Wyrażenia, które wprowadzisz są interpretowane jako obiekty i są połączone z innymi częsciami Firebuga. Prosty przykład: </p> + +<p><img alt="" src="https://mdn.mozillademos.org/files/6493/firebug.jpg" style="height: 280px; width: 859px;"></p> + +<p> </p> + +<p>Użycie strzałki znajdującej się w prawym, dolnym rogu pozwala wprowadzać wielolinijkowy kod.</p> + +<p>Firebug udostępnia również zaawansowany inspektor DOM, debugger JavaScriptu oraz wiele innych, użytecznych funkcji. Kod JavaScript działający na stronie może użyć funkcji <code>console.log()</code>, służącej do wyświewtlania zawartości w konsoli Firebuga.</p> + +<h2 id="Konwencje_tekstowe_w_tym_dokumencie">Konwencje tekstowe w tym dokumencie</h2> + +<p>Aplikacje JavaScriptu działają na wielu systemach operacyjnych, informacje zawarte w tej książce odnoszą się do wszystkich tych wersji. Ścierzki do plików i katalogów zapisane są w formacie Windowsowym (z backslashami oddzielającymi nazwy folderów). Wsystemach Unixowych backslashe nalezy zastąpić slashami. </p> + +<p>Adresy URL w tym przewodniku mają następującą formę:</p> + +<p><code>http://<em>serwer</em>.<em>domena</em>/<em>sciezka</em>/<em>plik</em>.html</code></p> + +<p>W tych URLach <em>serwer</em> reprezentuje nazwę serwera, którego używasz, np. <code>test1</code> czy <code>www</code>; <em>domena</em> to nazwa Twojej domeny np. <code>netscape.com</code> czy <code>uiuc.edu</code>; <em>sciezka</em> odpowiada za lokalizację pliku na twoim serwerze zaś <em>plik</em><code>.html</code> to konkretna nazwa pliku. Ogólnie rzecz ujmując w adresie URL teksty pisane czcionką pochyłą oznacza lokalizację pliku zaś te pisane czcionką o stałej szerokości to literały. Jeżeli twój serwer ma włączony protokół SSL, zamiast używać przedrostka<span style="line-height: inherit;"> </span><code style="font-size: 14px; line-height: inherit;">http,</code><span style="line-height: inherit;"> posługiwać się będziesz </span><code style="font-size: 14px; line-height: inherit;">https</code><span style="line-height: inherit;">.</span></p> + +<p>Przewodnik ten używa następujących konwencji tekstowych:</p> + +<ul> + <li><code>Czciona o stałej szerokości</code> przedstawia przykładowy kod, jego listingi, elementy API oraz języka JavaScript (np. nazwy metod i właściwości), nazwy plików, nazwy katalogów, tagi HTML oraz każdy inny tekst, który musisz wpisać. (<code><em>Pochyła czcionka o stałej szerokości</em></code> używana jest gdy wpisujemy ścieżki w kod.)</li> + <li><em>Czcionka pochyła</em> jest używana w przypadku tytułów książek, by wyróżnić tekst, wskazać zmienną czy też lokalizację.</li> + <li><strong>Czcionka wytłuszczona</strong> wskazuje na ważne nazwy.</li> +</ul> diff --git a/files/pl/web/javascript/guide/obsolete_pages/index.html b/files/pl/web/javascript/guide/obsolete_pages/index.html new file mode 100644 index 0000000000..26e6692789 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/index.html @@ -0,0 +1,10 @@ +--- +title: Obsolete Pages +slug: Web/JavaScript/Guide/Obsolete_Pages +tags: + - NeedsTranslation + - TopicStub +translation_of: Web/JavaScript/Guide +--- +<p>This is a list of pages that have been merged into chapters (in alphabetical order):</p> +<p>{{ tree() }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/blok_instrukcji/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/blok_instrukcji/index.html new file mode 100644 index 0000000000..3d89c82b57 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/blok_instrukcji/index.html @@ -0,0 +1,41 @@ +--- +title: Blok instrukcji +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Blok_instrukcji +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +--- +<p> +</p> +<h3 id="Blok_instrukcji" name="Blok_instrukcji"> Blok instrukcji </h3> +<p>Blok instrukcji jest użyty do grupowania instrukcji. Blok zawarty jest w klamrach: +</p> +<pre class="eval">{ + instrukcja_1 + instrukcja_2 + . + . + . + instrukcja_n +} +</pre> +<p><b>Przykład</b><br> +Blok instrukcji są zazwyczaj używane z instrukcją kontrolną (np. <code><b>if</b></code>, <code><b>for</b></code>, <code><b>while</b></code>). +</p> +<pre class="eval">while (x < 10) { + x++; +} +</pre> +<p>Tutaj, <code><b>{ x++; }</b></code> jest blokiem instrukcji. +</p><p><b>Ważne</b>: JavaScript <b>nie</b> ma zakresu blokowego. Zmienne przedstawione z blokiem są zakresem stanowiącym zawartość funkcji i skryptu, efektem ustawień ich i trwania ponad własny blok. Nie chcesz używać bloków "samodzielnych/wolnostojących" w JavaScript, ponieważ one nie robią tego co myślisz, że robią, jeśli myślisz, że robią cokolwiek tak jak bloki w C lub Javie. Na przykład: +</p> +<pre class="eval">var x = 1; +{ + var x = 2; +} +alert(x); // wyświetli wartość drugiej zmiennej 2 +</pre> +<p>Zostanie wyświetlona wartość drugiej zmiennej ponieważ instrukcja <code><b>var x</b></code> wewnątrz warunku posiada ten sam zakres co instrukcja <code><b>var x</b></code> przed instrukcją warunkową. W C lub Java, równoważny kod miałby wartość pierwszej zmiennej. +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Block_Statement", "fr": "fr/Guide_JavaScript_1.5/D\u00e9claration_de_blocs", "ja": "ja/Core_JavaScript_1.5_Guide/Block_Statement" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/definiowanie_funkcji/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/definiowanie_funkcji/index.html new file mode 100644 index 0000000000..5dca69e416 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/definiowanie_funkcji/index.html @@ -0,0 +1,61 @@ +--- +title: Definiowanie funkcji +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Definiowanie_funkcji +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +--- +<h2 id="Definiowanie_funkcji" name="Definiowanie_funkcji">Definiowanie funkcji</h2> +<p>Na definicję funkcji składają się słowa:</p> +<ul> + <li>Nazwa funkcji.</li> + <li>Lista argumentów funkcji, otoczona w nawiasach i oddzielona przecinkami.</li> + <li>Instrukcje JavaScript, które definiują funkcje, otoczone w nawiasach klamrowych, { }. Instrukcje w funkcji zawierają nazwę do innych funkcji zdefiniowane do aktualnej aplikacji.</li> +</ul> +<p>Na przykład, następujący kod definiuje prostą funkcję nazwaną square:</p> +<pre>function square(number) { + return number * number; +} +</pre> +<p>Funkcja <code>square</code> bierze jeden argument, nazwany number. Funkcja składa się z jednej instrukcji, która sygnalizuje zwrot argumentu funkcji pomnożonej przez samą siebie. Instrukcja <code>return</code> określa wartość zwracanej funkcji.</p> +<pre>return number * number +</pre> +<p>Wszystkie parametry są przekazywane do funkcji <em>przez wartość</em>; wartość zostaje przekazana do funkcji, ale jeżeli w funkcji wartość parametru zostanie zmieniona, zmiana ta nie będzie widoczna globalnie an. Jednakże, jeżeli przekażesz obiekt jako parametr funkcji, a funkcja zmieni właściwości obiektu, zmiana ta będzie widoczna poza funkcją, tak jak w następującym przykładzie:</p> +<pre>function myFunc(theObject) { + theObject.make="Toyota" +} + +mycar = {make:"Honda", model:"Accord", year:1998}; +x=mycar.make; // zwraca Honda +myFunc(mycar); // przechodzi obiekt mycar do funkcji +y=mycar.make; // zwraca Toyota (porada: was changed by the function) +</pre> +<p>Zdefiniowana funkcja jest oparta na warunku. Na przykład, dając następującą definicje funkcji:</p> +<pre>if (num == 0) +{ + function myFunc(theObject) { + theObject.make="Toyota" + } +} +</pre> +<p>Funkcja <code>myFunc</code> jest tylko zdefiniowana jeśli zmienna <code>num</code> równa się 0. Jeśli <code>num</code> nie jest równe 0, funkcja nie jest zdefiniowana i jakiekolwiek inne próby nie zostaną wykonane.</p> +<p>Oprócz opisanego tu definiowania funkcji, możliwe jest także definiowanie <a href="/pl/docs/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Function_Object" title="Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Function_Object">Function objects</a>.</p> +<p>Metoda jest to połączenie funkcji z obiektem. Możesz się nauczyć więcej o obiektach i metodach w <a href="/pl/docs/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_function" title="Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_function">Obiekt function</a></p> +<p>Funkcja może być także zdefiniowana wewnątrz wyrażenia. Jest to nazwane wyrażeniem funkcyjnym. Typowo takie funkcje są anonimowe - nie mają nazwy. Na przykład, funkcja <code>square</code> może być zdefiniowana jako:</p> +<pre>const square = function(number) {return number * number}; +</pre> +<p>To jest konwencja kiedy przekazujesz jako funkcję jako argument do następnej funkcji. Następujący przykład pokazuje mapę funkcji będących zdefiniowanymi i następnie nazwane z funkcją, a jako pierwszą funkcją będzie parametr:</p> +<pre>function map(f,a) { + var result=new Array; + for (var i = 0; i != a.length; i++) + result[i] = f(a[i]); + return result; +} +</pre> +<p>Wywołuje:</p> +<pre>map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]); +</pre> +<p>Zwraca {{ mediawiki.external('0, 1, 8, 125, 1000') }}.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/dodawanie_obiektom_nowej_funkcjonalności/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/dodawanie_obiektom_nowej_funkcjonalności/index.html new file mode 100644 index 0000000000..9ba9895af5 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/dodawanie_obiektom_nowej_funkcjonalności/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. +--- +<p>Każdy obiekt JavaScriptu posiada zadeklarowane, właściwe dla siebie funkcje, jak np. obiekt String posiada takie funkcje jak <code>toUpperCase()</code> czy<code> toLowerCase()</code>, 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.</p> +<p> </p> +<p><code>String.prototype.firstLetter = function() {</code></p> +<p><code> var callObject = this;</code></p> +<p><code> return callObject.charAt(0);<br> +</code></p> +<p><code>};</code></p> +<p> </p> +<p>Dysponując tak przygotowanym kodem, możemy teraz uż<font color="#313131" face="arial, sans-serif">y</font><span class="Apple-style-span" style="color: rgb(49, 49, 49); font-family: arial, sans-serif;">ć naszej metody <code>firstLetter()</code> na dowolnym łańcuchu znaków.</span></p> +<p> </p> +<p><code>alert("hello".firstLetter());</code></p> +<p> </p> +<p>Powyższy kod wyświetli w okienku dialogowym typu alert literę h.</p> +<p> </p> +<p> </p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcja_eval/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcja_eval/index.html new file mode 100644 index 0000000000..3a78b3c311 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcja_eval/index.html @@ -0,0 +1,20 @@ +--- +title: Funkcja eval +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_eval +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +--- +<p> +</p> +<h3 id="Funkcja_eval" name="Funkcja_eval"> Funkcja <code>eval</code> </h3> +<p>Funkcja <code>eval</code> ocenia łańcuch znaków w kodzie JavaScript bez odniesienia do osobliwego obiektu. Składnia <code>eval</code>: +</p> +<pre>eval(expr) +</pre> +<p>gdzie: <code>expr</code> jest ocenianym łańcuchem znaków. +</p><p>Jeśli łańcuch znaków reprezentuje wyrażenie, <code>eval</code> je ocenia. Jeśli argument reprezentuje jedną lub więcej instrukcji JavaScript, <code>eval</code> wykonuje instrukcję. Nie nazywaj <code>eval</code> oceniane wyrażenia arytmetyczne, gdyż JavaScript oceni wyrażenia arytmetyczne automatycznie. +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/eval_Function", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/La_fonction_eval", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/eval_Function" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcja_isfinite/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcja_isfinite/index.html new file mode 100644 index 0000000000..ee6209ed4f --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcja_isfinite/index.html @@ -0,0 +1,24 @@ +--- +title: Funkcja isFinite +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isFinite +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +--- +<p> +</p> +<h3 id="Funkcja_isFinite" name="Funkcja_isFinite"> Funkcja <code><b>isFinite</b></code> </h3> +<p>Funkcja <code><b>isFinite</b></code> sprawdza argument do momentu ustalenia czy jest liczbą skończona. Składnia <code><b>isFinite</b></code>: +</p> +<pre>isFinite(number) +</pre> +<p>gdzie: <code><b>number</b></code> jest liczbą, która jest sprawdzana. </p><p>Jeśli argument jest <code><b>NaN</b></code>, plus nieskończoność lub minus nieskończoność, to ta metoda zwraca <code><b>false</b></code>, w innych przypadkach zwraca <code><b>true</b></code>. +</p><p>Następujący kod sprawdza klienta wejścia i ustala czy to jest liczba skończona. </p> +<pre>if(isFinite(ClientInput) == true) +{ + /* wykonaj odpowiednie kroki */ +} +</pre> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/isFinite_Function", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/La_fonction_isFinite", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/isFinite_Function" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcja_isnan/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcja_isnan/index.html new file mode 100644 index 0000000000..c580bcd791 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcja_isnan/index.html @@ -0,0 +1,29 @@ +--- +title: Funkcja isNaN +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isNaN +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +--- +<p> +</p> +<h3 id="Funkcja_isNaN" name="Funkcja_isNaN"> Funkcja isNaN </h3> +<p>Funkcja <code><b>isNaN</b></code> ocenia argument do określenia jeśli jest "NaN" (nie numer). Składnia <code><b>isNaN</b></code>: +</p> +<pre>isNaN(testValue) +</pre> +<p>gdzie: <code><b>testValue</b></code> jest wartością do oceny. +</p><p>Funkcje <code><b>parseFloat</b></code> i <code><b>parseInt</b></code> zwracają "NaN", kiedy ocenią wartość, że to nie jest numer. <code><b>isNaN</b></code> zwraca true jeśli przyjmie "NaN," i false w przeciwnym wypadku. +</p><p>Następujący kod sprawdza wartość <code><b>floatValue</b></code>, potrafi określić czy to jest liczba, a następnie nazywa odpowiednią procedurę: +</p> +<pre>floatValue=parseFloat(toFloat) + +if (isNaN(floatValue)) { + notFloat() +} else { + isFloat() +} +</pre> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/isNaN_Function", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/La_fonction_isNaN", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/isNaN_Function" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcje_escape_i_unescape/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcje_escape_i_unescape/index.html new file mode 100644 index 0000000000..a0efea0a21 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcje_escape_i_unescape/index.html @@ -0,0 +1,25 @@ +--- +title: Funkcje escape i unescape +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_escape_i_unescape +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +--- +<p> +</p> +<h3 id="Funkcje_escape_i_unescape" name="Funkcje_escape_i_unescape"> Funkcje <code>escape</code> i <code>unescape</code> </h3> +<p>Funkcje <code>escape</code> i <code>unescape</code> kodują i dekodują wartość łańcuchową. Funkcja <code>escape</code> zwraca kodowanie szesnastkowe argumentu ustawiając czcionki ISO Latin. Funkcja <code>unescape</code> zwraca wartość łańcuchową jako ASCII - czyli specyficzną wartością kodowania szesnastkowego. +</p><p>Składnia tych funkcji: +</p> +<pre>escape(string) +unescape(string) +</pre> +<p>Funkcje używamy przede wszystkim po stronie serwera, JavaScript koduje i dekoduje nazwy/wartości par w URL. +</p><p>Funkcje <code>escape</code> i <code>unescape</code> nie pracują dla znaków nie znajdujących się w ASCII, które są deprecated. W JavaScript 1.5 i późniejszych wydaniach, używają <code>encodeURI</code>, <code>decodeURI</code>, <code>encodeURIComponent</code>, i <code>decodeURIComponent</code>. +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/escape_and_unescape_Functions", "es": "es/Gu\u00eda_JavaScript_1.5/Funciones_predefinidas/Funciones_escape_y_unescape", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/Les_fonctions_escape_et_unescape", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/escape_and_unescape_Functions" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcje_number_i_string/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcje_number_i_string/index.html new file mode 100644 index 0000000000..10c47d0cd8 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcje_number_i_string/index.html @@ -0,0 +1,26 @@ +--- +title: Funkcje Number i String +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_Number_i_String +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +--- +<p> +</p> +<h3 id="Funkcje_Number_i_String" name="Funkcje_Number_i_String"> Funkcje <code><b>Number</b></code> i <code><b>String</b></code> </h3> +<p>Funkcja <code><b>Number</b></code> i <code><b>String</b></code> przekonwertuje na obiekt numeryczny lub łańcuch znaków. Składnia tej funkcji to: +</p> +<pre>Number(objRef) +String(objRef) +</pre> +<p>gdzie: <code><b>objRef</b></code> jest wskaźnikiem funkcji. +</p><p>Następny przykład przekonwertuje obiekt <code><b>Date</b></code> na możliwy do odczytu łańcuch znaków. +</p> +<pre>D = new Date (430054663215) +// Następnie zwraca +// "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983" +x = String(D) +</pre> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/Number_and_String_Functions", "es": "es/Gu\u00eda_JavaScript_1.5/Funciones_predefinidas/Funciones_Number_y_String", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/Les_fonctions_Number_et_String", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/Number_and_String_Functions" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcje_parseint_i_parsefloat/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcje_parseint_i_parsefloat/index.html new file mode 100644 index 0000000000..987bd6757a --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/funkcje_parseint_i_parsefloat/index.html @@ -0,0 +1,27 @@ +--- +title: Funkcje parseInt i parseFloat +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_parseInt_i_parseFloat +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +--- +<p> +</p> +<h3 id="Funkcja_parseInt_i_parseFloat" name="Funkcja_parseInt_i_parseFloat"> Funkcja <code>parseInt</code> i <code>parseFloat</code> </h3> +<p>Dwie funkcje "parse", <code>parseInt</code> i <code>parseFloat</code>, zwracają wartość liczbową, gdy podano łańcuch znaków jako argument. </p><p>Składnia <code>parseFloat</code> +</p> +<pre>parseFloat(str) +</pre> +<p>gdzie <code>parseFloat</code> analizuje swój argument, łańcuch znaków <code>str</code> i próbuje zwrócić liczbę zmiennoprzecinkową. W razie napotkania symbolu innego niż znak (+ lub -), liczby (0-9), znaku dziesiętnego lub wykładnika, funkcja zwraca wartość do momentu jego wystąpienia ignorując sam symbol i wszystkie inne po nim następujące. Jeśli pierwszy znak nie może być przekonwertowany do liczby, zwrócona zostaje wartość "NaN" (nie liczba). +</p><p>Składnia <code>parseInt</code> </p> +<pre>parseInt(str [, radix]) +</pre> +<p><code>parseInt</code> analizuje swój pierwszy argument, łańcuch znaków <code>str</code> i próbuje zwrócić liczbę całkowitą o podstawie wskazanej przez drugi, opcjonalny argument <code>radix</code>. Na przykład, podstawa o wartości 10 wskazuje konwersję do liczby dziesiętnej, podstawa równa 8 do liczby ósemkowej, 16 do heksadecymalnej itd. Dla podstawy większej od 10 litery alfabetu wskazują liczby większe od 9. Na przykład, dla liczb heksadecymalnych (podstawa 16), używane są litery od A do F. +</p><p>Jeśli <code>parseInt</code> napotka w podanej podstawie symbolu, który nie jest liczbą, funkcja zwraca wartość całkowitą do momentu jego wystąpienia ignorując sam symbol i wszystkie inne po nim następujące. Jeśli pierwszy znak nie może być przekonwertowany do liczby, zwrócona zostaje wartość "NaN". Funkcja <code>parseInt</code> skraca łańcuchy znaków do wartości całkowitych. +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/parseInt_and_parseFloat_Functions", "es": "es/Gu\u00eda_JavaScript_1.5/Funciones_predefinidas/Funciones_parseInt_y_parseFloat", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/Les_fonctions_parseInt_et_parseFloat", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/parseInt_and_parseFloat_Functions" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/index.html new file mode 100644 index 0000000000..904181e0e9 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/funkcje_predefiniowane/index.html @@ -0,0 +1,23 @@ +--- +title: Funkcje predefiniowane +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +--- +<p> +</p> +<h3 id="Funkcje_predefiniwane" name="Funkcje_predefiniwane"> Funkcje predefiniwane </h3> +<p>JavaScript ma kilka predefiniowanych funkcji: +</p> +<ul><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_eval"><code>eval</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isFinite"><code>isFinite</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isNaN">Funkcja <code>isNaN</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_parseInt_i_parseFloat"><code>parseInt</code> i <code>parseFloat</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_Number_i_String"><code>Number</code> i <code>String</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_escape_i_unescape"><code>encodeURI</code>, <code>decodeURI</code>, <code>encodeURIComponent</code>, i <code>decodeURIComponent</code> (wszystkie dostępne z Javascript 1.5 i późniejszym).</a> +</li></ul> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/index.html new file mode 100644 index 0000000000..5cbec8cf40 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/index.html @@ -0,0 +1,875 @@ +--- +title: Przewodnik po języku JavaScript 1.5 +slug: Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5 +tags: + - AJAX + - JavaScript + - Projekt_MDC + - Przewodnik_JavaScript + - Strony_do_aktualizacji + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide +--- +<h4 id="O_tym_przewodniku" name="O_tym_przewodniku"><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/O_tym_przewodniku" title="pl/Przewodnik_po_języku_JavaScript_1.5/O_tym_przewodniku">O tym przewodniku</a></h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/O_tym_przewodniku#Nowe_mo.C5.BCliwo.C5.9Bci_tego_wydania" title="pl/Przewodnik_po_języku_JavaScript_1.5/O_tym_przewodniku#Nowe_mo.C5.BCliwo.C5.9Bci_tego_wydania">Nowe możliwości tego wydania</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/O_tym_przewodniku#Co_ju.C5.BC_powiniene.C5.9B_wiedzie.C4.87" title="pl/Przewodnik_po_języku_JavaScript_1.5/O_tym_przewodniku#Co_ju.C5.BC_powiniene.C5.9B_wiedzie.C4.87">Co już powinieneś wiedzieć</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/O_tym_przewodniku#Wersje_JavaScriptu" title="pl/Przewodnik_po_języku_JavaScript_1.5/O_tym_przewodniku#Wersje_JavaScriptu">Wersje JavaScriptu</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/O_tym_przewodniku#Gdzie_szuka.C4.87_informacji_o_JavaScripcie" title="pl/Przewodnik_po_języku_JavaScript_1.5/O_tym_przewodniku#Gdzie_szuka.C4.87_informacji_o_JavaScripcie">Gdzie szukać informacji o JavaScripcie</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/O_tym_przewodniku#Konwencje_dokumentu" title="pl/Przewodnik_po_języku_JavaScript_1.5/O_tym_przewodniku#Konwencje_dokumentu">Konwencje dokumentu</a></dd> +</dl> + +<h4 id="Przegl.C4.85d_JavaScriptu" name="Przegl.C4.85d_JavaScriptu"><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Przegl%C4%85d_JavaScriptu" title="pl/Przewodnik_po_języku_JavaScript_1.5/Przegląd_JavaScriptu">Przegląd JavaScriptu</a></h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Przegl%C4%85d_JavaScriptu#Czym_jest_JavaScript.3F" title="pl/Przewodnik_po_języku_JavaScript_1.5/Przegląd_JavaScriptu#Czym_jest_JavaScript.3F">Czym jest JavaScript?</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Przegl%C4%85d_JavaScriptu#JavaScript_i_Java" title="pl/Przewodnik_po_języku_JavaScript_1.5/Przegląd_JavaScriptu#JavaScript_i_Java">JavaScript i Java</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Przegl%C4%85d_JavaScriptu#JavaScript_i_specyfikacja_ECMA" title="pl/Przewodnik_po_języku_JavaScript_1.5/Przegląd_JavaScriptu#JavaScript_i_specyfikacja_ECMA">JavaScript i specyfikacja ECMA</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Przegl%C4%85d_JavaScriptu#Zwi.C4.85zek_pomi.C4.99dzy_JavaScript.2C_a_wersj.C4.85_ECMA" title="pl/Przewodnik_po_języku_JavaScript_1.5/Przegląd_JavaScriptu#Zwi.C4.85zek_pomi.C4.99dzy_JavaScript.2C_a_wersj.C4.85_ECMA">Związek pomiędzy JavaScript, a wersją ECMA</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Przegl%C4%85d_JavaScriptu#Dokumentacja_JavaScript_w_por.C3.B3wnaniu_ze_specyfikacj.C4.85_ECMA" title="pl/Przewodnik_po_języku_JavaScript_1.5/Przegląd_JavaScriptu#Dokumentacja_JavaScript_w_por.C3.B3wnaniu_ze_specyfikacj.C4.85_ECMA">Dokumentacja JavaScript w porównaniu ze specyfikacją ECMA</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Przegl%C4%85d_JavaScriptu#Terminologia_JavaScriptu_i_ECMA" title="pl/Przewodnik_po_języku_JavaScript_1.5/Przegląd_JavaScriptu#Terminologia_JavaScriptu_i_ECMA">Terminologia JavaScriptu i ECMA</a></dd> + </dl> + </dd> +</dl> + +<h4 id="Funkcjonalno.C5.9B.C4.87_j.C4.99zyka" name="Funkcjonalno.C5.9B.C4.87_j.C4.99zyka">Funkcjonalność języka</h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Warto%C5%9Bci" title="pl/Przewodnik_po_języku_JavaScript_1.5/Wartości">Wartości</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Warto%C5%9Bci#Konwersja_typu_danych" title="pl/Przewodnik_po_języku_JavaScript_1.5/Wartości#Konwersja_typu_danych">Konwersja typu danych</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Zmienne" title="pl/Przewodnik_po_języku_JavaScript_1.5/Zmienne">Zmienne</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Zmienne#Deklaracja_zmiennych" title="pl/Przewodnik_po_języku_JavaScript_1.5/Zmienne#Deklaracja_zmiennych">Deklaracja zmiennych</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Zmienne#Ocena_zmiennych" title="pl/Przewodnik_po_języku_JavaScript_1.5/Zmienne#Ocena_zmiennych">Ocena zmiennych</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Zmienne#Zakres_zmiennych" title="pl/Przewodnik_po_języku_JavaScript_1.5/Zmienne#Zakres_zmiennych">Zakres zmiennych</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Sta%C5%82e" title="pl/Przewodnik_po_języku_JavaScript_1.5/Stałe">Stałe</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Litera%C5%82y" title="pl/Przewodnik_po_języku_JavaScript_1.5/Literały">Literały</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Litera%C5%82y#Litera.C5.82y_tablicy" title="pl/Przewodnik_po_języku_JavaScript_1.5/Literały#Litera.C5.82y_tablicy">Literały tablicy</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Litera%C5%82y#Litera.C5.82y_logiczne" title="pl/Przewodnik_po_języku_JavaScript_1.5/Literały#Litera.C5.82y_logiczne">Literały logiczne</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Litera%C5%82y#Litera.C5.82y_ca.C5.82kowite" title="pl/Przewodnik_po_języku_JavaScript_1.5/Literały#Litera.C5.82y_ca.C5.82kowite">Literały całkowite</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Litera%C5%82y#Litera.C5.82y_zmiennoprzecinkowe" title="pl/Przewodnik_po_języku_JavaScript_1.5/Literały#Litera.C5.82y_zmiennoprzecinkowe">Literały zmiennoprzecinkowe</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Litera%C5%82y#Litera.C5.82y_obiektu" title="pl/Przewodnik_po_języku_JavaScript_1.5/Literały#Litera.C5.82y_obiektu">Literały obiektu</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Litera%C5%82y#Litera.C5.82y_znakowe" title="pl/Przewodnik_po_języku_JavaScript_1.5/Literały#Litera.C5.82y_znakowe">Literały znakowe</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Unicode" title="pl/Przewodnik_po_języku_JavaScript_1.5/Unicode">Unicode</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Unicode#Unicode_zgodny_z_ASCII_i_ISO" title="pl/Przewodnik_po_języku_JavaScript_1.5/Unicode#Unicode_zgodny_z_ASCII_i_ISO">Unicode zgodny z ASCII i ISO</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Unicode#Sekwencje_ucieczki_do_Unicode" title="pl/Przewodnik_po_języku_JavaScript_1.5/Unicode#Sekwencje_ucieczki_do_Unicode">Sekwencje ucieczki do Unicode</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Unicode#Wy.C5.9Bwietlanie_czcionek_z_Unicode" title="pl/Przewodnik_po_języku_JavaScript_1.5/Unicode#Wy.C5.9Bwietlanie_czcionek_z_Unicode">Wyświetlanie czcionek z Unicode</a></dd> + </dl> + </dd> +</dl> + +<h4 id="Wyra.C5.BCenia_i_operatory" name="Wyra.C5.BCenia_i_operatory">Wyrażenia i operatory</h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Wyra%C5%BCenia" title="pl/Przewodnik_po_języku_JavaScript_1.5/Wyrażenia">Wyrażenia</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Operatory" title="pl/Przewodnik_po_języku_JavaScript_1.5/Operatory">Operatory</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Operatory/Operatory_przypisania" title="pl/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_przypisania">Operatory przypisania</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Operatory/Operatory_por%C3%B3wnania" title="pl/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_porównania">Operatory porównania</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Operatory/Operatory_arytmetyczne" title="pl/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_arytmetyczne">Operatory arytmetyczne</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Operatory/Operatory_bitowe" title="pl/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_bitowe">Operatory bitowe</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Operatory/Operatory_logiczne" title="pl/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_logiczne">Operatory logiczne</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Operatory/Operacje_na_%C5%82a%C5%84cuchach" title="pl/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operacje_na_łańcuchach">Operacje na łańcuchach</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Operatory/Operatory_specjalne" title="pl/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_specjalne">Operatory specjalne</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Operatory#Pierwsze.C5.84stwo_operator.C3.B3w" title="pl/Przewodnik_po_języku_JavaScript_1.5/Operatory#Pierwsze.C5.84stwo_operator.C3.B3w">Pierwszeństwo operatorów</a></dd> + </dl> + </dd> +</dl> + +<h4 id="Wyra.C5.BCenia_regularne" name="Wyra.C5.BCenia_regularne">Wyrażenia regularne</h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_wyra%C5%BCenia_regularnego" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_wyrażenia_regularnego">Tworzenie wyrażenia regularnego</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Zapisywanie_wzorca_wyra%C5%BCenia_regularnego" title="pl/Przewodnik_po_języku_JavaScript_1.5/Zapisywanie_wzorca_wyrażenia_regularnego">Zapisywanie wzorca wyrażenia regularnego</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Zapisywanie_wzorca_wyra%C5%BCenia_regularnego#U.C5.BCywanie_prostego_wzoru" title="pl/Przewodnik_po_języku_JavaScript_1.5/Zapisywanie_wzorca_wyrażenia_regularnego#U.C5.BCywanie_prostego_wzoru">Używanie prostego wzoru</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Zapisywanie_wzorca_wyra%C5%BCenia_regularnego#U.C5.BCywanie_specjalnych_znak.C3.B3w" title="pl/Przewodnik_po_języku_JavaScript_1.5/Zapisywanie_wzorca_wyrażenia_regularnego#U.C5.BCywanie_specjalnych_znak.C3.B3w">Używanie specjalnych znaków</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Zapisywanie_wzorca_wyra%C5%BCenia_regularnego#U.C5.BCywanie_nawias.C3.B3w" title="pl/Przewodnik_po_języku_JavaScript_1.5/Zapisywanie_wzorca_wyrażenia_regularnego#U.C5.BCywanie_nawias.C3.B3w">Używanie nawiasów</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_wyra%C5%BCeniami_regularnymi" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_wyrażeniami_regularnymi">Praca z wyrażeniami regularnymi</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_wyra%C5%BCeniami_regularnymi/U%C5%BCycie_odpowiedniego_znaku" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_wyrażeniami_regularnymi/Użycie_odpowiedniego_znaku">Użycie odpowiedniego znaku</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_wyra%C5%BCeniami_regularnymi/Globalne_wyszukiwanie,_wielko%C5%9B%C4%87_znak%C3%B3w,_wieloliniowe_wej%C5%9Bcie" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_wyrażeniami_regularnymi/Globalne_wyszukiwanie,_wielkość_znaków,_wieloliniowe_wejście">Globalne wyszukiwanie, wielkość znaków, wieloliniowe wejście</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_wyra%C5%BCeniami_regularnymi/Przyk%C5%82ady_wyra%C5%BCe%C5%84_regularnych" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_wyrażeniami_regularnymi/Przykłady_wyrażeń_regularnych">Przykłady</a></dd> + </dl> + </dd> +</dl> + +<h4 id="Instrukcje" name="Instrukcje">Instrukcje</h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Blok_instrukcji" title="pl/Przewodnik_po_języku_JavaScript_1.5/Blok_instrukcji">Blok instrukcji</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_warunkowe" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_warunkowe">Instrukcje warunkowe</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_warunkowe#Instrukcja_if...else" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_warunkowe#Instrukcja_if...else">Instrukcja if...else</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_warunkowe#Instrukcja_switch" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_warunkowe#Instrukcja_switch">Instrukcja switch</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_p%C4%99tli" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli">Instrukcje pętli</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_p%C4%99tli/Instrukcja_for" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_for">Instrukcja for</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_p%C4%99tli/Instrukcja_do_...while" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_do_...while">Instrukcja do...while</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_p%C4%99tli/Instrukcja_while" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_while">Instrukcja while</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_p%C4%99tli/Instrukcja_label" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_label">Instrukcja label</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_p%C4%99tli/Instrukcja_break" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_break">Instrukcja break</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_p%C4%99tli/Instrukcja_continue" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli/Instrukcja_continue">Instrukcja continue</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_manipulacji_obiektem" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_manipulacji_obiektem">Instrukcje manipulacji obiektem</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_manipulacji_obiektem#Instrukcja_for...in" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_manipulacji_obiektem#Instrukcja_for...in">Instrukcja for...in</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_manipulacji_obiektem#Instrukcja_with" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_manipulacji_obiektem#Instrukcja_with">Instrukcja with</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_komentarzy" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_komentarzy">Komentarze</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_obs%C5%82ugi_wyj%C4%85tk%C3%B3w" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_obsługi_wyjątków">Instrukcje obsługi wyjątków</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_obs%C5%82ugi_wyj%C4%85tk%C3%B3w/Instrukcja_throw" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_obsługi_wyjątków/Instrukcja_throw">Instrukcja throw</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Instrukcje_obs%C5%82ugi_wyj%C4%85tk%C3%B3w/Instrukcja_try...catch" title="pl/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_obsługi_wyjątków/Instrukcja_try...catch">Instrukcja try...catch</a></dd> + </dl> + </dd> +</dl> + +<h4 id="Funkcje" name="Funkcje">Funkcje</h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Definiowanie_funkcji" title="pl/Przewodnik_po_języku_JavaScript_1.5/Definiowanie_funkcji">Definiowanie funkcji</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Wywo%C5%82anie_funkcji" title="pl/Przewodnik_po_języku_JavaScript_1.5/Wywołanie_funkcji">Wywołanie funkcji</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Zastosowanie_obiektu_arguments" title="pl/Przewodnik_po_języku_JavaScript_1.5/Zastosowanie_obiektu_arguments">Zastosowanie obiektu <code>arguments</code></a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Funkcje_predefiniowane" title="pl/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane">Funkcje predefiniowane</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_eval" title="pl/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_eval">Funkcja <code>eval</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isFinite" title="pl/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isFinite">Funkcja <code>isFinite</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isNaN" title="pl/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isNaN">Funkcja <code>isNaN</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_parseInt_i_parseFloat" title="pl/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_parseInt_i_parseFloat">Funkcje <code>parseInt</code> i <code>parseFloat</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_Number_i_String" title="pl/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_Number_i_String">Funkcje <code>Number</code> i <code>String</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_escape_i_unescape" title="pl/Przewodnik_po_języku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_escape_i_unescape">Funkcje <code>escape</code> i <code>unescape</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_zamknięciami" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_zamknięciami">Praca z zamknięciami</a></dd> +</dl> + +<h4 id="Praca_z_obiektami" name="Praca_z_obiektami">Praca z obiektami</h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_i_w%C5%82asno%C5%9Bci" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_i_własności">Obiekty i własności</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%C3%B3w" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów">Tworzenie nowych obiektów</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%C3%B3w/U%C5%BCywanie_inicjacji_obiektu" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Używanie_inicjacji_obiektu">Używanie inicjacji obiektu</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%C3%B3w/Zastosowanie_konstruktor%C3%B3w_funkcji" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Zastosowanie_konstruktorów_funkcji">Używanie konstruktorów funkcji</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%C3%B3w/Indeksowanie_w%C5%82asno%C5%9Bci_obiektu" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Indeksowanie_własności_obiektu">Indeksowanie własności obiektu</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%C3%B3w/Definiowanie_w%C5%82asno%C5%9Bci_typu_obiektu" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Definiowanie_własności_typu_obiektu">Definiowanie własności typu obiektu</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%C3%B3w/Definiowanie_metod" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Definiowanie_metod">Definiowanie metod</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%C3%B3w/Zastosowanie_'this'_do_obiektu_referencji" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Zastosowanie_'this'_do_obiektu_referencji">Używanie 'this' do obiektu referencji</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%C3%B3w/Definiowanie_metod_pobierania_i_ustawiania" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Definiowanie_metod_pobierania_i_ustawiania">Definiowanie metod pobierania i ustawiania</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%C3%B3w/Usuwanie_w%C5%82asno%C5%9Bci" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Usuwanie_własności">Usuwanie własności</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_predefiniowane" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane">Obiekty predefiniowane</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Array" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Array">Obiekt <code>Array</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Boolean" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Boolean">Obiekt <code>Boolean</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Date" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Date">Obiekt <code>Date</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_function" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_function">Obiekt function</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Math" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Math">Obiekt <code>Math</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Number" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Number">Obiekt <code>Number</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_RegExp" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_RegExp">Obiekt <code>RegExp</code></a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_String" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_String">Obiekt <code>String</code></a></dd> + </dl> + </dd> +</dl> + +<h4 id="Detale_modelu_obiektowego" name="Detale_modelu_obiektowego">Detale modelu obiektowego</h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/J%C4%99zyki_oparte_na_klasach_vs._oparte_na_prototypach" title="pl/Przewodnik_po_języku_JavaScript_1.5/Języki_oparte_na_klasach_vs._oparte_na_prototypach">Języki oparte na klasach vs. oparte na prototypach</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/J%C4%99zyki_oparte_na_klasach_vs._oparte_na_prototypach#Definiowanie_klasy" title="pl/Przewodnik_po_języku_JavaScript_1.5/Języki_oparte_na_klasach_vs._oparte_na_prototypach#Definiowanie_klasy">Definiowanie klasy</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/J%C4%99zyki_oparte_na_klasach_vs._oparte_na_prototypach#Podklasy_i_dziedziczenie" title="pl/Przewodnik_po_języku_JavaScript_1.5/Języki_oparte_na_klasach_vs._oparte_na_prototypach#Podklasy_i_dziedziczenie">Podklasy i dziedziczenie</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/J%C4%99zyki_oparte_na_klasach_vs._oparte_na_prototypach#Dodawanie_i_usuwanie_w.C5.82asno.C5.9Bci" title="pl/Przewodnik_po_języku_JavaScript_1.5/Języki_oparte_na_klasach_vs._oparte_na_prototypach#Dodawanie_i_usuwanie_w.C5.82asno.C5.9Bci">Dodawanie i usuwanie własności</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/J%C4%99zyki_oparte_na_klasach_vs._oparte_na_prototypach#R.C3.B3.C5.BCnice" title="pl/Przewodnik_po_języku_JavaScript_1.5/Języki_oparte_na_klasach_vs._oparte_na_prototypach#R.C3.B3.C5.BCnice">Różnice</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_przyk%C5%82adem" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem">Praca z przykładem</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_przyk%C5%82adem/Tworzenie_hierarchii" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem/Tworzenie_hierarchii">Tworzenie hierarchii</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_przyk%C5%82adem/W%C5%82asno%C5%9Bci_obiektu" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem/Własności_obiektu">Własności obiektu</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_przyk%C5%82adem/W%C5%82asno%C5%9Bci_obiektu/Dziedziczenie_w%C5%82asno%C5%9Bci" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem/Własności_obiektu/Dziedziczenie_własności">Dziedziczenie własności</a></dd> + </dl> + </dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_przyk%C5%82adem/W%C5%82asno%C5%9Bci_obiektu/Dodawanie_w%C5%82asno%C5%9Bci" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem/Własności_obiektu/Dodawanie_własności">Dodawanie własności</a></dd> + </dl> + </dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Praca_z_przyk%C5%82adem/Wi%C4%99cej_elastycznych_konstruktor%C3%B3w" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_przykładem/Więcej_elastycznych_konstruktorów">Więcej elastycznych konstruktorów</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Powr%C3%B3t_dziedziczenia_w%C5%82asno%C5%9Bci" title="pl/Przewodnik_po_języku_JavaScript_1.5/Powrót_dziedziczenia_własności">Powrót dziedziczenia własności</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Powr%C3%B3t_dziedziczenia_w%C5%82asno%C5%9Bci/Warto%C5%9Bci_lokalne_vs._dziedziczone" title="pl/Przewodnik_po_języku_JavaScript_1.5/Powrót_dziedziczenia_własności/Wartości_lokalne_vs._dziedziczone">Wartości lokalne vs. dziedziczone</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Powr%C3%B3t_dziedziczenia_w%C5%82asno%C5%9Bci/Okre%C5%9Blanie_wzajemnych_relacji_obiektu" title="pl/Przewodnik_po_języku_JavaScript_1.5/Powrót_dziedziczenia_własności/Określanie_wzajemnych_relacji_obiektu">Określanie wzajemnych relacji obiektu</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Powr%C3%B3t_dziedziczenia_w%C5%82asno%C5%9Bci/Globalne_informacje_w_konstruktorach" title="pl/Przewodnik_po_języku_JavaScript_1.5/Powrót_dziedziczenia_własności/Globalne_informacje_w_konstruktorach">Globalne informacje w konstruktorach</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Powr%C3%B3t_dziedziczenia_w%C5%82asno%C5%9Bci/Brak_wielokrotnego_dziedziczenia" title="pl/Przewodnik_po_języku_JavaScript_1.5/Powrót_dziedziczenia_własności/Brak_wielokrotnego_dziedziczenia">Brak wielokrotnego dziedziczenia</a></dd> + </dl> + </dd> +</dl> + +<h4 id="Podgl.C4.85d_klas_LiveConnect" name="Podgl.C4.85d_klas_LiveConnect"><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect">Podgląd klas LiveConnect</a></h4> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Praca_z_klas%C4%85_opakowuj%C4%85c%C4%85" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Praca_z_klasą_opakowującą">Praca z klasą opakowującą</a></dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Komunikacja_mi%C4%99dzy_JavaScript_a_Java" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Komunikacja_między_JavaScript_a_Java">Komunikacja między JavaScript a Java</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Komunikacja_mi%C4%99dzy_JavaScript_a_Java#Obiekt_opakowuj.C4.85cy" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Komunikacja_między_JavaScript_a_Java#Obiekt_opakowuj.C4.85cy">Obiekt opakowujący</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Komunikacja_mi%C4%99dzy_JavaScript_a_Java#Praca_z_tablicami_w_Javie" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Komunikacja_między_JavaScript_a_Java#Praca_z_tablicami_w_Javie">Praca z tablicami w Javie</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Komunikacja_mi%C4%99dzy_JavaScript_a_Java#Referencja_paczki_i_klasy" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Komunikacja_między_JavaScript_a_Java#Referencja_paczki_i_klasy">Referencja paczki i klasy</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Komunikacja_mi%C4%99dzy_JavaScript_a_Java#Argumenty_typu_char" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Komunikacja_między_JavaScript_a_Java#Argumenty_typu_char">Argumenty typu char</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Komunikacja_mi%C4%99dzy_JavaScript_a_Java#Obs.C5.82uga_wyj.C4.85tk.C3.B3w_Javy_w_JavaScript" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Komunikacja_między_JavaScript_a_Java#Obs.C5.82uga_wyj.C4.85tk.C3.B3w_Javy_w_JavaScript">Obsługa wyjątków Javy w JavaScript</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Komunikacja_mi%C4%99dzy_Java_a_JavaScript" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Komunikacja_między_Java_a_JavaScript">Komunikacja między Java a JavaScript</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Komunikacja_mi%C4%99dzy_Java_a_JavaScript/U%C5%BCywanie_klas_LiveConnect" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Komunikacja_między_Java_a_JavaScript/Używanie_klas_LiveConnect">Używanie klas LiveConnect</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Konwersja_typu_danych" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Konwersja_typu_danych">Konwersja typu danych</a></dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Konwersja_typu_danych/Konwersja_JavaScript_do_Java" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Konwersja_typu_danych/Konwersja_JavaScript_do_Java">Konwersja JavaScript do Java</a></dd> + </dl> + </dd> +</dl> + +<dl> + <dd> + <dl> + <dd><a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Podgl%C4%85d_klas_LiveConnect/Konwersja_typu_danych/Konwersja_Java_do_JavaScript" title="pl/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Konwersja_typu_danych/Konwersja_Java_do_JavaScript">Konwersja Java do JavaScript</a></dd> + </dl> + </dd> +</dl> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_komentarzy/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_komentarzy/index.html new file mode 100644 index 0000000000..4c7477d922 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_komentarzy/index.html @@ -0,0 +1,26 @@ +--- +title: Instrukcje komentarzy +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_komentarzy +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +--- +<p> +</p> +<h3 id="Komentarze" name="Komentarze"> Komentarze </h3> +<p>komentarze są notatkami autora, które wyjaśniają co znaczy dany kawałek kodu. Komentarze nie są wczytywane przez przeglądarkę. W JavaScript mamy ten sam styl komentarzy co w Java i C++: +</p> +<ul><li> Komentarze w pojedyńczej linii są wstawiane za pomoca podwójnych znaków slash (//). +</li><li> Komentarze blokowe są wstawiane za pomoca /* i następnie zakończone */: +</li></ul> +<p><b>Przykład</b><br> +Następujący kod pokazuje komentarze: +</p> +<pre>// To jest pojedyńczy komentarz. + +/* To jest komentarz blokowy. Może być dowolnej długości i wstwiać go możemy w +każdym miejscu, gdzie tylko będziemy chcieli. */ +</pre> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Comments", "es": "es/Gu\u00eda_JavaScript_1.5/Sentencias_para_comentarios", "fr": "fr/Guide_JavaScript_1.5/Commentaires", "ja": "ja/Core_JavaScript_1.5_Guide/Comments" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_manipulacji_obiektem/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_manipulacji_obiektem/index.html new file mode 100644 index 0000000000..45442f2c63 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Instrukcja_manipulacji_obiektem" name="Instrukcja_manipulacji_obiektem">Instrukcja manipulacji obiektem</h3> +<p>JavaScript używa instrukcji <strong>for...in</strong> i <strong>with</strong> do manipulacji obiektami.</p> +<h4 id="Instrukcja_for...in" name="Instrukcja_for...in">Instrukcja for...in</h4> +<p>Instrukcja <code><strong>for...in</strong></code> cyklicznie powtarza specyficzną wartość wszystkich właściwości obiektu. Dla każdej oddzielnej właściwości, JavaScript wykonuje specyficzna instrukcję. Instrukcja <code><strong>for...in</strong></code> wygląda jak pętle:</p> +<pre>for (variable in object) { + instrukcje +} +</pre> +<p><strong>Przykład</strong><br> + 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.</p> +<pre>function dump_props(obj, obj_name) { + var result = ""; + for (var i in obj) { + result += obj_name + "." + i + " = " + obj[i] + "<BR>" + } + result += "<HR>"; + return result; +} +</pre> +<p>Dla obiektu <code><strong>car</strong></code> z właściwościami <code><strong>make</strong></code> i <code><strong>model</strong></code>, będzie rezultat:</p> +<pre>car.make = Ford +car.model = Mustang +</pre> +<h4 id="Instrukcja_with" name="Instrukcja_with">Instrukcja with</h4> +<p>Instrukcja <code><strong>with</strong></code> nawiązuje z domyślnym obiektem <code><strong>for</strong></code> 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.</p> +<p>Składnia pętli <code><strong>with</strong></code> wygląda:</p> +<pre>with (object){ + instrukcja +} +</pre> +<p><strong>Przykład</strong><br> + Następująca instrukcja <code><strong>with</strong></code> określa, że obiekt <code><strong>Math</strong></code> jest obiektem domyślnym. Następująca instrukcja <code><strong>with</strong></code> odwołuje sie do właściwości instrukcji metod <code><strong>PI</strong></code> i <code><strong>cos</strong></code> i <code><strong>sin</strong></code>, bez specyficznego obiektu. JavaScript bierze na siebie obiekt <code><strong>Math</strong></code> dla tych referencji.</p> +<pre>var a, x, y; +var r=10 +with (Math) { + a = PI * r * r; + x = r * cos(PI); + y = r * sin(PI/2); +} +</pre> +<p>Nota: Używając instrukcji <a href="/pl/Dokumentacja_j%C4%99zyka_JavaScript_1.5/Polecenia/with" title="pl/Dokumentacja_języka_JavaScript_1.5/Polecenia/with">with</a> znacząco spowolniasz jego działanie.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_obsługi_wyjątków/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_obsługi_wyjątków/index.html new file mode 100644 index 0000000000..a31e3144d3 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_obsługi_wyjątków/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 +--- +<p> </p> +<h3 id="Instrukcje_obs.C5.82ugi_wyj.C4.85tk.C3.B3w" name="Instrukcje_obs.C5.82ugi_wyj.C4.85tk.C3.B3w">Instrukcje obsługi wyjątków</h3> +<p>Możesz wywoływać wyjątki używając instrukcji <code>throw</code> i obsługiwać je za pomocą instrukcji <code>try...catch</code>.</p> +<p>Instrukcji <code>try...catch</code> używa się również do obsługi wyjątków Javy. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_JavaScript_a_Java#Obs.C5.82uga_wyj.C4.85tk.C3.B3w_Javy_w_JavaScript">Obsługa wyjątków Javy w JavaScript</a> i <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_Java_a_JavaScript">Komunikacja między Java a JavaScript</a>, aby uzyskać więcej informacji.</p> +<ul> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_obs%c5%82ugi_wyj%c4%85tk%c3%b3w/Instrukcja_throw">Instrukcja throw</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_obs%c5%82ugi_wyj%c4%85tk%c3%b3w/Instrukcja_try...catch">Instrukcja try...catch</a></li> +</ul> +<h3 id="Typy_wyj.C4.85tk.C3.B3w" name="Typy_wyj.C4.85tk.C3.B3w">Typy wyjątków</h3> +<p>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:</p> +<ul> + <li>Wyjątki ECMAScript: + <ul> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Error">Error</a></li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/EvalError">EvalError</a></li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/RangeError">RangeError</a></li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/ReferenceError">ReferenceError</a></li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/SyntaxError">SyntaxError</a></li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/TypeError">TypeError</a></li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/URIError">URIError</a></li> + </ul> + </li> + <li>Wyjątki DOM: + <ul> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/DOMException">DOMException</a></li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/EventException">EventException</a></li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/RangeException">RangeException</a></li> + <li>... (?)</li> + </ul> + </li> + <li><a href="pl/NsIXPCException">nsIXPCException</a> (<a href="pl/XPConnect">XPConnect</a>)</li> +</ul> +<p>{{ 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") }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_obsługi_wyjątków/instrukcja_throw/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_obsługi_wyjątków/instrukcja_throw/index.html new file mode 100644 index 0000000000..d09220143a --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_obsługi_wyjątków/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 +--- +<div class="noinclude"> + <h3 id="Instrukcja_throw" name="Instrukcja_throw">Instrukcja throw</h3> + <p>Użyj instrukcji <code>throw</code>, aby wywołać wyjątek. Gdy wywołujesz wyjątek, określasz wyrażenie zawierające wartość, która ma zostać wywołana:</p> + <pre class="eval">throw wyrazenie; +</pre> + <p>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:</p> + <pre class="eval">throw "Error2"; +throw 42; +throw true; +throw {toString: function() { return "Jestem obiektem!"; } }; +</pre> + <div class="note"> + <b>Uwaga:</b> Możesz określić obiekt podczas wywoływania wyjątku. Można się wtedy odnieść do własności obiektu w bloku <code>catch</code>. Poniższy przykład tworzy obiekt <code>myUserException</code> typu <code>UserException</code> i używa go w instrukcji throw.</div> + <p> </p> + <pre class="eval">// 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ść"); +</pre> + <div class="noinclude"> + <p>{{ 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") }}</p> + </div> +</div> +<p> </p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_obsługi_wyjątków/instrukcja_try...catch/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_obsługi_wyjątków/instrukcja_try...catch/index.html new file mode 100644 index 0000000000..229633025c --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_obsługi_wyjątków/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 +--- +<p> </p> +<h3 id="Instrukcja_try...catch" name="Instrukcja_try...catch">Instrukcja <code><b>try...catch</b></code></h3> +<p>Instrukcja <code><b>try...catch</b></code> ś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 <code><b>try...catch</b></code> go łapie.</p> +<p>Instrukcja <code><b>try...catch</b></code> stanowi blok <code><b>try</b></code>, który stanowi jedną lub więcej instrukcji, i zero lub więcęj bloków stanowiących <code><b>catch</b></code>, 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 <code><b>try</b></code>, i jeśli nie nastąpi, chcesz przejąć kontrolę bloku <code><b>catch</b></code>. Jeśli jakakolwiek instrukcja bez bloku <code><b>try</b></code> (lub w nazwie funkcji nie występuje blok <code><b>try</b></code>) wyrzucany jest wyjątek, kontrola natychmiastowo wraca do bloku wyjątku, <code><b>catch</b></code>. Jeśli nie jest wyrzucony wyjątek w następującym bloku <code><b>try</b></code>, blok <code><b>catch</b></code> zostanie opuszczony. Blok kończący (finall) wykonany jest po wykonanych blokach <code><b>try</b></code> i <code><b>catch</b></code> przed instrukcjami następująca instrukcja <code><b>try...catch</b></code>.</p> +<p>Następujący przykład używa instrukcji <code><b>try...catch</b></code>. 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 <code><b>InvalidMonthNo</b></code> i instrukcje w bloku <code>catch</code> ustawiają zmienną <code><b>monthName</b></code> na <code><b>unknown</b></code>.</p> +<pre>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 +} +</pre> +<h4 id="Blok_catch" name="Blok_catch">Blok <code><b>catch</b></code></h4> +<p>Użyj pojedyńczego bloku <code><b>catch</b></code> do uchwytu wszystkich wyjątków, które mogą generować w bloku <code><b>try</b></code>, lub Ty potrafisz użyć separatora bloków <code><b>catch</b></code>, każdego, którego uchwyty są szczególnym typem wyjątku.</p> +<p><b>Pojedyńczy blok catch</b><br> + Użyj pojedyńczej instrukcji <code><b>try...catch</b></code>, bloku <code><b>catch</b></code> (odzyskanie bloku) wykonane kodu błędu uchwytu dla kazdego wyjątku wyrzuconego w bloku <code><b>try</b></code>.</p> +<p>Pojedyńczy blok <code><b>catch</b></code> ma następującą składnie:</p> +<pre>catch (catchID) { + statements +} +</pre> +<p>Blok <code><b>catch</b></code> wyszczególnia identyfikatory (<code><b>catchID</b></code> w poprzedzającej składni), którego wartość jest trzymana w bliżej określnonej instrukcji <code><b>throw</b></code>; użyj tego identyfikatora do pobrania informacji o wyjątku, który był zrzucony. JavaScript tworzy ten identyfikator, kiedy <code><b>catch</b></code> jest wstępem; ostatni identyfikator tylko dla czasu działanaia bloku <code><b>catch</b></code>; po bloku <code><b>catch</b></code> kończy wykonywanie identyfikatora, który jest nie długo dostępny.</p> +<p>Na przykład, następujący kod wyrzuca wyjątek. Kiedy wyjątek ma miejsce kontrolne cesje są w bloku <code><b>catch</b></code>.</p> +<pre>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 +} +</pre> +<p><b>Wielokrotne bloki catch</b><br> + Pojedyńcza instrukcja <code><b>try</b></code> stanowi wielokrotny warunkowe bloki <code><b>catch</b></code>, każdy który trzyma określony typ wyjątku. W tym przypadku przywłaszcza odpowiedni warunek blok <code><b>catch</b></code> 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 <code><b>catch-all catch</b></code> jako finalnego bloku w instrukcji bloku catch.</p> +<p>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.</p> +<pre>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); +} +</pre> +<p>Blok warunkowy <code><b>catch</b></code> kontroluje drogę dobierając odpowiedni uchwyt wyjątku.</p> +<pre>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) +} +</pre> +<h4 id="Blok_finally" name="Blok_finally">Blok <code><b>finally</b></code></h4> +<p>Blok <code><b>finally</b></code> stanowi instrukcja wykonywana po sprawdzeniu i wykonaniu bloku <code><b>catch</b></code>, ale przed następującą instrukcją <code><b>try...catch</b></code>. Blok <code><b>finally</b></code> wykonany gdziekolwiek lub nie jest wyjątkiem <code><b>thrown</b></code>. Jeśli wyjątek jest <code><b>thrown</b></code>, instrukcje w bloku <code><b>finally</b></code> wykonane równo, jeśli blok <code><b>catch</b></code> trzyma wyjątek.</p> +<p>Możesz używać bloku <code><b>finally</b></code> 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 <code><b>finally</b></code> zamyka pliki przed danymi skryptami.</p> +<pre>openMyFile(); +try { + writeMyFile(theData) +} +finally { + closeMyFile() // zawsze zamykaj źródło +} +</pre> +<h4 id="Zagnie.C5.BCd.C5.BCanie_instrukcji_try...catch" name="Zagnie.C5.BCd.C5.BCanie_instrukcji_try...catch">Zagnieżdżanie instrukcji <code><b>try...catch</b></code></h4> +<p>Żądaj jeden lub więcej instrukcji <code><b>try...catch</b></code>. Jeśli wewnętrzna instrukcja <code><b>try...catch</b></code> nie ma bloku catch, otoczamy blok catch i instrukcja <code><b>try...catch</b></code> jest zaznaczona dla danej wartości.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/index.html new file mode 100644 index 0000000000..f4b9e92afb --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/index.html @@ -0,0 +1,23 @@ +--- +title: Instrukcje pętli +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_pętli +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +--- +<p> +</p> +<h3 id="Instrukcje_p.C4.99tli" name="Instrukcje_p.C4.99tli"> Instrukcje pętli </h3> +<p>Pętle są to specjalnie ustawione polecenia, które wykonują wielokrotnie kod, aż do spotkania specyficznych wartości. JavaScript wspiera instrukcję pętli for, do while, i while, albo well albo label (etykieta nie instrukcją pętli, ale jest często użyta z tą instrukcjami). Uzupełniając, możesz użyć instrukcji <code><b>break</b></code> i <code><b>continue</b></code> wewnątrz instrukcji pętli. </p><p>Następna instrukcja, <code><b>for...in</b></code>, wykonuje wielokrotnie ale jest użyta do manipulacji obiektem. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_manipulacji_obiektem">Instrukcje manipulacji obiektem</a>. +</p><p>Instrukcjami pętli są:<br> +</p> +<ul><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_p%c4%99tli/Instrukcja_for">Instrukcja for</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_p%c4%99tli/Instrukcja_do_...while">Instrukcja do...while</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_p%c4%99tli/Instrukcja_while">Instrukcja while</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_p%c4%99tli/Instrukcja_label">Instrukcja label</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_p%c4%99tli/Instrukcja_break">Instrukcja break</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_p%c4%99tli/Instrukcja_continue">Instrukcja continue</a> +</li></ul> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Loop_Statements", "es": "es/Gu\u00eda_JavaScript_1.5/Sentencias_de_bucle", "fr": "fr/Guide_JavaScript_1.5/Boucles", "ja": "ja/Core_JavaScript_1.5_Guide/Loop_Statements" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_break/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_break/index.html new file mode 100644 index 0000000000..108f315058 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/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 +--- +<p> </p> +<h3 id="Instrukcja_break" name="Instrukcja_break">Instrukcja <code>break</code></h3> +<p>Użyjemy instrukcji <code><b>break</b></code> chcąc zakończyć jedną z instrukcji <code><b> pętli switch</b>, lub <b>label</b></code> .</p> +<ul> + <li>Kiedy użyjemy <code><b>break</b></code> to przerwana zostanie natychmiast najgłębsza instrukcja <code><b>while, do-while, for,</b></code> lub <code><b>switch</b></code> i kontrola przekazana zostanie do następnej instrukcji.</li> + <li>Kiedy użyjemy <code><b>break</b></code> z etykietą, to przerwana zostanie specyficzna instrukcja o nazwie tej etykiety.</li> +</ul> +<p>Składnia instrukcji <code><b>break</b></code> wygląda jak poniższy przykład:</p> +<pre>1. break +2. break label +</pre> +<p>Pierwsza forma składni przerywa najgłębszą otoczoną nawiasami lub instrukcje pętlę <code><b>switch</b></code>; druga forma składni przerywa specjalnie pętlę zamkniętą i oznaczoną etykietę instrukcji.</p> +<p><b>Przykład</b><br> + Następujący przykład powtarza pętle poprzez elementy w tablicy aż do momentu, znalezienia element indeksu, który jest wartością <code><b>theValue</b></code>:</p> +<pre>for (i = 0; i < a.length; i++) { + if (a[i] = theValue) + break; +} +</pre> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_continue/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_continue/index.html new file mode 100644 index 0000000000..dee2eda4ee --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/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 +--- +<p> </p> +<h3 id="Instrukcja_continue" name="Instrukcja_continue">Instrukcja <code>continue</code></h3> +<p>Instrukcja <code><b>continue</b></code> możemy użyć do ponownego uruchomienia instrukcji <code><b>while, do-while, for,</b></code> lub <code><b>label</b></code> tzw. etykiety.</p> +<ul> + <li>Kiedy użyjemy instrukcji <code><b>continue</b></code> bez label, to zostanie przerwana aktualnie wykonywana iteracja najgłębszej instrukcji otoczonej kodem <code><b>while, do-while</b></code> lub <code><b>for</b></code>, która będzie kontynuowała wykonanie następnej pętli z iteracją. Przeciwieństwem jest instrukcja <code><b>break</b></code>, <code><b>continue</b></code> nie zostanie przerwane wykonywanie w całości. W pętli <code><b>while</b></code>, to kod zostanie zawrócony wg warunków określonych w kodzie. W pętli <code><b>for</b></code>, to wykona przyrost wyrażenia.</li> + <li>Kiedy użyjemy <code><b>continue</b></code> z <code><b>label</b></code>, to nakłada się do instrukcji pętli identyfikującej się z <code><b>label</b></code>.</li> +</ul> +<p>Składnia instrukcji <code><b>continue</b></code> wygląda następująco:</p> +<ol> + <li><code><b>continue</b></code></li> + <li><code><b>continue label</b></code></li> +</ol> +<p><b>Przykład 1</b><br> + Następujący przykład pokazuje pętlę <code><b>while</b></code> z instrukcja <code><b>continue</b></code>, która jest wykonana wtedy, gdy wartość <code><b>i</b></code> jest liczbą trzy. W ten sposób, <code><b>n</b></code> pobiera wartości jeden, trzy, siedem, dwanaście.</p> +<pre class="eval">i = 0; +n = 0; +while (i < 5) { + i++; + if (i == 3) + continue; + n += i; +} +</pre> +<p><b>Przykład 2</b><br> + Etykieta instrukcji <code><b>checkiandj</b></code> stanowi etykietę instrukcji <code><b>checkj</b></code>. Jeśli <code><b>continue</b></code> zostanie napotkane, program przerwie aktualnie wykonywaną iterację <code><b>checkj</b></code> i rozpocznie następną iterację. Za każdym razem, gdy <code><b>continue</b></code> zostanie napotkane, <code><b>checkj</b></code> wykonuje ponownie iterację aż do momentu, gdy warunek stanie się nieprawdziwy. Kiedy został napotkany nieprawdziwy warunek, to powtarza, reszta instrukcji <code><b>checkiandj</b></code> jest dopełniona, i <code><b>checkiandj</b></code> ponownie iteruje aż jego warunek zwróci wartość nieprawdziwą. Kiedy <b>false</b> jest zwracany, to program kontynuuje następującą instrukcję <code><b>checkiandj</b></code>.</p> +<p>Jeśli <code><b>continue</b></code> miało pętlę <code><b>checkiandj</b></code>, to program będzie kontynuował instrukcję <code><b>checkiandj</b></code>, aż osiągnie jej najwyższą wartość.</p> +<pre>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/>"); + } +</pre> +<p> </p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_do_...while/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_do_...while/index.html new file mode 100644 index 0000000000..6c770f4ae6 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/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 +--- +<p> </p> +<h4 id="Instrukcja_do...while" name="Instrukcja_do...while">Instrukcja <code>do...while</code></h4> +<p>Instrukcja <code><b>do...while</b></code> powtarza specyficzny warunek, aż do momentu, kiedy uzna go za fałszywy. Instrukcja <code><b>do...while</b></code> wygląda następująco:</p> +<pre class="eval">do + statement +while (condition); +</pre> +<p>Instrukcja (<code><b>statement</b></code> zostanie wykonany raz, zanim warunek zostanie sprawdzony. Jeśli warunek (<code><b>condition</b></code>) 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 <code><b>do...while</b></code>.</p> +<p><b>Przykład</b><br> + 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.</p> +<pre class="eval">do { + i += 1; + document.write(i); +} while (i < 5); +</pre> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_for/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_for/index.html new file mode 100644 index 0000000000..c13c4558fb --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/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 +--- +<p> </p> +<h3 id="Instrukcja_for" name="Instrukcja_for">Instrukcja <code>for</code></h3> +<p>Pętla <code><b>for</b></code> jest powtarzana aż do momentu, kiedy testowany warunek staje się fałszywy. W JavaScript pętla <code><b>for</b></code> jest podobna do pętli w Java i C. Instrukcja pętli <code><b>for</b></code> wygląda następująco:</p> +<pre>for ([przypisanie]; [warunek]; [zmiana]) { + Instrukcje +} +</pre> +<p>Kiedy pętla <code><b>for</b></code> jest wykonywana to mają miejsce:</p> +<ol> + <li>Inicjalizacja wyrażenia <code><b>przypisanie</b></code>, 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.</li> + <li>Wyrażenie <code><b>warunek</b></code> jest wykonane. Jeśli wartość <code><b>warunek</b></code> jest prawdziwa, instrukcja pętli jest wykonana. Jeśli wartość <code><b>warunek</b></code> jest fałszywa, pętla <code><b>for</b></code> jest przerwana. Jeśli wyrażenie <code><b>warunek</b></code> jest w całości opuszczone, warunek to bierze na siebie, jeśli jest prawdziwy.</li> + <li>Wykonuje <code><b>instrukcje</b></code>.</li> + <li>Aktualizuje wyrażenia <code><b>zmiana</b></code>, jeśli jedna wykonywana to kontrola jest przekazywana do kroku drugiego.</li> +</ol> +<p><b>Przykład</b><br> + Następująca funkcja stanowi instrukcję <code><b>for</b></code>, która to tworzy licznik zaznaczonych opcji w liście przewijanej (obiekt <b>Select</b>, który pozwala na wielokrotne zaznaczenia). Instrukcja <code><b>for</b></code> deklaruje zmienną <code><b>i</b></code> i inicjuje ją od zera. Sprawdza, które <code><b>i</b></code> jest mniejsze niż liczba opcji w obiekcie <code><b>Select</b></code> wykonując kolejną instrukcję <code><b>if</b></code>, i zwiększa <code><b>i</b></code> o jeden po każdej wykonanej pętli.</p> +<pre><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> +</pre> +<p> </p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_label/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_label/index.html new file mode 100644 index 0000000000..e95a452b8f --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/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 +--- +<p> </p> +<h3 id="Instrukcja_label" name="Instrukcja_label">Instrukcja <code>label</code></h3> +<p>Instrukcja <code><b>label</b></code> dostarcza instrukcję wraz z identyfikatorem, który odnosi się całkiem gdzie indziej w Twoim programie. Na przykład, możesz użyć <code><b>label</b></code> do zidentyfikowania pętli i następnie w niej użyć instrukcję <code><b>break</b></code> lub <code><b>continue</b></code>, do wskazania miejsca gdzie program powinien zinterpretować pętlę lub kontynuować jego wykonanie.</p> +<p>Składnia instrukcji <code><b>label</b></code> wygląda następująco:</p> +<pre>label : + Instrukcja +</pre> +<p>Wartością <code><b>label</b></code> może być w JavaScript identyfikator, który jest nie zarezerwowanym słowem. <code><b>Instrukcja</b></code> to identyfikujesz z etykietą, która może być jakąś instrukcją.</p> +<p><b>Przykład</b><br> + W tym przykładzie, etykieta <code><b>markLoop</b></code> identyfikuje pętle while.</p> +<pre>markLoop: +while (theMark == true) + doSomething(); +} +</pre> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_while/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/instrukcja_while/index.html new file mode 100644 index 0000000000..48ecacaa70 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_pętli/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 +--- +<p> </p> +<h3 id="Instrukcja_while" name="Instrukcja_while">Instrukcja <code>while</code></h3> +<p>Instrukcja <code><b>while</b></code> wykonuje instrukcje tak długo, dopóki warunek będzie prawdziwy. Instrukcja pętli <code><b>while</b></code> wygląda następująco:</p> +<pre>while (warunek) { + instrukcje +} +</pre> +<p>Jeśli warunek stanie się fałszywy, instrukcja wewnątrz pętli zatrzyma wykonywanie i identyfikatorach kontroli w instrukcji następującej pętli.</p> +<p>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 <code><b>while</b></code>.</p> +<p><b>Przykład 1</b><br> + Następująca pętla <code><b>while</b></code> wykonuje iterację (powtarza) tak długo aż <b>n</b> jest mniejsze od trzech:</p> +<pre>n = 0; +x = 0; +while( n < 3 ) { + n ++; + x += n; +} +</pre> +<p>Do każdej wykonanej pętli iteracji, przyrost pętli <code><b>n</b></code> i dodanie te wartości <code><b>x</b></code>. Dlatego, <code><b>x</b></code> i <code><b>n</b></code> pobierają następujące wartości:</p> +<ul> + <li>Po pierwszym przejściu: <code><b>n</b></code> = 1 i <code><b>x</b></code> = 1</li> + <li>Po drugim przejściu: <code><b>n</b></code> = 2 i <code><b>x</b></code> = 3</li> + <li>Po trzecim przejściu: <code><b>n</b></code> = 3 i <code><b>x</b></code> = 6</li> +</ul> +<p>Po uzupełnieniu trzeciego przejścia, warunek <code><b>n</b></code> < 3 jest wartość prawdziwa, więc pętla zostanie przerwana.</p> +<p><b>Przykład 2</b><br> + 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 <code><b>while</b></code> występuje bezustannie, ponieważ warunek nigdy nie stanie się fałszywy.</p> +<pre>while (true) { + alert("Hello, world") } +</pre> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_warunkowe/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_warunkowe/index.html new file mode 100644 index 0000000000..8c314362fd --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/instrukcje_warunkowe/index.html @@ -0,0 +1,89 @@ +--- +title: Instrukcje warunkowe +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Instrukcje_warunkowe +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +--- +<p> +</p> +<h3 id="Instrukcja_warunkowa" name="Instrukcja_warunkowa"> Instrukcja warunkowa </h3> +<p>Instrukcja warunkowa jest zestawem poleceń wykonywanych, jeżeli dany warunek jest spełniony JavaScript obsługuje dwie instrukcje warunkowe:if...else i switch. +</p> +<h4 id="Instrukcja_if...else" name="Instrukcja_if...else"> Instrukcja if...else </h4> +<p>Instrukcja <code><b>if</b></code> powoduje wykonanie kodu źródłowego <code>instrukcja1</code> tylko wtedy, gdy <code>warunek</code> logiczny jest spełniony. Jeżeli zostanie użyty poszerzony wariant instrukcji <code>if</code>, to po spełnieniu warunku zostanie wykonany kod <code>instrukcja1</code> lecz w przeciwnym wypadku zostanie wykonany kod <code>instrukcja2</code>. Instrukcja <code><b>if</b></code> ma postać: +</p> +<pre>if (warunek) { + instrukcja1 +} +[else { + instrukcja2 +} ] +</pre> +<p>Jakiekolwiek wyrażenie w JavaScript może mieć warunek, który jest oceniany czy jest on prawdziwy lub fałszywy. Instrukcja wykonuje jakąkolwiek instrukcję zawartą w JavaScript, włączając pomoc zagnieżdżonym instrukcjom if. Jeśli chcesz użyć więcej niż po instrukcji <code><b>if</b></code> lub instrukcji <code><b>else</b></code> musisz otoczyć instrukcję nawiasami klamrowymi, {}. +</p><p>Nie powinieneś używać prostych zadań używając instrukcji warunkowej. Na przykład, nie używaj następującego kodu: </p> +<pre>if(x = y) +{ + /* coś jest wykonywane */ +} +</pre> +<p>Jeśli potrzebujesz użyć instrukcji warunkowej, aby wykonać zadanie, wstaw dodatkowy nawias wokół zadania. Na przykład, użyj if( (x = y) ). +</p><p>Nie pomieszaj wartości prymitywnej logicznej true i false z true i false wartości logicznej obiektu. Jakikolwiek obiekt, którego wartość nie jest zidentyfikowana, null, zero, NaN, lub pusty łańcuch znaków, włączając obiekt logiczny, którego wartość jest fałszem staje się prawdziwy, kiedy przechodzi w instrukcję warunkową. Na przykład: +</p> +<pre>var b = new Boolean(false); +if (b) // ten warunek jest prawdziwy +</pre> +<p><b>Przykład</b><br> +Następujący przykład funkcji <code><b>checkData</b></code> zwraca true i numer czcionki w obiekcie <code><b>Text</b></code> są trzy; W drugą stronę, to wyświetli alert ostrzegawczy i zwróci Ci false. +</p> +<pre>function checkData () { + if (document.form1.threeChar.value.length == 3) { + return true + } else { + alert("Enter exactly three characters. " + + document.form1.threeChar.value + " is not valid.") + return false + } +} +</pre> +<h4 id="Instrukcja_switch" name="Instrukcja_switch"> Instrukcja switch </h4> +<p>Instrukcja <code><b>switch</b></code> pozwala programowi na sprawdzenie ciągu warunków i próbuje wykonać wartość wyrażenia przypisana do odpowiedniej etykiety case. Jeśli jest to wyrażenie znalezione, program wykonuje załączoną instrukcję. Instrukcja <code><b>switch</b></code> wygląda w następujący sposób: +</p> +<pre>switch (expression){ + case label : + statement; + break; + case label : + statement; + break; + ... + default : statement; +} +</pre> +<p>Najpierw program szuka etykietę odpowiedniego wyrażenia i wykonuje załączoną instrukcję. Jeśli znaleziona zostaje nie odpowiednia etykieta, program szuka domyślnej instrukcji i jeśli znajdzie wykonuje załączoną instrukcję. Jeśli nie domyślna instrukcja jest znaleziona, program kontynuuje wykonywanie instrukcji aż do końca instrukcji <code><b>switch</b></code>. +</p><p>Opcjonalnie instrukcja <code><b>break</b></code> połączona z każdą etykietą case zapewnia przerwanie programu z całego bloku <code><b>switch</b></code> odpowiednio raz jak jest wykonana instrukcja i kontynuuje wykonywanie następnej instrukcji switch. Jeśli opuszcza <code><b>break</b></code>, program kontynuuje wykonywanie aż do następnej instrukcji w <code><b>switch</b></code>. +</p><p><b>Przykład</b><br> +W następującym przykładzie, jeśli <code><b>expr</b></code> sprawdza "Bananas", program szuka odpowiednią wartość z case "Bananas" i wykonuje załączoną instrukcję. Kiedy napotka <code><b>break</b></code>, progaram przerywa <code><b>switch</b></code>. Jeśli <code><b>break</b></code> zostało opuszczone, instrukcja zostanie wykonana dla case "Cherries". +</p> +<pre>switch (expr) { + case "Oranges" : + document.write("Oranges are $0.59 a pound.<BR>"); + break; + case "Apples" : + document.write("Apples are $0.32 a pound.<BR>"); + break; + case "Bananas" : + document.write("Bananas are $0.48 a pound.<BR>"); + break; + case "Cherries" : + document.write("Cherries are $3.00 a pound.<BR>"); + break; + default : + document.write("Sorry, we are out of " + i + ".<BR>"); +} + +document.write("Is there anything else you'd like?<BR>"); +</pre> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Conditional_Statements", "fr": "fr/Guide_JavaScript_1.5/Instructions_conditionnelles", "ja": "ja/Core_JavaScript_1.5_Guide/Conditional_Statements" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/literały/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/literały/index.html new file mode 100644 index 0000000000..ac080fcbb4 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/literały/index.html @@ -0,0 +1,207 @@ +--- +title: Literały +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Literały +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +--- +<p> +</p> +<h3 id="Litera.C5.82y" name="Litera.C5.82y"> Literały </h3> +<p>Literałów używa się w celu przedstawiania wartości w JavaScript. Są one ustalonymi wartościami (a nie zmiennymi), które <i>dosłownie</i> podajesz w swoim skrypcie. Ten fragment opisuje następujące typy literałów: </p> +<ul><li> {{ Anch("Literały tablicy") }} +</li><li> {{ Anch("Literały logiczne") }} +</li><li> {{ Anch("Literały zmiennoprzecinkowe") }} +</li><li> {{ Anch("Literały całkowite") }} +</li><li> {{ Anch("Literały obiektu") }} +</li><li> {{ Anch("Literały znakowe") }} +</li></ul> +<h4 id="Litera.C5.82y_tablicy" name="Litera.C5.82y_tablicy"> Literały tablicy </h4> +<p>Literał tablicy jest listą składającą się z zera lub większej liczby wyrażeń, z których każdy reprezentuje element tablicy, a które zamknięte są w nawiasach kwadratowych ([]). Tablica tworzona za pomocą literału tablicy zostaje zainicjalizowana podanymi wartościami jako jej elementami, a jej długość jest ustalone według liczby podanych argumentów. +</p><p>Poniższy przykład tworzy tablicę <code>kawy</code> z trzema elementami i o długości trzy: +</p> +<pre>kawy = ["Arabica", "Columbiana", "Zbożowa"]</pre> +<p><b>Uwaga</b> Literał tablicy jest typem inicjatora obiektu. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/U%c5%bcywanie_inicjacji_obiektu">Używanie inicjatorów obiektu</a>. +</p><p>Jeśli tablica została utworzona przy pomocy literału w skrypcie najwyższego poziomu, JavaScript interpretuje tablicę za każdym razem, gdy przelicza wyrażenie zawierające literał tablicowy. Dodatkowo literał użyty w funkcji jest tworzony przy każdym wywołaniu funkcji. +</p><p>Literały tablicy są także obiektami <code>Array</code>. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Array">obiekt <code>Array</code></a>, aby uzyskać więcej informacji o obiektach <code>Array</code>. +</p><p><b>Dodatkowe przecinki w literale tablicy</b> +</p><p>Nie musisz określać w literale tablicy wszystkich elementów. Jeśli postawisz kolejno dwa przecinki, zostanie utworzony obiekt <code>array</code> z pustym miejscem dla niesprecyzowanych elementów. Poniższy przykład tworzy tablicę <code>ryba</code>: +</p> +<pre>ryba = ["Piła", , "Młot"]</pre> +<p>Tablica ta posiada dwa elementy z wartościami i jeden pusty element (wartość <code>ryba{{ mediawiki.external(0) }}</code> to "Piła", <code>ryba{{ mediawiki.external(1) }}</code> jest niezdefiniowana, a <code>ryba{{ mediawiki.external(2) }}</code> to "Młot"): +</p><p>Jeśli na końcu listy elementów umieścisz dodatkowy przecinek, jest on ignorowany. W poniższym przykładzie długość <code>tablicy</code> jest równa trzy. Nie istnieje <code>mojaLista{{ mediawiki.external(3) }}</code>. Wszystkie inne przecinki w liście wskazują nowy element. </p> +<pre>mojaLista = ['dom', , 'szkoła', ];</pre> +<p>W kolejnym przykładzie długość <code>tablicy</code> jest równa cztery; nie zdefiniowano wartości dla <code>mojaLista{{ mediawiki.external(0) }}</code> i <code>mojaLista{{ mediawiki.external(2) }}</code>. +</p> +<pre>mojaLista = [ , 'dom', , 'szkoła'];</pre> +<p>W ostatnim przykładzie długość <code>tablicy</code> wynosi cztery i brakuje mojaLista{{ mediawiki.external(1) }} i mojaLista{{ mediawiki.external(3) }}. Tylko ostatni przecinek jest ignorowany. Jest on opcjonalny. +</p> +<pre>mojaLista = ['dom', , 'szkoła', , ];</pre> +<h4 id="Litera.C5.82y_logiczne" name="Litera.C5.82y_logiczne"> Literały logiczne </h4> +<p>Typ logiczny posiada dwie wartości: <code>true</code> i <code>false</code>. +</p><p>Nie wolno mylić pierwotnych wartości logicznych <code>true</code> i <code>false</code> z wartościami prawda i fałsz (true/false) obiektu logicznego. Obiekt logiczny jest obiektem opakowującym pierwotnego typu danych logicznych. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Boolean">obiekt Boolean</a>, aby uzyskać więcej informacji. +</p> +<h4 id="Litera.C5.82y_ca.C5.82kowite" name="Litera.C5.82y_ca.C5.82kowite"> Literały całkowite </h4> +<p>Liczby całkowite mogą być wyrażane jako dziesiętne (podstawa 10), szesnastkowe (podstawa 16) i ósemkowe (podstawa 8). Dziesiętny literał całkowity składa się z sekwencji cyfr bez czołowego 0 (zera). Czołowe 0 (zero) w literale całkowitym wskazuje na literał ósemkowy; Czołowe 0x (lub 0X) wskazuje na literał szesnastkowy. Liczby szesnastkowe mogą zawierać cyfry od 0 do 9 oraz litery a-f lub A-F. Ósemkowe literały całkowite mogą zawierać tylko cyfry od 0 do 7. +</p><p>Ósemkowe literały całkowite są wycofywane i zostały usunięte ze 3 edycji standardu ECMA-262. JavaScript 1.5 wciąż wspiera je dla kompatybilności wstecznej. +</p><p>Przykładami literałów całkowitych są: +</p> +<pre class="eval">0, 117 i -345 (dziesiętne, podstawa 10) +015, 0001 i -077 (ósemkowe, podstawa 8) +0x1123, 0x00111 i -0xF1A7 (szesnastkowe, "hex" lub podstawa 16) +</pre> +<h4 id="Litera.C5.82y_zmiennoprzecinkowe" name="Litera.C5.82y_zmiennoprzecinkowe"> Literały zmiennoprzecinkowe </h4> +<p>Literały zmiennoprzecinkowe mogą mieć następujące części: +</p> +<ul><li> Liczbę dziesiętną całkowitą mogąca posiadać znak (poprzedzona przez "+" lub "-"), +</li><li> Znak dziesiętny ("."), +</li><li> Ułamek (kolejna liczba dziesiętna), +</li><li> Wykładnik. +</li></ul> +<p>Wykładnik stanowi "e" lub "E", po którym następuje liczba całkowita mogąca posiadać znak (poprzedzona przez "+" lub "-"). Literały zmiennoprzecinkowe muszą posiadać co najmniej jedną cyfrę; muszą także posiadać "e" (lub "E") bądź znak dziesiętny. +</p><p>Przykładami literałów zmiennoprzecinkowych są 3.1415, -3.1E12, .1e12 i 2E-12. +</p><p>Ściślej, składnia jest następująca: +</p> +<pre class="eval">[cyfry][.cyfry][(E|e)[(+|-)]cyfry] +</pre> +<p>Na przykład: +</p> +<pre class="eval">3.14 +2345.789 +.3333333333333333333 +</pre> +<h4 id="Litera.C5.82y_obiektu" name="Litera.C5.82y_obiektu"> Literały obiektu </h4> +<p>Literał obiektu stanowi ujęta w nawias klamrowy ({}) lista składająca się z zera lub większej liczby par, które stanowią nazwa własności obiektu oraz przypisana jej wartość. Nie powinno się używać literału obiektu na początku instrukcji. Doprowadzi to do wystąpienia błędu lub nieoczekiwanych zachowań, gdyż { zostanie zinterpretowany jako początek bloku. +</p><p>Poniżej podany jest przykład literału obiektu. Pierwszy element obiektu <code>auto</code> definiuje własność <code>mojeAuto</code>; drugi element, własność <code>pobierzAuto</code>, wywołuje funkcję <code>(TypyAut("Polonez"));</code> trzeci element, własność <code>specjalne</code>, używa istniejącej zmiennej (<code>Sprzedaz</code>). +</p> +<pre>var Sprzedaz = "Toyota"; + +function TypyAut(nazwa) { + if(nazwa == "Polonez") + return nazwa; + else + return "Przykro nam, ale nie sprzedajemy marki " + nazwa + "."; +} + +auto = {mojeAuto: "Caro", pobierzAuto: TypyAut("Polonez"), specjalne: Sprzedaz} + +document.write(auto.mojeAuto); // Caro +document.write(auto.pobierzAuto); // Polonez +document.write(auto.specjalne); // Toyota</pre> +<p>Dodatkowo, możesz użyć literału znakowego lub liczbowego jako nazwy własności lub zagnieździć obiekt wewnątrz innego. Ilustruje to poniższy przykład. +</p> +<pre>auto = {wieleAut: {a: "Saab", b: "Jeep"}, 7: "Mazda"} + +document.write(auto.wieleAut.b); // Jeep +document.write(auto[7]); // Mazda +</pre> +<p>Zauważ: +</p> +<pre class="eval">foo = {a: "alfa", 2: "dwa"} +document.write (foo.a) // alfa +document.write (foo[2]) // dwa +//document.write (foo.2) // Błąd: brakuje ) po liście argumentów +//document.write (foo[a]) // Błąd: a nie jest zdefiniowane +document.write (foo["a"]) // alfa +document.write (foo["2"]) // dwa +</pre> +<h4 id="Litera.C5.82y_znakowe" name="Litera.C5.82y_znakowe"> Literały znakowe </h4> +<p>Literały znakowe to zero lub więcej znaków zamkniętych w podwójnych (") lub pojedynczych (') znacznikach cytatu. Łańcuch znaków musi być ograniczony przez znaczniki tego samego typu, a więc obydwa pojedyncze lub obydwa podwójne znaki cytatu. Poniżej umieszczono przykłady literałów znakowych: +</p> +<ul><li> "bla" +</li><li> 'bla' +</li><li> "1234" +</li><li> "jedna linia \n kolejna linia" +</li><li> "kot Ali" +</li></ul> +<p>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 <code>String.length</code> z literałem znakowym: +</p> +<ul><li> "kot Ali".length +</li></ul> +<p>Powinieneś użyć literału znakowego, chyba że potrzebujesz szczególnie obiektu String. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_String">obiekt String</a>, aby uzyskać szczegółowe informacje o obiektach String. +</p> +<h5 id="U.C5.BCywanie_specjalnych_znak.C3.B3w_w_.C5.82a.C5.84cuchach" name="U.C5.BCywanie_specjalnych_znak.C3.B3w_w_.C5.82a.C5.84cuchach"> Używanie specjalnych znaków w łańcuchach </h5> +<p>Dodatkowo oprócz znaków zwykłych możesz także włączyć do łańcuchów specjalne znaki, tak jak pokazano w przykładzie: </p> +<pre>"pierwsza linia \n następna linia"</pre> +<p>Poniższa tabela przedstawia znaki specjalne, które możesz użyć w łańcuchach znaków JavaScript. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Znak</th> +<th>Znaczenie</th> +</tr> +<tr> +<td><b>\b</b></td> +<td>Backspace</td> +</tr> +<tr> +<td><b>\f</b></td> +<td>Nowa strona</td> +</tr> +<tr> +<td><b>\n</b></td> +<td>Nowa linia</td> +</tr> +<tr> +<td><b>\r</b></td> +<td>Powrót karetki</td> +</tr> +<tr> +<td><b>\t</b></td> +<td>Tabulacja</td> +</tr> +<tr> +<td><b>\v</b></td> +<td>Tabulacja pionowa</td> +</tr> +<tr> +<td><b>\'</b></td> +<td>Apostrof lub pojedynczy cudzysłów</td> +</tr> +<tr> +<td><b>\"</b></td> +<td>Podwójny cudzysłów</td> +</tr> +<tr> +<td><b>\\</b></td> +<td>Lewy ukośnik (\).</td> +</tr> +<tr> +<td><b>\<i>XXX</i></b></td> +<td>Znaki z kodowaniem Latin-1 określone przez do trzech cyfrósemkowych <i>XXX</i> pomiędzy 0 i 377. Na przykład \251 jest sekwencją ósemkową dla symbolu copyright.</td> +</tr> +<tr> +<td><b>\x<i>XX</i></b></td> +<td>Znaki z kodowaniem Latin-1 określone przez dwie cyfry szesnastkowe <i>XX</i> pomiędzy 00 i FF. Na przykład \xA9 jest szesnastkową sekwencją dla symbolu copyright.</td> +</tr> +<tr> +<td><b>\u<i>XXXX</i></b></td> +<td>Znak Unicode określony przez cztery cyfry szesnastkowe <i>XXXX</i>. Na przykład \u00A9 jest sekwencją Unicode dla symbolu copyright. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Unicode#Sekwencje_ucieczki_do_Unicode">Sekwencje ucieczki do Unicode</a>.</td> +</tr> +</tbody></table> +<p><small><b>Tabela 2.1: Znaki specjalne w JavaScript</b></small> +</p> +<h5 id="Znaki_ucieczki" name="Znaki_ucieczki"> Znaki ucieczki </h5> +<p>Dla znaków niewymienionych w tabeli powyżej, poprzedzający znak backslash jest ignorowany, ale użycie tego jest wycofywane i powinno być unikane. +</p><p>Możesz wstawić znak cudzysłowu wewnątrz łańcucha znaków poprzedzając go znakiem backslash. Znane jest to jako <i>kodowanie</i> (<i>escaping</i>) znaków cudzysłowu. Na przykład: +</p> +<pre>var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service." +document.write(quote) +</pre> +<p>Rezultatem tego będzie: +</p> +<pre>He read "The Cremation of Sam McGee" by R.W. Service. +</pre> +<p>Aby użyć literału backslash w łańcuchu znaków, musisz zastosować znak backslash. Na przykład, aby przydzielić plikowi ścieżkę <code><b>c:\temp</b></code> do łańcucha znaków, użyj następującej konstrukcji: +</p> +<pre>var home = "c:\\temp " +</pre> +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Stałe", "Przewodnik po języku JavaScript 1.5:Unicode") }} +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Literals", "es": "es/Gu\u00eda_JavaScript_1.5/Literales", "fr": "fr/Guide_JavaScript_1.5/Constantes_litt\u00e9rales", "ja": "ja/Core_JavaScript_1.5_Guide/Literals", "ko": "ko/Core_JavaScript_1.5_Guide/Literals", "zh-cn": "cn/Core_JavaScript_1.5_Guide/\u6587\u672c\u5316" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/o_tym_przewodniku/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/o_tym_przewodniku/index.html new file mode 100644 index 0000000000..0fd0f2ec8a --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<h3 id="Nowe_mo.C5.BCliwo.C5.9Bci_wersji_JavaScriptu" name="Nowe_mo.C5.BCliwo.C5.9Bci_wersji_JavaScriptu">Nowe możliwości wersji JavaScriptu</h3> + +<ul> + <li><a href="pl/Nowo%c5%9bci_w_JavaScript_1.5">Nowości w JavaScript 1.5</a></li> + <li><a href="pl/Nowo%c5%9bci_w_JavaScript_1.6">Nowości w JavaScript 1.6</a></li> + <li><a href="pl/Nowo%c5%9bci_w_JavaScript_1.7">Nowości w JavaScript 1.7</a></li> + <li><a href="pl/Nowo%c5%9bci_w_JavaScript_1.8">Nowości w JavaScript 1.8</a></li> +</ul> + +<h3 id="Co_ju.C5.BC_powiniene.C5.9B_wiedzie.C4.87" name="Co_ju.C5.BC_powiniene.C5.9B_wiedzie.C4.87">Co już powinieneś wiedzieć</h3> + +<p>Ten dokument zakłada, że jego czytelnik ma podstawowe pojęcie na temat niżej wymienionych dziedzin:</p> + +<ul> + <li>ogólne rozumienie sieci Internet i WWW.</li> + <li>dobra praktyczna znajomość języka HTML (<a href="pl/HTML">HTML</a>).</li> +</ul> + +<p>Przydatne, aczkolwiek nie wymagane, jest doświadczenie w językach programowania takich jak C czy Visual Basic.</p> + +<h3 id="Wersje_JavaScriptu" name="Wersje_JavaScriptu">Wersje JavaScriptu</h3> + +<p>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ść.</p> + +<p>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.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Wersja JavaScript</th> + <th>Wersja Navigatora</th> + </tr> + <tr> + <td>JavaScript 1.0</td> + <td>Navigator 2.0</td> + </tr> + <tr> + <td>JavaScript 1.1</td> + <td>Navigator 3.0</td> + </tr> + <tr> + <td>JavaScript 1.2</td> + <td>Navigator 4.0-4.05</td> + </tr> + <tr> + <td>JavaScript 1.3</td> + <td>Navigator 4.06-4.7x</td> + </tr> + <tr> + <td>JavaScript 1.4</td> + <td> </td> + </tr> + <tr> + <td>JavaScript 1.5</td> + <td>Navigator 6.0<br> + Mozilla (przeglądarka open source)</td> + </tr> + <tr> + <td>JavaScript 1.6</td> + <td><a href="pl/Firefox_1.5">Firefox 1.5</a>, other Mozilla 1.8-based products</td> + </tr> + <tr> + <td>JavaScript 1.7</td> + <td><a href="pl/Firefox_2">Firefox 2</a>, other Mozilla 1.8.1-based products</td> + </tr> + <tr> + <td>JavaScript 1.8</td> + <td><a href="pl/Firefox_3">Firefox 3</a>, other Gecko 1.9-based products</td> + </tr> + </tbody> +</table> + +<p><small><strong>Tablica 1: Wersje JavaScriptu oraz Navigatora</strong></small><br> + </p> + +<p>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ść.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Skrót</th> + <th>Wersja Enterprise Server</th> + </tr> + <tr> + <td>NES 2.0</td> + <td>Netscape Enterprise Server 2.0</td> + </tr> + <tr> + <td>NES 3.0</td> + <td>Netscape Enterprise Server 3.0</td> + </tr> + </tbody> +</table> + +<p><small><strong>Tablica 2: Skróty oraz wersje Netscape Enterprise Server</strong></small></p> + +<h3 id="Gdzie_szuka.C4.87_informacji_o_JavaScripcie" name="Gdzie_szuka.C4.87_informacji_o_JavaScripcie">Gdzie szukać informacji o JavaScripcie</h3> + +<p>Na kompletną bazę informacji o języku JavaScript składają się następujące dokumenty:</p> + +<ul> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5">Przewodnik po języku JavaScript 1.5</a> (ten dokument) - dostarcza informacji na temat samego języka JavaScript i jego obiektów.</li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5">Dokumentacja języka JavaScript 1.5</a> - dostarcza informacji na temat języka JavaScript w formie encyklopedycznej</li> +</ul> + +<p>Jeśli JavaScript stanowi dla Ciebie nowość, zacznij od <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5">Przewodnika po języku JavaScript 1.5</a>. Kiedy posiądziesz już podstawową wiedzę, możesz skorzystać z <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5">Dokumentacji języka JavaScript 1.5</a>, by szybko odnaleźć konkretne informacje na temat obiektów i poleceń.</p> + +<h3 id="Wskaz.C3.B3wki_do_nauki_JavaScript" name="Wskaz.C3.B3wki_do_nauki_JavaScript">Wskazówki do nauki JavaScript</h3> + +<p>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.</p> + +<h4 id="Interaktywny_interpreter" name="Interaktywny_interpreter">Interaktywny interpreter</h4> + +<p>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".</p> + +<p><img alt="Image:ErrorConsole.png"></p> + +<h4 id="Firebug" name="Firebug">Firebug</h4> + +<p>Bardziej zaawansowana interaktywna podpowiedź dostępna jest pod adresem: <a class="external" href="http://www.getfirebug.com/">Firebug</a>, 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:</p> + +<p><img alt="Image:Firebug.png"></p> + +<p>jedno z najbardziej użytecznych ułatwień oferowanych przez Firebug w <code>console.log()</code>, 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. <code>console.log()</code> stanowi pożyteczną alternatywę obserwowania bardzo łatwo tego co twój program robi.</p> + +<p>Wiele przykładów w tym przewodniku używa <code>alert()</code> do zobaczenia komunikatów z ich wykonania. Jeśli masz zainstalowanego Firebug możesz użyć <code>console.log()</code> w miejsce <code>alert()</code> w czasie działania tych przykładów.</p> + +<h3 id="Konwencje_dokumentu" name="Konwencje_dokumentu">Konwencje dokumentu</h3> + +<p>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<em>\</em> zwykłym ukośnikiem<em>/</em> .</p> + +<p>Przewodnik ten używa uniform resource locators (adresów URL) w następującej formie:</p> + +<p><code><span class="nowiki">http://server.domain/path/file.html</span></code></p> + +<p>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.</p> + +<p>Przewodnik ten stosuje z następującą konwencją czcionki:</p> + +<dl> + <dt>Czcionka <code>monospace</code></dt> + <dd>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).</dd> + <dt>Kursywa </dt> + <dd>Jest użyta dla tytułów, nagłówków, zmiennych i specjalnych miejscach, i słów użytych w dosłownym znaczeniu.</dd> + <dt>Boldface </dt> + <dd>Typ używany do terminów słownikowych.</dd> +</dl> + +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5", "Przewodnik po języku JavaScript 1.5:Przegląd JavaScriptu") }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_i_własności/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_i_własności/index.html new file mode 100644 index 0000000000..0495bbc3fc --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_i_własności/index.html @@ -0,0 +1,49 @@ +--- +title: Obiekty i własności +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_i_własności +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Working_with_Objects +--- +<p> +</p> +<h3 id="Obiekty_i_w.C5.82asno.C5.9Bci" name="Obiekty_i_w.C5.82asno.C5.9Bci"> Obiekty i własności </h3> +<p>Obiekty JavaScript łączą się z ich własnościami. Do własności obiektu odwołujesz się za pomocą prostego zapisu: +</p> +<pre>objectName.propertyName +</pre> +<p>Wielkości znaków w nazwie mają znaczenie zarówno w przypadku obiektu jak i jego własności. Własności definiujesz poprzez przypisanie do niej wartości. Na przykład, przypuśćmy, że mamy obiekt o nazwie <code>myCar</code> (na razie załóżmy że ten obiekt już istnieje). Możesz zadeklarować (i jednocześnie zdefiniować) własności <code>make</code>, <code>model</code> i <code>year</code> tego obiektu następująco: +</p> +<pre>myCar.make = "Ford"; +myCar.model = "Mustang"; +myCar.year = 1969; +</pre> +<p>Tablica jest uporządkowanym zbiorem wartości związanych z pojedynczymi nazwami zmiennych. Własności i tablice są w języku JavaScript bardzo ze sobą powiązane; właściwie są różnymi reprezentacjami tej samej struktury danych. Na przykład możesz wywoływać własności obiektu <code>myCar</code> następująco: +</p> +<pre>myCar["make"] = "Ford" +myCar["model"] = "Mustang" +myCar["year"] = 1967 +</pre> +<p>Ten typ tablicy nazywa się <b>tablicą asocjacyjną</b> (czasem <b>listą asocjacyjną</b>), ponieważ każdy jej element jest związany także z pewną wartością typu String. Ilustracją tego mechanizmu działania jest niżej zamieszczona funkcja wyświetlająca własności obiektu, który jest jej pierwszym argumentem podczas wywołania: +</p> +<pre>function show_props(obj, obj_name) { + var result = ""; + for (var i in obj) + result += obj_name + "." + i + " = " + obj[i] + "\n"; + return result +} +</pre> +<p>Więc funkcje <code>call show_props(myCar, "myCar")</code> zwróciły następująco: +</p> +<pre>myCar.make = Ford +myCar.model = Mustang +myCar.year = 1967 +</pre> +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Funkcje predefiniowane:Funkcje escape i unescape", "Przewodnik po języku JavaScript 1.5:Tworzenie nowych obiektów") }} +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Objects_and_Properties", "es": "es/Gu\u00eda_JavaScript_1.5/Objetos_y_propiedades", "fr": "fr/Guide_JavaScript_1.5/Objets_et_propri\u00e9t\u00e9s", "ja": "ja/Core_JavaScript_1.5_Guide/Objects_and_Properties" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/index.html new file mode 100644 index 0000000000..35f23dc503 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/index.html @@ -0,0 +1,24 @@ +--- +title: Obiekty predefiniowane +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Obiekty_predefiniowane +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide +--- +<p> +</p> +<h3 id="Obiekty_predefiniowane" name="Obiekty_predefiniowane"> Obiekty predefiniowane </h3> +<p>Artykuł opisuje obiekty predefiniowane w JavaScript: </p> +<ul><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Array">Obiekt <code>Array</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Boolean">Obiekt <code>Boolean</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Date">Obiekt <code>Date</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_function">Obiekt <code>function</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Math">Obiekt <code>Math</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Number">Obiekt <code>Number</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_RegExp">Obiekt <code>RegExp</code></a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_String">Obiekt <code>String</code></a> +</li></ul> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "es": "es/Gu\u00eda_JavaScript_1.5/Objetos_base_predefinidos", "fr": "fr/Guide_JavaScript_1.5/Objets_pr\u00e9d\u00e9finis", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "ko": "ko/Core_JavaScript_1.5_Guide/Predefined_Core_Objects" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_array/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_array/index.html new file mode 100644 index 0000000000..9befbd17cc --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Obiekt_Array" name="Obiekt_Array">Obiekt Array</h3> +<p>JavaScript nie ma wyraźnych danych typu + <i> + array</i> + . Jednakże, możesz użyć predefiniowanego obiektu <code><b>Array</b></code> i jego metod do pracy z tabelami w twojej aplikacji. Obiekt <code><b>Array</b></code> 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 + <i> + array</i> + i innych właściwości użytych w wyrażeniach regularnych.</p> +<p> + <i> + array</i> + jest uporządkowane ustawienia wartości, które odsyłają do nazwy i indeksu. Na przykład, możesz mieć tablice nazwaną <code><b>emp</b></code>, która stanowi nazwę indeksu przez jego numer pracownika. Więc <code><b>emp{{ mediawiki.external(1) }}</b></code> będzie pracownik z numerem jeden, <code><b>emp{{ mediawiki.external(2) }}</b></code> pracownik z numerem dwa i tak dalej.</p> +<h4 id="Tworzenie_tablicy" name="Tworzenie_tablicy">Tworzenie tablicy</h4> +<p>Utwórz obiekt <code><b>Array</b></code>:</p> +<pre>1. arrayObjectName = new Array(element0, element1, ..., elementN) +2. arrayObjectName = new Array(arrayLength) +</pre> +<p><code><b>arrayObjectName</b></code> jest nazwą nowego obiektu lub właściwości istniejącego obiektu. Kiedy używamy właściwości i metody <code><b>Array</b></code>, <b>arrayObjectName</b> jest nazwą istniejącego obiektu <code><b>Array</b></code> lub właściwość istniejącego obiektu.</p> +<p><code><b>element0, element1, ..., elementN</b></code> 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.</p> +<p><code><b>arrayLength</b></code> jest inicjowanie długości w tablicy. Następujący kod tworzy tablice na pięć elementów:</p> +<pre>billingMethod = new Array(5) +</pre> +<p>Literały Array sa także obiektami <code><b>Array</b></code>; na przykład, następujący literał jest obiektem <code><b>Array</b></code>. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Litera%c5%82y#Litera.C5.82y_tablicy">Literały tablicy</a> aby uzyskać więcej szczegółów.</p> +<pre>coffees = ["French Roast", "Columbian", "Kona"] +</pre> +<h4 id="Zape.C5.82nienie_tablicy" name="Zape.C5.82nienie_tablicy">Zapełnienie tablicy</h4> +<p>Możesz wypełnić tablicę przydzielonymi wartościami elementów. Na przykład,</p> +<pre>emp[1] = "Casey Jones" +emp[2] = "Phil Lesh" +emp[3] = "August West" +</pre> +<p>Możesz także wypełnić tablicę jeśli utworzysz:</p> +<pre>myArray = new Array("Hello", myVar, 3.14159) +</pre> +<h4 id="Kierowanie_do_elementu_tablicy" name="Kierowanie_do_elementu_tablicy">Kierowanie do elementu tablicy</h4> +<p>Kierowanie do elementu tablicy używając przypisanie numeru odpowiedniemu elementowi. Na przykład, przypuśćmy, że zdefiniujesz następującą tablice:</p> +<pre>myArray = new Array("Wiatr","Deszcz","Ogień") +</pre> +<p>Następnie kieruje się do pierwszego elementu tablicy jako <code><b>myArray{{ mediawiki.external(0) }}</b></code> i drugi element tablicy jako <code><b>myArray{{ mediawiki.external(1) }}</b></code>. Indeks elementów zaczyna się wraz z zerem (0), ale długość tablicy (na przykład, <code><b>myArray.length</b></code>) odzwierciedla numer elementów w tablicy.</p> +<h4 id="Metody" name="Metody">Metody</h4> +<p>Obiekt <code><strong>Array</strong></code> posiada następujące metody:</p> +<ul> + <li><code><strong>concat</strong></code> dołącz dwie tablice i zwróć nową.</li> + <li><code><strong>join</strong></code> aby połączyć wszystkie elementy tablicy.</li> + <li><code><strong>pop</strong></code> usuń ostatni element z tablicy i zwróć ten element</li> + <li><code><strong>push</strong></code> dodaje jeden lub więcej elementów tablicy i zwraca, tego który jest ostatni dodany.</li> + <li><code><strong>reverse</strong></code> transportuje elementy tablicy; pierwszy element tablicy staje się ostatni i ostatni staje się pierwszym.</li> + <li><code><strong>shift</strong></code> usuń pierwszy element z tablicy i zwróć</li> + <li><code><strong>slice</strong></code> ekstrakty sekcji tablicy i zwraca nowa tablicę.</li> + <li><code><strong>splice</strong></code> dodaje i/lub usuwa elementy tablicy.</li> + <li><code><strong>sort</strong></code> sortowanie elementów w systemie.</li> + <li><code><strong>unshift</strong></code> dodaje jeden lub więcej elementów tablicy; tablica jest tworzona wraz z nowa długością length.</li> +</ul> +<p>Na przykład, przypuśćmy, że zdefiniujemy następującą tablice:</p> +<pre>myArray = new Array("Wiatr","Deszcz","Ogień") +</pre> +<p><code><strong>myArray.join()</strong></code> zwraca "Wiatr","Deszcz","Ogień"; <code><strong>myArray.reverse</strong></code> transportuje tablicę więc, który <code><strong>myArray[0</strong>]</code> jest "Ogień", <code><strong>myArray{{ mediawiki.external(1) }}</strong></code> jest "Deszcz", i <code><strong>myArray{{ mediawiki.external(2) }}</strong></code> jest "Wiatr". <code><strong>myArray.sort</strong></code> sortuje tablicę więc, który <code><strong>myArray{{ mediawiki.external(0) }}</strong></code> jest "Ogień", <code><strong>myArray{{ mediawiki.external(1) }}</strong></code> jest "Deszcz", i <code><strong>myArray{{ mediawiki.external(2) }}</strong></code> jest "Wiatr".</p> +<h4 id="Tablice_dwuwymiarowe" name="Tablice_dwuwymiarowe">Tablice dwuwymiarowe</h4> +<p>Następujący kod tworzy tablicę dwuwymiarową.</p> +<pre>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+"]" + } +} +</pre> +<p>Ten przykład tworzy tablicę z następującymi wierszami:</p> +<pre>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] +</pre> +<h4 id="Tablice_i_wyra.C5.BCenia_regularne" name="Tablice_i_wyra.C5.BCenia_regularne">Tablice i wyrażenia regularne</h4> +<p>Kiedy + <i> + array</i> + jest rezultatem pomiędzy wyrażeniami regularnymi i łańcucha, + <i> + array</i> + zwraca właściwości i elementy, które dostarczają informacji o odpowiedniku. Wartość + <i> + array</i> + jest zwracany <code><b>RegExp.exec</b></code>, <code><b>String.match</b></code>, i <code><b>String.split</b></code>. Dla uzyskania informacji, jak używać tablicę z wyrażeniami regularnymi <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5#Wyra.C5.BCenia_regularne">Wyrażenia regularne</a>.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_boolean/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_boolean/index.html new file mode 100644 index 0000000000..ff6e5b774a --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Obiekt_Boolean" name="Obiekt_Boolean">Obiekt Boolean</h3> +<p>Obiekt <code><b>Boolean</b></code> jest otoczeniem wokół prymitywnych danych typu Boolean. Użyj następującej składni do utworzenia obiektu <code><b>Boolean</b></code>:</p> +<pre>booleanObjectName = new Boolean(wartość) +</pre> +<p>Nie pomieszaj prymitywnej wartości Boolean <code><b>true</b></code> i <code><b>false</b></code> z wartościami <b>true</b> i <b>false</b> obiektu <code><b>Boolean</b></code>. Jakikolwiek obiekt którego wartość obiektu jest nie <code><b>undefined</b></code> , <code><b>null</b></code>, <code><b>0</b></code>, <code><b>NaN</b></code>, lub pusty łańcuch, włączając obiekt <code><b>Boolean</b></code>, którego wartość jest nieprawdziwa (false), ocenia jako prawdziwy (true), kiedy przechodzi do instrukcji warunkowej. Zobacz artykuł <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_warunkowe#Instrukcja_if...else">Instrukcja if...else</a> aby zdobyć więcej informacji.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_date/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_date/index.html new file mode 100644 index 0000000000..e0dc4845d8 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Obiekt_Date" name="Obiekt_Date">Obiekt Date</h3> +<p>JavaScript nie posiada danych typu date. Jednakże, możesz użyć obiektu <code><b>Date</b></code> i jego metod do pracy z datami i czasem w swoich aplikacjach. Obiekt <code><b>Date</b></code> posiada wiele metod do ustawiania, pobierania i manipulacji datami. Nie posiada żadnych właściwości.</p> +<p>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.</p> +<p>Obiekt Date jest z zakresu -100,000,000 dni do 100,000,000 dni odnosząc się do 01 stycznia, 1970 UTC.</p> +<p>Do utworzenia obiektu <code><b>Date</b></code> służy:</p> +<pre>dateObjectName = new Date([parameters]) +</pre> +<p>gdzie: <code><b>dateObjectName</b></code> jest nazwą tworzonego obiektu; <code><b>Date</b></code> potrafi też być nowym obiektem lub właściwością już istniejącego obiektu.</p> +<p>W poprzedniej składni <code><b>parameters</b></code> mogły być:</p> +<ul> + <li>Niczym: tworzyć dzisiejszą datę i czas. Na przykład: <code><b>today = new Date()</b></code>.</li> + <li>Łańcuchem reprezentującym datę w następujących formach: "Month day, year hours:minutes:seconds." Na przykład:, <code><b>Xmas95 = new Date("December 25, 1995 13:30:00")</b></code>. Jeśli opuszczasz godziny, minuty lub sekundy to wartość ich będzie ustawiona na zero.</li> + <li>Ustawienia wartości liczby całkowitej dla roku, miesiąca i dnia. Na przykład, <code><b>Xmas95 = new Date(1995,11,25)</b></code>. Ustawienia wartości dla roku, miesiąca, dnia, godziny, minuty, sekund. Na przykład: <code><b>Xmas95 = new Date(1995,11,25,9,30,0)</b></code>.</li> +</ul> +<p><b>JavaScript 1.2 i wcześniejsze</b><br> + Obiekt <code><b>Date</b></code> postępuje następująco:</p> +<ul> + <li>Daty z przed roku 1970 nie są uznawane.</li> + <li>Data w JavaScript zależy od dostępności i zachowania rodzaju platformy; zachowanie platform obiektu <code><b>Date</b></code> różnią się pomiędzy sobą.</li> +</ul> +<h4 id="Metody_obiektu_Date" name="Metody_obiektu_Date">Metody obiektu Date</h4> +<p>Metody obiektu <code><b>Date</b></code> są do obsługi daty i czasu zawartego w tych obszernych kategoriach:</p> +<ul> + <li>metody "<code><b>set</b></code>", służy do ustawienia wartości daty i czasu w obiektach <code><b>Date</b></code>.</li> + <li>metody "<code><b>get</b></code>", służą do pobrania wartości daty i czasu w obiektach <code><b>Date</b></code>.</li> + <li>metody "<code><b>to</b></code>", służy do powtórzenia łańcuchów wartości z obiektów <code><b>Date</b></code>.</li> + <li>parsowanie i metody UTC, służą do analizy składniowej łańcuchów <code><b>Date</b></code>.</li> +</ul> +<p>Z metodami "<code><b>get</b></code>" i "<code><b>set</b></code>" możemy pobrać i ustawić sekundy, minuty, godziny, dni miesiąca, dni tygodnia, miesiące, jak i poszczególne lata. Istnieje metoda <code><b>getDay</b></code>, która zwraca dzień tygodnia, ale nie współpracuje z metodą <code><b>setDay</b></code>, ponieważ dzień tygodnia jest ustawiany automatycznie. Te metody używają liczb całkowitych do reprezentacji następujących wartości:</p> +<ul> + <li>Sekund /i minut: 0 do 59</li> + <li>Godziny: 0 do 23</li> + <li>Dzień: 0 (Niedziela) do 6 (Sobota)</li> + <li>Data: 1 do 31 (dzień miesiąca)</li> + <li>Miesiące: 0 (Styczeń) do 11 (Grudzień)</li> + <li>Lata: lata od 1900</li> +</ul> +<p>Na przykład, przypuśćmy, że zdefiniowałeś następującą datę:</p> +<pre>Xmas95 = new Date("December 25, 1995") +</pre> +<p>Następnie <code><b>Xmas95.getMonth()</b></code> zwraca 11, i <code><b>Xmas95.getFullYear()</b></code> zwraca 1995.</p> +<p>Metody <code><b>getTime</b></code> i <code><b>setTime</b></code> są użyteczne dla porównania dat. Metoda <code><b>getTime</b></code> zwraca liczbę milisekund od 1 stycznia 1970, 00:00:00 ( + <i> + January 1, 1970, 00:00:00</i> + ) dla obiektu <code><b>Date</b></code>.</p> +<p>Na przykład, następujący kod wyświetla liczbę dni opuszczonych w aktualnym roku:</p> +<pre>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 +</pre> +<p>Ten przykład stworzył obiekt <code><b>Date</b></code> nazywany <b>today</b>, który stanowi dzisiejszą datę. Następnie utworzył obiekt <code><b>Date</b></code> nazwany <code><b>endYear</b></code> i ustawi się od roku do aktualnego roku. Następnie, użyje liczbę milisekund na dzień, to obliczy liczbę dni pomiędzy dzisiejszym dniem <b>today</b> a <code><b>endYear</b></code>, używających <code><b>getTime</b></code> i zaokrąglenie do liczby dni.</p> +<p>Metoda <code><b>parse</b></code> jest użyteczna dla przydzielania wartości z łańcucha daty do wykorzystania przez obiekty <code><b>Date</b></code>. Na przykład, następujący kod używa <code><b>parse</b></code> i <code><b>setTime</b></code> do przydzielenia wartości obiektu <code><b>IPOdate</b></code>:</p> +<pre>IPOdate = new Date() +IPOdate.setTime(Date.parse("Aug 9, 1995")) +</pre> +<h4 id="U.C5.BCywanie_obiektu_Date:_Przyk.C5.82ad" name="U.C5.BCywanie_obiektu_Date:_Przyk.C5.82ad">Używanie obiektu Date: Przykład</h4> +<p>W następującym przykładzie, funkcja <code><b>JSClock()</b></code> zwraca czas w formacie zegara cyfrowego.</p> +<pre>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 +} +</pre> +<p>Pierwsza funkcja <code><b>JSClock</b></code> tworzy nowy obiekt <code><b>Date</b></code>, który nazywany jest <code><b>time</b></code>; nie dający argumentów, czas jest tworzony z aktualną datą i czasem. Następnie metody <code><b>getHours</b></code>, <code><b>getMinutes</b></code>, i <code><b>getSeconds</b></code> przypisują wartości aktualnej godziny, minuty i sekundy do <code><b>hour</b></code>, <code><b>minute</b></code>, i <code><b>second</b></code>.</p> +<p>Następne cztery linijki instrukcji budują łańcuch wartości oparty na czasie. Pierwsza instrukcja tworzy zmienne <code><b>temp</b></code>, przydzielając jej wartość używanego warunku wyrażenia; jeśli <code><b>hour</b></code> jest wyższa niż 12, (godzina - 12), w innym przypadku prosta godzina, chyba że jest godzina 0, która to staje się 12.</p> +<p>Następna instrukcja przypisuje wartość <code><b>minute</b></code> do temp. Jeśli wartość <code><b>minute</b></code> 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.</p> +<p>Kończąc, wyrażenie warunkowe dołącza "<code><b>PM</b></code>" do temp, jeśli <code><b>hour</b></code> posiada wartość 12 lub wyższą; w innym przypadku, to dołącza "<code><b>AM</b></code>" do <code><b>temp</b></code>.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_function/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_function/index.html new file mode 100644 index 0000000000..02eef23d82 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Obiekt_Function" name="Obiekt_Function">Obiekt Function</h3> +<p>Predefiniowany obiekt <code>Function</code> określa łańcuch znaków do skompilowania jako funkcja.</p> +<p>Aby utworzyć obiekt <code>Function</code>:</p> +<pre>nazwaObiektuFunkcji = new Function ([arg1, arg2, ... argn], cialoFunkcji) +</pre> +<p><code>nazwaObiektuFunkcji</code> 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. <code>window.onerror</code>.</p> +<p><code>arg1</code>, <code>arg2</code>, ... <code>argn</code> 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".</p> +<p><code>cialoFunkcji</code> jest łańcuchem znaków określającym kod JavaScript, który ma zostać skompilowany jako ciało funkcji.</p> +<p>Obiekty <code>Function</code> 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.</p> +<p>Oprócz definiowania funkcji w sposób opisany tutaj, możesz również użyć instrukcji <code>function</code> i wyrażenia funkcji. Zobacz <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5">Dokumentacja języka JavaScript 1.5</a>, aby uzyskać więcej informacji.</p> +<p>Poniższy kod przypisuje funkcję do zmiennej <code>ustawKolorTla</code>. Funkcja ta ustawia obecny kolor tła dokumentu.</p> +<pre>var ustawKolorTla = new Function("document.bgColor='antiquewhite'") +</pre> +<p>Aby wywołać obiekt <code>Function</code>, możesz określić nazwę zmiennej tak, jak gdyby była to funkcja. Poniższy kod wykonuje funkcję określoną przez zmienną <code>ustawKolorTla</code>:</p> +<pre>var wyborKoloru="antiquewhite" +if (wyborKoloru=="antiquewhite") {ustawKolorTla()} +</pre> +<p>Możesz przypisać funkcję do uchwytu zdarzenia w jeden z następujących sposobów:</p> +<pre>1. document.form1.colorButton.onclick=ustawKolorTla +2. <INPUT NAME="kolorPrzycisku" TYPE="button" + VALUE="Zmień kolor tła" + onClick="ustawKolorTla()"> +</pre> +<p>Tworzenie zmiennej <code>ustawKolorTla</code> pokazane powyżej jest podobne do deklarowania następującej funkcji:</p> +<pre>function ustawKolorTla() { + document.bgColor='antiquewhite' +} +</pre> +<p>Przypisywanie funkcji do zmiennej jest podobne do deklarowania funkcji, są jednak pewne różnice:</p> +<ul> + <li>Gdy przypisujesz funkcję do zmiennej używając var <code>ustawKolorTla = new Function("...")</code>, <code>ustawKolorTla</code> jest zmienną, dla której obecnej wartość jest odniesieniem do funkcji stworzonej za pomocą new <code>Function()</code>.</li> + <li>Gdy tworzysz funkcję używając <code>function ustawKolorTla() {...}</code>, <code>ustawKolorTla</code> nie jest zmienną, ale nazwą funkcji.</li> +</ul> +<p>Możesz zagnieździć funkcję wewnątrz funkcji. Zagnieżdżona (wewnętrzna) funkcja jest prywatna do zawierającej ją (zewnętrznej) funkcji:</p> +<ul> + <li>Dostęp do wewnętrznej funkcji może być osiągnięty tylko przez instrukcje w funkcji zewnętrznej.</li> + <li>Funkcja wewnętrzna może używać tych samych argumentów i zmiennych, co funkcja zewnątrzna. Funkcja zewnętrzna nie może używać argumentów i zmiennych funkcji wewnętrznej.</li> +</ul> +<div class="noinclude"> + </div> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_math/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_math/index.html new file mode 100644 index 0000000000..b09ad2f801 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Obiekt_Math" name="Obiekt_Math">Obiekt Math</h3> +<p>Obiekt predefiniowany <code><b>Math</b></code> posiada właściwości i metody dla stałych matematycznych i funkcji. Na przykład: obiekt <code><b>Math</b></code> <code><b>PI</b></code> pi posiada wartość (3.141...), który będzie używany w aplikacji jako:</p> +<pre>Math.PI +</pre> +<p>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 <b>sine</b>, musisz napisać:</p> +<pre>Math.sin(1.56) +</pre> +<p>Wszystkie metody trygonometryczne <code><b>Math</b></code> pobierają argumenty w radianach.</p> +<p>Następująca tabela podsumowuje metodę <code><b>Math</b></code>.</p> +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Metoda</th> + <th>Opis</th> + </tr> + <tr> + <td><b>abs</b></td> + <td>Wartość bezwzględna argumentu</td> + </tr> + <tr> + <td><b>sin, cos, tan</b></td> + <td>Standardowe funkcje trygonometryczne; argumenty w radianach</td> + </tr> + <tr> + <td><b>acos, asin, atan, atan2</b></td> + <td>Odwrotne funkcje trygonometryczne; zwracają wartość w radianach</td> + </tr> + <tr> + <td><b>exp, log</b></td> + <td>Wykładniczy i naturalny logarytm, podstawą jest <sub><b>e</b></sub></td> + </tr> + <tr> + <td><b>ceil</b></td> + <td>Zwraca najmniejszą liczbę całkowitą większą bądź równą argumentowi</td> + </tr> + <tr> + <td><b>floor</b></td> + <td>Zwraca największą liczbę całkowitą mniejszą bądź równą argumentowi</td> + </tr> + <tr> + <td><b>min, max</b></td> + <td>Zwraca większą lub mniejeszą (jedną z podanych) z dwóch argumentów</td> + </tr> + <tr> + <td><b>pow</b></td> + <td>Wykładniczy; pierwszy argument jest podstawą, drugi jest wykładnikiem</td> + </tr> + <tr> + <td><b>random</b></td> + <td>Zwraca przypadkową liczbę pomiędzy 0 i 1.</td> + </tr> + <tr> + <td><b>round</b></td> + <td>Zwraca argumenty najbliższe liczbie całkowitej</td> + </tr> + <tr> + <td><b>sqrt</b></td> + <td>Zwraca pierwiastek kwadratowy argumentu</td> + </tr> + </tbody> +</table> +<p><small><b>Tabela: Metody Math</b></small></p> +<p>Wiele innych niepodobnych obiektów, nigdy nie utworzy dla siebie obiektu <code><b>Math</b></code>. Zawsze używaj predefiniowanego obiektu <code><b>Math</b></code>.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_number/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_number/index.html new file mode 100644 index 0000000000..d66696774b --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Obiekt_Number" name="Obiekt_Number">Obiekt Number</h3> +<p>Obiekt <code><b>Number</b></code> 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:</p> +<pre>biggestNum = Number.MAX_VALUE +smallestNum = Number.MIN_VALUE +infiniteNum = Number.POSITIVE_INFINITY +negInfiniteNum = Number.NEGATIVE_INFINITY +notANum = Number.NaN +</pre> +<p>Możesz zawsze odwołać się do własności predefiniowanego obiektu <code>Number</code> w sposób pokazany powyżej, lecz nie jako własności obiektu <code>Number</code>, który sam utworzyłeś.</p> +<p>Poniższa tabela podsumowuje własności obiektu <code><b>Number</b></code> .</p> +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Własność</th> + <th>Opis</th> + </tr> + <tr> + <td><b>MAX_VALUE</b></td> + <td>Największa możliwa do przedstawienia liczba</td> + </tr> + <tr> + <td><b>MIN_VALUE</b></td> + <td>Najmniejsza możliwa do przedstawienia liczba</td> + </tr> + <tr> + <td><b>NaN</b></td> + <td>Specjalna wartość "nieliczbowa"</td> + </tr> + <tr> + <td><b>NEGATIVE_INFINITY</b></td> + <td>Specjalna wartość nieskończoności; zwracana przy przepełnieniu</td> + </tr> + <tr> + <td><b>POSITIVE_INFINITY</b></td> + <td>Specjalna wartość ujemnej nieskończoności; zwracana przy przepełnieniu</td> + </tr> + </tbody> +</table> +<p><small><b>Tabela 7.2: Własności obiektu Number</b></small></p> +<p>Prototyp Number dostarcza metod używanych w celu uzyskiwania w różnych formatach informacji z obiektów Number. Poniższa tabelka podsumowuje metody <code>Number.prototype</code>.</p> +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Metoda</th> + <th>Opis</th> + </tr> + <tr> + <td><b>toExponential</b></td> + <td>Zwraca łańcuch znaków reprezentujący liczbę w notacji wykładniczej.</td> + </tr> + <tr> + <td><b>toFixed</b></td> + <td>Zwraca łańcuch znaków reprezentujący liczbę w notacji stałoprzecinkowej.</td> + </tr> + <tr> + <td><b>toPrecision</b></td> + <td>Zwraca łańcuch znaków reprezentujący z określoną dokładnością w notacji stałoprzecinkowej.</td> + </tr> + <tr> + <td><b>toSource</b></td> + <td>Zwraca obiekt literałowy reprezentujący określony obiekt Number; możesz użyć tej wartości do stworzenia nowego obiektu. Nadpisuje metodę Object.toSource.</td> + </tr> + <tr> + <td><b>toString</b></td> + <td>Zwraca łańcuch znaków reprezentujący dany obiekt. Nadpisuje metodę Object.toString.</td> + </tr> + <tr> + <td><b>valueOf</b></td> + <td>Zwraca pierwotną wartość określonego obiektu. Nadpisuje metodę Object.valueOf.</td> + </tr> + </tbody> +</table> +<p><small><b>Tabela: Metody Number.prototype</b></small> {{ PreviousNext("Przewodnik po języku JavaScript 1.5:Obiekty predefiniowane:Obiekt Math", "Przewodnik po języku JavaScript 1.5:Obiekty predefiniowane:Obiekt RegExp") }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_regexp/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_regexp/index.html new file mode 100644 index 0000000000..120abc3cb9 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Obiekt_RegExp" name="Obiekt_RegExp">Obiekt RegExp</h3> +<p>Obiekt <code><b>RegExp</b></code> umożliwia działanie na wyrażeniach regularnych. Został on opisany w Rozdziale 4, <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5#Wyra.C5.BCenia_regularne">Wyrażenia regularne</a>. {{ PreviousNext("Przewodnik po języku JavaScript 1.5:Obiekty predefiniowane:Obiekt Number", "Przewodnik po języku JavaScript 1.5:Obiekty predefiniowane:Obiekt String") }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_string/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/obiekty_predefiniowane/obiekt_string/index.html new file mode 100644 index 0000000000..dc7aa33326 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Obiekt_String" name="Obiekt_String">Obiekt String</h3> +<p>Obiekt <code>String</code> ma jedną własność, <code>length</code>, która wskazuje liczbę znaków w łańcuchu znaków. Przykładowo, poniższy kod przypisuje zmiennej <code>x</code> wartość 13, ponieważ "Hello, World!" ma 13 znaków:</p> +<pre>myString = "Hello, World!" +x = mystring.length +</pre> +<p>Obiekt <code>String</code> posiada dwa typy metod: zwracające zmienność samego łańcucha znaków, takie jak <code>substring</code> i <code>toUpperCase</code> oraz te, które zwracają wersję łańcucha sformatowaną jako kod HTML, takie jak <code>bold</code> i <code>link</code>.</p> +<p>Na przykład używając poprzedniego przykładu, zarówno <code>mystring.toUpperCase()</code> jak i <code>"hello, world!".toUpperCase()</code> zwrócą łańcuch "HELLO, WORLD!"</p> +<p>Metoda <code>substring</code> 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ę <code>substring</code> obiektu String w <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5">Dokumentacja języka JavaScript 1.5</a>, aby uzyskać więcej informacji.</p> +<p>Obiekt <code>String</code> posiada również wiele metod do automatycznego formatowania kodu HTML, takie jak <code>bold</code> do tworzenia pogrubionego tekstu i <code>link</code> do tworzenia hiperłącz. Przykładowo, możesz utworzyć hiperłącze do hipotetycznego adresu URL przy użyciu metody <code>link</code> w następujący sposób:</p> +<pre>mystring.link("http://www.helloworld.com") +</pre> +<p>Poniższe tabela podsumowuje metody obiektu <code>String</code>.</p> +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Metody</th> + <th>Opis</th> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/anchor">anchor</a></td> + <td>Tworzy nazwaną kotwicę HTML.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/big">big</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/blink">blink</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/bold">bold</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/fixed">fixed</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/italics">italics</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/small">small</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/strike">strike</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/sub">sub</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/sup">sup</a></td> + <td>Tworzy w HTML sformatowany łańcuch znaków.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/charAt">charAt</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/charCodeAt">charCodeAt</a></td> + <td>Zwraca znak lub kod znaku znajdującego się na określonej pozycji łańcucha znaków.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/indexOf">indexOf</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/lastIndexOf">lastIndexOf</a></td> + <td>Zwraca odpowiednio pozycję określonego podciągu w łańcuchu znaków lub ostatnią pozycję określonego podciągu.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/link">link</a></td> + <td>Tworzy odnośnik HTML.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/concat">concat</a></td> + <td>Łączy tekst z dwóch łańcuchów i zwraca nowy łańcuch znaków.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/fromCharCode">fromCharCode</a></td> + <td>Buduje łańcuch znaków z określonej sekwencji wartości Unicode. Jest metoda klasy String, a nie instancji String.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/split">split</a></td> + <td>Dzieli obiekt String na tablicę łańcuchów poprzez rozdzielenie łańcucha znaków na podciągi.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/slice">slice</a></td> + <td>Wycina fragment łańcucha znaków i zwraca nowy łańcuch.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/substring">substring</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/substr">substr</a></td> + <td>Zwraca 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.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/match">match</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/replace">replace</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/search">search</a></td> + <td>Pracuje z wyrażeniami regularnymi.</td> + </tr> + <tr> + <td><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/toLowerCase">toLowerCase</a>, <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/toUpperCase">toUpperCase</a></td> + <td>Zwraca łańcuch znaków odpowiednio z wszystkimi małymi lub wszystkimi dużymi znakami.</td> + </tr> + </tbody> +</table> +<p><small><b>Tabela 7.4: Metody instancji String</b></small></p> +<h3 id="Litera.C5.82y_znakowe_nie_s.C4.85_obiektami_String" name="Litera.C5.82y_znakowe_nie_s.C4.85_obiektami_String">Literały znakowe nie są obiektami String</h3> +<p>Obiekt <code>String</code> jest obiektem opakowującym wokół pierwotnego typu danych łańcuchu znaków. Nie myl literału znakowego z obiektem <code>String</code>. Na przykład poniższy kod tworzy literał <code>s1</code>, jak również obiekt String <code>s2</code>:</p> +<pre>s1 = "foo" //tworzy wartość literału znakowego +s2 = new String("foo") //tworzy obiekt String +</pre> +<p>Możesz wywołać dowolną metodę obiektu String na wartości literału znakowego - JavaScript automatycznie skonwertuje literał znakowy do tymczasowego obiektu <code>String</code>, wywoła metodę, a następnie pozbędzie się tymczasowego obiektu <code>String</code>. Możesz również użyć własności <code>String.length</code> z literałem znakowym. Możesz również użyć własności <code>String.length</code> z literałem znakowym.</p> +<p>Powinieneś użyć literału znakowego, chyba że potrzebujesz szczególnie obiektu String, ponieważ obiekty <code>String</code> mogą zachowywać się nieintuicyjnie. Przykładowo:</p> +<pre>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" +</pre> +<p>{{ 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") }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/index.html new file mode 100644 index 0000000000..cc916dff5d --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/index.html @@ -0,0 +1,112 @@ +--- +title: Operatory +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +--- +<p> +</p> +<h3 id="Operatory" name="Operatory"> Operatory </h3> +<p>JavaScript posiada następujące typy operatorów. Ten temat opisuje operatory i wartości informacyjne o operatorach pierwszeństwa. +</p> +<ul><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_przypisania">Operatory przypisania</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_por%c3%b3wnania">Operatory porównania</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_arytmetyczne">Operatory arytmetyczne</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_bitowe">Operatory bitowe</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_logiczne">Operatory logiczne</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operacje_na_%c5%82a%c5%84cuchach">Operacje na łańcuchach</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_specjalne">Operatory specjalne</a> +</li></ul> +<p>JavaScript posiada po dwa operatory bitowe i unarne. Operator bitowy zwraca dwa argumenty, jeden przed operatorem i jeden za operatorem: </p> +<pre>argument1 operator argument2 +</pre> +<p>Na przykład, <code>3+4</code> lub <code>x*y</code>. +Operator unarny zwraca pojedynczy znak argumentu, znaki te zapisujemy przed lub za operatorem: +</p> +<pre>operator argument +</pre> +<p>lub +</p> +<pre>argument operator +</pre> +<p>Na przykład, <code>x++</code> lub <code>++x</code>. +</p><p>Uzupełniając, JavaScript posiada potrójny operator, jakim jest operator warunkowy. Potrójny operator zwraca trzy argumenty. +</p> +<h4 id="Pierwsze.C5.84stwo_operator.C3.B3w" name="Pierwsze.C5.84stwo_operator.C3.B3w"> Pierwszeństwo operatorów </h4> +<table class="fullwidth-table"> +<tbody><tr> +<th>Typ operatora</th> +<th>Indywidualny operator</th> +</tr> +<tr> +<td>przecinek</td> +<td>,</td> +</tr> +<tr> +<td>przypisania </td> +<td>= += -= *= /= %= <<= >>= >>>= &= ^= |=</td> +</tr> +<tr> +<td>warunkowy</td> +<td>?:</td> +</tr> +<tr> +<td>logiczne "LUB" </td> +<td>||</td> +</tr> +<tr> +<td>logiczne "I"</td> +<td>&&</td> +</tr> +<tr> +<td>bitowe "LUB"</td> +<td>|</td> +</tr> +<tr> +<td>bitowe "XOR" </td> +<td>^</td> +</tr> +<tr> +<td>bitowe "I"</td> +<td>&</td> +</tr> +<tr> +<td>porównanie</td> +<td>== != === !==</td> +</tr> +<tr> +<td>relacji</td> +<td>< <= > >= in instanceof</td> +</tr> +<tr> +<td>przesunięcie bitowe </td> +<td><< >> >>></td> +</tr> +<tr> +<td>dodawanie/odejmowanie </td> +<td>+ -</td> +</tr> +<tr> +<td>mnożenie/dzielenie/modulo </td> +<td>* / %</td> +</tr> +<tr> +<td>negacja/inkrementacja/dekrementacja </td> +<td>! ~ - + ++ -- typeof void delete</td> +</tr> +<tr> +<td>nazwa / tworzenie przykładu </td> +<td>() new</td> +</tr> +<tr> +<td>pamięci </td> +<td>. []</td> +</tr> +</tbody></table> +<p><small><b>Tabela: Operatory pierwszeństwa</b></small> +</p><p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Wyrażenia", "Przewodnik po języku JavaScript 1.5:Operatory:Operatory przypisania") }} +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs", "ja": "ja/Core_JavaScript_1.5_Guide/Operators" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operacje_na_łańcuchach/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operacje_na_łańcuchach/index.html new file mode 100644 index 0000000000..5406be0bbe --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operacje_na_łańcuchach/index.html @@ -0,0 +1,17 @@ +--- +title: Operacje na łańcuchach +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operacje_na_łańcuchach +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +--- +<p> +</p> +<h4 id="Operatory_.C5.82a.C5.84cuchowe" name="Operatory_.C5.82a.C5.84cuchowe"> Operatory łańcuchowe </h4> +<p>Oprócz operatorów porównania łańcuchów istnieje operator konkatenacji (+), który konkatenuje dwa łańcuchy zwracając łańcuch będący połączeniem obu argumentów. Na przykład <code>"my " + "string"</code> zwraca łańcuch znaków <code>"my string"</code>. +</p><p>Skróconego operatora += też można używać do konkatenacji łańcuchów. Na przykład jeśli zmienna <code>mystring</code> ma wartość "alpha", to wyrażenie <code>mystring += "bet"</code> przyjmuje wartość "alphabet" i wartość ta jest nadawana zmiennej <code>mystring</code>. +</p><p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operatory logiczne", "Przewodnik po języku JavaScript 1.5:Operatory:Operatory specjalne") }} +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/String_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_de_cadenas_de_caracteres_(string)", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_li\u00e9s_aux_cha\u00eenes", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/String_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/String_Operators" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_arytmetyczne/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_arytmetyczne/index.html new file mode 100644 index 0000000000..a9f27489ad --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_arytmetyczne/index.html @@ -0,0 +1,48 @@ +--- +title: Operatory arytmetyczne +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_arytmetyczne +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +--- +<p> +</p> +<h3 id="Operatory_arytmetyczne" name="Operatory_arytmetyczne"> Operatory arytmetyczne </h3> +<p>Operatory arytmetyczne pobierają wartości liczbowe (albo literowy lub zmienny) jako własne argumenty i zwracają pojedynczą wartość liczbową. Podstawowymi operatorami arytmetycznymi są <b>dodawanie (+)</b>, <b>odejmowanie (-)</b>, <b>mnożenie (*)</b>, i <b>dzielenie (/)</b>. Wspomniane operatory działają także w innych językach programowania (oprócz operatora /, który zwraca wynik dzielenia w wartościach dziesiętnych w JavaScript), dzielenie nie zaokrągla wartości dziesiętnej, jak to robi w językach programowania, takich jak C i Java. Na przykład: +</p> +<pre>1/2 //zwraca 0.5 w JavaScript +1/2 //zwraca 0 w Java +</pre> +<p>Uzupełniając, JavaScript dostarcza operatory arytmetyczne wyliczone w poniższej tabeli. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Operator</th> +<th>Opis</th> +<th>Przykład</th> +</tr> +<tr> +<td><b>%</b><br>(Modulo)</td> +<td>Operator bitowy. Zwraca liczbę całkowitą z resztą podczas dzielenie dwóch argumentów.</td> <td>12 % 5 zwraca 2.</td> +</tr> +<tr> +<td><b>++</b><br>(Inkrementacji)</td> +<td>Operator unarny. Zwiększa o jeden argument. Jeśli użyjemy operator z przedrostkiem (<b>++x</b>), zwróci wartość argumentu zwiększonego o jeden; jeśli użyjemy argumentu i za nim przedrostek (<b>x++</b>), zwróci wartość argumentu z przed zwiększenia o jeden.</td> +<td>Jeśli <code><b>x</b></code> jest 3, potem <code><b>++x</b></code> ustawia <code><b>x</b></code> na 4 i zwraca 4, podczas gdy <code><b>x++</b></code> ustawia <code><b>x</b></code> na 4 i zwraca 3.</td> +</tr> +<tr> +<td><b>--</b><br>(Dekrementacji)</td> +<td>Operator unarny. Zmniejszy o jeden argument. Zwracana wartość jest analogiczna do zapisu operatora inkrementacji.</td> +<td>Jeśli <code><b>x</b></code> jest 3, potem <code><b>--x</b></code> ustawia <code><b>x</b></code> na 2 i zwraca 2, podczas gdy <code><b>x++</b></code> ustawia <code><b>x</b></code> na 2 i zwraca 3.</td> +</tr> +<tr> +<td><b>-</b><br>(Negacja unarna)</td> +<td>Operator unarny. Zwraca negacje tego argumentu.</td> +<td>Jeśli <code><b>x</b></code> jest 3, potem <code><b>-x</b></code> zwraca -3.</td> +</tr> +</tbody></table> +<p><small><b>Tabela: Operatory arytmetyczne</b></small> +</p><p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operatory porównania", "Przewodnik po języku JavaScript 1.5:Operatory:Operatory bitowe") }} +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Arithmetic_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_aritm\u00e9ticos", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_arithm\u00e9tiques", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Arithmetic_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Arithmetic_Operators" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_logiczne/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_logiczne/index.html new file mode 100644 index 0000000000..b6f33ac4ff --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_logiczne/index.html @@ -0,0 +1,72 @@ +--- +title: Operatory logiczne +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_logiczne +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +--- +<p> +</p> +<h3 id="Operatory_logiczne" name="Operatory_logiczne"> Operatory logiczne </h3> +<p>Operatory logiczne są typem użytym z wartością Boolean (logiczną); zwracają one wartość logiczną (true lub false). Jednakże, operatory && i || aktualnie zwracają wartość jednego ze określonych argumentów, więc jeśli któryś z tych operatorów jest użyty z wartością nielogiczną, to zwróci wartość nie-logiczną. Operatory logiczne są opisane w następującej tablicy. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Operatory</th> +<th>Użycie</th> +<th>Opis</th> +</tr> +<tr> +<td>&&</td> +<td>expr1 && expr2</td> +<td>(Iloczyn logiczny AND) Zwraca expr1, jeśli jest konwertowany do false; w innym przypadku, zwraca expr2. Tak więc, kiedy użyjemy wartość logiczną, && zwróci true jeśli oba argumenty są true; w innym przypadku, zwróci false.</td> +</tr> +<tr> +<td>||</td> +<td>expr1 || expr2</td> +<td>(Suma logiczna OR) Zwróć expr1, jeśli jest konwertowany do true; w innym wypadku, zwróci expr2 logiczną. Tak więc, kiedy użyjemy wartość || zwróci true, jeśli oba argumenty są prawdziwe; jeśli oba są fałszywe, zwróci false.</td> +</tr> +<tr> +<td>!</td> +<td>!expr</td> +<td>(Negacja logiczna NOT) Zwraca false, jeśli jest pojedynczy argument konwertuje do true; w innym przypadku, zwróci true.</td> +</tr> +</tbody></table> +<p><small><b>Tabela: Operatory logiczne</b></small> +</p><p>Przykłady wyrażeń, które potrafią być konwertowane do false, są to te, które prawie są ocenione do null, 0, pusty łańcuch (""), lub niezidentyfikowany. +</p><p>Następujący kod pokazuje przykład operatora && (logiczny AND). +</p> +<pre>a1=true && true // t && t zwraca true +a2=true && false // t && f zwraca false +a3=false && true // f && t zwraca false +a4=false && (3 == 4) // f && f zwraca false +a5="Cat" && "Dog" // t && t zwraca Dog +a6=false && "Cat" // f && t zwraca false +a7="Cat" && false // t && f zwraca false +</pre> +<p>Następujący kod pokazuje przykład operatora || (logiczny OR). +</p> +<pre>o1=true || true // t || t zwraca true +o2=false || true // f || t zwraca true +o3=true || false // t || f zwraca true +o4=false || (3 == 4) // f || f zwraca false +o5="Cat" || "Dog" // t || t zwraca Cat +o6=false || "Cat" // f || t zwraca Cat +o7="Cat" || false // t || f zwraca Cat +</pre> +<p>Następujący kod pokazuje przykład operatora ! (logiczny NOT). +</p> +<pre>n1=!true // !t zwraca false +n2=!false // !f zwraca true +n3=!"Cat" // !t zwraca false +</pre> +<h4 id="Skr.C3.B3cona_ocena" name="Skr.C3.B3cona_ocena"> Skrócona ocena </h4> +<p>Wyrażenia logiczne są oceniane od lewego do prawego, są one testowane dla ewentualnych "skrótów" potrafiących wykonać wyrażenie wykonując następujące reguły: </p> +<ul><li> <code>false</code> && <i>coś_tam</i> jest skrótem wykonującym wyrażenie fałszywe. </li><li> <code>true</code> || <i>coś_tam</i> jest skrótem wykonującym wyrażenie prawdziwe. +</li></ul> +<p>Zasady te są gwarancją, która te ewolucje zawsze poprawi. Notatka, która część <i>coś_tam</i> z powyższego wyrażenia jest nieoceniana, więc któraś strona nie wykona w pełni warunku jaki został założony. +</p><p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operatory bitowe", "Przewodnik po języku JavaScript 1.5:Operatory:Operacje na łańcuchach") }} +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Logical_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_l\u00f3gicos", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_logiques", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Logical_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Logical_Operators" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_porównania/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_porównania/index.html new file mode 100644 index 0000000000..5be8b2d982 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_porównania/index.html @@ -0,0 +1,73 @@ +--- +title: Operatory porównania +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_porównania +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +--- +<p> +</p> +<h3 id="Operatory_por.C3.B3wnania" name="Operatory_por.C3.B3wnania"> Operatory porównania </h3> +<p>Operator porównania porównuje jego argumenty i zwraca logiczna wartość bazującą na sprawdzeniu czy wartość jest prawdziwa (true). Argumenty są wartościami liczbowymi, łańcuchowymi, logicznymi lub obiektowymi. Wartości łańcuchowe są porównywane z zasadami opartymi na zasadach zawartych w leksykonach, używając wartości Unicode. Poniższa tabela opisuje operatory porównania. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Operator</th> +<th>Opis</th> +<th>Przykłady powrotu true<sup>1</sup></th> +</tr> +<tr> +<td>Jest równe (==)</td> +<td>Zwraca true, jeśli argumenty są równe. Jeśli dwa argumenty nie są tego samego typu, JavaScript próbuje konwertować argument do odpowiedniego typu dla porównania.</td> +<td><code>3 == var1<br> +<p>"3" == var1<br> +</p> +3 == '3'</code></td> +</tr> +<tr> +<td>Nie jest równe (!=)</td> +<td>Zwraca true, jeśli argumenty nie są równe. Jeśli dwa argumenty nie są tego samego typu, JavaScript próbuje konwertować argument do odpowiedniego typu dla porównania.</td> +<td><code>var1 != 4<br> +var2 != "3"</code></td> +</tr> +<tr> +<td>Ściśle równe (===)</td> +<td>Zwraca true, jeśli argumenty są równe i są tego samego typu.</td> +<td><code>3 === var1</code></td> +</tr> +<tr> +<td>Ściśle nie jest równe (!==)</td> +<td>Zwraca true, jeśli argumenty nie są równe i/lub nie są tego samego typu.</td> +<td><code>var1 !== "3"<br> +3 !== '3'</code></td> +</tr> +<tr> +<td>Jest większe (>)</td> +<td>Zwraca true, jeśli lewy argument jest większy niż prawy argument.</td> +<td><code>var2 > var1</code></td> +</tr> +<tr> +<td>Jest większe lub równe (>=)</td> +<td>Zwraca true, jeśli lewy argument jest większy lub równy prawemu argumentowi.</td> +<td><code>var2 >= var1<br> +var1 >= 3</code></td> +</tr> +<tr> +<td>Jest mniejsze (<)</td> +<td>Zwraca true, jeśli lewy argument jest mniejszy niż prawy argument.</td> +<td><code>var1 < var2</code></td> +</tr> +<tr> +<td>Jest mniejsze lub równe (<=)</td> +<td>Zwraca true, jeśli lewy argument jest mniejszy lub równy prawemu argumentowi. </td> +<td><code>var1 <= var2<br> +var2 <= 5</code></td> +</tr> +</tbody></table> +<p><small><b>Tabela: Operatory porównania</b></small> +</p><p><small><sup>1</sup>Ten przykład podsumowuje, że <code>var1</code> ma przydzieloną wartość 3 i <code>var2</code> ma przydzieloną wartość 4.</small> +</p><p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operatory przypisania", "Przewodnik po języku JavaScript 1.5:Operatory:Operatory arytmetyczne") }} +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Comparison_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_de_comparaci\u00f3n", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_de_comparaison", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Comparison_Operators" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_przypisania/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_przypisania/index.html new file mode 100644 index 0000000000..8af382eee6 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Operatory_przypisania" name="Operatory_przypisania">Operatory przypisania</h3> +<p>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.</p> +<p>Inne operatory przypisania są stenografią dla standardowych operacji, jakie widzimy w poniższej tabeli.</p> +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Skrócony operator</th> + <th>Znaczenie</th> + </tr> + <tr> + <td>x += y</td> + <td>x = x + y</td> + </tr> + <tr> + <td>x -= y</td> + <td>x = x - y</td> + </tr> + <tr> + <td>x *= y</td> + <td>x = x * y</td> + </tr> + <tr> + <td>x /= y</td> + <td>x = x / y</td> + </tr> + <tr> + <td>x %= y</td> + <td>x = x % y</td> + </tr> + <tr> + <td>x <<= y</td> + <td>x = x << y</td> + </tr> + <tr> + <td>x >>= y</td> + <td>x = x >> y</td> + </tr> + <tr> + <td>x >>>= y</td> + <td>x = x >>> y</td> + </tr> + <tr> + <td>x &= y</td> + <td>x = x & y</td> + </tr> + <tr> + <td>x ^= y</td> + <td>x = x ^ y</td> + </tr> + <tr> + <td>x |= y</td> + <td>x = x | y</td> + </tr> + </tbody> +</table> +<p><small><b>Tabela: Operatory 'Przypisanie'</b></small></p> +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory", "Przewodnik po języku JavaScript 1.5:Operatory:Operatory porównania") }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_specjalne/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_specjalne/index.html new file mode 100644 index 0000000000..f50067e328 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/operatory/operatory_specjalne/index.html @@ -0,0 +1,227 @@ +--- +title: Operatory specjalne +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Operatory/Operatory_specjalne +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +--- +<p> +</p> +<h3 id="Operatory_specjalne" name="Operatory_specjalne"> Operatory specjalne </h3> +<p>JavaScript udostępnia następujące operatory specjalne: +</p> +<ul><li> {{ Anch("Operator warunkowy") }} +</li><li> {{ Anch("Operator przecinka") }} +</li><li> {{ Anch("delete") }} +</li><li> {{ Anch("in") }} +</li><li> {{ Anch("instanceof") }} +</li><li> {{ Anch("new") }} +</li><li> {{ Anch("this") }} +</li><li> {{ Anch("typeof") }} +</li><li> {{ Anch("void") }} +</li></ul> +<h4 id="Operator_warunkowy" name="Operator_warunkowy"> Operator warunkowy </h4> +<p><b>Operator warunkowy</b> jest tylko operatorem JavaScript, który pobiera trzy argumenty. Operator może mieć jedną lub dwie wartości oparte na warunku. Składnia: +</p> +<pre>condition ? val1 : val2 +</pre> +<p>Jeśli <code>condition</code> (warunek) jest prawdziwy (true), operator ma wartość <code>val1</code>. W przeciwnym razie posiada wartość <code>val2</code>. Możesz użyć operatora warunkowego wszędzie, gdzie będziesz używał operatorów standardowych. +</p><p>Na przykład: +</p> +<pre>status = (age >= 18) ? "adult" : "minor" +</pre> +<p>Ta instrukcja przydziela wartość <code>"adult"</code> do <code>status</code>, jeśli posiada osiemnaście lub więcej lat. Z drugiej strony przydzielasz <code>"minor"</code> do <code>status</code>. +</p> +<h4 id="Operator_przecinka" name="Operator_przecinka"> Operator przecinka </h4> +<p>Operator przecinka, prosty poszukujący obu argumentów zwracających drugi argument. Ten operator początkowo używany był wewnątrz pętli <code>for</code>. Pozwalał wielokrotnie na aktualizację zmiennych, za każdym razem kiedy pętla jest wykonywana. </p><p>Na przykład, jeśli <code>a</code> jest 2-u wymiarową tablicą z 10 elementami na stronę, następujący operator przecinkowy to kod użytkownika będący przyrostem dwóch zmiennych na raz. Kod drukuje wartości diagonalne elementów w tablicy: +</p> +<pre>for (var i=0, j=9; i <= 9; i++, j--) + document.writeln("a["+i+","+j+"]= " + a[i*10 +j]) +</pre> +<p>Uwaga te dwuwymiarowe tablice są już nie wspierane. Ten przykład emuluje dwuwymiarowe tablice używając jedno wymiarowej tablicy. +</p> +<h4 id="delete" name="delete"> delete </h4> +<p>Operator delete usuwa obiekty, własności obiektów, lub elementy określone w indeksie tablicy. Składnia: +</p> +<pre>delete objectName +delete objectName.property +delete objectName[index] +delete property // legal only within a with statement +</pre> +<p>gdzie: <code>objectName</code> jest nazwą obiektu, <code>property</code> są to istniejące własności i <code>index</code> reprezentuje liczbę całkowita w lokalizacji z elementem tablicy. </p><p>Czwarta forma jest dopuszczalna tylko wewnątrz instrukcji <code>with</code>, aby usunąć własności z obiektu. +</p><p>Możesz użyć operator <code>delete</code> do usunięcia zmiennych zadeklarowanych bez zastrzeżeń, ale nie te z deklaracją instrukcji <code>var</code>. +</p><p>Jeśli operator <code>delete</code> jest prawidłowy, to ustawienia własności lub usuniętego elementu są nieczytelne (<code>undefined</code>). Operator <code>delete</code> zwraca true, jeśli operacja jest możliwa; zwraca <code>false</code>, jeżeli operacja nie jest możliwa. </p> +<pre>x=42 +var y= 43 +myobj=new Number() +myobj.h=4 // tworzy własności h +delete x // zwraca true (potrafi usunąć, jeśli zadeklarujemy brak zastrzeżeń) +delete y // zwraca false (nie potrafi usunąć jeśli zadeklarujemy z var) +delete Math.PI // zwraca false (nie potrafi usunąć predefiniowanych własności) +delete myobj.h // zwraca true (potrafi usunąć własności zdefiniowane przez użytkownika) +delete myobj // zwraca true (potrafi usunąć, jeśli zadeklarujemy brak zastrzeżeń) +</pre> +<p><b>Usuwanie tablicy elementów</b><br> +Kiedy operator delete usunie elementy tablicy, długość tablicy będzie nadal taka sama. Na przykład, jeśli usuniemy a{{ mediawiki.external(3) }}, a{{ mediawiki.external(4) }} to wciąż jest a{{ mediawiki.external(4) }} i a{{ mediawiki.external(3) }} ale niezdefiniowane. +</p><p>Kiedy operator <code><b>delete</b></code> usuwa element, który jest elementem tablicowym, taki element nie jest dłuższy w tablicy. W następnym przykładzie, trees{{ mediawiki.external(3) }} jest usunięty z <code>delete</code>. +</p> +<pre>trees=new Array("redwood","bay","cedar","oak","maple") +delete trees[3] +if (3 in trees) { + // to nie zadziała +} +</pre> +<p>Jeśli chcesz, aby element tablicy istniał, ale masz nieznaną wartość, użyj słowa kluczowego <code>undefined</code> zamiast operatora <code>delete</code>. W następnym przykładzie, jest przydzielona niezidentyfikowana wartość <code>trees{{ mediawiki.external(3) }}</code>, ale element tablicy nadal istnieje: </p> +<pre>trees=new Array("redwood","bay","cedar","oak","maple") +trees[3]=undefined +if (3 in trees) { + // to zadziała +} +</pre> +<h4 id="in" name="in"> in </h4> +<p>Operator <code>in</code> zwraca <code>true</code>, jeśli specyficzne właściwości są w specyficznym obiekcie. Składnia: </p> +<pre>propNameOrNumber in objectName +</pre> +<p>gdzie: <code>propNameOrNumber</code> jest łańcuchem znaków lub wyrażeniem liczbowym reprezentującym własności nazwy lub index tablicy, <code>objectName</code> jest nazwą obiektu. +</p><p>Następujący przykład używa operatora <code>in</code>. +</p> +<pre>// Tablice +trees=new Array("redwood","bay","cedar","oak","maple") +0 in trees // zwracają true +3 in trees // zwracają true +6 in trees // zwracają false +"bay" in trees // zwracają false (musisz mieć specyficzny numer indeksu, + // nie ma wartości w tym indeksie) +"length" in trees // zwracają true (długość jest własnością tablicy) + +// obiekty predefiniowane +"PI" in Math // zwracają true +myString=new String("coral") +"length" in myString // zwracają true + +// obiekty użytkownika +mycar = {make:"Honda",model:"Accord",year:1998} +"make" in mycar // zwracają true +"model" in mycar // zwracają true +</pre> +<h4 id="instanceof" name="instanceof"> instanceof </h4> +<p>Operator <code>instanceof</code> zwraca <code>true</code>, jeśli konkretny obiekt jest obiektem konkretnego typu. Składnia: </p> +<pre>objectName instanceof objectType +</pre> +<p>gdzie: <code>objectName</code> jest nazwą obiektu do porównania z <code>objectType</code> a <code>objectType</code> jest typem obiektu, jak naprzykład <code>Date</code> lub <code>Array</code>. +</p><p>Używamy <code>instanceof</code>, kiedy potrzebujemy porównać typy uruchomionych obiektów. Na przykład, kiedy wystąpi wyjątek, to można, w zależności od zgłoszonego typu wyjątku rozgałęzić różną obsługę tego wyjątku. +</p><p>Na przykład, następujący kod używa <code>instanceof</code> do określenia czy <code>theDay</code> jest obiektem <code>Date</code>. Ponieważ <code>theDay</code> jest obiektem <code>Date</code>, instrukcja w <code>if</code> jest wykonywana. +</p> +<pre>theDay=new Date(1995, 12, 17) +if (theDay instanceof Date) { + // instrukcja do wykonania +} +</pre> +<h4 id="new" name="new"> new </h4> +<p>Użyj operatora <code>new</code>, aby utworzyć przykład definicji użytkownika typu obiektowego lub jednego z predefiniowanego typu obiektowego <code>Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp</code>, lub <code>String</code>. Na serwerze możesz, używać także z <code>DbPool, Lock, File</code> lub <code>SendMail</code>. Użyj <code>new</code> w następującym kodzie: +</p> +<pre>objectName = new objectType ( param1 [,param2] ...[,paramN] ) +</pre> +<p>Możemy także tworzyć obiekty używając inicjatorów obiektu opisanych na stronie <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/U%c5%bcywanie_inicjacji_obiektu">Używanie inicjacji obiektu</a>. +</p><p>Zobacz więcej na temat <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_new">operatora new</a> w dokumentacji JavaScript. +</p> +<h4 id="this" name="this"> this </h4> +<p>Użyj słowa kluczowego <code>this</code> do wskazania aktualnego obiektu. Generalnie, <code>this</code> wskazuje nazwę obiektu w metodzie. Używamy go następująco: </p> +<pre>this[.propertyName] +</pre> +<p><b>Przykład 1.</b><br> +Załóżmy że funkcja <code>validate</code> zatwierdza właściwą wartość, przekazując obiekt oraz górny i dolny zakres. </p> +<pre>function validate(obj, lowval, hival) { + if ((obj.value < lowval) || (obj.value > hival)) + alert("Invalid Value!") +} +</pre> +<p>Teraz możesz wywoływać <code>validate</code> w każdym formularzu korzystając z zdarzenia <code>onChange</code>. +Używamy <code>this</code> do przekazania elementu w formularz, tak jak w przykładzie: +</p> +<pre><B>Wprowadź liczbę pomiędzy 18 i 99:</B> +<INPUT TYPE = "text" NAME = "age" SIZE = 3 + onChange="validate(this, 18, 99)"> +</pre> +<p><b>Przykład 2.</b><br> +Kiedy kombinujesz z własnościami <code>form</code>, zostaniesz skierowany do tymczasowego obiektu znajdującego się w obrębie tego formularza. W następującym przykładzie, formularz <code>myForm</code> składa się z obiektu <code>Text</code> i przycisku. Kiedy użytkownik kliknie w przycisk, wartość obiektu <code>Text</code> ustawia się na nazwę formularza. Przycisk zawiera zdarzenie <code>onClick</code> używane za pomocą uchwytu <code>this.form</code> do wywołania go w tym samym formularzu, <code>myForm</code>. +</p> +<pre><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> +</pre> +<h4 id="typeof" name="typeof"> typeof </h4> +<p>Operator <code>typeof</code> jest użyty w jednej z dwóch sytuacji: +</p> +<pre>1. typeof operand +2. typeof (operand) +</pre> +<p>Operator <code>typeof</code> zwraca łańcuch zwracający typ nie ocenionego argumentu. Argumentem (<code>operand</code>) jest łańcuch, zmienna, słowo kluczowe lub obiekt, dla którego ten typ będzie zwracany. Nawiasy są opcjonalne. </p><p>Przypuśćmy, że zdefiniujemy następujące zmienne: </p> +<pre>var myFun = new Function("5+2") +var shape="round" +var size=1 +var today=new Date() +</pre> +<p>Operator <code>typeof</code> zwraca następujący rezultat dla tych zmiennych: </p> +<pre>typeof myFun is function +typeof shape is string +typeof size is number +typeof today is object +typeof dontExist is undefined +</pre> +<p>Dla słowa kluczowego <code>true</code> i <code>null</code>, operator <code>typeof</code> zwraca następujący rezultat: </p> +<pre>typeof true is boolean +typeof null is object +</pre> +<p>Dla liczby lub łańcucha znaków, operator <code>typeof</code> zwraca następujący rezultat: +</p> +<pre>typeof 62 is number +typeof 'Hello world' is string +</pre> +<p>Dla wartości własności, operator <code>typeof</code> zwraca właściwość stanowiącą typ zmiennej: +</p> +<pre>typeof document.lastModified is string +typeof window.length is number +typeof Math.LN2 is number +</pre> +<p>Dla metod lub funkcji, operator <code>typeof</code> zwraca następujący rezultat: +</p> +<pre>typeof blur is function +typeof eval is function +typeof parseInt is function +typeof shape.split is function +</pre> +<p>Dla obiektów predefiniowanych, operator <code>typeof</code> zwraca następujący rezultat: </p> +<pre>typeof Date is function +typeof Function is function +typeof Math is function +typeof Option is function +typeof String is function +</pre> +<h4 id="void" name="void"> void </h4> +<p>Operator <code>void</code> jest użyty w jednym z następujących przypadków: +</p> +<pre>1. void (expression) +2. void expression +</pre> +<p>Operator <code>void</code> określa wykonane wyrażenie bez zwracania wartości. <code>expression</code> jest wyrażeniem JavaScript do wykonania. Nawiasy otaczające wyrażenie są opcjonalne, jednak dobrym stylem jest ich stosowanie. +</p><p>Możemy zastosować operator <code>void</code> do określenia wyrażenia jako hipertekstowy odnośnik. Wyrażenie jest wykonywane ale nie jest wczytywane w miejsce bieżącego dokumentu. +</p><p>Następujący kod tworzy odnośnik hipertekstowy, który nic nie wywoła w momencie, kiedy użytkownik go kliknie. Kiedy użytkownik kliknie w odnośnik, to wykonane zostanie niezidentyfikowane wyrażenie <code>void(0)</code>, które nie ma żadnego efektu w języku JavaScript. +</p> +<pre><a href="javascript:void(0)">Kliknij tu, nie robiąc nic</a> +</pre> +<p>Następujący kod tworzy odnośnik, który przedłoży (prześle) zawartość formularza w momencie, kiedy użytkownik naciśnie przycisk formularza. +</p> +<pre><a href="javascript:void(document.form.submit())">Kliknij tutaj, aby przesłać zawartość formularza</a> +</pre> +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory:Operacje na łańcuchach", "Przewodnik_po_j%C4%99zyku_JavaScript_1.5:Operatory#Pierwszeństwo_operatorów") }} +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_especiales", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_sp\u00e9ciaux", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Special_Operators" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/index.html new file mode 100644 index 0000000000..2dd4acf285 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_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 +--- +<p> +</p> +<h2 id="Podgl.C4.85d_klas_LiveConnect" name="Podgl.C4.85d_klas_LiveConnect"> Podgląd klas LiveConnect </h2> +<dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Praca_z_klas%c4%85_opakowuj%c4%85c%c4%85">Praca z klasą opakowującą</a> +</dd></dl> +<dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_JavaScript_a_Java">Komunikacja między JavaScript a Java</a> +</dd></dl> +<dl><dd><dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_JavaScript_a_Java#Obiekt_opakowuj.C4.85cy">Obiekt opakowujący</a> +</dd></dl> +</dd></dl> +<dl><dd><dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_JavaScript_a_Java#Praca_z_tablicami_w_Javie">Praca z tablicami w Javie</a> +</dd></dl> +</dd></dl> +<dl><dd><dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_JavaScript_a_Java#Referencja_paczki_i_klasy">Referencja paczki i klasy</a> +</dd></dl> +</dd></dl> +<dl><dd><dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_JavaScript_a_Java#Argumenty_typu_char">Argumenty typu char</a> +</dd></dl> +</dd></dl> +<dl><dd><dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_JavaScript_a_Java#Obs.C5.82uga_wyj.C4.85tk.C3.B3w_Javy_w_JavaScript">Obsługa wyjątków Javy w JavaScript</a> +</dd></dl> +</dd></dl> +<dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_Java_a_JavaScript">Komunikacja między Java a JavaScript</a> +</dd></dl> +<dl><dd><dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Komunikacja_mi%c4%99dzy_Java_a_JavaScript/U%c5%bcywanie_klas_LiveConnect">Używanie klas LiveConnect</a> +</dd></dl> +</dd></dl> +<dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Konwersja_typu_danych">Konwersja typu danych</a> +</dd></dl> +<dl><dd><dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Konwersja_typu_danych/Konwersja_JavaScript_do_Java">Konwersja JavaScript do Java</a> +</dd></dl> +</dd></dl> +<dl><dd><dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Konwersja_typu_danych/Konwersja_Java_do_JavaScript">Konwersja Java do JavaScript</a> +</dd></dl> +</dd></dl> +<div class="noinclude"> +</div> +{{ 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/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/komunikacja_między_java_a_javascript/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/komunikacja_między_java_a_javascript/index.html new file mode 100644 index 0000000000..67a367ab69 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/komunikacja_między_java_a_javascript/index.html @@ -0,0 +1,39 @@ +--- +title: Komunikacja między Java a JavaScript +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Komunikacja_między_Java_a_JavaScript +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect/LiveConnect_Overview +--- +<p> +</p><p>Jeśli chcesz użyć obiektów JavaScript w Javie, musisz zaimportować pakiet <code>netscape.javascript</code> do Twojego pliku Javy. Pakiet ten definiuje następujące klasy: +</p> +<ul><li> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/LiveConnect/JSObject">netscape.javascript.JSObject</a></code> pozwala kodowi Javy na dostęp do metod i własności JavaScript. +</li><li> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/LiveConnect/JSException">netscape.javascript.JSException</a></code> pozwala kodowi Javy obsługiwać błędy JavaScript. +</li></ul> +<p>Zobacz <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5">dokumentację języka JavaScript</a>, aby dowiedzieć się więcej o tych klasach. +</p> +<h3 id="Odnajdywanie_klas_LiveConnect" name="Odnajdywanie_klas_LiveConnect"> Odnajdywanie klas LiveConnect </h3> +<p>W starszych wersjach Netscapa klasy te były rozpowszechniane razem z przeglądarką. Począwszy od JavaScript 1.2 powyższe klasy są dostarczane w pliku .jar file; w poprzednich wersjach JavaScriptu był one dostarczane w pliku .zip. Przykładowo, wraz z Netscape Navigator 4 dla Windows NT, klasy były dystrybuowane w pliku <code>java40.jar</code> w katalogu <code>Program\Java\Classes</code> wewnątrz katalogu przeglądarki. +</p><p>Nieco później klasy zaczęto rozpowszechniać ze środowiskiem Sun Java Runtime; początkowo w pliku "jaws.jar" w katalogu "jre/lib" dystrybucji (dla JRE 1.3), a następnie w "plugin.jar" w tym samym katalogu (JRE 1.4 i kolejne). +</p> +<h3 id="U.C5.BCywanie_klas_LiveConnect_z_JDK" name="U.C5.BCywanie_klas_LiveConnect_z_JDK"> Używanie klas LiveConnect z JDK </h3> +<p>Aby uzyskać dostęp do klas LiveConnect, umieść plik .jar lub .zip w <code>CLASSPATH</code> kompilatora JDK w jeden z następujących sposobów: +</p> +<ul><li> Utwórz zmienną środowiskową <code>CLASSPATH</code>, aby określić ścieżkę i nazwę pliku .jar lub .zip. +</li><li> Określ lokalizację pliku .jar lub .zip, gdy kompilujesz używając parametru <code>-classpath</code> linii poleceń. +</li></ul> +<p>Możesz określić zmienną środowiskową w systemie Windows NT poprzez dwukrotne kliknięcie ikony System w Panelu Sterowania i utworzenie zmiennej środowiskowej o nazwie <code>CLASSPATH</code> z wartością podobną do poniższej: +</p> +<pre class="eval">C:\Program Files\Java\jre1.4.1\lib\plugin.jar +</pre> +<p>Zobacz dokumentację JDK documentation, aby uzyskać więcej informacji o <code>CLASSPATH</code>. +</p><p><b>Uwaga:</b> Ponieważ Java jest językiem o silnej typizacji, zaś JavaScript językiem o typizacji słabej, gdy używasz LiveConnecta silnik JavaScriptu konwertuje wartości argumentu do odpowiednich typów danych drugiego języka. Zobacz artykuł o <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Konwersja_typu_danych">konwersji typu danych</a>, aby uzyskać pełne informacje. +</p><p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Podgląd klas LiveConnect:Komunikacja między JavaScript a Java", "Przewodnik po języku JavaScript 1.5:Podgląd klas LiveConnect:Komunikacja między Java a JavaScript:Używanie klas LiveConnect") }} +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/LiveConnect_Overview/Java_to_JavaScript_Communication", "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_general_de_LiveConnect/Comunicaci\u00f3n_de_Java_con_JavaScript", "ja": "ja/Core_JavaScript_1.5_Guide/LiveConnect_Overview/Java_to_JavaScript_Communication" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/konwersja_typu_danych/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/konwersja_typu_danych/index.html new file mode 100644 index 0000000000..18a30fa8e9 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/konwersja_typu_danych/index.html @@ -0,0 +1,24 @@ +--- +title: Konwersja typu danych +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Konwersja_typu_danych +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect/LiveConnect_Overview +--- +<p> +</p> +<h3 id="Konwersja_typu_danych" name="Konwersja_typu_danych"> Konwersja typu danych </h3> +<p>Ponieważ Java jest językiem o silnej typizacji, zaś JavaScript językiem o typizacji słabej, gdy używasz LiveConnecta silnik JavaScriptu konwertuje wartości argumentu do odpowiednich typów danych drugiego języka. Konwersje te zostały opisane w poniższych sekcjach: +</p> +<ul><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Konwersja_typu_danych/Konwersja_JavaScript_do_Java">Konwersja z JavaScriptu do Javy</a> +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Podgl%c4%85d_klas_LiveConnect/Konwersja_typu_danych/Konwersja_Java_do_JavaScript">Konwersja z Javy do JavaScriptu</a> +</li></ul> +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Podgląd klas LiveConnect:Komunikacja między Java a JavaScript:Używanie klas LiveConnect", "Przewodnik po języku JavaScript 1.5:Podgląd klas LiveConnect:Konwersja typu danych:Konwersja JavaScript do Java") }} +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/LiveConnect_Overview/Data_Type_Conversions", "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_general_de_LiveConnect/Conversiones_de_tipos_de_datos", "ja": "ja/Core_JavaScript_1.5_Guide/LiveConnect_Overview/Data_Type_Conversions" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/konwersja_typu_danych/konwersja_javascript_do_java/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/konwersja_typu_danych/konwersja_javascript_do_java/index.html new file mode 100644 index 0000000000..04848bc653 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/podgląd_klas_liveconnect/konwersja_typu_danych/konwersja_javascript_do_java/index.html @@ -0,0 +1,320 @@ +--- +title: Konwersja JavaScript do Java +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Podgląd_klas_LiveConnect/Konwersja_typu_danych/Konwersja_JavaScript_do_Java +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect/LiveConnect_Overview +--- +<p> +</p> +<h3 id="Konwersja_JavaScript_do_Java" name="Konwersja_JavaScript_do_Java"> Konwersja JavaScript do Java </h3> +<p>Kiedy wywołujesz metody Java i zmieniasz parametry z JavaScript, typ danych tych parametrów zmienione zostaną konwertowane stosownie do opisanych reguł w następujących tematach: </p> +<ul><li> {{ Anch("Wartości liczbowe") }} +</li><li> {{ Anch("Wartości Boolean") }} +</li><li> {{ Anch("Wartości String") }} +</li><li> {{ Anch("Wartości niezidentyfikowane") }} +</li><li> {{ Anch("Wartości Null") }} +</li><li> {{ Anch("Obiekty JavaArray i JavaObject") }} +</li><li> {{ Anch("Obiekty JavaClass") }} +</li><li> {{ Anch("Inne obiekty JavaScript") }} +</li></ul> +<p>Zwraca wartości metod <code>netscape.javascript.JSObject</code>, które są zawsze konwertowane do przykładu <code><b>java.lang.Object</b></code>. Reguły konwersji, które zwracają wartość są także opisane w tym temacie. </p><p>Na przykład, jeśli zwraca numer JavaScript <code>JSObject.eval</code>, możesz znaleźć reguły konwersji tegoż numeru do numeru <code>java.lang.Object</code> w {{ Anch("wartości liczbowe") }}. +</p> +<h4 id="Warto.C5.9Bci_liczbowe" name="Warto.C5.9Bci_liczbowe"> Wartości liczbowe </h4> +<p>Kiedy w JavaScript typ Number zmienisz na jako parametry metod Java, Java konwertuje wartości stosownie do zasad opisanych w następującej tabeli: </p><p><br> +</p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Java typ parametru</th> +<th>Zasady konwersji</th> +</tr> +<tr> +<td>double</td> +<td>* Dokładne wartości są transferowane do Javy bez zaokrąglonych i bez straconych wielkości lub znaku . <ul><li> NaN jest konwertowane do NaN.</li></ul></td> </tr> +<tr> +<td>java.lang.Double<br> +java.lang.Object</td> +<td>Nowy przykład <code>java.lang.Double</code> jest tworzony i dokładna wartość jest transferowana do Java bez zaokrągleń i bez straconej wielkości lub znaku.</td> +</tr> +<tr> +<td><b>float</b></td> +<td>* Wartości <b>float</b> są dokładnie zaokrąglane. +<ul><li> Wartości, które są zbyt za duże lub za małe, aby być prezentowanym są zaokrąglane do +nieskończoności lub -nieskończoności. +</li><li> NaN jest konwertowany do NaN.</li></ul></td> </tr> +<tr> +<td><b>byte</b><br> +<p><b>char</b><br> +<b>int</b><br> +<b>long</b><br> +</p> +<b>short</b></td> +<td>* Wartości są okrążane przy użyciu trybu round-to-negative-infinity. +<ul><li> Wartości które są też duże lub małe reprezentuje rezultat w błędzie run-time. +</li><li> NaN nie może być konwertowany, czego rezultatem jest błąd run-time.</li></ul></td> </tr> +<tr> +<td>java.lang.String</td> +<td>Wartości są konwertowane do łańcucha znaków. Na przykład: +<ul><li> 237 staje się "237"</li></ul></td> </tr> +<tr> +<td>boolean</td> +<td>* Wartości 0 i NaN są konwertowanie do false. +<ul><li> Inne wartości są konwertowane do true.</li></ul></td> </tr> +</tbody></table> +<p>Kiedy liczba JavaScript przechodzi jako parametr metody Java, która oczekuje przykładu z <code>java.lang.String</code>, numer jest konwertowany do łańcucha znaków. Użyj metody <code>equals()</code> do porównania rezultatów tej konwersji z innymi wartościami łańcuchów znaków. +</p> +<h4 id="Warto.C5.9Bci_logiczne" name="Warto.C5.9Bci_logiczne"> Wartości logiczne </h4> +<p>Kiedy w JavaScript typ Boolean zmienisz na parametry metod Javy, Java konwertuje wartości stosownie do zasad opisanych w następującej tabeli: </p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Java typ parametru</th> +<th>Zasady konwersji</th> +</tr> +<tr> +<td>boolean</td> +<td>Wszystkie wartości są konwertowane w kierunku wyposażenia Javy.</td> +</tr> +<tr> +<td>lava.lang.Boolean<br> +java.lang.Object</td> +<td>Nowy przykład <code>java.lang.Boolean</code> jest utworzony. Każdy parametr tworzy nowy przykład, nie jeden przykład z tymi samymi prymitywnymi wartościami.</td> +</tr> +<tr> +<td>java.lang.String</td> +<td>Wartości są konwertowane do łańcuchów znaków. Na przykład: +<ul><li> true staje się "true" +</li><li> false staje się "false"</li></ul></td> </tr> +<tr> +<td>byte<br> +<p>char<br> +double<br> +float<br> +int<br> +long<br> +</p> +short</td> +<td>* true staje się 1 +<ul><li> false staje się 0</li></ul></td> </tr> +</tbody></table> +<p>Kiedy zmienimy JavaScript wartość boolean, który jest jako parametr do metod Javy, oczekuje przykładu <code>java.lang.String</code>, wartość boolean jest konwertowana do wartości string. Użyj operatora <code>==</code> do porównania rezultatów tej konwersji z innymi wartościami string. +</p> +<h4 id="Warto.C5.9B.C4.87_String" name="Warto.C5.9B.C4.87_String"> Wartość String </h4> +<p>Kiedy w JavaScript typ string zmienisz na parametry metod Javy, Java konwertuje wartości stosownie do zasad opisanych w następującej tabeli: </p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Java typ parametru</th> +<th>Zasady konwersji</th> +</tr> +<tr> +<td><b>java.lang.String</b><br> +<b>java.lang.Object</b></td> +<td>JavaScript 1.4: +<ul><li> Łańcuch JavaScript jest konwertowany przykładem java.lang.String z wartościami Unicode.<br> +</li></ul> +<p>JavaScript 1.3 i wcześniejsze: +</p> +<ul><li> Łańcuch JavaScript jest konwertowany przykładem java.lang.String z wartościami ASCII.</li></ul></td> </tr> +<tr> +<td><b>byte</b> +<p><b>double</b><br> +<b>float</b><br> +<b>int</b><br> +<b>long</b><br> +</p> +<b>short</b></td> +<td>Wszystkie wartości są konwertowane do liczb opisanych w ECMA-262. +Wartości string JavaScript jest konwertowana do liczby stosownie do opisu ECMA-262.</td> +</tr> +<tr> +<td><b>char</b></td> +<td>JavaScript 1.4: +<ul><li> jeden znak łańcucha jest konwertowany do znaków Unicode. +</li><li> wszystkie inne wartości są konwertowane na liczby.<br> +</li></ul> +<p>JavaScript 1.3 i wcześniejsze: +</p> +<ul><li> Wszystkie wartości są konwertowane na liczby.</li></ul></td> </tr> +<tr> +<td><b>boolean</b></td> +<td>* Pusty łańcuch staje się false. +<ul><li> Wszystkie inne klucze staną się true.</li></ul></td> </tr> +</tbody></table> +<h4 id="Warto.C5.9Bci_niezidentyfikowane" name="Warto.C5.9Bci_niezidentyfikowane"> Wartości niezidentyfikowane </h4> +<p>Kiedy w JavaScript wartości niezidentyfikowane zmienisz na parametry metod Javy, Java konwertuje wartości stosownie do zasad opisanych w następującej tabeli: </p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Java typ parametru</th> +<th>Zasady konwersji</th> +</tr> +<tr> +<td><b>lava.lang.String</b><br> +<b>java.lang.Object</b></td> +<td>Wartość jest konwertowana do przykładu java.lang.String, którego wartość jest łańcuch "niezdefiniowany".</td> +</tr> +<tr> +<td><b>boolean</b></td> +<td>Wartość staje się false.</td> +</tr> +<tr> +<td><b>double</b><br> +<b>float</b></td> +<td>Wartość staje się NaN.</td> +</tr> +<tr> +<td><b>byte</b><br> +<p><b>char</b><br> +<b>int</b><br> +<b>long</b><br> +</p> +<b>short</b></td> +<td>Wartość staje się 0.</td> +</tr> +</tbody></table> +<p>Konwersja niezdefiniowanej wartości wartość prawdopodobnie w JavaScript 1.3 i późniejszych wersjach. wcześniejsze wersje JavaScript nie dostarczają wartości niezdefiniowanych. </p><p>Kiedy wartość niezdefiniowana JavaScript jest zmieniona na parametr metody Java, która oczekuje na przykład <b>java.lang.String</b>, wartość niezdefiniowana jest konwertowana do wartości string. Użyj operator == do porównania tych konwersji z inną wartością string. +</p> +<h4 id="Warto.C5.9B.C4.87_Null" name="Warto.C5.9B.C4.87_Null"> Wartość Null </h4> +<p>Kiedy w JavaScript wartości null zmienisz na parametry metod Javy, Java konwertuje wartości stosownie do zasad opisanych w następującej tabeli: </p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Java typ parametru</th> +<th>Zasady konwersji</th> +</tr> +<tr> +<td><b>Jakaś class</b><br> +<b>Jakiś typ interfejsu</b></td> +<td>Wartość stanie się null.</td> +</tr> +<tr> +<td><b>byte</b><br> +<p><b>char</b><br> +<b>double</b><br> +<b>float</b><br> +<b>int</b><br> +<b>long</b><br> +</p> +<b>short</b></td> +<td>Wartość stanie się 0.</td> +</tr> +<tr> +<td><b>boolean</b></td> +<td>Wartość stanie się false.</td> +</tr> +</tbody></table> +<h4 id="Obiekty_JavaArray_i_JavaObject" name="Obiekty_JavaArray_i_JavaObject"> Obiekty JavaArray i JavaObject </h4> +<p>W wielu sytuacjach, kiedy zmieniałeś JavaScript JavaArray lub JavaObject jako parametry metod w Javie, Java prosto rozpakowuje obiekt; w kilku sytuacjach, obiekt jest poprawiany do innego typu danych stosowanych do opisu zasad w następującej tabeli: </p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Java typ parametru</th> +<th>Zasady konwersji</th> +</tr> +<tr> +<td><b>Jakiś interfejs lub klasa, która przypisuje kompatybilność z rozpakowanym obiekt.</b></td> +<td>Obiekt jest rozpakowany.</td> +</tr> +<tr> +<td><b>java.lang.String</b></td> +<td>Obiekt jest rozpakowywany, metoda toString rozpakowanego obiektu Java jest nazywana, i w rezultacie zwrócona jako nowy przykład java.lang.String.</td> +</tr> +<tr> +<td><b>byte</b><br> +<p><b>char</b><br> +<b>double</b><br> +<b>float</b><br> +<b>int</b><br> +<b>long</b><br> +</p> +<b>short</b></td> +<td>Obiekt jest rozpakowany, i w następujących dwóch sytuacjach się może to zdarzyć: +<ul><li> Jeśli rozpakowany obiekt Java posiada metodę doubleValue, to JavaArray lub JavaObject jest konwertowany do wartości powrotu tej metody. +</li><li> Jeśli rozpakowany obiekt Java nie posiada metody doubleValue, błąd zdarzenia.</li></ul></td> </tr> +<tr> +<td><b>boolean</b></td> +<td>W JavaScript 1.3 i późniejszych wersjach, obiekt jest rozpakowywany i przytrafia się w obu następujących sytuacjach: +<ul><li> Jeśli obiekt jest null, to jest konwertowany jako false. +</li><li> Jeśli obiekt ma jakąkolwiek wartość, to jest konwertowany do true. +</li></ul> +<p>W JavaScript 1.2 i wcześniejszych wersjach, obiekt jest rozpakowany i zdarza się w obu następujących sytuacjach: +</p> +<ul><li> Jeśli rozpakowany obiekt posiada metodę booleanValue, źródło obiektu jest konwertowane do zwracanej wartości. +</li><li> Jeśli obiekt nie posiada metody booleanValue, konwersja zostanie nie wykonana.</li></ul></td> </tr> +</tbody></table> +<p>interfejs lub klasa jest kompatybilnym przypisaniem z rozpakowanego obiektu jeśli obiekt ten jest przykładem typu parametru Javy. To jest, że następująca instrukcja musi zwrócić true: </p> +<pre>unwrappedObject instanceof parameterType +</pre> +<h4 id="Obiekty_JavaClass" name="Obiekty_JavaClass"> Obiekty JavaClass </h4> +<p>Kiedy w JavaScript obiekt JavaClass zmienisz na parametry metod Javy, Java konwertuje wartości stosownie do zasad opisanych w następującej tabeli: </p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Java typ parametru</th> +<th>Zasady konwersji</th> +</tr> +<tr> +<td><b>java.lang.Class</b></td> +<td>Obiekt jest rozpakowany.</td> +</tr> +<tr> +<td><b>java.lang.JSObject</b><br> +<b>java.lang.Object</b></td> +<td>Obiekt JavaClass jest pakowany w nowym przykładzie java.lang.JSObject.</td> +</tr> +<tr> +<td><b>java.lang.String</b></td> +<td>Obiekt jest rozpakowywany, metoda toString rozpakowanego obiektu Java jest nazywana, i w rezultacie zwrócona jako nowy przykład java.lang.String.</td> +</tr> +<tr> +<td><b>boolean</b></td> +<td>W JavaScript 1.3 i późniejszych wersjach, obiekt jest rozpakowywany i przytrafia się w obu następujących sytuacjach: +<ul><li> Jeśli obiekt jest null, to jest konwertowany jako false. +</li><li> Jeśli obiekt ma jakąkolwiek wartość, to jest konwertowany do true. +</li></ul> +<p>W JavaScript 1.2 i wcześniejszych wersjach, obiekt jest rozpakowany i zdarza się w obu następujących sytuacjach: </p> +<ul><li> Jeśli rozpakowany obiekt posiada metodę booleanValue, źródło obiektu jest konwertowane do zwracanej wartości. +</li><li> Jeśli obiekt nie posiada metody booleanValue, konwersja zostanie nie wykonana.</li></ul></td> </tr> +</tbody></table> +<h4 id="Inne_obiekty_JavaScript" name="Inne_obiekty_JavaScript"> Inne obiekty JavaScript </h4> +<p>Kiedy w JavaScript jakikolwiek obiekt zmienisz na parametry metod Javy, Java konwertuje wartości stosownie do zasad opisanych w następującej tabeli: </p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Java typ parametru</th> +<th>Zasady konwersji</th> +</tr> +<tr> +<td><b>java.lang.JSObject</b><br> +<b>java.lang.Object</b></td> +<td>Obiekt JavaClass jest pakowany w nowym przykładzie java.lang.JSObject.</td> +</tr> +<tr> +<td><b>java.lang.String</b></td> +<td>Obiekt jest rozpakowywany, metoda toString rozpakowanego obiektu Java jest nazywana, i w rezultacie zwrócona jako nowy przykład java.lang.String.</td> +</tr> +<tr> +<td><b>byte</b><br> +<p><b>char</b><br> +<b>double</b><br> +<b>float</b><br> +<b>int</b><br> +<b>long</b><br> +</p> +<b>short</b></td> +<td>Obiekty są generowane używając wartości logicznej operatora ToPrimitive opisanego w ECMA-262. Użyj ukryty PreferredType z operatorem Number.</td> +</tr> +<tr> +<td><b>boolean</b></td> +<td>W JavaScript 1.3 i późniejszych wersjach, obiekt jest rozpakowywany i przytrafia się w obu następujących sytuacjach: +<ul><li> Jeśli obiekt jest null, to jest konwertowany jako false. +</li><li> Jeśli obiekt ma jakąkolwiek wartość, to jest konwertowany do true. +</li></ul> +<p>W JavaScript 1.2 i wcześniejszych wersjach, obiekt jest rozpakowany i zdarza się w obu następujących sytuacjach: +</p> +<ul><li> Jeśli rozpakowany obiekt posiada metodę booleanValue, źródło obiektu jest konwertowane do zwracanej wartości. +</li><li> Jeśli obiekt nie posiada metody booleanValue, konwersja zostanie nie wykonana.</li></ul></td> </tr> +</tbody></table> +<p><br> +</p><p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/LiveConnect_Overview/Data_Type_Conversions/JavaScript_to_Java_Conversions", "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_general_de_LiveConnect/Conversiones_de_tipos_de_datos/Conversiones_de_JavaScript_a_Java", "ja": "ja/Core_JavaScript_1.5_Guide/LiveConnect_Overview/Data_Type_Conversions/JavaScript_to_Java_Conversions" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/powrót_dziedziczenia_własności/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/powrót_dziedziczenia_własności/index.html new file mode 100644 index 0000000000..1f4acab46c --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/powrót_dziedziczenia_własności/index.html @@ -0,0 +1,24 @@ +--- +title: Powrót dziedziczenia własności +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Powrót_dziedziczenia_własności +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +--- +<p> +</p> +<h3 id="Powr.C3.B3t_dziedziczenia_w.C5.82asno.C5.9Bci" name="Powr.C3.B3t_dziedziczenia_w.C5.82asno.C5.9Bci"> Powrót dziedziczenia własności </h3> +<p>W poprzednim temacie zostało opisane jak w JavaScript działają prototypy konstruktorów dostarczające hierarchie i dziedziczenie. Ten temat omawia kilka podtematów, które były konieczne do omówienia we wcześniejszych dyskusjach. </p> +<dl><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Powr%c3%b3t_dziedziczenia_w%c5%82a%c5%9bciwo%c5%9bci/Warto%c5%9bci_lokalne_vs._dziedziczone">Wartości lokalne vs. dziedziczone</a> +</dd><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Powr%c3%b3t_dziedziczenia_w%c5%82a%c5%9bciwo%c5%9bci/Okre%c5%9blanie_wzajemnych_relacji_obiektu">Określanie wzajemnych relacji obiektu</a> +</dd><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Powr%c3%b3t_dziedziczenia_w%c5%82a%c5%9bciwo%c5%9bci/Globalne_informacje_w_konstruktorach">Globalne informacje w konstruktorach</a> +</dd><dd> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Powr%c3%b3t_dziedziczenia_w%c5%82a%c5%9bciwo%c5%9bci/Brak_wielokrotnego_dziedziczenia">Brak wielokrotnego dziedziczenia</a> +</dd></dl> +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Praca z przykładem:Więcej elastycznych konstruktorów", "Przewodnik po języku JavaScript 1.5:Powrót dziedziczenia własności:Wartości lokalne vs. dziedziczone") }} +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited", "es": "es/Gu\u00eda_JavaScript_1.5/M\u00e1s_sobre_la_herencia_de_propiedades", "ja": "ja/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/powrót_dziedziczenia_własności/wartości_lokalne_vs._dziedziczone/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/powrót_dziedziczenia_własności/wartości_lokalne_vs._dziedziczone/index.html new file mode 100644 index 0000000000..c094e90365 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/powrót_dziedziczenia_własności/wartości_lokalne_vs._dziedziczone/index.html @@ -0,0 +1,71 @@ +--- +title: Wartości lokalne vs. dziedziczone +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Powrót_dziedziczenia_własności/Wartości_lokalne_vs._dziedziczone +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +--- +<p> +</p> +<h3 id="Warto.C5.9Bci_lokalne_vs._dziedziczone" name="Warto.C5.9Bci_lokalne_vs._dziedziczone"> Wartości lokalne vs. dziedziczone </h3> +<p>Gdy korzystasz z dostępu do własności obiektu, JavaScript wykonuje następujące kroki, tak jak opisano w poprzednim rozdziale: +</p> +<ol><li> Sprawdza czy wartość istnieje lokalnie. Jeśli tak, to zwraca tę wartość. +</li><li> Jeśli wartość lokalna nie istnieje, sprawdza łańcuch prototypu (używając własności <code>__proto__</code>). +</li><li> Jeśli obiekt w łańcuchu prototypu posiada wartość dla określonej wartości, zwraca tę wartość. +</li><li> Jeśli własność ta nie została odnaleziona, to obiekt nie posiada tej własności. +</li></ol> +<p>Rezultat tych kroków zależy od sposobu, w jaki definiujesz rzeczy w kodzie. Oyginalny przykład używał następujących definicji: +</p> +<pre>function Employee () { +this.name = ""; +this.dept = "general"; +} + +function WorkerBee () { +this.projects = []; +} +WorkerBee.prototype = new Employee; +</pre> +<p>Przypuśćmy, że wraz z tymi definicjami utworzyłeś <code>amy</code> jako instancję <code>WorkerBee</code> za pomocą poniższej instrukcji: +</p> +<pre>amy = new WorkerBee; +</pre> +<p>Obiekt <code>amy</code> posiada jedną lokalną własność, <code>projects</code>. Wartości własności <code>name</code> i <code>dept</code> nie są lokalne dla <code>amy</code> i dlatego są pobrane z własności <code>__proto__</code> obiektu <code>amy</code>. W ten sposób <code>amy</code> posiada następujące wartości własności: +</p> +<pre>amy.name == ""; +amy.dept = "general"; +amy.projects == []; +</pre> +<p>Teraz przypuśćmy, że zmienisz wartość własności <code>name</code> w prototypie powiązanym z <code>Employee</code>: +</p> +<pre>Employee.prototype.name = "Unknown" +</pre> +<p>Na pierwszy rzut oka może Ci sie wydawać, że nowa wartość zostanie przekazana dalej do wszystkich instancji <code>Employee</code>. Nie dzieje się tak. +</p><p>Gdy tworzysz <i>dowolną</i> instancję obiektu <code>Employee</code>, instancja ta otrzymuje lokalną wartość dla własności <code>name</code> (pusty ciąg znaków). Oznacza to, że gdy ustawisz prototyp <code>WorkerBee</code> poprzez utworzenie nowego obiektu <code>Employee</code>, <code>WorkerBee.prototype</code> posiada lokalną wartość dla własności <code>name</code>. Dlatego więc, gdy JavaScript sprawdza własność <code>name</code> obiektu <code>amy</code> (instancji <code>WorkerBee</code>), JavaScript znajduje lokalną wartość dla tej własności w <code>WorkerBee.prototype</code>. Dlatego też nie sprawdza on łańcucha dalej aż do <code>Employee.prototype</code>. +</p><p>Jeśli chcesz zmienić wartość własności obiektu w momencie uruchomienia i sprawić, by była ona dziedziczona przez wszystkich potomków obiektu, nie możesz zdefiniować własności w funkcji konstruktora obiektu. Zamiast tego dodaj ją do prototypu powiązanego z konstruktorem. Na przykład, zakładając zmianę poprzedniego kodu na poniższy: +</p> +<pre>function Employee () { + this.dept = "general"; +} +Employee.prototype.name = ""; + +function WorkerBee () { +this.projects = []; +} +WorkerBee.prototype = new Employee; + +amy = new WorkerBee; + +Employee.prototype.name = "Unknown"; +</pre> +<p>W tym wypadku własność <code>name</code> obiektu <code>amy</code> przyjmuje wartość "Unknown". +</p><p>Jak pokazuję powyższe przykłady, jeśli chcesz zachować domyślne wartości dla własności obiektu i móc zmienić domyślne wartości w momencie uruchomienia, powinieneś utworzyć własności w prototypie konstruktora, a nie w samej funkcji konstruktora. +{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Powrót dziedziczenia własności", "Przewodnik po języku JavaScript 1.5:Powrót dziedziczenia własności:Określanie wzajemnych relacji obiektu") }} +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Local_versus_Inherited_Values", "es": "es/Gu\u00eda_JavaScript_1.5/M\u00e1s_sobre_la_herencia_de_propiedades/Valores_locales_frente_a_los_heredados", "ja": "ja/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Local_versus_Inherited_Values" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/index.html new file mode 100644 index 0000000000..28e5f9255c --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/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 +--- +<p> </p> +<h3 id="Przyk.C5.82ad_obiektu_Pracownik" name="Przyk.C5.82ad_obiektu_Pracownik">Przykład obiektu Pracownik</h3> +<p>Dalsza część tego rozdziału opiera się na hierarchii pracowników przedstawionej na poniższym rysunku.</p> +<p><img alt="Grafika:hier01.png"></p> +<p><small><b>Rysunek 8.1: Prosta hierarchia obiektu</b></small></p> +<p>W przykładzie tym zostały użyte następujące obiekty:</p> +<ul> + <li>Pracownik posiada własność imie (której domyślną wartością jest pusty łańcuch znaków) i dept (z domyślną wartością "ogólny").</li> + <li>Manager jest oparty na Pracowniku. Dodaje własność raporty (której domyślną wartością jest pusta tablica mająca w zamierzeniu przyjmować obiekty Pracownik jako swoje wartości).</li> + <li>Robotnik również jest oparty na Pracowniku. Dodaje własność projekty (której domyślną wartością jest pusta tablica mająca w zamierzeniu przyjmować łańcuchy znaków jako swoje wartości).</li> + <li>Sprzedawca jest oparty na Robotniku. Dodaje on własność przydzial (z domyślną wartością 100). Nadpisuje on również własność dept wartością "sprzedaż" wskazując, że wszyscy sprzedawcy są w tym samym dziale.</li> + <li>Inzynier jest oparty na Robotniku. Dodaje własność maszyna (której domyślną wartością jest pusty łańcuch znaków) oraz nadpisuje własność dept wartością "inżynieria".</li> +</ul> +<p>Pozostała część przykładu:</p> +<ul> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_przyk%c5%82adem/Tworzenie_hierarchii">Tworzenie hierarchii</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_przyk%c5%82adem/W%c5%82a%c5%9bciwo%c5%9bci_obiektu">Właściwości obiektu</a> + <ul> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_przyk%c5%82adem/W%c5%82a%c5%9bciwo%c5%9bci_obiektu/Dziedziczenie_w%c5%82a%c5%9bciwo%c5%9bci">Dziedziczenie właściwości</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_przyk%c5%82adem/W%c5%82a%c5%9bciwo%c5%9bci_obiektu/Dodawanie_w%c5%82a%c5%9bciwo%c5%9bci">Dodawanie właściwości</a></li> + </ul> + </li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_przyk%c5%82adem/Wi%c4%99cej_elastycznych_konstruktor%c3%b3w">Więcej elastycznych konstruktorów</a></li> +</ul> +<div class="noinclude"> + <p>{{ 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") }}</p> +</div> +<p> </p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/tworzenie_hierarchii/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/tworzenie_hierarchii/index.html new file mode 100644 index 0000000000..a15422c92d --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/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 +--- +<p> </p> +<h3 id="Tworzenie_hierarchii" name="Tworzenie_hierarchii">Tworzenie hierarchii</h3> +<p>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.</p> +<p>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.</p> +<p>W prawdziwej aplikacji zdefiniowałbyś prawdopodobnie konstruktory, które pozwoliłyby Ci na zapewnienie własnościom wartości w czasie tworzenia obiektu (zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_przyk%c5%82adem/Wi%c4%99cej_elastycznych_konstruktor%c3%b3w">więcej elastycznych konstruktorów</a>, aby uzyskać więcej informacji). Na chwilę obecną te proste definicje zademonstrują jak objawia się dziedziczenie.</p> +<p><img alt="Grafika:hier02.png"><br> + <small><b>Rysunek 8.2: Definicje obiektu Pracownik</b></small></p> +<p>Poniższe definicje obiektu <code>Pracownik</code> 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.</p> +<p></tr></p> +<table class="fullwidth-table"> + <tbody> + <tr> + <th>JavaScript</th> + <th>Java</th> + </tr> + <tr> + <td> + <pre> +function Pracownik () { +this.imie = ""; +this.dept = "ogólny"; +} +</pre> + </td> + <td> + <pre> +public class Pracownik { + public String imie; + public String dept; + public Pracownik () { + this.imie = ""; + this.dept = "ogólny"; + } +} +</pre> + </td> + </tr> + </tbody> +</table> +<p>Definicje <code>Manager</code> i <code>Robotnik</code> 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.</p> +<p></tr></p> +<table class="fullwidth-table"> + <tbody> + <tr> + <th>JavaScript</th> + <th>Java</th> + </tr> + <tr> + <td> + <pre> +function Manager () { +this.raporty = []; +} +Manager.prototype = new Pracownik; + +function Robotnik () { +this.projekty = []; +} +Robotnik.prototype = new Pracownik; +</pre> + </td> + <td> + <pre> +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]; + } +} +</pre> + </td> + </tr> + </tbody> +</table> +<p>Definicje <code>Inzynier</code> i <code>Sprzedawca</code> tworzą obiekty, które pochodzą od <code>Robotnik</code> a stamtąd od <code>Pracownik</code>. 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ść <code>dept</code> nowymi wartościami specyficznymi dla tych obiektów.</p> +<table class="fullwidth-table"> + <tbody> + <tr> + <th>JavaScript</th> + <th>Java</th> + </tr> + <tr> + <td> + <pre> +function Sprzedawca () { + this.dept = "sprzedaż"; + this.przydzial = 100; +} +Sprzedawca.prototype = new Robotnik; + +function Inzynier () { + this.dept = "inżynieria"; + this.maszyna = ""; +} +Inzynier.prototype = new Robotnik; +</pre> + </td> + <td> + <pre> +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 = ""; + } +} +</pre> + </td> + </tr> + </tbody> +</table> +<p>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.</p> +<p><b>Uwaga:</b> Termin + <i> + instancja</i> + 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 <code>janina</code> jest instancją <code>Inzynier</code>. Podobnie chociaż terminy + <i> + rodzic, dziecko, przodek</i> + i + <i> + potomek</i> + 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.</p> +<p><img alt="Grafika:hier03.png"><br> + <small><b>Rysunek 8.3: Tworzenie obiektów z prostymi definicjami</b></small></p> +<p>{{ 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") }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/własności_obiektu/dodawanie_własności/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/własności_obiektu/dodawanie_własności/index.html new file mode 100644 index 0000000000..ec2e836159 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/własności_obiektu/dodawanie_własności/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 +--- +<p> </p> +<h3 id="Dodawanie_w.C5.82asno.C5.9Bci" name="Dodawanie_w.C5.82asno.C5.9Bci">Dodawanie własności</h3> +<p>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:</p> +<pre>mark.bonus = 3000; +</pre> +<p>Teraz obiekt <code>mark</code> posiada własność bonus, lecz nie posiadają jej inne obiekty <code>WorkerBee</code>.</p> +<p>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ść <code>specialty</code> dla wszystkich obiektów employee za pomocą następującej instrukcji:</p> +<pre>Employee.prototype.specialty = "none"; +</pre> +<p>Gdy tylko JavaScript wykona tę instrukcję, obiekt <code>mark</code> również będzie posiadał własność specialty wraz z wartością "<code>none</code>". Poniższy rysunek pokazuje efekt dodania tej własności do prototypu Employee oraz następnie nadpisania jej prototypem <code>Engineer</code>.</p> +<p><img alt="Grafika:hier04.gif"><br> + <small><b>Rysunek 8.4: Dodawanie własności</b></small> {{ 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") }}</p> +<div class="noinclude"> + </div> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/własności_obiektu/dziedziczenie_własności/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/własności_obiektu/dziedziczenie_własności/index.html new file mode 100644 index 0000000000..8287857c63 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/własności_obiektu/dziedziczenie_własności/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 +--- +<p> </p> +<h3 id="Dziedziczenie_w.C5.82asno.C5.9Bci" name="Dziedziczenie_w.C5.82asno.C5.9Bci">Dziedziczenie własności</h3> +<p>Przypuśćmy, że utworzyłeś obiekt marek jako <code>Robotnik</code>, tak jak pokazano na <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_przyk%c5%82adem/Tworzenie_hierarchii">Rysunku 8.3</a>, za pomocą poniższej instrukcji:</p> +<pre class="eval">marek = new Robotnik; +</pre> +<p>Gdy JavaScript napotyka na operator new, tworzy nowy ogólny obiekt i przekazuje go jako wartość słowa kluczowego <code>this</code> funkcji konstruktora Robotnik. Funkcja konstruktora bezpośrednio nadaje wartość własności <code>projekty</code> i bezwzględnie ustala wartość wewnętrznej własności <code>__proto__</code> jako <code>Robotnik.prototype</code> (ta nazwa własności posiada dwa znaki podkreślenia na początku i dwa na końcu). Własność <code>__proto__</code> 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.</p> +<p>Proces ten nie umieszcza wartości bezpośrednio w obiekcie <code>marek</code> (wartości + <i> + lokalne</i> + ) dla własności, które <code>marek</code> 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 <code>__proto__</code>). 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 <code>mark</code> posiada następujące własności i wartości:</p> +<pre class="eval">marek.imie = ""; +marek.dept = "ogólny"; +marek.projekty = []; +</pre> +<p>Obiekt <code>mark</code> dziedziczy wartości własności imie i dept z obiektu prototypowego w <code>mark.__proto__</code>. 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 <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Powr%c3%b3t_dziedziczenia_w%c5%82asno%c5%9bci">Powrót dziedziczenia własności</a>.</p> +<p>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 <code>marek</code> tak jak pokazano poniżej:</p> +<pre class="eval">marek.imie = "Doe, Marek"; +marek.dept = "administrator"; +marek.projekty = ["navigator"]; +</pre> +<div class="noinclude"> + <p>{{ 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") }}</p> +</div> +<p> </p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/własności_obiektu/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/własności_obiektu/index.html new file mode 100644 index 0000000000..85957fa7fc --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_przykładem/własności_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 +--- +<p> </p> +<h3 id="W.C5.82asno.C5.9Bci_obiektu" name="W.C5.82asno.C5.9Bci_obiektu">Własności obiektu</h3> +<p>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.</p> +<ul> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_przyk%c5%82adem/W%c5%82asno%c5%9bci_obiektu/Dziedziczenie_w%c5%82asno%c5%9bci">Dziedziczenie własności</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_przyk%c5%82adem/W%c5%82a%c5%9bciwo%c5%9bci_obiektu/Dodawanie_w%c5%82a%c5%9bciwo%c5%9bci">Dodawanie własności</a></li> +</ul> +<p>{{ 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") }}</p> +<div class="noinclude"> + </div> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_wyrażeniami_regularnymi/globalne_wyszukiwanie,_wielkość_znaków,_wieloliniowe_wejście/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_wyrażeniami_regularnymi/globalne_wyszukiwanie,_wielkość_znaków,_wieloliniowe_wejście/index.html new file mode 100644 index 0000000000..a566755689 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_wyrażeniami_regularnymi/globalne_wyszukiwanie,_wielkość_znaków,_wieloliniowe_wejście/index.html @@ -0,0 +1,49 @@ +--- +title: 'Globalne wyszukiwanie, wielkość znaków, wieloliniowe wejście' +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Praca_z_wyrażeniami_regularnymi/Globalne_wyszukiwanie,_wielkość_znaków,_wieloliniowe_wejście +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Regular_Expressions +--- +<p> +</p> +<h3 id="Zaawansowane_wyszukiwanie_za_pomoc.C4.85_flag" name="Zaawansowane_wyszukiwanie_za_pomoc.C4.85_flag"> Zaawansowane wyszukiwanie za pomocą flag </h3> +<p>Wyrażenia regularne posiadają cztery opcjonalne flagi, które pozwalają na globalne i niezależne od wielkości znaków wyszukiwanie. Aby wskazać wyszukiwanie globalne, użyj flagi <code>g</code>. Aby wskazać wyszukiwanie nieczułe na wielkość znaków, użyj flagi <code>i</code>. Aby wskazać wyszukiwanie wieloliniowe, użyj flagi <code>m</code>. Aby przeprowadzić "lepkie" wyszukiwanie, które pasuje do początku obecnej pozycji w łańcuchu docelowym, użyj flagi <code>y</code>. Flagi te mogą być użyte oddzielnie lub razem w dowolnej kolejności i są dołączane jako część wyrażenia regularnego. +</p><p>{{ Fx_minversion_note(3, "Obsługa flagi <code>y</code> została dodana w Firefoksie 3. Użycie flagi <code>y</code> skutkuje niepowodzeniem, jeśli wynik nie następuje po aktualnej pozycji w łańcuchu docelowym.") }} +</p><p>Aby dołączyć flagę do wyrażenia regularnego, użyj składni: +</p> +<pre>re = /pattern/flags +re = new RegExp("pattern", ["flags"]) +</pre> +<p>Zauważ że flagi są integralną częścią wyrażenia regularnego. Nie mogą być one dodane lub usunięte później. +</p><p>Na przykład, <code>re = /\w+\s/g</code> tworzy wyrażenie regularne, które szuka jednego lub więcej znaków, po których następuje spacja, szukając tej kombinacji w całym łańcuchu znaków. +</p> +<pre><script type="text/javascript"> + re = /\w+\s/g; + str = "fee fi fo fum"; + myArray = str.match(re); + document.write(myArray); +</script> +</pre> +<p>To wyświetli {{ mediawiki.external('\"fee \", \"fi \", \"fo \"') }}. W tym przykładzie możesz zamienić linię: +</p> +<pre>re = /\w+\s/g; +</pre> +<p>z: +</p> +<pre>re = new RegExp("\\w+\\s", "g"); +</pre> +<p>otrzymując ten sam rezultat. +</p><p>Flaga <code>m</code> jest używana do określenia, że wieloliniowy łańcuch wejściowy powinien być traktowany jako wiele linii. Jeśli użyta jest flaga <code>m</code>, ^ i $ odpowiadają za początek lub koniec z każdej linii w wejściowym łańcuchu znaków zamiast początku i końca całego łańcucha. +</p> +<div class="noinclude"> +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Praca z wyrażeniami regularnymi:Użycie odpowiedniego znaku", "Przewodnik po języku JavaScript 1.5:Praca z wyrażeniami regularnymi:Przykłady wyrażeń regularnych") }} +</p><p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div></div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions/Advanced_Searching_With_Flags", "es": "es/Gu\u00eda_JavaScript_1.5/Trabajar_con_expresiones_regulares/Ejecutar_una_busqueda_global,_discriminar_mayusculas_y_minusculas_y_considerar_entrada_multil\u00ednea", "fr": "fr/Guide_JavaScript_1.5/Travailler_avec_les_expressions_rationnelles/Ex\u00e9cution_de_recherches_globales,_ignorer_la_casse,_utilisation_de_cha\u00eenes_multilignes", "ja": "ja/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions/Advanced_Searching_With_Flags" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_wyrażeniami_regularnymi/przykłady_wyrażeń_regularnych/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_wyrażeniami_regularnymi/przykłady_wyrażeń_regularnych/index.html new file mode 100644 index 0000000000..f615d23035 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_wyrażeniami_regularnymi/przykłady_wyrażeń_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 +--- +<p> </p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3> +<p>Poniższe przykłady prezentują niektóre użycia wyrażeń regularnych.</p> +<h4 id="Zmiana_kolejno.C5.9Bci_w_.C5.82a.C5.84cuchu_znak.C3.B3w_wej.C5.9Bcia" name="Zmiana_kolejno.C5.9Bci_w_.C5.82a.C5.84cuchu_znak.C3.B3w_wej.C5.9Bcia">Zmiana kolejności w łańcuchu znaków wejścia</h4> +<p>Następujący przykład ilustruje tworzenie wyrażeń regularnych i użycie <code>string.split()</code> i <code>string.replace()</code>. 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ę.</p> +<pre><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> +</pre> +<h4 id="U.C5.BCywanie_specjalnych_znak.C3.B3w_do_sprawdzenia_wej.C5.9Bcia" name="U.C5.BCywanie_specjalnych_znak.C3.B3w_do_sprawdzenia_wej.C5.9Bcia">Używanie specjalnych znaków do sprawdzenia wejścia</h4> +<p>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.</p> +<p>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 (<code>-\\/\\.</code>), 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}.</p> +<p>Zdarzenie <code>Change</code> zostaje aktywowane, kiedy użytkownik naciśnie klawisz Enter ustawiając wartość <code>RegExp.input</code>.</p> +<pre><!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> +</pre> +<div class="noinclude"> + <p>{{ 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") }}</p> +</div> +<p> </p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_zamknięciami/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_zamknięciami/index.html new file mode 100644 index 0000000000..fc71b64cad --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/praca_z_zamknięciami/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 +--- +<h3 id="Praca_z_zamknięciami" name="Praca_z_zamknięciami">Praca z zamknięciami</h3> + +<p>Zamknięcia są często uważane za zaawansowaną właściwość JavaScript, ale zrozumienie ich jest niezbędne do opanowania tego języka.</p> + +<p>Rozważmy następującą funkcję:</p> + +<pre class="brush: js">function init() { + var name = "Mozilla"; + function displayName() { + alert(name); + } + displayName(); +} +</pre> + +<p>Funkcja <code>init()</code> tworzy lokalną zmienną o nazwie <code>name</code>, i następnie definiuje funkcję nazwaną <code>displayName()</code>. <code>displayName()</code> jest wewnętrzną funkcją - jest zdefiniowana wewnątrz funkcji <code>init()</code>, i jest dostępna jedynie w zasięgu ciała tej funkcji. <code>displayName()</code> nie posiada własnych lokalnych zmiennych, ale używa zmiennej <code>name</code> zadeklarowanej w funkcji zewnętrznej.</p> + +<p>Działa to całkiem nieźle - spróbujmy wykonać kod, aby zobaczyć co się stanie. To jest przykład <em>leksykalnego zasięgu</em>: 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.</p> + +<p>Teraz rozważmy następny przykład:</p> + +<pre class="brush: js">function makeFunc() { + var name = "Mozilla"; + function displayName() { + alert(name); + } + return displayName; +} + +var myFunc = makeFunc(); +myFunc(); +</pre> + +<p>Po wykonaniu kodu otrzymamy identyczny efekt jak poprzedni przykład z funkcją <code>init()</code>: łańcuch "Mozilla" zostanie wyświetlony w oknie alertowym JavaScript. Jaka jest różnica - i co ciekawsze - Czy wewnętrzna funkcja <code>displayName()</code> została zwrócona z zewnętrznej funkcji zanim została wykonana?</p> + +<p>Kod działa, lecz może się on wydawać nieintuicyjny. Normalnie, lokalne zmienne wewnątrz funkcji istnieją tylko podczas jej wykonywania. Kiedy <code>makeFunc()</code> została wykonana, spodziewamy się - i ma to sens - że zmienna <code>name</code> nie będzie więcej potrzebna. Skoro kod wykonuje oczekiwaną pracę, oczywiście nie ma mowy o przypadku.</p> + +<p>Rozwiązaniem tej zagadki jest fakt, że funkcja <code>myFunc</code> zostaje <em>zamknięciem</em>. 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, <code>myFunc</code> is a closure that incorporates both the <code>displayName</code> function and the "Mozilla" string that existed when the closure was created.</p> + +<p>Here's a slightly more interesting example - a <code>makeAdder</code> function:</p> + +<pre class="brush: js">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 +</pre> + +<p>In this example, we have defined a function <code>makeAdder(x)</code> which takes a single argument <code>x</code> and returns a new function. The function it returns takes a single argument <code>y</code>, and returns the sum of <code>x</code> and <code>y</code>.</p> + +<p>In essence, <code>makeAdder</code> 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.</p> + +<p><code>add5</code> and <code>add10</code> are both closures. They share the same function body definition, but store different environments. In <code>add5</code>'s environment, <code>x</code> is 5. As far as <code>add10</code> is concerned, <code>x</code> is 10.</p> + +<h4 id="Praktyczne_zamknięcia" name="Praktyczne_zamknięcia">Praktyczne zamknięcia</h4> + +<p>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.</p> + +<p>Consequently, you can use a closure anywhere that you might normally use an object with only a single method.</p> + +<p>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.</p> + +<p>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:</p> + +<pre class="brush: css">body { + font-family: Helvetica, Aria, sans-serif; + font-size: 12px; +} + +h1 { + font-size: 1.5em; +} +h2 { + font-size: 1.2em; +} +</pre> + +<p>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.</p> + +<p>Here's the JavaScript:</p> + +<pre class="brush: js">function makeSizer(size) { + return function() { + document.body.style.fontSize = size + 'px'; + }; +} + +var size12 = makeSizer(12); +var size14 = makeSizer(14); +var size16 = makeSizer(16); +</pre> + +<p><code>size12</code>, <code>size14</code> and <code>size16</code> 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:</p> + +<pre class="brush: js">function setupButtons() { + document.getElementById('size-12').onclick = size12; + document.getElementById('size-14').onclick = size14; + document.getElementById('size-16').onclick = size16; +}</pre> + +<pre class="brush: html"><a href="#" id="size-12">12</a> +<a href="#" id="size-14">14</a> +<a href="#" id="size-16">16</a> +</pre> + +<h4 id="Emulating_private_methods_with_closures" name="Emulating_private_methods_with_closures">Emulating private methods with closures</h4> + +<p>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.</p> + +<p>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.</p> + +<p>Here's how to define some public functions that can access private functions and variables, using closures:</p> + +<pre class="brush: js">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 */ +</pre> + +<p>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: <code>Counter.increment</code>, <code>Counter.decrement</code> and <code>Counter.value</code>.</p> + +<p>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 <code>privateCounter</code> and a function called <code>changeBy</code>. 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.</p> + +<p>Those three public functions are closures that share the same environment. Thanks to JavaScript's lexical scoping, they each have access to the <code>privateCounter</code> variable and <code>changeBy</code> function.</p> + +<p>Using closures in this way provides a number of benefits that are normally associated with object oriented programming, in particular data hiding and encapsulation.</p> + +<h4 id="Creating_closures_in_loops:_A_common_mistake" name="Creating_closures_in_loops:_A_common_mistake">Creating closures in loops: A common mistake</h4> + +<p>Prior to the introduction of the <code>let</code> keyword in JavaScript 1.7, a common problem with closures occurred when they were created inside a loop. Consider the following example:</p> + +<pre class="brush: html"><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> +</pre> + +<pre class="brush: js">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); + } + } +} +</pre> + +<p>The <code>helpText</code> 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.</p> + +<p>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.</p> + +<p>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 <code>setupHelp</code> 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 <code>helpText</code> list.</p> + +<p>One solution in this case is to use more closures: in particular, to use a function factory as described earlier on:</p> + +<pre class="brush: js">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); + } +} +</pre> + +<p>This works as expected. Rather than the callbacks all sharing a single environment, the <code>makeHelpCallback</code> function creates a new environment for each one in which <code>help</code> refers to the corresponding string from the <code>helpText</code> array.</p> + +<p>If you are using JavaScript 1.7 or higher, you can solve this problem by using the <code>let</code> keyword to create a variable that has block level scope:</p> + +<pre class="brush: js"> for (var i = 0; i < helpText.length; i++) { + let item = helpText[i]; + document.getElementById(item.id).onfocus = function() { + showHelp(item.help); + } + } +</pre> + +<p>The <code>let</code> 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.</p> + +<h4 id="Performance_considerations" name="Performance_considerations">Performance considerations</h4> + +<p>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.</p> + +<p>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).</p> + +<p>Consider the following impractical but demonstrative case:</p> + +<pre class="brush: js">function MyObject(name, message) { + this.name = String(name); + this.message = String(message); + this.getName = function() { + return this.name; + }; + + this.getMessage = function() { + return this.message; + }; +} +</pre> + +<p>The previous code does not take advantage of the benefits of closures and thus should instead be formulated:</p> + +<pre class="brush: js">function MyObject(name, message) { + this.name = String(name); + this.message = String(message); +} +MyObject.prototype = { + getName: function() { + return this.name; + }, + getMessage: function() { + return this.message; + } +}; +</pre> + +<p>Or as follows:</p> + +<pre class="brush: js">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; +}; +</pre> + +<p>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 <a href="/en/Core_JavaScript_1.5_Guide#Details_of_the_Object_Model" title="en/Core_JavaScript_1.5_Guide#Details_of_the_Object_Model">Core_JavaScript_1.5_Guide#Details_of_the_Object_Model</a> for more details.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/stałe/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/stałe/index.html new file mode 100644 index 0000000000..4fbd013295 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/stałe/index.html @@ -0,0 +1,29 @@ +--- +title: Stałe +slug: Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Stałe +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +--- +<p> </p> +<h3 id="Sta.C5.82e" name="Sta.C5.82e">Stałe</h3> +<p>Możesz utworzyć stałą (nazwaną i tylko do odczytu) za pomocą słowa kluczowego <code>const</code>. Składnia identyfikatora stałej jest taka sama, jak dla identyfikatora zmiennej: musi zaczynać się literą lub znakiem podkreślenia i obejmować znaki alfabetu lub cyfry.</p> +<pre>const prefix = '212';</pre> +<p>Stałe nie mogą podczas wykonywania skryptu zmieniać swojej wartości, ani być ponownie deklarowane.</p> +<p>Reguły zasięgu dotyczące stałych są takie same jak dla zmiennych, z wyjątkiem tego, że słowo kluczowe <code>const</code> jest wymagane zawsze, nawet dla stałych globalnych. W przypadku braku słowa kluczowego przyjmuje się, że identyfikator oznacza zmienną.</p> +<p>Nie można deklarować stałych o nazwie identycznej z nazwą zmiennej występującej w zasięgu tej samej funkcji. Na przykład:</p> +<pre>//TO SPOWODUJE BŁĄD +function f{}; +const f = 5; + +//TO RÓWNIEŻ SPOWODUJE BŁĄD +function f{ +const g=5; +var g; + +//instrukcje +}</pre> +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Zmienne", "Przewodnik po języku JavaScript 1.5:Literały") }}</p> +<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Constants", "es": "es/Gu\u00eda_JavaScript_1.5/Constantes", "fr": "fr/Guide_JavaScript_1.5/Constantes", "ja": "ja/Core_JavaScript_1.5_Guide/Constants", "ko": "ko/Core_JavaScript_1.5_Guide/Constants" } ) }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/definiowanie_metod/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/definiowanie_metod/index.html new file mode 100644 index 0000000000..64b164df13 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/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 +--- +<p> </p> +<h3 id="Definiowanie_metod" name="Definiowanie_metod">Definiowanie metod</h3> +<p>Funkcja + <i> + method</i> + 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:</p> +<pre>object.methodname = function_name +</pre> +<p>gdzie: <code>object</code> jest to istniejący obiekt, <code>methodname</code> jest nazwą przydzielonej metody i <code>function_name</code> jest nazwą funkcji.</p> +<p>Możesz nazwać metodę w kontekście obiektu jako następujące:</p> +<pre>object.methodname(params); +</pre> +<p>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 <code>car</code>, na przykład:</p> +<pre>function displayCar() { + var result = "A Beautiful " + this.year + " " + this.make + + " " + this.model; + pretty_print(result); +} +</pre> +<p>gdzie: <code>pretty_print</code> jest funkcją wyświetlającą wg poziomej reguły i łańcuch znaków. Uwaga przy użyciu <code>this</code> odnoszącego się do obiektu, do której metody należą.</p> +<p>Tworzymy funkcję metody <code>car</code>, poprzez dodanie instrukcji:</p> +<pre>this.displayCar = displayCar; +</pre> +<p>Do definicji obiektu. Więc, pełna definicja <code>car</code> będzie wyglądała jak</p> +<pre>function car(make, model, year, owner) { + this.make = make; + this.model = model; + this.year = year; + this.owner = owner; + this.displayCar = displayCar; +} +</pre> +<p>Teraz możemy nazwać metodę <code>displayCar</code> dla każdego następującego kodu:</p> +<pre>car1.displayCar() +car2.displayCar() +</pre> +<p>Efektem będzie produkcja wyjściowa następującego przykładu.</p> +<p><img alt="Grafika:Obja.gif"><br> + <small><b>Przykład: Wyświetlanie metody po jej wykonaniu</b></small></p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/definiowanie_własności_typu_obiektu/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/definiowanie_własności_typu_obiektu/index.html new file mode 100644 index 0000000000..e52ead3f93 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/definiowanie_własności_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 +--- +<p> </p> +<h3 id="Definiowanie_w.C5.82asno.C5.9Bci_typu_obiektu" name="Definiowanie_w.C5.82asno.C5.9Bci_typu_obiektu">Definiowanie własności typu obiektu</h3> +<p>Dodaj własność do poprzednio zdefiniowanego typu obiektu stosując własności <code>prototype</code>. 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 <code>color</code> do wszystkich obiektów typu <code>car</code> i potem przydziela wartość do własności <code>color</code> obiektu <code>car1</code>.</p> +<pre>Car.prototype.color=null; +car1.color="black"; +</pre> +<p>Zobacz <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function#W.C5.82asno.C5.9Bci">własności <code>prototype</code></a> z funkcji obiektu w <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5">dokumentacji języka JavaScript</a>, aby uzyskać dodatkowe informacje.</p> +<div class="noinclude"> + </div> +<p> </p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/indeksowanie_własności_obiektu/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/indeksowanie_własności_obiektu/index.html new file mode 100644 index 0000000000..c7d904e907 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/indeksowanie_własności_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 +--- +<p> </p> +<h3 id="Indeksowanie_w.C5.82asno.C5.9Bci_obiektu" name="Indeksowanie_w.C5.82asno.C5.9Bci_obiektu">Indeksowanie własności obiektu</h3> +<p>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.</p> +<p>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 <code>mojeAuto.kolor = "czerwony"</code>). Dlatego jeśli definiujesz początkowo własności obiektu z indeksem, tak jak <code>mojeAuto{{ mediawiki.external(5) }} = "25 mpg"</code>, możesz później odwołać się do własności poprzez <code>myCar{{ mediawiki.external(5) }}</code>.</p> +<p>Wyjątkiem od tej reguły są obiekty zaczerpnięte z języka HTML, jak na przykład tablica <code>forms</code>. 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 <code><FORM></code> w dokumencie posiada atrybut <code><b>NAME</b></code> o wartości "mojFormularz", możesz się odwołać do formularza przez <code>document.forms{{ mediawiki.external(1) }}</code> lub <code>document.forms{{ mediawiki.external('\"mojFormularz\"') }}</code> lub też <code>document.mojFormularz</code>. {{ 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") }}</p> +<div class="noinclude"> + </div> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/index.html new file mode 100644 index 0000000000..44ccf12523 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/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 +--- +<p> </p> +<h3 id="Tworzenie_nowych_obiekt.C3.B3w" name="Tworzenie_nowych_obiekt.C3.B3w">Tworzenie nowych obiektów</h3> +<p>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 <code>new</code>.</p> +<ul> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/U%c5%bcywanie_inicjacji_obiektu">Używanie inicjacji obiektu</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/U%c5%bcywanie_konstruktor%c3%b3w_funkcji">Używanie konstruktorów funkcji</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/Indeksowanie_w%c5%82asno%c5%9bci_obiektu">Indeksowanie własności obiektu</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/Definiowanie_w%c5%82asno%c5%9bci_typu_obiektu">Definiowanie własności typu obiektu</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/Definiowanie_metod">Definiowanie metod</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/U%c5%bcywanie_'this'_do_obiektu_referencji">Używanie <code>this</code> do obiektu referencji</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/Definiowanie_metod_pobierania_i_ustawiania">Definiowanie metod pobierania i ustawiania</a></li> + <li><a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/Usuwanie_w%c5%82asno%c5%9bci">Usuwanie własności</a></li> +</ul> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/usuwanie_własności/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/usuwanie_własności/index.html new file mode 100644 index 0000000000..ade0f3875e --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/usuwanie_własności/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 +--- +<p> </p> +<h3 id="Usuwanie_w.C5.82a.C5.9Bciwo.C5.9Bci" name="Usuwanie_w.C5.82a.C5.9Bciwo.C5.9Bci">Usuwanie właściwości</h3> +<p>Możesz usunąć właściwość używając operatora <code><b>delete</b></code> Poniższy kod pokazuje jak usunąć właściwość.</p> +<pre>//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; +</pre> +<p>Możesz także użyć <code><b>delete</b></code> do usunięcia globalnych zmiennych jeśli słowo kluczowe <code><b>var</b></code> nie było użyte do zadeklarowania zmiennej:</p> +<pre>g = 17; +delete g; +</pre> +<p>Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_specjalne#delete">delete</a> aby uzyskać więcej informacji.</p> +<div class="noinclude"> + </div> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/używanie_inicjacji_obiektu/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/używanie_inicjacji_obiektu/index.html new file mode 100644 index 0000000000..b1b38112d9 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/używanie_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 +--- +<h3 id="Zastosowanie_inicjacji_obiektu" name="Zastosowanie_inicjacji_obiektu">Zastosowanie inicjacji obiektu</h3> + +<p>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++.</p> + +<p>Składnia tworząca obiekt, używając inicjatora obiektu jest następująca:</p> + +<pre>objectName = {własność1:wartość2, własność2:wartość2,..., własnośćN:wartośćN} +</pre> + +<p>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.</p> + +<p>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.</p> + +<p>Poniższa instrukcja tworzy obiekt i przypisuje go do zmiennej x, tylko w przypadku, gdy warunek jest prawdziwy.</p> + +<pre>if (warunek) x = {a:"witaj"} +</pre> + +<p>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.</p> + +<pre>mojaHonda = {kolor:"czerwony", koła:4, silnik:{ilośćCylindrów:4, objętość:2.2}} +</pre> + +<p>Inicjatorów możesz użyć również do tworzenia tablic. Zobacz <a href="/pl/Przewodnik_po_języku_JavaScript_1.5/Literały#Litera.c5.82y_tablicy" title="pl/Przewodnik po języku JavaScript 1.5/Literały#Litera.c5.82y tablicy">literały tablic</a>.</p> + +<p>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 <a href="/pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Zastosowanie_konstruktorów_funkcji" title="pl/Przewodnik_po_języku_JavaScript_1.5/Tworzenie_nowych_obiektów/Zastosowanie_konstruktorów_funkcji">Zastosowanie konstruktorów funkcji</a>.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/zastosowanie_'this'_do_obiektu_referencji/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/zastosowanie_'this'_do_obiektu_referencji/index.html new file mode 100644 index 0000000000..2b4ad01835 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/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 +--- +<p> </p> +<h3 id="Zastosowanie_this_do_obiektu_referencji" name="Zastosowanie_this_do_obiektu_referencji">Zastosowanie <code>this</code> do obiektu referencji</h3> +<p>JavaScript posiada specjalne słowo kluczowe <code>this</code>, 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ę <code>validate</code>, która waliduje wartość własności obiektów, nadając im wartość wyższą lub niższą:</p> +<pre>function validate(obj, lowval, hival) { + if ((obj.value < lowval) || (obj.value > hival)) + alert("Invalid Value!") +} +</pre> +<p>Następnie, możesz nazwać/powiedzieć, że funkcja <code>validate</code>, w każdym elemencie formularza, <code>onChange</code> posiada uchwyt, którego używa do przejścia do określonego elementu <code>formularza</code>, jak w następującym przykładzie:</p> +<pre><INPUT TYPE="text" NAME="age" SIZE=3 + onChange="validate(this, 18, 99)"> +</pre> +<p>Generalnie, <code>this</code> jest referencją do nazwy obiektu w metodzie.</p> +<p>Kiedy połączymy właściwości <code>form</code>, <code>this</code> który potrafi się odwołać do bieżącego obiektu formularza będącego jego 'rodzicem'. W poniższym przykładzie, formularz <code>myForm</code> składa się z obiektu <code>Text</code> oraz przycisku. Kiedy użytkownik kliknie przycisk, wartość obiektu <code>Text</code> jest ustawiana do nazwy formularza. Przyciski wywołują uchwyt zdarzenia <code>onClick</code> poprzez zastosowanie <code>this.form</code> w celu wskazania formularza będącego 'rodzicem', <code>myForm</code>.</p> +<pre><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> +</pre> +<div class="noinclude"> + </div> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/zastosowanie_konstruktorów_funkcji/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/zastosowanie_konstruktorów_funkcji/index.html new file mode 100644 index 0000000000..1c5d6cdbda --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_nowych_obiektów/zastosowanie_konstruktorów_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 +--- +<p> </p> +<h3 id="Zastosowaniem_konstruktor.C3.B3w_funkcji" name="Zastosowaniem_konstruktor.C3.B3w_funkcji">Zastosowaniem konstruktorów funkcji</h3> +<p>Alternatywnie, możesz utworzyć obiekt w dwóch krokach:</p> +<ol> + <li>Zdefiniować typ obiektu poprzez napisanie konstruktora funkcji.</li> + <li>Utworzyć natychmiast nowy obiekt.</li> +</ol> +<p>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ć <code>car</code> i chcesz posiadać właściwości do zrobienia <code>make</code> , <code>model</code>, <code>year</code> i <code>color</code>. Aby to zrobić, powinieneś napisać następującą funkcje:</p> +<pre>function car(make, model, year) { + this.make = make; + this.model = model; + this.year = year; +} +</pre> +<p>Uwaga, użycie <code>this</code> pozwala wartości własności obiektów opartych na wartościach pasujących do tej funkcji.</p> +<p>Teraz możesz utworzyć obiekt nazwany <code>mycar</code> w następującym kodzie:</p> +<pre>mycar = new car("Eagle", "Talon TSi", 1993); +</pre> +<p>Instrukcja ta tworzy <code>mycar</code> i dopuszcza to do określonych wartości. Potem wartość <code>mycar.make</code> jest łańcuchem "Eagle", <code>mycar.year</code> jest liczba całkowita 1993, w ten sposób<b>(?)</b>.</p> +<p>Utwórz jakis numer obiektu <code>car</code> nazywając <code>new</code>. Na przykład,</p> +<pre>kenscar = new car("Nissan", "300ZX", 1992); +vpgscar = new car("Mazda", "Miata", 1990); +</pre> +<p>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 <code>person</code>:</p> +<pre>function person(name, age, sex) { + this.name = name + this.age = age + this.sex = sex +} +</pre> +<p>i potem przypisze nowe obiekty <b>person</b> jako następujące:</p> +<pre>rand = new person("Rand McKinnon", 33, "M"); +ken = new person("Ken Jones", 39, "M"); +</pre> +<p>Potem znów zapisz definicję <b>car</b> włączając własne właściwości, które pobierają obiekt <code><b>person</b></code>, jak następująco:</p> +<pre>function car(make, model, year, owner) { + this.make = make; + this.model = model; + this.year = year; + this.owner = owner +} +</pre> +<p>Błyskawiczne nowe obiekty, następnie użyjesz:</p> +<pre>car1 = new car("Eagle", "Talon TSi", 1993, rand); +car2 = new car("Nissan", "300ZX", 1992, ken); +</pre> +<p>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 <code>rand</code> i <code>ken</code> jako argumenty dla właściciela. Potem jeśli chcesz przekonać się do nazwy właściciela <code>car2</code> , możesz zaakceptować następujące warunki:</p> +<pre>car2.owner.name +</pre> +<p>Notuj wszystko co możesz zawsze dodać do poprzedniego zdefiniowanego obiektu. Na przykład, instrukcja</p> +<pre>car1.color = "black" +</pre> +<p>dodawaj właściwości <code>color</code> do <code>car1</code>, 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 <code>car</code>.</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_wyrażenia_regularnego/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_wyrażenia_regularnego/index.html new file mode 100644 index 0000000000..e6a76041a3 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/tworzenie_wyrażenia_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 +--- +<p> </p> +<h3 id="Tworzenie_wyra.C5.BCenia_regularnego" name="Tworzenie_wyra.C5.BCenia_regularnego">Tworzenie wyrażenia regularnego</h3> +<p>Wyrażenie regularne możemy skonstruować na jeden z dwóch sposobów:</p> +<ul> + <li>za pomocą literału wyrażenia regularnego, np.</li> +</ul> +<pre> re = /ab+c/; </pre> +<dl> + <dd> + <dl> + <dd> + Literały wyrażeń regularnych są kompilowane w czasie czytania skryptu ( + <i> + script evaluation</i> + ). Gdy wyrażenie regularne nie będzie się zmieniać, sposób ten zapewni lepszą wydajność.</dd> + </dl> + </dd> +</dl> +<ul> + <li>wywołując konstruktora obiektu <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/RegExp">RegExp</a>, np.</li> +</ul> +<pre> re = new RegExp("ab+c"); </pre> +<dl> + <dd> + <dl> + <dd> + Użycie konstruktora powoduje kompilację wyrażenia regularnego w czasie wykonywania ( + <i> + runtime</i> + ). 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.</dd> + </dl> + </dd> +</dl> +<p>{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Operatory", "Przewodnik po języku JavaScript 1.5:Zapisywanie wzorca wyrażenia regularnego") }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/unicode/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/unicode/index.html new file mode 100644 index 0000000000..38fa6c8d7f --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/unicode/index.html @@ -0,0 +1,110 @@ +--- +title: Unicode +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Unicode +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +--- +<p> +</p> +<h3 id="Unicode" name="Unicode"> Unicode </h3> +<p>Unicode jest uniwersalnym standardem kodowania znaków, dzięki któremu można wyświetlać znaki charakterystyczne dla różnych języków. Obejmuje języki Ameryki, Europy, Środkowego wschodu, Afryki, Indii, Azji i języki pacyficzne (ponadregionalne), ale również inne symbole historyczne czy techniczne. Unicode zamienia, konwertuje i wyświetla wielojęzyczne teksty, symbole techniczne i matematyczne a dzięki temu rozwiązuje wiele międzynarodowych problemów językowych w systemach obliczeniowych związanych ze standardami charakterystycznymi dla konkretnych narodów. Jednak nie wszystkie nowoczesne lub archaiczne języki są obecnie wspierane. +</p><p>Zestaw znaków Unicode może być używany praktycznie we wszystkich znanych typach kodowania. Unicode jest modelowany podobnie jak w zestawach znaków ASCII (Amerykański standardowy kod wymiany informacji). Używa opisu literowego i liczbowej wartości dla każdego kodowanego znaku. 16 bitowa wartość jest definiowana jako liczba w systemie szesnastkowym wraz z przedrostkiem <b>U</b> na przykład , <b>U+0041</b> przedstawia <b>A</b>, a unikalna nazw dla tej wartości to <b>LATIN CAPITAL LETTER A</b>. </p><p><b>Nie jest wspierany w wersjach JavaScript wcześniejszych niż 1.3.</b> </p> +<h4 id="Unicode_zgodny_z_ASCII_i_ISO" name="Unicode_zgodny_z_ASCII_i_ISO"> Unicode zgodny z ASCII i ISO </h4> +<p>Unicode jest zgodny z kodami ASCII i jest wspierany przez wiele programów. Pierwsze 128 znaków Unicode odpowiadają kodom ASCII i mają tę samą wartość bajtu. W Unicode, przykładowo, znaki <i>U+0020</i> i <i>U+007E</i> są równoważne w ASCII znakom <i>0x20</i> i <i>0x7E</i> . Nieco inaczej jest w ASCII, który wspiera łaciński alfabet i używa siedmiobitowego zestawu znaków. Unicode używa szesnastobitowych wartości dla każdego znaku i uwzględnia dziesięć tysięcy znaków. Rozszerzony mechanizm UTF 16, uwzględnia kodowanie miliona znaków więcej, przez używanie 16 bitowych par. </p><p><i>Unicode</i> jest w pełni zgodny z międzynarodowym standardowym ISO/IEC 10646 1; 1993 , który jest podzbiorem ISO 10646 i wspiera ISO Ucs 2, który używa dwu oktetów (dwóch bajtów albo 16 bitów). </p><p>JavaScript i Nawigator wspiera Unicode dzięki czemu można używać w JavaScript-ie niełacińskich, międzynarodowych i lokalnych znaków, oraz specjalistycznych symboli technicznych oraz pozwala kodować wielojęzyczny tekst. Odkąd Unicode jest zgodny z ASCII, programy mogą używać znaków ASCII. W komentarzach używać możemy znaków Unicode nie ASCII, literałów string, identyfikatorów i wcześniejszych wyrażeń, i wyrażeń regularnych JavaScript-u. +</p> +<h4 id="Sekwencje_ucieczki_do_Unicode" name="Sekwencje_ucieczki_do_Unicode"> Sekwencje ucieczki do Unicode </h4> +<p>Możesz użyć sekwencje ucieczki do Unicode w literałach łańcuchowych, wyrażeniach regularnych i identyfikatorach. Sekwencja ucieczki sześciu znaków ASCII: <b>\u</b> i czterocyfrowa liczba heksadecymalna. Na przykład, <b>\u00A9</b> reprezentuje symbol <i>copyright</i>. Każda sekwencja ucieczki Unicode w JavaScript-ie jest interpretowana jako jeden znak. +</p><p>Następujący kod zawiera symbol <i>copyright</i> i napis "<i>Netscape Communications</i>". +</p> +<pre>x="\u00A9 Netscape Communications"</pre> +<p>Następująca tabela jest listą często używanych specjalnych znaków i ich wartości Unicode. </p> +<table class="fullwidth-table"> +<tbody><tr> +<th>Kategoria</th> +<th>Wartość Unicode</th> +<th>Nazwa</th> +<th>Nazwa formatowania</th> +</tr> +<tr> +<td>Białe spacje</td> +<td><b>\u0009</b></td> +<td><b>Tab</b></td> +<td><<b>TAB></b></td> +</tr> +<tr> +<td> </td> +<td><b>\u000B</b></td> +<td><b>Pionowy tabulator</b></td> +<td><b><VT></b></td> +</tr> +<tr> +<td> </td> +<td><b>\u000C</b></td> +<td><b>Z kanału</b></td> +<td><b><FF></b></td> +</tr> +<tr> +<td> </td> +<td><b>\u0020</b></td> +<td><b>Spacja</b></td> +<td><b><SP></b></td> +</tr> +<tr> +<td>Linia kończąca wartość</td> +<td><b>\u000A</b></td> +<td><b>Line Feed</b></td> +<td><b><LF></b></td> +</tr> +<tr> +<td> </td> +<td><b>\u000D</b></td> +<td><b>Powrót karetki</b></td> +<td><b><CR></b></td> +</tr> +<tr> +<td>Dodatkowe znaki ucieczki Unicode</td> +<td><b>\u0008</b></td> +<td><b>Backspace</b></td> +<td><b><BS></b></td> +</tr> +<tr> +<td> </td> +<td><b>\u0009</b></td> +<td><b>Poziomy tabulator</b></td> +<td><b><HT></b></td> +</tr> +<tr> +<td> </td> +<td><b>\u0022</b></td> +<td><b>Podwójny cudzysłów</b></td> +<td>"</td> +</tr> +<tr> +<td> </td> +<td><b>\u0027</b></td> +<td><b>Pojedynczy cudzysłów</b></td> +<td>'</td> +</tr> +<tr> +<td> </td> +<td><b>\u005C</b></td> <td><b>Backslash</b></td> +<td><b>\</b></td> +</tr> +</tbody></table> +<p><small><b>Tabela: Wartości Unicode dla specjalnych czcionek</b></small> +</p><p>JavaScript używa sekwencje znaku ucieczki Unicode i jest ona inna niż w Javie. W JavaScript-ie, sekwencja ucieczki nigdy nie interpretuje jako pierwsza znaków specjalnych. Przykładowo, znak końca linii sekwencji ucieczki nie zakańcza ciągu zanim nie jest on zinterpretowany przez funkcje. JavaScript ignoruje każdą sekwencje ucieczki, jeśli jest ona użyta w komentarzu. W Javie, jeśli sekwencja ucieczki używana jest w pojedynczej linii komentarza interpretowana jest wtedy jako znak Unicode. W ciągu literałów kompilator Javy interpretuje wpierw sekwencje ucieczki. Przykładowo, w przypadku użycia w Javie znaku końca linii (\u000A), zakańcza on literał ciągu. W Javie doprowadza to do wystąpienia błędu, ponieważ znaki końca linii nie są dozwolone w literałach ciągów. Musisz użyć \n do zakończenia linii w literałach. W JavaScript-ie sekwencja ucieczki działa tak samo jak \n. +</p> +<div class="note">Program do konwersji długich ciągów znaków <a class="external" href="http://www.hot-tips.co.uk/useful/unicode_converter.HTML">Hot-Tips' Unicode Converter</a>, autorstwa Bob Foley.</div> +<h4 id="Wy.C5.9Bwietlanie_czcionek_z_Unicode" name="Wy.C5.9Bwietlanie_czcionek_z_Unicode"> Wyświetlanie czcionek z Unicode </h4> +<p>Można używać Unicode do wyświetlania znaków w rożnych językach lub technicznych symboli. Dla poprawnego wyświetlania klient tj. Netscape Navigator 4.x lub Netscape 6 musi wspomagać Unicode. Dodatkowo odpowiednia czcionka Unicode musi być dostępna dla klienta, jak i platforma klienta musi wspomagać Unicode. Często zdarza się, że czcionki Unicode nie wyświetlają wszystkich znaków. Niektóre platformy tj. Windows 95 posiadają tylko częściowe wsparcie Unicode. +</p><p>W celu pobrania znaku typu non-ASCII klient musi go wysłać w kodzie Unicode. Używając standardowej rozszerzonej klawiatury klient nie może łatwo wyświetlić dodatkowych znaków wspieranych przez Unicode. Czasami jedynym sposobem na wyświetlenie znaków w kodzie Unicode jest użycie sekwencji ucieczki Unicode. +</p><p>Więcej informacji o Unicode, zobacz <a class="external" href="http://www.unicode.org/">Unicode Consortium Web site</a> i The Unicode Standard, Version 2.0, wydane przez Addison-Wesley, 1996. +</p><p>{{ PreviousNext("Przewodnik_po_j%C4%99zyku_JavaScript_1.5:Litera%C5%82y#Litera.C5.82y_znakowe", "Przewodnik po języku JavaScript 1.5:Wyrażenia") }} +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Unicode", "es": "es/Gu\u00eda_JavaScript_1.5/Unicode", "fr": "fr/Guide_JavaScript_1.5/Unicode", "ja": "ja/Core_JavaScript_1.5_Guide/Unicode", "ko": "ko/Core_JavaScript_1.5_Guide/Unicode" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/wartości/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/wartości/index.html new file mode 100644 index 0000000000..fc0464bd3a --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/wartości/index.html @@ -0,0 +1,46 @@ +--- +title: Wartości +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Wartości +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +--- +<p> +</p> +<h3 id="Warto.C5.9Bci" name="Warto.C5.9Bci"> Wartości </h3> +<p>JavaScript rozróżnia następujące typy: +</p> +<ul><li> <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Number">Liczby (Number)</a>, takie jak 42 lub 3.14159 +</li><li> <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Boolean">Logiczne (Boolean)</a> wartość, <code>true</code> albo <code>false</code> +</li><li> <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String">Łańcuchy znakowe (String)</a>, takie jak "Siema!" +</li><li> <code>null</code>, specjalne słowo oznaczające wartość null (pustą); <code>null</code> jest także wartością prymitywną; ponieważ JavaScript rozróżnia małe/duże litery, null to nie to samo co Null, NULL czy jakkolwiek inaczej. </li><li> <code>undefined</code> podstawowa właściwość, której wartość jest nieokreślona; <code>undefined</code> także jest wartością prymitywną. +</li></ul> +<p>Ten względnie niewielki zestaw typów wartości - lub <i>typów danych</i> - pozwala wyposażyć Twoją aplikację w wiele użytecznych funkcji. Nie występuje wyraźna różnica pomiędzy liczbami całkowitymi a wartościami rzeczywistymi, tak jak i w JavaScript nie ma w ogóle jawnego rozróżnienia typów danych. Możesz jednak, przykładowo, użyć obiektu <code>Date</code> oraz jego metod do obsługi dat. +</p><p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Object">Obiekty</a> i <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">funkcje</a> to inne podstawowe elementy języka. Obiekty można sobie wyobrazić jako nazwane pojemniki na wartości, a funkcje jako procedury, które są wykonywane przez Twoją aplikację. +</p> +<h4 id="Konwersja_typu_danych" name="Konwersja_typu_danych"> Konwersja typu danych </h4> +<p>JavaScript jest językiem programowania o dynamicznych typach. Oznacza to, że przy deklaracji zmiennej nie musisz określać jej typu. Typy danych w razie potrzeby są automatycznie konwertowane w trakcie wykonywania skryptu. Możemy, przykładowo, zadeklarować zmienną następująco: </p> +<pre class="eval"><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/var">var</a> odpowiedz = 42 +</pre> +<p>a później przypisać tej samej zmiennej wartość tekstową, na przykład: +</p> +<pre>odpowiedz = "Dziękuję za wszystkie ryby..." +</pre> +<p>Ponieważ JavaScript posiada dynamiczne typy, przypisanie to nie powoduje komunikatu błędu. +</p><p>W wyrażeniach z operatorem <i>+</i> zawierających wartość tekstową oraz numeryczną, JavaScript konwertuje wartości numeryczne na tekst. Przyjrzyjmy się następującym instrukcjom. </p> +<pre>x = "Odpowiedzią jest " + 42 // zwraca "Odpowiedzią jest 42" +y = 42 + " jest odpowiedzią" // zwraca "42 jest odpowiedzią" +</pre> +<p>W wyrażeniach z innymi operatorami, JavaScript nie konwertuje wartości numerycznej do postaci tekstowej. Na przykład: </p> +<pre>"37" - 7 // zwraca 30 +"37" + 7 // zwraca 377 +</pre> +<p><br> +{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Przegląd JavaScriptu", "Przewodnik po języku JavaScript 1.5:Zmienne") }} +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Values", "es": "es/Gu\u00eda_JavaScript_1.5/Valores", "fr": "fr/Guide_JavaScript_1.5/Valeurs", "ja": "ja/Core_JavaScript_1.5_Guide/Values", "ko": "ko/Core_JavaScript_1.5_Guide/Values", "zh-cn": "cn/Core_JavaScript_1.5_Guide/Values" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/wyrażenia/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/wyrażenia/index.html new file mode 100644 index 0000000000..994db44f93 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/wyrażenia/index.html @@ -0,0 +1,22 @@ +--- +title: Wyrażenia +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Wyrażenia +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +--- +<p> +</p> +<h3 id="Wyra.C5.BCenia" name="Wyra.C5.BCenia"> Wyrażenia </h3> +<p>Wyrażenia (<i>expression</i>) są ważnym ustawieniem literałów, zmiennych, operatorów oraz wyrażeń które są wykonywane dla pojedynczej wartości; wartością tą może być liczba, znak, lub wartość logiczną. </p><p>Konceptualnie, są dwa typy wyrażeń: te, które próbują przypisać wartość do zmiennych, i te, które po prostu posiadają wartość. Na przykład, wyrażenie x=7 jest wyrażeniem, które przydziela 7 wartości x. Wyrażenie to samo sprawdza liczbę siedem, podobnie także zachowuje się wyrażenie użyte w "przydzielonych operatorach". Z drugiej strony, możemy powiedzieć, że wyrażenie proste 3 + 4 staje się siódemką; lecz w taki sposób nie można dokonać przydzielenia. Operatory użyte jak wyrażenia są kierowane prosto jako <i>operatory</i>. +</p><p>JavaScript posiada następujące typy wyrażeń: +</p> +<ul><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_arytmetyczne">Arytmetyczne</a>: ocenia liczby, na przykład 3.14159 +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operacje_na_%c5%82a%c5%84cuchach">Łańcuchowe</a>: ocenia łańcuch znaków, na przykład, "Fred" lub "234" +</li><li> <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_logiczne">Logiczne</a>: ocenia czy warunek jest prawdziwy czy fałszywy. </li><li> Obiektowe: ocenia obiekt (Zobacz: <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Operatory/Operatory_specjalne">Operatory specjalne</a>) +</li></ul> +<p>{{ PreviousNext("Przewodnik_po_j%C4%99zyku_JavaScript_1.5:Unicode#Wy.C5.9Bwietlanie_czcionek_z_Unicode", "Przewodnik po języku JavaScript 1.5:Operatory") }} +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Expressions", "fr": "fr/Guide_JavaScript_1.5/Expressions", "ja": "ja/Core_JavaScript_1.5_Guide/Expressions" } ) }} diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/wywołanie_funkcji/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/wywołanie_funkcji/index.html new file mode 100644 index 0000000000..330237eed8 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/wywołanie_funkcji/index.html @@ -0,0 +1,45 @@ +--- +title: Wywołanie funkcji +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Wywołanie_funkcji +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Functions +--- +<p> </p> + +<h3 id="Wywo.C5.82anie_funkcji" name="Wywo.C5.82anie_funkcji">Wywołanie funkcji</h3> + +<p>Definiowanie funkcji nie powoduje ich wykonania. Definiowanie funkcji po prostu ją wywołuje oraz określa co dana funkcja ma robić po wywołaniu. <em>Wywołanie</em> funkcji określa właściwą akcje z ustalonymi parametrami. Dla przykładu, gdy chcesz zdefiniować funkcje potęgowania należałoby wywołać ją następująco:</p> + +<pre>square(5) +</pre> + +<p>Powyższe stwierdzenie wywołuje funkcje z argumentem 5. Funkcja zostaje wykonana i zwraca wartość równą 25.</p> + +<p>Argumenty funkcji nie ograniczają się wyłącznie do łańcuchów znaków lub liczb. Można również przekazywać całe obiekty. Funkcja <code>show_props</code> (zdefiniowane w <a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Obiekty_i_w%C5%82asno%C5%9Bci" title="pl/Przewodnik_po_języku_JavaScript_1.5/Obiekty_i_własności">obiekty i własności</a>) może posłużyć za przykład funkcji, gdzie argumentem jest obiekt.</p> + +<p>Funkcja może być rekurencyjna tj. wywoływać samą siebie. Przykładem może być funkcja licząca silnię:</p> + +<pre>function silnia(n) { + if ((n == 0) || (n == 1)) + return 1 + else { + var result = (n * silnia(n-1) ); + return result + } +} +</pre> + +<p>Można policzyć silnię od 1 do 5:</p> + +<pre>a=silnia(1) // zwraca 1 +b=silnia(2) // zwraca 2 +c=silnia(3) // zwraca 6 +d=silnia(4) // zwraca 24 +e=silnia(5) // zwraca 120 +</pre> + +<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Calling_Functions", "fr": "fr/Guide_JavaScript_1.5/Appel_de_fonctions", "ja": "ja/Core_JavaScript_1.5_Guide/Calling_Functions" } ) }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/zapisywanie_wzorca_wyrażenia_regularnego/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/zapisywanie_wzorca_wyrażenia_regularnego/index.html new file mode 100644 index 0000000000..65c13b3816 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/zapisywanie_wzorca_wyrażenia_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 +--- +<h3 id="Zapisywanie_wzorca_wyra.C5.BCenia_regularnego" name="Zapisywanie_wzorca_wyra.C5.BCenia_regularnego">Zapisywanie wzorca wyrażenia regularnego</h3> + +<p>Wzorzec wyrażenia regularnego składa się ze znaków prostych takich jak <code>/abc/</code> lub kombinacji znaków prostych i specjalnych, jak np. <code>/ab*c/</code> lub <code>/Rozdział (\d+)\.\d*/</code>. 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 <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_wyra%c5%bceniami_regularnymi/U%c5%bcycie_odpowiedniego_znaku">Using Parenthesized Substring Matches</a>.</p> + +<p> </p> + +<h4 id="U.C5.BCywanie_prostych_wzorc.C3.B3w" name="U.C5.BCywanie_prostych_wzorc.C3.B3w">Używanie prostych wzorców</h4> + +<p>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'.</p> + +<h4 id="U.C5.BCywanie_znak.C3.B3w_specjalnych" name="U.C5.BCywanie_znak.C3.B3w_specjalnych">Używanie znaków specjalnych</h4> + +<p>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 <code>/ab*c/</code> 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'.</p> + +<p>Poniższa tabela zawiera kompletny wykaz znaków specjalnych wraz z opisem stosowanych w wyrażeniach regularnych.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Znak</th> + <th>Znaczenie</th> + </tr> + <tr> + <td>\</td> + <td>jedno z poniższych: + <ul> + <li>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 (<em>backslash</em> ) powoduje, że znak ten oznacza ogranicznik słowa.</li> + </ul> + + <ul> + <li>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'.</li> + </ul> + </td> + </tr> + <tr> + <td>^</td> + <td>Pasuje do początku wpisywanego tekstu. Jeśli flaga multiline (wiele linii) jest ustawiona na true, dodatkowo pasuje do każdej nowej linii. + <p>Np. <code>/^A/</code> nie da nam w efekcie 'A' w łańcuchu "an A", ale da nam 'A' w łańcuchu "An A"</p> + </td> + </tr> + <tr> + <td>$</td> + <td>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. <code>/t$/</code> zwróci 't' z "eat", ale nie z "eater"</td> + </tr> + <tr> + <td>*</td> + <td>Pasuje jeśli poprzedzający znak wystąpił 0 bądź więcej razy. + <p>Np. <code>/bo*/</code> zwróci 'boooo' z "A Ghost booooed" oraz 'b' z "A bird warbled", ale nie zwróci nic z łańcucha "A goat grunted".</p> + </td> + </tr> + <tr> + <td>+</td> + <td>Pasuje jeśli poprzedzający znak wystąpił 1 lub więcej razy. Równoważne z {1,} Np. <code>/a+/</code> dopasuje 'a' z łańcucha "candy" oraz wszystkie literki a w "caaaaaaandy".</td> + </tr> + <tr> + <td>?</td> + <td>Pasuje jeśli poprzedzający znak wystąpił raz lub nie wystąpił wcale. + <p>Np. <code>/e?le?/</code> dopasuje 'el' w łańcuchu "angel" oraz 'le' w "angle".</p> + + <p>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).</p> + + <p>Np. <code>/bo*?/</code> zwróci 'b' z "A Ghost booooed".</p> + Znak ten używamy też w<em>lookahead assertions</em> , wyjaśnione w komórkach x(?=y) i x(?!y) w tej tabeli.</td> + </tr> + <tr> + <td>.</td> + <td>(kropka) pasuje do każdego pojedynczego znaku oprócz znaku nowej linii. Np. <code>/.n/</code> z łańcucha "nay, an apple is on the tree", dopasuje 'an' i 'on', ale nie 'nay'.</td> + </tr> + <tr> + <td>(x)</td> + <td>Matches 'x' and remembers the match. These are called capturing parentheses. For example, <code>/(foo)/</code> matches and remembers 'foo' in "foo bar." The matched substring can be recalled from the resulting array's elements <code>1</code>, ..., <code>n</code>.</td> + </tr> + <tr> + <td>(?:x)</td> + <td>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 <code>1</code>, ..., <code>n</code>.</td> + </tr> + <tr> + <td>x(?=y)</td> + <td>Matches 'x' only if 'x' is followed by 'y'. For example, <code>/Jack(?=Sprat)/</code> matches 'Jack' only if it is followed by 'Sprat'. <code>/Jack(?=Sprat|Frost)/</code> matches 'Jack' only if it is followed by 'Sprat' or 'Frost'. However, neither 'Sprat' nor 'Frost' is part of the match results.</td> + </tr> + <tr> + <td>x(?!y)</td> + <td>Matches 'x' only if 'x' is not followed by 'y'. For example, <code>/\d+(?!\.)/</code> matches a number only if it is not followed by a decimal point. The regular expression <code>/\d+(?!\.)/.exec("3.141")</code> matches '141' but not '3.141'.</td> + </tr> + <tr> + <td>x|y</td> + <td>oznacza 'x' lub 'y'. Na przykład <code>/green|red/</code> pasuje do 'green' w "green apple" i do 'red' w "red apple."</td> + </tr> + <tr> + <td>{n}</td> + <td>gdzie n jest liczbą całkowitą dodatnią. Oznacza dokładnie n wystąpień znaku poprzedzającego. Na przykład <code>/a{2}/</code> 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."</td> + </tr> + <tr> + <td>{n,}</td> + <td>Where n is a positive integer. Matches at least n occurrences of the preceding character. For example, <code>/a{2,}/</code> doesn't match the 'a' in "candy", but matches all of the a's in "caandy" and in "caaaaaaandy."</td> + </tr> + <tr> + <td>{n,m}</td> + <td>Where n and m are positive integers. Matches at least n and at most m occurrences of the preceding character. For example, <code>/a{1,3}/</code> 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.</td> + </tr> + <tr> + <td><code>xyz</code></td> + <td>zestaw znaków. Pasuje do każdego znaku w nawiasie. Można określić zakres znaków za pomocą łącznika. Na przykład <code>abcd</code> oznacza to samo co <code>a-d</code>. Pasują one do 'b' w "brisket" i do 'c' w "ache".</td> + </tr> + <tr> + <td><code>^xyz</code></td> + <td>A 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, <code>^abc</code> is the same as <code>^a-c</code>. They initially match 'r' in "brisket" and 'h' in "chop."</td> + </tr> + <tr> + <td><code>\\b</code></td> + <td>Matches a backspace. (Not to be confused with \b.)</td> + </tr> + <tr> + <td>\b</td> + <td>Matches a word boundary, such as a space or a newline character. (Not to be confused with <code>\\b</code>.) For example, <code>/\bn\w/</code> matches the 'no' in "noonday";<code>/\wy\b/</code> matches the 'ly' in "possibly yesterday."</td> + </tr> + <tr> + <td>\B</td> + <td>Matches a non-word boundary. For example, <code>/\w\Bn/</code> matches 'on' in "noonday", and <code>/y\B\w/</code> matches 'ye' in "possibly yesterday."</td> + </tr> + <tr> + <td>\cX</td> + <td>Where X is a control character. Matches a control character in a string. For example, <code>/\cM/</code> matches control-M in a string.</td> + </tr> + <tr> + <td>\d</td> + <td>Matches a digit character. Equivalent to <code>0-9</code>. For example, <code>/\d/</code> or <code>/0-9/</code> matches '2' in "B2 is the suite number."</td> + </tr> + <tr> + <td>\D</td> + <td>Matches any non-digit character. Equivalent to <code>^0-9</code>. For example, <code>/\D/</code> or <code>/^0-9/</code> matches 'B' in "B2 is the suite number."</td> + </tr> + <tr> + <td>\f</td> + <td>Matches a form-feed.</td> + </tr> + <tr> + <td>\n</td> + <td>Matches a linefeed.</td> + </tr> + <tr> + <td>\r</td> + <td>Matches a carriage return.</td> + </tr> + <tr> + <td>\s</td> + <td>Matches a single white space character, including space, tab, form feed, line feed. Equivalent to + <p><code>\\f\\n\\r\\t\\v\\u00A0\\u2028\\u2029</code>.</p> + For example, <code>/\s\w*/</code> matches ' bar' in "foo bar."</td> + </tr> + <tr> + <td>\S</td> + <td>Matches a single character other than white space. Equivalent to + <p><code>^ \\f\\n\\r\\t\\v\\u00A0\\u2028\\u2029</code>.</p> + For example, <code>/\S\w*/</code> matches 'foo' in "foo bar."</td> + </tr> + <tr> + <td>\t</td> + <td>Matches a tab.</td> + </tr> + <tr> + <td>\v</td> + <td>Matches a vertical tab.</td> + </tr> + <tr> + <td>\w</td> + <td>Matches any alphanumeric character including the underscore. Equivalent to <code>A-Za-z0-9_</code>. For example, <code>/\w/</code> matches 'a' in "apple," '5' in "$5.28," and '3' in "3D."</td> + </tr> + <tr> + <td>\W</td> + <td>Matches any non-word character. Equivalent to <code>^A-Za-z0-9_</code>. For example, <code>/\W/</code> or <code>/^A-Za-z0-9_/</code> matches '%' in "50%."</td> + </tr> + <tr> + <td>\n</td> + <td>Where 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, <code>/apple(,)\sorange\1/</code> matches 'apple, orange,' in "apple, orange, cherry, peach."</td> + </tr> + <tr> + <td>\0</td> + <td>Matches a NUL character. Do not follow this with another digit.</td> + </tr> + <tr> + <td>\xhh</td> + <td>Matches the character with the code hh (two hexadecimal digits)</td> + </tr> + <tr> + <td>\uhhhh</td> + <td>Matches the character with the code hhhh (four hexadecimal digits).</td> + </tr> + </tbody> +</table> + +<p><small><strong>Tabela 4.1: Znaki specjalne w wyrażeniach regularnych.</strong></small></p> + +<h4 id="U.C5.BCywanie_nawias.C3.B3w" name="U.C5.BCywanie_nawias.C3.B3w">Używanie nawiasów</h4> + +<p>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 <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_wyra%c5%bceniami_regularnymi/U%c5%bcycie_odpowiedniego_znaku">Using Parenthesized Substring Matches</a>.</p> + +<p>For example, the pattern <code>/Chapter (\d+)\.\d*/</code> 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.</p> + +<p>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'.</p> + +<p>To match a substring without causing the matched part to be remembered, within the parentheses preface the pattern with <code>?:</code>. For example, <code>(?:\d+)</code> matches one or more numeric characters but does not remember the matched characters.</p> + +<p><br> + {{ PreviousNext("Przewodnik_po_języku_JavaScript_1.5:Tworzenie_wyrażenia_regularnego", "Przewodnik_po_języku_JavaScript_1.5:Praca_z_wyrażeniami_regularnymi") }}</p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/zastosowanie_obiektu_arguments/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/zastosowanie_obiektu_arguments/index.html new file mode 100644 index 0000000000..8422fdf2c0 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_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 +--- +<p> </p> +<h3 id="Zastosowanie_obiektu_arguments" name="Zastosowanie_obiektu_arguments">Zastosowanie obiektu <code>arguments</code></h3> +<p>Argumenty funkcji będą je utrzymywać je w tablicy. Wewnątrz funkcji, możemy zaadresować lub przydzielić argumenty w następujący sposób:</p> +<pre>arguments[i] +</pre> +<p>gdzie: <code>i</code> jest kolejną liczbą porządkową znajdującą się wewnątrz funkcji, pierwszym argumentem zawsze jest 0 (zero). Więc, pierwszy argument funkcji to <code>arguments{{ mediawiki.external(0) }}</code>. Łączna liczba argumentów jest podana w <code>arguments.length</code>.</p> +<p>Używając argumentów tablicy (<code>arguments</code>) 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 <code>arguments</code>.length do określenie aktualnie argumentów do funkcji, potrzebnych do opisania każdego argumentu w tablicy <code>arguments</code>.</p> +<p>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:</p> +<pre>function myConcat(separator) { + var result="" // initialize list + // iterate through arguments + for (var i=1; i<arguments.length; i++) { + result += arguments[i] + separator + } + return result +} +</pre> +<p>Możemy podawać jakiekolwiek liczby argumentów funkcji, i to zostanie utworzona lista używająca każdej pozycji zawartej na liście.</p> +<pre>// 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") +</pre> +<p>Zobacz: <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Funkcja obiektu</a> w dokumentacji języka JavaScript, aby uzyskać więcej informacji.</p> +<p><b>JavaScript 1.3 i wersje wcześniejsze</b><br> + Argument tablicy jest właściwością obiektu <code>Function</code> i może on być umieszczony przed nazwą funkcji, tak jak poniżej:</p> +<p><code>functionName.arguments(i)</code></p> +<p> </p> diff --git a/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/zmienne/index.html b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/zmienne/index.html new file mode 100644 index 0000000000..af6e304537 --- /dev/null +++ b/files/pl/web/javascript/guide/obsolete_pages/przewodnik_po_języku_javascript_1.5/zmienne/index.html @@ -0,0 +1,63 @@ +--- +title: Zmienne +slug: >- + Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_języku_JavaScript_1.5/Zmienne +tags: + - JavaScript + - Przewodnik_JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Guide/Grammar_and_types +--- +<p> </p> +<p><span class="comment">Trzeba całość wyczyścić i uzgodnić z wersją EN: zmiany 06-2006</span></p> +<h3 id="Zmienne" name="Zmienne">Zmienne</h3> +<p>Zmiennych używa się jako symbolicznych nazw dla wartości w Twojej aplikacji. Nazwy zmiennych, nazywane <em>identyfikatorami</em>, podporządkowane są pewnym regułom.</p> +<p><em>Identyfikator</em> JavaScript musi zaczynać się literą, podkreśleniem (_) lub znakiem dolara ($); kolejne znaki mogą być cyframi (0-9). Ponieważ JavaScript rozróżnia duże/małe litery, litery oznaczają znaki od "A"do "Z" (duże litery) oraz znaki od "a" do "z" (małe litery).</p> +<p>Poczynając od JavaScript 1.5, w identyfikatorze możesz używać znaków ISO 8859-1 lub Unicode takich jak å czy ą. Jako znaków w identyfikatorze możesz także używać \uXXXX - sekwencji ucieczki Unicode wypisanych na stronie <a href="/pl/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/Unicode#Sekwencje_ucieczki_do_Unicode" title="pl/Przewodnik_po_języku_JavaScript_1.5/Unicode#Sekwencje_ucieczki_do_Unicode">Sekwencje ucieczki do Unicode</a>.</p> +<p>Niektóre przykłady prawidłowych nazw to <code>Number_hits</code>, <code>temp99</code> i <code>_name</code>.</p> +<h4 id="Deklaracja_zmiennych" name="Deklaracja_zmiennych">Deklaracja zmiennych</h4> +<p>Możesz zadeklarować zmienne na dwa sposoby:</p> +<ul> <li>Za pomocą słowa kluczowego <code>var</code>. Na przykład, <code>var x = 42</code></li> <li>Poprzez proste przypisanie wartości. Na przykład, <code>x = 42</code></li> +</ul> +<h4 id="Ocena_zmiennych" name="Ocena_zmiennych">Ocena zmiennych</h4> +<p>Zmienna lub element tablicy, którym nie przypisano wartości, mają wartość <em>undefined</em>. Rezultat oceny nieprzydzielonej zmiennej zależny jest od sposobu jej deklaracji:</p> +<ul> <li>Jeśli nieprzydzielona zmienna została zadeklarowana bez <code>var</code>, wynikiem oceny będzie <em>runtime error</em>.</li> <li>Jeśli nieprzydzielona zmienna została zadeklarowana z <code>var</code>, wynikiem oceny będzie wartość niezdefiniowana lub NaN w kontekstach numerycznych.</li> +</ul> +<p>Poniższy kod demonstruje ocenę nieprzydzielonych zmiennych.</p> +<pre>function f1() { + return y - 2; +} +f1() //Powoduje runtime error + +function f2() { + return var y - 2; +} +f2() //zwraca NaN +</pre> +<p>Aby określić, czy zmienna posiada wartość, możesz użyć <code>undefined</code>. W poniższym kodzie zmienna <code>input</code> nie posiada przypisanej wartości, więc instrukcja <code>if</code> przyjmuje wartość <code>true</code>.</p> +<pre>var input; +if(input === undefined){ + doThis(); +} else { + doThat(); +}</pre> +<p>Wartość <code>undefined</code> zachowuje sie jak logiczne <em>false</em> w odpowiednim kontekście (boolean). Poniższy kod wykonuje funkcję <code>myFunction</code>, ponieważ element <code>array</code> nie został zdefiniowany:</p> +<pre>myArray=new Array() +if (!myArray[0]) + myFunction()</pre> +<p>Podczas oceny wartości zmiennej <em>null</em>, wartość <em>null</em> zachowuje się jak <em>0</em> w kontekście numerycznym oraz jako false w kontekście logicznym (boolean). Na przykład:</p> +<pre>var n = null +n * 32 //zwraca 0</pre> +<h4 id="Zakres_zmiennych" name="Zakres_zmiennych">Zakres zmiennych</h4> +<p>Zmienna zadeklarowana poza jakąkolwiek funkcją nazywana jest zmienną <em>globalną</em> (<em>global</em>); staje się ona dostępna dla dowolnego kodu w bieżącym dokumencie. Zmienna zadeklarowana wewnątrz funkcji staje się zmienną <em>lokalną</em> (<em>local</em>) i dostępna będzie jedynie wewnątrz tej funkcji.</p> +<p>Użycie <code>var</code> do zadeklarowania zmiennej <em>global</em> jest opcjonalne. Jednakże, musisz użyć <code>var</code> do zadeklarowania zmiennej wewnątrz funkcji.</p> +<p>Masz dostęp do zmiennych globalnych zadeklarowanych w jednym oknie lub ramce z innego okna/ramki poprzez podanie nazwy okna/ramki. Na przykład, jeśli zmienna <code>phoneNumber</code> jest zadeklarowana w dokumencie <code>FRAMESET</code>, to można się do niej odwołać z dokumentu potomnego poprzez <code>parent.phoneNumber</code>.</p> +<h4 id="Zmienne_globalne" name="Zmienne_globalne">Zmienne globalne</h4> +<p>Zmienne globalne są w istocie własnościami <em>obiektu globalnego</em>. W stronach internetowych obiektem globalnym jest <a href="/pl/DOM/window" title="pl/DOM/window">window</a>. +<span class="comment">dodać link wewnętrzny</span> Możesz wiec ustawiać i odczytywać zmienne globalne przy użyciu składni <code>window.<em>zmienna</em></code>. Analogicznie, podając nazwę ramki lub okna, możesz uzyskać dostęp do zmiennych zadeklarowanych w tym oknie lub ramce z innego okna lub ramki. Przykładowo: jeśli zmienna nazwana <code>numerTelefonu</code> została zadeklarowana w dokumencie <code>FRAMESET</code>, możesz odwołać się do tej zmiennej z ramki podrzędnej poprzez <code>parent.numerTelefonu</code>.</p> +<p><br> +{{ PreviousNext("Przewodnik po języku JavaScript 1.5:Wartości", "Przewodnik po języku JavaScript 1.5:Stałe") }}</p> +<p><br> +</p> + +<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Variables", "es": "es/Gu\u00eda_JavaScript_1.5/Variables", "fr": "fr/Guide_JavaScript_1.5/Variables", "ja": "ja/Core_JavaScript_1.5_Guide/Variables", "ko": "ko/Core_JavaScript_1.5_Guide/Variables", "zh-cn": "cn/Core_JavaScript_1.5_Guide/\u53d8\u91cf" } ) }}</p> diff --git a/files/pl/web/javascript/guide/składnia_i_typy/index.html b/files/pl/web/javascript/guide/składnia_i_typy/index.html new file mode 100644 index 0000000000..98e66063d0 --- /dev/null +++ b/files/pl/web/javascript/guide/składnia_i_typy/index.html @@ -0,0 +1,595 @@ +--- +title: Składnia i typy +slug: Web/JavaScript/Guide/Składnia_i_typy +tags: + - JavaScript + - Poradnik +translation_of: Web/JavaScript/Guide/Grammar_and_types +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}</div> + +<p class="summary">Ten rozdział porusza temat podstawowych elementów języka, takich jak składnia, deklaracje zmiennych, typy danych oraz literały. </p> + +<h2 id="Podstawy">Podstawy</h2> + +<p>Składnia JavaScripta zapożycza wiele rozwiązań użytych w Javie, jednak w jej konstrukcji można zauważyć również wpływy języków takich jak Awk, Perl i Python</p> + +<p>JavaScript jest językiem, w którym <strong>rozróżnialna jest wielkość liter,</strong> oraz wspierany jest standard znaków <strong>Unicode.</strong></p> + +<p>W JavaScripcie instrukcje nazywane są {{Glossary("Wyrażenie", "wyrażeniami")}} i rozdzielane średnikiem (;). Spacje, tabulatury i znaki nowej linii zaliczają się do grupy tak zwanych znaków białych. Kod źródłowy skryptów napisanych w JavaScripcie skanowany jest przez interpreter od lewej do prawej i konwertowany w sekwencje elementów wejścia, które reprezentowane są przez tokeny, znaki kontrolne, znaki przerwania linii, komentarze i białe znaki. ECMAScript definiuje również zestaw słów kluczowych i literałów oraz zasady automatycznego umieszczania średników (<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">ASI</a>), tak by zakończyć dane wyrażenie, jednakże wykorzystywanie tej zasady wiąże się z efektami ubocznymi, dlatego zaleca się samodzielne umieszczanie średników. Więcej informacji na ten temat znajdziesz w szczegółowym opisie <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">gramatyki języka.</a> </p> + +<h2 id="Komentarze">Komentarze</h2> + +<p>Składnia komentarzy jest identyczna jak ta używana w języku C++ oraz w wielu innych.</p> + +<pre class="brush: js">// Komentarz w jednej linii + +/* to jest dłuższy, + wieloliniowy komentarz + */ + +/* Nie możesz jednak /* zagnieżdzać komentarzy */ SyntaxError */</pre> + +<h2 id="Deklaracje">Deklaracje </h2> + +<p>W języku JavaScript występują trzy typy deklaracji.</p> + +<dl> + <dt>{{jsxref("Statements/var", "var")}}</dt> + <dd>Deklaruje zmienną, opcjonalnie inicjalizując ją podaną wartością.</dd> + <dt>{{experimental_inline}} {{jsxref("Statements/let", "let")}}</dt> + <dd>Deklaruje zmienną lokalną, ograniczoną do bloku w którym jest zawarta, opcjonalnie inicjalizując ją podaną wartością. </dd> + <dt>{{experimental_inline}} {{jsxref("Statements/const", "const")}}</dt> + <dd>Deklaruje zmienną stałą tylko do odczytu. </dd> +</dl> + +<h3 id="Zmienne">Zmienne</h3> + +<p>Możesz używać zmiennych jako symbolicznych nazw oraz wartości w swojej aplikacji. Nazwy zmiennych są wtedy nazywane {{Glossary("Identyfikator", "identyfikatorami")}} i podlegają pewnym regułom. </p> + +<p>W języku JavaScript indentyfikator musi rozpoczynać się od litery, podkreślnika(_) lub symbolu dolara ($). Pozostałe znaki w indetyfikatorze mogą być także cyframi(0-9). Ponieważ JavaScript rozróżnia wielkość liter, znaki jakich możemy użyć jako nazw identyfikatora mogą być zarówno wielkimi (A-Z; uppercase) jak i małymi (a-z; lowercase) literami alfabetu. </p> + +<p>Możesz również użyć ISO 8859-1 lub znaków Unicodu dla liter takich jak å i ü. Możesz także użyć <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals">symboli graficzne definiowanych przez Unicode</a> jako znaków identyfikatora.</p> + +<p>Przykładowymi nazwami zmiennych, z których możemy bezpiecznie korzystać są <code>Number_hits</code>, <code>temp99</code>, oraz <code>_name</code>.</p> + +<h3 id="Deklarowanie_zmiennych">Deklarowanie zmiennych</h3> + +<p>Zmienną możemy deklarować na trzy sposoby:</p> + +<ul> + <li>Wykorzystując słowo kluczowe {{jsxref("Statements/var", "var")}}. Na przykład, var x = 42. Wykorzystując tą opcje możemy deklarować zarówno zmienne lokalne jak i globalne.</li> + <li>Przez podstawienie wartości do zmiennej. Na przykład x = 42. Jednakże w ten sposób zadeklarować możemy jedynie zmienne globalne, które nie mogą być zmieniane z poziomu lokalnego. W trybie ścisłym wygeneruje nam to ostrzeżenie, stąd też nie jest to preferowana metoda. </li> + <li>Za pomocą słowa kluczowego {{jsxref("Statements/let", "let")}}. Na przykład let y = 13. W tym przypadku deklarujemy zmienną ograniczoną do lokalnej <a href="#Variable_scope">przestrzeni nazw</a>, o której więcej informacji znajdziesz poniżej. </li> +</ul> + +<h3 id="Ewaluacja_zmiennych">Ewaluacja zmiennych</h3> + +<p>Zmienna deklarowana przy użyciu <code>var</code> lub <code>let</code>, której nie przypiszemy początkowej wartości przyjmie automatycznie wartość {{jsxref("undefined")}}.</p> + +<p>W poniższym przykładzie chcemy uzyskać dostęp do niezadeklarowanej zmiennej, co skutkować będzie błędem {{jsxref("ReferenceError")}}:</p> + +<pre class="brush: js">var a; +console.log("The value of a is " + a); // W konsoli pojawi się komunikat "The value of a is undefined" +console.log("The value of b is " + b); // wyrzuci wyjątek ReferenceError +</pre> + +<p>Możesz użyć wartości <code>undefined</code> do sprawdzenia czy dana zmienna posiada jakąś wartość. W poniższym kodzie zmienna <code>input</code> nie posiada przypisanej wartości, dlatego instrukcja <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else" title="en-US/docs/JavaScript/Reference/Statements/if...else">if</a></code> zwróci nam wartość <code>true</code>.</p> + +<pre class="brush: js">var input; +if(input === undefined){ + doThis(); +} else { + doThat(); +} +</pre> + +<p>Wartość <code>undefined</code> zachowuje się jak <code>false</code>, kiedy używana jest w kontekście funkcji boolowskich. W poniższym przykładzie kod zawarty w instrukcji if zostanie uruchomiony, ponieważ żądany element nie istnieje w tej tablicy.</p> + +<pre class="brush: js">var myArray = []; +if (!myArray[0]) myFunction(); +</pre> + +<p>Wartość <code>undefined</code> konwertowana jest do wartości <code>NaN</code> kiedy używana jest w kontekście numerycznym. </p> + +<pre class="brush: js">var a; +a + 2; // ewaluacja do NaN</pre> + +<p>Kiedy ewaluowana jest zmienna typu {{jsxref("null")}}, zachowuje się ona jak 0 w kontekście numerycznym i jako false w kontekście funkcji boolowskich. Ilustruje to poniższy przykład. </p> + +<pre class="brush: js">var n = null; +console.log(n * 32); // zaloguje 0 w konsoli +</pre> + +<h3 id="Zasięg_zmiennej">Zasięg zmiennej</h3> + +<p>Zmienna, którą zadeklarujemy poza funkcją nazywana jest zmienną <em>globalną</em>, ponieważ jest ona dostępna z każdego miejsca w naszym kodzie. Jeżeli zmienna deklarowana jest wewnątrz funkcji, nazwana jest wtedy <em>lokalną</em>, ponieważ używać jej możemy tylko i wyłączenie w ciele tej funkcji. </p> + +<p>JavaScript przed wersją ECMAScript 6 nie posiadał zasięgu blokowego, zamiast tego zmienna zadeklarowana w danym bloku była funkcją lokalną dla tej <em>funkcji (lub zasięgu globalnego)</em>. Dla przykladu poniższy kod pokaże nam wartość 5, ponieważ zasięgiem zmiennej x jest funkcja, w której została ona zdefiniowana, a nie blok, którym w tym przypadku jest funkcja <code>if</code>. </p> + +<pre class="brush: js">if (true) { + var x = 5; +} +console.log(x); // 5 +</pre> + +<p>Zachowanie zmieni się, kiedy użyjemy deklaracji <code>let</code> wprowadzonej w standardzie ECMAScript 6.</p> + +<pre class="brush: js">if (true) { + let y = 5; +} +console.log(y); // ReferenceError: y is not defined +</pre> + +<h3 id="Podnoszenie_zmiennych">Podnoszenie zmiennych</h3> + +<p>Kolejną niecodzienną rzeczą, na którą natkniemy się pracując z JavaScript'em jest fakt, że bez żadnego błędu możemy uzyskać dostęp do zmiennych, które zadeklarowane są dalej w naszym skrypcie. Ta koncepcja zwana jest <strong>podnoszeniem lub windowaniem (ang. </strong><strong><em>hoisting</em>)</strong>, ponieważ zmienne są niejako wyciągane do góry wyrażenia. Nie możemy jednak używać w ten sposób zmiennych, które nie zostały zinicjalizowane, ponieważ zwrócą one wartość <code>undefined</code>. </p> + +<pre class="brush: js">/** + * Przykład 1 + */ +console.log(x === undefined); // Zwróci nam wartość "true" +var x = 3; + +/** + * Przykład 2 + */ +// zwróci wartość undefined +var myvar = "my value"; + +(function() { + console.log(myvar); // undefined + var myvar = "local value"; +})(); +</pre> + +<p>Powyższe przykłady intepretowane będą tak samo jak:</p> + +<pre class="brush: js">/** + * Przykład 1 + */ +var x; +console.log(x === undefined); // Zwaraca wartość "true" +x = 3; + +/** + * Przykład 2 + */ +var myvar = "my value"; + +(function() { + var myvar; + console.log(myvar); // undefined + myvar = "local value"; +})(); +</pre> + +<p>Przez podnoszenie wszystkie zmienne deklarowane poprzez użycie <code>var</code>, w miarę możliwości powinny być umieszczane na górze funkcji. Zwiększa to czytelność kodu i traktowane jest jako dobra praktyka. </p> + +<p>W ECMAScript 2015 <code>let (const)</code><strong> nie zostaną podniesione</strong> na górę bloku kodu. Jednak odwołanie do zmiennej, w bloku przed zadeklarowanymi, da w rezultacie <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError">ReferenceError</a>. Zmienne będą w tzw. "tymczasowej martwej strefie" od początku bloku aż do stwierdzenia są przetwarzane.</p> + +<pre>function do_something() { console.log(foo); // ReferenceError let foo = 2; }</pre> + +<h3 id="Zmienne_globalne">Zmienne globalne</h3> + +<p>Zmienne globalne są w istocie właściwością <em>obiektu globalnego</em>. W przypadku stron internetowych obiektem tym jest {{domxref("window")}}, co pozwala na wykorzystywanie i manipulowanie zmiennymi globalnymi za pomocą składni <code>window.<em>variable</em></code>.</p> + +<p>Pozwala to także na wykorzystywanie zmiennych globalnych zadeklarowanych w jednym oknie przez inne okno, poprzez jego nazwę. Na przykład zmienną <code>phoneNumber</code> zadeklarowaną w jednym dokumencie, możemy uzyskać poprzez wykorzystanie <code>parent.phoneNumber.</code></p> + +<h3 id="Stałe">Stałe</h3> + +<p>Możesz także tworzyć zmienne tylko do odczytu, zwane zmiennymi stałymi poprzez wykorzystywanie slowa kluczowego {{jsxref("Statements/const", "const")}}. Składnia identyfikatora stałego jest taka sama jak identyfikatora zmiennej. Musi zaczynać się od litery, podkreślnika lub symbolu dolara i może zawierać cyfry i znaki alfabetu. </p> + +<pre class="brush: js">const prefix = '212'; +</pre> + +<p>Zmienna nie może zostać ponownie zadeklarowana lub przyjąć nowej wartości kiedy działa nasz skrypt. Możemy to zrobić jedynie przy jej inicjalizacji.</p> + +<p>Zasady zasięgu są dla niej takie same jak dla zmiennych tworzonych z użyciem <code>let</code>. Jeżeli pominiemy słowo kluczowe <code>const</code> identyfikator będzie intepretowany jako reprezentacja zmiennej.</p> + +<p>Limitacją dla stałych jest fakt, że nie możemy zadeklarować takiej, która wykorzystuje nazwę występującą już jako identyfikator zmiennej lub funkcji w tym samym bloku. Zachowanie to ilustruje poniższy przykład.</p> + +<pre class="example-bad brush: js">// SPOWODUJE TO WYRZUCENIE BŁĘDU +function f() {}; +const f = 5; + +// TO RÓWNIEŻ SPOWODUJE BŁĄD +function f() { + const g = 5; + var g; + + //instrukcje +} +</pre> + +<p>Jednak atrybuty obiektu nie są chronione, , object attributes are not protected, więc następujące wyrażenie zostanie wykonywane bez problemów.</p> + +<pre><code>const MY_OBJECT = {"key": "value"}; +MY_OBJECT.key = "otherValue";</code> +</pre> + +<h2 id="Struktury_i_typy_danych">Struktury i typy danych</h2> + +<h3 id="Typy_danych">Typy danych</h3> + +<p>Najnowszy standard ECMAScript definiuje siedem typów danych:</p> + +<ul> + <li>Sześć typów danych rodzaju {{Glossary("Primitive", "primitives")}}: + <ul> + <li>{{Glossary("Boolean")}}. <font face="Consolas, Liberation Mono, Courier, monospace">true</font> oraz <code>false</code>.</li> + <li>{{Glossary("null")}}. Specjalne słowo kluczowe oznaczające wartość zerową. Ponieważ w języku JavaScript rozróżniana jest wielkość liter, <code>null</code> nie jest tym samym co <code>Null</code>, <code>NULL</code> lub jakikolwiek inny wariant.</li> + <li>{{Glossary("undefined")}}. Najwyższa właściwość, której wartość jest nieokreślona.</li> + <li>{{Glossary("Number")}}. <code>42</code> lub <code>3.14159</code>.</li> + <li>{{Glossary("String")}}. "Uszanowanko"</li> + <li>{{Glossary("Symbol")}} (nowość w ECMAScript 6). Typ danych, gdzie przykłady są niepowtarzalne i niezmienne.</li> + </ul> + </li> + <li>oraz typ złożony + <ul> + <li>{{Glossary("Object")}} (do którego można również zaliczyć podtypy functions i array)</li> + </ul> + </li> +</ul> + +<p>Mimo, że typów danych w javascript jest stosunkowo niewiele, pozwalają one na tworzenie użytecznych funkcji.</p> + +<h3 id="Konwersja_typów_danych">Konwersja typów danych</h3> + +<p>JavaScript jest językiem dynamicznie typowanym. Oznacza to, że nie musimy deklarować typu zmiennej, ponieważ jest on automatycznie konwertowany do porządanych wartości w czasie wykonywania się skryptu. Przykładowo możemy zdefniniować zmienną w podany sposób:</p> + +<pre class="brush: js">var answer = 42; +</pre> + +<p>A później przypisać do tej samej zmiennej kawałek typu string: </p> + +<pre class="brush: js">answer = "Dzięki za wszystko..."; +</pre> + +<p>To przypisanie nie wywołuje błędu, gdyż typ danych został ustalony dynamicznie. </p> + +<p>W wyrażeniach, w których tekst mieszany jest z liczbami za pomocą operatora "+" JavaScript konwertuje wartości liczbowe do ciągu znaków. Ilustruje to poniższy przykład:</p> + +<pre class="brush: js">x = "Odpowiedź to " + 42 // "Odpowiedź to 42" +y = 42 + " jest odpowiedzią" // "42 jest odpowiedzią" +</pre> + +<p>W przypadku użycia innych operatorów JavaScript nie używa powyższej metody, ale konwertuje je automatycznie próbując sparować dwie zmienne. </p> + +<pre class="brush: js">"37" - 7 // 30 +"37" + 7 // "377" +</pre> + +<h3 id="Konwersja_do_typu_number">Konwersja do typu number</h3> + +<p>W przypadku kiedy w pamięci programu przechowujemy liczbę pod postacią łancucha znaków możemy posłużyć się poniższymi metodami konwersji:</p> + +<ul> + <li id="parseInt()_and_parseFloat()">{{jsxref("parseInt", "parseInt()")}}</li> + <li>{{jsxref("parseFloat", "parseFloat()")}}</li> +</ul> + +<p><code>parseInt</code> zwróci nam liczbę całkowitą, dobrą praktyką w przypadku zamiany z użyciem tej funkcji jest specyzowanie podstawy, która informuje o tym jaki system liczbowy został przez nas przyjęty.</p> + +<p>Alternatywną metodą konwersji jest użycie operatora "+", który działa zarówno z typem string jak i boolean.</p> + +<pre class="brush: js">"1.1" + "1.1" = "1.11.1" +(+"1.1") + (+"1.1") = 2.2 +// Notka: Cudzyslowy uzyte sa dla zwiekszenia czytelnosci, nie sa one wymagane +</pre> + +<h3 id="Literały">Literały</h3> + +<p>Literałów używa się w celu przedstawiania wartości w języku JavaScript. Są one ustalonymi wartościami (a nie zmiennymi), które <em>dosłownie</em> podajesz w swoim skrypcie. Ten fragment opisuje następujące typy literałów:</p> + +<ul> + <li>{{anch("Literały tablicowe")}}</li> + <li>{{anch("Literały boolowskie")}}</li> + <li>{{anch("Literały zmiennoprzecinkowe")}}</li> + <li>{{anch("Literały całkowite")}}</li> + <li>{{anch("Literały obiektowe")}}</li> + <li>{{anch("Literały znakowe")}}</li> +</ul> + +<h3 id="Literały_tablicowe">Literały tablicowe</h3> + +<p>Literał tablicowy jest listą składającą się z zera lub większej liczby wyrażeń, gdzie każde z nich reprezentuje element tablicy i zamknięty jest w nawiasach kwadratowych. Tablica tworzona za pomocą literału tablicowego zostaje zainicjalizowana podanymi wartościami, które stają się jej elementami, a długość tablicy ustalona zostaje według liczby podanych argumentów.</p> + +<p>Poniższy przykład tworzy tablicę długości trzy, o nazwie <code>kawy</code>, w której umieszczone zostają trzy elementy:</p> + +<pre><code>kawy = ["Arabica", "Columbiana", "Zbożowa"]</code> +</pre> + +<p><strong>Uwaga</strong> Literał tablicowy jest typem inicjalizatora obiektu. Zobacz <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide/Obsolete_Pages/Przewodnik_po_j%C4%99zyku_JavaScript_1.5/pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Tworzenie_nowych_obiekt%c3%b3w/U%c5%bcywanie_inicjacji_obiektu">Używanie inicjalizatorów obiektu</a>.</p> + +<p>Jeśli tablica została utworzona przy pomocy literału w skrypcie najwyższego poziomu, JavaScript interpretuje tablicę za każdym razem, gdy przelicza wyrażenie zawierające literał tablicowy. Dodatkowo taki literał, kiedy zostaje użyty w funkcji tworzony jest przy każdym jej wywołaniu.</p> + +<p>Literały tablicowe są także obiektami typu <code>Array</code>. Zobacz <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Array">obiekt <code>Array</code></a>, aby uzyskać więcej informacji o obiektach <code>Array</code>.</p> + +<h4 id="Dodatkowe_przecinki_w_literalach_tablicowych">Dodatkowe przecinki w literalach tablicowych</h4> + +<p>W chwili inicjalizacji nie musisz deklarować wszystkich elementów tablicy. Jeżeli umieścisz następujące po sobie dwa przecinki, w miejscu pustego miejsca wstawiona będzie wartość <code>undefined</code>. W poniższym przykładzie tworzymy tablice o nazwie <code>ryby</code>:</p> + +<pre><code>ryby = ["Piła", , "Młot"]</code> +</pre> + +<p>Tablica ta posiada dwa elementy z wartościami i jeden pusty (wywołanie <code>ryby[0]</code> zwróci nam "Piła", wartość <code>ryby[1]</code> jest niezdefiniowana, a <code>ryby[2]</code> zwróći "Młot"):</p> + +<p>W przypadku kiedy pozostawiamy przecinek na końcu listy, jest on ignorowany. (<strong>Uwaga: </strong>przecinki pozostawione na końcu listy mogą powodować błędy w starszych przeglądarkach i zalecane jest ich usuwanie). W poniższym przypadku długośc tablicy to trzy ponieważ nie istnieje element <code>mojaLista[3]</code>. Wszystkie inne przecinki w liście wskazują nowy element.</p> + +<pre class="brush: js">var mojaLista = ['dom', , 'szkola', ]; +</pre> + +<p>W poniższym przykładzie długość tablicy wynosi cztery, a elementy niezefiniowane występują pod indeksami 0 i 2.</p> + +<pre class="brush: js">var mojaLista = [ , 'dom', , 'szkola']; +</pre> + +<p>W poniższym przykładzie tablica jest dlugości cztery, brakuje w niej zdefiniowanych elementów <code>mojaLista[1]</code> oraz <code>mojaLista[3]</code>. Zignorowany zostaje jedynie ostatni przecinek.</p> + +<pre class="brush: js">var mojaLista = ['dom', , 'szkola', , ]; +</pre> + +<p>Zrozumienie zachowania dodatkowych przecinków jest bardzo ważne w procesie nauki języka JavaScript, jednocześnie zalecanym podejściem jest jawne deklarowanie brakujących elementów jako <code>undefined</code>, co pomaga zwiększyć czytelność kodu, ułatwia jego utrzymanie oraz wprowadzanie zmian w przyszłości.</p> + +<h3 id="Literały_boolowskie">Literały boolowskie</h3> + +<p>Typ Boolowski posiada dwie wartości literałowe: <code>true</code> oraz <code>false</code>. </p> + +<p>Jednakże nie należy mylić tego z wartościami <code>true</code> oraz <code>false</code>, które są wartościami obiektu, ponieważ jest on jedynie reprezentacją prymitywnego typu danych. Więcej na ten temat możemy znaleźć w dokumentacji typu {{jsxref("Boolean")}}. </p> + +<h3 id="Literały_całkowite">Literały całkowite</h3> + +<p>Literały całkowite mogą być wyrażane w systemie decymalnym (baza 10), heksadecymalnym (baza 16), oktalnym (baza 8) oraz binarnym (baza 2).</p> + +<ul> + <li>Literały dziesiętne zawierają sekwencje cyfr pozbawioną wiodącego zera. </li> + <li>Wiodące zero w literale całkowitym świadczy o tym że jest on reprezentowany w systemie oktalnym, w którym dopuszczane są cyfry z zakresu 0-7.</li> + <li>Kiedy łańcuch cyfr zaczyna się od 0x (lub 0X) oznacza to że przyjmujemy reprezentację heksadecymalną, gdzie dopuszczalne jest użycie wszystkich cyfr oraz liter z przedziału a-f lub A-F.</li> +</ul> + +<p>Posłużymy się kilkoma przykładami literałów całkowitych:</p> + +<pre class="eval">0, 117 and -345 (dziesietne, baza 10) +015, 0001 and -077 (oktalne, baza 8) +0x1123, 0x00111 and -0xF1A7 (heksadecymalne, "hex" or baza 16) +</pre> + +<p>By zasięgnąc informacji przejdź do działu <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Numeric_literals">Numeric literals in the Lexical grammar reference</a>.</p> + +<h3 id="Literały_zmiennoprzecinkowe">Literały zmiennoprzecinkowe</h3> + +<p>Literały zmiennoprzecinkowe mogą zawierać poniższe elementy:</p> + +<ul> + <li>Liczbę dziesiętną z określonym znakiem "+" i "-" ,</li> + <li>Część dziesiętną,</li> + <li>Wykładnik potęgi.</li> +</ul> + +<p>Wykładnik potęgi oznaczami małą lub wielką literą "e", a następnie liczbą całkowitą która także może zawierać znak "+" lub "-". Literał zmiennoprzecinkowy musi zawierać conajmniej jedną cyfre oraz przecinek wymiennie z literą "e" (lub "E"). </p> + +<p>Przykładowymi literałamy zmiennoprzecinkowymi są 3.1415, -3.1E12, .1e12, oraz 2E-12.</p> + +<p>Ogólna składnia wyrażenia przedstawiona jest na poniższym przykładzie: :</p> + +<pre class="eval">[(+|-)][digits][.digits][(E|e)[(+|-)]digits] +</pre> + +<p>Na przykład:</p> + +<pre class="eval">3.14 +2345.789 +.3333333333333333333 +-.283185307179586 +</pre> + +<h3 id="Literały_obiektowe">Literały obiektowe</h3> + +<p>Literałem obiektowym nazywamy listę złożoną z zera lub większej ilości par indeks - wartość, zamkniętych w nawiasy klamrowe (<code>{}</code>). Należy pamiętać by nie używać literałów obiektowych na początku wyrażeń, gdyż może to spowodować błąd programu lub zachowanie którego nie możemy przewidzieć. Jest to wynikiem zachowania intepretera, który odczyta otwierający nawias klamrowy jako początek bloku. </p> + +<p>W poniższym przykładzie ilustrujemy literał obiektowy tworząc go i przypisując do zmiennej <code>samochod</code>, następnie definiujemy element <code>mojSamochod</code>, którego wartośc ustalamy na <code>"Saturn"</code>, do drugiego elementu przypisujemy wynik wywołania funkcji TypSamochodu("Honda"), a trzeci element <code>specjalizacja</code> reprezentuje wcześniej zainicjalizowaną zmienną <code>Sprzedaz</code>.</p> + +<pre class="brush: js">var Sprzedaz = "Toyota"; + +function TypSamochodu(nazwa) { + if (nazwa == "Honda") { + return nazwa; + } else { + return "Niestety nie sprzedajemy samochodow marki" + " + nazwa + "."; + } +} + +var samochod = { mojSamochod: "Saturn", znajdzSamochod: TypSamochodu("Honda"), specializacja: Sprzedaz }; + +console.log(samochod.mojSamochod); // Saturn +console.log(samochod.znajdzSamochod); // Honda +console.log(samochod.specjalizacja); // Toyota +</pre> + +<p>Dodatkowo możemy użyć literału numerycznego lub znakowego jako własności obiektu, a także zagnieżdzać je jeden w drugim. Poniższy przykład ilustruje użycie tych metod.</p> + +<pre class="brush: js">var samochod = { wieleSamochodow: {a: "Saab", "b": "Jeep"}, 7: "Mazda" }; + +console.log(samochod.wieleSamochodow.b); // Jeep +console.log(samochod[7]); // Mazda +</pre> + +<p>Własności obiektu mogą być reprezentowane przez łańcuch znaków, także pusty. Jeżeli jego nazwa nie byłaby prawidłowym <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Variables">identifikatorem</a> JavaScript musi być ujęta w cudzysłowach.</p> + +<p>Nazwy własności które nie są prawidłowe nie mogą być dostępne za pomocą operatora kropki (.), natomiast można je wywołać oraz zmieniać dzięki wykorzystaniu notacji tablicowej ("[]").</p> + +<pre class="brush: js">var niestandardoweNazwyWlasnosci = { + "": "Pusty lancuch", + "!": "Bang!" +} +console.log(niestandardoweNazwyWlasnosci.""); // SyntaxError: Unexpected string +console.log(niestandardoweNazwyWlasnosci[""]); // Pusty lancuch +console.log(niestandardoweNazwyWlasnosci.!); // SyntaxError: Unexpected token ! +console.log(niestandardoweNazwyWlasnosci["!"]); // Bang!</pre> + +<p>Warto zapamiętać:</p> + +<pre class="brush: js">var foo = {a: "alfa", 2: "dwa"}; +console.log(foo.a); // alfa +console.log(foo[2]); // dwa +//console.log(foo.2); // Error: missing ) after argument list +//console.log(foo[a]); // Error: a is not defined +console.log(foo["a"]); // alfa +console.log(foo["2"]); // dwa +</pre> + +<h3 id="Literały_RegExp">Literały RegExp</h3> + +<p>Literały regex są szablonem zamkniętym pomiędzy ukośnikami. Poniższy przykład obrazuje regex.</p> + +<pre>var re = /ab+c/</pre> + +<h3 id="Literały_łańcuchowe">Literały łańcuchowe</h3> + +<p>Literałem łancuchowym nazywamy zero lub więcej pojedyńczych znaków ujętych w podwójny (") lub pojedyńczy (') cudzysłów. Należy pamiętać by otwarcie i zamnięcie łańcucha zostało wyrażone za pomocą tego samego wariantu. Przykłady literałów łańcuchowych:</p> + +<ul> + <li><code>"foo"</code></li> + <li><code>'bar'</code></li> + <li><code>"1234"</code></li> + <li><code>"jedna linia \n nastepna linia"</code></li> + <li><code>"Kot Jana"</code></li> +</ul> + +<p>Na literale łancuchowym możemy wywołać wszystkie metody jakich moglibyśmy użyć na obiekcie tego typu, ponieważ JavaScript automatycznie konwertuje literał do tymczasowego obiektu, na którym zostaje wywołana metoda a następnie jest on niszczony. Przykładem wykorzystania tej możliwości jest wywołanie <code>String.length</code> :</p> + +<pre class="brush: js">console.log("John's cat".length) +// Wypisze ilość symboli użytych w łancuchu łącznie z białymi znakami +// W tym przypadku zwróconą wartością jest 10. +</pre> + +<p>Używanie literałów jest korzystniejsze dla wydajności naszych programów, dlatego jeżeli zaawansowane metody obiektu typu String nie są nam potrzebne powinniśmy pozostać przy ich wykorzystaniu. Więcej informacji na ten temat dostępne jest w dokumentacji obiektu {{jsxref("String")}}</p> + +<h4 id="Używanie_specjalnych_znaków_w_łańcuchach">Używanie specjalnych znaków w łańcuchach</h4> + +<p>W dodatku to podstawowych znaków w łancuchach możemy umieszczać zdefiniowane znaki specjalne, co ilustruje poniższy przykład.</p> + +<pre class="brush: js">"jedna linia \n akolejna linia" +</pre> + +<p>Poniższa tabela pokazuje zestaw znaków które możemy wykorzystyć.</p> + +<table class="standard-table"> + <caption>Tabela 2.1 Specjalne znaki w języku JavaScript</caption> + <thead> + <tr> + <th scope="col">Znak</th> + <th scope="col">Znaczenie</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>\0</code></td> + <td>Null Byte</td> + </tr> + <tr> + <td><code>\b</code></td> + <td>Backspace</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>Form feed</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>Nowa linia</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>Powrót wózka</td> + </tr> + <tr> + <td><code>\t</code></td> + <td>Tabulatura</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>Wertykalna tabulatura</td> + </tr> + <tr> + <td><code>\'</code></td> + <td>Apostrof lub pojedyńczy cudzysłów</td> + </tr> + <tr> + <td><code>\"</code></td> + <td>Podwójny cudzysłów</td> + </tr> + <tr> + <td><code>\\</code></td> + <td>Backslash</td> + </tr> + <tr> + <td><code>\<em>XXX</em></code></td> + <td>Znak zakodowany w formacie Latin-1 składający się z trzech znaków w systemie oktalnym, z przedzialu od 0 do 377. Przykładowo, sekwencja \251 reprezentuje symbol praw autorskich.</td> + </tr> + <tr> + </tr> + <tr> + <td><code>\x<em>XX</em></code></td> + <td>Znak zakodowany w formacie Latin-1 składający się z dwóch znaków w systemie heksadecymalnym, z przedzialu od 00 do FF. Przykładowo, sekwencja \xA9 reprezentuje symbol praw autorskich</td> + </tr> + <tr> + </tr> + <tr> + <td><code>\u<em>XXXX</em></code></td> + <td>Znak w formacie Unicode wyznaczony przez cztery liczby w formacie heksadecymalnym. Przykładowo \u00A9 w tym formacie reprezentuje symbol praw autorskich, więcej informacji na ten temat znajdziesz w {{anch("Unicode escape sequences")}}.</td> + </tr> + </tbody> +</table> + +<h3 id="Unikanie_znaków">Unikanie znaków</h3> + +<p>Dla znaków, które nie zostały wylistowane w Tabeli 2.1 poprzedzające je ukośnik jest ignorowany, jednakże jest to zachowanie przestrarzałe i należy go unikać. </p> + +<p>By zachować znaki specjalne w łańcuchu należy poprzedzić je ukośnikiem, ta funkcjonalność znana jest jako unikanie znaków. Przykładowo:</p> + +<pre class="brush: js">var cytat = "On przeczytał \"Kremacje Sama McGee\" autorstwa R.W. Service."; +console.log(cytat); +</pre> + +<p>Rezultatem uruchomienia powyższego kodu jest: </p> + +<pre class="eval">On przeczytał "Kremacje Sama McGee" autorstwa R.W. Service. +</pre> + +<p>By zawrzeć w naszym programie ukośnik należy poprzedzić go drugim ukośnikiem, który spowoduje uniknięcie następującego go znaku. Przykładowo jeżeli chcemy przypisać do zmiennej ścieżkę <code>c:\temp</code> musimy posłużyć się poniższym zapisem: </p> + +<pre class="brush: js">var sciezka = "c:\\temp"; +</pre> + +<p>Możemy w ten sposób także opuszczać znak końca linii, który zostanie usunięty z wartości zwróconej ze zmiennej .</p> + +<pre class="brush: js">var str = "ten lancuch \ +jest rozbity \ +na wiele \ +linii." +console.log(str); // ten lancuch jest rozbity na wiele linii. +</pre> + +<p>Pomimo tego że natywnie JavaScript nie oferuje składni "heredoc" możemy zasymulować ją poprzed dodanie znaku końca linii i opuszczenie automatycznie dodawanego znaku: </p> + +<pre class="brush: js">var poem = +"Na górze róże,\n\ +na dole fiołki.\n\ +Ale z was piękne,\n\ +są aniołki." +</pre> + +<h2 id="Więcej_informacji">Więcej informacji</h2> + +<p>Ten rozdział skupia się na podstawowych własnościach składni umożliwiającej deklaracje i posługiwanie się typami. By dowiedzieć się więcej na temat konstrukcji dozwolonych w języku JavaScript odwiedź poniższe rozdziały w tym przewodniku: </p> + +<ul> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Control_flow_and_error_handling">Control flow and error handling</a></li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration">Loops and iteration</a></li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions">Functions</a></li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators">Expressions and operators</a></li> +</ul> + +<p>W następnym rozdziale skupimy się nad kontrolą logiki programów i obsługą błędów.{{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}</p> |