diff options
Diffstat (limited to 'files/pl/web/javascript')
466 files changed, 50244 insertions, 0 deletions
diff --git a/files/pl/web/javascript/domkniecia/index.html b/files/pl/web/javascript/domkniecia/index.html new file mode 100644 index 0000000000..985f5e50ce --- /dev/null +++ b/files/pl/web/javascript/domkniecia/index.html @@ -0,0 +1,408 @@ +--- +title: Domknięcia +slug: Web/JavaScript/Domkniecia +translation_of: Web/JavaScript/Closures +--- +<div> {{jsSidebar("Intermediate")}}</div> + +<div></div> + +<p class="summary">Domknięcie jest funkcją skojarzoną z odwołującym się do niej środowiskiem. Innymi słowy domknięcie daje Ci dostęp z funkcji wewnętrznej do zasięgu funkcji zewnętrznej.</p> + +<h2 id="Zasięg_leksykalny">Zasięg leksykalny</h2> + +<p>Rozważ poniższy przykład:</p> + +<div> +<pre class="brush: js">function init() { + var name = "Mozilla"; // name jest zmienną lokalną utworzoną przez funkcję init + function displayName() { // displayName() jest wewnętrzną funkcją, domknięciem + alert(name); // używa zmiennej zdeklarowanej w funkcji nadrzędnej + } + displayName(); +} +init();</pre> +</div> + +<p><code>init()</code> tworzy zmienną lokalną <code>name</code> oraz funkcję <code>displayName()</code>. <code>displayName()</code> jest funkcją lokalną która została zdefiniowana wewnątrz funkcji <code>init()</code> i jest dostępna tylko wewnątrz tej funkcji. <code>displayName()</code> nie ma własnych zmiennych lokalnych. Jednakże, ponieważ wewnętrzne funkcje mają dostęp do zmiennych zdefiniowanych w funkcjach zewnętrznych, <code>displayName()</code> ma dostęp do zmiennej <code>name</code> zdeklarowanej w funkcji nadrzędnej, <code>init()</code>.</p> + +<p>{{JSFiddleEmbed("https://jsfiddle.net/xAFs9/3/", "js,result", 200)}}</p> + +<p>Uruchom kod i zauważ że <code>alert()</code> zawarty w funkcji <code>displayName()</code> wyświetlił wartość ze zmiennej <code>name</code>, która jest zdeklarowana w funkcji nadrzędnej. Jest to przykład <em>zasięgu leksykalnego</em>, który opisuje jak parser rozwiązuje zmienne kiedy funkcje są zagnieżdżone. Słowo "leksykalny" odnosi się do faktu że zasięg leksykalny używa lokalizacji zdefiniowania zmiennej w kodzie źródłowym aby określić gdzie ta zmienna jest dostępna. Zagnieżdżone funkcje mają dostęp do zmiennych zdeklarowanych w ich zewnętrznym zasięgu.</p> + +<h2 id="Domknięcie">Domknięcie</h2> + +<p>Teraz rozważmy następujący przykład:</p> + +<pre class="brush: js">function makeFunc() { + var name = "Mozilla"; + function displayName() { + alert(name); + } + return displayName; +} + +var myFunc = makeFunc(); +myFunc(); +</pre> + +<p>Jeżeli uruchomisz ten kod przekonasz się że ma takie samo działanie jak poprzedni przykład z funkcją <code>init()</code>: tym razem wartość tekstowa "Mozilla" zostanie wyświetlona w alercie. To, co jest inne, - i interesujące - to to, że wewnętrzna funkcja <code>displayName()</code> została zwrócona z nadrzędnej funkcji przed jej wykonaniem.</p> + +<p>Na pierwszy rzut oka może się wydawać nieintuicyjne, że kod nadal pracuje. W niektórych językach programowania zmienne lokalne znajdujące się w funkcji istnieją tylko przez czas trwania tej funkcji. W momencie gdy <code>makeFunc()</code> zostanie wykonana możesz oczekiwać, że zmienna nie będzie już dostępna. Jednakże, ponieważ w naszym przypadku kod nadal pracuje, jak widać nie dotyczy to języka JavaScript.</p> + +<p>Spowodowane jest to tym, że omawiane funkcje przybierają w Javascript formę domknięć. <em>Domknięcie</em> jest kombinacją funkcji i leksykalnego środowiska w którym ta funkcja została zdeklarowana. To środowisko zawiera każdą zmienną lokalną która była w zasięgu w momencie kiedy domknięcie zostało stworzone. W tym przypadku, <code>myFunc</code> jest referencją do instancji funkcji <code>displayName</code> stworzonej w momencie działania <code>makeFunc</code>. Instancja <code>displayName</code> zarządza referencją do jej leksykalnego środowiska, w którym istnieje zmienna. Dlatego, kiedy <code>myFunc</code> jest uruchomiona, zmienna pozostaje dostępna do użycia i "Mozilla" może być przekazane do <code>alert</code>.</p> + +<p>Poniżej znajduje się znacznie bardziej interesujący przykład — funkcja <code>makeAdder</code>:</p> + +<pre><code>function makeAdder(x) { + return function(y) { + return x + y; + }; +} + +var add5 = makeAdder(5); +var add10 = makeAdder(10); + +console.log(add5(2)); // 7 +console.log(add10(2)); // 12</code></pre> + +<p>W tym przykładzie, zdefiniowaliśmy funkcję <code>makeAdder(x)</code>, która pobiera argument, <code>x</code>, i zwraca nową funkcję. Zwrócona funkcja pobiera argument, y, i zwraca sume x i y.</p> + +<p>W zasadzie <code>makeAdder</code> jest fabryką funkcji — wytwarza funkcje, które mogą dodawać pewną wartość do ich argumentu. W powyższym przykładzie używamy naszej fabryki funkcji do stworzenia dwóch nowych funkcji — jedna, która dodaje 5 do jej argumentu i druga, która dodaje 10.</p> + +<p><code>add5</code> i <code>add10</code> są domknięciami. Dzielą ten sam kod zawarty w funkcji <code>makeAdder</code>, ale przechowują różne leksykalne środowisko. W leksykalnym środowisku <code>add5</code>, <code>x</code> wynosi 5, natomiast w leksykalnym środowisku <code>add10</code>, <code>x</code> jest równe 10.</p> + +<h2 id="Praktyczne_domknięcia">Praktyczne domknięcia</h2> + +<p>Domknięcia są przydatne, ponieważ pozwalają Ci powiązać część danych (środowisko leksykalne) z funkcją, która operuje na tych danych. Jest to oczywista analogia do programowania obiektowego, gdzie obiekty pozwalają nam na powiązanie części danych (właściwości obiektu) z jedną lub dwiema metodami.</p> + +<p>W rezultacie możesz użyć dokmnięć w sytuacjach, gdzie normalnie byś użył/a obiektu z wyłącznie jedną metodą.</p> + +<p>Potencjalne sytuacje zastosowania powyższego zachowania są szczególnie popularne w sieci. Wiele kodu, który piszemy we front-endowym Javascripcie bazuje na zdarzeniach — definiujemy jakieś zachowanie, następnie dołączamy je do wydarzenia, które jest wywoływane przez użytkownika (kliknięciem myszki lub naciśnięciem klawisza klawiatury). Nasz kod jest najczęściej dołączony jako callback (wywołanie zwrotne): pojedyncza funkcja wykonywana jako odpowiedź na wydarzenie.</p> + +<p>Przyjmijmy przykładowo, że chcemy dodać do strony przyciski, które zmieniają wielkość tekstu. Jednym ze sposobów na osiągnięcie tego jest określenie rozmiaru czcionki <code>font-size</code> elementu <code>body</code> w pikselach, następnie ustawienie rozmiaru innych elementów na stronie (takich jak nagłówki) używając jednostki względnej <code>em</code>:</p> + +<pre><code>body { + font-family: Helvetica, Arial, sans-serif; + font-size: 12px; +} + +h1 { + font-size: 1.5em; +} + +h2 { + font-size: 1.2em; +}</code></pre> + +<p>Nasze interaktywne przyciski zmiany wielkości tekstu mogą zmienić wlaściwość <code>font-size</code> elementu <code>body</code>, a inne elementy strony dostosują się dzięki zastosowaniu jednostki względnej.</p> + +<p>Poniżej realizacja w JavaScript:</p> + +<pre><code>function makeSizer(size) { + return function() { + document.body.style.fontSize = size + 'px'; + }; +} + +var size12 = makeSizer(12); +var size14 = makeSizer(14); +var size16 = makeSizer(16);</code></pre> + +<p><code>size12</code>, <code>size14</code>, oraz <code>size16</code> są obecnie funkcjami, które zmienią rozmiar tekstu w <code>body</code> do odpowiednio 12, 14 oraz 16 pixeli. Możemy dołączyć je do przycisków (w tym przypadku linków) jak ponżej:</p> + +<pre><code>document.getElementById('size-12').onclick = size12; +document.getElementById('size-14').onclick = size14; +document.getElementById('size-16').onclick = size16;</code></pre> + +<pre><code><a href="#" id="size-12">12</a> +<a href="#" id="size-14">14</a> +<a href="#" id="size-16">16</a></code></pre> + +<p>{{JSFiddleEmbed("https://jsfiddle.net/vnkuZ/","","200")}}</p> + +<h2 id="Emulowanie_prywatnych_metod_przy_użyciu_domknięć">Emulowanie prywatnych metod przy użyciu domknięć</h2> + +<p>Języki takie jak Java dostarczają możliwość zadeklarowania metody jako prywatna, co oznacza, że może ona zostać wywołana wylącznie przez inne metody w tej samej klasie.</p> + +<p>JavaScript nie zapewnia do tego wbudowanej metody, jednakże jest możliwa emulacja prywatnych metod przy użyciu domknięć. Prywatne metody nie sa wyłącznie użyteczne z racji możliwości ograniczenia dostępu do kodu: dają również świetną możliwość zarządzania Twoją globalną przestrzenią nazw (namespace) uniemożliwiając nieistotnym metodom zaśmiecenie interfejsu publicznego Twojego kodu.</p> + +<p>Poniższy kod ukazuje, w jaki sposób można użyć domknięć do zdefiniowania publicznych funkcji, które mają dostęp do prywatnych funkcji i zmiennych. Używanie dokmnięć w taki sposób znane jest jako <a href="http://www.google.com/search?q=javascript+module+pattern" title="http://www.google.com/search?q=javascript+module+pattern">module pattern</a>:</p> + +<pre><code>var counter = (function() { + var privateCounter = 0; + function changeBy(val) { + privateCounter += val; + } + return { + increment: function() { + changeBy(1); + }, + decrement: function() { + changeBy(-1); + }, + value: function() { + return privateCounter; + } + }; +})(); + +console.log(counter.value()); // logs 0 +counter.increment(); +counter.increment(); +console.log(counter.value()); // logs 2 +counter.decrement(); +console.log(counter.value()); // logs 1</code></pre> + +<p>W poprzednich przykładach każde domknięcie miało własne leksykalne środowisko. Jednakże w tym przypadku tworzymy pojedyncze środowisko leksykalne, współdzielone przez trzy funkcje: <code>counter.increment</code>, <code>counter.decrement<font face="Open Sans, arial, x-locale-body, sans-serif"><span style="background-color: #ffffff;"> oraz </span></font></code><code>counter.value</code>.</p> + +<p>Owo współdzielone środowisko leksykalne tworzone jest w ciele funkcji anonimowej, która jest wykonana w momencie, gdy tylko zostanie zdefiniowana. Środowisko leksykalne zawiera dwa prywatne przedmioty: zmienną o nazwie <code>privateCounter</code> i funkcję o nazwie <code>changeBy</code>. Żaden z tych prywatnych przedmiotów nie może być wywołany bezpośrednio spoza funkcji anonimowej. Zamiast tego, muszą mieć być one wywołane poprzez trzy funkcje publiczne, które są zwracane z anonimowej klasy opakowującej (wrapper).</p> + +<p>Te trzy funkcje publiczne to domknięcia, które współdzielą to samo środowisko. Dzięki JavaScriptowemu zakresowi leksykalnemu, każda z nich ma dostęp do zmiennej <code>privateCounter</code> oraz funkcji <code>changeBy.</code></p> + +<p>Zauważysz, że definiujemy anonimową funkcję, która tworzy licznik, a następnie od razu ją wywołujemy i przypisujemy wynik do zmiennej <code>counter</code>. Moglibyśmy przetrzymywać tę funkcję w oddzielnej zmiennej <code>makeCounter</code> i użyć jej do stworzenia kilku liczników.</p> + +<pre><code>var makeCounter = function() { + var privateCounter = 0; + function changeBy(val) { + privateCounter += val; + } + return { + increment: function() { + changeBy(1); + }, + decrement: function() { + changeBy(-1); + }, + value: function() { + return privateCounter; + } + } +}; + +var counter1 = makeCounter(); +var counter2 = makeCounter(); +alert(counter1.value()); /* Alerts 0 */ +counter1.increment(); +counter1.increment(); +alert(counter1.value()); /* Alerts 2 */ +counter1.decrement(); +alert(counter1.value()); /* Alerts 1 */ +alert(counter2.value()); /* Alerts 0 */</code></pre> + +<p>Zauważ, że każdy z dwóch liczników, <code>counter1</code> oraz <code>counter2</code>, jest niezależny od drugiego. Każde domknięcie odnosi się do innej wersji zmiennej <code>privateCounter</code> przez własne domknięcie. Za każdym razem gdy któryś z liczników jest wywołany, jego środowisko leksykalne zmienia się przez zmianę wartości tej zmiennej; jednakże zmiany wartości zmiennej jednego domknięcia nie wpływają na wartość w innym domknięciu.</p> + +<p>Używanie domknięć w ten sposób dostarcza wielu korzyści, które normalnie kojarzone sa z programowaniem obiektowym — w szczególności ukrywaniem oraz enkapsulacją danych.</p> + +<h2 id="Tworzenie_domknięć_w_pętlach_popularne_błędy">Tworzenie domknięć w pętlach: popularne błędy</h2> + +<p>W czasach przed wprowadzeniem definicji <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let" title="let"><code>let</code> </a>w standardzie ECMAScript 2015, popularnym problemem z domknięciami było ich użycie w pętlach.<br> + Rozważmy poniższy kod:</p> + +<pre class="brush: html"><code><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></code></pre> + +<pre class="brush: js"><code>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); + } + } +} + +setupHelp();</code></pre> + +<p>{{JSFiddleEmbed("https://jsfiddle.net/v7gjv/", "", 200)}}</p> + +<p>Tablica <code>helpText</code> definiuje trzy podpowiedzi. Każda z nich jest powiązana z ID inputu z dokumentu. Następnie w pętli <code>for</code> dodawana jest obsługa zdarzenia <code>onfocus</code>, która ma pokazać tekst podpowiedzi podczas ustawienia focusa na pole.<br> + <br> + Jeżeli sprawdzisz działanie tego kodu okaże się, że nie działa tak, jak się spodziewaliśmy. Zawsze zostanie wyświetlona podpowiedź dotycząca ostatniego pola (<code>'Your age (you must be over 16)'</code>).</p> + +<p>Powodem takiego działania funkcji zwrotnej obsługującej <code>onfocus</code> jest domknięcie. Składa sie ono z definicji funkcji i przechwyconego kontekstu zakresu z <code>setupHelp</code>. Trzy domknięcia stworzone są w pętli, ale dzielą one to samo środowisko leksykalne, ktore posiada zmienną, która jest aktualizowana (<code>item.help</code>). Wartości <code>item.help</code> są determinowane w pętli, więc kiedy obsługa zdarzenia <code>onfocus</code> zostanie wywołana, <code>item.help</code> będzie miało wartość z ostatniej iteracji pętli.</p> + +<p>Rozwiązaniem tego problemu jest użycie kolejnych domknięć, szczególnie fabryki funkcji opisanej wcześniej:</p> + +<pre class="brush: js"><code>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); + } +} + +setupHelp();</code></pre> + +<p>{{JSFiddleEmbed("https://jsfiddle.net/v7gjv/1/", "", 300)}}</p> + +<p>To rozwiązanie działa zgodnie z oczekiwaniami. W odróżnieniu od wcześniejszego przykładu, <code>makeHelpCallback</code> tworzy <em>nowe środowisko leksykalne</em> dla każdej funkcji zwrotnej, w której <code>help</code> odnosi się do odpowiadającego stringa z tablicy <code>helpText</code>.</p> + +<p>Innym sposobem zapisu rozwiązania z anonimowymi domknięciami jest:</p> + +<pre class="brush: js"><code>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++) { + (function() { + var item = helpText[i]; + document.getElementById(item.id).onfocus = function() { + showHelp(item.help); + } + })(); // Immediate event listener attachment with the current value of item (preserved until iteration). + } +} + +setupHelp();</code></pre> + +<p>Jeżeli nie chcesz używać domknięć możesz użyć słowa kluczowego <code>let</code> ze standardu ES2015:</p> + +<pre class="brush: js"><code>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++) { + let item = helpText[i]; + document.getElementById(item.id).onfocus = function() { + showHelp(item.help); + } + } +} + +setupHelp();</code></pre> + +<p>Ten przykład używa <code>let</code> zamiast <code>var</code>, więc każde domknięcie wiąże się z blokowym zasięgiem funkcji, dlatego nie potrzeba żadnych dodatkowych domknięć.</p> + +<p>Alternatywą może być użycie <code>forEach()</code>, by iterować po tablicy <code>helpText</code> i dodać listener dla każdego elementu <code><input></code>:</p> + + + +<pre class="brush: js"><code>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)'} + ]; + + helpText.forEach(function(text) { + document.getElementById(text.id).onfocus = function() { + showHelp(text.help); + } + }); +} + +setupHelp();</code></pre> + + + +<h2 id="Wątpliwości_wydajnościowe">Wątpliwości wydajnościowe</h2> + +<p>Niemądrze jest, aby niepotrzebnie tworzyć funkcje wewnątrz innych funkcji, jeżeli domnkięcia nie są wymagane w danej sytuacji, jako że odbije się to w negatywny sposób na wydajność skryptu, mierzoną poprzez czas wykonywania jak również i używaną pamięć.</p> + +<p>Na przykład gdy tworzymy nowy obiekt/klasę, metody powinny być zwykle powiązane z prototypem obiektu zamiast definiowane w konstruktorze obiektu. Przyczyną jest to, że za każdym razem gdy konstruktor zostanie użyty, metody zostaną nadpisane (czyli przy każdym tworzeniu nowego obiektu).</p> + +<p>Rozważmy następujący przykład:</p> + +<pre><code>function MyObject(name, message) { + this.name = name.toString(); + this.message = message.toString(); + this.getName = function() { + return this.name; + }; + + this.getMessage = function() { + return this.message; + }; +}</code></pre> + +<p>Ponieważ poprzedni przykład nie wykorzystuje zalet, które płyną z wykorzystania domknięć, możemy to przepisać w następujący sposób:</p> + +<pre><code>function MyObject(name, message) { + this.name = name.toString(); + this.message = message.toString(); +} +MyObject.prototype = { + getName: function() { + return this.name; + }, + getMessage: function() { + return this.message; + } +};</code></pre> + +<p>Jednakże ponowne definiowanie prototypu nie jest rekomendowane. Poniższy przykład zamiast tego dodaje właściwości do istniejącego prototypu:</p> + +<pre><code>function MyObject(name, message) { + this.name = name.toString(); + this.message = message.toString(); +} +MyObject.prototype.getName = function() { + return this.name; +}; +MyObject.prototype.getMessage = function() { + return this.message; +};</code></pre> + +<p>Powyższy przykład może też zostać przepisany w bardziej czytelny sposób, z identycznym wynikiem:</p> + +<pre><code>function MyObject(name, message) { + this.name = name.toString(); + this.message = message.toString(); +} +(function() { + this.getName = function() { + return this.name; + }; + this.getMessage = function() { + return this.message; + }; +}).call(MyObject.prototype);</code></pre> + +<p>W poprzednich trzech przykładach odziedziczony prototyp może być współdzielony przez wszystkie obiektu i definicje metod nie muszą występować przy każdorazowym tworzeniu obiektu. Aby dowiedzieć się więcej, zobacz Szczegóły modelu obiektowego.</p> + +<p>In the three 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="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model">Details of the Object Model</a> for more.</p> diff --git a/files/pl/web/javascript/dziedziczenie_lancuch_prototypow/index.html b/files/pl/web/javascript/dziedziczenie_lancuch_prototypow/index.html new file mode 100644 index 0000000000..0c18115595 --- /dev/null +++ b/files/pl/web/javascript/dziedziczenie_lancuch_prototypow/index.html @@ -0,0 +1,295 @@ +--- +title: Dziedziczenie i łańcuch prototypów +slug: Web/JavaScript/dziedziczenie_lancuch_prototypow +tags: + - Dziedziczenie + - JavaScript + - OOP +translation_of: Web/JavaScript/Inheritance_and_the_prototype_chain +--- +<div>{{jsSidebar("Advanced")}}</div> + +<p>JavaScript bywa mylący dla developerów doświadczonych w językach opartych na klasach (jak Java lub C++) przez to, że jest dynamiczny i nie zapewnia implementacji klasy per se (słowo kluczowe <code>class</code> zostało wprowadzone w ES2015, ale to tylko lukier składniowy, JavaScript pozostaje oparty na prototypach).</p> + +<p>Jeżeli chodzi o dziedziczenie, JavaScript posiada tylko jedną konstrukcję: obiekty. Każdy obiekt posiada prywatną własność łączącą go z innym obiektem zwanym jego <strong>prototypem</strong>. Obiekt <em>prototype </em>posiada swój własny prototyp, i tak dalej aż obiekt osiągnie <code>null</code> jako swój prototyp. <code>null</code> nie ma prototypu i działa jak zakończenie <strong>łańcucha</strong> <strong>prototypów</strong>.</p> + +<p>Podczas gdy jest to często uważane za słabość języka JavaScript, prototypowe podejście do dziedziczenia jest w rzeczywistości znacznie potężniejszym narzędziem niż model klasowy. Dla przykładu trywialnie proste jest zbudowanie klas w modelu prototypowym, podczas gdy odwrotna operacja jest znacznie bardziej skomplikowana.</p> + +<h2 id="Dziedziczenie_z_łańcucha_prototypów">Dziedziczenie z łańcucha prototypów</h2> + +<h3 id="Dziedziczenie_właściwości">Dziedziczenie właściwości</h3> + +<p>Obiekty w JavaScript są dynamicznymi "workami" właściwości, nazywanych <strong>własnymi właściwościami</strong><em> </em>(<em>own properties</em>). Obiekty JavaScript mają połączenie z obiektem prototypu. Podczas próby dostępu do właściwości obiektu, właściwość będzie szukana nie tylko w samym obiekcie, ale też w jego prototypie, prototypie jego prototypu i tak dalej, aż do odnalezienia właściwości o pasującej nazwie bądź końca łańcucha prototypów.</p> + +<div class="note"> +<p>W standardzie ECMAScript, notacja <code>jakisObiekt.[[Prototype]] </code> jest używana do oznaczenia prototypu <code>jakisObiekt.</code> Jest to odpowiednik właściwości <code>__proto__</code> (przestarzały).</p> + +<p>Nie powinno być to mylone z właściwością <code><em>func</em>.prototype</code> funkcji, który zamiast tego oznacza <code>[[Prototype]]</code> który jest przypisany do wszystkich instancji stworzonych z danej funkcji kiedy jest użyta jako konstruktor . Od ECMAScript 6 do obiektu <code>[[Prototype]]</code> można uzyskać dostęp przez {{jsxref("Object.getPrototypeOf()")}} i {{jsxref("Object.setPrototypeOf()")}}.</p> +</div> + +<p>Oto co się dzieje kiedy próbujemy uzyskać dostęp do właściwości:</p> + +<pre class="brush: js">// Przyjmijmy istnienie obiektu o, z własnymi właściwościami a i b: +// {a: 1, b: 2} +// o.[[Prototype]] ma właściwości b i c: +// {b: 3, c: 4} +// o.[[Prototype]].[[Prototype]] jest nullem. +// Oznacza to koniec łańcucha prototypów, +// zgodnie z definicją null nie ma [[Prototype]] +// A więc pełny łańcuch prototypów wygląda tak: +// {a:1, b:2} ---> {b:3, c:4} ---> null + +console.log(o.a); // 1 +// Czy istnieje własna właściwość 'a' obiektu o? Tak, jej wartość to 1. + +console.log(o.b); // 2 +// Czy istnieje własna właściwość 'b' obiektu o? Tak, jej wartość to 2. +// Prototyp także ma właściwość 'b', ale nie jest ona brana pod uwagę. +// Nazywa się to "zakrywaniem właściwości" (ang. property shadowing) + +console.log(o.c); // 4 +// Czy istnieje właściwość 'c' obiektu o? Nie, sprawdź prototyp. +// Czy istnieje właściwość 'c' obiektu o.[[Prototype]]? Tak, jej wartość to 4. + +console.log(o.d); // undefined +// Czy istnieje właściwość 'd' obiektu o? Nie, sprawdź prototyp. +// Czy istnieje właściwość 'd' obiektu o.[[Prototype]]? Nie, sprawdź prototyp. +// o.[[Prototype]].[[Prototype]] to null, koniec wyszukiwania. +// Nie znaleziono właściwości, zwróć undefined. +</pre> + +<p>Ustawienie właściwości obiektu tworzy własną właściwość. Jedyny wyjątek od reguł pobierania i tworzenia właściwości stanowi przypadek gdy istnieje odziedziczona właściwość z <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters" title="Defining Getters and Setters"> getterem lub setterem.</a></p> + +<h3 id="Dziedziczenie_metody">Dziedziczenie "metody"</h3> + +<p>JavaScript nie ma "metod" w rozumieniu języków obiektowych. W JS każda funkcja może być dodana jako właściwość do obiektu. Odziedziczona funkcja zachowuje się jak każda inna właściwość, wliczając w to zakrywanie właściwości, tak jak pokazano wyżej (w tym wypadku forma <em>nadpisania metody</em>).</p> + +<p>Kiedy jest wykonywana odziedziczona metoda, wartość <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this" title="this">this</a></code> wskazuje na obiekt, który dziedziczy, nie na obiekt w którym ta metoda została zadeklarowana jako własna właściwość</p> + +<pre class="brush: js">var o = { + a: 2, + m: function(b){ + return this.a + 1; + } +}; + +console.log(o.m()); // 3 +// Podczas wywołania o.m, 'this' wskazuje na o + +var p = Object.create(o); +// p jest obiektem dziedziczącym z o + +p.a = 12; // tworzy własną właściwość 'a' w obiekcie p +console.log(p.m()); // 13 +// Podczas wywołania p.m, 'this' wskazuje na p. +// p dziedziczy funkcję m z obiektu o. +// 'this.a' oznacza p.a, własną właściwość 'a' obiektu p. +</pre> + +<h2 id="Różne_sposoby_tworzenia_obiektów_i_powiązane_z_nimi_łańcuchy_prototypów.">Różne sposoby tworzenia obiektów i powiązane z nimi łańcuchy prototypów.</h2> + + + +<h3 id="Obiekty_stworzone_za_pomocą_podstawowej_składni">Obiekty stworzone za pomocą podstawowej składni</h3> + +<pre class="brush: js">var o = {a: 1}; +// Nowo stworzony obiekt używa Object.prototype jako swojego [[Prototype]] +// o nie posiada właściwości o nazwie 'hasOwnProperty' +// hasOwnProperty jest własną właściwością Object.prototype. +// o dziedziczy hasOwnProperty z Object.prototype +// Object.prototype ma null jako swój prototyp. +// o ---> Object.prototype ---> null + +var a = ["yo", "whadup", "?"]; +// Tablice dziedziczą z Array.prototype +// (który zawiera metody takie jak indexOf, forEach, itd.) +// Łańcuch prototypów wygląda następująco: +// a ---> Array.prototype ---> Object.prototype ---> null + +function f(){ + return 2; +} + +// Funkcje dziedziczą z Function.prototype +// (który zawiera metody takie jak call, bind, itd.) +// f ---> Function.prototype ---> Object.prototype ---> null +</pre> + +<h3 id="Za_pomocą_konstruktora">Za pomocą konstruktora</h3> + +<p>"Konstruktor" w JavaScript jest "tylko" funkcją, której używa się w połączeniu z <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new" title="new">operatorem new</a>.</p> + +<pre class="brush: js">function Graph() { + this.vertices = []; + this.edges = []; +} + +Graph.prototype = { + addVertex: function(v){ + this.vertices.push(v); + } +}; + +var g = new Graph(); +// g is an object with own properties 'vertices' and 'edges'. +// g.[[Prototype]] is the value of Graph.prototype when new Graph() is executed. +</pre> + +<h3 id="Za_pomocą_Object.create">Za pomocą <code>Object.create</code></h3> + +<p>ECMAScript 5 wprowadził nową metodę: {{jsxref("Object.create()")}}. Wywołanie tej metody tworzy nowy obiekt. Jego prototypem staje się pierwszy argument tej metody:</p> + +<pre class="brush: js">var a = {a: 1}; +// a ---> Object.prototype ---> null + +var b = Object.create(a); +// b ---> a ---> Object.prototype ---> null +console.log(b.a); // 1 (inherited) + +var c = Object.create(b); +// c ---> b ---> a ---> Object.prototype ---> null + +var d = Object.create(null); +// d ---> null +console.log(d.hasOwnProperty); +// undefined, because d doesn't inherit from Object.prototype +</pre> + +<div> +<h3 id="Za_pomocą_słowa_kluczowego_class">Za pomocą słowa kluczowego <code>class</code></h3> + +<p>ECMAScript 6 wprowadził zestaw nowych słów kluczowych do implementacji <a href="/en-US/docs/Web/JavaScript/Reference/Classes">klas</a>. Mimo, że konstrukcje te mogą wydawać się znajome programistom języków opartych na klasach, nie są one tym samym. JavaScript wciąż opiera się na prototypach. Nowe słowa kluczowe to {{jsxref("Statements/class", "class")}}, {{jsxref("Classes/constructor", "constructor")}}, {{jsxref("Classes/static", "static")}}, {{jsxref("Classes/extends", "extends")}} oraz {{jsxref("Operators/super", "super")}}.</p> + +<pre class="brush: js">"use strict"; + +class Polygon { + constructor(height, width) { + this.height = height; + this.width = width; + } +} + +class Square extends Polygon { + constructor(sideLength) { + super(sideLength, sideLength); + } + get area() { + return this.height * this.width; + } + set sideLength(newLength) { + this.height = newLength; + this.width = newLength; + } +} + +var square = new Square(2); +</pre> + +<h3 id="Wydajność">Wydajność</h3> + +<p>Czas dostępu do właściwości znajdujących się wysoko w łańcuchu prototypów może negatywnie wpływać na wydajność, co może mieć znaczenie w przypadku kodu, którego szybkość wykonania jest krytyczna. W dodatku próba dostępu do nieistniejącej właściwości zawsze powoduje przeszukanie pełnego łańcucha prototypów.</p> + +<p>Kiedy iterujemy po właściwościach obiektu, sięgamy do <strong>każdej</strong> właściwości widocznej w łańcuchu prototypów.</p> + +<p>Aby sprawdzić czy obiekt ma właściwość zdefiniowaną na nim samym, a nie gdzieś w łańcuchu prototypów, konieczne jest użycie metody <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty" title="/ru/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty"><code>hasOwnProperty</code></a>, którą wszystkie obiekty dziedziczą z <code>Object.prototype</code>.</p> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty" title="/ru/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty"><code>hasOwnProperty</code></a> jest w JavaScript jedyną rzeczą, która działa na właściwościach obiektu <strong>nie</strong> przeszukując łańcucha prototypów.</p> + +<p>Uwaga: sprawdzenie czy właściwość jest <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> <strong>nie </strong>wystarczy. Właściwość może istnieć, a jedynie mieć akurat wartość ustawioną na <code>undefined</code>.</p> +</div> + +<h3 id="Zła_praktyka_Rozszerzanie_natywnych_prototypów">Zła praktyka: Rozszerzanie natywnych prototypów</h3> + +<p>One mis-feature that is often used is to extend <code>Object.prototype</code> or one of the other built-in prototypes.</p> + +<p>This technique is called monkey patching and breaks <em>encapsulation</em>. While used by popular frameworks such as Prototype.js, there is still no good reason for cluttering built-in types with additional <em>non-standard</em> functionality.</p> + +<p>The <strong>only</strong> good reason for extending a built-in prototype is to backport the features of newer JavaScript engines; for example <code>Array.forEach</code>, etc.</p> + +<h2 id="Przykład">Przykład</h2> + +<p><code>B</code> shall inherit from <code>A</code>:</p> + +<pre class="brush: js">function A(a){ + this.varA = a; +} + +// What is the purpose of including varA in the prototype when A.prototype.varA will <em>always</em> be shadowed by +// this.varA, given the definition of function A above? +A.prototype = { + varA : null, // Shouldn't we strike varA from the prototype as doing nothing? + // perhaps intended as an optimization to allocate space in hidden classes? + // https://developers.google.com/speed/articles/optimizing-javascript#Initializing instance variables + // would be valid if varA wasn't being initialized uniquely for each instance + doSomething : function(){ + // ... + } +}; + +function B(a, b){ + A.call(this, a); + this.varB = b; +} +B.prototype = Object.create(A.prototype, { + varB : { + value: null, + enumerable: true, + configurable: true, + writable: true + }, + doSomething : { + value: function(){ // override + A.prototype.doSomething.apply(this, arguments); // call super + // ... + }, + enumerable: true, + configurable: true, + writable: true + } +}); +B.prototype.constructor = B; + +var b = new B(); +b.doSomething(); +</pre> + +<p>The important parts are:</p> + +<ul> + <li>Types are defined in <code>.prototype</code></li> + <li>You use <code>Object.create()</code> to inherit</li> +</ul> + +<h2 id="prototype_and_Object.getPrototypeOf"><code>prototype</code> and <code>Object.getPrototypeOf</code></h2> + +<p>JavaScript is a bit confusing for developers coming from Java or C++, as it's all dynamic, all runtime, and it has no classes at all. It's all just instances (objects). Even the "classes" we simulate are just a function object.</p> + +<p>You probably already noticed that our <code>function A</code> has a special property called <code>prototype</code>. This special property works with the JavaScript <code>new </code>operator. The reference to the prototype object is copied to the internal <code>[[Prototype]]</code> property of the new instance. For example, when you do <code>var a1 = new A()</code>, JavaScript (after creating the object in memory and before running function <code>A()</code> with <code>this</code> defined to it) sets <code>a1.[[Prototype]] = A.prototype</code>. When you then access properties of the instance, JavaScript first checks whether they exist on that object directly, and if not, it looks in <code>[[Prototype]]</code>. This means that all the stuff you define in <code>prototype</code> is effectively shared by all instances, and you can even later change parts of <code>prototype</code> and have the changes appear in all existing instances, if you wanted to.</p> + +<p>If, in the example above, you do <code>var a1 = new A(); var a2 = new A();</code> then <code>a1.doSomething</code> would actually refer to <code>Object.getPrototypeOf(a1).doSomething</code>, which is the same as the <code>A.prototype.doSomething</code> you defined, i.e. <code>Object.getPrototypeOf(a1).doSomething == Object.getPrototypeOf(a2).doSomething == A.prototype.doSomething</code>.</p> + +<p>In short, <code>prototype</code> is for types, while <code>Object.getPrototypeOf()</code> is the same for instances.</p> + +<p><code>[[Prototype]]</code> is looked at <em>recursively</em>, i.e. <code>a1.doSomething</code>, <code>Object.getPrototypeOf(a1).doSomething</code>, <code>Object.getPrototypeOf(Object.getPrototypeOf(a1)).doSomething</code> etc., until it's found or <code>Object.getPrototypeOf </code>returns null.</p> + +<p>So, when you call</p> + +<pre class="brush: js">var o = new Foo();</pre> + +<p>JavaScript actually just does</p> + +<pre class="brush: js">var o = new Object(); +o.[[Prototype]] = Foo.prototype; +Foo.call(o);</pre> + +<p>(or something like that) and when you later do</p> + +<pre class="brush: js">o.someProp;</pre> + +<p>it checks whether <code>o</code> has a property <code>someProp</code>. If not it checks <code>Object.getPrototypeOf(o).someProp</code> and if that doesn't exist it checks <code>Object.getPrototypeOf(Object.getPrototypeOf(o)).someProp</code> and so on.</p> + +<div> +<h2 id="Na_zakończenie">Na zakończenie</h2> + +<p>It is <strong>essential</strong> to understand the prototypal inheritance model before writing complex code that makes use of it. Also, be aware of the length of the prototype chains in your code and break them up if necessary to avoid possible performance problems. Further, the native prototypes should <strong>never</strong> be extended unless it is for the sake of compatibility with newer JavaScript features.</p> +</div> diff --git a/files/pl/web/javascript/eventloop/index.html b/files/pl/web/javascript/eventloop/index.html new file mode 100644 index 0000000000..e61f3c2a48 --- /dev/null +++ b/files/pl/web/javascript/eventloop/index.html @@ -0,0 +1,98 @@ +--- +title: Model współbieżności i Event Loop +slug: Web/JavaScript/EventLoop +translation_of: Web/JavaScript/EventLoop +--- +<div>{{JsSidebar("Advanced")}}</div> + +<p>Model współbieżności w JavaScript opiera się o "event loop". Model ten jest lekko odmienny od spotykanego innych językach programowania takich jak C lub Java.</p> + +<h2 id="Koncepcje_środowiska_wykonawczego">Koncepcje środowiska wykonawczego</h2> + +<p>Poniższa sekcja objaśnia model teoretyczny. Nowoczesne silniki JavaScript implementują i optymalizują w dużej mierze opisaną semantykę.</p> + +<h3 id="Reprezentacja_wizualna">Reprezentacja wizualna</h3> + +<p style="text-align: center;"><img alt="Stack, heap, queue" src="/files/4617/default.svg" style="height: 270px; width: 294px;"></p> + +<h3 id="Stack">Stack</h3> + +<p>Wywołania funkcji formują stos (ang. stack) <em>klatek</em>.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">foo</span><span class="punctuation token">(</span>b<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> a <span class="operator token">=</span> <span class="number token">10</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> a <span class="operator token">+</span> b <span class="operator token">+</span> <span class="number token">11</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="keyword token">function</span> <span class="function token">bar</span><span class="punctuation token">(</span>x<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> y <span class="operator token">=</span> <span class="number token">3</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> <span class="function token">foo</span><span class="punctuation token">(</span>x <span class="operator token">*</span> y<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="function token">bar</span><span class="punctuation token">(</span><span class="number token">7</span><span class="punctuation token">)</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">//zwraca 42</span></code></pre> + +<p>Podczas wywoływania funkcji <code>bar</code>, tworzona jest pierwsza klatka (ang. frame), która zawiera argumenty funkcji <code>bar</code> oraz jej lokalne zmienne. Gdy <code>bar</code> wywołuje <code>foo</code>, tworzona jest kolejna klatka, która trafia na wierzch stosu. Druga klatka zawiera argumenty funkcji <code>foo</code> dla której została utworzona oraz jej lokalne zmienne. Gdy funkcja <code>foo</code> zwraca wynik działania, klatka znajdująca się na wierzchu stosu jest usuwana (pozostawiając wyłącznie klatkę wywołującą funkcję <code>bar</code>). Gdy w kolejnym kroku funkcja <code>bar</code> zwróci wynik, stos zostaje opróżniony.</p> + +<h3 id="Heap">Heap</h3> + +<p>Sterta (ang. heap) jest pojęciem opisującym duży nieuporządkowany obszar pamięci. W nim przechowywane są obiekty.</p> + +<h3 id="Queue">Queue</h3> + +<p>Środowisko wykonawcze (ang. runtime) JavaScript zawiera kolejkę wiadomości (ang. queue), która stanowi listę komunikatów do przetworzenia. Każda z wiadomości posiada przyporządkowaną funkcję, która przechowuje instrukcję przetworzenia danej wiadomości.</p> + +<p>W przeciwieństwie do stosu wiadomości są przetwarzane począwszy od najstarszej z nich (znajdującej się na początku kolejki). Przetworzenie wiadomości polega na wywołaniu odpowiadającej jej funkcji. Wywołanie funkcji powoduje stworzenie i umieszczenie na stosie nowej klatki początkowej. Przetwarzanie danej informacji zostaje zakończone, gdy nastąpi opróżnienie stosu.</p> + +<p>Gdy stos jest pusty, środowisko rozpoczyna przetwarzanie kolejnej informacji z kolejki.</p> + +<h2 id="Event_loop">Event loop</h2> + +<p>Nazwa <code>Event loop</code> wiąże się ze sposobem implementacji, który zwykle przypomina następujący schemat:</p> + +<pre class="brush: js">while(queue.waitForMessage()){ + queue.processNextMessage(); +}</pre> + +<p><code>queue.waitForMessage</code> oczekuje na wiadomość tak długo, dopóki jej nie otrzyma.</p> + +<h3 id="Run-to-completion">"Run-to-completion"</h3> + +<p>W tym modelu każda z wiadomości przetwarzana jest po całkowitym zakończeniu przetwarzania poprzedniej. Oferuje to pewne udogodnienia w analizie programu polegające na tym, że po uruchomieniu funkcji nie może zostać ona wyprzedzona oraz zostanie całkowicie wykonana przed uruchomieniem kolejnego kawałka kodu (dotyczy to również modyfikowanych przez funkcję danych). Model ten różni się od stosowanego np. w języku C, gdzie uruchomiona w danym wątku funkcja może w dowolnym punkcie zostać zatrzymana w celu uruchomienia innego fragmentu kodu w kolejnym wątku.</p> + +<p><span id="result_box" lang="pl"><span>Wadą tego modelu jest to, że jeśli wykonanie wiadomości trwa zbyt długo, aplikacja internetowa nie jest w stanie przetworzyć interakcji użytkownika, takich jak kliknięcie lub scrollowanie.</span> <span>Przeglądarka łagodzi to za pomocą okna dialogowego "skrypt trwa zbyt długo, aby uruchomić".</span> <span>Dobrą praktyką jest dążenie, aby przetwarzanie komunikatów było krótkie, a jeśli to możliwe, należy rozbić wiadomości na kilka krótszych.</span></span></p> + +<h3 id="Dodawanie_wiadomości_do_kolejki">Dodawanie wiadomości do kolejki</h3> + +<p>W przeglądarkach internetowych wiadomości są dodawane przy każdym wystąpieniu eventu z dołączonym nasłuchiwaniem. Jeżeli brak nasłuchiwania event jest gubiony. Zatem przykładowo kliknięcie na element z nasłuchiwaniem doda nową wiadomość.</p> + +<p>Funkcja <code><a href="/en-US/docs/Web/API/WindowTimers.setTimeout" title="/en-US/docs/window.setTimeout">setTimeout</a></code> przyjmuje dwa argumenty: wiadomość do dodania do kolejki oraz czas (argument opcjonalny, domyślnie 0). Podany czas reprezentuje minimalne opóźnienie, po którym wiadomość trafi do kolejki. Jeżeli w kolejce nie ma innej wiadomości, zostaje ona przetworzona natychmiast po upływie danego czasu opóźnienia. Jeżeli jednak w kolejce znajdują się wiadomości, wiadomość <code><a href="/en-US/docs/Web/API/WindowTimers.setTimeout" title="/en-US/docs/window.setTimeout">setTimeout</a></code> odczeka aż inne wiadomości zostaną przetworzone. Z tego powodu drugi argument tej funkcji określa czas minimalny, nie gwarantowany. </p> + +<p>Poniższy przykład ilustruje tę ideę (<code>setTimeout</code> nie zostanie uruchomiony bezpośrednio po upływie określonego czasu):</p> + + + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">const</span> s <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Date</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">.</span><span class="function token">getSeconds</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + +<span class="function token">setTimeout</span><span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="comment token">// zwraca "2", co oznacza, że callback nie zostaje wywołany bezpośrednio po upływie 500 millisekund.</span> + console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">"Uruchomiono po upływie "</span> <span class="operator token">+</span> <span class="punctuation token">(</span><span class="keyword token">new</span> <span class="class-name token">Date</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">.</span><span class="function token">getSeconds</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">-</span> s<span class="punctuation token">)</span> <span class="operator token">+</span> <span class="string token">" sekund"</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span><span class="punctuation token">,</span> <span class="number token">500</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + +<span class="keyword token">while</span><span class="punctuation token">(</span><span class="keyword token">true</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">if</span><span class="punctuation token">(</span><span class="keyword token">new</span> <span class="class-name token">Date</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">.</span><span class="function token">getSeconds</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">-</span> s <span class="operator token">>=</span> <span class="number token">2</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">"Ok, zapętlono na 2 sekundy"</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">break</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> +<span class="punctuation token">}</span></code></pre> + + + +<h3 id="Several_Runtime_communicating_together">Several Runtime communicating together</h3> + +<p>A web worker or a cross-origin iframe has its own stack, heap, and message queue. Two distinct runtimes can only communicate through sending messages via the <a href="/en-US/docs/DOM/window.postMessage" title="/en-US/docs/DOM/window.postMessage"><code>postMessage</code></a> method. This method adds a message to the other runtime if the latter listens to <code>message</code> events.</p> + +<h2 id="Never_blocking">Never blocking</h2> + +<p>A very interesting property of the event loop model is that JavaScript, unlike a lot of other languages, never blocks. Handling I/O is typically performed via events and callbacks, so when the application is waiting for an <a href="/en-US/docs/Web/API/IndexedDB_API" title="/en-US/docs/IndexedDB">IndexedDB</a> query to return or an <a href="/en-US/docs/Web/API/XMLHttpRequest" title="/en-US/docs/DOM/XMLHttpRequest">XHR</a> request to return, it can still process other things like user input.</p> + +<p>Legacy exceptions exist like <code>alert</code> or synchronous XHR, but it is considered as a good practice to avoid them. Beware, <a href="http://stackoverflow.com/questions/2734025/is-javascript-guaranteed-to-be-single-threaded/2734311#2734311" title="http://stackoverflow.com/questions/2734025/is-javascript-guaranteed-to-be-single-threaded/2734311#2734311">exceptions to the exception do exist</a> (but are usually implementation bugs rather than anything else).</p> 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> diff --git a/files/pl/web/javascript/index.html b/files/pl/web/javascript/index.html new file mode 100644 index 0000000000..ff1b6c50e6 --- /dev/null +++ b/files/pl/web/javascript/index.html @@ -0,0 +1,131 @@ +--- +title: JavaScript +slug: Web/JavaScript +tags: + - JavaScript + - Nauka +translation_of: Web/JavaScript +--- +<div>{{JsSidebar}}</div> + +<p class="summary"><strong>JavaScript</strong> (<strong>JS</strong>) to skryptowy (interpretowany lub kompilowany metodą <a href="https://pl.wikipedia.org/wiki/JIT_(informatyka)">JIT</a>) język programowania, w którym funkcje są "obywatelami pierwszej kategorii" - obiektami, które można przechowywać w zmiennych jako referencje i przekazywać jak każde inne obiekty. Chociaż JavaScript jest najbardziej znany jako język skryptowy dla stron internetowych, używa go również <a class="external" href="https://en.wikipedia.org/wiki/JavaScript#Uses_outside_Web_pages">wiele środowisk poza przeglądarką</a>, takich jak <a class="external" href="/en-US/docs/Glossary/Node.js">Node.js</a>, <a href="https://couchdb.apache.org/">Apache CouchDB</a> czy <a href="http://www.adobe.com/devnet/acrobat/javascript.html">Adobe Acrobat</a>. JavaScript jest językiem opartym na prototypach, wielu paradygmatach, dynamicznej składni, zorientowanym obiektowo, o <a href="https://pl.wikipedia.org/wiki/Programowanie_imperatywne">stylu imperatywnym</a> i <a href="https://pl.wikipedia.org/wiki/Programowanie_deklaratywne">deklaratywnym</a> (np. <a href="https://pl.wikipedia.org/wiki/Programowanie_funkcyjne">programowanie funkcyjne</a>). </p> + +<p>Ta sekcja naszego serwisu jest poświęcona samemu językowi JavaScript, a nie zagadnieniom związanym ze stronami internetowymi lub innymi środowiskami hosta. Informacje dotyczące {{Glossary("interfejsów API","Interfejsów API")}} specyficznych dla stron internetowych, prosimy szukać w źródłach: <a href="/pl/docs/Web/API">Internetowe interfesy API</a> i <a href="/pl/docs/Glossary/DOM">DOM</a>.</p> + +<p>Standardem dla JavaScript jest <a href="/pl/docs/Web/JavaScript/Language_Resources">ECMAScript</a>. Od roku 2012, wszystkie <a href="https://kangax.github.io/compat-table/es5/">nowoczesne przegladarki</a> całkowicie obsługują ECMAScript 5.1. Starsze przegladarki obsługują co najmniej ECMAScript 3. 17 czerwca 2015, <a href="https://www.ecma-international.org">ECMA International</a> opublikował szóstą główną wersję ECMAScript, która oficjalnie nazywa się ECMAScript 2015, ale początkowo była nazywana też ECMAScript 6 lub ES6. Od tego czasu standardy ECMAScript są wydawane w cyklach rocznych. Niniejszy dokument odnosi sie do szkicu najnowszej wersji, którą obecnie jest <a href="https://tc39.github.io/ecma262/">ECMAScript 2018</a>.</p> + +<p>Nie należy mylić JavaScript z <a href="https://pl.wikipedia.org/wiki/Java">językiem programowania Java</a>. Zarówno "Java" jak i "JavaScript" są znakami towarowymi lub zastrzeżonymi znakami towarowymi Oracle w U.S.A. i innych krajach. Jednak obydwa te języki programowania mają bardzo różną składnię, semantykę i zastosowanie.</p> + +<div class="column-container"> +<div class="column-half"> +<h2 id="Przewodniki">Przewodniki</h2> + +<p>Naucz się programować w JavaScript, studiując nasze przewodniki i samouczki.</p> + +<h3 id="Dla_zupełnie_początkujących">Dla zupełnie początkujących</h3> + +<p>Jeśli chcesz nauczyć się JavaScript, ale nie masz jeszcze doświadczenia w JavaScript lub programowaniu, przejdź do naszych <a href="/pl/docs/Learn/JavaScript">tematów w strefie nauki JavaScript</a>. Dostępne są tu następujące moduły:</p> + +<dl> + <dt><a href="/pl/docs/Learn/JavaScript/First_steps">Pierwsze kroki w JavaScript</a></dt> + <dd>Znajdziesz tu odpowiedź na kilka podstawowych pytań, takich jak: "Co to jest JavaScript?", "Jak wygląda?" czy "Co można z nim zrobić?", oraz omówienie kluczowych elementów JavaScript, takich jak zmienne, łańcuchy, liczby i tablice.</dd> +</dl> + +<p><strong><a href="/pl/docs/Learn/JavaScript/Building_blocks">Klocki JavaScript</a></strong><br> + Kontynuujemy tu opis podstawowych elementów JavaScript, zwracając uwagę na często stosowane typy bloków kodu, takie jak wyrażenia warunkowe, pętle, funkcje i zdarzenia.</p> + +<dl> + <dt><a href="/pl/docs/Learn/JavaScript/Objects">Wprowadzenie do obiektów JavaScript</a></dt> + <dd>W procesie nauki języka JavaScript ważne jest zrozumienie jego obiektowo zorientowanej natury. Ułatwi Ci to dalsze zgłębianie tajników tego języka i tworzenie bardziej efektywnego kodu w przyszłości. Ten moduł ma Ci w tym pomóc.</dd> +</dl> + +<p><a href="https://pl.khanacademy.org/computing/computer-programming/programming#intro-to-programming">Polecamy także kurs z khan academy</a> </p> + +<h3 id="Przewodnik_JavaScript">Przewodnik JavaScript</h3> + +<dl> + <dt><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide">Przewodnik JavaScript</a></dt> + <dd>Znacznie bardziej szczegółowy poradnik JavaScript, przeznaczony dla osób z wcześniejszym doświadczeniem programistycznym w innych jezykach.</dd> +</dl> + +<h3 id="Dla_średnozaawansowanych">Dla średnozaawansowanych</h3> + +<dl> + <dt><a href="/pl/docs/Learn/JavaScript/Client-side_web_APIs">Interfejsy API po stronie klienta</a></dt> + <dd>Jeśli chcesz pisać kod JavaScript dla stron internetowych lub aplikacji, działający po stronie klienta nie zajdziesz daleko, zanim nie zaczniesz używać odpowiednich interfejsów API — interfejsów do manipulowania róznymi funkcjami zarówno przeglądarki jak i systemu operacyjnego, w którym owa przeglądarka działa, a nawet manipulowania danymi pochodzącymi z innych witryn lub serwisów internetowych. W tym module dowiesz się, jakie są interfejsy API działające po stronie klienta i jak korzystać z najbardziej popularnych z nich. </dd> +</dl> + +<dl> + <dt><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/A_re-introduction_to_JavaScript">Ponowne wprowadzenie do JavaScript</a></dt> + <dd>Przegląd zagadnień związanych z JavaScript, przeznaczony dla tych, co już "wiedzą wszystko".</dd> +</dl> + +<dl> + <dt> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures">Struktura danych JavaScript</a></dt> + <dd>Przegląd dostępnych w JavaScript struktur danych.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Equality_comparisons_and_sameness">Porównanie a identyczność</a></dt> + <dd>JavaScript zapewnia trzy różne operacje porównywania wartości: ścisłą równość przy użyciu operatoa <code>===</code>, luźną równość przy uzyciu operatoa <code>== i metodę </code>{jsxref("Global_Objects/Object/is", "Object.is()")}}.</dd> + <dt><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Domkniecia">Domknięcia</a></dt> + <dd> + <p>Domknięcie jest kombinacją funkcji i środowiska leksykalnego, w którym ta funkcja została zadeklarowana.</p> + </dd> +</dl> + +<h3 id="Dla_zaawansowanych">Dla zaawansowanych</h3> + +<dl> + <dt><a href="/pl/docs/Web/JavaScript/Inheritance_and_the_prototype_chain">Dziedziczenie i łańcuch prototypowania</a></dt> + <dd>Wyjaśnienie powszechnie nierozumianego i niedocenianego dziedziczenia prototypowego.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Reference/Strict_mode">Tryb ścisły</a></dt> + <dd>Tryb ścisły powoduje, że nie jest możliwe użycie jakichkolwiek zmiennych przed ich inicjowaniem. Jest to ścisły wariant ECMAScript 5, zwiekszający wydajność i łatwość debugowania.</dd> + <dt><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Typed_arrays">Tablice typowane JavaScript</a></dt> + <dd>Tablice typowane JavaScript dostarczają mechanizm dostępu do surowych danych binarnych.</dd> + <dt><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Memory_Management">Zarządzanie pamięcią</a></dt> + <dd>Cykl życia pamięci i odśmiecanie kolekcji w JavaScript.</dd> + <dt><a href="/pl/docs/Web/JavaScript/EventLoop">Model współbieżności i pętla zdarzeń</a></dt> + <dd>JavaScript posiada model współbieżny oparty na "pętli zdarzeń".</dd> + <dt><a href="/pl/docs/Web/JavaScript/Introduction_to_using_XPath_in_JavaScript">Wprowadzenie do stosowania XPath w JavaScript</a></dt> + <dd>W tym dokumencie opisano interfejs przeznaczony do używania w JavaScript biblioteki <a href="/en-US/docs/XPath" title="en/XPath">XPath</a>, w rozszerzeniach i witrynach internetowych.</dd> +</dl> +</div> + +<div class="column-half"> +<h2 id="Informatory">Informatory</h2> + +<p>Przejrzyj kompletną dokumentację <a href="/en-US/docs/Web/JavaScript/Reference">informacyjną JavaScript </a>.</p> + +<dl> + <dt><a href="/pl/docs/Web/JavaScript/Reference/Global_Objects">Obiekty standardowe</a></dt> + <dd>Poznaj standardowe obiekty wbudowane {{jsxref("Array")}}, {{jsxref("Boolean")}}, {{jsxref("Date")}}, {{jsxref("Error")}}, {{jsxref("Function")}}, {{jsxref("JSON")}}, {{jsxref("Math")}}, {{jsxref("Number")}}, {{jsxref("Object")}}, {{jsxref("RegExp")}}, {{jsxref("String")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, {{jsxref("WeakMap")}}, {{jsxref("WeakSet")}} i inne</dd> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Operators">Wyrażenia i operatory</a></dt> + <dd>Dowiedz się więcej o zachowywaniu się operatorów JavaScript {{jsxref("Operators/instanceof", "instanceof")}}, {{jsxref("Operators/typeof", "typeof")}}, {{jsxref("Operators/new", "new")}}, {{jsxref("Operators/this", "this")}}, <a href="/pl/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">pierwszeństwo opertaorów</a> itd.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Reference/Statements">Instrukcje i deklaracje</a></dt> + <dd>Zapoznaj się jak działają {{jsxref("Statements/do...while", "do-while")}}, {{jsxref("Statements/for...in", "for-in")}}, {{jsxref("Statements/for...of", "for-of")}}, {{jsxref("Statements/try...catch", "try-catch")}}, {{jsxref("Statements/let", "let")}}, {{jsxref("Statements/var", "var")}}, {{jsxref("Statements/const", "const")}}, {{jsxref("Statements/if...else", "if-else")}}, {{jsxref("Statements/switch", "switch")}} i inne instrukcje i słowa kluczowe JavaScript.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Reference/Functions">Funkcje</a></dt> + <dd>Dowiedz się jak pracować z funkcjami JavaScript przy tworzeniu swoich aplikacji.</dd> +</dl> + +<h2 id="Narzędzia_i_zasoby">Narzędzia i zasoby</h2> + +<p>Przydatne narzędzia do pisania i debugowania kodu <strong>JavaScript</strong>.</p> + +<dl> + <dt><a href="/pl/docs/Tools">Narzędzia programistyczne Firefox</a></dt> + <dd><a href="/pl/docs/Tools/Scratchpad">Scratchpad</a>, <a href="/pl/docs/Tools/Web_Console">Web Console</a>, <a href="/pl/docs/Tools/Profiler">JavaScript Profiler</a>, <a href="/pl/docs/Tools/Debugger">Debugger</a> itd.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Shells">Powłoki JavaScript</a></dt> + <dd>Powłoka JavaScript (konsola linii poleceń) pozwala szybko przetestować fragmenty kodu JavaScript.</dd> + <dt><a href="https://togetherjs.com/">TogetherJS</a></dt> + <dd>Ułatwia współpracę. Dodając TogetherJS do swojej witryny, można wpomóc współpracę, poprzez wzajemną komunikację uzytkowników w czasie rzeczywistym.</dd> + <dt><a href="https://stackoverflow.com/questions/tagged/javascript">Stack Overflow</a></dt> + <dd>Zapytania oznaczone tagiem "JavaScript" na platformie Stack Overflow.</dd> + <dt><a href="/en-US/docs/Web/JavaScript/New_in_JavaScript">Wersje JavaScript i uwagi do wydań</a></dt> + <dd>Przeglądaj historię wydań JavaScript i stan implementacji.</dd> + <dt><a href="https://jsfiddle.net/">JSFiddle</a></dt> + <dd>Edytowanie JavaScript, CSS i HTML z natychmiastowym podglądem wyników. Pozwala na używanie zasobów zewnętrznych i pracę zespołową.</dd> + <dt><a href="/pl/docs/Web/JavaScript/JavaScript_templates">Szablony JavaScript</a></dt> + <dd>Na tej stronie omawia sie najpopularniejsze systemy szablonowania stosowane w JavaScript.</dd> + <dt><a href="https://plnkr.co/">Plunker</a></dt> + <dd>Plunker to internetowa społeczność, która współpacuje, tworzy i dzieli się pomysłami na tworzenie stron internetowych. Edytuj w przegladarce swoje pliki JavaScript, CSS i HTML i ogladaj na żywo wyniki swojej pracy i strukturę plików.</dd> +</dl> +</div> +</div> diff --git a/files/pl/web/javascript/na_początek/index.html b/files/pl/web/javascript/na_początek/index.html new file mode 100644 index 0000000000..44f95f6c62 --- /dev/null +++ b/files/pl/web/javascript/na_początek/index.html @@ -0,0 +1,903 @@ +--- +title: Na początek +slug: Web/JavaScript/Na_początek +tags: + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +--- +<div class="note"><strong>UWAGA, UWAGA!</strong>: Pomimo tego, że artykuł jest wywieszony jako artykuł do dopracowania, to mimo to, PROSZĘ go na razie <strong>NIE TŁUMACZYĆ</strong>. Powodem jest to, że tekst w sporej mierze jest już przetłumaczony. Więc po prostu szkoda zapału i zużywania energii na coś co już jest w wersji PL. W ramach tego samego czasu możecie przetłumaczyć coś, czego nie ma na 100% w dopracowanych. <a href="pl/Wikipedysta/Ptak82">Ptak82</a> 17:18, 13 mar 2007 (PDT)</div> + +<h3 id="Wprowadzenie" name="Wprowadzenie">Wprowadzenie</h3> + +<p>Dlaczego ponowne wprowadzenie? Bo <a href="pl/JavaScript">JavaScript</a> można śmiało określić jako <a class="external" href="http://javascript.crockford.com/javascript.html">najbardziej błędnie rozumiany język programowania (en)</a>. Często wyszydzany, nazywany zabawką, pod swoją kuszącą prostotą chowa on szerokie możliwości. W roku 2005 pojawił się szereg wysokiej jakości aplikacji w JavaScripcie, dowodzących, że pogłębiona znajomość tej technologii to to, czym powinien móc się pochwalić każdy twórca serwisów internetowych.</p> + +<p>Wygodnie będzie zacząć od kilku słów na temat historii języka. JavaScript stowrzył w roku 1995 Brendan Eich, programista firmy Netscape. Pierwszą przeglądarką z obsługą JavaScriptu była Netscape 2, wydana na początku 1996 r. Pierwotnie język ten miał się nazywać LiveScript, ale nazwę nieszczęśliwie zmieniono z przyczyn marketingowych - chciano skorzystać z popularności Javy, języka firmy Sun Microsystems, mimo że oba te języki niewiele ze sobą łączy. Nazwa "JavaScript" do dziś jest przyczyną wielu nieporozumień.</p> + +<p>Microsoft wydał prawie kompatybilną wersję tego języka pod nazwą JScript razem z przeglądarką Internet Explorer 3 kilka miesięcy później. Firma Netscape zgłosiła język do europejskiej organizacji standaryzacyjnej <a class="external" href="http://www.ecma-international.org/">Ecma International</a>, skutkiem czego było pierwsze wydanie standardu <a href="pl/ECMAScript">ECMAScript</a> w roku 1997. Specyfikację tę szeroko uzupełniono i rozbudowano w roku 1999 i opublikowano jako <a class="external" href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMAScript wydanie 3</a> i od tej pory język ten był w miarę stabilny, nie przechodził większych rewolucji, choć obecnie trwają prace nad wydaniem czwartym.</p> + +<p>Stabilność ta to dobra wiadomość dla programistów, jako że wszystkie implementacje miały wiele czasu, by w pełni dojść do w miarę zgodnego stanu. W tym artykule skupiam się wyłącznie na dialekcie z wydania trzeciego. Dla uproszczenia pozostanę w tym artykule przy terminie "JavaScript".</p> + +<p>W przeciwieństwie do większości języków, JavaScript nie posiada koncepcji wejścia/wyjścia. Zaprojektowany został jako język skryptowy dla maszyny wirtualnej i to ta maszyna wirtualna ma za zadanie zapewnić mechanizmy komunikacji ze światem zewnętrznym. Najbardziej popularną maszyną wirtualną jest przeglądarka, ale interpretery JavaScriptu można znaleźć np. w programach Adobe Acrobat, Photoshop, silniku Yahoo! Widget i innych.</p> + +<h3 id="Przegl.C4.85d" name="Przegl.C4.85d">Przegląd</h3> + +<p>Zacznijmy od fundamentów każdego języka programowania: typów danych. Programy w JavaScripcie manipulują wartościami, z których każda należy do konkretnego typu. Typy w JavaScripcie to:</p> + +<ul> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Number">Number</a> - liczby</li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String">String</a> - ciągi znaków (teksty)</li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Boolean">Boolean</a> - wartości logiczne</li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a> - funkcje</li> + <li><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Object">Object</a> - obiekty</li> +</ul> + +<p>a także Undefined (wartość niezdefiniowana) i Null, które można uważać za nieco dziwne. Ponadto mamy do dyspozycji tablice - <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array">Array</a> - które są szczególnym rodzajem obiektu. Oprócz tego daty - <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date">Date</a> i <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/RegExp">wyrażenia regularne</a>, które także są obiektami. Gwoli ścisłości, funkcje także są szczególnymi obiektami.</p> + +<p>Diagram typów wygląda zatem następująco:</p> + +<ul> + <li>Number</li> + <li>String</li> + <li>Boolean</li> + <li>Object + <ul> + <li>Function</li> + <li>Array</li> + <li>Date</li> + <li>RegExp</li> + </ul> + </li> + <li>Null</li> + <li>Undefined</li> +</ul> + +<p>Istnieją także podtypy typu <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Error">Error</a>, ale pomińmy je, żeby za bardzo nie mieszać i pozostańmy przy pierwszym diagramie.</p> + +<h3 id="Liczby" name="Liczby">Liczby</h3> + +<p>Zgodnie ze specyfikacją, liczby w JavaScripcie są "64-bitowymi wartościami podwójnej precyzji w formacie IEEE 754". Ma to ciekawe skutki. Na przykład, w JavaScripcie nie ma czegoś takiego jak liczba całkowita, dlatego trzeba zachować nieco ostrożności przy operacjach arytmetycznych, zwłaszcza jeśli przyzwyczajeni jesteśmy do C lub Javy. Należy uważać na takie sytuacje:</p> + +<pre class="eval">0.1 + 0.2 = 0.30000000000000004 +</pre> + +<p>Dostępne są standardowe <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_arytmetyczne">operatory arytmetyczne</a>, w tym oczywiście dodawanie, odejmowanie, modulo (reszta z dzielenia) itd. Jest także specjalny obiekt <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Math">Math</a> pozwalający na stosowanie bardziej zaawansowanych funkcji i stałych matematycznych:</p> + +<pre class="eval">Math.sin(3.5); +d = Math.PI * r * r; +</pre> + +<p>Ciąg znaków można skonwertować do liczby korzystając z wbudowanej funkcji <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/parseInt">parseInt()</a></code>. Funkcja ta może posiadać dodatkowy, drugi argument, który określa podstawę systemu dla tej konwersji. Ten argument warto jednak zawsze podawać:</p> + +<pre class="eval">> parseInt("123", 10) +123 +> parseInt("010", 10) +10 +</pre> + +<p>...żeby nie dostać nieoczekiwanych wyników:</p> + +<pre class="eval">> parseInt("010") +8 +</pre> + +<p>Taki wynik otrzymaliśmy dlatego, że funkcja <code>parseInt</code> uznała liczbę w naszym ciągu znaków za ósemkową, bo rozpoczęliśmy ją od znaku "0".</p> + +<p>Jeśli chcesz skonwertować liczbę binarną do dziesiętnej, wystarczy zmienić podstawę:</p> + +<pre class="eval">> parseInt("11", 2) +3 +</pre> + +<p>Funkcja zwraca specjalną wartość <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/W%c5%82asno%c5%9bci/NaN">NaN</a></code> (skrót ang. "Not a Number" - "To nie jest liczba"), jeśli dany ciąg znaków nie jest liczbą:</p> + +<pre class="eval">> parseInt("witaj", 10) +NaN +</pre> + +<p><code>NaN</code> jest toksyczna: wprowadzenie jej do jakiejkolwiek operacji matematycznej spowoduje, że jej wynikiem również będzie <code>NaN</code>:</p> + +<pre class="eval">> NaN + 5 +NaN +</pre> + +<p>Aby sprawdzić, czy dana wartość jest <code>NaN</code>, można użyć wbudowanej funkcji <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/isNaN">isNaN()</a></code>:</p> + +<pre class="eval">> isNaN(NaN) +true +</pre> + +<p>(NaN nie jest bowiem równe nawet samo sobie, <code>NaN!=NaN</code> - przyp. tłum.)</p> + +<p>W JavaScripcie istnieją także specjalne wartości reprezentujące plus i minus nieskończoność: <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/W%c5%82asno%c5%9bci/Infinity">Infinity</a></code> and <code>-Infinity</code>:</p> + +<pre class="eval">> 1 / 0 +Infinity +> -1 / 0 +-Infinity +</pre> + +<h3 id="Ci.C4.85gi_znak.C3.B3w" name="Ci.C4.85gi_znak.C3.B3w">Ciągi znaków</h3> + +<p>Teksty w JavaScripcie to sekwencje znaków. Dokładniej rzecz biorąc, są to sekwencje <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Unicode">znaków Unicode</a>, w których każdy znak reprezentowany jest przez liczbę 16-bitową. To dobra wiadomość dla wszystkich osób zajmujących się internacjonalizacją.</p> + +<p>Jeśli zajdzie potrzeba reprezentowania pojedynczego znaku, stosuje się po prostu ciąg o długości równej 1.</p> + +<p>Aby odnaleźć długość ciągu, należy skorzystać z jego własności <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String/length">length</a></code>:</p> + +<pre class="eval">> "witaj".length +5 +</pre> + +<p>To nasze pierwsze spotkanie z obiektami JavaScriptu! Czy wspomniałem, że ciągi są też obiektami? Naturalnie, mają też <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/String#Metody">metody</a>:</p> + +<pre class="eval">> "witaj".charAt(0) +w +> "witaj, świecie".replace("witaj", "do zobaczenia") +do zobaczenia, świecie +> "witaj".toUpperCase() +WITAJ +</pre> + +<h3 id="Other_types" name="Other_types">Other types</h3> + +<p>JavaScript distinguishes between <code>null</code>, which is an object of type 'object' that indicates a deliberate non-value, and <code>undefined</code>, which is an object of type 'undefined' that indicates an uninitialized value — that is, a value hasn't even been assigned yet. We'll talk about variables later, but in JavaScript it is possible to declare a variable without assigning a value to it. If you do this, the variable's type is <code>undefined</code>.</p> + +<p>JavaScript has a boolean type, with possible values <code>true</code> and <code>false</code> (both of which are keywords). Any value can be converted to a boolean according to the following rules:</p> + +<ol> + <li><code>false</code>, <code>0</code>, the empty string (<code>""</code>), <code>NaN</code>, <code>null</code>, and <code>undefined</code> all become <code>false</code></li> + <li>all other values become <code>true</code></li> +</ol> + +<p>You can perform this conversion explicitly using the <code>Boolean()</code> function:</p> + +<pre class="eval">> Boolean("") +false +> Boolean(234) +true +</pre> + +<p>However, this is rarely necessary, as JavaScript will silently perform this conversion when it expects a boolean, such as in an <code>if</code> statement (see below). For this reason, we sometimes speak simply of "true values" and "false values," meaning values that become <code>true</code> and <code>false</code>, respectively, when converted to booleans. Alternatively, such values can be called "truthy" and "falsy," respectively.</p> + +<p>Boolean operations such as <code>&&</code> (logical<em>and</em>), <code>||</code> (logical<em>or</em>), and <code>!</code> (logical<em>not</em>) are supported; see below.</p> + +<h3 id="Variables" name="Variables">Variables</h3> + +<p>New variables in JavaScript are declared using the <code><a href="pl/Core_JavaScript_1.5_Reference/Statements/var">var</a></code> keyword:</p> + +<pre class="eval">var a; +var name = "simon"; +</pre> + +<p>If you declare a variable without assigning any value to it, its type is <code>undefined</code>. <span class="comment">should note the absence of block-scoping in JS</span></p> + +<h3 id="Operators" name="Operators">Operators</h3> + +<p>JavaScript's numeric operators are <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code> and <code>%</code> - which is the remainder operator. Values are assigned using <code>=</code>, and there are also compound assignment statements such as <code>+=</code> and <code>-=</code>. These extend out to <code>x = x<em>operator</em> y</code>.</p> + +<pre class="eval">x += 5 +x = x + 5 +</pre> + +<p>You can use <code>++</code> and <code>--</code> to increment and decrement respectively. These can be used as prefix or postfix operators.</p> + +<p>The <a href="pl/Core_JavaScript_1.5_Reference/Operators/String_Operators"><code>+</code> operator</a> also does string concatenation:</p> + +<pre class="eval">> "hello" + " world" +hello world +</pre> + +<p>If you add a string to a number (or other value) everything is converted in to a string first. This might catch you out:</p> + +<pre class="eval">> "3" + 4 + 5 +345 +> 3 + 4 + "5" +75 +</pre> + +<p>Adding an empty string to something is a useful way of converting it.</p> + +<p><a href="pl/Core_JavaScript_1.5_Reference/Operators/Comparison_Operators">Comparisons</a> in JavaScript can be made using <code><</code>, <code>></code>, <code><=</code> and <code>>=</code>. These work for both strings and numbers. Equality is a little less straightforward. The double-equals operator performs type coercion if you give it different types, with sometimes interesting results:</p> + +<pre class="eval">> "dog" == "dog" +true +> 1 == true +true +</pre> + +<p>To avoid type coercion, use the triple-equals operator:</p> + +<pre class="eval">> 1 === true +false +> true === true +true +</pre> + +<p>There are also <code>!=</code> and <code>!==</code> operators.</p> + +<p>JavaScript also has <a href="pl/Core_JavaScript_1.5_Reference/Operators/Bitwise_Operators">bitwise operations</a>. If you want to use them, they're there.</p> + +<h3 id="Control_structures" name="Control_structures">Control structures</h3> + +<p>JavaScript has a similar set of control structures to other languages in the C family. Conditional statements are supported by <code>if</code> and <code>else</code>; you can chain them together if you like:</p> + +<pre class="eval">var name = "kittens"; +if (name == "puppies") { + name += "!"; +} else if (name == "kittens") { + name += "!!"; +} else { + name = "!" + name; +} +name == "kittens!!" +</pre> + +<p>JavaScript has <code>while</code> loops and <code>do-while</code> loops. The first is good for basic looping; the second for loops where you wish to ensure that the body of the loop is executed at least once:</p> + +<pre class="eval">while (true) { + // an infinite loop! +} + +do { + var input = get_input(); +} while (inputIsNotValid(input)) +</pre> + +<p>JavaScript's <code>for</code> loop is the same as that in C and Java: it lets you provide the control information for your loop on a single line.</p> + +<pre class="eval">for (var i = 0; i < 5; i++) { + // Will execute 5 times +} +</pre> + +<p>The <code>&&</code> and <code>||</code> operators use short-circuit logic, which means whether they will execute their second operand is dependent on the first. This is useful for checking for null objects before accessing their attributes:</p> + +<pre class="eval">var name = o && o.getName(); +</pre> + +<p>Or for setting default values:</p> + +<pre class="eval">var name = otherName || "default"; +</pre> + +<p>JavaScript has a tertiary operator for one-line conditional statements:</p> + +<pre class="eval">var allowed = (age > 18) ? "yes" : "no"; +</pre> + +<p>The switch statement can be used for multiple branches based on a number or string:</p> + +<pre class="eval">switch(action) { + case 'draw': + drawit(); + break; + case 'eat': + eatit(); + break; + default: + donothing(); +} +</pre> + +<p>If you don't add a <code>break</code> statement, execution will "fall through" to the next level. This is very rarely what you want - in fact it's worth specifically labelling deliberate fallthrough with a comment if you really meant it to aid debugging:</p> + +<pre class="eval">switch(a) { + case 1: // fallthrough + case 2: + eatit(); + break; + default: + donothing(); +} +</pre> + +<p>The default clause is optional. You can have expressions in both the switch part and the cases if you like; comparisons take place between the two using the <code>===</code> operator:</p> + +<pre class="eval">switch(1 + 3): + case 2 + 2: + yay(); + break; + default: + neverhappens(); +} +</pre> + +<h3 id="Objects" name="Objects">Objects</h3> + +<p>JavaScript objects are simply collections of name-value pairs. As such, they are similar to:</p> + +<ul> + <li>Dictionaries in Python</li> + <li>Hashes in Perl and Ruby</li> + <li>Hash tables in C and C++</li> + <li>HashMaps in Java</li> + <li>Associative arrays in PHP</li> +</ul> + +<p>The fact that this data structure is so widely used is a testament to its versatility. Since everything (bar core types) in JavaScript is an object, any JavaScript program naturally involves a great deal of hash table lookups. It's a good thing they're so fast!</p> + +<p>The "name" part is a JavaScript string, while the value can be any JavaScript value - including more objects. This allows you to build data structures of arbitrary complexity.</p> + +<p>There are two basic ways to create an empty object:</p> + +<pre class="eval">var obj = new Object(); +</pre> + +<p>And:</p> + +<pre class="eval">var obj = {}; +</pre> + +<p>These are semantically equivalent; the second is called object literal syntax, and is more convenient. Object literal syntax was not present in very early versions of the language which is why you see so much code using the old method.</p> + +<p>Once created, an object's properties can again be accessed in one of two ways:</p> + +<pre class="eval">obj.name = "Simon" +var name = obj.name; +</pre> + +<p>And...</p> + +<pre class="eval">obj["name"] = "Simon"; +var name = obj["name"]; +</pre> + +<p>These are also semantically equivalent. The second method has the advantage that the name of the property is provided as a string, which means it can be calculated at run-time. It can also be used to set and get properties with names that are <a href="pl/Core_JavaScript_1.5_Reference/Reserved_Words">reserved words</a>:</p> + +<pre class="eval">obj.for = "Simon"; // Syntax error, because 'for' is a reserved word +obj["for"] = "Simon"; // works fine +</pre> + +<p>Object literal syntax can be used to initialise an object in its entirety:</p> + +<pre class="eval">var obj = { + name: "Carrot", + "for": "Max", + details: { + color: "orange", + size: 12 + } +} +</pre> + +<p>Attribute access can be chained together:</p> + +<pre class="eval">> obj.details.color +orange +> obj["details"]["size"] +12 +</pre> + +<h3 id="Arrays" name="Arrays">Arrays</h3> + +<p>Arrays in JavaScript are actually a special type of object. They work very much like regular objects (numerical properties can naturally be accessed only using [] syntax) but they have one magic property called '<code>length</code>'. This is always one more than the highest index in the array.</p> + +<p>The old way of creating arrays is as follows:</p> + +<pre class="eval">> var a = new Array(); +> a[0] = "dog"; +> a[1] = "cat"; +> a[2] = "hen"; +> a.length +3 +</pre> + +<p>A more convenient notation is to use an array literal:</p> + +<pre class="eval">> var a = ["dog", "cat", "hen"]; +> a.length +3 +</pre> + +<p>Leaving a trailing comma at the end of an array literal is inconsistent across browsers, so don't do it.</p> + +<p>Note that <code>array.length</code> isn't necessarily the number of items in the array. Consider the following:</p> + +<pre class="eval">> var a = ["dog", "cat", "hen"]; +> a[100] = "fox"; +> a.length +101 +</pre> + +<p>Remember - the length of the array is one more than the highest index.</p> + +<p>If you query a non-existent array index, you get <code>undefined</code>:</p> + +<pre class="eval">> typeof(a[90]) +undefined +</pre> + +<p>If you take the above into account, you can iterate over an array using the following:</p> + +<pre class="eval">for (var i = 0; i < a.length; i++) { + // Do something with a[i] +} +</pre> + +<p>This is slightly inefficient as you are looking up the length property once every loop. An improvement is this:</p> + +<pre class="eval">for (var i = 0, len = a.length; i < len; i++) { + // Do something with a[i] +} +</pre> + +<p>An even nicer idiom is:</p> + +<pre class="eval">for (var i = 0, item; item = a[i]; i++) { + // Do something with item +} +</pre> + +<p>Here we are setting up two variables. The assignment in the middle part of the <code>for</code> loop is also tested for truthfulness - if it succeeds, the loop continues. Since <code>i</code> is incremented each time, items from the array will be assigned to item in sequential order. The loop stops when a "falsy" item is found (such as <code>undefined</code>).</p> + +<p>Note that this trick should only be used for arrays which you know do not contain "falsy" values (arrays of objects or <a href="pl/DOM">DOM</a> nodes for example). If you are iterating over numeric data that might include a 0 or string data that might include the empty string you should use the <code>i, j</code> idiom instead.</p> + +<p>Another way to iterate is to use the <code><a href="pl/Core_JavaScript_1.5_Reference/Statements/for...in">for...in</a></code> loop. Note that if someone added new properties to <code>Array.prototype</code>, they will also be iterated over by this loop:</p> + +<pre class="eval">for (var i in a) { + // Do something with a[i] +} +</pre> + +<p>If you want to append an item to an array, the safest way to do it is like this:</p> + +<pre class="eval">a[a.length] = item; // same as a.push(item); +</pre> + +<p>Since <code>a.length</code> is one more than the highest index, you can be assured that you are assigning to an empty position at the end of the array.</p> + +<p>Arrays come with a number of methods:</p> + +<pre class="eval">a.toString(), a.toLocaleString(), a.concat(item, ..), a.join(sep), +a.pop(), a.push(item, ..), a.reverse(), a.shift(), a.slice(start, end), +a.sort(cmpfn), a.splice(start, delcount, [item]..), a.unshift([item]..) +</pre> + +<ul> + <li><code>concat</code> returns a new array with the items added on to it.</li> + <li><code>pop</code> removes and returns the last item</li> + <li><code>push</code> adds one or more items to the end (like our <code>ar{{ mediawiki.external('ar.length') }}</code> idiom)</li> + <li><code>slice</code> returns a sub-array</li> + <li><code>sort</code> takes an optional comparison function</li> + <li><code>splice</code> lets you modify an array by deleting a section and replacing it with more items</li> + <li><code>unshift</code> prepends items to the start of the array</li> +</ul> + +<h3 id="Functions" name="Functions">Functions</h3> + +<p>Along with objects, functions are the core component in understanding JavaScript. The most basic function couldn't be much simpler:</p> + +<pre class="eval">function add(x, y) { + var total = x + y; + return total; +} +</pre> + +<p>This demonstrates everything there is to know about basic functions. A JavaScript function can take 0 or more named parameters. The function body can contain as many statements as you like, and can declare its own variables which are local to that function. The <code>return</code> statement can be used to return a value at any time, terminating the function. If no return statement is used (or an empty return with no value), JavaScript returns <code>undefined</code>.</p> + +<p>The named parameters turn out to be more like guidelines than anything else. You can call a function without passing the parameters it expects, in which case they will be set to <code>undefined</code>.</p> + +<pre class="eval">> add() +NaN // You can't perform addition on undefined +</pre> + +<p>You can also pass in more arguments than the function is expecting:</p> + +<pre class="eval">> add(2, 3, 4) +5 // added the first two; 4 was ignored +</pre> + +<p>That may seem a little silly, but functions have access to an additional variable inside their body called <a href="pl/Core_JavaScript_1.5_Reference/Functions/arguments"><code>arguments</code></a>, which is an array-like object holding all of the values passed to the function. Let's re-write the add function to take as many values as we want:</p> + +<pre class="eval">function add() { + var sum = 0; + for (var i = 0, j = arguments.length; i < j; i++) { + sum += arguments[i]; + } + return sum; +} + +> add(2, 3, 4, 5) +14 +</pre> + +<p>That's really not any more useful than writing <code>2 + 3 + 4 + 5</code> though. Let's create an averaging function:</p> + +<pre class="eval">function avg() { + var sum = 0; + for (var i = 0, j = arguments.length; i < j; i++) { + sum += arguments[i]; + } + return sum / arguments.length; +} +> avg(2, 3, 4, 5) +3.5 +</pre> + +<p>This is pretty useful, but introduces a new problem. The <code>avg()</code> function takes a comma separated list of arguments - but what if you want to find the average of an array? You could just rewrite the function as follows:</p> + +<pre class="eval">function avgArray(arr) { + var sum = 0; + for (var i = 0, j = arr.length; i < j; i++) { + sum += arr[i]; + } + return sum / arr.length; +} +> avgArray([2, 3, 4, 5]) +3.5 +</pre> + +<p>But it would be nice to be able to reuse the function that we've already created. Luckily, JavaScript lets you call a function and call it with an arbitrary array of arguments, using the <a href="pl/Core_JavaScript_1.5_Reference/Global_Objects/Function/apply"><code>apply()</code></a> method of any function object.</p> + +<pre class="eval">> avg.apply(null, [2, 3, 4, 5]) +3.5 +</pre> + +<p>The second argument to <code>apply()</code> is the array to use as arguments; the first will be discussed later on. This emphasizes the fact that functions are objects too.</p> + +<p>JavaScript lets you create anonymous functions.</p> + +<pre class="eval">var avg = function() { + var sum = 0; + for (var i = 0, j = arguments.length; i < j; i++) { + sum += arguments[i]; + } + return sum / arguments.length; +} +</pre> + +<p>This is semantically equivalent to the <code>function avg()</code> form. It's extremely powerful, as it lets you put a full function definition anywhere that you would normally put an expression. This enables all sorts of clever tricks. Here's a way of "hiding" some local variables - like block scope in C:</p> + +<pre class="eval">> var a = 1; +> var b = 2; +> (function() { + var b = 3; + a += b; +})(); +> a +4 +> b +2 +</pre> + +<p>JavaScript allows you to call functions recursively. This is particularly useful for dealing with tree structures, such as you get in the browser <a href="pl/DOM">DOM</a>.</p> + +<pre class="eval">function countChars(elm) { + if (elm.nodeType == 3) { // TEXT_NODE + return elm.nodeValue.length; + } + var count = 0; + for (var i = 0, child; child = elm.childNodes[i]; i++) { + count += countChars(child); + } + return count; +} +</pre> + +<p>This highlights a potential problem with anonymous functions: how do you call them recursively if they don't have a name? The answer lies with the <code>arguments</code> object, which in addition to acting as a list of arguments also provides a property called <code>arguments.callee</code>. This always refers to the current function, and hence can be used to make recursive calls:</p> + +<pre class="eval">var charsInBody = (function(elm) { + if (elm.nodeType == 3) { // TEXT_NODE + return elm.nodeValue.length; + } + var count = 0; + for (var i = 0, child; child = elm.childNodes[i]; i++) { + count += arguments.callee(child); + } + return count; +})(document.body); +</pre> + +<p>Since <code>arguments.callee</code> is the current function, and all functions are objects, you can use <code>arguments.callee</code> to save information across multiple calls to the same function. Here's a function that remembers how many times it has been called:</p> + +<pre class="eval">function counter() { + if (!arguments.callee.count) { + arguments.callee.count = 0; + } + return arguments.callee.count++; +} + +> counter() +0 +> counter() +1 +> counter() +2 +</pre> + +<h3 id="Custom_objects" name="Custom_objects">Custom objects</h3> + +<p>In classic Object Oriented Programming, objects are collections of data and methods that operate on that data. Let's consider a person object with first and last name fields. There are two ways in which their name might be displayed: as "first last" or as "last, first". Using the functions and objects that we've discussed previously, here's one way of doing it:</p> + +<pre class="eval">function makePerson(first, last) { + return { + first: first, + last: last + } +} +function personFullName(person) { + return person.first + ' ' + person.last; +} +function personFullNameReversed(person) { + return person.last + ', ' + person.first +} +> s = makePerson("Simon", "Willison"); +> personFullName(s) +Simon Willison +> personFullNameReversed(s) +Willison, Simon +</pre> + +<p>This works, but it's pretty ugly. You end up with dozens of functions in your global namespace. What we really need is a way to attach a function to an object. Since functions are objects, this is easy:</p> + +<pre class="eval">function makePerson(first, last) { + return { + first: first, + last: last, + fullName: function() { + return this.first + ' ' + this.last; + }, + fullNameReversed: function() { + return this.last + ', ' + this.first; + } + } +} +> s = makePerson("Simon", "Willison") +> s.fullName() +Simon Willison +> s.fullNameReversed() +Willison, Simon +</pre> + +<p>There's something here we haven't seen before: the '<code><a href="pl/Core_JavaScript_1.5_Reference/Operators/Special_Operators/this_Operator">this</a></code>' keyword. Used inside a function, '<code>this</code>' refers to the current object. What that actually means is specified by the way in which you called that function. If you called it using <a href="pl/Core_JavaScript_1.5_Reference/Operators/Member_Operators">dot notation or bracket notation</a> on an object, that object becomes '<code>this</code>'. If dot notation wasn't used for the call, '<code>this</code>' refers to the global object. This is a frequent cause of mistakes. For example:</p> + +<pre class="eval">> s = makePerson("Simon", "Willison") +> var fullName = s.fullName; +> fullName() +undefined undefined +</pre> + +<p>When we call <code>fullName()</code>, '<code>this</code>' is bound to the global object. Since there are no global variables called <code>first</code> or <code>last</code> we get <code>undefined</code> for each one.</p> + +<p>We can take advantage of the '<code>this</code>' keyword to improve our <code>makePerson</code> function:</p> + +<pre class="eval">function Person(first, last) { + this.first = first; + this.last = last; + this.fullName = function() { + return this.first + ' ' + this.last; + } + this.fullNameReversed = function() { + return this.last + ', ' + this.first; + } +} +var s = new Person("Simon", "Willison"); +</pre> + +<p>We've introduced another keyword: '<code><a href="pl/Core_JavaScript_1.5_Reference/Operators/Special_Operators/new_Operator">new</a></code>'. <code>new</code> is strongly related to '<code>this</code>'. What it does is it creates a brand new empty object, and then calls the function specified, with '<code>this</code>' set to that new object. Functions that are designed to be called by '<code>new</code>' are called constructor functions. Common practise is to capitalise these functions as a reminder to call them with <code>new</code>.</p> + +<p>Our person objects are getting better, but there are still some ugly edges to them. Every time we create a person object we are creating two brand new function objects within it - wouldn't it be better if this code was shared?</p> + +<pre class="eval">function personFullName() { + return this.first + ' ' + this.last; +} +function personFullNameReversed() { + return this.last + ', ' + this.first; +} +function Person(first, last) { + this.first = first; + this.last = last; + this.fullName = personFullName; + this.fullNameReversed = personFullNameReversed; +} +</pre> + +<p>That's better: we are creating the method functions only once, and assigning references to them inside the constructor. Can we do any better than that? The answer is yes:</p> + +<pre class="eval">function Person(first, last) { + this.first = first; + this.last = last; +} +Person.prototype.fullName = function() { + return this.first + ' ' + this.last; +} +Person.prototype.fullNameReversed = function() { + return this.last + ', ' + this.first; +} +</pre> + +<p><code>Person.prototype</code> is an object shared by all instances of <code>Person</code>. It forms part of a lookup chain (that has a special name, "prototype chain"): any time you attempt to access a property of <code>Person</code> that isn't set, JavaScript will check <code>Person.prototype</code> to see if that property exists there instead. As a result, anything assigned to <code>Person.prototype</code> becomes available to all instances of that constructor via the <code>this</code> object.</p> + +<p>This is an incredibly powerful tool. JavaScript lets you modify something's prototype at any time in your program, which means you can add extra methods to existing objects at runtime:</p> + +<pre class="eval">> s = new Person("Simon", "Willison"); +> s.firstNameCaps(); +TypeError on line 1: s.firstNameCaps is not a function +> Person.prototype.firstNameCaps = function() { + return this.first.toUpperCase() +} +> s.firstNameCaps() +SIMON +</pre> + +<p>Interestingly, you can also add things to the prototype of built-in JavaScript objects. Let's add a method to <code>String</code> that returns that string in reverse:</p> + +<pre class="eval">> var s = "Simon"; +> s.reversed() +TypeError on line 1: s.reversed is not a function +> String.prototype.reversed = function() { + var r = ""; + for (var i = this.length - 1; i >= 0; i--) { + r += this[i]; + } + return r; +} +> s.reversed() +nomiS +</pre> + +<p>Our new method even works on string literals!</p> + +<pre class="eval">> "This can now be reversed".reversed() +desrever eb won nac sihT +</pre> + +<p>As I mentioned before, the prototype forms part of a chain. The root of that chain is <code>Object.prototype</code>, whose methods include <code>toString()</code> - it is this method that is called when you try to represent an object as a string. This is useful for debugging our <code>Person</code> objects:</p> + +<pre class="eval">> var s = new Person("Simon", "Willison"); +> s +[object Object] +> Person.prototype.toString = function() { + return '<Person: ' + this.fullName() + '>'; +} +> s +<Person: Simon Willison> +</pre> + +<p>Remember how <code>avg.apply()</code> had a null first argument? We can revisit that now. The first argument to <code>apply()</code> is the object that should be treated as '<code>this</code>'. For example, here's a trivial implementation of '<code>new</code>':</p> + +<pre class="eval">function trivialNew(constructor) { + var o = {}; // Create an object + constructor.apply(o, arguments); + return o; +} +</pre> + +<p>This isn't an exact replica of <code>new</code> as it doesn't set up the prototype chain. <code>apply()</code> is difficult to illustrate - it's not something you use very often, but it's useful to know about.</p> + +<p><code>apply()</code> has a sister function named <a href="pl/Core_JavaScript_1.5_Reference/Global_Objects/Function/call"><code>call</code></a>, which again lets you set '<code>this</code>' but takes an expanded argument list as opposed to an array.</p> + +<pre class="eval">function lastNameCaps() { + return this.last.toUpperCase(); +} +var s = new Person("Simon", "Willison"); +lastNameCaps.call(s); +// Is the same as: +s.lastNameCaps = lastNameCaps; +s.lastNameCaps(); +</pre> + +<h3 id="Inner_functions" name="Inner_functions">Inner functions</h3> + +<p>JavaScript function declarations are allowed inside other functions. We've seen this once before, with an earlier <code>makePerson()</code> function. An important detail of nested functions in JavaScript is that they can access variables in their parent function's scope:</p> + +<pre class="eval">function betterExampleNeeded() { + var a = 1; + function oneMoreThanA() { + return a + 1; + } + return oneMoreThanA(); +} +</pre> + +<p>This provides a great deal of utility in writing more maintainable code. If a function relies on one or two other functions that are not useful to any other part of your code, you can nest those utility functions inside the function that will be called from elsewhere. This keeps the number of functions that are in the global scope down, which is always a good thing.</p> + +<p>This is also a great counter to the lure of global variables. When writing complex code it is often tempting to use global variables to share values between multiple functions - which leads to code that is hard to maintain. Nested functions can share variables in their parent, so you can use that mechanism to couple functions together when it makes sense without polluting your global namespace - 'local globals' if you like. This technique should be used with caution, but it's a useful ability to have.</p> + +<h3 id="Closures" name="Closures">Closures</h3> + +<p>This leads us to one of the most powerful abstractions that JavaScript has to offer - but also the most potentially confusing. What does this do?</p> + +<pre class="eval">function makeAdder(a) { + return function(b) { + return a + b; + } +} +x = makeAdder(5); +y = makeAdder(20); +x(6) +? +y(7) +? +</pre> + +<p>The name of the <code>makeAdder</code> function should give it away: it creates new 'adder' functions, which when called with one argument add it to the argument that they were created with.</p> + +<p>What's happening here is pretty much the same as was happening with the inner functions earlier on: a function defined inside another function has access to the outer function's variables. The only difference here is that the outer function has returned, and hence common sense would seem to dictate that its local variables no longer exist. But they<em>do</em> still exist - otherwise the adder functions would be unable to work. What's more, there are two different "copies" of <code>makeAdder</code>'s local variables - one in which <code>a</code> is 5 and one in which <code>a</code> is 20.</p> + +<p>Here's what's actually happening. Whenever JavaScript executes a function, a 'scope' object is created to hold the local variables created within that function. It is initialised with any variables passed in as function parameters. This is similar to the global object that all global variables and functions live in, but with a couple of important differences: firstly, a brand new scope object is created every time a function starts executing, and secondly, unlike the global object (which in browsers is accessible as window) these scope objects cannot be directly accessed from your JavaScript code. There is no mechanism for iterating over the properties of the current scope object for example.</p> + +<p>So when <code>makeAdder</code> is called, a scope object is created with one property: <code>a</code>, which is the argument passed to the <code>makeAdder</code> function. <code>makeAdder</code> then returns a newly created function. Normally JavaScript's garbage collector would clean up the scope object created for <code>makeAdder</code> at this point, but the returned function maintains a reference back to that scope object. As a result, the scope object will not be garbage collected until there are no more references to the function object that <code>makeAdder</code> returned.</p> + +<p>Scope objects form a chain called the scope chain, similar to the prototype chain used by JavaScript's object system.</p> + +<p>A closure is the combination of a function and the scope object in which it was created.</p> + +<p>Closures let you save state - as such, they can often be used in place of objects.</p> + +<h3 id="Memory_leaks" name="Memory_leaks">Memory leaks</h3> + +<p>An unfortunate side effect of closures is that they make it trivially easy to leak memory in Internet Explorer. JavaScript is a garbage collected language - objects are allocated memory upon their creation and that memory is reclaimed by the browser when no references to an object remain. Objects provided by the host environment are handled by that environment.</p> + +<p>Browser hosts need to manage a large number of objects representing the HTML page being presented - the objects of the <a href="pl/DOM">DOM</a>. It is up to the browser to manage the allocation and recovery of these.</p> + +<p>Internet Explorer uses its own garbage collection scheme for this, separate from the mechanism used by JavaScript. It is the interaction between the two that can cause memory leaks.</p> + +<p>A memory leak in IE occurs any time a circular reference is formed between a JavaScript object and a native object. Consider the following:</p> + +<pre class="eval">function leakMemory() { + var el = document.getElementById('el'); + var o = { 'el': el }; + el.o = o; +} +</pre> + +<p>The circular reference formed above creates a memory leak; IE will not free the memory used by <code>el</code> and <code>o</code> until the browser is completely restarted.</p> + +<p>The above case is likely to go unnoticed; memory leaks only become a real concern in long running applications or applications that leak large amounts of memory due to large data structures or leak patterns within loops.</p> + +<p>Leaks are rarely this obvious - often the leaked data structure can have many layers of references, obscuring the circular reference.</p> + +<p>Closures make it easy to create a memory leak without meaning to. Consider this:</p> + +<pre class="eval">function addHandler() { + var el = document.getElementById('el'); + el.onclick = function() { + this.style.backgroundColor = 'red'; + } +} +</pre> + +<p>The above code sets up the element to turn red when it is clicked. It also creates a memory leak. Why? Because the reference to <code>el</code> is inadvertently caught in the closure created for the anonymous inner function. This creates a circular reference between a JavaScript object (the function) and a native object (<code>el</code>).</p> + +<p>There are a number of workarounds for this problem. The simplest is this:</p> + +<pre class="eval">function addHandler() { + var el = document.getElementById('el'); + el.onclick = function() { + this.style.backgroundColor = 'red'; + } + el = null; +} +</pre> + +<p>This works by breaking the circular reference.</p> + +<p>Surprisingly, one trick for breaking circular references introduced by a closure is to add another closure:</p> + +<pre class="eval">function addHandler() { + var clickHandler = function() { + this.style.backgroundColor = 'red'; + } + (function() { + var el = document.getElementById('el'); + el.onclick = clickHandler; + })(); +} +</pre> + +<p>The inner function is executed straight away, and hides its contents from the closure created with <code>clickHandler</code>.</p> + +<p>Another good trick for avoiding closures is breaking circular references during the <code>window.onunload</code> event. Many event libraries will do this for you. Note that doing so disables <a href="pl/Using_Firefox_1.5_caching">bfcache in Firefox 1.5</a>, so you should not register an <code>unload</code> listener in Firefox, unless you have other reasons to do so.</p> + +<div class="originaldocinfo"> +<h2 id="Original_Document_Information" name="Original_Document_Information">Original Document Information</h2> + +<ul> + <li>Author: <a class="external" href="http://simon.incutio.com/">Simon Willison</a></li> + <li>Last Updated Date: March 7, 2006</li> + <li>Copyright: © 2006 Simon Willison, contributed under the Creative Commons: Attribute-Sharealike 2.0 license.</li> + <li>More information: For more information about this tutorial (and for links to the original talk's slides), see Simon's <a class="external" href="http://simon.incutio.com/archive/2006/03/07/etech">Etech weblog post</a>.</li> +</ul> +</div> diff --git a/files/pl/web/javascript/new_in_javascript/index.html b/files/pl/web/javascript/new_in_javascript/index.html new file mode 100644 index 0000000000..179a7ed557 --- /dev/null +++ b/files/pl/web/javascript/new_in_javascript/index.html @@ -0,0 +1,10 @@ +--- +title: New in JavaScript +slug: Web/JavaScript/New_in_JavaScript +tags: + - NeedsTranslation + - TopicStub +translation_of: Archive/Web/JavaScript/New_in_JavaScript +--- +<p>Follow the links below to get to know about new features in JavaScript:</p> +<p>{{ tree('','1') }}</p> diff --git a/files/pl/web/javascript/new_in_javascript/nowości_w_javascript_1.5/index.html b/files/pl/web/javascript/new_in_javascript/nowości_w_javascript_1.5/index.html new file mode 100644 index 0000000000..74bbc59612 --- /dev/null +++ b/files/pl/web/javascript/new_in_javascript/nowości_w_javascript_1.5/index.html @@ -0,0 +1,36 @@ +--- +title: Nowości w JavaScript 1.5 +slug: Web/JavaScript/New_in_JavaScript/Nowości_w_JavaScript_1.5 +tags: + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Archive/Web/JavaScript/New_in_JavaScript/1.5 +--- +<p>Wersja 1.5 języka JavaScript została wzbogacona o nowe możliwości, takie jak:</p> + +<p><strong>Błędy czasu wykonania (runtime errors)</strong><br> + Błędy czasu wykonania są teraz zgłaszane jako wyjątki.</p> + +<p><strong>Udoskonalenie formatowania danych liczbowych</strong><br> + Nowe metody formatujące dane liczbowe: Number.prototype.toExponential, Number.prototype.toFixed i Number.prototype.toPrecision. Zobacz stronę <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Obiekty_predefiniowane/Obiekt_Number">Obiekt Number</a>.</p> + +<p><strong>Usprawnienie wyrażeń regularnych</strong><br> + Dodane zostały poniższe rozszerzenia wyrażeń regularnych:</p> + +<ul> + <li>Kwantyfikatory — +, *, ? i {} — poprzez dodanie na ich końcu znaku ? można wymusić, aby były niezachłanne. Zobacz wpis na temat ? na stronie <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Zapisywanie_wzorca_wyra%c5%bcenia_regularnego#U.C5.BCywanie_znak.C3.B3w_specjalnych">Zapisywanie wzorca wyrażenia regularnego</a>.</li> + <li>Non-capturing parentheses, (?:x) can be used instead of capturing parentheses, (x). When non-capturing parentheses are used, matched subexpressions are not available as back-references. See the entry for (?:x) on the <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Zapisywanie_wzorca_wyra%c5%bcenia_regularnego#U.C5.BCywanie_znak.C3.B3w_specjalnych">Zapisywanie wzorca wyrażenia regularnego</a> page.</li> + <li>Positive and negative lookahead assertions are supported. Both assert a match depending on what follows the string being matched. See the entries for x(?=y) and x(?!y) on the <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Zapisywanie_wzorca_wyra%c5%bcenia_regularnego#U.C5.BCywanie_znak.C3.B3w_specjalnych">Zapisywanie wzorca wyrażenia regularnego</a> page.</li> + <li>Dodano flagę m określającą, że wyrażenie regularne powinno objąć wiele linii. Zobacz stronę <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_wyra%c5%bceniami_regularnymi/Globalne_wyszukiwanie%2c_wielko%c5%9b%c4%87_znak%c3%b3w%2c_wieloliniowe_wej%c5%9bcie">Globalne wyszukiwanie, wielkość znaków, wieloliniowe wejście</a>.</li> +</ul> + +<p><strong>Warunkowe deklaracje funkcji:</strong> Funkcje mogą być teraz deklarowane wewnątrz klauzuli <code>if</code>. Zobacz stronę <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Definiowanie_funkcji">Definiowanie funkcji</a>.</p> + +<p><strong>Wyrażenia funkcyjne:</strong> Funkcje mogą być teraz deklarowane wewnątrz wyrażeń. Zobacz stronę <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Definiowanie_funkcji">Definiowanie funkcji</a>.</p> + +<p>Wielokrotne klauzule <code>catch</code>: W jednym bloku <code>try...catch</code> może teraz występować wiele klauzul <code>catch</code>. Zobacz stronę <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Instrukcje_obs%c5%82ugi_wyj%c4%85tk%c3%b3w/Instrukcja_try...catch#Blok_catch">Blok catch</a></p> + +<p><strong>Operacje dostępowe (gettery i settery):</strong> Programiści JavaScript mogą teraz stosować operacje dostępowe (tzw. getter i setter) dla tworzonych przez siebie obiektów. Ta możliwość jest dostępna tylko w implementacji JavaScriptu w języku C. Zobacz stronę <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>.</p> + +<p><strong>Stałe:</strong> Obsługiwane są nazwane stałe tylko do odczytu. Ta możliwość jest dostępna tylko w implementacji JavaScriptu w języku C. Zobacz stronę <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Sta%c5%82e">Stałe</a>.</p> diff --git a/files/pl/web/javascript/new_in_javascript/nowości_w_javascript_1.6/index.html b/files/pl/web/javascript/new_in_javascript/nowości_w_javascript_1.6/index.html new file mode 100644 index 0000000000..514bec084f --- /dev/null +++ b/files/pl/web/javascript/new_in_javascript/nowości_w_javascript_1.6/index.html @@ -0,0 +1,62 @@ +--- +title: Nowości w JavaScript 1.6 +slug: Web/JavaScript/New_in_JavaScript/Nowości_w_JavaScript_1.6 +tags: + - E4X + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/JavaScript/New_in_JavaScript/1.6 +--- +<p> +</p><p>JavaScript 1.6 wprowadza nowe funkcje i technologie: E4X, kilka nowych metod <code>Array</code> oraz rodzajów Array i String. +</p><p>JavaScript 1.6 jest obsługiwany w <a href="pl/Firefox_1.5">Firefoksie 1.5</a> i późniejszych. +</p> +<h3 id="E4X" name="E4X"> E4X </h3> +<p>ECMAScript dla XML-a (<a href="pl/E4X">E4X</a>) jest potężną technologią dla tworzenia i przetwarzania treści <a href="pl/XML">XML</a> przez <a href="pl/JavaScript">JavaScript</a>. Będziemy dalej usprawniać naszą obsługę E4X, włączając dodanie przezroczystej integracji z istniejącym <a href="pl/DOM">DOM-em</a>, jednak programiści tworzący internetowe aplikacje XML mogą korzystać z obsługi E4X w Firefoksie 1.5 już teraz. +</p><p>Możesz nadal używać standardowego typu MIME używając E4X: +</p> +<pre><script type="text/javascript"> +</pre> +<p>Jednakże składnia E4X może powodować konflikty z popularnymi praktykami umieszczania skryptów w komentarzach HTML (<code><span class="nowiki"><!--...--></span></code>) w celu ukrycia ich przed starymi przeglądarkami. E4X może również powodować konflikty z nowocześniejszą praktyką umieszczania skryptów w XML-owych sekcjach CDATA (<code><![CDATA{{ mediawiki.external('...') }}]></code>), aby umożliwić użycie symboli "<" oraz ">" w skryptach (zwróć uwagę, że nie dotyczy to HTML-a). Jeżeli napotkasz dziwne błędy składni, dodaj "; e4x=1" do wartości typu MIME: +</p> +<pre><script type="text/javascript; e4x=1"> +</pre> +<p>Zwróć uwagę, że skrypty w rozszerzeniach zawsze traktują komentarze HTML jako literały E4X. To znaczy, że "e4x=1" jest domniemany. +</p><p>E4X jest opisany w <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Przetwarzanie_XML_za_pomoc%c4%85_E4X">Przetwarzanie XML za pomocą E4X</a> +</p> +<h3 id="Dodatkowe_funkcje_obiektu_Array" name="Dodatkowe_funkcje_obiektu_Array"> Dodatkowe funkcje obiektu Array </h3> +<p>Do obiektu <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array">Array</a></code> zostało dodanych 7 nowych metod, które można podzielić na dwie kategorie: metody położenia elementów oraz metody iteratywne. Metody położenia elementów to: +</p> +<ul><li> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/indexOf">indexOf()</a></code> - zwraca indeks pierwszego wystąpienia danego elementu. +</li><li> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/lastIndexOf">lastIndexOf()</a></code> - zwraca indeks ostatniego wystąpienia danego elementu. +</li></ul> +<p>Metody iteratywne to: +</p> +<ul><li> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/every">every()</a></code> - wywołuje funkcję na elementach tablicy, dopóki funkcja zwraca wartość true. Zwraca wartość true, jeśli funkcja zwraca true dla każdego odwiedzonego elementu. </li><li> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/filter">filter()</a></code> - wywołuje funkcję na każdym elemencie tablicy i zwraca tablicę wszystkich elementów, dla których funkcja zwraca wartość true. +</li><li> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/forEach">forEach()</a></code> - wywołuje funkcje na każdym elemencie tablicy. +</li><li> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/map">map()</a></code> - wywołuje funkcję na każdym elemencie tablicy i zwraca wyniki w postaci tablicy. +</li><li> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/some">some()</a></code> - wywołuje funkcję na elementach tablicy, dopóki funkcja zwraca wartość false. Zwraca wartość true, jeśli funkcja zwraca true dla każdego odwiedzonego elementu. </li></ul> +<p>Więcej infomacji można znaleźć na stronie <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5/Praca_z_tablicami#Wprowadzone_w_JavaScripcie_1.6">Praca z tablicami</a> lub w artykule Nicholasa C. Zakasa, <a class="external" href="http://www.webreference.com/programming/javascript/ncz/column4/index.html">Nowe metody Array Mozilli</a>. +</p> +<h3 id="Rodzaje_Array_i_String" name="Rodzaje_Array_i_String">Rodzaje Array i String</h3> +<p>Czasami chcesz zastosować metody tablicy na łańcuchu znaków. Robiąc to traktujesz łańcuch znaków jako tablicę złożoną ze znaków. Przykładowo w celu sprawdzenia, czy wszystkie znaki w zmiennej <var>str</var> są literami, możesz użyć:</p> +<pre>function isLetter(character) { + return (character >= "a" && character <= "z"); +} + +if (Array.prototype.every.call(str, isLetter)) + alert("Ciąg '" + str + "' składa się z samych liter!"); +</pre> +<p>Taki zapis zajmuje stosunkowo dużo miejsca. JavaScript 1.6 wprowadza wygodne uproszczenie:</p> +<pre>if (Array.every(str, isLetter)) + alert("Ciąg '" + str + "' składa się z samych liter!"); +</pre> +<p>W podobny sposób możesz łatwo zastosować metody obiektu String do dowolnego obiektu:</p> +<pre>var num = 15; +alert(String.prototype.replace(num, /5/, '2')); +</pre> +<p>Zobacz także <a href="/pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_tablicami#Praca_z_obiektami_tablicopodobnymi" title="pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_tablicami#Praca_z_obiektami_tablicopodobnymi">Praca z obiektami tablicopodobnymi</a>.</p> +<p> </p> +<p> </p> + +<p>{{ languages( { "en": "en/New_in_JavaScript_1.6", "es": "es/Novedades_en_JavaScript_1.6", "fr": "fr/Nouveaut\u00e9s_dans_JavaScript_1.6", "ja": "ja/New_in_JavaScript_1.6", "ru": "ru/\u041d\u043e\u0432\u043e\u0435_\u0432_JavaScript_1.6", "zh-cn": "cn/New_in_JavaScript_1.6", "zh-tw": "zh_tw/JavaScript_1.6_\u65b0\u9bae\u4e8b" } ) }}</p> diff --git a/files/pl/web/javascript/nowości_w_javascript_1.4/index.html b/files/pl/web/javascript/nowości_w_javascript_1.4/index.html new file mode 100644 index 0000000000..cef8039309 --- /dev/null +++ b/files/pl/web/javascript/nowości_w_javascript_1.4/index.html @@ -0,0 +1,24 @@ +--- +title: Nowości w JavaScript 1.4 +slug: Web/JavaScript/Nowości_w_JavaScript_1.4 +tags: + - JavaScript + - JavaScript 1.4 +translation_of: Archive/Web/JavaScript/New_in_JavaScript/1.4 +--- +<p><span class="hps">Funkcje, które</span> <span class="hps">zostały</span> <span class="hps">dodane w</span> <span class="hps">JavaScripcie 1.4</span> <span class="hps">obejmują:</span></p> + +<ul> + <li>Dodano <a href="/en/JavaScript/Guide/Obsolete_Pages/Exception_Handling_Statements" rel="internal" title="en/Core JavaScript 1.5 Guide/Exception Handling Statements">exception handling</a> (throw oraz try-catch)</li> + <li>Dodano operatory <code><a href="/en/JavaScript/Reference/Operators/in" rel="internal" title="en/Core_JavaScript_1.5_Reference/Operators/Special_Operators/in_Operator">in</a></code> oraz <code><a href="/en/JavaScript/Reference/Operators/instanceof" rel="internal" title="En/Core_JavaScript_1.5_Reference/Operators/Special_Operators/Instanceof_Operator">instanceof</a></code></li> + <li><a href="/en/LiveConnect" rel="internal" title="en/LiveConnect">LiveConnect</a></li> + <li><code>zmiany <a href="/en/JavaScript/Reference/Global_Objects/eval" rel="internal" title="En/Core_JavaScript_1.5_Reference/Global_Functions/Eval">eval</a> </code>(nie można używać pośrednio oraz usunięcie z metod <code>Object</code>)</li> + <li><code><a href="/en/JavaScript/Reference/Functions_and_function_scope/arguments" rel="internal" title="en/Core_JavaScript_1.5_Reference/Functions/arguments">arguments</a></code> nie jest już właściwością funkcji</li> + <li><code><font face="'Lucida Grande', 'Lucida Sans Unicode', Lucida, Arial, Helvetica, sans-serif"><span style="line-height: 19px;">Metodę uznano za przestarzałą </span></font><a href="/en/JavaScript/Reference/Global_Objects/Function/arity" rel="internal" title="En/Core_JavaScript_1.5_Reference/Objects/Function/Arity">Function.arity</a></code> na rzecz <code><a href="/en/JavaScript/Reference/Global_Objects/Function/length" rel="internal" title="en/Core_JavaScript_1.5_Reference/Objects/Function/length">Function.length</a></code></li> +</ul> + +<h2 id="Odniesienia">Odniesienia</h2> + +<ul> + <li><a class="external" href="http://devedge-temp.mozilla.org/library/manuals/2000/javascript/1.4/reference/frames.html" title="http://devedge-temp.mozilla.org/library/manuals/2000/javascript/1.4/reference/frames.html">http://devedge-temp.mozilla.org/library/manuals/2000/javascript/1.4/reference/frames.html</a></li> +</ul> diff --git a/files/pl/web/javascript/nowości_w_javascript_1.8/index.html b/files/pl/web/javascript/nowości_w_javascript_1.8/index.html new file mode 100644 index 0000000000..bee5db7813 --- /dev/null +++ b/files/pl/web/javascript/nowości_w_javascript_1.8/index.html @@ -0,0 +1,135 @@ +--- +title: Nowości w JavaScript 1.8 +slug: Web/JavaScript/Nowości_w_JavaScript_1.8 +tags: + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Archive/Web/JavaScript/New_in_JavaScript/1.8 +--- +<div>{{ Fx_minversion_header(3) }}</div> + +<p>Obsługa języka JavaScript w wersji 1.8 ma zostać wprowadzona wraz z wydaniem silnika Gecko 1.9 (który ma się znaleźć w programie <a href="/pl/docs/Firefox_3_dla_programistów" title="Firefox_3_dla_programistów">Firefox 3</a>). Jest to aktualizacja mniej znacząca niż <a href="/pl/docs/Nowości_w_JavaScript_1.7" title="Nowości_w_JavaScript_1.7">JavaScript 1.7</a>; zmiany odpowiadają modyfikacjom dokonanym ostatnio w języku ECMAScript 4/JavaScript 2. W tym wydaniu zawarte będą wszystkie nowe funkcje wprowadzone w wydaniach <a href="/pl/docs/Nowości_w_JavaScript_1.6" title="Nowości_w_JavaScript_1.6">JavaScript 1.6</a> i <a href="/pl/docs/Nowości_w_JavaScript_1.7" title="Nowości_w_JavaScript_1.7">JavaScript 1.7</a>.</p> + +<p>Aby zapoznać się z postępem prac nad rozwojem obsługi języka JavaScript w wersji 1.8, zobacz {{ Bug(380236) }}.</p> + +<h3 id="Korzystanie_z_j.C4.99zyka_JavaScript_1.8" name="Korzystanie_z_j.C4.99zyka_JavaScript_1.8">Korzystanie z języka JavaScript 1.8</h3> + +<p>Aby skorzystać z nowych własności języka JavaScript 1.8 w kodzie HTML, należy użyć następującego kodu:</p> + +<pre class="eval"> <script type="application/javascript;version=1.8"> ... twój kod ... </script> +</pre> + +<p>W przypadku korzystania z <a href="/pl/docs/Wprowadzenie_do_powłoki_JavaScript" title="Wprowadzenie_do_powłoki_JavaScript">powłoki JavaScript</a>, komponentów XPCOM języka JavaScript lub elementów <code><script></code> w języku XUL automatycznie używana jest najnowsza wersja JS (JS1.8 w Mozilli 1.9); patrz {{ Bug(381031) }} i {{ Bug(385159) }}.</p> + +<p>W przypadku korzystania z funkcji, w których wymagane jest użycie nowych słów kluczowych <code>yield</code> i <code>let</code>, należy określić, że używana ma być wersja języka 1.7 lub nowsza — w istniejącym kodzie te słowa kluczowe mogą być bowiem nazwami zmiennych lub funkcji. Funkcje, w których nie wprowadzono nowych słów kluczowych (takie jak <a href="#Wyra.C5.BCenia_generator.C3.B3w">wyrażenia generatorów</a>), mogą być używane bez określania wersji języka JavaScript.</p> + +<h3 id="Domkni.C4.99cia_wyra.C5.BCe.C5.84" name="Domkni.C4.99cia_wyra.C5.BCe.C5.84">Domknięcia wyrażeń</h3> + +<p>Ta nowość to nic innego jak skrót do pisania prostych funkcji, dodający do języka konstrukcję podobną do <a class="external" href="http://pl.wikipedia.org/wiki/Rachunek_lambda">notacji lambda</a>.</p> + +<p><a href="/pl/docs/Nowości_w_JavaScript_1.7" title="Nowości_w_JavaScript_1.7">JavaScript 1.7</a> i starsze:</p> + +<pre class="eval"> function(x) { return x * x; } +</pre> + +<p>JavaScript 1.8:</p> + +<pre class="eval"> function(x) x * x +</pre> + +<p>Taka składnia pozwala pominąć nawiasy i wyrażenie <code>return</code> - są one dodawane automatycznie. Nie ma żadnej dodanej wartości w pisaniu z wykorzystaniem tej notacji, poza tym, że sam kod staje się krótszy.</p> + +<p><strong>Przykłady:</strong></p> + +<p>Skrót do podpinania nasłuchiwania zdarzeń:</p> + +<pre class="eval"> document.addEventListener("click", function() false, true); +</pre> + +<p>Użycie nowej notacji w połączeniu z niektórymi funkcjami tablic z <a href="/pl/docs/Nowości_w_JavaScript_1.6" title="Nowości_w_JavaScript_1.6">JavaScript 1.6</a>:</p> + +<pre class="eval"> elems.some(function(elem) elem.type == "text"); +</pre> + +<h3 id="Wyra.C5.BCenia_generator.C3.B3w" name="Wyra.C5.BCenia_generator.C3.B3w">Wyrażenia generatorów</h3> + +<p>Ten dodatek pozwala na proste tworzenie generatorów (które opisano w <a href="/pl/docs/Nowości_w_JavaScript_1.7" title="Nowości_w_JavaScript_1.7">JavaScript 1.7</a>). Wcześniej konieczne byłoby stworzenie własnej funkcji zawierającej w sobie wyrażenie yield, jednak ten dodatek pozwala na użycie składni podobnej do <em>wyrażenia tablicowego/listowego</em> (ang. array/list comprehension) do stworzenia identycznego wyrażenia generatora.</p> + +<p>Wykorzystując <a href="/pl/docs/Nowości_w_JavaScript_1.7" title="Nowości_w_JavaScript_1.7">JavaScript 1.7</a> w celu stworzenia własnego generatora obiektu kod wyglądać mógłby następująco:</p> + +<pre class="eval"> function add3(obj) { + + for ( let i in obj ) + yield i + 3; + } + + let it = add3(someObj); + try { + while (true) { + document.write(it.next() + "<br>\n"); + } + } catch (err if err instanceof StopIteration) { + document.write("End of record.<br>\n"); + } +</pre> + +<p>W JavaScript 1.8 można pominąć tworzenie własnej funkcji generatora wykorzystując w zamian następujące wyrażenie generatora:</p> + +<pre class="eval"> let it = (i + 3 for (i in someObj)); + try { + while (true) { + document.write(it.next() + "<br>\n"); + } + } catch (err if err instanceof StopIteration) { + document.write("End of record.<br>\n"); + } +</pre> + +<p>Wyrażenia generatora mogą być także przesłane do funkcji jako wartości. To rozwiązanie jest szczególnie warte uwagi odkąd generatory uruchamiane są wyłącznie gdy są kategorycznie potrzebne (w przeciwieństwie do typowych sytuacji wykorzystujących wyobrażenie tablicy, gdzie tablice tworzone są wcześniej). Przykład pokazujący różnice w tych rozwiązaniach znaleźć można poniżej:</p> + +<p>Wykorzystując JavaScript 1.7 Wyrażenie Tablicowe</p> + +<pre class="eval"> handleResults([ i for ( i in obj ) if ( i > 3 ) ]); + + function handleResults( results ) { + for ( let i in results ) + // ... + } +</pre> + +<p>Wykorzystując JavaScript 1.8 Wyrażenia Generatora</p> + +<pre class="eval"> handleResults( i for ( i in obj ) if ( i > 3 ) ); + + function handleResults( results ) { + for ( let i in results ) + // ... + } +</pre> + +<p>Znaczącą różnicą pomiędzy tymi dwoma przykładami jest to, iż dla wyrażeń generatora konieczne jest wykonanie pętli dla struktury 'obj' tylko raz, podczas gdy dla Wyrażenia Tablicowego konieczne jest wykonanie pętli raz w celu stworzenia wyobrażenia tablicy oraz drugi raz podczas iteracji po jej elementach.</p> + +<h3 id="Dodatkowe_zmiany_w_obiekcie_Array" name="Dodatkowe_zmiany_w_obiekcie_Array">Dodatkowe zmiany w obiekcie Array</h3> + +<p>W języku JavaScript 1.8 dostępne są dwie nowe metody iteracyjne obiektu <code><a href="/pl/docs/Dokumentacja_języka_JavaScript_1.5/Obiekty/Array" title="Dokumentacja_języka_JavaScript_1.5/Obiekty/Array">Array</a></code>:</p> + +<ul> + <li><code><a href="/pl/docs/Dokumentacja_języka_JavaScript_1.5/Obiekty/Array/reduce" title="Dokumentacja_języka_JavaScript_1.5/Obiekty/Array/reduce">reduce()</a></code> - wywołuje funkcję dla każdego elementu z tablicy i zachowuje wyniki z poprzednich wywołań.</li> + <li><code><a href="/pl/docs/Dokumentacja_języka_JavaScript_1.5/Obiekty/Array/reduceRight" title="Dokumentacja_języka_JavaScript_1.5/Obiekty/Array/reduceRight">reduceRight()</a></code> - wywołuje funkcję dla każdego elementu z tablicy i zachowuje wyniki z poprzednich wywołań, lecz w odwrotnej kolejności.</li> +</ul> + +<h3 id="Changes_in_destructuring_for..in" name="Changes_in_destructuring_for..in">Zmiany z usuwaniem elementów tablicy w pętli for..in</h3> + +<p>TBD: mention <a href="/pl/docs/Nowości_w_JavaScript_1.7#Iterowanie_przez_obiekty" title="Nowości_w_JavaScript_1.7#Iterowanie_przez_obiekty">Nowości w JavaScript 1.7#Iterowanie przez obiekty</a> ({{ Bug(366941) }}).</p> + +<p><br> + <font><font face="Georgia, Times, Times New Roman, serif"><span style="font-size: 20px;"><strong>Nadchodzące zmiany</strong></span></font></font></p> + +<p><span style="line-height: inherit;">Zmiany w JavaScript 1.8 włączają również:</span></p> + +<ul> + <li>Kodowanie i dekodowanie danych w JSON.</li> + <li>Składnia funkcji Slice.</li> + <li>Generalized destructuring <code>for...in</code> (czy znaczy to coś innego niż <a href="#Changes_in_destructuring_for..in">#Changes in destructuring for..in</a> ? --<a href="/User:Nickolay" title="User:Nickolay">Nickolay</a> 10:52, 9 Wrzesień 2007 (PDT))</li> +</ul> diff --git a/files/pl/web/javascript/o_javascript/index.html b/files/pl/web/javascript/o_javascript/index.html new file mode 100644 index 0000000000..26c921724f --- /dev/null +++ b/files/pl/web/javascript/o_javascript/index.html @@ -0,0 +1,57 @@ +--- +title: O JavaScript +slug: Web/JavaScript/O_JavaScript +translation_of: Web/JavaScript/About_JavaScript +--- +<div>{{JsSidebar}}</div> + +<h2 id="Co_to_jest_JavaScript">Co to jest JavaScript?</h2> + +<p><strong>JavaScript</strong><sup>®</sup> (w skrócie <strong>JS</strong>) jest lekkim, interpretowanym, zorientowanym obiektowo językiem z funkcjami <a href="https://en.wikipedia.org/wiki/First-class_function" title="https://en.wikipedia.org/wiki/First-class_function">pierwszej klasy</a>, i jest najbardziej znany jako język skryptowy dla stron sieci Web, ale jest także <a class="external" href="https://en.wikipedia.org/wiki/JavaScript#Uses_outside_web_pages">używany w wielu innych środowiskach niż przeglądarka</a>. It is a <a class="mw-redirect" href="https://en.wikipedia.org/wiki/Prototype-based_programming" title="Prototype-based">prototype-based</a>, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.</p> + +<p>JavaScript działa po stronie klienta, co można wykorzystać w projektowaniu / programowaniu jak strona ma się zachowywać w przypadku wystąpienia jakiegoś zdarzenia. JavaScript jest łatwym do opanowania i jednocześnie potężnym językiem skryptowym, powszechnie używany do kontrolowania zachowania strony internetowej.</p> + +<p>Wbrew powszechnemu przekonaniu, <strong>JavaScript <em>nie </em>jest "zinterpretowaną Java"</strong>. W skrócie, JavaScript jest dynamicznym językiem skryptowym obsługującym prototypową konstrukcję obiektów. Podstawowa składnia jest celowo podobna zarówno do Java i C++, aby zmniejszyć liczbę nowych pojęć potrzebnych do nauki języka. Konstrukcje językowe, takie jak istrukcje <code>if</code> i <code>switch</code>, pętle <code>for</code> i <code>while</code>, oraz blok <code>try ... catch</code> funkcjonują tak samo w tych językach (lub bardzo podobnie).</p> + +<p>JavaScript może funkcjonować jako język <a class="external" href="https://en.wikipedia.org/wiki/Procedural_programming" title="https://en.wikipedia.org/wiki/Procedural_programming">proceduralny</a>, jak również <a class="external" href="/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript" title="https://developer.mozilla.org/en-US/docs/Introduction_to_Object-Oriented_JavaScript">język zorientowany obiektowo</a>. Obiekty w JavaScript są tworzone automatycznie, poprzez dołączenie metod i właściwości do pustego obiektów <strong>w czasie wykonywania</strong>, w przeciwieństwie do definicji składniowych klasy wspólnych zestawionych w językach takich jak C ++ i Java. Raz stworzony obiekt może być stosowany jako projekt (lub prototyp) do tworzenia podobnych obiektów.</p> + +<p>JavaScript's dynamic capabilities include runtime object construction, variable parameter lists, function variables, dynamic script creation (via <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval" title="en-US/docs/JavaScript/Reference/Global_Functions/eval">eval</a></code>), object introspection (via <code>for ... in</code>), and source code recovery (JavaScript programs can decompile function bodies back into their source text).</p> + +<p>For a more in depth discussion of JavaScript programming follow the <a href="#JavaScript_resources">JavaScript resources</a> links below.</p> + +<h2 id="What_JavaScript_implementations_are_available">What JavaScript implementations are available?</h2> + +<p>The Mozilla project provides two JavaScript implementations. The first <strong>ever</strong> JavaScript was created by Brendan Eich at Netscape, and has since been updated to conform to ECMA-262 Edition 5 and later versions. This engine, code named <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey" title="en-US/docs/SpiderMonkey">SpiderMonkey</a>, is implemented in C/C++. The <a href="/en-US/docs/Rhino" title="en-US/docs/Rhino">Rhino</a> engine, created primarily by Norris Boyd (also at Netscape) is a JavaScript implementation written in Java. Like SpiderMonkey, Rhino is ECMA-262 Edition 5 compliant.</p> + +<p>Several major runtime optimizations such as TraceMonkey (Firefox 3.5), JägerMonkey (Firefox 4) and IonMonkey were added to the SpiderMonkey JavaScript engine over time. Work is always ongoing to improve JavaScript execution performance.</p> + +<p>Besides the above implementations, there are other popular JavaScript engines such as:-</p> + +<ul> + <li>Google's <a class="external" href="https://code.google.com/p/v8/" title="https://code.google.com/p/v8/">V8</a>, which is used in the Google Chrome browser and recent versions of Opera browser. This is also the engine used by <a href="http://nodejs.org">Node.js</a>.</li> + <li>The <a class="external" href="https://www.webkit.org/projects/javascript/index.html" title="https://www.webkit.org/projects/javascript/index.html">JavaScriptCore</a> (SquirrelFish/Nitro) used in some WebKit browsers such as Apple Safari.</li> + <li><a class="external" href="http://my.opera.com/ODIN/blog/carakan-faq" title="http://my.opera.com/ODIN/blog/carakan-faq">Carakan</a> in old versions of Opera.</li> + <li>The <a class="external" href="http://en.wikipedia.org/wiki/Chakra_%28JScript_engine%29" title="http://en.wikipedia.org/wiki/Chakra_%28JScript_engine%29">Chakra</a> engine used in Internet Explorer (although the language it implements is formally called "JScript" in order to avoid trademark issues).</li> +</ul> + +<p>Each of Mozilla's JavaScript engines expose a public API which application developers can use to integrate JavaScript into their software. By far, the most common host environment for JavaScript is web browsers. Web browsers typically use the public API to create <strong>host objects</strong> responsible for reflecting the <a class="external" href="http://www.w3.org/DOM/">DOM</a> into JavaScript.</p> + +<p>Another common application for JavaScript is as a (Web) server side scripting language. A JavaScript web server would expose host objects representing a HTTP request and response objects, which could then be manipulated by a JavaScript program to dynamically generate web pages. <a href="http://nodejs.org">Node.js</a> is a popular example of this.</p> + +<h2 id="JavaScript_resources">JavaScript resources</h2> + +<dl> + <dt><a href="/en-US/docs/Mozilla/Projects/SpiderMonkey" title="en-US/docs/SpiderMonkey">SpiderMonkey</a></dt> + <dd>Information specific to Mozilla's implementation of JavaScript in C/C++ engine (aka SpiderMonkey), including how to embed it in applications.</dd> +</dl> + +<dl> + <dt><a href="/en-US/docs/Rhino" title="en-US/docs/Rhino">Rhino</a></dt> + <dd>Information specific to the JavaScript implementation written in Java (aka Rhino).</dd> + <dt><a href="/en-US/docs/Web/JavaScript/Language_Resources" title="en-US/docs/JavaScript_Language_Resources">Language resources</a></dt> + <dd>Pointers to published JavaScript standards.</dd> + <dt><a href="/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript" title="en-US/docs/A_re-introduction_to_JavaScript">A re-introduction to JavaScript</a></dt> + <dd><a href="/en-US/docs/Web/JavaScript/Guide" title="en-US/docs/JavaScript/Guide">JavaScript guide</a> and <a href="/en-US/docs/Web/JavaScript/Reference" title="en-US/docs/JavaScript/Reference">JavaScript reference</a>.</dd> +</dl> + +<p>JavaScript® is a trademark or registered trademark of Oracle in the U.S. and other countries.</p> diff --git a/files/pl/web/javascript/ponowne_wprowadzenie_do_javascript/index.html b/files/pl/web/javascript/ponowne_wprowadzenie_do_javascript/index.html new file mode 100644 index 0000000000..abb01ce731 --- /dev/null +++ b/files/pl/web/javascript/ponowne_wprowadzenie_do_javascript/index.html @@ -0,0 +1,965 @@ +--- +title: Ponowne wprowadzenie do JavaScript (JS tutorial) +slug: Web/JavaScript/Ponowne_wprowadzenie_do_JavaScript +translation_of: Web/JavaScript/A_re-introduction_to_JavaScript +--- +<div>{{jsSidebar}}</div> + +<div></div> + +<div>Po co ponowne wprowadzanie? Ponieważ {{Glossary("JavaScript")}} osławiony jest jako <a href="http://crockford.com/javascript/">najbardziej niezrozumiany język świata</a>. Często wyśmiewany jest jako bycie zabawką, jednak pod warstwą jego prosoty czekają potężne funkcje. Obecnie JavaScript używany jest w niewiarygodnie dużej ilości wysokoprofilowych aplikacji, pokazując, że dogłębne zrozumienie tej technologii jest ważną umiejętnością dla każdego, webowego jak i mobilnego, dewelopera.</div> + +<div></div> + +<div>Warto rozpocząć od zaznajomienia się z historią tego języka. JavaScript został stworzony w 1995 roku przez Brendah Eich, który w tym czasie był inżynierem w Netscape. Pierwszy raz JavaScript został wydany z Netscape 2 początkiem 1996 roku. Pierwotnie miał on być nazywany LiveScript, został jednak przemianowany za sprawą feralnej decyzji marketingowej, która miała na celu wykorzystanie popularności języka Java Sun Microsystem - pomijając znikome części wspólne. Od tego czasu jest to źrodłem wielu nieporozumień. </div> + +<div></div> + +<div>Kilka miesięcy poźniej Microsoft wydał JScript razem z Internet Explorer 3. Był to w większości kompatybilny i podobny w pracy do JavaScript. Kilka miesięcy po tym, Netscape zgłosił JavaScript do <a href="http://www.ecma-international.org/">Ecma International</a>, europejskiego stowarzyszenia standaryzującego, czego rezultatem było wydanie pierwszej edycji {{Glossary("ECMAScript")}}. Standard otrzymał znaczącą aktualizację jako <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMAScript edition 3</a> w 1999 roku i od tego czasu został prawie niezmieniony. Czwarta edycja została porzucona z powodu różnic politycznych dotyczących złożoności języka. Wiele części czwartej edycji uformowało podstawy dla piątej ECMAScript - opublikowanej w grudniu 2009 roku, oraz szóstej, której publikacja wypadła w czerwcu 2015 roku.</div> + +<div></div> + +<div></div> + +<div class="note"> +<p>Od tej pory określenie "JavaScript" będzie używane w odniesieniu do ECMAScript, ponieważ określenie to jest bardziej rozpoznawalne.</p> +</div> + +<p>W odróżnieniu od innych języków programowania, JavaScript nie posiada koncepcji wejścia ani wyjścia. Zaprojektowany został do działania jako język skryptowy działający w środowisku hosta i do tego środowiska nalezy zapewnienie mechanizmów komunikacji ze światem. Najbardziej pospolitym środowiskiem jest przeglądarka, jednak interpretatory JavaScript można znaleźć również w wielu innych miejscach włączając w to Adobe Acrobat, Adobe Photoshop, obrazy SVG, silnik wigetów Yahoo, w środowiskach uruchomieniowych takich jak <a href="http://nodejs.org/">Node.js</a>, bazach danych NoSQL - <a href="http://couchdb.apache.org/">Apache CouchDB</a>, systemach wbudowanych czy kompletnych środowiskach graficznych takich jak <a href="http://www.gnome.org/">GNOME </a>( jeden z najpopularniejszych GUI dla systemów operacyjnych GNU/Linux ).</p> + +<h2 id="Przegląd">Przegląd</h2> + +<p>JavaScript jest wieloparadygmatowym, dynamicznym językiem z typami i operatorami, standardowymi wbudowanymi obiektami oraz metodami. Jego składnia opiera się na językach Java i C - wiele struktur tych języków również zostało wprowadzonych do JavaScript-u. JavaScript wspiera programowanie obiektowe z prototypami obiektów zamiast klas ( zobacz więcej <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/dziedziczenie_lancuch_prototypow">dziedziczenie prototypowe</a> oraz <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes">ES2015 klasy</a> (ang.)). Dodatkowo JavaScript wspiera programowanie funkcyjne - funkcje są obiektami, nadanie funkcjom możliwości przechowywania kodu wykonawczego i przekazywaniu go jak każdemu innemu obiektowi.</p> + +<p>Zacznijmy od spojrzenia na budulec każdego języka: typy. Programy JavaScript manipulują wartościami, a wszystkie te wartości należą do typu. W JavaScript wyróżniamy typy: </p> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Boolean")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Object")}}</li> + <li>{{jsxref("Symbol")}} (new in ES2015)</li> +</ul> + +<p>...oraz {{jsxref("undefined")}} i {{jsxref("null")}}, które są nieco dziwne. Obiekty posiadają specjalne rodzaje, więc aby być technicznie poprawnym powyższa lista powinna wyglądać następująco:</p> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Boolean")}}</li> + <li>{{jsxref("Symbol")}} (new in ES2015)</li> + <li>{{jsxref("Object")}} + <ul> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Date")}}</li> + <li>{{jsxref("RegExp")}}</li> + </ul> + </li> + <li>{{jsxref("null")}}</li> + <li>{{jsxref("undefined")}}</li> +</ul> + +<p>Istnieją także wbudowane typy {{jsxref("Error")}}. Będzie prościej jeśli będziemy trzymać się pierwszej listy, a więc omówione zostaną wymienione tam typy.</p> + +<h2 id="Liczby">Liczby</h2> + +<p>Zgodnie ze specyfikacją numery w JavaScript są "wartościami podwójnie precyzyjnymi 64-bitowego formatu IEEE 754". Ma to pewne interesujące konsekwencje. W JavaScript nie ma rzeczy takiej jak liczba całkowita, należy więc być dość ostrożnym z artmetyką jeśli jesteś przyzywczajony do matematyki w języku C lub Java.</p> + +<p>Dodatkowo, zwracaj uwagę na rzeczy takie jak: </p> + +<pre class="brush: js">0.1 + 0.2 == 0.30000000000000004; +</pre> + +<p>W praktyce, liczby całkowite są traktowane jako 32-bitowe jednostki, a niektóre implementacje przechowują je w ten sposób dopóki nie zostaną poproszone o wykonanie instrukcji, która jest poprawna dla liczby, ale nie dla 32-bitowej liczby całkowitej. Może to być istotne dla operacji bitowych.</p> + +<p>Standardowe<a href="/en-US/docs/Web/JavaScript/Reference/Operators#Arithmetic_operators"> operatory arytmetyczne</a> są wspierane, wliczając w to dodawanie, odejmowanie, modulo i tak dalej. Istnieje też wbudowany obiekt, o którym zapomnieliśmy wspomnieć, {{jsxref("Math")}}, który zapewnia zaawansowane funkcje i stałe matematyczne:</p> + +<pre class="brush: js">Math.sin(3.5); +var circumference = 2 * Math.PI * r; +</pre> + +<p>Możesz zamienić String na liczbę całkowitą używając wbudowanej funkcji {{jsxref("Global_Objects/parseInt", "parseInt()")}}. Funkcja ta przyjmuje podstawę do konwersji jako opcjonalny drugi argument, który zawsze należy podawać:</p> + +<pre class="brush: js">parseInt('123', 10); // 123 +parseInt('010', 10); // 10 +</pre> + +<p>W starszych przeglądarkach, String-i zaczynające się od "0" przyjmowane są w formacie ósemkowym (podstawa 8), jednak od 2013 roku nie stanowiło to problemu. Chyba, że jesteś pewien formatu String-a, mogą zaskoczyć Cię wyniki w starszych przeglądarkach:</p> + +<pre class="brush: js">parseInt('010'); // 8 +parseInt('0x10'); // 16 +</pre> + +<p>Widzimy tu, że funkcja {{jsxref("Global_Objects/parseInt", "parseInt()")}} traktuje pierwszego Stringa w systemie ósemkowym przez 0 na przodzie, drugi String natomiast traktowny jest w systemie szesnastowym przez "0x" z przodu. <em>Zapis szesnastkowy nadal istnieje</em>; tylko ósemkowy został usunięty.</p> + +<p>Jeśli chcesz zmenić liczbę binarną na całkowitą, wystarczy zmienić podstawę:</p> + +<pre class="brush: js">parseInt('11', 2); // 3 +</pre> + +<p>Podobnie możemy przekształcić liczbę zmiennoprzecinkową używając wbudowanej funckcji {{jsxref("Global_Objects/parseFloat", "parseFloat()")}}. W odróżnieniu do {{jsxref("Global_Objects/parseInt", "parseInt()")}}, <code>parseFloat()</code> zawsze uzywa 10 jako podstawy.</p> + +<p>Możesz użyć działania jednoargumentowego <code>+</code>, aby zamienić wartości na liczby:</p> + +<pre class="brush: js">+ '42'; // 42 ++ '010'; // 10 ++ '0x10'; // 16 +</pre> + +<p>Specjalna wartość {{jsxref("NaN")}} ( skrót od "Not a Number" ( ang. nie numer )) zostaje zwrócona jeśli String nie jest liczbowy:</p> + +<pre class="brush: js">parseInt('hello', 10); // NaN +</pre> + +<p><code>NaN</code> jest toksyczny: jesli podasz go jako argument operacji matematycznej jej wynikiem również będzie <code>NaN</code>:</p> + +<pre class="brush: js">NaN + 5; // NaN + +</pre> + +<p>Możesz wykorzystać <code>NaN</code> do testów używając wbudowanej funkcji {{jsxref("Global_Objects/isNaN", "isNaN()")}}:</p> + +<pre class="brush: js">isNaN(NaN); // true + +</pre> + +<p>JavaScript dostarcza również specjalną wartość {{jsxref("Infinity")}} oraz <code>-Infinity</code>:</p> + +<pre class="brush: js"> 1 / 0; // Infinity +-1 / 0; // -Infinity + +</pre> + +<p><code>Infinity</code>, <code>-Infinity</code> oraz <code>NaN </code>wykorzystane mogą być do testów za pomocą wbudowanej funkcji {{jsxref("Global_Objects/isFinite", "isFinite()")}}:</p> + +<pre class="brush: js">isFinite(1 / 0); // false +isFinite(-Infinity); // false +isFinite(NaN); // false +</pre> + +<div class="note">Funkcje {{jsxref("Global_Objects/parseInt", "parseInt()")}} i {{jsxref("Global_Objects/parseFloat", "parseFloat()")}} przekształcają String dopóki nie napotkają znaku, który nie spełnia wymagań formatu liczbowego, po napotkaniu takiego znaku zwrócona zostanie liczba przekształcona do tego momentu. Jednak operator "+" zwyczajnie zwróci <code>NaN</code> jeśli w przekształcanym Stringu znajduje się niepoprawny znak. Spróbuj przekształcić String "10.2abc" używając przedstawionych metod, aby lepiej zrozumieć ich rożnice.</div> + +<h2 id="Strings">Strings</h2> + +<p>String-ami w JavaScript są sekwencje <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Unicode">znaków Unicode</a>. To powinna być dobra wiadomość dla każdego kto miał do czynienia z internacjonalizacją. Dokładniej, są to sekwencje jednostek kodowych UTF-16; każda jednostka kodowa jest reprezentowana przez 16-bitową liczbę. Każdy znak Unicode reprezentowany jest przez 1 lub 2 jednostki kodu.</p> + +<p>Jeśli chcesz przekazać jeden znak, musisz poprostu użyć String-a składającego się z tego pojedyńczego znaku.</p> + +<p>Aby sprawdzić długość String-a (w jednostkach kodu), użyj właściwości <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/String/length">length</a>:</p> + +<pre class="brush: js">'hello'.length; // 5 +</pre> + +<p>To było nasza pierwsza styczność z obiektami JavaScript! Wspominaliśmy, że możesz traktować String-i jak {{jsxref("Object", "obiekty", "", 1)}}? Też posiadają one {{jsxref("String", "metody", "#Methods", 1)}}, które pozwalają nimi manipulować i uzyskiwać informacje na ich temat:</p> + +<pre class="brush: js">'hello'.charAt(0); // "h" +'hello, world'.replace('hello', 'goodbye'); // "goodbye, world" +'hello'.toUpperCase(); // "HELLO" +</pre> + +<h2 id="Inne_typy">Inne typy</h2> + +<p>JavaScript odróżnia {{jsxref("null")}}, który jest wartością wskazujacą na umyślny brak wartości ( dostęp do nich tylko za pomocą słowa kluczowego <code>null</code> ), od {{jsxref("undefined")}}, która jest wartością typu <code>undefinded</code>, wskazującą na niezainicjowaną wartość - oznacza to, że wartość nie została jeszcze przypisana. Zmienne zostaną omówione później, narazie wystarczy nam wiedza, że w JavaScripcie możliwe jest zdeklarowanie zmiennej bez przypisania do niej wartości. Jeśli to zrobimy zmienna będzie typu <code>undefinded</code>. <code>undefinded</code> jest w rzeczywistości stałą.</p> + +<p>JavaScript posiada boolean (logiczny typ danych) z możliwymi wartościami <code>true</code> lub <code>false</code> (obie są słowami kluczowymi). Każda wartość może zostać przekonwertowana na typ logiczny zgodnie z zasadami:</p> + +<ol> + <li><code>false</code>, <code>0</code>, pusty string (<code>""</code>), <code>NaN</code>, <code>null</code>, oraz <code>undefined</code> wszystkie odpowiadają <code>false</code>.</li> + <li>Wszystkie inne odpowiadają <code>true</code>.</li> +</ol> + +<p>Możesz wykonać jawną konwersję używając wbudowanej funkcji <code>Boolean()</code>:</p> + +<pre class="brush: js">Boolean(''); // false +Boolean(234); // true +</pre> + +<p>Jednak, tego typu zamiana jest rzadko potrzeba, ponieważ JavaScript automatycznie wykona konwersję, kiedy oczekiwać będzie typu logicznego jak na przykład w przypadku instrukcji warunkowej <code>if</code> (zobacz niżej). Z tego powodu czasami mówi się o "wartościach prawdziwych" (<em>true values</em>) i "wartościach fałszywych" (<em>false value</em>), które oznaczają wartości, które po konwersji na typ logiczny stają się, odpowienio, prawdziwe lub fałszywe. Alternatywnie wartości te nazywane mogą być "truthy" lub "falsy".</p> + +<p>Operatory logiczne takie jak <code>&&</code>( i <em>)</em>, <code>||</code>( lub ) oraz <code>!</code>( negacja ) są wspierane; zobacz niżej.</p> + +<h2 id="Zmienne">Zmienne</h2> + +<p>Do deklaracji nowej zmiennej w JavaScript używamy jednego z trzech słów kluczowych: <a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a>, <a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a> lub <a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a>.</p> + +<p><code><strong>let</strong></code><strong> </strong>pozwala na deklarację zmiennej blokowej. Zadeklarowana zmienna dostępna jest z poziomu <em>bloku, </em>w którym została zadeklarowana.</p> + +<pre class="brush: js">let a; +let name = 'Simon'; + +</pre> + +<p>Poniżej znajduje się przykład zakresu ze zmienną zadeklarowaną za pomocą <code><strong>let</strong></code>:</p> + +<pre class="brush: js">// mojaZmiennaLet *nie* jest tutaj widoczna + +for (let mojaZmiennaLet = 0; mojaZmiennaLet < 5; mojaZmiennaLet++) { + // mojaZmiennaLet jest widoczna tylko tutaj +} + +// mojaZmiennaLet *nie* jest tutaj widoczna +</pre> + +<p><code><strong>const</strong></code><strong> </strong>pozwala zadeklarować zmienne, których wartości z założenia są stałe. Zmienna dostępna jest z <em>bloku,</em> w którym została zadeklarowana.</p> + +<pre class="brush: js">const Pi = 3.14; // deklaruje zmienną Pi +Pi = 1; // zwrócony zostanie błąd ponieważ nie można zmieniać zmiennej <code>const</code></pre> + +<p><strong><code>var</code> </strong>jest najczęściej deklarowaną zmienną. W odróżnieniu do dwóch pozostałych zmiennych nie posiada ograniczeń. Jest tak dlatego, że tradycyjnie był to jedeny sposób deklarowania zmiennych w JavaScript. Zmienna zadeklarowana przy użyciu <strong><code>var</code></strong> dostepna jest z <em>funkcji, </em>w której została zadeklarowana.</p> + +<pre class="brush: js">var a; +var name = 'Simon'; +</pre> + +<p>Przykład zakresu zmiennej zadeklarowanej za pomocą <strong><code>var</code>:</strong></p> + +<pre class="brush: js">// mojaZmiennaVar *jest* tutaj widoczna + +for (var mojaZmiennaVar = 0; mojaZmiennaVar < 5; mojaZmiennaVar++) { + // mojaZmiennaVar jest widoczna dla całej funckji +} + +// mojaZmiennaVar *jest* tutaj widoczna +</pre> + +<p>Jesli zadeklarujesz zmienną bez przypisania do niej wartości, jej typ stanie się <code>undefinded</code>.</p> + +<p>Ważną różnicą między JavaScript i innymi językami, jak Java, jest fakt, że w JavaScript bloki nie mają zasiegu; tylko funkcje posiadają zasięg. Więc jeśli zmienna zostanie zadeklarowana przy użyciu <code>var</code> w złożonej deklaracji (na przykład wewnątrz instrukcji warunkowej <code>if</code>), będzie ona widoczna dla całej funkcji. Jednak, korzystając ze składni ECMAScript 2015, deklaracje <a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a> i <a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a> pozwalają na tworzenie zmiennych o <u>zasięgu blokowym</u>.</p> + +<h2 id="Operatory">Operatory</h2> + +<p>Operatory liczbowe w JavaScript to <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code> oraz <code>%</code>, który jest operatorem reszty (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder_%28%29">co nie jest tym samym co modulo</a>). Do przypisania wartości używamy =, istnieje także przypisanie złożone jak na przykład += i -=. Ich rozwinięcie to <code>x = x operator y</code></p> + +<p>x += 5;<br> + x = x + 5;</p> + +<p>Możesz użyć operatorów <code>++</code> aby inkrementować oraz <code>--</code> aby dekrementować. Mogą one być używane zarówno jako operatory prefiksowe lub przyrostkowe.</p> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition">Operator +</a> dodatkowo używany jest do łączenia string-ów.</p> + +<pre class="brush: js">'hello' + ' world'; // "hello world" + +</pre> + +<p>Jeśli dodasz string do numeru (lub innej wartości) wszystko zostanie przekształcone w string. Przykład poniżej:</p> + +<pre class="brush: js">'3' + 4 + 5; // "345" + 3 + 4 + '5'; // "75" +</pre> + +<p>Dodanie do czegoś pustego string-a jest przydatnym sposobem na zamiane tego w string. </p> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Porówniania</a> w JavaScript wykonywane są za pomocą <code><</code>, <code>></code>, <code><=</code> oraz <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">>=</span></font>. Działają one zarówno ze string-ami jak i numerami. Równość jest trochę mniej prosta. Podwójny operator równości wykonuje przymusowe sprawdzenie kiedy podane zostały wartości o dwóch różnych typach, co czasami może dawać interesujące wyniki:</p> + +<pre class="brush: js">123 == '123'; // true +1 == true; // true + +</pre> + +<p>Aby uniknąć przymusowego sprawdzenia, użyj potrójnego operatora równości:</p> + +<pre class="brush: js">123 === '123'; // false +1 === true; // false +</pre> + +<p>Dodatkowo występują operatory <code>!=</code> oraz <code>!==</code>.</p> + +<p>JavaScript posiada również <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">operacje bitowe</a>.</p> + +<h2 id="Struktury_kontroli">Struktury kontroli</h2> + +<p>JavaScript posiada podobny zestaw struktur kontorli do innych języków rodziny C. Instrukcje warunkowe są wspierane przez <code>if</code> oraz <code>else</code>; jeśli chcesz możesz je ze sobą łączyć:</p> + +<pre class="brush: js">var name = 'kotki'; +if (name == 'pieski') { + name += ' hau'; +} else if (name == 'kotki') { + name += ' miau'; +} else { + name += '!'; +} +name == 'kotki miau'; +</pre> + +<p>JavaScript ma pętle <code>while</code> i <code>do-while</code>. Pierwsza jest dobra do prostych pętli; druga, jeśli chcesz mieć pewność, że funkcja zostanie wykonana przynajmniej raz:</p> + +<pre class="brush: js">while (true) { + // an infinite loop! +} + +var input; +do { + input = get_input(); +} while (inputIsNotValid(input)); +</pre> + +<p>W JavaScript pętla <code>for</code> działa w taki sam sposób jak w C i Java: pozwala na zapewnienie informacji dla pętli w jednej lini.</p> + +<pre class="brush: js">for (var i = 0; i < 5; i++) { + // Will execute 5 times +} +</pre> + +<p>JavaScript dodatkowo posiada dwie inne znaczące pętle for: <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></p> + +<pre class="brush: js">for (let value of array) { + // działania na value +} +</pre> + +<p>oraz <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for</code>...<code>in</code></a>:</p> + +<pre class="brush: js">for (let własność in obiekt) { + // działania na własności obiektu +} +</pre> + +<p>Operatory <code>&&</code> oraz <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">|<code>|</code></span></font> w których wykonanie drugiego operanda zależne jest od pierwszego. Przydatne do sprawdzania istnienia obiektu przed przypisaniem do niego atrybutów:</p> + +<pre class="brush: js">var name = o && o.getName(); + +</pre> + +<p>Lub do cachowania wartości (kiedy wartości nieprawdziwe są nieprawidłowe):</p> + +<pre class="brush: js">var name = cachedName || (cachedName = getName()); +</pre> + +<p>JavaScript posiada potrójny operator dla wyrażeń warunkowych:</p> + +<pre class="brush: js">var allowed = (age > 18) ? 'yes' : 'no'; +</pre> + +<p>Warunek <code>switch</code> może być używany dla wielu odgałęzień na podstawie liczby lub ciągu znaków:</p> + +<pre class="brush: js">switch (action) { + case 'draw': + drawIt(); + break; + case 'eat': + eatIt(); + break; + default: + doNothing(); +} +</pre> + +<p>Jeśli nie dodasz warunku <code>break</code>, wykonanie "przeskoczy" do następnego warunku. Takie działanie jest bardzo rzadko pożądane - w rzeczywistości warto opisać celowy "przeskok" w komentarzu w celu ułatwienia debugowania:</p> + +<pre class="brush: js">switch (a) { + case 1: // przeskok + case 2: + eatIt(); + break; + default: + doNothing(); +} +</pre> + +<p>Domyślny (<code>default</code>) warunek jest opcjonalny. Możesz mieć wyrażenia zarówno w części przełącznika (<code>switch</code>), jak i w przypadku (<code>case</code>); porównania między nimi odbywają się przy pomocy operatora <code>===</code>: </p> + +<pre class="brush: js">switch (1 + 3) { + case 2 + 2: + yay(); + break; + default: + neverhappens(); +} +</pre> + +<h2 id="Obiekty">Obiekty</h2> + +<p>Obiekty w JavaScript można opisać jako prostą kolekcję par nazwa-wartość. Jako takie podobne są do:</p> + +<ul> + <li>Słowniki w Pythonie.</li> + <li>Tablic asocjacyjnych w Perl i Ruby.</li> + <li>Tablic asocjacyjnych w C i C++.</li> + <li>Map w Javie.</li> + <li>Tablic asocjacyjnych w PHP.</li> +</ul> + +<p>Ze względu na popularność tej struktury danych są one świadectwem wszechstronności. Ponieważ wszystko (poza typami prostymi) jest traktowane w JavaScript jak obiekt, każdy program JavaScript naturalnie objemuje dużą ilość wyszukiwań w tablicach mieszających. Dobrze, że są one takie szybkie!</p> + +<p>Część "nazwa" jest stringiem, natomiast wartość może być każdą wartością JavaScript- nawet kolejnym obiektem. Pozwala to na budowanie struktur danych o dowolnej złożoności.</p> + +<p>Istnieją dwa podstawowe sposoby tworzenia pustego obiektu:</p> + +<pre class="brush: js">var obj = new Object(); +</pre> + +<p>Oraz:</p> + +<pre class="brush: js">var obj = {}; +</pre> + +<p>These are semantically equivalent; the second is called object literal syntax and is more convenient. This syntax is also the core of JSON format and should be preferred at all times.</p> + +<p>Semantycznie obie wersje są równe; druga, nazywana jest literalną składnią obiektu, jest wygodniejsza. Ta składnia jest dodatkowo kluczowym formatem JSON i powinna być preferowana w użyciu.</p> + +<p>Literalna składnia może być użyta do zainicjowania obiektu w całości:</p> + +<pre class="brush: js">var auto = { + marka: 'Ford', + model: 'Fiesta', + detale: { + kolor: 'grafitowy', + konieMechaniczne: 96 + } +}; +</pre> + +<p>Dostęp do atrybutu może być ze sobą połączony:</p> + +<pre class="brush: js">obj.detale.kolor; // grafitowy +obj['detale']['konieMechaniczne']; // 96 +</pre> + +<p>The following example creates an object prototype, <code>Person</code> and an instance of that prototype, <code>you</code>.</p> + +<p>Poniższy przykład tworzy prototyp obiektu <code>Person</code> i jego instancję, <code>marek</code>.</p> + +<pre class="brush: js">function Person(imie, wiek) { + this.imie = imie; + this.wiek = wiek; +} + +// Definiowanie obiektu +var marek = new Person('Marek', 24); +// Stworzyliśmy nową osobę o imieniu 'Marek' i wieku 24 lat. + +</pre> + +<p><strong>Once created</strong>, an object's properties can again be accessed in one of two ways:</p> + +<p>Do właściwości stworzonego obiektu można uzyskać dostep na dwa sposoby:</p> + +<pre class="brush: js">// notacja kropkowa ( <code>dot notation )</code> +obj.name = 'Simon'; +var name = obj.name; +</pre> + +<p>oraz...</p> + +<pre class="brush: js">// notacją nawiasową ( bracket notation ) +obj['name'] = 'Simon'; +var name = obj['name']; +// zmienna może być użyta do zdefiniowania wartości klucza +var user = prompt('what is your key?') +obj[user] = prompt('what is its value?') +</pre> + +<p>Te notacje także są semantycznie jednakowe. Druga metoda ma tę zaletę, że nazwa własności podawana jest jako string, dzięki czemu obliczana jest w czasie wykonywania. Jednak użycie tej metody zapobiega zastosowaniu niektórych mechanizmów JavaScript i procesów minifikacji. Może też być używany do ustawiania i pobierania własności z nazwami wykorzystującymi <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords">słowa zastrzeżone</a>: </p> + +<pre class="brush: js">obj.for = 'Simon'; // Syntax error, ponieważ 'for' jest zastrzeżone +obj['for'] = 'Simon'; // kod działa +</pre> + +<div class="note"> +<p>Począwszy od ECMAScript 5, słowa zastrzeżone mogą być używane jako nazwy własności obiektów "w locie". Oznacza to, że nie muszą być zamknięte w cudzysłów podczas definiowania obiektu notacją literałową. Zobacz <a href="http://es5.github.io/#x7.6.1">specyfikację ES5</a>.</p> +</div> + +<p>For more on objects and prototypes see <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype">Object.prototype</a>. For an explanation of object prototypes and the object prototype chains see <a href="/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain">Inheritance and the prototype chain</a>.</p> + +<p>Po więcej informacji na temat obiektów i prototypów zobacz <a href="pl/docs/Web/JavaScript/Referencje/Obiekty/Object/prototype">Object.prototype</a>. Wyjaśnienie prototypów obiektów i łańcuch prototypów zobacz <a href="/pl/docs/Web/JavaScript/dziedziczenie_lancuch_prototypow">dziedziczenie i łańcuch prototypów</a>.</p> + +<h2 id="Tablice">Tablice</h2> + +<p>Tablice w JavaScript są specialnym typem obiektu. Działają bardzo podobnie do zwykłych obiektów, jednak posiadają jedną magiczną właściwość <code>'length'</code>. Jest ona zawsze o jeden więcej niż najwyższy index w tablicy.</p> + +<p>Poniżej jeden z sposób tworzenia tablcy:</p> + +<pre class="brush: js">var a = new Array(); +a[0] = 'pies'; +a[1] = 'kot'; +a[2] = 'hen'; +a.length; // 3 +</pre> + +<p><span class="tlid-translation translation" lang="pl"><span title="">Bardziej dogodną notacją jest użycie literału tablicy:</span></span></p> + +<pre class="brush: js">var a = ['dog', 'cat', 'hen']; +a.length; // 3 +</pre> + +<p><span class="tlid-translation translation" lang="pl"><span title="">Zauważ, że</span></span> <code>array.length</code> <span class="tlid-translation translation" lang="pl"><span title="">niekoniecznie jest liczbą elementów w tablicy.</span></span> <span class="tlid-translation translation" lang="pl"><span title="">Rozważ następujący zapis:</span></span></p> + +<pre class="brush: js">var a = ['dog', 'cat', 'hen']; +a[100] = 'fox'; +a.length; // 101 +</pre> + +<p><span class="tlid-translation translation" lang="pl"><span title="">Pamiętaj - długość tablicy jest o jeden większa niż najwyższy indeks.</span></span></p> + +<p>If you query a non-existent array index, you'll get a value of <code>undefined</code> in return:</p> + +<pre class="brush: js">typeof a[90]; // undefined +</pre> + +<p>If you take the above about <code>[]</code> and <code>length</code> into account, you can iterate over an array using the following <code>for</code> loop:</p> + +<pre class="brush: js">for (var i = 0; i < a.length; i++) { + // Do something with a[i] +} +</pre> + +<p>ECMAScript introduced the more concise <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for</code>...<code>of</code></a> loop for iterable objects such as arrays:</p> + +<pre class="brush:js">for (const currentValue of a) { + // Do something with currentValue +}</pre> + +<p>You could also iterate over an array using a <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in" title="/en/JavaScript/Reference/Statements/for...in"><code>for</code>...<code>in</code></a> loop, however this does not iterate over the array elements, but the array indices. Furthermore, if someone added new properties to <code>Array.prototype</code>, they would also be iterated over by such a loop. Therefore this loop type is not recommended for arrays.</p> + +<p>Another way of iterating over an array that was added with ECMAScript 5 is <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach">forEach()</a></code>:</p> + +<pre class="brush: js">['dog', 'cat', 'hen'].forEach(function(currentValue, index, array) { + // Do something with currentValue or array[index] +}); +</pre> + +<p>If you want to append an item to an array simply do it like this:</p> + +<pre class="brush: js">a.push(item);</pre> + +<p>Arrays come with a number of methods. See also the <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array">full documentation for array methods</a>.</p> + +<table> + <thead> + <tr> + <th scope="col">Method name</th> + <th scope="col">Description</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>a.toString()</code></td> + <td>Returns a string with the <code>toString()</code> of each element separated by commas.</td> + </tr> + <tr> + <td><code>a.toLocaleString()</code></td> + <td>Returns a string with the <code>toLocaleString()</code> of each element separated by commas.</td> + </tr> + <tr> + <td><code>a.concat(item1[, item2[, ...[, itemN]]])</code></td> + <td>Returns a new array with the items added on to it.</td> + </tr> + <tr> + <td><code>a.join(sep)</code></td> + <td>Converts the array to a string — with values delimited by the <code>sep</code> param</td> + </tr> + <tr> + <td><code>a.pop()</code></td> + <td>Removes and returns the last item.</td> + </tr> + <tr> + <td><code>a.push(item1, ..., itemN)</code></td> + <td>Appends items to the end of the array.</td> + </tr> + <tr> + <td><code>a.reverse()</code></td> + <td>Reverses the array.</td> + </tr> + <tr> + <td><code>a.shift()</code></td> + <td>Removes and returns the first item.</td> + </tr> + <tr> + <td><code>a.slice(start[, end])</code></td> + <td>Returns a sub-array.</td> + </tr> + <tr> + <td><code>a.sort([cmpfn])</code></td> + <td>Takes an optional comparison function.</td> + </tr> + <tr> + <td><code>a.splice(start, delcount[, item1[, ...[, itemN]]])</code></td> + <td>Lets you modify an array by deleting a section and replacing it with more items.</td> + </tr> + <tr> + <td><code>a.unshift(item1[, item2[, ...[, itemN]]])</code></td> + <td>Prepends items to the start of the array.</td> + </tr> + </tbody> +</table> + +<h2 id="Functions">Functions</h2> + +<p>Along with objects, functions are the core component in understanding JavaScript. The most basic function couldn't be much simpler:</p> + +<pre class="brush: js">function add(x, y) { + var total = x + y; + return total; +} +</pre> + +<p>This demonstrates a basic function. A JavaScript function can take 0 or more named parameters. The function body can contain as many statements as you like and can declare its own variables which are local to that function. The <code>return</code> statement can be used to return a value at any time, terminating the function. If no return statement is used (or an empty return with no value), JavaScript returns <code>undefined</code>.</p> + +<p>The named parameters turn out to be more like guidelines than anything else. You can call a function without passing the parameters it expects, in which case they will be set to <code>undefined</code>.</p> + +<pre class="brush: js">add(); // NaN +// You can't perform addition on undefined +</pre> + +<p>You can also pass in more arguments than the function is expecting:</p> + +<pre class="brush: js">add(2, 3, 4); // 5 +// added the first two; 4 was ignored +</pre> + +<p>That may seem a little silly, but functions have access to an additional variable inside their body called <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments" title="/en/JavaScript/Reference/Functions_and_function_scope/arguments"><code>arguments</code></a>, which is an array-like object holding all of the values passed to the function. Let's re-write the add function to take as many values as we want:</p> + +<pre class="brush: js">function add() { + var sum = 0; + for (var i = 0, j = arguments.length; i < j; i++) { + sum += arguments[i]; + } + return sum; +} + +add(2, 3, 4, 5); // 14 +</pre> + +<p>That's really not any more useful than writing <code>2 + 3 + 4 + 5</code> though. Let's create an averaging function:</p> + +<pre class="brush: js">function avg() { + var sum = 0; + for (var i = 0, j = arguments.length; i < j; i++) { + sum += arguments[i]; + } + return sum / arguments.length; +} + +avg(2, 3, 4, 5); // 3.5 +</pre> + +<p>This is pretty useful, but it does seem a little verbose. To reduce this code a bit more we can look at substituting the use of the arguments array through <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">Rest parameter syntax</a>. In this way, we can pass in any number of arguments into the function while keeping our code minimal. The <strong>rest parameter operator</strong> is used in function parameter lists with the format: <strong>...variable</strong> and it will include within that variable the entire list of uncaptured arguments that the function was called with. We will also replace the <strong>for</strong> loop with a <strong>for...of</strong> loop to return the values within our variable.</p> + +<pre class="brush: js">function avg(...args) { + var sum = 0; + for (let value of args) { + sum += value; + } + return sum / args.length; +} + +avg(2, 3, 4, 5); // 3.5 +</pre> + +<div class="note">In the above code, the variable <strong>args</strong> holds all the values that were passed into the function.<br> +<br> +It is important to note that wherever the rest parameter operator is placed in a function declaration it will store all arguments <em>after</em> its declaration, but not before. <em>i.e. function</em> <em>avg(</em><strong>firstValue, </strong><em>...args)</em><strong> </strong>will store the first value passed into the function in the <strong>firstValue </strong>variable and the remaining arguments in <strong>args</strong>. That's another useful language feature but it does lead us to a new problem. The <code>avg()</code> function takes a comma-separated list of arguments — but what if you want to find the average of an array? You could just rewrite the function as follows:</div> + +<pre class="brush: js">function avgArray(arr) { + var sum = 0; + for (var i = 0, j = arr.length; i < j; i++) { + sum += arr[i]; + } + return sum / arr.length; +} + +avgArray([2, 3, 4, 5]); // 3.5 +</pre> + +<p>But it would be nice to be able to reuse the function that we've already created. Luckily, JavaScript lets you call a function with an arbitrary array of arguments, using the {{jsxref("Function.apply", "apply()")}} method of any function object.</p> + +<pre class="brush: js">avg.apply(null, [2, 3, 4, 5]); // 3.5 +</pre> + +<p>The second argument to <code>apply()</code> is the array to use as arguments; the first will be discussed later on. This emphasizes the fact that functions are objects too.</p> + +<div class="note"> +<p>You can achieve the same result using the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a> in the function call.</p> + +<p>For instance: <code>avg(...numbers)</code></p> +</div> + +<p>JavaScript lets you create anonymous functions.</p> + +<pre class="brush: js">var avg = function() { + var sum = 0; + for (var i = 0, j = arguments.length; i < j; i++) { + sum += arguments[i]; + } + return sum / arguments.length; +}; +</pre> + +<p>This is semantically equivalent to the <code>function avg()</code> form. It's extremely powerful, as it lets you put a full function definition anywhere that you would normally put an expression. This enables all sorts of clever tricks. Here's a way of "hiding" some local variables — like block scope in C:</p> + +<pre class="brush: js">var a = 1; +var b = 2; + +(function() { + var b = 3; + a += b; +})(); + +a; // 4 +b; // 2 +</pre> + +<p>JavaScript allows you to call functions recursively. This is particularly useful for dealing with tree structures, such as those found in the browser DOM.</p> + +<pre class="brush: js">function countChars(elm) { + if (elm.nodeType == 3) { // TEXT_NODE + return elm.nodeValue.length; + } + var count = 0; + for (var i = 0, child; child = elm.childNodes[i]; i++) { + count += countChars(child); + } + return count; +} +</pre> + +<p>This highlights a potential problem with anonymous functions: how do you call them recursively if they don't have a name? JavaScript lets you name function expressions for this. You can use named IIFEs (Immediately Invoked Function Expressions) as shown below:</p> + +<pre class="brush: js">var charsInBody = (function counter(elm) { + if (elm.nodeType == 3) { // TEXT_NODE + return elm.nodeValue.length; + } + var count = 0; + for (var i = 0, child; child = elm.childNodes[i]; i++) { + count += counter(child); + } + return count; +})(document.body); +</pre> + +<p>The name provided to a function expression as above is only available to the function's own scope. This allows more optimizations to be done by the engine and results in more readable code. The name also shows up in the debugger and some stack traces, which can save you time when debugging.</p> + +<p>Note that JavaScript functions are themselves objects — like everything else in JavaScript — and you can add or change properties on them just like we've seen earlier in the Objects section.</p> + +<h2 id="Custom_objects">Custom objects</h2> + +<div class="note">For a more detailed discussion of object-oriented programming in JavaScript, see <a href="/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introduction to Object-Oriented JavaScript</a>.</div> + +<p>In classic Object Oriented Programming, objects are collections of data and methods that operate on that data. JavaScript is a prototype-based language that contains no class statement, as you'd find in C++ or Java (this is sometimes confusing for programmers accustomed to languages with a class statement). Instead, JavaScript uses functions as classes. Let's consider a person object with first and last name fields. There are two ways in which the name might be displayed: as "first last" or as "last, first". Using the functions and objects that we've discussed previously, we could display the data like this:</p> + +<pre class="example-bad brush: js">function makePerson(first, last) { + return { + first: first, + last: last + }; +} +function personFullName(person) { + return person.first + ' ' + person.last; +} +function personFullNameReversed(person) { + return person.last + ', ' + person.first; +} + +s = makePerson('Simon', 'Willison'); +personFullName(s); // "Simon Willison" +personFullNameReversed(s); // "Willison, Simon" +</pre> + +<p>This works, but it's pretty ugly. You end up with dozens of functions in your global namespace. What we really need is a way to attach a function to an object. Since functions are objects, this is easy:</p> + +<pre class="brush: js">function makePerson(first, last) { + return { + first: first, + last: last, + fullName: function() { + return this.first + ' ' + this.last; + }, + fullNameReversed: function() { + return this.last + ', ' + this.first; + } + }; +} + +s = makePerson('Simon', 'Willison'); +s.fullName(); // "Simon Willison" +s.fullNameReversed(); // "Willison, Simon" +</pre> + +<p>There's something here we haven't seen before: the <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this" title="/en/JavaScript/Reference/Operators/this">this</a></code> keyword. Used inside a function, <code>this</code> refers to the current object. What that actually means is specified by the way in which you called that function. If you called it using <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Accessing_properties" title="/en/JavaScript/Reference/Operators/Member_Operators">dot notation or bracket notation</a> on an object, that object becomes <code>this</code>. If dot notation wasn't used for the call, <code>this</code> refers to the global object.</p> + +<p>Note that <code>this</code> is a frequent cause of mistakes. For example:</p> + +<pre class="brush: js">s = makePerson('Simon', 'Willison'); +var fullName = s.fullName; +fullName(); // undefined undefined +</pre> + +<p>When we call <code>fullName()</code> alone, without using <code>s.fullName()</code>, <code>this</code> is bound to the global object. Since there are no global variables called <code>first</code> or <code>last</code> we get <code>undefined</code> for each one.</p> + +<p>We can take advantage of the <code>this</code> keyword to improve our <code>makePerson</code> function:</p> + +<pre class="brush: js">function Person(first, last) { + this.first = first; + this.last = last; + this.fullName = function() { + return this.first + ' ' + this.last; + }; + this.fullNameReversed = function() { + return this.last + ', ' + this.first; + }; +} +var s = new Person('Simon', 'Willison'); +</pre> + +<p>We have introduced another keyword: <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new" title="/en/JavaScript/Reference/Operators/new">new</a></code>. <code>new</code> is strongly related to <code>this</code>. It creates a brand new empty object, and then calls the function specified, with <code>this</code> set to that new object. Notice though that the function specified with <code>this</code> does not return a value but merely modifies the <code>this</code> object. It's <code>new</code> that returns the <code>this</code> object to the calling site. Functions that are designed to be called by <code>new</code> are called constructor functions. Common practice is to capitalize these functions as a reminder to call them with <code>new</code>.</p> + +<p>The improved function still has the same pitfall with calling <code>fullName()</code> alone.</p> + +<p>Our person objects are getting better, but there are still some ugly edges to them. Every time we create a person object we are creating two brand new function objects within it — wouldn't it be better if this code was shared?</p> + +<pre class="brush: js">function personFullName() { + return this.first + ' ' + this.last; +} +function personFullNameReversed() { + return this.last + ', ' + this.first; +} +function Person(first, last) { + this.first = first; + this.last = last; + this.fullName = personFullName; + this.fullNameReversed = personFullNameReversed; +} +</pre> + +<p>That's better: we are creating the method functions only once, and assigning references to them inside the constructor. Can we do any better than that? The answer is yes:</p> + +<pre class="brush: js">function Person(first, last) { + this.first = first; + this.last = last; +} +Person.prototype.fullName = function() { + return this.first + ' ' + this.last; +}; +Person.prototype.fullNameReversed = function() { + return this.last + ', ' + this.first; +}; +</pre> + +<p><code>Person.prototype</code> is an object shared by all instances of <code>Person</code>. It forms part of a lookup chain (that has a special name, "prototype chain"): any time you attempt to access a property of <code>Person</code> that isn't set, JavaScript will check <code>Person.prototype</code> to see if that property exists there instead. As a result, anything assigned to <code>Person.prototype</code> becomes available to all instances of that constructor via the <code>this</code> object.</p> + +<p>This is an incredibly powerful tool. JavaScript lets you modify something's prototype at any time in your program, which means you can add extra methods to existing objects at runtime:</p> + +<pre class="brush: js">s = new Person('Simon', 'Willison'); +s.firstNameCaps(); // TypeError on line 1: s.firstNameCaps is not a function + +Person.prototype.firstNameCaps = function() { + return this.first.toUpperCase(); +}; +s.firstNameCaps(); // "SIMON" +</pre> + +<p>Interestingly, you can also add things to the prototype of built-in JavaScript objects. Let's add a method to <code>String</code> that returns that string in reverse:</p> + +<pre class="brush: js">var s = 'Simon'; +s.reversed(); // TypeError on line 1: s.reversed is not a function + +String.prototype.reversed = function() { + var r = ''; + for (var i = this.length - 1; i >= 0; i--) { + r += this[i]; + } + return r; +}; + +s.reversed(); // nomiS +</pre> + +<p>Our new method even works on string literals!</p> + +<pre class="brush: js">'This can now be reversed'.reversed(); // desrever eb won nac sihT +</pre> + +<p>As mentioned before, the prototype forms part of a chain. The root of that chain is <code>Object.prototype</code>, whose methods include <code>toString()</code> — it is this method that is called when you try to represent an object as a string. This is useful for debugging our <code>Person</code> objects:</p> + +<pre class="brush: js">var s = new Person('Simon', 'Willison'); +s.toString(); // [object Object] + +Person.prototype.toString = function() { + return '<Person: ' + this.fullName() + '>'; +} + +s.toString(); // "<Person: Simon Willison>" +</pre> + +<p>Remember how <code>avg.apply()</code> had a null first argument? We can revisit that now. The first argument to <code>apply()</code> is the object that should be treated as '<code>this</code>'. For example, here's a trivial implementation of <code>new</code>:</p> + +<pre class="brush: js">function trivialNew(constructor, ...args) { + var o = {}; // Create an object + constructor.apply(o, args); + return o; +} +</pre> + +<p>This isn't an exact replica of <code>new</code> as it doesn't set up the prototype chain (it would be difficult to illustrate). This is not something you use very often, but it's useful to know about. In this snippet, <code>...args</code> (including the ellipsis) is called the "<a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest arguments</a>" — as the name implies, this contains the rest of the arguments.</p> + +<p>Calling</p> + +<pre class="brush: js">var bill = trivialNew(Person, 'William', 'Orange');</pre> + +<p>is therefore almost equivalent to</p> + +<pre class="brush: js">var bill = new Person('William', 'Orange');</pre> + +<p><code>apply()</code> has a sister function named <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call" title="/en/JavaScript/Reference/Global_Objects/Function/call"><code>call</code></a>, which again lets you set <code>this</code> but takes an expanded argument list as opposed to an array.</p> + +<pre class="brush: js">function lastNameCaps() { + return this.last.toUpperCase(); +} +var s = new Person('Simon', 'Willison'); +lastNameCaps.call(s); +// Is the same as: +s.lastNameCaps = lastNameCaps; +s.lastNameCaps(); // WILLISON +</pre> + +<h3 id="Inner_functions">Inner functions</h3> + +<p>JavaScript function declarations are allowed inside other functions. We've seen this once before, with an earlier <code>makePerson()</code> function. An important detail of nested functions in JavaScript is that they can access variables in their parent function's scope:</p> + +<pre class="brush: js">function parentFunc() { + var a = 1; + + function nestedFunc() { + var b = 4; // parentFunc can't use this + return a + b; + } + return nestedFunc(); // 5 +} +</pre> + +<p>This provides a great deal of utility in writing more maintainable code. If a function relies on one or two other functions that are not useful to any other part of your code, you can nest those utility functions inside the function that will be called from elsewhere. This keeps the number of functions that are in the global scope down, which is always a good thing.</p> + +<p>This is also a great counter to the lure of global variables. When writing complex code it is often tempting to use global variables to share values between multiple functions — which leads to code that is hard to maintain. Nested functions can share variables in their parent, so you can use that mechanism to couple functions together when it makes sense without polluting your global namespace — "local globals" if you like. This technique should be used with caution, but it's a useful ability to have.</p> + +<h2 id="Closures">Closures</h2> + +<p>This leads us to one of the most powerful abstractions that JavaScript has to offer — but also the most potentially confusing. What does this do?</p> + +<pre class="brush: js">function makeAdder(a) { + return function(b) { + return a + b; + }; +} +var x = makeAdder(5); +var y = makeAdder(20); +x(6); // ? +y(7); // ? +</pre> + +<p>The name of the <code>makeAdder()</code> function should give it away: it creates new 'adder' functions, each of which, when called with one argument, adds it to the argument that it was created with.</p> + +<p>What's happening here is pretty much the same as was happening with the inner functions earlier on: a function defined inside another function has access to the outer function's variables. The only difference here is that the outer function has returned, and hence common sense would seem to dictate that its local variables no longer exist. But they <em>do</em> still exist — otherwise, the adder functions would be unable to work. What's more, there are two different "copies" of <code>makeAdder()</code>'s local variables — one in which <code>a</code> is 5 and the other one where <code>a</code> is 20. So the result of that function calls is as follows:</p> + +<pre class="brush: js">x(6); // returns 11 +y(7); // returns 27 +</pre> + +<p>Here's what's actually happening. Whenever JavaScript executes a function, a 'scope' object is created to hold the local variables created within that function. It is initialized with any variables passed in as function parameters. This is similar to the global object that all global variables and functions live in, but with a couple of important differences: firstly, a brand new scope object is created every time a function starts executing, and secondly, unlike the global object (which is accessible as <code>this</code> and in browsers as <code>window</code>) these scope objects cannot be directly accessed from your JavaScript code. There is no mechanism for iterating over the properties of the current scope object, for example.</p> + +<p>So when <code>makeAdder()</code> is called, a scope object is created with one property: <code>a</code>, which is the argument passed to the <code>makeAdder()</code> function. <code>makeAdder()</code> then returns a newly created function. Normally JavaScript's garbage collector would clean up the scope object created for <code>makeAdder()</code> at this point, but the returned function maintains a reference back to that scope object. As a result, the scope object will not be garbage-collected until there are no more references to the function object that <code>makeAdder()</code> returned.</p> + +<p>Scope objects form a chain called the scope chain, similar to the prototype chain used by JavaScript's object system.</p> + +<p>A <strong>closure</strong> is the combination of a function and the scope object in which it was created. Closures let you save state — as such, they can often be used in place of objects. You can find <a href="http://stackoverflow.com/questions/111102/how-do-javascript-closures-work">several excellent introductions to closures</a>.</p> diff --git a/files/pl/web/javascript/reference/classes/extends/index.html b/files/pl/web/javascript/reference/classes/extends/index.html new file mode 100644 index 0000000000..6b25a766e5 --- /dev/null +++ b/files/pl/web/javascript/reference/classes/extends/index.html @@ -0,0 +1,88 @@ +--- +title: extends +slug: Web/JavaScript/Reference/Classes/extends +tags: + - Classes + - ECMAScript 2015 + - JavaScript +translation_of: Web/JavaScript/Reference/Classes/extends +--- +<div>{{jsSidebar("Classes")}}</div> + +<p>Słowo kluczowe <strong><code>extends</code></strong> jest używane w <a href="/pl/docs/Web/JavaScript/Referencje/Polecenia/class">deklaracjach klas</a> lub <a href="/en-US/docs/Web/JavaScript/Reference/Operators/class">wyrażeniach class</a> do tworzenia klasy jako elementu potomnego innej klasy.</p> + +<div>{{EmbedInteractiveExample("pages/js/classes-extends.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">class ChildClass extends ParentClass { ... }</pre> + +<h2 id="Opis">Opis</h2> + +<p>Słowo kluczowe <code>extends</code> może być użyte do dziedziczenia po niestandardowych klasach lub standardowych obiektach wbudowanych.</p> + +<p>Prototypem rozszerzenia musi być {{jsxref("Object")}} lub {{jsxref("null")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Zastosowanie_extends">Zastosowanie <code>extends</code></h3> + +<p>Pierwszy przykład tworzy klasę <code>Square</code> rozszerzającą klasę <code>Polygon</code>. <a href="https://googlechrome.github.io/samples/classes-es6/index.html">live demo</a> <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">(source)</a>.</p> + +<pre class="brush: js notranslate">class Square extends Polygon { + constructor(length) { + // Wywołanie konstruktora klasy nadrzędnej + // określenie szerokości i wysokości wielokątu + super(length, length); + // Uwaga: W pochodnych klasach, super() musi być wywołane wcześniej niż + // pierwsze użycie 'this'. W przeciwnym wypadku pojawi się błąd odniesienia. + this.name = 'Square'; + } + + get area() { + return this.height * this.width; + } +}</pre> + +<h3 id="Zastosowanie_extends_z_obiektami_wbudowanymi">Zastosowanie <code>extends</code> z obiektami wbudowanymi</h3> + +<p>Poniższy przykład rozszerza wbudowany obiekt {{jsxref("Date")}}. <a href="https://googlechrome.github.io/samples/classes-es6/index.html">live demo</a> <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">(source)</a>.</p> + +<pre class="brush: js notranslate">class myDate extends Date { + + getFormattedDate() { + var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; + return this.getDate() + '-' + months[this.getMonth()] + '-' + this.getFullYear(); + } +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-class-definitions', 'extends')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + + + +<p>{{Compat("javascript.classes.extends")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Reference/Classes">Classes</a></li> + <li><a href="/pl/docs/Web/JavaScript/Reference/Classes/Konstruktor">Konstruktor</a></li> + <li><a href="/pl/docs/Web/JavaScript/Referencje/Operatory/super">super</a></li> + <li><a href="https://medium.com/beginners-guide-to-mobile-web-development/super-and-extends-in-javascript-es6-understanding-the-tough-parts-6120372d3420">Anurag Majumdar - Super & Extends in JavaScript</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/classes/index.html b/files/pl/web/javascript/reference/classes/index.html new file mode 100644 index 0000000000..81388acbc3 --- /dev/null +++ b/files/pl/web/javascript/reference/classes/index.html @@ -0,0 +1,410 @@ +--- +title: Classes +slug: Web/JavaScript/Reference/Classes +tags: + - Classes + - Constructors + - ECMAScript 2015 + - Inheritance + - Intermediate + - JavaScript + - TopicStub +translation_of: Web/JavaScript/Reference/Classes +--- +<div>{{JsSidebar("Classes")}}</div> + +<p>Klasy w Javascript zostały wprowadzone w ECMAScript 2015 jako lukier składniowy<strong> </strong>(ang. <em>syntactic sugar</em>) dla istniejącego, opartego na prototypach modelu dziedziczenia. Składnia klas <strong>nie</strong> wprowadza nowego zorientowanego obiektowo modelu dziedziczenia. Klasy wprowadzają znacznie prostszą i bardziej czytelną składnię do tworzenia obiektów i dziedziczenia.</p> + +<h2 id="Definiowanie_klas">Definiowanie klas</h2> + +<p>Klasy są w zasadzie "szczególnymi <a href="/pl/docs/Web/JavaScript/Reference/Functions">funkcjami</a>". Podobnie jak w funkcji można definiować <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operator_function">wyrażenie <code>function</code></a> i <a href="/pl/docs/Web/JavaScript/Reference/Statements/function">deklaracje funkcji</a>, tak składnia klasy posiada dwa komponenty: <a href="/pl/docs/Web/JavaScript/Reference/Operators/class">wyrażenie <code>class</code></a> i <a href="/pl/docs/Web/JavaScript/Reference/Statements/class">deklaracje klasy</a>.</p> + +<h3 id="Deklaracje_klas">Deklaracje klas</h3> + +<p>Jednym ze sposobów definiowania klas jest <strong>deklaracja klasy</strong>. Aby zadeklarować klasę, należy użyć słowa kluczowego <code>class</code> wraz z nazwą klasy (w tym przypadku "Prostokat").</p> + +<pre class="brush: js notranslate">class Prostokat { + constructor(wysokosc, szerokosc) { + this.wysokosc = wysokosc; + this.szerokosc = szerokosc; + } +}</pre> + +<h4 id="Hoisting">Hoisting</h4> + +<p>Ważną różnicą pomiędzy <strong>deklaracją funkcji</strong> a <strong>deklaracją klasy</strong> jest to, że deklaracje funkcji są przenoszone na początek ({{Glossary("Hoisting")}}) a klas nie. Najpierw musisz zadeklarować swoją klasę, by mieć do niej dostęp, w przeciwnym razie kod, jak ten poniżej, wygeneruje błąd {{jsxref("ReferenceError")}}:</p> + +<pre class="brush: js example-bad notranslate">var p = new Prostokat(); // ReferenceError + +class Prostokat {} +</pre> + +<h3 id="Wyrażenie_class">Wyrażenie <code>class</code></h3> + +<p><strong>Wyrażenie <code>class</code></strong> jest kolejnym sposobem definiowania klasy. Wyrażenia <code>class</code> mogą być nazwane lub nienazwane. Nazwa przypisana nazwanemu wyrażeniu <code>class</code> jest lokalna dla ciała klasy. (można ją odczytać z właściwości {{jsxref("Function.name", "name")}} klasy)</p> + +<pre class="brush: js notranslate">// nienazwane +var Prostokat = class { + constructor(wysokosc, szerokosc) { + this.wysokosc = wysokosc; + this.szerokosc = szerokosc; + } +}; +console.log(Prostokat.name); // Prostokat + +// nazwane +var Prostokat = class Prostokat2 { + constructor(wysokosc, szerokosc) { + this.wysokosc = wysokosc; + this.szerokosc = szerokosc; + } +}; +console.log(Prostokat.name); // Prostokat2 +</pre> + +<div class="note"> +<p><strong>Uwaga</strong>: <strong>Wyrażenia </strong><code>class</code> dotykają te same kwestie związane z przenoszeniem na początek (ang. hoisting) co wspomnianych <strong>deklaracji </strong>klas.</p> +</div> + +<h2 id="Ciało_klasy_i_definicje_metod">Ciało klasy i definicje metod</h2> + +<p>Ciało klasy jest umieszczane w nawiasach klamrowych <code>{}</code>. To tam definiuje się metody, czy konstruktory.</p> + +<h3 id="Tryb_ścisły">Tryb ścisły</h3> + +<p>Ciało klasy jest wykonywane w <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">trybie ścisłym</a> (ang. <em>strict mode</em>). W celu poprawienia wydajności, kod wykorzystywany tutaj podlega ścisłej składni; nie pozwala to na ukrycie niektórych wyjątków, a pewne słowa kluczowe są rezerwowane dla przyszłych wersji ECMAScript.</p> + +<h3 id="Konstruktor">Konstruktor</h3> + +<p><code><a href="/en-US/docs/Web/JavaScript/Reference/Classes/constructor">Constructor</a></code> jest szczególną metodą, która służy tworzeniu i inicjalizowaniu obiektu zdefiniowanego słowem kluczowym <code>class</code>. Dozwolony jest tylko jeden konstruktor w danej klasie. Jeśli klasa posiada więcej niż jedno wystąpienie metody <code>constructor</code>, wygenerowany zostanie błąd {{jsxref("SyntaxError")}}.</p> + +<p>Aby wywołać konstruktor klasy bazowej, należy użyć słowa kluczowego <code>super</code>.</p> + +<h3 id="Metody">Metody</h3> + +<p>Zobacz też <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions">definiowanie metod</a>.</p> + +<pre class="brush: js notranslate">class Prostokat { + constructor(wysokosc, szerokosc) { + this.wysokosc = wysokosc; + this.szerokosc = szerokosc; + } + // Getter + get pole() { + return this.liczPole(); + } + // Method + liczPole() { + return this.wysokosc * this.szerokosc; + } +} + +const kwadrat = new Prostokat(10, 10); + +console.log(kwadrat.pole); // 100</pre> + +<h3 id="Metody_i_właściwości_statyczne">Metody i właściwości statyczne</h3> + +<p>Słowo kluczowe <code><a href="/en-US/docs/Web/JavaScript/Reference/Classes/static">static</a></code> definiuje metodę kub właściwość statyczną w klasie. Statyczne metody i właściwości są wywoływane bez <a href="/pl/docs/Learn/JavaScript/Obiekty" title='An example of class instance is "var john = new Person();"'>inicjalizowania</a> ich klas i <strong>nie mogą</strong> być wywołane przez instancję klasy.</p> + +<pre class="brush: js notranslate">class Punkt { + constructor(x, y) { + this.x = x; + this.y = y; + } + + static nazwa = "Punkt"; + static odleglosc(a, b) { + const dx = a.x - b.x; + const dy = a.y - b.y; + + return Math.sqrt(dx*dx + dy*dy); + } +} + +const p1 = new Punkt(5, 5); +const p2 = new Punkt(10, 10); +p1.nazwa; // undefined +p1.odleglosc; // undefined +p2.nazwa; // undefined +p2.odleglosc; // undefined + +console.log(Punkt.nazwa); // "Punkt" +console.log(Punkt.odleglosc(p1, p2)); // 7.0710678118654755</pre> + +<h3 id="Powiązanie_this_z_metodami_niestatycznymi_i_statycznymi">Powiązanie <code>this</code> z metodami niestatycznymi i statycznymi</h3> + +<p>Kiedy metoda typu <code>static</code> lub <code>prototype</code> jest wywoływana bez <code>this</code> (na przykład poprzez przypisanie metody do zmiennej), wtedy <code>this</code><em> </em>będzie <code>undefined</code> w środku metody. Takie zachowanie będzie takie same, nawet jeżeli dyrektywa <code>"use strict"</code> nie będzie obecna, ponieważ kod w obrębie metody danej klasy zawsze będzie wykonywał się jako <code>strict mode</code>.</p> + +<pre class="brush: js notranslate">class Animal { + speak() { + return this; + } + static eat() { + return this; + } +} + +let obj = new Animal(); +obj.speak(); // obiekt Animal +let speak = obj.speak; +speak(); // undefined + +Animal.eat(); // klasa Animal +let eat = Animal.eat; +eat(); // undefined</pre> + +<p>Jeśli przepiszemy powyższy przykład z użyciem tradycyjnych funkcji bez dyrektywy <code>"use strict"</code>, to <code>this</code> wywołane w metodzie będzie automatycznie przypisane do pierwotnej wartości <code>this</code>, którą domyślnie jest <a href="/en-US/docs/Glossary/Global_object">global object</a>.</p> + +<pre class="brush: js notranslate">function Animal() { } + +Animal.prototype.speak = function() { + return this; +} + +Animal.eat = function() { + return this; +} + +let obj = new Animal(); +let speak = obj.speak; +speak(); // global object + +let eat = Animal.eat; +eat(); // global object +</pre> + +<h3 id="Właściwości_instancji">Właściwości instancji</h3> + +<p>Właściwości instancji muszą być zdefiniowane wewnątrz metody klasy:</p> + +<pre class="brush: js notranslate">class Rectangle { + constructor(height, width) { + this.height = height; + this.width = width; + } +}</pre> + +<p>Statyczne właściwości i właściwości prototypu muszą być zdefiniowane poza ciałem klasy:</p> + +<pre class="brush: js notranslate">Rectangle.staticWidth = 20; +Rectangle.prototype.prototypeWidth = 25;</pre> + +<h3 id="Deklaracje_pól">Deklaracje pól</h3> + +<div class="blockIndicator warning"> +<p>Publiczna i prywatne deklaracje pól są <a href="https://github.com/tc39/proposal-class-fields">funkcjonalnościami eksperymentalnymi</a> zaproponowanymi na <a href="https://tc39.es">TC39</a>. Wsparcie przeglądarek jest ograniczone, ale ta funkcjonalność może być używana przy użyciu systemów takich jak <a href="https://babeljs.io/">Babel</a>. </p> +</div> + +<h4 id="Deklaracje_pól_publicznych">Deklaracje pól publicznych</h4> + +<p>Przy użyciu deklaracji pól, powyższy przykład może być przepisany na:</p> + +<pre class="brush: js notranslate">class Rectangle { + height = 0; + width; + constructor(height, width) { + this.height = height; + this.width = width; + } +} +</pre> + +<p>Dzięki deklarowaniu pól na początku klasy, definicje klas stają się bardziej samodokumentujące, a pola są zawsze obecne.</p> + +<p>Jak widać w powyższym przykładzie, pola mogą być zadeklarowane z lub bez domyślnej wartości.</p> + +<p>Zobacz <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Public_class_fields">public class fields</a> po więcej informacji.</p> + +<h4 id="Deklaracje_pól_prywatnych">Deklaracje pól prywatnych</h4> + +<p>Używając deklaracji pól prywatnych, definicja może być zapisana w taki sposób:</p> + +<pre class="brush: js notranslate">class Rectangle { + #height = 0; + #width; + constructor(height, width) { + this.#height = height; + this.#width = width; + } +} +</pre> + +<p>Próba odniesienia się do prywatnego pola poza ciałem klasy wygeneruje błąd. Prywatne pola mogą być tylko odczytywane i modyfikowane wewnątrz ciała klasy. Poprzez definicję właściwości niewidocznych poza ciałem klasy, można zapewnić, że użytkownicy klasy nie będą polegali na jej wewnętrznych właściwościach.</p> + +<div class="note"> +<p>Pola prywatne mogą być tylko zadeklarowane na początku ciała klasy</p> +</div> + +<p>Prywatnych pól nie da się utworzyć później, poprzez przypisywanie, tak jak normalnych właściwości.</p> + +<p>Po więcej informacji zobacz <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Private_class_fields">private class fields</a>.</p> + +<h2 id="Podklasy_z_extends">Podklasy z <code>extends</code></h2> + +<p>Słowo kluczowe <code><a href="/en-US/docs/Web/JavaScript/Reference/Classes/extends">extends</a></code> jest używane w <em>deklaracjach klas</em> lub <em>wyrażeniach klas</em> do tworzenia klasy jako elementu potomnego innej klasy.</p> + +<pre class="brush: js notranslate">class Animal { + constructor(name) { + this.name = name; + } + + speak() { + console.log(this.name + ' makes a noise.'); + } +} + +class Dog extends Animal { + constructor(name) { + super(name); // wywyłanie konstruktora klasy nadrzędnej poprzez użycie super() + } + speak() { + console.log(this.name + ' barks.'); + } +} + +let d = new Dog('Mitzie'); +d.speak(); // Mitzie barks. +</pre> + +<p>Jeśli w podklasie znajduje się konstruktor, musi najpierw wywołać super() przed użyciem "this".</p> + +<p>Można również rozszerzyć tradycyjne klasy oparte na funkcjach:</p> + +<pre class="brush: js notranslate">function Animal (name) { + this.name = name; +} + +Animal.prototype.speak = function () { + console.log(this.name + ' makes a noise.'); +} + +class Dog extends Animal { + speak() { + console.log(this.name + ' barks.'); + } +} + +let d = new Dog('Mitzie'); +d.speak(); // Mitzie barks +</pre> + +<p>Zwróć uwagę, że klasy nie mogą rozszerzać zwykłych (niezdatnych do konstrukcji) obiektów. Jeśli chcesz dziedziczyć po zwykłym obiekcie, możesz, zamiast tego użyć {{jsxref ("Object.setPrototypeOf()")}}:</p> + +<pre class="brush: js notranslate">var Animal = { + speak() { + console.log(this.name + ' makes a noise.'); + } +}; + +class Dog { + constructor(name) { + this.name = name; + } +} + +Object.setPrototypeOf(Dog.prototype, Animal);// If you do not do this you will get a TypeError when you invoke speak + +let d = new Dog('Mitzie'); +d.speak(); //Mitzie makes a noise. +</pre> + +<h2 id="Species">Species</h2> + +<p>Jeśli chcesz zwrócić obiekt {{jsxref("Array")}} w twojej klasie <code>MyArray</code>, która dziedziczy po <code>Array</code>, to możesz użyć wzorca "species", który pozwala na nadpisywanie domyślnych konstruktorów.</p> + +<p>Na przykład, wywołanie metody {{jsxref("Array.map", "map()")}} zwraca domyślny konstruktor <code>MyArray</code>. Użycie {{jsxref("Symbol.species")}} pozwala na nadpisanie tego zachowania tak, by zwracany był obiekt typu <code>Array</code>, a nie <code>MyArray</code>:</p> + +<pre class="brush: js notranslate">class MyArray extends Array { + // Nadpisanie domyślnego kontruktora + static get [Symbol.species]() { return Array; } +} + +var a = new MyArray(1,2,3); +var mapped = a.map(x => x * x); + +console.log(mapped instanceof MyArray); // false +console.log(mapped instanceof Array); // true +</pre> + +<h2 id="Słowo_kluczowe_super">Słowo kluczowe <code>super</code></h2> + +<p>Słowo kluczowe <strong>super </strong>jest wykorzystywane do udostępniania i korzystania z funkcji klasy, po której nasz obiekt dziedziczy.</p> + +<pre class="brush: js notranslate">class Cat { + constructor(name) { + this.name = name; + } + + speak() { + console.log(`${this.name} makes a noise.`); + } +} + +class Lion extends Cat { + speak() { + super.speak(); + console.log(`${this.name} roars.`); + } +} + +let l = new Lion('Fuzzy'); +l.speak(); +// Fuzzy makes a noise. +// Fuzzy roars.</pre> + +<h2 id="Mix-ins">Mix-ins</h2> + +<p>Abstrakcyjne podklasy lub <em>mix-ins</em> są szablonami dla klas. Klasa może mieć tylko jedną klasę nadrzędną, więc dziedziczenie z wielu klas jest niemożliwe. Cała funkcjonalność musi być dostarczona przez jedną klasę nadrzędną.</p> + +<p>Funkcja przyjmująca klasę nadrzędną jako argument i zwracająca podklasę rozszerzającą klasę nadrzędną może być użyta do implementacji mix-in'ów:</p> + +<pre class="brush: js notranslate">var calculatorMixin = Base => class extends Base { + calc() { } +}; + +var randomizerMixin = Base => class extends Base { + randomize() { } +}; +</pre> + +<p>Klasa używająca tych mix-in'ów może być zapisana w taki sposób:</p> + +<pre class="brush: js notranslate">class Foo { } +class Bar extends calculatorMixin(randomizerMixin(Foo)) { }</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<p>{{Compat("javascript.classes")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions">Functions</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class"><code>class</code> declaration</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> expression</a></li> + <li>{{jsxref("Operators/super", "super")}}</li> + <li><a href="https://hacks.mozilla.org/2015/07/es6-in-depth-classes/">Blog post: "ES6 In Depth: Classes"</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/classes/konstruktor/index.html b/files/pl/web/javascript/reference/classes/konstruktor/index.html new file mode 100644 index 0000000000..353adecd19 --- /dev/null +++ b/files/pl/web/javascript/reference/classes/konstruktor/index.html @@ -0,0 +1,188 @@ +--- +title: Konstruktor +slug: Web/JavaScript/Reference/Classes/Konstruktor +tags: + - Classes + - JavaScript + - Language feature +translation_of: Web/JavaScript/Reference/Classes/constructor +--- +<div>{{jsSidebar("Classes")}}</div> + +<p>Konstruktor <span id="result_box" lang="pl"><span>jest specjalną metodą tworzenia i inicjowania obiektu utworzonego w klasie.</span></span></p> + +<p>{{EmbedInteractiveExample("pages/js/classes-constructor.html")}}</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">constructor([arguments]) { ... }</pre> + +<h2 id="Opis">Opis</h2> + +<p>Konstruktor umożliwia zdefiniowanie inicjalizacji obiektu, która musi się wykonać, zanim będzie można wywołać metody obiektu.</p> + +<pre class="brush: js notranslate">class Person { + + constructor(name) { + this.name = name; + } + + introduce() { + console.log(`Hello, my name is ${this.name}`); + } + +} + +const otto = new Person('Otto'); + +otto.introduce();</pre> + +<p>Jeśli niestandardowy konstruktor nie został podany, to domyślny konstruktor będzie użyty. Dla klas bazowych konstruktor domyślny jest pusty:</p> + +<pre class="brush: js notranslate">constructor() {}</pre> + +<p>Dla klas pochodnych domyślny konstruktor wywołuje konstruktor klasy nadrzędnej:</p> + +<pre class="brush: js notranslate">constructor(...args) { + super(...args); +}</pre> + +<p>Pozwala to na działanie takiego kodu:</p> + +<pre class="brush: js notranslate">class ValidationError extends Error { + + printCustomerMessage() { + return `Validation failed :-( (details: ${this.message})`; + } + +} + +try { + throw new ValidationError("Not a valid phone number"); +} catch (error) { + if (error instanceof ValidationError) { + console.log(error.name); // This is Error instead of ValidationError! + console.log(error.printCustomerMessage()); + } else { + console.log('Unknown error', error); + throw error; + } +}</pre> + +<p>Klasa <code>ValidationError</code> nie musi mieć niestandardowego konstruktora, ponieważ domyślny konstruktor wywołuje konstruktor klasy <code>Error</code>.</p> + +<p>Jeśli jednak klasa <code>ValidationError</code> ma niestandardowy konstruktor, to musi on wywoływać konstruktor klasy nadrzędnej przy użyciu <code>super</code>:</p> + +<pre class="brush: js notranslate">class ValidationError extends Error { + + constructor(message) { + super(message); // call parent class constructor + this.name = 'ValidationError'; + this.code = '42'; + } + + printCustomerMessage() { + return `Validation failed :-( (details: ${this.message}, code: ${this.code})`; + } + +} + +try { + throw new ValidationError("Not a valid phone number"); +} catch (error) { + if (error instanceof ValidationError) { + console.log(error.name); // Now this is ValidationError! + console.log(error.printCustomerMessage()); + } else { + console.log('Unknown error', error); + throw error; + } +}</pre> + +<p>Wewnątrz klasy może być tylko jedna metoda nazwana <code>constructor</code>. Jeżeli <code>constructor</code> wystąpi więcej niż jeden raz, to wygeneruje błąd {{jsxref("SyntaxError")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_konstruktora">Używanie konstruktora</h3> + +<p>Fragment kodu pochodzi z <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">classes sample</a> (<a href="https://googlechrome.github.io/samples/classes-es6/index.html">live demo</a>).</p> + +<pre class="brush: js notranslate">class Square extends Polygon { + constructor(length) { + // Wywołanie konstruktora klasy nadrzędnej + // określenie szerokości i wysokości wielokątu + super(length, length); + // Uwaga: W pochodnych klasach, super() musi być wywołane wcześniej niż + // pierwsze użycie 'this'. W przeciwnym wypadku pojawi się błąd odniesienia. + this.name = 'Square'; + } + + get area() { + return this.height * this.width; + } + + set area(value) { + this.area = value; + } +}</pre> + +<h3 id="Inny_przykład">Inny przykład</h3> + +<p>W tym przykładzie klasa <code>Square</code> jest zmieniona — ale konstruktor klasy <code>Polygon</code> nadal jest wywoływany przy tworzeniu nowej instancji klasy <code>Square</code>.</p> + +<pre class="brush: js notranslate">class Polygon { + constructor() { + this.name = "Polygon"; + } +} + +class Square extends Polygon { + constructor() { + super(); + } +} + +class Rectangle {} + +Object.setPrototypeOf(Square.prototype, Rectangle.prototype); + +console.log(Object.getPrototypeOf(Square.prototype) === Polygon.prototype); //false +console.log(Object.getPrototypeOf(Square.prototype) === Rectangle.prototype); //true + +let newInstance = new Square(); +console.log(newInstance.name); //Polygon</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-static-semantics-constructormethod', 'Constructor Method')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-static-semantics-constructormethod', 'Constructor Method')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<p>{{Compat("javascript.classes.constructor")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/super">super()</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> expression</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class"><code>class</code> declaration</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/classes/private_class_fields/index.html b/files/pl/web/javascript/reference/classes/private_class_fields/index.html new file mode 100644 index 0000000000..6b55474d5b --- /dev/null +++ b/files/pl/web/javascript/reference/classes/private_class_fields/index.html @@ -0,0 +1,205 @@ +--- +title: Private class fields +slug: Web/JavaScript/Reference/Classes/Private_class_fields +tags: + - Classes + - JavaScript + - Language feature +translation_of: Web/JavaScript/Reference/Classes/Private_class_fields +--- +<div>{{JsSidebar("Classes")}}</div> + +<p>Właściwości klas są domyślnie publiczne i mogą być wywoływane i modyfikowane poza klasą. Istnieje jednak <a href="https://github.com/tc39/proposal-class-fields">funkcjonalność eksperymentalna</a> pozwalająca na zdefiniowanie pól prywatnych klasy przy użyciu <code>#</code> przed nazwą pola.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">class ClassWithPrivateField { + #privateField +} + +class ClassWithPrivateMethod { + #privateMethod() { + return 'hello world' + } +} + +class ClassWithPrivateStaticField { + static #PRIVATE_STATIC_FIELD +} +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Prywatne_pola_statyczne">Prywatne pola statyczne</h3> + +<p>Pola prywatne są dostępne z poziomu konstruktora klasy ze środka ciała klasy.</p> + +<p>Prywatne pola statyczne są tylko dostępne z poziomu statycznych metod. </p> + +<pre class="brush: js notranslate">class ClassWithPrivateStaticField { + static #PRIVATE_STATIC_FIELD + + static publicStaticMethod() { + ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD = 42 + return ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD + } +} + +console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42)</pre> + +<p>Prywatne pola statyczne są dodawane do konstruktora klasy podczas wykonywania klasy.</p> + +<p>Tylko klasa, która definiuje prywatne pola statyczne, może mieć do nich dostęp.</p> + +<p>Może to prowadzić to nieoczekiwanego zachowania podczas używania <strong><code>this</code></strong>.</p> + +<pre class="brush: js notranslate">class BaseClassWithPrivateStaticField { + static #PRIVATE_STATIC_FIELD + + static basePublicStaticMethod() { + this.#PRIVATE_STATIC_FIELD = 42 + return this.#PRIVATE_STATIC_FIELD + } +} + +class SubClass extends BaseClassWithPrivateStaticField { } + +let error = null + +try { + SubClass.basePublicStaticMethod() +} catch(e) { error = e} + +console.assert(error instanceof TypeError) +</pre> + +<h3 id="Prywatne_pola_instancji">Prywatne pola instancji</h3> + +<p>Prywatne pola instancji są deklarowane przy użyciu <strong># names </strong>("<em>hash names</em>"), czyli nazw poprzedzonych <code>#</code>. Znak <code>#</code> jest częścią nazwy. Jest używany do deklaracji i dostępu do właściwości.</p> + +<p>Enkapsulacja jest wymuszona przez język. Próba dostępu do prywatnego pola poza klasą wygeneruje błąd <code>Syntax Error</code>.</p> + +<pre class="brush: js notranslate">class ClassWithPrivateField { + #privateField + + constructor() { + this.#privateField = 42 + this.#randomField = 444 // Syntax error + } +} + +const instance = new ClassWithPrivateField() +instance.#privateField === 42 // Syntax error +</pre> + +<h3 id="Prywatne_metody">Prywatne metody</h3> + +<h4 id="Prywatne_metody_statyczne">Prywatne metody statyczne</h4> + +<p>Podobnie jak ich publiczne odpowiedniki, prywatne metody statyczne są wywoływane przez samą klasę, a nie jej instancje. Podobnie jak pola prywatne, są dostępne tylko z poziomu ciała klasy.</p> + +<pre class="brush: js notranslate">class ClassWithPrivateStaticMethod { + static #privateStaticMethod() { + return 42 + } + + static publicStaticMethod1() { + return ClassWithPrivateStaticMethod.#privateStaticMethod(); + } + + static publicStaticMethod2() { + return this.#privateStaticMethod(); + } +} + +console.assert(ClassWithPrivateStaticMethod.publicStaticMethod1() === 42); +console.assert(ClassWithPrivateStaticMethod.publicStaticMethod2() === 42); +</pre> + +<p>Może to prowadzić do nieoczekiwanego zachowania przy używaniu <strong><code>this</code></strong>. W poniższym przykładzie <code>this</code> odnosi się do klasy <code>Derived</code> (a nie klasy <code>Base</code>) podczas wywołania metody <code>Derived.publicStaticMethod2()</code>, co powoduje błąd.</p> + +<pre class="brush: js notranslate">class Base { + static #privateStaticMethod() { + return 42; + } + static publicStaticMethod1() { + return Base.#privateStaticMethod(); + } + static publicStaticMethod2() { + return this.#privateStaticMethod(); + } +} + +class Derived extends Base {} + +console.log(Derived.publicStaticMethod1()); // 42 +console.log(Derived.publicStaticMethod2()); // TypeError +</pre> + +<h4 id="Prywatne_metody_instancji">Prywatne metody instancji</h4> + +<p>Prywatne metody instancji to metody dostępne dla instancji klasy, które mają podobne ograniczenia co prywatne pola instancji.</p> + +<pre class="brush: js notranslate">class ClassWithPrivateMethod { + #privateMethod() { + return 'hello world' + } + + getPrivateMessage() { + return this.#privateMethod() + } +} + +const instance = new ClassWithPrivateMethod() +console.log(instance.getPrivateMessage()) +// expected output: "hello world"</pre> + +<p>Prywatne metody mogą używać async lub być generatorami. Możliwe jest również tworzenie prywatnych getter'ów i setter'ów:</p> + +<pre class="brush: js notranslate">class ClassWithPrivateAccessor { + #message + + get #decoratedMessage() { + return `✨${this.#message}✨` + } + set #decoratedMessage(msg) { + this.#message = msg + } + + constructor() { + this.#decoratedMessage = 'hello world' + console.log(this.#decoratedMessage) + } +} + +new ClassWithPrivateAccessor(); +// expected output: "✨hello world✨" +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('Public and private instance fields', '#prod-FieldDefinition', 'FieldDefinition')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_2"><a id="Kompatybilność" name="Kompatybilność">Kompatybilność</a></h2> + + + +<p>{{Compat("javascript.classes.private_class_fields")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Reference/Classes/Public_class_fields">Public class fields</a></li> + <li><a href="https://rfrn.org/~shu/2018/05/02/the-semantics-of-all-js-class-elements.html">The Semantics of All JS Class Elements</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/classes/public_class_fields/index.html b/files/pl/web/javascript/reference/classes/public_class_fields/index.html new file mode 100644 index 0000000000..780300e64f --- /dev/null +++ b/files/pl/web/javascript/reference/classes/public_class_fields/index.html @@ -0,0 +1,269 @@ +--- +title: Public class fields +slug: Web/JavaScript/Reference/Classes/Public_class_fields +tags: + - Classes + - JavaScript + - Language feature +translation_of: Web/JavaScript/Reference/Classes/Public_class_fields +--- +<div>{{JsSidebar("Classes")}}</div> + +<div> +<div class="note"> +<p><strong>Ta strona opisuje funkcjonalności eksperymentalne</strong></p> + +<p>Deklaracje pól publicznych i prywatnych są <a class="external external-icon" href="https://github.com/tc39/proposal-class-fields" rel="noopener">funkcjonalnościami eksperymentalnymi (stage 3)</a> zaproponowanymi na <a class="external external-icon" href="https://tc39.github.io/beta/" rel="noopener">TC39</a>.</p> + +<p>Wsparcie przeglądarek jest ograniczone, ale ta funkcjonalność może być używana przy użyciu systemów takich jak <a class="external external-icon" href="https://babeljs.io/" rel="noopener">Babel</a>. Zobacz <a href="#Kompatybilność">tabelę kompatybilności</a> poniżej.</p> +</div> +</div> + +<p>Zarówno statyczne, jak i instancyjne pola publiczne są właściwościami zapisywalnymi, wyliczalnymi i konfigurowalnymi. W przeciwieństwie do ich prywatnych odpowiedników uczestniczą w dziedziczeniu prototypów.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">class ClassWithInstanceField { + instanceField = 'instance field' +} + +class ClassWithStaticField { + static staticField = 'static field' +} + +class ClassWithPublicInstanceMethod { + publicMethod() { + return 'hello world' + } +} +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Publiczne_pola_statyczne">Publiczne pola statyczne</h3> + +<p>Publiczne pola statyczne są użyteczne, gdy chcesz, aby pole istniało tylko raz dla danej klasy, a nie dla każdej tworzonej instancji klasy. Jest to użyteczne w przypadku cache'ów, stałej konfiguracji lub innych danych, które nie muszą być replikowane na wszystkich instancjach.</p> + +<p>Publiczne pola statyczne są deklarowane z użyciem słowa kluczowego <code>static</code>. Są dodawane do konstruktora klasy podczas jej wykonywania z użyciem {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}. Są one dostępne z poziomu konstruktora klasy.</p> + +<pre class="brush: js notranslate">class ClassWithStaticField { + static staticField = 'static field' +} + +console.log(ClassWithStaticField.staticField) +// expected output: "static field" +</pre> + +<p>Pola bez inicjalizatorów są ustawiane na <code>undefined</code>.</p> + +<pre class="brush: js notranslate">class ClassWithStaticField { + static staticField +} + +console.assert(ClassWithStaticField.hasOwnProperty('staticField')) +console.log(ClassWithStaticField.staticField) +// expected output: "undefined"</pre> + +<p>Publiczne pola statyczne nie są inicjalizowane ponownie w podklasach, ale można uzyskać do nich dostęp przez łańcuch prototypów.</p> + +<pre class="brush: js notranslate">class ClassWithStaticField { + static baseStaticField = 'base field' +} + +class SubClassWithStaticField extends ClassWithStaticField { + static subStaticField = 'sub class field' +} + +console.log(SubClassWithStaticField.subStaticField) +// expected output: "sub class field" + +console.log(SubClassWithStaticField.baseStaticField) +// expected output: "base field"</pre> + +<p>Przy inicjalizacji pól, <code>this</code> odnosi się do konstruktora klasy. Można się również odwołać przez nazwę i użyć <code>super</code> do otrzymania konstruktora klasy nadrzędnej (jeżeli istnieje).</p> + +<pre class="brush: js notranslate">class ClassWithStaticField { + static baseStaticField = 'base static field' + static anotherBaseStaticField = this.baseStaticField + + static baseStaticMethod() { return 'base static method output' } +} + +class SubClassWithStaticField extends ClassWithStaticField { + static subStaticField = super.baseStaticMethod() +} + +console.log(ClassWithStaticField.anotherBaseStaticField) +// expected output: "base static field" + +console.log(SubClassWithStaticField.subStaticField) +// expected output: "base static method output" +</pre> + +<h3 id="Publiczne_pola_instancyjne">Publiczne pola instancyjne</h3> + +<p>Publiczne pola instancyjne istnieją na każdej utworzonej instancji danej klasy. Poprzez zadeklarowanie pola publicznego, można zapewnić, że pole jest zawsze obecne, a definicja klasy jest bardziej samodokumentująca.</p> + +<p>Publiczne pola instancyjne są dodawane przy użyciu {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}} podczas wykonywania konstruktora klasy, lub po wywołaniu metody <code>super()</code>.</p> + +<pre class="brush: js notranslate">class ClassWithInstanceField { + instanceField = 'instance field' +} + +const instance = new ClassWithInstanceField() +console.log(instance.instanceField) +// expected output: "instance field"</pre> + +<p>Pola bez inicjalizatorów są ustawiane na <code>undefined</code>.</p> + +<pre class="brush: js notranslate">class ClassWithInstanceField { + instanceField +} + +const instance = new ClassWithInstanceField() +console.assert(instance.hasOwnProperty('instanceField')) +console.log(instance.instanceField) +// expected output: "undefined"</pre> + +<p>Podobnie jak właściwości, nazwy pól mogą być obliczane.</p> + +<pre class="brush: js notranslate">const PREFIX = 'prefix' + +class ClassWithComputedFieldName { + [`${PREFIX}Field`] = 'prefixed field' +} + +const instance = new ClassWithComputedFieldName() +console.log(instance.prefixField) +// expected output: "prefixed field"</pre> + +<p>Przy inicjalizacji pól <code>this</code> odnosi się do instancji klasy. Tak jak w publicznych metodach instancji, można odnieść się do klasy nadrzędnej, używając <code>super</code>.</p> + +<pre class="brush: js notranslate">class ClassWithInstanceField { + baseInstanceField = 'base field' + anotherBaseInstanceField = this.baseInstanceField + baseInstanceMethod() { return 'base method output' } +} + +class SubClassWithInstanceField extends ClassWithInstanceField { + subInstanceField = super.baseInstanceMethod() +} + +const base = new ClassWithInstanceField() +const sub = new SubClassWithInstanceField() + +console.log(base.anotherBaseInstanceField) +// expected output: "base field" + +console.log(sub.subInstanceField) +// expected output: "base method output"</pre> + +<h3 id="Publiczne_metody">Publiczne metody</h3> + +<h4 id="Publiczne_metody_statyczne">Publiczne metody statyczne</h4> + +<p>Słowo kluczowe <code><strong>static</strong></code> definiuje metodę statyczną dla klasy. Metody statyczne nie są wywoływane na instancjach klasy, ale na samej klasie. Są to często funkcje użytkowe, takie jak funkcje tworzenia lub klonowania obiektów.</p> + +<pre class="brush: js notranslate">class ClassWithStaticMethod { + static staticMethod() { + return 'static method has been called.'; + } +} + +console.log(ClassWithStaticMethod.staticMethod()); +// expected output: "static method has been called."</pre> + +<p>Metody statyczne są dodawane do konstruktora klasy z użyciem {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}} podczas wykonania klasy. Te metody są zapisywalne, niewyliczalne i konfigurowalne.</p> + +<h4 id="Publiczne_metody_instancyjne">Publiczne metody instancyjne</h4> + +<p>Jak nazwa wskazuje, publiczne metody instancji to metody dostępne na instancjach klasy.</p> + +<pre class="brush: js notranslate">class ClassWithPublicInstanceMethod { + publicMethod() { + return 'hello world' + } +} + +const instance = new ClassWithPublicInstanceMethod() +console.log(instance.publicMethod()) +// expected output: "hello world"</pre> + +<p>Publiczne metody instancji są dodawane do prototypu klasy z użyciem {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}} podczas wykonania klasy. Te metody są zapisywalne, niewyliczalne i konfigurowalne.</p> + +<p>Publiczne metody mogą używać async lub być generatorami.</p> + +<pre class="brush: js notranslate">class ClassWithFancyMethods { + *generatorMethod() { } + async asyncMethod() { } + async *asyncGeneratorMethod() { } +}</pre> + +<p>Wewnątrz metod instancji, <code>this</code> odnosi się do samej instancji. W podklasach można użyć <code>super</code> do dostępu do prototypu klasy nadrzędnej, umożliwiając wywoływanie metod tej klasy.</p> + +<pre class="brush: js notranslate">class BaseClass { + msg = 'hello world' + basePublicMethod() { + return this.msg + } +} + +class SubClass extends BaseClass { + subPublicMethod() { + return super.basePublicMethod() + } +} + +const instance = new SubClass() +console.log(instance.subPublicMethod()) +// expected output: "hello world" +</pre> + +<p>Getter'y i setter'y to specjalne metody, które wiążą się z właściwością danej klasy i są wywoływane, gdy właściwość jest odczytywana lub modyfikowana. Do tworzenia getter'ów i setter'ów należy użyć <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Reference/Functions/get">get</a> and <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Reference/Functions/set">set</a>.</p> + +<pre class="brush: js notranslate">class ClassWithGetSet { + #msg = 'hello world' + get msg() { + return this.#msg + } + set msg(x) { + this.#msg = `hello ${x}` + } +} + +const instance = new ClassWithGetSet() +console.log(instance.msg) +// expected output: "hello world" + +instance.msg = 'cake' +console.log(instance.msg) +// expected output: "hello cake" +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('Public and private instance fields', '#prod-FieldDefinition', 'FieldDefinition')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_2"><a name="Kompatybilność">Kompatybilność</a></h2> + + + +<p>{{Compat("javascript.classes.public_class_fields")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Reference/Classes/Private_class_fields">Private class fields</a></li> + <li><a href="https://rfrn.org/~shu/2018/05/02/the-semantics-of-all-js-class-elements.html">The Semantics of All JS Class Elements</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/classes/static/index.html b/files/pl/web/javascript/reference/classes/static/index.html new file mode 100644 index 0000000000..814c118957 --- /dev/null +++ b/files/pl/web/javascript/reference/classes/static/index.html @@ -0,0 +1,138 @@ +--- +title: static +slug: Web/JavaScript/Reference/Classes/static +tags: + - Classes + - ECMAScript 2015 + - JavaScript + - Static +translation_of: Web/JavaScript/Reference/Classes/static +--- +<div>{{jsSidebar("Classes")}}</div> + +<p><span class="seoSummary">Słowo kluczowe <code><strong>static</strong></code> definiuje statyczną metodę lub właściwość klasy. Metody i właściwości statyczne nie są wywoływane na instancjach klasy, a bezpośrednio na samej klasie. Statyczne metody to często funkcje służące na przykład do tworzenia czy klonowania obiektów, a statyczne właściwości są użyteczne do cache'ów, stałej konfiguracji lub innych właściwości, które nie muszą być powielane w instancjach.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/classes-static.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">static nazwaMetody() { ... } +static nazwaWlasciwosci [=wartosc]; +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_static_w_klasach">Używanie <code>static</code> w klasach</h3> + +<p>Poniższy przykład demonstruje kilka rzeczy:</p> + +<ol> + <li>Jak statyczna metoda lub właściwość jest implementowana w klasie</li> + <li>Klasa z metodą lub właściwością statyczną może być dziedziczona</li> + <li>Jak metoda lub właściwość statyczna może być wywoływana</li> +</ol> + +<pre class="brush: js notranslate">class Triple { + static customName = 'Tripler'; + static description = 'I triple any number you provide'; + static triple(n = 1) { + return n * 3; + } +} + +class BiggerTriple extends Triple { + static longDescription; + static description = 'I square the triple of any number you provide'; + static triple(n) { + return super.triple(n) * super.triple(n); + } +} + +console.log(Triple.description); // 'I triple any number you provide' +console.log(Triple.triple()); // 3 +console.log(Triple.triple(6)); // 18 + +var tp = new Triple(); + +console.log(BiggerTriple.triple(3)); // 81 (not affected by parent's instantiation) +console.log(BiggerTriple.description); // 'I square the triple of any number you provide' +console.log(BiggerTriple.longDescription); // undefined +console.log(BiggerTriple.customName); // 'Tripler' + +console.log(tp.triple()); // 'tp.triple is not a function'. +</pre> + +<h3 id="Wywoływanie_metod_statycznych_z_innych_metod_statycznych">Wywoływanie metod statycznych z innych metod statycznych</h3> + +<p>W celu wywołania metody lub właściwości statycznej z innej metody statycznej tej samej klasy można użyć słowa kluczowego <code>this</code>.</p> + +<pre class="brush: js notranslate">class StaticMethodCall { + static staticProperty = 'static property'; + static staticMethod() { + return 'Static method and ' + this.staticProperty + ' has been called'; + } + static anotherStaticMethod() { + return this.staticMethod() + ' from another static method'; + } +} +StaticMethodCall.staticMethod(); +// 'Static method and static property has been called' + +StaticMethodCall.anotherStaticMethod(); +// 'Static method and static property has been called from another static method'</pre> + +<h3 id="Wywoływanie_metod_statycznych_z_konstruktora_i_innych_metod">Wywoływanie metod statycznych z konstruktora i innych metod</h3> + +<p>Metody statyczne nie są dostępne przez this w metodach niestatycznych. Trzeba je wywołać, używając nazwy klasy: <code>CLASSNAME.STATIC_METHOD_NAME()</code> / <code>CLASSNAME.STATIC_PROPERTY_NAME</code> lub jako metody właściwości <code>constructor</code>: <code>this.constructor.STATIC_METHOD_NAME()</code> / <code>this.constructor.STATIC_PROPERTY_NAME</code>.</p> + +<pre class="brush: js notranslate">class StaticMethodCall { + constructor() { + console.log(StaticMethodCall.staticProperty); // 'static property' + console.log(this.constructor.staticProperty); // 'static property' + console.log(StaticMethodCall.staticMethod()); // 'static method has been called.' + console.log(this.constructor.staticMethod()); // 'static method has been called.' + } + + static staticProperty = 'static property'; + static staticMethod() { + return 'static method has been called.'; + } +}</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + + + +<p>{{Compat("javascript.classes.static")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> expression</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class"><code>class</code> declaration</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/brakujący_średnik_po_własności_id/index.html b/files/pl/web/javascript/reference/errors/brakujący_średnik_po_własności_id/index.html new file mode 100644 index 0000000000..ecdb783335 --- /dev/null +++ b/files/pl/web/javascript/reference/errors/brakujący_średnik_po_własności_id/index.html @@ -0,0 +1,77 @@ +--- +title: 'Błąd składni: brakująca własność po identyfikatorze.' +slug: Web/JavaScript/Reference/Errors/Brakujący_średnik_po_własności_id +tags: + - Błąd + - Błąd składniowy + - Błędy + - JavaScript +translation_of: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox"><span class="short_text" id="result_box" lang="pl"><span>Błąd składni: brakująca własność po identyfikatorze.</span></span> +</pre> + +<h2 id="Typ_błedu">Typ błedu</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Kiedy tworzysz objekty korzystając z <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Inicjalizatora objektu</a> składnia, używając dwukropka (<code>:</code>) oddziela klucze i wartości od własności objektu.</p> + +<pre class="brush: js">var obj = { własnośćKlucza: 'wartość' }; +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Dwukropki_a_znaki_równości">Dwukropki a znaki równości</h3> + +<p>Ten kod nie zadziała prawidłowo, ponieważ nie możesz w ten sposób używać znaków równości, aby korzystać z inicjalizatora objektu.</p> + +<pre class="brush: js example-bad">var obj = { własnośćKlucza = 'wartość' }; +// <span class="short_text" id="result_box" lang="pl"><span>Błąd składni: brakująca własność po identyfikatorze.</span></span> +</pre> + +<p>Poprawnie byłoby użyć znaku dwukropka, lub używając nawiasów kwadratowych aby przydzielić nową własność po stworzeniu objektu</p> + +<pre class="brush: js example-good">var obj = { własnośćKlucza: 'wartość' }; + +// Lub inaczej + +var obj = { }; +obj['własnośćKlucza'] = 'wartość'; +</pre> + +<h3 id="Puste_własności">Puste własności</h3> + +<p>Nie możesz w ten sposób tworzyć pustych własności.</p> + +<pre class="brush: js example-bad">var obj = { własnośćKlucza; }; +// <span class="short_text" id="result_box" lang="pl"><span>Błąd składni: brakująca własność po identyfikatorze.</span></span> +</pre> + +<p>Jeżeli potrzebujesz zdefiniować własność bez wartości, powinieneś użyć {{jsxref("null")}} jako wartości</p> + +<pre class="brush: js example-good">var obj = { własnośćKlucza: null };</pre> + +<h3 id="Własności_obliczeniowe">Własności obliczeniowe</h3> + +<p>Jeżeli tworzysz własność klucza z wyrażenia, potrzebujesz uzyć kwadratowych nawiasów. W przeciwnym razie, nazwa własności nie będzie możliwa do obliczenia</p> + +<pre class="brush: js example-bad">var obj = { 'b'+'ar': 'foo' }; +// <span class="short_text" id="result_box" lang="pl"><span>Błąd składni: brakująca własność po identyfikatorze.</span></span> +</pre> + +<p>Przenieś to wyrażenie do nawiasów <code>[]</code>:</p> + +<pre class="brush: js example-good">var obj = { ['b'+'ar']: 'foo' };</pre> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Inicjalizator objektu</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/index.html b/files/pl/web/javascript/reference/errors/index.html new file mode 100644 index 0000000000..68d78ee3e9 --- /dev/null +++ b/files/pl/web/javascript/reference/errors/index.html @@ -0,0 +1,28 @@ +--- +title: JavaScript error reference +slug: Web/JavaScript/Reference/Errors +tags: + - Błąd + - Błąd javascript + - Debugowanie JavaScript + - JavaScript + - Pomoc JavaScript +translation_of: Web/JavaScript/Reference/Errors +--- +<p>{{jsSidebar("Errors")}}</p> + +<p>Poniżej znajduje się lista błędów JavaScript wyświetlanych w konsoli. Takie błędy mogą być dla Ciebie pomocne w debugowaniu skryptu, natomiast wyświetlany komunikat dotyczący danego błędu nie zawsze jest zrozumiały. Poniższe odnośniki przekierowują Cię na strony, których zawartość szczegółowo opisuje dany problem. Każdy błąd jest traktowany jako obiekt {{jsxref("Error")}}, posiada <code>name</code> oraz <code>message</code>.</p> + +<p>Błędy wyświetlane w konsoli www mogą zawierać łącza do odpowiedniej strony poniżej, aby pomóc Ci szybko zrozumieć problem, który pojawił się w kodzie. </p> + +<h2 id="Lista_błędów">Lista błędów</h2> + +<p>Na tej liście każda strona jest wyświetlana według nazwy (typu błędu) i wiadomości (bardziej czytelna forma błędu dla człowieka w formie komuniaktu). Razem te dwa elementy stanowią punkt wyjścia do zrozumienia problemu. Aby uzyskać więcej informacji, kliknij jeden z poniższych odnośników.</p> + +<p>{{ListSubPages("/en-US/docs/Web/JavaScript/Reference/Errors")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Learn/JavaScript/First_steps/What_went_wrong">What went wrong? Troubleshooting JavaScript</a>: Tutorial dla początkujących - jak naprawić błąd JavaScript.</li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/invalid_array_length/index.html b/files/pl/web/javascript/reference/errors/invalid_array_length/index.html new file mode 100644 index 0000000000..e84d0f36a2 --- /dev/null +++ b/files/pl/web/javascript/reference/errors/invalid_array_length/index.html @@ -0,0 +1,79 @@ +--- +title: 'RangeError: invalid array length' +slug: Web/JavaScript/Reference/Errors/Invalid_array_length +tags: + - Błędy + - Errors + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Invalid_array_length +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox">RangeError: Array length must be a finite positive integer (Edge) +RangeError: invalid array length (Firefox) +RangeError: Invalid array length (Chrome) +RangeError: Invalid array buffer length (Chrome) +</pre> + +<h2 id="Typ_błędu">Typ błędu</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Niewłaściwa długość tablicy może wystąpić w następujących sytuacjach:</p> + +<ul> + <li>Kiedy obiekt {{jsxref("Array")}} lub {{jsxref("ArrayBuffer")}} ma długość ujemną albo większą lub równą 2<sup>32</sup>,</li> + <li>przy ustawianiu własności {{jsxref("Array.length")}} na wartość ujemną albo większą lub równą 2<sup>32</sup>.</li> +</ul> + +<p>Dlaczego długość obiektów typu <code>Array</code> i <code>ArrayBuffer</code> jest ograniczona? Własności te są reprezentowane jako 32-bitowe liczby całkowite bez znaku, które mogą przyjmować wartości z zakresu od 0 do 2<sup>32</sup>-1.</p> + +<p>Kiedy tworzysz obiekt typu <code>Array</code>, używając konstruktora, prawdopodobnie chcesz użyć zamiast tego literalnej notacji, gdyż pierwszy argument jest interpretowany jako długość obiektu <code>Array</code>.</p> + +<p><span class="tlid-translation translation" lang="pl"><span title="">W przeciwnym razie możesz chcieć ustalić długość przed ustawieniem właściwości <code>length</code> lub użyć jej jako argumentu konstruktora.</span></span></p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Niepoprawne_przypadki">Niepoprawne przypadki</h3> + +<pre class="brush: js example-bad">new Array(Math.pow(2, 40)) +new Array(-1) +new ArrayBuffer(Math.pow(2, 32)) +new ArrayBuffer(-1) + +let a = []; +a.length = a.length - 1; // ustaw -1 dla własności length + +let b = new Array(Math.pow(2, 32) - 1); +b.length = b.length + 1; // ustaw 2^32 dla własności length +</pre> + +<h3 id="Poprawne">Poprawne</h3> + +<pre class="brush: js example-good">[ Math.pow(2, 40) ] // [ 1099511627776 ] +[ -1 ] // [ -1 ] +new ArrayBuffer(Math.pow(2, 32) - 1) +new ArrayBuffer(0) + +let a = []; +a.length = Math.max(0, a.length - 1); + +let b = new Array(Math.pow(2, 32) - 1); +b.length = Math.min(0xffffffff, b.length + 1); + +// 0xffffffff jest szesnastkowym zapisem dla 2^32 - 1, +// co może być także zapisane jako (-1 >>> 0) +</pre> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.length")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/invalid_date/index.html b/files/pl/web/javascript/reference/errors/invalid_date/index.html new file mode 100644 index 0000000000..fe5d685894 --- /dev/null +++ b/files/pl/web/javascript/reference/errors/invalid_date/index.html @@ -0,0 +1,59 @@ +--- +title: 'RangeError: invalid date' +slug: Web/JavaScript/Reference/Errors/Invalid_date +tags: + - Błąd + - Error + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Invalid_date +--- +<div>{{jsSidebar("Errors")}}</div> + +<p>Wyjątek JavaScript „invalid date” (<em>niewłaściwa data</em>) zdarza się, gdy ciąg znaków zawierający niepoprawną datę jest przekazany do {{jsxref("Date")}} lub {{jsxref("Date.parse()")}}.</p> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox notranslate">RangeError: invalid date (Edge) +RangeError: invalid date (Firefox) +RangeError: invalid time value (Chrome) +RangeError: Provided date is not in valid range (Chrome) +</pre> + +<h2 id="Rodzaj_błędu">Rodzaj błędu</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Ciąg znaków przekazany do {{jsxref("Date")}} lub {{jsxref("Date.parse()")}} prowadzi do niepoprawnej daty.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Niepoprawne_przypadki">Niepoprawne przypadki</h3> + +<p>Ciągi znaków, w których nie można rozpoznać daty, lub które zawierają elementy niezgodne ze standardem ISO w większości przypadków spowodują zwrócenie {{jsxref("NaN")}}. Jednakże — w zależności od implementacji — niektóre wartości niezgodne z formatem ISO mogą także spowodować błąd <code>RangeError: invalid date</code>, tak jak następujące przypadki w przeglądarce Firefox:</p> + +<pre class="brush: js example-bad notranslate">new Date('foo-bar 2014'); +new Date('2014-25-23').toISOString(); +new Date('foo-bar 2014').toString(); +</pre> + +<p>Jednocześnie poniższy przykład zwróci w Firefoksie wartość {{jsxref("NaN")}}:</p> + +<pre class="brush: js example-bad notranslate">Date.parse('foo-bar 2014'); // NaN</pre> + +<p>Więcej szczegółów znajduje się w dokumentacji {{jsxref("Date.parse()")}}.</p> + +<h3 id="Poprawne_przypadki">Poprawne przypadki</h3> + +<pre class="brush: js example-good notranslate">new Date('05 October 2011 14:48 UTC'); +new Date(1317826080); // Timestamp Unix dla daty 5 października 2011 14:48:00 UTC</pre> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Date")}}</li> + <li>{{jsxref("Date.prototype.parse()")}}</li> + <li>{{jsxref("Date.prototype.toISOString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/json_bad_parse/index.html b/files/pl/web/javascript/reference/errors/json_bad_parse/index.html new file mode 100644 index 0000000000..a57c961088 --- /dev/null +++ b/files/pl/web/javascript/reference/errors/json_bad_parse/index.html @@ -0,0 +1,114 @@ +--- +title: 'SyntaxError: JSON.parse: bad parsing' +slug: Web/JavaScript/Reference/Errors/JSON_bad_parse +tags: + - Błąd składniowy + - Błędy + - Errors + - JSON + - JavaScript + - Metodă + - SyntaxError + - Własność +translation_of: Web/JavaScript/Reference/Errors/JSON_bad_parse +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Wiadomosć">Wiadomosć</h2> + +<pre class="syntaxbox">SyntaxError: JSON.parse: unterminated string literal +SyntaxError: JSON.parse: bad control character in string literal +SyntaxError: JSON.parse: bad character in string literal +SyntaxError: JSON.parse: bad Unicode escape +SyntaxError: JSON.parse: bad escape character +SyntaxError: JSON.parse: unterminated string +SyntaxError: JSON.parse: no number after minus sign +SyntaxError: JSON.parse: unexpected non-digit +SyntaxError: JSON.parse: missing digits after decimal point +SyntaxError: JSON.parse: unterminated fractional number +SyntaxError: JSON.parse: missing digits after exponent indicator +SyntaxError: JSON.parse: missing digits after exponent sign +SyntaxError: JSON.parse: exponent part is missing a number +SyntaxError: JSON.parse: unexpected end of data +SyntaxError: JSON.parse: unexpected keyword +SyntaxError: JSON.parse: unexpected character +SyntaxError: JSON.parse: end of data while reading object contents +SyntaxError: JSON.parse: expected property name or '}' +SyntaxError: JSON.parse: end of data when ',' or ']' was expected +SyntaxError: JSON.parse: expected ',' or ']' after array element +SyntaxError: JSON.parse: end of data when property name was expected +SyntaxError: JSON.parse: expected double-quoted property name +SyntaxError: JSON.parse: end of data after property name when ':' was expected +SyntaxError: JSON.parse: expected ':' after property name in object +SyntaxError: JSON.parse: end of data after property value in object +SyntaxError: JSON.parse: expected ',' or '}' after property value in object +SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal +SyntaxError: JSON.parse: property names must be double-quoted strings +SyntaxError: JSON.parse: expected property name or '}' +SyntaxError: JSON.parse: unexpected character +SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data +SyntaxError: JSON.parse Error: Invalid character at position {0} (Edge)</pre> + +<h2 id="Typ_błędu">Typ błędu</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>{{jsxref("JSON.parse()")}} parsuje string jako JSON. Zadany string musi być poprawnym dokumentem JSON, więc błąd wystąpi wtedy, gdy zostanie napotkana niepoprawna składnia.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="JSON.parse_nie_pozwala_na_końcowe_przecinki"><code>JSON.parse()</code> nie pozwala na końcowe przecinki</h3> + +<p>Both lines will throw a SyntaxError:</p> + +<pre class="brush: js example-bad">JSON.parse('[1, 2, 3, 4,]'); +JSON.parse('{"foo": 1,}'); +// SyntaxError JSON.parse: unexpected character +// at line 1 column 14 of the JSON data +</pre> + +<p>Pomiń końcowe przecinki, aby sparsować dokument JSON w poprawny sposób:</p> + +<pre class="brush: js example-good">JSON.parse('[1, 2, 3, 4]'); +JSON.parse('{"foo": 1}');</pre> + +<h3 id="Nazwy_własności_muszą_znajdować_się_w_cudzysłowach">Nazwy własności muszą znajdować się w cudzysłowach</h3> + +<p>Nie możesz użyć apostrofów do określania nazw własności, jak np. 'foo'.</p> + +<pre class="brush: js example-bad">JSON.parse("{'foo': 1}"); +// SyntaxError: JSON.parse: expected property name or '}' +// at line 1 column 2 of the JSON data</pre> + +<p>Zamiast tego użyj "foo":</p> + +<pre class="brush: js example-good">JSON.parse('{"foo": 1}');</pre> + +<h3 id="Zera_wiodące_i_część_niecałkowita_liczby">Zera wiodące i część niecałkowita liczby</h3> + +<p>Nie możesz użyć zer wiodących, jak na przykład <code>01</code>, ponadto część niecałkowita musi zawierać co najmniej jedną cyfrę, jeśli używany jest format dziesiętny.</p> + +<pre class="brush: js example-bad">JSON.parse('{"foo": 01}'); +// SyntaxError: JSON.parse: expected ',' or '}' after property value +// in object at line 1 column 2 of the JSON data + +JSON.parse('{"foo": 1.}'); +// SyntaxError: JSON.parse: unterminated fractional number +// at line 1 column 2 of the JSON data +</pre> + +<p>Zamiast tego napisz po prostu <code>1</code> bez zera z przodu i użyj co najmniej jednej cyfry w częsci dziesiętnej:</p> + +<pre class="brush: js example-good">JSON.parse('{"foo": 1}'); +JSON.parse('{"foo": 1.0}'); +</pre> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("JSON")}}</li> + <li>{{jsxref("JSON.parse()")}}</li> + <li>{{jsxref("JSON.stringify()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/missing_curly_after_function_body/index.html b/files/pl/web/javascript/reference/errors/missing_curly_after_function_body/index.html new file mode 100644 index 0000000000..efabf665c9 --- /dev/null +++ b/files/pl/web/javascript/reference/errors/missing_curly_after_function_body/index.html @@ -0,0 +1,72 @@ +--- +title: 'SyntaxError: missing } after function body' +slug: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body +tags: + - Błąd + - Błąd składni + - Błędy + - Error + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body +--- +<div>{{jsSidebar("Errors")}}</div> + +<p>Wyjątek JavaScript "missing } after function body" (<em>brakujący } po ciele funkcji</em>) zdarza się, gdy jest błąd składniowy gdzieś w definicji funkcji. Należy sprawdzić, czy wszystkie klamry i nawiasy są w odpowiednich miejscach i kolejności.</p> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox notranslate">SyntaxError: Expected '}' (Edge) +SyntaxError: missing } after function body (Firefox) +</pre> + +<h2 id="Rodzaj_błędu">Rodzaj błędu</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>W którymś miejscu pojawił się błąd przy tworzeniu funkcji. Należy sprawdzić, czy wszystkie zamykaące klamry i nawiasy są we właściwej kolejności. Odpowiednie wcięcia i formatowanie kodu mogą pomóc Ci w odnalezieniu błędu.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Brakująca_klamra_zamykająca">Brakująca klamra zamykająca</h3> + +<p>Często zdarza się, że brakuje klamry zamykającej w funkcji w Twoim kodzie:</p> + +<pre class="brush: js example-bad notranslate">var charge = function() { + if (sunny) { + useSolarCells(); + } else { + promptBikeRide(); +}; +</pre> + +<p>Poprawny kod wygląda następująco:</p> + +<pre class="brush: js example-good notranslate">var charge = function() { + if (sunny) { + useSolarCells(); + } else { + promptBikeRide(); + } +};</pre> + +<p>Może to być o wiele bardziej niejasne, kiedy używane są <a href="/en-US/docs/Glossary/IIFE">IIFE</a>, <a href="/pl/docs/Web/JavaScript/Domkniecia">domknięcia</a>, czy inne konstrukcje wymagające wielu różnych nawiasów i klamer, jak na przykład:</p> + +<pre class="brush: js example-bad notranslate">(function() { if (true) { return false; } ); +</pre> + +<p>Często zastosowanie innych wcięć lub dokładne sprawdzenie poprawności wcięć pozwala na znalezienie błędów tego rodzaju.</p> + +<pre class="brush: js example-good notranslate">(function() { + if (true) { + return false; + } +});</pre> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Guide/Funkcje">Funkcje</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/missing_initializer_in_const/index.html b/files/pl/web/javascript/reference/errors/missing_initializer_in_const/index.html new file mode 100644 index 0000000000..457a8e6a97 --- /dev/null +++ b/files/pl/web/javascript/reference/errors/missing_initializer_in_const/index.html @@ -0,0 +1,61 @@ +--- +title: 'SyntaxError: missing = in const declaration' +slug: Web/JavaScript/Reference/Errors/Missing_initializer_in_const +tags: + - Błąd + - Błąd składni + - Error + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_initializer_in_const +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox">SyntaxError: Const must be initalized (Edge) +SyntaxError: missing = in const declaration (Firefox) +SyntaxError: Missing initializer in const declaration (Chrome) +</pre> + +<h2 id="Typ_błędu">Typ błędu</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Stała jest wartością, która nie może być zmieniona podczas normalnego wykonania programu. Nie może być zmodyfikowana poprzez ponowne przypisanie wartości ani ponowną deklarację. W języku JavaScipt, stałe są deklarowane za pomocą słowa kluczowego <code>const</code>. Wymagane jest zainicjowanie stałej konkretną wartością – konieczne jest przypisanie danej stałej wartości w tym samym wyrażeniu, w którym jest deklarowana (co ma sens, biorąc pod uwagę fakt, że nie może ona być później zmieniana).</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Brakująca_inicjalizacja_stałej">Brakująca inicjalizacja stałej</h3> + +<p>W przeciwieństwie do <code>var</code> lub <code>let</code>, konieczne jest podanie wartości przy deklaracji <code>const</code>. W przeciwnym razie zwracany jest błąd:</p> + +<pre class="brush: js example-bad">const COLUMNS; +// SyntaxError: missing = in const declaration</pre> + +<h3 id="Naprawianie_błędu">Naprawianie błędu</h3> + +<p>Jest wiele opcji, by naprawić ten błąd. Należy sprawdzić, czemu miała służyć stała, o której mowa.</p> + +<h4 id="Dodawanie_wartości_stałej">Dodawanie wartości stałej</h4> + +<p>Ustal wartość stałej w tym samym wyrażeniu, w którym jest ona deklarowana:</p> + +<pre class="brush: js example-good">const COLUMNS = 80;</pre> + +<h4 id="const_let_or_var"><code>const</code>, <code>let</code> or <code>var</code>?</h4> + +<p>Nie używaj <code>const</code> tam, gdzie nie chcesz użyć stałej. Być może chciałeś zadeklarować zmienną z zakresem ograniczonym do danego bloku kodu za pomocą <code>let</code> lub zmienną globalną przy użyciu <code>var</code>. Obydwie te opcje nie wymagają wartości początkowej.</p> + +<pre class="brush: js example-good">let columns; +</pre> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a></code></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.html b/files/pl/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.html new file mode 100644 index 0000000000..a821081889 --- /dev/null +++ b/files/pl/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.html @@ -0,0 +1,59 @@ +--- +title: 'SyntaxError: missing ) after argument list' +slug: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_argument_list +tags: + - Błąd + - Błąd składni + - Błędy + - Error + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_argument_list +--- +<div>{{jsSidebar("Errors")}}</div> + +<p>Wyjątek JavaScript „missing ) after argument list” (brakujący „)” po liście argumentów) występuje, gdy pojawia się błąd przy próbie wywołania funkcji. Może być on spowodowany literówką, brakującym operatorem lubciągiem znaków, w którym nie został zastosowany znak ucieczki tam, gdzie był potrzebny.</p> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox notranslate">SyntaxError: Expected ')' (Edge) +SyntaxError: missing ) after argument list (Firefox) +</pre> + +<h2 id="Rodzaj_błędu">Rodzaj błędu</h2> + +<p>{{jsxref("SyntaxError")}}.</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Wystąpił błąd w wywołaniu funkcji. Powodem może być na przykład literówka, brakujący operator lub brak znaku ucieczki w ciągu znaków, gdy zastosowanie go było potrzebne.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Ponieważ brakuje operatora <code>+</code> przy próbie połączenia ciągów znaków, JavaScript oczekuje, że jedynym argumentem funkcji <code>log</code> będzie <code>"PI: "</code>, a zatem że nastąpi po nim nawias zamykający.</p> + +<pre class="brush: js example-bad notranslate">console.log('PI: ' Math.PI); +// SyntaxError: missing ) after argument list +</pre> + +<p>Można naprawić wywołanie funkcji <code>log</code> poprzez dodanie brakującego operatora <code>+</code>:</p> + +<pre class="brush: js example-good notranslate">console.log('PI: ' + Math.PI); +// "PI: 3.141592653589793"</pre> + +<h3 id="Niedokończone_ciągi_znaków">Niedokończone ciągi znaków</h3> + +<pre class="brush: js example-bad notranslate">console.log('"Java" + "Script" = \"' + 'Java' + 'Script\"); +// SyntaxError: missing ) after argument list</pre> + +<p>W powyższym przypadku JavaScript sądzi, że chciałeś użyć <code>);</code> jako fragmentu ciągu znaków (<em>string</em>) i ignoruje to, ponieważ nie wie, że <code>);</code> miało zakończyć wywołanie funkcji <code>console.log</code>. Aby naprawić ten problem, należy dodać znak <code>'</code> na końcu ciągu znaków, po fragmencie <code>'Script\"</code>:</p> + +<pre class="brush: js example-good notranslate">console.log('"Java" + "Script" = \"' + 'Java' + 'Script\"'); +// '"Java" + "Script" = "JavaScript"' +</pre> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Guide/Funkcje">Funkcje</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/missing_semicolon_before_statement/index.html b/files/pl/web/javascript/reference/errors/missing_semicolon_before_statement/index.html new file mode 100644 index 0000000000..6ff362a7aa --- /dev/null +++ b/files/pl/web/javascript/reference/errors/missing_semicolon_before_statement/index.html @@ -0,0 +1,82 @@ +--- +title: zezwalaj na wklejanie +slug: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement +tags: + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox">SyntaxError: Expected ';' (Edge) +SyntaxError: missing ; before statement (Firefox) +</pre> + +<h2 id="Typ_Błędu">Typ Błędu</h2> + +<p>{{jsxref("SyntaxError")}}.</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Brakuje gdzieś średnika (;). Instrukcje JavaScript muszą być zakończone średnikami. Niektóre z nich podlegają automatycznemu wstawianiu średnika (ASI), ale w tym przypadku musisz podać średnik, aby JavaScript mógł poprawnie przeanalizować kod źródłowy.</p> + +<p>Jednak często ten błąd jest tylko konsekwencją innego błędu, takiego jak niewłaściwe unikanie ciągów znaków lub niewłaściwe używanie zmiennej var. Możesz także mieć gdzieś za dużo nawiasów. Dokładnie sprawdź składnię, gdy ten błąd zostanie zgłoszony.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Niezdefiniowane_wiersze">Niezdefiniowane wiersze</h3> + +<p>Ten błąd może wystąpić z łatwością, gdy łańcuch znaków nie jest poprawnie zlozony, a silnik JavaScript oczekuje już końca łańcucha. Na przykład:</p> + +<pre class="brush: js example-bad">var foo = 'Tom's bar'; +// SyntaxError: missing ; before statement</pre> + +<p>Możesz użyć podwójnych cudzysłowów lub uciec od apostrofu:</p> + +<pre class="brush: js example-good">var foo = "Tom's bar"; +var foo = 'Tom\'s bar'; +</pre> + +<h3 id="Deklarowanie_właściwości_za_pomocą_var">Deklarowanie właściwości za pomocą var</h3> + +<p>Nie można zadeklarować właściwości obiektu lub tablicy za pomocą deklaracji var.</p> + +<pre class="brush: js example-bad">var obj = {}; +var obj.foo = 'hi'; // SyntaxError missing ; before statement + +var array = []; +var array[0] = 'there'; // SyntaxError missing ; before statement +</pre> + +<p>Zamiast tego pomiń słowo kluczowe var:</p> + +<pre class="brush: js example-good">var obj = {}; +obj.foo = 'hi'; + +var array = []; +array[0] = 'there'; +</pre> + +<h3 id="Bad_keywords">Bad keywords</h3> + +<p>Jeśli pochodzisz z innego języka programowania, często używasz słów kluczowych, które nie oznaczają tego samego lub nie mają żadnego znaczenia w javaScript:</p> + +<pre class="brush: js example-bad">def print(info){ + console.log(info); +}; // SyntaxError missing ; before statement</pre> + +<p>Zamiast tego użyj funkcji def:</p> + +<pre class="brush: js example-good">function print(info){ + console.log(info); +};</pre> + +<h2 id="Zobacz_tez">Zobacz tez</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">Automatic semicolon insertion (ASI)</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements">JavaScript statements</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/more_arguments_needed/index.html b/files/pl/web/javascript/reference/errors/more_arguments_needed/index.html new file mode 100644 index 0000000000..309031c6d0 --- /dev/null +++ b/files/pl/web/javascript/reference/errors/more_arguments_needed/index.html @@ -0,0 +1,44 @@ +--- +title: 'TypeError: More arguments needed' +slug: Web/JavaScript/Reference/Errors/More_arguments_needed +translation_of: Web/JavaScript/Reference/Errors/More_arguments_needed +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Komunikat">Komunikat</h2> + +<pre class="syntaxbox">TypeError: Object.create requires more than 0 arguments +TypeError: Object.setPrototypeOf requires more than 1 argument +TypeError: Object.defineProperties requires more than 0 arguments +</pre> + +<h2 id="Typ_błędu">Typ błędu</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Błąd zaistniał w sposobie wywołania funkcji. Należy podać więcej argumentów.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Metoda {{jsxref("Object.create()")}} wymaga przynajmniej jednego argumentu a metoda {{jsxref("Object.setPrototypeOf()")}} wymaga przynajmniej dwóch:</p> + +<pre class="brush: js example-bad">var obj = Object.create(); +// TypeError: Object.create requires more than 0 arguments + +var obj = Object.setPrototypeOf({}); +// TypeError: Object.setPrototypeOf requires more than 1 argument +</pre> + +<p>Możesz temu zaradzić ustawiając {{jsxref("null")}} jako prototyp, na przykład:</p> + +<pre class="brush: js example-good">var obj = Object.create(null); + +var obj = Object.setPrototypeOf({}, null);</pre> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Functions">Functions</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/not_a_function/index.html b/files/pl/web/javascript/reference/errors/not_a_function/index.html new file mode 100644 index 0000000000..019a223f0f --- /dev/null +++ b/files/pl/web/javascript/reference/errors/not_a_function/index.html @@ -0,0 +1,84 @@ +--- +title: 'TypeError: "x" nie jest funkcją' +slug: Web/JavaScript/Reference/Errors/Not_a_function +tags: + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Not_a_function +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox">TypeError: "x" is not a function +</pre> + +<h2 id="Typ_błędu">Typ błędu</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="Co_poszło_źle">Co poszło źle?</h2> + +<p>Próbowano wywołać wartość jak funkcję, ale wartość nie jest funkcją. Kod oczekuje od Ciebie przekazania funkcji, co nie miało miejsca.</p> + +<p>Może zrobiłeś literówkę w nazwie funkcji? Może objekt na którym wywołujesz tę metodę nie posiada tej funkcji? Na przykład, objekt JavaScript nie posiada funkcji <em>map, </em>natomiast objekt JavaScript Array posiada.</p> + +<p>Istnieje mnóstwo wbudowanych funkcji wymagających (callback) funkcji. Będziesz musiał wprowadzić funkcję, by metody te działały poprawnie:</p> + +<ul> + <li>Gdy pracujesz z {{jsxref("Array")}} lub {{jsxref("TypedArray")}} objektami: + <ul> + <li>{{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.forEach()")}}, {{jsxref("Array.prototype.map()")}}, {{jsxref("Array.prototype.filter()")}}, {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}}, {{jsxref("Array.prototype.find()")}}</li> + </ul> + </li> + <li>Gdy pracujesz z {{jsxref("Map")}} i {{jsxref("Set")}} objektami: + <ul> + <li>{{jsxref("Map.prototype.forEach()")}} and {{jsxref("Set.prototype.forEach()")}}</li> + </ul> + </li> +</ul> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Literówka_w_nazwie_funkcji">Literówka w nazwie funkcji</h3> + +<p>W tym wypadku, co zdarza się zbyt często, jest literówka w nazwie metody:</p> + +<pre class="brush: js example-bad">var x = document.getElementByID('foo'); +// TypeError: document.getElementByID is not a function +</pre> + +<p>Poprawna naywa metody to <code>getElementByI<strong>d</strong></code>:</p> + +<pre class="brush: js example-good">var x = document.getElementById('foo'); +</pre> + +<h3 id="Funkcje_wywołane_na_nieodpowiednim_objekcie">Funkcje wywołane na nieodpowiednim objekcie</h3> + +<p>Dla pewnych metod, musisz podać (callback) funkcję, która będzie działała tylko dla specyficznych objektów. W tym przykładzie, {{jsxref("Array.prototype.map()")}} jest użyta, podczas gdy działa tylko z objektami {{jsxref("Array")}}</p> + +<pre class="brush: js example-bad">var obj = {a: 13, b: 37, c: 42}; + +obj.map(function(num) { + return num * 2; +}); + +// TypeError: obj.map is not a function</pre> + +<p>Użyj w zamian <em>array:</em></p> + +<pre class="brush: js example-good">var numbers = [1, 4, 9]; + +numbers.map(function(num) { + return num * 2; +}); + +// Array [2, 8, 18] +</pre> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions">Functions</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/not_defined/index.html b/files/pl/web/javascript/reference/errors/not_defined/index.html new file mode 100644 index 0000000000..a5e72f84cb --- /dev/null +++ b/files/pl/web/javascript/reference/errors/not_defined/index.html @@ -0,0 +1,66 @@ +--- +title: 'ReferenceError: "x" is not defined' +slug: Web/JavaScript/Reference/Errors/Not_defined +translation_of: Web/JavaScript/Reference/Errors/Not_defined +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox">ReferenceError: "x" is not defined +</pre> + +<h2 id="Typ_błędu">Typ błędu</h2> + +<p>{{jsxref("ReferenceError")}}.</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Istnieje gdzieś niezadeklarowana zmienna. Zmienna ta powinna być zadeklarowana, a jeśli jest upewnij się czy jest dostępna w twoim skrypcie albo {{Glossary("scope")}}.</p> + +<div class="note"> +<p><strong>Notatka:</strong> Gdy ładujesz bibliotekę (na przykład jQuery), <span id="result_box" lang="pl"><span>upewnij się, że jest załadowana przed dostępem do zmiennych biblioteki, np</span></span> "$". Dodaj znacznik {{HTMLElement("script")}} ładujący bibliotekę przed twoim kodem, który jej używa.</p> +</div> + +<h2 id="Przykład">Przykład</h2> + +<h3 id="Zmienna_niezadeklarowana">Zmienna niezadeklarowana</h3> + +<pre class="brush: js example-bad">foo.substring(1); // ReferenceError: foo is not defined +</pre> + +<p>Zmianna "foo" jest niezdefiniowana. Powinna być jakąś wartością string wiec("String.prototype.substring()")}} metoda ta będzie działać.</p> + +<pre class="brush: js example-good">var foo = 'bar'; +foo.substring(1); // "ar"</pre> + +<h3 id="Zły_zasięg">Zły zasięg</h3> + +<p><span id="result_box" lang="pl"><span>Zmienna musi być dostępna w bieżącym kontekście realizacji.</span> <span>Zmienne zdefiniowane wewnątrz</span></span> <a href="/en-US/docs/Web/JavaScript/Reference/Functions">funcji </a><span lang="pl"><span>nie mogą być dostępne z dowolnego miejsca poza funkcją, powodem jest to że zmienna jest zdefiniowana tylko zmienną lokalną funkcji.</span></span></p> + +<pre class="brush: js example-bad">function numbers() { + var num1 = 2, + num2 = 3; + return num1 + num2; +} + +console.log(num1); // ReferenceError num1 is not defined.</pre> + +<p>Jakkolwiek funkcja może mieć dostęp do wszystkich zmiennych dzięki deklaracji zmiennych globalnie. Zmienne globalne są dostępne dla wszystkich funkcji.</p> + +<pre class="brush: js example-good">var num1 = 2, + num2 = 3; + +function numbers() { + return num1 + num2; +} + +console.log(num1); // 2</pre> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{Glossary("Scope")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Declaring_variables">Przewodnik deklaracji zmiennych w JavaScript</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Functions#Function_scope/en-US/docs/">Zasięg funkcji w Javascript</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/property_access_denied/index.html b/files/pl/web/javascript/reference/errors/property_access_denied/index.html new file mode 100644 index 0000000000..5db1ef3cad --- /dev/null +++ b/files/pl/web/javascript/reference/errors/property_access_denied/index.html @@ -0,0 +1,53 @@ +--- +title: 'Error: Permission denied to access property "x"' +slug: Web/JavaScript/Reference/Errors/Property_access_denied +tags: + - Bezpieczeństwo + - Błąd + - Błędy + - Error + - Errors + - JavaScript +translation_of: Web/JavaScript/Reference/Errors/Property_access_denied +--- +<div>{{jsSidebar("Errors")}}</div> + +<p>Wyjątek JavaScript "Permission denied to access property" pojawia się podczas próby dostępu do obiektu, do którego nie masz uprawnień</p> + +<h2 id="Wiadomość">Wiadomość</h2> + +<pre class="syntaxbox notranslate">Error: Permission denied to access property "x" +</pre> + +<h2 id="Typ_błędu">Typ błędu</h2> + +<p>{{jsxref("Error")}}</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Podjęto próbę dostępu do obiektu, do którego nie masz uprawnień. There was attempt to access an object for which you have no permission.Jest to prawdopodobnie element <a href="/en-US/docs/Web/HTML/Element/iframe" title="The HTML Inline Frame element (<iframe>) represents a nested browsing context, embedding another HTML page into the current one."><code><iframe></code></a> załadowany z innej domeny, dla której naruszyłeś <a href="/en-US/docs/Web/Security/Same-origin_policy">regułę tego samego pochodzenia (same-origin policy)</a>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Brak_uprawnień_dostepu_do_dokumentu">Brak uprawnień dostepu do dokumentu</h3> + +<pre class="brush: html notranslate"><!DOCTYPE html> +<html> + <head> + <iframe id="myframe" src="http://www1.w3c-test.org/common/blank.html"></iframe> + <script> + onload = function() { + console.log(frames[0].document); + // Error: Permission denied to access property "document" + } + </script> + </head> + <body></body> +</html></pre> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/HTML/Element/iframe" title="The HTML Inline Frame element (<iframe>) represents a nested browsing context, embedding another HTML page into the current one."><code><iframe></code></a></li> + <li><a href="/pl/docs/Web/Bezpieczeństwo/Same-origin_policy">Reguła tego samego pochodzenia (same-origin policy)</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/errors/unexpected_type/index.html b/files/pl/web/javascript/reference/errors/unexpected_type/index.html new file mode 100644 index 0000000000..39b363d42f --- /dev/null +++ b/files/pl/web/javascript/reference/errors/unexpected_type/index.html @@ -0,0 +1,69 @@ +--- +title: 'TypeError: "x" is (not) "y"' +slug: Web/JavaScript/Reference/Errors/Unexpected_type +tags: + - Błąd TypeError + - Błąd undefined + - Wartość null +translation_of: Web/JavaScript/Reference/Errors/Unexpected_type +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Message">Message</h2> + +<pre class="syntaxbox">TypeError: "x" is (not) "y" + +Examples: +TypeError: "x" is undefined +TypeError: "x" is null +TypeError: "undefined" is not an object +TypeError: "x" is not an object or null +TypeError: "x" is not a symbol +</pre> + +<h2 id="Typ_błędu">Typ błędu</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="Co_poszło_nie_tak">Co poszło nie tak?</h2> + +<p>Pojawił się nieoczekiwany typ, dlatego pojawił się błąd. Błąd pojawia się często jako {{jsxref("undefined")}} albo {{jsxref("null")}} dla określonych wartości.</p> + +<p>Dodatkowo niektóre metody takie jak {{jsxref("Object.create()")}} albo {{jsxref("Symbol.keyFor()")}}, wymagają określonego typu, który musi być zadeklarowany.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Nieprawidłowe_przypadki_które_mogą_się_pojawić">Nieprawidłowe przypadki, które mogą się pojawić</h3> + +<pre class="brush: js example-bad">// undefined oraz null to przypadki, dla których pojawi się błąd +var foo = undefined; +foo.substring(1); // TypeError: foo is undefined + +var foo = null; +foo.substring(1); // TypeError: foo is null + + +// <span class="short_text" id="result_box" lang="pl"><span>Niektóre metody mogą wymagać określonego typu</span></span> +var foo = {} +Symbol.keyFor(foo); // TypeError: foo is not a symbol + +var foo = 'bar' +Object.create(foo); // TypeError: "foo" is not an object or null +</pre> + +<h2 id="Jak_naprawić">Jak naprawić?</h2> + +<p>Aby naprawić problem, w przypadku wyświetlenia <code>'undefined'</code> bądź '<code>null</code>' dla określonych wartości można użyć operatora <a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof.</a></p> + +<h3 id="Przykład">Przykład</h3> + +<pre class="brush: js">if (typeof foo !== 'undefined') { + // Teraz wiemy, że zmienna foo jest zdefiniowana +}</pre> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("undefined")}}</li> + <li>{{jsxref("null")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/functions/funkcje_strzalkowe/index.html b/files/pl/web/javascript/reference/functions/funkcje_strzalkowe/index.html new file mode 100644 index 0000000000..d1b9d6010f --- /dev/null +++ b/files/pl/web/javascript/reference/functions/funkcje_strzalkowe/index.html @@ -0,0 +1,355 @@ +--- +title: Funkcje strzałkowe +slug: Web/JavaScript/Reference/Functions/Funkcje_strzalkowe +translation_of: Web/JavaScript/Reference/Functions/Arrow_functions +--- +<div>{{jsSidebar("Functions")}}</div> + +<p><strong>Funkcja strzałkowa </strong>ma krótszą składnię niż <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">zwykłe wyrażenie funkcji</a> oraz nie posiada własnego <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code>, <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">argumentów</a>, <a href="/en-US/docs/Web/JavaScript/Reference/Operators/super">super</a>, tudzież właściwości <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a>. Taki sposób wyrażenia funkcji najlepiej wykorzystać przy tworzeniu funkcji bez metod, ponadto nie mogą zostać one użyte jako konstruktory.</p> + +<h2 id="Składnia">Składnia</h2> + +<h3 id="Składnia_podstawowa">Składnia podstawowa</h3> + +<pre class="syntaxbox"><strong>(</strong><em>param1</em>, <em>param2</em>, …, <em>paramN</em><strong>) => {</strong> <em>statements</em> <strong>}</strong> +<strong>(</strong><em>param1</em>, <em>param2</em>, …, <em>paramN</em><strong>) =></strong> <em>expression</em> +// inaczej mówiąc: <strong>(</strong><em>param1</em>, <em>param2</em>, …, <em>paramN</em><strong>)</strong> => { return <em>expression</em>; } + +// Nawiasy są opcjonalne jeżeli występuje wyłącznie jedna nazwa parametru: +<em>(singleParam)</em> <strong>=> {</strong> <em>statements</em> <strong>}</strong> +<em>singleParam</em> <strong>=></strong> { <em>statements </em>} +<em>singleParam</em> <strong>=></strong> <em>expression</em> + + +// Lista parametrów dla funkcji bez parametrów powinna być zapisana przy użyciu pustego nawiasu. +() => { <em>statements</em> } +</pre> + +<h3 id="Zaawansowana_składnia">Zaawansowana składnia</h3> + +<pre class="syntaxbox">// Otoczenie ciała funkcji nawiasami pozwoli zwrócić tzw. object literal expression: +<em>params</em> => ({<em>foo: bar</em>}) + +// Parametry Rest (<a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">Rest parameters</a>) i domyślne (<a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">default parameters</a>) są wspierane +(<em>param1</em>, <em>param2</em>, <strong>...rest</strong>) => { <em>statements</em> } +(<em>param1</em> <strong>= defaultValue1</strong>, <em>param2</em>, …, paramN <strong>= defaultValueN</strong>) => { <em>statements</em> } + +// Destrukturyzacja (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">Destructuring</a>) w ramach listy parametrów jest również wspierana +let f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c; +f(); +// 6 +</pre> + +<h2 id="Opis">Opis</h2> + +<p>Zobacz również <a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">"ES6 In Depth: Arrow functions" na hacks.mozilla.org</a>.</p> + +<p>Dwa czynniki, które wpłynęły na wprowadzenie funkcji strzałkowych: krótszy zapis funkcji i brak wiązania <code>this</code>.</p> + +<h3 id="Krótsze_funkcje">Krótsze funkcje</h3> + +<pre class="brush: js">var materials = [ + 'Hydrogen', + 'Helium', + 'Lithium', + 'Beryllium' +]; + +materials.<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a>(function(material) { + return material.length; +}); // [8, 6, 7, 9] + +materials.<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a>((material) => { + return material.length; +}); // [8, 6, 7, 9] + +materials.<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a>(material => material.length); // [8, 6, 7, 9] + +materials.<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a>(({ length }) => length); // [8, 6, 7, 9] +</pre> + +<h3 id="Brak_oddzielnego_this">Brak oddzielnego <code>this</code></h3> + +<p>Przed wprowadzeniem funkcji strzałkowych każda nowa funkcja deniniowała swoją własną wartość <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code> (nowy obiekt w przypadku konstruktora, undefined w wywołaniach funkcji <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>, obiekt bazowy jeśli funkcja jest wywoływana jako "metoda obiektowa", itp.). Okazało się to niekorzystne przy obiektowym stylu programowania.</p> + +<pre class="brush: js">function Person() { + // Konstruktor Person() definiuje `this` jako instancję samego siebie. + this.age = 0; + + setInterval(function growUp() { + // Bez trybu non-strict, funkcja growUp() definuje `this` + // jako obiekt globalny, który jest inny od `this` + // zdefiniowanego przez konstruktor Person(). + this.age++; + }, 1000); +} + +var p = new Person();</pre> + +<p>W ECMAScript 3/5, problem z <code>this</code> można było rozwiązać przez przydzielenie wartości <code>this</code> do zmiennej, która wygląda bardzo podobnie.</p> + +<pre class="brush: js">function Person() { + var that = this; + that.age = 0; + + setInterval(function growUp() { + // The callback refers to the `that` variable of which + // the value is the expected object. + that.age++; + }, 1000); +}</pre> + +<p>Można było również stworzyć <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">funkcję bound</a>, co pozwoliło nadać wstępnie przypisaną wartość <code>this</code> do powiązanej funkcji docelowej (funkcja <code>growUp()</code> w przykładzie powyżej).</p> + +<p>Funkcja strzałkowa nie posiada własnego <code>this</code>; używana jest wartość <code>this</code> kontekstu wykonania. W związku z tym, w poniższym kodzie, <code>this</code> użyty w funkcji, który jest przekazywany do <code>setInterval</code>, ma taką samą wartość jak <code>this</code> w funkcji otaczającej:</p> + +<pre class="brush: js">function Person(){ + this.age = 0; + + setInterval(() => { + this.age++; // własność |this| właściwie odnosi się do obiektu Person() + }, 1000); +} + +var p = new Person();</pre> + +<h4 id="Relation_with_strict_mode">Relation with strict mode</h4> + +<p>Given that <code>this</code> comes from the surrounding lexical context, <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> rules with regard to <code>this</code> are ignored.</p> + +<pre class="brush: js">var f = () => { 'use strict'; return this; }; +f() === window; // or the global object</pre> + +<p>All other strict mode rules apply normally.</p> + +<h4 id="Invoked_through_call_or_apply">Invoked through call or apply</h4> + +<p>Since arrow functions do not have their own <code>this</code>, the methods <code>call()</code> or <code>apply()</code> can only pass in parameters. <code>thisArg</code> is ignored.</p> + +<pre class="brush: js">var adder = { + base: 1, + + add: function(a) { + var f = v => v + this.base; + return f(a); + }, + + addThruCall: function(a) { + var f = v => v + this.base; + var b = { + base: 2 + }; + + return f.call(b, a); + } +}; + +console.log(adder.add(1)); // This would log to 2 +console.log(adder.addThruCall(1)); // This would log to 2 still</pre> + +<h3 id="No_binding_of_arguments">No binding of <code>arguments</code></h3> + +<p>Arrow functions do not have their own <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments"><code>arguments</code> object</a>. Thus, in this example, <code>arguments</code> is simply a reference to the the arguments of the enclosing scope:</p> + +<pre class="brush: js">var arguments = [1, 2, 3]; +var arr = () => arguments[0]; + +arr(); // 1 + +function foo(n) { + var f = () => arguments[0] + n; // <em>foo</em>'s implicit arguments binding. arguments[0] is n + return f(10); +} + +foo(1); // 2</pre> + +<p>In most cases, using <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameters</a> is a good alternative to using an <code>arguments</code> object.</p> + +<pre class="brush: js">function foo(n) { + var f = (...args) => args[0] + n; + return f(10); +} + +foo(1); // 11</pre> + +<h3 id="Arrow_functions_used_as_methods">Arrow functions used as methods</h3> + +<p>As stated previously, arrow function expressions are best suited for non-method functions. Let's see what happens when we try to use them as methods:</p> + +<pre class="brush: js">'use strict'; +var obj = { + i: 10, + b: () => console.log(this.i, this), + c: function() { + console.log(this.i, this); + } +} +obj.b(); // prints undefined, Window {...} (or the global object) +obj.c(); // prints 10, Object {...}</pre> + +<p>Arrow functions do not have their own <code>this</code>. Another example involving {{jsxref("Object.defineProperty()")}}:</p> + +<pre class="brush: js">'use strict'; +var obj = { + a: 10 +}; + +Object.defineProperty(obj, 'b', { + get: () => { + console.log(this.a, typeof this.a, this); + return this.a + 10; // represents global object 'Window', therefore 'this.a' returns 'undefined' + } +}); +</pre> + +<h3 id="Use_of_the_new_operator">Use of the <code>new</code> operator</h3> + +<p>Arrow functions cannot be used as constructors and will throw an error when used with <code>new</code>.</p> + +<pre class="brush: js">var Foo = () => {}; +var foo = new Foo(); // TypeError: Foo is not a constructor</pre> + +<h3 id="Use_of_prototype_property">Use of <code>prototype</code> property</h3> + +<p>Arrow functions do not have a <code>prototype</code> property.</p> + +<pre class="brush: js">var Foo = () => {}; +console.log(Foo.prototype); // undefined +</pre> + +<h3 id="Use_of_the_yield_keyword">Use of the <code>yield</code> keyword</h3> + +<p>The <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/yield">yield</a></code> keyword may not be used in an arrow function's body (except when permitted within functions further nested within it). As a consequence, arrow functions cannot be used as generators.</p> + +<h2 id="Function_body">Function body</h2> + +<p>Arrow functions can have either a "concise body" or the usual "block body".</p> + +<p>In a concise body, only an expression is specified, which becomes the explicit return value. In a block body, you must use an explicit <code>return</code> statement.</p> + +<pre class="brush: js">var func = x => x * x; +// concise body syntax, implied "return" + +var func = (x, y) => { return x + y; }; +// with block body, explicit "return" needed +</pre> + +<h2 id="Returning_object_literals">Returning object literals</h2> + +<p>Keep in mind that returning object literals using the concise body syntax <code>params => {object:literal}</code> will not work as expected.</p> + +<pre class="brush: js">var func = () => { foo: 1 }; +// Calling func() returns undefined! + +var func = () => { foo: function() {} }; +// SyntaxError: function statement requires a name</pre> + +<p>This is because the code inside braces ({}) is parsed as a sequence of statements (i.e. <code>foo</code> is treated like a label, not a key in an object literal).</p> + +<p>Remember to wrap the object literal in parentheses.</p> + +<pre class="brush: js">var func = () => ({foo: 1});</pre> + +<h2 id="Line_breaks">Line breaks</h2> + +<p>An arrow function cannot contain a line break between its parameters and its arrow.</p> + +<pre class="brush: js">var func = () + => 1; +// SyntaxError: expected expression, got '=>'</pre> + +<h2 id="Parsing_order">Parsing order</h2> + +<p>Although the arrow in an arrow function is not an operator, arrow functions have special parsing rules that interact differently with <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">operator precedence</a> compared to regular functions.</p> + +<pre class="brush: js">let callback; + +callback = callback || function() {}; // ok + +callback = callback || () => {}; +// SyntaxError: invalid arrow-function arguments + +callback = callback || (() => {}); // ok +</pre> + +<h2 id="More_examples">More examples</h2> + +<pre class="brush: js">// An empty arrow function returns undefined +let empty = () => {}; + +(() => 'foobar')(); +// Returns "foobar" +// (this is an Immediately Invoked Function Expression +// see 'IIFE' in glossary) + +var simple = a => a > 15 ? 15 : a; +simple(16); // 15 +simple(10); // 10 + +let max = (a, b) => a > b ? a : b; + +// Easy array filtering, mapping, ... + +var arr = [5, 6, 13, 0, 1, 18, 23]; + +var sum = arr.reduce((a, b) => a + b); +// 66 + +var even = arr.filter(v => v % 2 == 0); +// [6, 0, 18] + +var double = arr.map(v => v * 2); +// [10, 12, 26, 0, 2, 36, 46] + +// More concise promise chains +promise.then(a => { + // ... +}).then(b => { + // ... +}); + +// Parameterless arrow functions that are visually easier to parse +setTimeout( () => { + console.log('I happen sooner'); + setTimeout( () => { + // deeper code + console.log('I happen later'); + }, 1); +}, 1); +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.functions.arrow_functions")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">"ES6 In Depth: Arrow functions" on hacks.mozilla.org</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/functions/get/index.html b/files/pl/web/javascript/reference/functions/get/index.html new file mode 100644 index 0000000000..0c4cf664dc --- /dev/null +++ b/files/pl/web/javascript/reference/functions/get/index.html @@ -0,0 +1,216 @@ +--- +title: getter +slug: Web/JavaScript/Reference/Functions/get +translation_of: Web/JavaScript/Reference/Functions/get +--- +<div>{{jsSidebar("Functions")}}</div> + +<div>Składnia <strong>get </strong>łączy właściwość obiektu z funkcją, która będzie wykonywana za każdym razem, kiedy ta właściwość jest wywoływana.</div> + +<div></div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">{get <em>prop</em>() { ... } } +{get <em>[expression]</em>() { ... } }</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>prop</code></dt> + <dd>Nazwa właściwości, która łączy ją z okresloną funkcją.</dd> + <dt>expression</dt> + <dd>Począwszy od ECMAScript 2015, można również użyć wyrażeń w celu połaczenia funkcji z nazwą właściwości, która jest obliczana.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Czasami pożądane jest aby umożliwić dostęp do właściwości, która zwraca wartość obliczaną dynamicznie lub potrzeba odzwierciedlić stan jakiejś wewnętrznej zmiennej bez potrzeby użycia wyraźnego wywołania metody. W języku JavaScript może to być osiągnięte dzięki użyciu <em>gettera</em>. Nie jest możliwe jednocześnie mieć getter połączony z właściwością i mieć tą właściwość (o takiej samej nazwie jak getter), która faktycznie trzyma wartość. Jednakże jest możliwe aby używać połączenia gettera i settera, żeby utworzyć rodzaj pseudo-właściwości.</p> + +<p>Zauważ, że gdy pracujemy ze składnią get to:</p> + +<div> +<ul> + <li>Można mieć identyfikator, który jest zarówno typu number jak i string;</li> + <li>Obowiązkowe jest aby zawierała dokładnie zero parametrów (zobacz: "<a href="http://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/">Niekompatybilna zmiana ES5: literał dla funkcji gettera i setera muszą teraz mieć dokładnie zero albo jeden argumentów</a>", aby uzyskać więcej informacji)</li> + <li>Nie może pojawiać się w literale obiektu z innym getem lub właściwością o takich samych nazwach (<code>{ get x() { }, get x() { } }</code> oraz <code>{ x: ..., get x() { } }</code> są niedozwolone).</li> +</ul> +</div> + +<p>Getter może być usunięty poprzez operator <code><a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operator_delete" title="en/Core_JavaScript_1.5_Reference/Operators/Special_Operators/delete_Operator">delete</a></code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Definiowanie_gettera_na_nowym_obiekcie_w_inicjalizatorze_obiektu.">Definiowanie gettera na nowym obiekcie w inicjalizatorze obiektu.</h3> + +<p>To stworzy pseudowłaściwość <code>latest</code> dla obiektu <code>obj</code>, która zwróci ostatnio zalogowany element w tablicy <code>log</code>.</p> + +<pre class="brush: js">var obj = { + log: ['test'], + get latest() { + if (this.log.length == 0) return undefined; + return this.log[this.log.length - 1]; + } +} +console.log(obj.latest); // Zwróci "test". +</pre> + +<p>Zauważ, że usiłowanie przypisania wartości do <code>latest</code> nie zmieni jej.</p> + +<h3 id="Usuwanie_gettera_używając_operatora_delete">Usuwanie gettera używając operatora <code>delete</code></h3> + +<p>Jeśli chcesz usunąć getter, wystarczy użyć <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete</a> </code>:</p> + +<pre class="brush: js">delete obj.latest; +</pre> + +<h3 id="Definiowanie_gettera_na_istniejącym_obiekcie_uzywając_defineProperty">Definiowanie gettera na istniejącym obiekcie uzywając <code>defineProperty</code></h3> + +<p>Aby dołączyć getter do istniejącego obiektu, można w każdej chwili użyć:<br> + {{jsxref("Object.defineProperty()")}}.</p> + +<pre class="brush: js">var o = {a: 0}; + +Object.defineProperty(o, 'b', { get: function() { return this.a + 1; } }); + +console.log(o.b) // Uruchamia getter, który otrzymuje yields a + 1 (which is 1)</pre> + +<h3 id="Używanie_obliczanych_wartości_dla_właściwości.">Używanie obliczanych wartości dla właściwości.</h3> + +<pre class="brush: js">var expr = 'foo'; + +var obj = { + get [expr]() { return 'bar'; } +}; + +console.log(obj.foo); // "bar"</pre> + +<h3 id="Bystre_samo-nadpisujące_leniwe_gettery">Bystre / samo-nadpisujące / leniwe gettery</h3> + +<p>Gettery dają ci możliwośc zdefiniowania właściwości obiektu, ale nie obliczają wartości właściwości dopóki nie jest ona dostępna. Getter odracza koszt obliczania wartości dopóki ta wartość jest potrzebna, a jeśli nigdy nie jest potrzebna, nie ponosi się tego kosztu.</p> + +<p>Dodatkową techniką optymalizacyjna aby uleniwić lub opóźnić obliczanie wartości dla właściwości jak i przechować ją na później są <strong>bystre (smart) lub <a href="https://en.wikipedia.org/wiki/Memoization">zmemoizowane</a> gettery.</strong> Wartość jest obliczana gdy getter jest wywoływany za pierwszym razem, a potem jest przechowywana więc kolejne dostępy zwracają zbuforowaną wartość bez jej ponownego obliczania. Jest to użyteczne w następujących sytuacjach:</p> + +<ul> + <li>Jeśli obliczanie wartości dla właściwości jest kosztowne (wymaga zużycia dużych zasobów pamięci operacyjnej RAM lub czasu procesora, itd).</li> + <li>Jesli wartość nie jest potrzebna natychmiast. Będzie jednak używana później lub w pewnych przypadkach nie będzie użyta wcale.</li> + <li>Jeżeli jest użyta, będzie wykorzystywana wiele razy i nie ma potrzeby ponownego jej oblczania, oraz jej wartość nigdy nie będzie zmieniona lub ponownie obliczana.</li> +</ul> + +<p>To oznacza, że nie powinno się używać leniwych getterów dla właściwości, której wartość może ulec zmianie, ponieważ taki getter nie oblicza właściwości ponownie.</p> + +<p>W następującym przykładzie obiekt posiada getter jako swoją właściwość. Otrzymując tą właściwość, jest ona usuwana z obiektu i ponownie dodawana, ale niejawnie jako właściwość z przypisanymi danymi. W ostatecznym rozrachunku zwracana jest wartość.</p> + +<pre class="brush: js">get notifier() { + delete this.notifier; + return this.notifier = document.getElementById('bookmarked-notification-anchor'); +},</pre> + +<p>Na potrzeby kodu Firefoxa, zobacz również moduł z kodem XPCOMUtils.jsm, który okresla funkcje <code><a href="/en-US/docs/Mozilla/JavaScript_code_modules/XPCOMUtils.jsm#defineLazyGetter()">defineLazyGetter()</a></code>.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacje</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Added computed property names.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(1)}}</td> + <td>{{ CompatGeckoDesktop("1.8.1") }}</td> + <td>{{ CompatIE(9) }}</td> + <td>9.5</td> + <td>3</td> + </tr> + <tr> + <td>Computed property names</td> + <td>{{CompatChrome(46)}}</td> + <td>{{ CompatGeckoDesktop("34") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("1.8.1") }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Computed property names</td> + <td>47</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile("34.0") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setter</a></li> + <li>{{jsxref("Operators/delete", "delete")}}</li> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li> + <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Defining Getters and Setters</a> in JavaScript Guide</li> +</ul> diff --git a/files/pl/web/javascript/reference/functions/index.html b/files/pl/web/javascript/reference/functions/index.html new file mode 100644 index 0000000000..e7935d3318 --- /dev/null +++ b/files/pl/web/javascript/reference/functions/index.html @@ -0,0 +1,657 @@ +--- +title: Functions +slug: Web/JavaScript/Reference/Functions +tags: + - Constructor + - Function + - Functions + - JavaScript + - NeedsTranslation + - Parameter + - TopicStub + - parameters +translation_of: Web/JavaScript/Reference/Functions +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>Generally speaking, a function is a "subprogram" that can be <em>called</em> by code external (or internal in the case of recursion) to the function. Like the program itself, a function is composed of a sequence of statements called the <em>function body</em>. Values can be <em>passed</em> to a function, and the function will <em>return</em> a value.</p> + +<p>In JavaScript, functions are first-class objects, because they can have properties and methods just like any other object. What distinguishes them from other objects is that functions can be called. In brief, they are <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function">Function</a></code> objects.</p> + +<p>For more examples and explanations, see also the <a href="/en-US/docs/Web/JavaScript/Guide/Functions">JavaScript guide about functions</a>.</p> + +<h2 id="Description">Description</h2> + +<p>Every function in JavaScript is a <code>Function</code> object. See {{jsxref("Function")}} for information on properties and methods of <code>Function</code> objects.</p> + +<p>To return a value other than the default, a function must have a <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/return">return</a></code> statement that specifies the value to return. A function without a return statement will return a default value. In the case of a <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor">constructor</a> called with the <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code> keyword, the default value is the value of its <code>this</code> parameter. For all other functions, the default return value is {{jsxref("undefined")}}.</p> + +<p>The parameters of a function call are the function's <em>arguments</em>. Arguments are passed to functions <em>by value</em>. If the function changes the value of an argument, this change is not reflected globally or in the calling function. However, object references are values, too, and they are special: if the function changes the referred object's properties, that change is visible outside the function, as shown in the following example:</p> + +<pre class="brush: js">/* Declare the function 'myFunc' */ +function myFunc(theObject) { + theObject.brand = "Toyota"; + } + + /* + * Declare variable 'mycar'; + * create and initialize a new Object; + * assign reference to it to 'mycar' + */ + var mycar = { + brand: "Honda", + model: "Accord", + year: 1998 + }; + + /* Logs 'Honda' */ + console.log(mycar.brand); + + /* Pass object reference to the function */ + myFunc(mycar); + + /* + * Logs 'Toyota' as the value of the 'brand' property + * of the object, as changed to by the function. + */ + console.log(mycar.brand); +</pre> + +<p>The <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this"><code>this</code> keyword</a> does not refer to the currently executing function, so you must refer to <code>Function</code> objects by name, even within the function body.</p> + +<h2 id="Defining_functions">Defining functions</h2> + +<p>There are several ways to define functions:</p> + +<h3 id="The_function_declaration_(function_statement)">The function declaration (<code>function</code> statement)</h3> + +<p>There is a special syntax for declaring functions (see <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a> for details):</p> + +<pre class="syntaxbox">function <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>The function name.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument to be passed to the function. A function can have up to 255 arguments.</dd> +</dl> + +<dl> + <dt><code>statements</code></dt> + <dd>The statements comprising the body of the function.</dd> +</dl> + +<h3 id="The_function_expression_(function_expression)">The function expression (<code>function</code> expression)</h3> + +<p>A function expression is similar to and has the same syntax as a function declaration (see <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expression</a> for details). A function expression may be a part of a larger expression. One can define "named" function expressions (where the name of the expression might be used in the call stack for example) or "anonymous" function expressions. Function expressions are not <em>hoisted</em> onto the beginning of the scope, therefore they cannot be used before they appear in the code.</p> + +<pre class="syntaxbox">function [<em>name</em>]([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>The function name. Can be omitted, in which case the function becomes known as an anonymous function.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument to be passed to the function. A function can have up to 255 arguments.</dd> + <dt><code>statements</code></dt> + <dd>The statements comprising the body of the function.</dd> +</dl> + +<p>Here is an example of an <strong>anonymous</strong> function expression (the <code>name</code> is not used):</p> + +<pre class="brush: js">var myFunction = function() { + statements +}</pre> + +<p>It is also possible to provide a name inside the definition in order to create a <strong>named</strong> function expression:</p> + +<pre class="brush: js">var myFunction = function namedFunction(){ + statements +} +</pre> + +<p>One of the benefit of creating a named function expression is that in case we encounted an error, the stack trace will contain the name of the function, making it easier to find the origin of the error.</p> + +<p>As we can see, both example do not start with the <code>function</code> keyword. Statements involving functions which do not start with <code>function</code> are function expressions.</p> + +<p>When function are used only once, a common pattern is an <strong>IIFE (<em>Immediately Invokable Function Expressions</em>)</strong>.</p> + +<pre class="brush: js">(function() { + statements +})();</pre> + +<p>IIFE are function expression that are invoked as soon as the function is declared.</p> + +<h3 id="The_generator_function_declaration_(function*_statement)">The generator function declaration (<code>function*</code> statement)</h3> + +<p>There is a special syntax for generator function declarations (see {{jsxref('Statements/function*', 'function* statement')}} for details):</p> + +<pre class="syntaxbox">function* <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>The function name.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument to be passed to the function. A function can have up to 255 arguments.</dd> +</dl> + +<dl> + <dt><code>statements</code></dt> + <dd>The statements comprising the body of the function.</dd> +</dl> + +<h3 id="The_generator_function_expression_(function*_expression)">The generator function expression (<code>function*</code> expression)</h3> + +<p>A generator function expression is similar to and has the same syntax as a generator function declaration (see {{jsxref('Operators/function*', 'function* expression')}} for details):</p> + +<pre class="syntaxbox">function* [<em>name</em>]([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>The function name. Can be omitted, in which case the function becomes known as an anonymous function.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument to be passed to the function. A function can have up to 255 arguments.</dd> + <dt><code>statements</code></dt> + <dd>The statements comprising the body of the function.</dd> +</dl> + +<h3 id="The_arrow_function_expression_(>)">The arrow function expression (=>)</h3> + +<p>An arrow function expression has a shorter syntax and lexically binds its <code>this</code> value (see <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a> for details):</p> + +<pre class="syntaxbox">([param[, param]]) => { + statements +} + +param => expression +</pre> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument. Zero arguments need to be indicated with <code>()</code>. For only one argument, the parentheses are not required. (like <code>foo => 1</code>)</dd> + <dt><code>statements or expression</code></dt> + <dd>Multiple statements need to be enclosed in brackets. A single expression requires no brackets. The expression is also the implicit return value of the function.</dd> +</dl> + +<h3 id="The_Function_constructor">The <code>Function</code> constructor</h3> + +<div class="note"> +<p><strong>Note:</strong> Using the <code>Function</code> constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.</p> +</div> + +<p>As all other objects, {{jsxref("Function")}} objects can be created using the <code>new</code> operator:</p> + +<pre class="syntaxbox">new Function (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>) +</pre> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Zero or more names to be used by the function as formal parameters. Each must be a proper JavaScript identifier.</dd> +</dl> + +<dl> + <dt><code>functionBody</code></dt> + <dd>A string containing the JavaScript statements comprising the function body.</dd> +</dl> + +<p>Invoking the <code>Function</code> constructor as a function (without using the <code>new</code> operator) has the same effect as invoking it as a constructor.</p> + +<h3 id="The_GeneratorFunction_constructor">The <code>GeneratorFunction</code> constructor</h3> + +<div class="note"> +<p><strong>Note:</strong> <code>GeneratorFunction</code> is not a global object, but could be obtained from generator function instance (see {{jsxref("GeneratorFunction")}} for more detail).</p> +</div> + +<div class="note"> +<p><strong>Note:</strong> Using the <code>GeneratorFunction</code> constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.</p> +</div> + +<p>As all other objects, {{jsxref("GeneratorFunction")}} objects can be created using the <code>new</code> operator:</p> + +<pre class="syntaxbox">new GeneratorFunction (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>) +</pre> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Zero or more names to be used by the function as formal argument names. Each must be a string that conforms to the rules for a valid JavaScript identifier or a list of such strings separated with a comma; for example "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd> +</dl> + +<dl> + <dt><code>functionBody</code></dt> + <dd>A string containing the JavaScript statements comprising the function definition.</dd> +</dl> + +<p>Invoking the <code>Function</code> constructor as a function (without using the <code>new</code> operator) has the same effect as invoking it as a constructor.</p> + +<h2 id="Function_parameters">Function parameters</h2> + +<h3 id="Default_parameters">Default parameters</h3> + +<p>Default function parameters allow formal parameters to be initialized with default values if no value or <code>undefined</code> is passed. For more details, see<a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters"> default parameters</a>.</p> + +<h3 id="Rest_parameters">Rest parameters</h3> + +<p>The rest parameter syntax allows to represent an indefinite number of arguments as an array. For more details, see <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameters</a>.</p> + +<h2 id="The_arguments_object">The <code>arguments</code> object</h2> + +<p>You can refer to a function's arguments within the function by using the <code>arguments</code> object. See <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>.</p> + +<ul> + <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a></code>: An array-like object containing the arguments passed to the currently executing function.</li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/callee">arguments.callee</a></code> {{Deprecated_inline}}: The currently executing function.</li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/caller">arguments.caller</a></code> {{Obsolete_inline}} : The function that invoked the currently executing function.</li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code>: The number of arguments passed to the function.</li> +</ul> + +<h2 id="Defining_method_functions">Defining method functions</h2> + +<h3 id="Getter_and_setter_functions">Getter and setter functions</h3> + +<p>You can define getters (accessor methods) and setters (mutator methods) on any standard built-in object or user-defined object that supports the addition of new properties. The syntax for defining getters and setters uses the object literal syntax.</p> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">get</a></dt> + <dd> + <p>Binds an object property to a function that will be called when that property is looked up.</p> + </dd> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">set</a></dt> + <dd>Binds an object property to a function to be called when there is an attempt to set that property.</dd> +</dl> + +<h3 id="Method_definition_syntax">Method definition syntax</h3> + +<p>Starting with ECMAScript 2015, you are able to define own methods in a shorter syntax, similar to the getters and setters. See <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions">method definitions</a> for more information.</p> + +<pre class="brush: js">var obj = { + foo() {}, + bar() {} +};</pre> + +<h2 id="Function_constructor_vs._function_declaration_vs._function_expression"><code>Function</code> constructor vs. function declaration vs. function expression</h2> + +<p>Compare the following:</p> + +<p>A function defined with the <code>Function</code> constructor assigned to the variable <code>multiply:</code></p> + +<pre class="brush: js">var multiply = new Function('x', 'y', 'return x * y');</pre> + +<p>A <em>function declaration</em> of a function named <code>multiply</code>:</p> + +<pre class="brush: js">function multiply(x, y) { + return x * y; +} // there is no semicolon here +</pre> + +<p>A <em>function expression</em> of an anonymous function assigned to the variable <code>multiply:</code></p> + +<pre class="brush: js">var multiply = function(x, y) { + return x * y; +}; +</pre> + +<p>A <em>function expression</em> of a function named <code>func_name</code> assigned to the variable <code>multiply:</code></p> + +<pre class="brush: js">var multiply = function func_name(x, y) { + return x * y; +}; +</pre> + +<h3 id="Differences">Differences</h3> + +<p>All do approximately the same thing, with a few subtle differences:</p> + +<p>There is a distinction between the function name and the variable the function is assigned to. The function name cannot be changed, while the variable the function is assigned to can be reassigned. The function name can be used only within the function's body. Attempting to use it outside the function's body results in an error (or <code>undefined</code> if the function name was previously declared via a <code>var</code> statement). For example:</p> + +<pre class="brush: js">var y = function x() {}; +alert(x); // throws an error +</pre> + +<p>The function name also appears when the function is serialized via <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString"><code>Function</code>'s toString method</a>.</p> + +<p>On the other hand, the variable the function is assigned to is limited only by its scope, which is guaranteed to include the scope where the function is declared in.</p> + +<p>As the 4th example shows, the function name can be different from the variable the function is assigned to. They have no relation to each other. A function declaration also creates a variable with the same name as the function name. Thus, unlike those defined by function expressions, functions defined by function declarations can be accessed by their name in the scope they were defined in:</p> + +<p>A function defined by '<code>new Function'</code> does not have a function name. However, in the <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> JavaScript engine, the serialized form of the function shows as if it has the name "anonymous". For example, <code>alert(new Function())</code> outputs:</p> + +<pre class="brush: js">function anonymous() { +} +</pre> + +<p>Since the function actually does not have a name, <code>anonymous</code> is not a variable that can be accessed within the function. For example, the following would result in an error:</p> + +<pre class="brush: js">var foo = new Function("alert(anonymous);"); +foo(); +</pre> + +<p>Unlike functions defined by function expressions or by the <code>Function</code> constructor, a function defined by a function declaration can be used before the function declaration itself. For example:</p> + +<pre class="brush: js">foo(); // alerts FOO! +function foo() { + alert('FOO!'); +} +</pre> + +<p>A function defined by a function expression inherits the current scope. That is, the function forms a closure. On the other hand, a function defined by a <code>Function</code> constructor does not inherit any scope other than the global scope (which all functions inherit).</p> + +<p>Functions defined by function expressions and function declarations are parsed only once, while those defined by the <code>Function</code> constructor are not. That is, the function body string passed to the <code>Function</code> constructor must be parsed each and every time the constructor is called. Although a function expression creates a closure every time, the function body is not reparsed, so function expressions are still faster than "<code>new Function(...)</code>". Therefore the <code>Function</code> constructor should generally be avoided whenever possible.</p> + +<p>It should be noted, however, that function expressions and function declarations nested within the function generated by parsing a <code>Function constructor</code> 's string aren't parsed repeatedly. For example:</p> + +<pre class="brush: js">var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))(); +foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.</pre> + +<p>A function declaration is very easily (and often unintentionally) turned into a function expression. A function declaration ceases to be one when it either:</p> + +<ul> + <li>becomes part of an expression</li> + <li>is no longer a "source element" of a function or the script itself. A "source element" is a non-nested statement in the script or a function body:</li> +</ul> + +<pre class="brush: js">var x = 0; // source element +if (x == 0) { // source element + x = 10; // not a source element + function boo() {} // not a source element +} +function foo() { // source element + var y = 20; // source element + function bar() {} // source element + while (y == 10) { // source element + function blah() {} // not a source element + y++; // not a source element + } +} +</pre> + +<h3 id="Examples">Examples</h3> + +<pre class="brush: js">// function declaration +function foo() {} + +// function expression +(function bar() {}) + +// function expression +x = function hello() {} + + +if (x) { + // function expression + function world() {} +} + + +// function declaration +function a() { + // function declaration + function b() {} + if (0) { + // function expression + function c() {} + } +} +</pre> + +<h2 id="Block-level_functions">Block-level functions</h2> + +<p>In <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>, starting with ES2015, functions inside blocks are now scoped to that block. Prior to ES2015, block-level functions were forbidden in strict mode.</p> + +<pre class="brush: js">'use strict'; + +function f() { + return 1; +} + +{ + function f() { + return 2; + } +} + +f() === 1; // true + +// f() === 2 in non-strict mode +</pre> + +<h3 id="Block-level_functions_in_non-strict_code">Block-level functions in non-strict code</h3> + +<p>In a word: Don't.</p> + +<p>In non-strict code, function declarations inside blocks behave strangely. For example:</p> + +<pre class="brush: js">if (shouldDefineZero) { + function zero() { // DANGER: compatibility risk + console.log("This is zero."); + } +} +</pre> + +<p>ES2015 says that if <code>shouldDefineZero</code> is false, then <code>zero</code> should never be defined, since the block never executes. However, it's a new part of the standard. Historically, this was left unspecified, and some browsers would define <code>zero</code> whether the block executed or not.</p> + +<p>In <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>, all browsers that support ES2015 handle this the same way: <code>zero</code> is defined only if <code>shouldDefineZero</code> is true, and only in the scope of the <code>if</code>-block.</p> + +<p>A safer way to define functions conditionally is to assign a function expression to a variable:</p> + +<pre class="brush: js">var zero; +if (0) { + zero = function() { + console.log("This is zero."); + }; +} +</pre> + +<h2 id="Examples_2">Examples</h2> + +<h3 id="Returning_a_formatted_number">Returning a formatted number</h3> + +<p>The following function returns a string containing the formatted representation of a number padded with leading zeros.</p> + +<pre class="brush: js">// This function returns a string padded with leading zeros +function padZeros(num, totalLen) { + var numStr = num.toString(); // Initialize return value as string + var numZeros = totalLen - numStr.length; // Calculate no. of zeros + for (var i = 1; i <= numZeros; i++) { + numStr = "0" + numStr; + } + return numStr; +} +</pre> + +<p>The following statements call the padZeros function.</p> + +<pre class="brush: js">var result; +result = padZeros(42,4); // returns "0042" +result = padZeros(42,2); // returns "42" +result = padZeros(5,4); // returns "0005" +</pre> + +<h3 id="Determining_whether_a_function_exists">Determining whether a function exists</h3> + +<p>You can determine whether a function exists by using the <code>typeof</code> operator. In the following example, a test is performed to determine if the <code>window</code> object has a property called <code>noFunc</code> that is a function. If so, it is used; otherwise some other action is taken.</p> + +<pre class="brush: js"> if ('function' == typeof window.noFunc) { + // use noFunc() + } else { + // do something else + } +</pre> + +<p>Note that in the <code>if</code> test, a reference to <code>noFunc</code> is used—there are no brackets "()" after the function name so the actual function is not called.</p> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-13', 'Function Definition')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>New: Arrow functions, Generator functions, default parameters, rest parameters.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Generator functions</td> + <td>39</td> + <td>{{CompatGeckoDesktop("26.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>26</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Arrow functions</td> + <td>{{CompatChrome(45.0)}}</td> + <td>{{CompatGeckoDesktop("22.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera(32)}}</td> + <td>10</td> + </tr> + <tr> + <td>Block-level functions</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("46.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Generator functions</td> + <td>{{CompatUnknown}}</td> + <td>39</td> + <td>{{CompatGeckoMobile("26.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>26</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Arrow functions</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("22.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Block-level functions</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("46.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Statements/function*", "function* statement")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li>{{jsxref("Functions/Arrow_functions", "Arrow functions")}}</li> + <li>{{jsxref("Functions/Default_parameters", "Default parameters")}}</li> + <li>{{jsxref("Functions/rest_parameters", "Rest parameters")}}</li> + <li>{{jsxref("Functions/arguments", "Arguments object")}}</li> + <li>{{jsxref("Functions/get", "getter")}}</li> + <li>{{jsxref("Functions/set", "setter")}}</li> + <li>{{jsxref("Functions/Method_definitions", "Method definitions")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope">Functions and function scope</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/functions/parametry_domyślne/index.html b/files/pl/web/javascript/reference/functions/parametry_domyślne/index.html new file mode 100644 index 0000000000..b192456adf --- /dev/null +++ b/files/pl/web/javascript/reference/functions/parametry_domyślne/index.html @@ -0,0 +1,225 @@ +--- +title: Parametry domyślne +slug: Web/JavaScript/Reference/Functions/Parametry_domyślne +tags: + - ECMAScript2015 + - Funkcje + - JavaScript +translation_of: Web/JavaScript/Reference/Functions/Default_parameters +--- +<div>{{jsSidebar("Functions")}}</div> + +<p><span class="seoSummary"><strong>Domyślne parametry funkcji</strong> pozwalają na inicjalizację nazwanych parametrów wartościami domyślnymi tam, gdzie nie została podana żadna wartość lub jako wartość podano <code>undefined</code>.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/functions-default.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">function [nazwa]([parametr1[ = domyślnaWartość1 ][, ..., parametrN[ = domyślnaWartośćN ]]]) { + ciało funkcji +} +</pre> + +<h2 id="Opis">Opis</h2> + +<p>W języku JavaScript domyślną wartością parametrów funkcji jest <code>{{jsxref("undefined")}}</code>. Często jednak dobrze jest ustawić inną wartość domyślną – wówczas parametry domyślne okazują się pomocne.</p> + +<p>W przeszłości, ogólną strategią na ustawianie domyślnych wartości było sprawdzanie parametrów w ciele funkcji – w sytuacji, w których były one równe <code>undefined</code>, przypisywano im konkretne wartości.</p> + +<p>W następującym przykładzie, jeśli żadna wartość nie jest podana jako <code>b</code>, kiedy wywoływana jest funkcja <code>pomnóż</code>, wartość <code>b</code> powinna być równa <code>undefined</code> – wówczas funkcja powinna zwrócić <code>NaN</code> jako wynik operacji <code>a * b</code>.</p> + +<pre class="brush: js">function pomnóż(a, b) { + return a * b; +} + +pomnóż(5, 2); // 10 +pomnóż(5); // NaN ! +</pre> + +<p>Aby się przed tym uchronić, należy użyć czegoś takiego, jak w drugiej linijce, gdzie wartość <code>b</code> jest ustawiana na <code>1</code>, jeśli funkcja <code>pomnóż</code> jest wywoływana tylko z jednym argumentem.</p> + +<pre class="brush: js">function pomnóż(a, b) { + b = (typeof b !== 'undefined') ? b : 1; + return a * b; +} + +pomnóż(5, 2); // 10 +pomnóż(5); // 5 +</pre> + +<p>Dzięki parametrom domyślnym w ES2015, tego rodzaju sprawdzanie wartości parametrów w ciele funkcji nie jest już konieczne. Można teraz przypisać <code>1</code> jako domyślną wartość w nagłówku funkcji:</p> + +<pre class="brush: js">function pomnóż(a, b = 1) { + return a * b; +} + +pomnóż(5, 2); // 10 +pomnóż(5); // 5 +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Przekazywanie_undefined_kontra_inne_puste_wartości">Przekazywanie <code>undefined</code> kontra inne <em>puste wartości</em></h3> + +<p>W drugim wywołaniu funkcji w tym przykłądzie, nawet jeśli jako pierwszy argument wprost podany <code>undefined</code> (jednak nie <code>null</code> lub inne <em><a href="/en-US/docs/Glossary/Falsy">puste</a> wartości</em>), wartością argumentu <code>num</code> dalej będzie wartość domyślna.</p> + +<pre class="brush: js">function test(num = 1) { + console.log(typeof num); +} + +test(); // 'number' (num jest ustawiany na 1) +test(undefined); // 'number' (num również jest ustawiany na 1) + +// test z innymi "pustymi" wartościami: +test(''); // 'string' (num jest ustawiany na '') +test(null); // 'object' (num jest ustawiany na null) +</pre> + +<h3 id="Ewaluacja_w_czasie_wykonania">Ewaluacja w czasie wykonania</h3> + +<p>Domyślne argumenty są przypisywane w czasie wykonania, a więc w odróżnieniu od np. Pythona, nowy obiekt jest tworzony przy każdym wywołaniu funkcji.</p> + +<pre class="brush: js">function append(wartość, tablica = []) { + array.push(wartość); + return tablica; +} + +append(1); //[1] +append(2); //[2], nie [1, 2] +</pre> + +<p>Dotyczy to również funkcji i zmiennych:</p> + +<pre class="brush: js">function callSomething(thing = something()) { + return thing; +} + +let numberOfTimesCalled = 0; +function something() { + numberOfTimesCalled += 1; + return numberOfTimesCalled; +} + +callSomething(); // 1 +callSomething(); // 2</pre> + +<h3 id="Domyślne_parametry_są_dostępne_dla_późniejszych_domyślnych_parametrów">Domyślne parametry są dostępne dla późniejszych domyślnych parametrów</h3> + +<p>Parametry zdefiniowane wcześniej (bardziej na lewo na liście parametrów), są dostępne dla domyślnych parametrów definiowanych później:</p> + +<pre class="brush: js">function pozdrów(imię, pozdrowienie, wiadomość = pozdrowienie + ' ' + imię) { + return [imię, pozdrowienie, wiadomość]; +} + +pozdrów('Dawid', 'Cześć'); // ["Dawid", "Cześć", "Cześć Dawid"] +pozdrów('Dawid', 'Cześć', 'Wszystkiego najlepszego!'); // ["Dawid", "Cześć", "Wszystkiego najlepszego!"] +</pre> + +<p>Ta funkcjonalność może być przybliżona w ten sposób, pokazujący, jak wiele przypadków brzegowych może być obsłużonych:</p> + +<pre class="brush: js">function go() { + return ':P'; +} + +function withDefaults(a, b = 5, c = b, d = go(), e = this, + f = arguments, g = this.value) { + return [a, b, c, d, e, f, g]; +} + +function withoutDefaults(a, b, c, d, e, f, g) { + switch (arguments.length) { + case 0: + a; + case 1: + b = 5; + case 2: + c = b; + case 3: + d = go(); + case 4: + e = this; + case 5: + f = arguments; + case 6: + g = this.value; + default: + } + return [a, b, c, d, e, f, g]; +} + +withDefaults.call({value: '=^_^='}); +// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="] + +withoutDefaults.call({value: '=^_^='}); +// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="] +</pre> + +<h3 id="Funkcje_definiowane_w_ciele_funkcji">Funkcje definiowane w ciele funkcji</h3> + +<p>Wprowadzone w Gecko 33 {{geckoRelease(33)}}. Funkcje deklarowane w ciele funkcji nie mogą być używane jako wartości domyślne w tej samej funkcji. Przy takiej próbie, wyrzucany jest jest {{jsxref("ReferenceError")}}. Parametr domyślny zawsze wykonywany jest jako pierwszy, a więc deklaracje w ciele funkcji są ewaluowane później.</p> + +<pre class="brush: js">// Nie działa! Wyrzuca ReferenceError. +function f(a = go()) { + function go() { return ':P'; } +} +</pre> + +<h3 id="Parametry_bez_wartości_domyślnych_po_parametrach_domyślnych">Parametry bez wartości domyślnych po parametrach domyślnych</h3> + +<p>Przed Gecko 26 {{geckoRelease(26)}}, poniższy kod zwracał {{jsxref("SyntaxError")}}. Zostało to naprawione w {{bug(777060)}}. Wartości parametrów dalej są ustawiane w kolejności od lewej do prawej, nadpisując domyślne parametry, nawet jeśli występują potem parametry bez wartości domyślnych.</p> + +<pre class="brush: js">function f(x = 1, y) { + return [x, y]; +} + +f(); // [1, undefined] +f(2); // [2, undefined] +</pre> + +<h3 id="Parametr_destrukturyzowany_z_przypisaniem_domyślnej_wartości">Parametr destrukturyzowany z przypisaniem domyślnej wartości</h3> + +<p>Możesz też użyć przypisania domyślnej wartości z notacją <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">parametru destruktyryzowanego</a>:</p> + +<pre class="brush: js">function f([x, y] = [1, 2], {z: z} = {z: 3}) { + return x + y + z; +} + +f(); // 6</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-function-definitions', 'Function Definitions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.functions.default_parameters")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:parameter_default_values" rel="external" title="http://wiki.ecmascript.org/doku.php?id=harmony:parameter_default_values">Original proposal at ecmascript.org</a></li> +</ul> diff --git a/files/pl/web/javascript/reference/functions/set/index.html b/files/pl/web/javascript/reference/functions/set/index.html new file mode 100644 index 0000000000..d3eb6ad31d --- /dev/null +++ b/files/pl/web/javascript/reference/functions/set/index.html @@ -0,0 +1,146 @@ +--- +title: setter +slug: Web/JavaScript/Reference/Functions/set +translation_of: Web/JavaScript/Reference/Functions/set +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>Składnia <strong><code>set</code></strong> wiąże właściwość obiektu z funkcją, która zostanie wywołana przy próbie przypisania wartości danej właściwości.</p> + +<div>{{EmbedInteractiveExample("pages/js/functions-setter.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">{set <em>prop</em>(<em>val</em>) { . . . }} +{set [expression](<em>val</em>) { . . . }}</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>prop</code></dt> + <dd>Nazwa właściwości wiązanej z określoną funkcją.</dd> +</dl> + +<dl> + <dt><code>val</code></dt> + <dd>Zmienna przechowująca wartość przekazaną do przypisania do właściwości <code>prop.</code></dd> + <dt>expression</dt> + <dd>Począwszy od ECMAScript 2015, można również użyć wyrażeń w celu połaczenia funkcji z nazwą właściwości, która jest obliczana.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>Setter może być użyty do wywołania określonej funkcji przy każdej próbie przypisania wartości do danej właściwości. Settery są najczęściej używane razem z getterami żeby utworzyć rodzaj pseudo-właściwości. Nie ma możliwości jednoczesnego używania settera oraz faktycznej wartości przypisanej do danej właściwości.</p> + +<p>Uwagi do składni <code>set</code>:</p> + +<div> +<ul> + <li>Można utworzyć identyfikator typu number lub string;</li> + <li>Setter musi mieć jeden paramter (sprawdź szczegóły <a class="external" href="http://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/" rel="external nofollow">Niekompatybilna zmiana <abbr title="ECMAScript 5th edition">ES5</abbr>: gettery i settery muszą mieć dokładnie zero lub one argument</a>);</li> + <li>Setter nie może być zdefiniowany kilkukrotnie dla danej właściwości. Jednoczesne użycie settera i faktycznej wartości przypisanej do właściwości jest zabronione<br> + ( <code>{ set x(v) { }, set x(v) { } }</code> oraz <code>{ x: ..., set x(v) { } }</code> są zabronione)</li> +</ul> +</div> + +<p>Setter może być usunięty przy użyciu operatora <a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete" title="en-US/docs/JavaScript/Reference/Operators/Special/delete"><code>delete</code></a>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Definicja_settera_w_nowym_obiekcie_podczas_inicjalizacji">Definicja settera w nowym obiekcie podczas inicjalizacji</h3> + +<p>Poniższa składnia definiuje pseudo-właściwość <code>current</code> obiektu <font face="consolas, Liberation Mono, courier, monospace">language</font>, która podczas przypisania wartości aktualizuje tablicę <code>log</code> o tą wartość:</p> + +<pre class="brush: js">var language = { + set current(name) { + this.log.push(name); + }, + log: [] +} + +language.current = 'EN'; +console.log(language.log); // ['EN'] + +language.current = 'FA'; +console.log(language.log); // ['EN', 'FA'] +</pre> + +<p>Zwróć uwagę, że właściwość <code>current</code> nie jest zdefiniowana i próby odczytu zwrócą <code>undefined</code>.</p> + +<h3 id="Usuwanie_settera_przy_użyciu_operatora_delete">Usuwanie settera przy użyciu operatora <code>delete</code></h3> + +<p>Setter może zostać usunięty przy użyciu <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code>:</p> + +<pre class="brush: js">delete o.current; +</pre> + +<h3 id="Definicja_settera_dla_istniejącego_obiektu_przy_użyciu_defineProperty">Definicja settera dla istniejącego obiektu przy użyciu <code>defineProperty</code></h3> + +<p>Aby zdefiniować setter dla istniejącego obiektu po jego uprzednim utworzeniu użyj {{jsxref("Object.defineProperty()")}}.</p> + +<pre class="brush: js">var o = {a: 0}; + +Object.defineProperty(o, 'b', { set: function(x) { this.a = x / 2; } }); + +o.b = 10; // Uruchamia setter, który przypisuje 10 / 2 (5) do właściwości 'a' +console.log(o.a) // 5</pre> + +<h3 id="Używanie_wyrażenia_do_obliczenia_nazwy_settera">Używanie wyrażenia do obliczenia nazwy settera</h3> + +<pre class="brush: js">var expr = 'foo'; + +var obj = { + baz: 'bar', + set [expr](v) { this.baz = v; } +}; + +console.log(obj.baz); // "bar" +obj.foo = 'baz'; // uruchom setter +console.log(obj.baz); // "baz" +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Added computed property names.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.functions.set")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">getter</a></li> + <li>{{jsxref("Operators/delete", "delete")}}</li> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li> + <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Defining Getters and Setters</a> in JavaScript Guide</li> +</ul> diff --git a/files/pl/web/javascript/referencje/funkcje/arguments/callee/index.html b/files/pl/web/javascript/referencje/funkcje/arguments/callee/index.html new file mode 100644 index 0000000000..50b76e1f63 --- /dev/null +++ b/files/pl/web/javascript/referencje/funkcje/arguments/callee/index.html @@ -0,0 +1,60 @@ +--- +title: callee +slug: Web/JavaScript/Referencje/Funkcje/arguments/callee +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Functions/arguments/callee +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Określa aktualnie wykonywaną funkcję. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Własność obiektów <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments">arguments</a> i <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/arguments">Function.arguments</a> (Wycofywany)</td> +</tr> +<tr> +<td>Zaimplementowano w:</td> +<td>JavaScript 1.2 +<p>JavaScript 1.4: <code>callee</code> wycofywany jako własność <code>Function.arguments</code>, zachowany jako własność zmiennej lokalnej <code>arguments</code> funkcji. +</p> +</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262</td> +</tr> +</tbody></table> +<h3 id="Opis" name="Opis"> Opis </h3> +<p><code>callee</code> jest własnością zmiennej lokalnej <code>arguments</code> dostępnej wewnątrz wszystkich obiektów funkcji; <code>callee</code> jako własność <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/arguments">Function.arguments</a></code> nie jest już używana (również sam obiekt <code>Function.arguments</code> jest wycofywany). +</p><p><code>arguments.callee</code> pozwala anonimowym funkcjom odwoływać się do siebie samych, co jest potrzebne w przypadku rekursywnych anonimowych funkcji. +</p><p>Słowo kluczowe <code>this</code> nie odwołuje się do aktualnie wykonywanej funkcji. Użyj własności <code>callee</code>, aby odwołać się do funkcji z poziomu jej ciała. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_arguments.callee_w_anonimowych_funkcjach_rekursywnych" name="Przyk.C5.82ad:_Zastosowanie_arguments.callee_w_anonimowych_funkcjach_rekursywnych"> Przykład: Zastosowanie <code>arguments.callee</code> w anonimowych funkcjach rekursywnych </h4> +<p>Funkcja rekursywna musi mieć możliwość odwołania się do siebie samej. Zazwyczaj funkcja odwołuje się do samej siebie wykorzystując swoją nazwę. Jednakże anonimowa funkcja nie posiada nazwy i jeśli w łańcuchu zasięgu nie istnieje zmienna odwołująca się do tej funkcji, tj. funkcja nie jest przypisana do żadnej zmiennej, to funkcja ta nie ma możliwości odwołania się do siebie samej (anonimowe funkcje można tworzyć przy użyciu <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_function">wyrażenia function</a> lub <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">konstruktora <code>Function</code></a>). W tym miejscu wkracza <code>arguments.callee</code>. +</p><p>Poniższy przykład definiuje funkcję, która z kolei definiuje i zwraca funkcję obliczającą silnię. +</p> +<pre class="eval">function makeFactorialFunc() { + alert('tworzenie funkcji obliczającej silnię!'); + return function(x) { + if (x <= 1) + return 1; + return x * arguments.callee(x - 1); + }; +} + +var result = makeFactorialFunc()(5); // zwraca 120 (5 * 4 * 3 * 2 * 1) +</pre> +<p><span class="comment">this example isn't very practical, but then again, there are few practical cases where arguments.callee is necessary, and most of the those cases involve closures</span> +</p><p><br> +</p><p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments/callee", "es": "es/Referencia_de_JavaScript_1.5/Funciones/arguments/callee", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments/callee", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments/callee" } ) }} diff --git a/files/pl/web/javascript/referencje/funkcje/arguments/caller/index.html b/files/pl/web/javascript/referencje/funkcje/arguments/caller/index.html new file mode 100644 index 0000000000..1eb9d8279b --- /dev/null +++ b/files/pl/web/javascript/referencje/funkcje/arguments/caller/index.html @@ -0,0 +1,48 @@ +--- +title: caller +slug: Web/JavaScript/Referencje/Funkcje/arguments/caller +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/JavaScript/arguments.caller +--- +<p> +{{ Obsolete_header() }} +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Określa funkcję, która wywołała aktualnie wykonywaną funkcję. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Własność funkcji: <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments">arguments</a></td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.1, NES 2.0 +<p>JavaScript 1.3: Wycofywana. +<span class="comment">JavaScript ??: Removed</span> +</p> +</td> +</tr> +</tbody></table> +<h3 id="Opis" name="Opis"> Opis </h3> +<p><b><code>arguments.caller</code> nie może być już stosowana.</b> Zamiast tego należy użyć niestandardowej własności <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/caller">caller</a></code> obiektu funkcji. Szczegóły można znaleźć w jej opisie. +</p><p>Własność <code>arguments.caller</code> jest dostępna tylko wewnątrz ciała funkcji. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<p>Poniższy kod sprawdza wartość <code>arguments.caller</code> w funkcji. +</p> +<pre class="eval">function myFunc() { + if (arguments.caller == null) { + return ("Funkcja została wywołana z góry!"); + } else + return ("Funkcję wywołano poprzez " + arguments.caller); +} +</pre> +<p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments/caller", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments/caller", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments/caller" } ) }} diff --git a/files/pl/web/javascript/referencje/funkcje/arguments/index.html b/files/pl/web/javascript/referencje/funkcje/arguments/index.html new file mode 100644 index 0000000000..8a48b5b323 --- /dev/null +++ b/files/pl/web/javascript/referencje/funkcje/arguments/index.html @@ -0,0 +1,129 @@ +--- +title: arguments +slug: Web/JavaScript/Referencje/Funkcje/arguments +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Functions/arguments +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Tablicopodobny obiekt odpowiadający argumentom przekazanym do funkcji. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2"> +Zmienna lokalna we wszystkich funkcjach oraz wycofywana własność obiektu <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a></td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.1, NES 2.0 +<p>JavaScript 1.2: dodano własność <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/callee">arguments.callee</a></code>. +</p><p>JavaScript 1.3: wycofywana własność <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/caller">arguments.caller</a></code>; usunięto obsługę nazw argumentów oraz zmiennych lokalnych jako własności obiektu <code>arguments</code>. +</p><p>JavaScript 1.4: wycofywane <code>arguments</code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/callee">arguments.callee</a></code> oraz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">arguments.length</a></code> jako własności <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a></code>; zachowanie <code>arguments</code> jako lokalnej zmiennej funkcji oraz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/callee">arguments.callee</a></code> oraz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">arguments.length</a></code> jako własności tej zmiennej. +</p> +</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262</td> +</tr> +</tbody></table> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Obiekt <code>arguments</code> jest zmienną lokalną dostępną wewnątrz każdej funkcji; <code>arguments</code> jako własność <code>Function</code> nie może być już używana. +</p><p>Do argumentów wewnątrz funkcji możesz odwołać się używając obiektu <code>arguments</code>. Obiekt ten zawiera pozycję dla każdego argumentu przekazanego funkcji, przy czym indeks pierwszego z nich ma wartość 0. Na przykład, jeśli do funkcji przekazane są trzy argumenty, można się do nich odwołać w następujący sposób: +</p> +<pre class="eval">arguments[0] +arguments[1] +arguments[2] +</pre> +<p>Argumentom mogą być również przypisywane wartości: +</p> +<pre class="eval">arguments[1] = 'nowa wartosc'; +</pre> +<div class="note"><b>Uwaga:</b> silnik JavaScript <a href="pl/SpiderMonkey">SpiderMonkey</a> posiada <a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=292215">bug</a>, w którym nie można do <code>arguments{{ mediawiki.external('n') }}</code> przypisać wartości, jeśli <code>n</code> jest większe niż liczba formalnych lub rzeczywistych parametrów. +Błąd ten został usunięty w silniku JavaScript 1.6.</div> +<p>Obiekt <code>arguments</code> nie jest tablicą. Jest do niej podobny, lecz nie posiada żadnej z własności tablicy poza <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">length</a></code>. Przykładowo nie posiada on metody <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/pop">pop</a></code>. Może być on jednak skonwertowany do prawdziwej tablicy: +</p> +<pre class="eval"> var args = Array.prototype.slice.call(arguments); +</pre> +<p>Obiekt <code>arguments</code> dostępny jest wyłącznie wewnątrz ciała funkcji. Próba dostępu do obiektu <code>arguments</code> spoza części deklaracyjnej funkcji zakończy się błędem. +</p><p>Możesz użyć obiektu <code>arguments</code>, jeśli funkcja wywołana jest z większą liczbą argumentów niż zostało to zadeklarowane. Jest to użyteczne dla funkcji, które wywoływać można ze zmienną liczbą argumentów. +Aby określić liczbę argumentów przekazywanych do funkcji można użyć własności +<code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">arguments.length</a></code>, a następnie skorzystać z każdego z argumentów używając obiektu <code>arguments</code> (aby określić liczbę argumentów zadeklarowanych podczas definiowania funkcji, skorzystać można z własności <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/length">Function.length</a></code>). +</p> +<h3 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci"> Własności </h3> +<dl><dt> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/callee">arguments.callee</a></code></dt><dd> Określa ciało funkcji aktualnie wykonywanej funkcji. +</dd></dl> +<dl><dt> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/caller">arguments.caller</a></code> {{ Deprecated_inline() }}</dt><dd> Określa nazwę funkcji, która wywołała aktualnie wykonywaną funkcję. +</dd></dl> +<dl><dt> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">arguments.length</a></code></dt><dd> Określa liczbę argumentów przekazywanych do funkcji. +</dd></dl> +<h3 id="Zgodno.C5.9B.C4.87_wsteczna" name="Zgodno.C5.9B.C4.87_wsteczna"> Zgodność wsteczna </h3> +<h4 id="JavaScript_1.3_i_wcze.C5.9Bniejsze_wersje" name="JavaScript_1.3_i_wcze.C5.9Bniejsze_wersje"> JavaScript 1.3 i wcześniejsze wersje </h4> +<p>Oprócz dostępności jako zmienna lokalna, obiekt <code>arguments</code> jest również własnością obiektu <code>Function</code> i może być poprzedzony nazwą funkcji. Na przykład, jeżeli do funkcji <code>myFunc</code> są przekazywane trzy argumenty o nazwie <code>arg1</code>, <code>arg2</code>, i <code>arg3</code>, można odwołać się do tych argumentów następująco: +</p> +<pre class="eval">myFunc.arguments[0] +myFunc.arguments[1] +myFunc.arguments[2] +</pre> +<h4 id="JavaScript_1.1_i_1.2" name="JavaScript_1.1_i_1.2"> JavaScript 1.1 i 1.2 </h4> +<p>Następujące cechy dostępne w JavaScripcie 1.1 i JavaScripcie 1.2 zostały usunięte: +</p> +<ul><li> Każda zmienna lokalna funkcji jest własnością obiektu <code>arguments</code>. Na przykład, jeśli funkcja <code>myFunc</code> posiada zmienną lokalną nazwaną <code>myLocalVar</code>, możesz odwołać się do zmiennej jako <code>arguments.myLocalVar</code>. +</li></ul> +<ul><li> Każdy argument formalny funkcji jest własnością obiektu <code>arguments</code>. Na przykład, jeżeli funkcja <code>myFunc</code> posiada dwa argumenty o nazwie <code>arg1</code> i <code>arg2</code>, możesz odwołać się do nich jako <code>arguments.arg1</code> i <code>arguments.arg2</code> (możesz także odwołać się do tych argumentów poprzez <code>arguments{{ mediawiki.external(0) }}</code> i <code>arguments{{ mediawiki.external(1) }}</code>). +</li></ul> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Definiowanie_funkcji_.C5.82.C4.85cz.C4.85cej_.C5.82a.C5.84cuchy_znak.C3.B3w" name="Przyk.C5.82ad:_Definiowanie_funkcji_.C5.82.C4.85cz.C4.85cej_.C5.82a.C5.84cuchy_znak.C3.B3w"> Przykład: Definiowanie funkcji łączącej łańcuchy znaków </h4> +<p>Ten przykład definiuje funkcję łączącą kilka łańcuchów znaków. Jedynym formalnym argumentem tej funkcji jest łańcuch znaków, który określa znaki oddzielające poszczególne łączone elementy. Funkcja jest zdefiniowana następująco: +</p> +<pre class="eval">function myConcat(separator) { + result = ""; // inicjalizacja listy + // iteracja pomiędzy argumentami + for (var i = 1; i < arguments.length; i++) { + result += arguments[i] + separator; + } + return result; +} +</pre> +<p>Możesz przesłać dowolną liczbę argumentów do tej funkcji, tworząc na ich bazie listę. +</p> +<pre class="eval">// zwraca "czerwony, pomaranczowy, niebieski, " +myConcat(", ", "czerwony", "pomaranczowy", "niebieski"); + +// zwraca "slon; zyrafa; lew; gepard; " +myConcat("; ", "slon", "zyrafa", "lew", "gepard"); + +// zwraca "szalwia. bazylia. oregano. pieprz. pietruszka. " +myConcat(". ", "szalwia", "bazylia", "oregano", "pieprz", "pietruszka"); +</pre> +<h4 id="Przyk.C5.82ad:_Definiowanie_funkcji.2C_kt.C3.B3ra_tworzy_list.C4.99_HTML" name="Przyk.C5.82ad:_Definiowanie_funkcji.2C_kt.C3.B3ra_tworzy_list.C4.99_HTML"> Przykład: Definiowanie funkcji, która tworzy listę HTML </h4> +<p>Ten przykład definiuje funkcję, która tworzy łańcuch znaków reprezentujący kod HTML listy. Jedynym argumentem formalnym tej funkcji jest ciąg znaków, który przyjmuje wartość "<code>u</code>" dla listy nieuporządkowanej, lub "<code>o</code>" w przypadku listy uporządkowanej. Funkcja ta jest zdefiniowana następująco: +</p> +<pre>function list(type) { + var result = "<" + type + "l>"; + + // iteracja pomiędzy argumentami + for (var i = 1; i < arguments.length; i++) + result += "<li>" + arguments[i] + "</li>"; + + result += "</" + type + "l>"; // koniec listy + + return result; +} +</pre> +<p>Możesz przekazać funkcji dowolną liczbę argumentów, a ona doda każdy z nich jako kolejną pozycję na liście o wskazanym typie. Przykładowo następujące wywołanie funkcji: +</p> +<pre>var listHTML = list("u", "Raz", "Dwa", "Trzy"); +// listHTML zawiera łańcuch "<ul><li>Raz</li><li>Dwa</li><li>Trzy</li></ul>" +</pre> +<p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments", "es": "es/Referencia_de_JavaScript_1.5/Funciones/arguments", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments" } ) }} diff --git a/files/pl/web/javascript/referencje/funkcje/arguments/length/index.html b/files/pl/web/javascript/referencje/funkcje/arguments/length/index.html new file mode 100644 index 0000000000..79d54a4f50 --- /dev/null +++ b/files/pl/web/javascript/referencje/funkcje/arguments/length/index.html @@ -0,0 +1,59 @@ +--- +title: length +slug: Web/JavaScript/Referencje/Funkcje/arguments/length +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Functions/arguments/length +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Określa liczbę argumentów przekazywanych do funkcji. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Własność obiektów <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments">arguments</a> i <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/arguments">Function.arguments</a> (wycofywana)</td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.1 +<p>JavaScript 1.4: Przenaczono do wycofania <code>length</code> jako własność <code>Function.arguments</code>, zachowano ją natomiast jako własność zmiennej lokalnej <code>arguments</code> funkcji. +</p> +</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262</td> +</tr> +</tbody></table> +<h3 id="Opis" name="Opis"> Opis </h3> +<p><code>length</code> jest własnością zmiennej lokalnej <code>arguments</code> dostępnej wewnątrz wszystkich obiektów funkcji; <code>length</code> jako własność <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/arguments">Function.arguments</a></code> nie jest już używana (również sam obiekt <code>Function.arguments</code> jest wycofywany). +</p><p><code>arguments.length</code> dostarcza liczbę argumentów przekazywanych obecnie funkcji. Dla porównania, własność <code>Function.length</code> wskazuje ilość argumentów oczekiwanych przez funkcję. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length" name="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length"> Przykład: Zastosowanie <code>Function.length</code> i <code>arguments.length</code> </h4> +<p>Następujący przykład przedstawia zastosowanie <code>Function.length</code> i <code>arguments.length</code>. +</p> +<pre>function addNumbers(x,y){ + if (arguments.length == addNumbers.length) { + return (x+y) + } + else return 0 +} +</pre> +<p>Jeśli podano więcej niż dwa argumenty funkcji, zostanie zwrócona wartość 0: +</p> +<pre>result=addNumbers(3,4,5) // zwraca 0 +result=addNumbers(3,4) // zwraca 7 +result=addNumbers(103,104) // zwraca 207 +</pre> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/length">Function.length</a></code> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments/length", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments/length", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments/length" } ) }} diff --git a/files/pl/web/javascript/referencje/index.html b/files/pl/web/javascript/referencje/index.html new file mode 100644 index 0000000000..e493d4ad80 --- /dev/null +++ b/files/pl/web/javascript/referencje/index.html @@ -0,0 +1,70 @@ +--- +title: Dokumentacja referencyjna JavaScript +slug: Web/JavaScript/Referencje +tags: + - AJAX + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference +--- +<h4 id="JsSidebar">{{JsSidebar}}</h4> + +<p>Ta część rozdziału JavaScript na MDN służy jako repozytorium faktów dotyczących jezyka JavaScript. Więcej na ten temat na stronie <a href="/pl/docs/Web/JavaScript/Reference/About">O dokumentacji referencyjnej</a>.<br> + </p> + +<h2 id="Obiekty_globalne">Obiekty globalne</h2> + +<p>W tym rozdziale udokumentowano wszystkie <a href="/pl/docs/Web/JavaScript/Reference/Global_Objects">standardowe wbudowane obiekty JavaScript</a>, wraz z ich metodami i właściwościami.<br> + </p> + +<p>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects', 'Standard_objects_by_category')}}</p> + +<h2 id="Instrukcje">Instrukcje</h2> + +<p>Rozdział ten dokumentuje wszystkie <a href="/pl/docs/Web/JavaScript/Reference/Statements">deklaracje i instrukcje JavaScript</a>.</p> + +<p>{{page('/en-US/docs/Web/JavaScript/Reference/Statements', 'Statements_and_declarations_by_category')}}</p> + +<p> </p> + +<h2 id="Wyrażenia_i_operatory">Wyrażenia i operatory</h2> + +<p>Udokumentowano tu wszystkie <a href="/pl/docs/Web/JavaScript/Reference/Operators">wyrażenie i operatory JavaScript</a>.</p> + +<p>{{page('/en-US/docs/Web/JavaScript/Reference/Operators', 'Expressions_and_operators_by_category')}}</p> + +<p> </p> + +<h2 id="Funkcje">Funkcje</h2> + +<p>W tym rozdziale opisano pracę z <a href="/pl/docs/Web/JavaScript/Reference/Functions">funkcjami JavaScript</a> przy tworzeniu aplikacji.</p> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/arguments"><code>argumenty</code></a></li> + <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/Arrow_functions">funkcje strzałkowe</a></li> + <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/Default_parameters">parametry domyślne</a></li> + <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/rest_parameters">parametry resztowe</a></li> +</ul> + +<p> </p> + +<h2 id="Dodatkowe_strony_z_informacjami">Dodatkowe strony z informacjami</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Reference/Lexical_grammar">Gramatyka leksykalna</a></li> + <li><a href="/pl/docs/Web/JavaScript/Data_structures">Typy danych i struktury danych</a></li> + <li><a href="/pl/docs/Web/JavaScript/Reference/Strict_mode">Tryb ścisły</a></li> + <li><a href="/pl/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features">Funkcjonalności zdeprecjonowane</a></li> +</ul> + +<p> </p> + +<p> </p> + +<p> </p> + +<p> </p> + +<p> </p> diff --git a/files/pl/web/javascript/referencje/komentarz/index.html b/files/pl/web/javascript/referencje/komentarz/index.html new file mode 100644 index 0000000000..4561a31d9b --- /dev/null +++ b/files/pl/web/javascript/referencje/komentarz/index.html @@ -0,0 +1,54 @@ +--- +title: Komentarz +slug: Web/JavaScript/Referencje/Komentarz +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Lexical_grammar#Comments +--- +<p> </p> +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> +<p>Uwagi od programisty wyjaśniające działanie kodu. Komentarze są ignorowane przez interpreter.</p> +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header" colspan="2">Komentarze</td> + </tr> + <tr> + <td>Zaimplementowane w:</td> + <td>JavaScript 1.0, NES2.0</td> + </tr> + <tr> + <td>Wersja ECMA:</td> + <td>ECMA-262</td> + </tr> + </tbody> +</table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> +<p><code>// tekst komentarza </code></p> +<p><code>/* wieloliniowy tekst komentarza */ </code></p> +<h3 id="Opis" name="Opis">Opis</h3> +<p>JavaScript obsługuje komentarze w stylu Javy:</p> +<ul> + <li>Komentarze zawarte w jednej linii poprzedzone są dwoma ukośnikami (<code>//</code>),</li> + <li>Komentarze zawarte w wielu liniach poprzedzone są znakami <code>/*</code>, a zakończone znakami <code>*/</code>. Komentarze wieloliniowe + <i> + nie mogą</i> + być zagnieżdżane.</li> +</ul> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3> +<h4 id="Przyk.C5.82ad:_Komentarz_jednoliniowy" name="Przyk.C5.82ad:_Komentarz_jednoliniowy">Przykład: Komentarz jednoliniowy</h4> +<pre>// To jest komentarz jednoliniowy. +var intAge = 37; //To jest inny komentarz +</pre> +<h4 id="Przyk.C5.82ad:_Komentarz_wieloliniowy" name="Przyk.C5.82ad:_Komentarz_wieloliniowy">Przykład: Komentarz wieloliniowy</h4> +<pre>/* To jest komentarz wieloliniowy. + Może być dowolnie długi i zawierać dowolne znaki, + za wyjątkiem innych komentarzy wieloliniowych. */ +</pre> +<p> </p> +<div class="noinclude"> + </div> +<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Comments/comment", "es": "es/Referencia_de_JavaScript_1.5/Comentarios/comentario", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Commentaires", "ja": "ja/Core_JavaScript_1.5_Reference/Comments/comment" } ) }}</p> diff --git a/files/pl/web/javascript/referencje/liveconnect/index.html b/files/pl/web/javascript/referencje/liveconnect/index.html new file mode 100644 index 0000000000..74f6c075d4 --- /dev/null +++ b/files/pl/web/javascript/referencje/liveconnect/index.html @@ -0,0 +1,23 @@ +--- +title: LiveConnect +slug: Web/JavaScript/Referencje/LiveConnect +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect/LiveConnect_Reference +--- +<p> +</p><p>Ten rozdział opisuje klasy języka Java używane z technologią LiveConnect wraz z ich konstruktorami i metodami. Klasy te pozwalają obiektom języka Java na dostęp do kodu JavaScript. +</p><p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/LiveConnect/JSException">JSException</a> +</p> +<dl><dd> Publiczna klasa <code>JSException</code> dziedziczy po klasie <code>RuntimeException</code>. Wyjątek ten jest wyrzucany, kiedy kod JavaScriptu zwróci błąd. +</dd></dl> +<p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/LiveConnect/JSObject">JSObject</a> +</p> +<dl><dd> Publiczna klasa <code>JSObject</code> dziedziczy po klasie <code>Object</code>. Obiekty JavaScriptu są otaczane instancjami klasy <code>JSObject</code> i przekazywane do kodu Javy, pozwalając Javie na manipulowanie obiektami JavaScriptu. +</dd></dl> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/LiveConnect", "es": "es/Referencia_de_JavaScript_1.5/LiveConnect" } ) }} diff --git a/files/pl/web/javascript/referencje/liveconnect/jsexception/index.html b/files/pl/web/javascript/referencje/liveconnect/jsexception/index.html new file mode 100644 index 0000000000..3d66cc7ac7 --- /dev/null +++ b/files/pl/web/javascript/referencje/liveconnect/jsexception/index.html @@ -0,0 +1,93 @@ +--- +title: JSException +slug: Web/JavaScript/Referencje/LiveConnect/JSException +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect/LiveConnect_Reference/JSException +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Publiczna klasa<code>JSException</code> rozszerzająca <code>RuntimeException</code> +</p> +<pre>java.lang.Object + | + +----java.lang.Throwable + | + +----java.lang.Exception + | + +----java.lang.RuntimeException + | + +----netscape.javascript.JSException +</pre> +<h3 id="Opis" name="Opis"> Opis </h3> +<p><code>JSException</code> jest wyjątkiem wyrzucanym, kiedy kod JavaScript zwróci błąd. +</p> +<h3 id="Podsumowanie_konstruktora" name="Podsumowanie_konstruktora"> Podsumowanie konstruktora </h3> +<p>Klasa <code>netscape.javascript.JSException</code> posiada następujące konstruktory : +</p> +<dl><dt> <code>JSException</code></dt><dd> Przestarzały konstruktor pozwala opcjonalnie na określenie szczegółowego powiadomienia lub innych informacji. +</dd></dl> +<h3 id="Podsumowanie_metod" name="Podsumowanie_metod"> Podsumowanie metod </h3> +<p>Klasa <code>netscape.javascript.JSException</code> posiada następujące metody: +</p> +<dl><dt> <code>getWrappedException</code> </dt><dd> Instancja metody <code>getWrappedException</code>. +</dd></dl> +<dl><dt> <code>getWrappedExceptionType</code> </dt><dd> Instancja metody <code>getWrappedExceptionType</code> zwraca wartość int mapującą typ obiektu <code>wrappedException</code>. +</dd></dl> +<h3 id="Kompatybilno.C5.9B.C4.87_wsteczna" name="Kompatybilno.C5.9B.C4.87_wsteczna"> Kompatybilność wsteczna </h3> +<h4 id="JavaScript_1.1_do_1.3" name="JavaScript_1.1_do_1.3"> JavaScript 1.1 do 1.3 </h4> +<p>Klasa <code>JSException</code> miała trzy konstruktory publiczne, które opcjonalnie pobierały argument w postaci ciągu znaków, określającego szczegółowy komunikat lub inne informacje danego wyjątku. Metoda <code>getWrappedException</code> nie była dostępna. +</p><p>Konstruktory <code>JSException</code>, oznaczone jako przestarzałe w JavaScripcie 1.4, tworzą obiekt <code>JSException</code> z opcjonalnym komunikatem szczegółowym. +</p> +<h3 id="Deklaracja" name="Deklaracja"> Deklaracja </h3> +<pre>1. public JSException() + +2. public JSException(String s) + +3. public JSException(String s, + String filename, + int lineno, + String source, + int tokenIndex) +</pre> +<h3 id="Argumenty" name="Argumenty"> Argumenty </h3> +<dl><dt> <code>s</code> </dt><dd> Szczegółowy komunikat. </dd></dl> +<dl><dt> <code>filename</code> </dt><dd> Adres URL pliku gdzie wystąpił błąd, o ile jest dostępny. </dd></dl> +<dl><dt> <code>lineno</code> </dt><dd> Liczba linii w pliku, o ile jest dostępny. </dd></dl> +<dl><dt> <code>source</code> </dt><dd> Łańcuch znakowy zawierający wykonywany kod JavaScript. </dd></dl> +<dl><dt> <code>tokenIndex</code> </dt><dd> Indeks w źródłowym łańcuchu znaków, wskazujący miejsce wystąpienia błędu. +</dd></dl> +<h3 id="getWrappedException" name="getWrappedException"> <code>getWrappedException</code> </h3> +<p>Metoda instancji <code>getWrappedException</code>. +</p> +<h4 id="Deklaracja_2" name="Deklaracja_2"> Deklaracja </h4> +<p><code> +public Object getWrappedException() +</code> +</p> +<h4 id="Opis_2" name="Opis_2"> Opis </h4> +<p><code>getWrappedException()</code> zwraca obiek reprezentujący wartość faktycznie wyrzuconą przez JavaScript. JavaScript może wyrzucić wartość dowolnego typu. Metoda <code>getWrappedException()</code> pozwala określić, jaki rodzaj wartości jest reprezentowany przez zwracany typ Object. +</p> +<h3 id="getWrappedExceptionType" name="getWrappedExceptionType"> <code>getWrappedExceptionType</code> </h3> +<p>Metoda instancji <code>getWrappedExceptionType</code>. +</p> +<h4 id="Deklaracja_3" name="Deklaracja_3"> Deklaracja </h4> +<p><code> +public int getWrappedExceptionType() +</code> +</p> +<h4 id="Opis_3" name="Opis_3"> Opis </h4> +<p><code>getWrappedExceptionType()</code> zwraca wartość <code>int</code>, pasującą do jednej z następujących statycznych <code>int</code> pól klasy <code>JSException</code>: +</p> +<ul><li> <code>EXCEPTION_TYPE_EMPTY</code> +</li><li> <code>EXCEPTION_TYPE_VOID</code> +</li><li> <code>EXCEPTION_TYPE_OBJECT</code> +</li><li> <code>EXCEPTION_TYPE_FUNCTION</code> +</li><li> <code>EXCEPTION_TYPE_STRING</code> +</li><li> <code>EXCEPTION_TYPE_NUMBER</code> </li><li> <code>EXCEPTION_TYPE_BOOLEAN</code> +</li></ul> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/LiveConnect/JSException" } ) }} diff --git a/files/pl/web/javascript/referencje/liveconnect/jsobject/index.html b/files/pl/web/javascript/referencje/liveconnect/jsobject/index.html new file mode 100644 index 0000000000..c556510362 --- /dev/null +++ b/files/pl/web/javascript/referencje/liveconnect/jsobject/index.html @@ -0,0 +1,186 @@ +--- +title: JSObject +slug: Web/JavaScript/Referencje/LiveConnect/JSObject +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect/LiveConnect_Reference/JSObject +--- +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> + +<p>The public final class <code>netscape.javascript.JSObject</code> extends <code>Object</code>.</p> + +<pre>java.lang.Object + | + +----netscape.javascript.JSObject +</pre> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Obiekty JavaScript są are wrapped in an instance of the class <code>netscape.javascript.JSObject</code> and passed to Java. <code>JSObject</code> allows Java to manipulate JavaScript objects.</p> + +<p>When a JavaScript object is sent to Java, the runtime engine creates a Java wrapper of type <code>JSObject</code>; when a <code>JSObject</code> is sent from Java to JavaScript, the runtime engine unwraps it to its original JavaScript object type. The <code>JSObject</code> class provides a way to invoke JavaScript methods and examine JavaScript properties.</p> + +<p>Any JavaScript data brought into Java is converted to Java data types. When the <code>JSObject</code> is passed back to JavaScript, the object is unwrapped and can be used by JavaScript code. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5">Przewodnik po języku JavaScript 1.5</a> w celu uzyskania dodatkowych informacji o konwersji typu danych.</p> + +<h3 id="Podsumowanie_metod" name="Podsumowanie_metod">Podsumowanie metod</h3> + +<p>Klasa <code>netscape.javascript.JSObject</code> posiada następujące metody:</p> + +<dl> + <dt><code>{{ Anch("call") }}</code> </dt> + <dd>Wywołuje metodę JavaScript.</dd> +</dl> + +<dl> + <dt><code>{{ Anch("equals") }}</code> </dt> + <dd>Określa, jeśli dwa obiekty <code>JSObject</code> odnoszą się do tej samej instancji.</dd> +</dl> + +<dl> + <dt><code>{{ Anch("eval") }}</code> </dt> + <dd>Wykonuje wyrażenie JavaScript.</dd> +</dl> + +<dl> + <dt><code>{{ Anch("getMember") }}</code> </dt> + <dd>Odzyskuje wartość własności obiektu JavaScript.</dd> +</dl> + +<dl> + <dt><code>{{ Anch("getSlot") }}</code> </dt> + <dd>Odzyskuje wartość elementu tablicy obiektu JavaScript.</dd> +</dl> + +<dl> + <dt><code>{{ Anch("removeMember") }}</code> </dt> + <dd>Usuwa własność obiektu JavaScript.</dd> +</dl> + +<dl> + <dt><code>{{ Anch("setMember") }}</code> </dt> + <dd>Ustawia wartość własności obiektu JavaScript.</dd> +</dl> + +<dl> + <dt><code>{{ Anch("setSlot") }}</code> </dt> + <dd>Ustawia wartość elementu tablicy obiektu JavaScript.</dd> +</dl> + +<dl> + <dt><code>{{ Anch("toString") }}</code> </dt> + <dd>Konwertuje JSObject do łańcucha znaków.</dd> +</dl> + +<p>Klasa <code>netscape.javascript.JSObject</code> posiada następujące statyczne metody:</p> + +<dl> + <dt><code>{{ Anch("getWindow") }}</code> </dt> + <dd>Pobiera <code>JSObject</code> dla okna stanowiącego dany aplet.</dd> +</dl> + +<h4 id="call" name="call">call</h4> + +<p>Metoda. Wywołuje metodę JavaScript. Równoważny z "<code>this.methodName(args{{ mediawiki.external(0) }}, args{{ mediawiki.external(1) }}, ...)</code>" w JavaScript.</p> + +<h5 id="Deklaracja" name="Deklaracja">Deklaracja</h5> + +<pre>public Object call(String methodName, + Object args[]) +</pre> + +<h4 id="equals" name="equals">equals</h4> + +<p>Metoda. Określona, jeśli dwa obiekty <code>JSObject</code> odnoszą się do tej samej instancji.</p> + +<p>Przesłania: <code>equals</code> w klasie <code>java.lang.Object</code></p> + +<h5 id="Deklaracja_2" name="Deklaracja_2">Deklaracja</h5> + +<pre>public boolean equals(Object obj) +</pre> + +<h5 id="Kompatybilno.C5.9B.C4.87_wsteczna" name="Kompatybilno.C5.9B.C4.87_wsteczna">Kompatybilność wsteczna</h5> + +<p><strong>JavaScript 1.3</strong>. W JavaScript 1.3 i wersjach wcześniejszych, możemy zastosować wcześniejsze metody równości <code>java.lang.Object</code> lub operator <code>==</code> do porównania dwóch obiektów <code>JSObject</code>.</p> + +<p>W większości ostatnich wersji, samo <code>JSObject</code> potrafi wyświetlić jako obiekt Javy. Można użyć metody equals do określenia gdzie dwa obiekty <code>JSObjects</code> odnoszą się do tej samej instancji.</p> + +<h4 id="eval" name="eval">eval</h4> + +<p>Metoda. Wykonuje wyrażenia JavaScript. Wyrażenie jest łańcuchem znakowym kodu źródłowego JavaScript, który będzie wykonany w kontekście pobierania przez "this".</p> + +<h5 id="Deklaracja_3" name="Deklaracja_3">Deklaracja</h5> + +<pre>public Object eval(String s) +</pre> + +<h4 id="getMember" name="getMember">getMember</h4> + +<p>Metoda. Odzyskuje wartość własności obiektu JavaScript. Równoważna do "<code>this.name</code>" w JavaScript.</p> + +<h5 id="Deklaracja_4" name="Deklaracja_4">Deklaracja</h5> + +<pre>public Object getMember(String name) +</pre> + +<h4 id="getSlot" name="getSlot">getSlot</h4> + +<p>Metoda. Odzyskuje wartość elementu tablicy obiektu w JavaScript. Równoważna do "<code>this{{ mediawiki.external('index') }}</code>" w JavaScript.</p> + +<h5 id="Deklaracja_5" name="Deklaracja_5">Deklaracja</h5> + +<pre>public Object getSlot(int index) +</pre> + +<h4 id="getWindow" name="getWindow">getWindow</h4> + +<p>Metoda statyczna. Zwraca <code>JSObject</code> dla okna stanowiącego dany aplet. Ta metoda jest użyteczna tylko po stronie klienta (client-side) w JavaScripcie.</p> + +<h5 id="Deklaracja_6" name="Deklaracja_6">Deklaracja</h5> + +<pre>public static JSObject getWindow(Applet applet) +</pre> + +<h4 id="removeMember" name="removeMember">removeMember</h4> + +<p>Metoda. Usuwa własność obiektu w JavaScript.</p> + +<h5 id="Deklaracja_7" name="Deklaracja_7">Deklaracja</h5> + +<pre>public void removeMember(String name) +</pre> + +<h4 id="setMember" name="setMember">setMember</h4> + +<p>Metoda. Ustala wartość własności obiektu JavaScript. Równoważna do "<code>this.name = value</code>" w JavaScript.</p> + +<h5 id="Deklaracja_8" name="Deklaracja_8">Deklaracja</h5> + +<pre>public void setMember(String name, + Object value) +</pre> + +<h4 id="setSlot" name="setSlot">setSlot</h4> + +<p>Metoda. Ustala wartość elementu tablicy obiektu JavaScript. Równoważna "<code>this{{ mediawiki.external('index') }} = value</code>" w JavaScript.</p> + +<h5 id="Deklaracja_9" name="Deklaracja_9">Deklaracja</h5> + +<pre>public void setSlot(int index, + Object value) +</pre> + +<h4 id="toString" name="toString">toString</h4> + +<p>Metoda. Konwertuje <code>JSObject</code> na <code>String</code>.</p> + +<p>Przesłania: <code>toString</code> w klasie <code>java.lang.Object</code></p> + +<h5 id="Deklaracja_10" name="Deklaracja_10">Deklaracja</h5> + +<pre>public String toString() +</pre> diff --git a/files/pl/web/javascript/referencje/o_tym_dokumencie/index.html b/files/pl/web/javascript/referencje/o_tym_dokumencie/index.html new file mode 100644 index 0000000000..a16cf69e3d --- /dev/null +++ b/files/pl/web/javascript/referencje/o_tym_dokumencie/index.html @@ -0,0 +1,58 @@ +--- +title: O dokumentacji referencyjnej +slug: Web/JavaScript/Referencje/O_tym_dokumencie +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - Informator + - JavaScript + - Referencje + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/About +--- +<p>{{JsSidebar}}</p> + +<p>Dokumentacja referencyjna JavaScript służy jako repozytorium faktów w zakresie języka JavaScript. Tutaj opisany jest szczegółowo cały język. Podczas pisania kodu JavaScript, będziesz często zaglądać na te strony, stąd nazwa tej części dokumentacji (dokumentacja referencyjna). Jeśli uczysz się dopiero JavaScript lub potrzebujesz wyjaśnień na temat jakichś możliwości lub funkcjonalności, sprawdz nasz <a href="/pl/docs/Web/JavaScript/Guide">podręcznik JavaScript</a>.</p> + +<p>Język JavaScript jest przeznaczony do użycia w szerokim środowisku, zarówno w przeglądarce internetowej, aplikacjach na urządzenia mobilne jak i skryptach działających po stronie serwera. Przeważająca część informacji, zawarta w naszym dokumentacji referencyjnej, ma charakters agnostyczny i nie dotyczy środowiska przeglądarki.</p> + +<h2 id="Gdzie_znaleźć_informacje_o_JavaScript">Gdzie znaleźć informacje o JavaScript</h2> + +<p>Nasza dokumentacja rdzennych funkcjonalności JavaScript (w przeważającej części czysty <a href="/pl/docs/Web/JavaScript/Zasoby_języka_JavaScript">ECMAScript</a>) obejmuje</p> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Guide">Podręcznik JavaScript</a></li> + <li><a href="/pl/docs/Web/JavaScript/Referencje">Dokumentację referencyjną JavaScript</a></li> +</ul> + +<p>Jeśli jesteś początkującym w JavaScript, rozpocznij od lektury <a href="/pl/docs/Web/JavaScript/Guide">podręcznika</a>. Gdy już będziesz zrozumiesz podstawy, możesz zająć się <a href="/pl/docs/Web/JavaScript/Referencje">referencjami</a>, aby uzyskać wiedzę na temat poszczególnych obiektów i konstrukcji językowych.</p> + +<h2 id="Struktura_dokumentacji_referencyjnej">Struktura dokumentacji referencyjnej</h2> + +<p>W dokumentacji referencyjnej znajdują się następujące rozdziały:</p> + +<dl> + <dt><a href="/pl/docs/Web/JavaScript/Referencje/Obiekty">Obiekty</a></dt> + <dd>W tym rozdziale opisano wszystkie standardowe obiekty wbudowane JavaScript, w tym ich metody i właściwości.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Referencje/Polecenia">Polecenia i deklaracje</a></dt> + <dd>JavaScript applications consist of statements with an appropriate syntax. A single statement may span multiple lines. Multiple statements may occur on a single line if each statement is separated by a semicolon. This isn't a keyword, but a group of keywords.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Referencje/Operatory">Operatory i wyrażenia</a></dt> + <dd>This chapter documents all the JavaScript language operators, expressions and keywords.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Reference/Functions">Funkcje</a></dt> + <dd>Chapter about JavaScript functions.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Reference/Classes">Klasy</a></dt> + <dd>Chapter about JavaScript classes introduced in ECMAScript 2015.</dd> + <dt><a href="/pl/docs/Web/JavaScript/Reference/Errors">Błędy</a></dt> + <dd>Chapter about specific errors, exceptions and warnings thrown by JavaScript.</dd> + <dt><a href="/pl/docs/Web/JavaScript/New_in_JavaScript">Nowości w JavaScript</a></dt> + <dd>Chapter about JavaScript version history.</dd> +</dl> + +<h3 id="Więcej_odnośnych_stron">Więcej odnośnych stron</h3> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Referencje/Przestarzałe_własności_i_metody">Przestarzałe własności i metody</a></li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">Gramatyka leksykalna</a></li> + <li><a href="/pl/docs/Web/JavaScript/typy_oraz_struktury_danych">Typy oraz struktury danych w JavaScript</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/o_tym_dokumencie/konwencje_formatowania_tekstu/index.html b/files/pl/web/javascript/referencje/o_tym_dokumencie/konwencje_formatowania_tekstu/index.html new file mode 100644 index 0000000000..3dbff8627a --- /dev/null +++ b/files/pl/web/javascript/referencje/o_tym_dokumencie/konwencje_formatowania_tekstu/index.html @@ -0,0 +1,31 @@ +--- +title: Konwencje formatowania tekstu +slug: Web/JavaScript/Referencje/O_tym_dokumencie/Konwencje_formatowania_tekstu +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +--- +<p> </p> +<p>Aplikacje w języku JavaScript działają na różnych systemach operacyjnych; informacje zawarte w tym dokumencie dotyczą wszystkich wersji. Nazwy plików i katalogów podawane są w stylu Windows (tzn. do rozdzielania katalogów stosowane są wsteczne ukośniki). Dla wersji Unix ścieżki są takie same, należy tylko zamienić ukośniki wsteczne na ukośniki zwykłe.</p> +<p>W dokumencie tym uniwersalne lokalizatory zasobów (adresy URL) podawane są w postaci:</p> +<p><code><span class="nowiki">http://</span><em>serwer</em>.<em>domena</em>/<em>ścieżka</em>/<em>plik.html</em> </code></p> +<p>W tych adresach URL:</p> +<ul> + <li><em>serwer</em> oznacza nazwę serwera, na którym uruchamiana jest Twoja aplikacja, np. <code>research1</code> albo <code>www</code></li> + <li><em>domena</em> oznacza Twoją domenę internetową, taką jak <code>mozilla.org</code> albo <code>po.opole.pl</code></li> + <li><em>ścieżka</em> oznacza strukturę katalogów na serwerze</li> + <li><em>plik.html</em> oznacza nazwę danego pliku</li> +</ul> +<p>Ogólnie rzecz biorąc, elementy pochylone w adresach URL są placeholderami, a elementy w normalnej czcionce o stałej szerokości - literałami.</p> +<p>W dokumencie tym stosowane są następujące konwencje dotyczące czcionek:</p> +<ul> + <li><code>czcionka o stałej szerokości</code> używana jest w listingach kodu źródłowego i przykładach, opisach elementów API i języka (np. nazwy metod i własności), nazw plików, ścieżek dostępu, nazw katalogów, znaczników HTML oraz każdego innego tekstu, który ma być wpisany z klawiatury (pochylona czcionka o stałej szerokości używana jest dla placeholderów w kodzie źródłowym).</li> +</ul> +<ul> + <li><em>czcionka pochylona</em> używana jest do tytułów książek, emfazy, nazw zmiennych i ścieżek do plików oraz wyrażeń użytych w sensie dosłownym.</li> +</ul> +<ul> + <li><strong>czcionka pogrubiona</strong> używana dla terminów słownikowych.</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/concat/index.html b/files/pl/web/javascript/referencje/obiekty/array/concat/index.html new file mode 100644 index 0000000000..014219e1d9 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/concat/index.html @@ -0,0 +1,71 @@ +--- +title: Array.prototype.concat() +slug: Web/JavaScript/Referencje/Obiekty/Array/concat +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca nową tablicę złożoną z tablicy, na której wywołano tę metodę, połączonej z innymi podanymi tablicami lub wartościami.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>var <var>new_array</var> = <var>old_array</var>.concat(wartość1[, wartość2[, ...[, wartośćN]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>wartość + <i>N</i> + </code> </dt> + <dd>Tablice lub wartości do dołączenia do tablicy, na której wywołana została metoda <code>concat</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>concat</code> nie zmienia oryginalnej tablicy, lecz zwraca jej kopię "o jednym poziomie głębokości" zawierającą te same elementy wspólne co pierwotna tablica. Elementy oryginalnej tablicy są kopiowane do nowej tablicy następująco:</p> + +<ul> + <li>referencje do obiektów (a nie faktyczne obiekty): <code>concat</code> kopiuje referencje do obiektów do nowej tablicy. Zarówno pierwotna, jak i nowa tablica odnoszą się więc do tych samych obiektów. Oznacza to, że jeżeli wskazany obiekt jest modyfikowany, zmiany są widoczne w obydwu tablicach (nowej i starej).</li> +</ul> + +<ul> + <li>Łańcuchy znaków i liczby (ale nie obiekty {{jsxref("String")}} i {{jsxref("Number")}} ): <code>concat</code> kopiuje wartości łańcuchów znaków i liczb do nowej tablicy.</li> +</ul> + +<p>Operacje wykonywane na nowej tablicy nie wpłyną w żaden sposób na oryginalną tablicę i na odwrót.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_dw.C3.B3ch_tablic" name="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_dw.C3.B3ch_tablic">Przykład: Połączenie dwóch tablic</h3> + +<p>Następujący kod łączy dwie tablice:</p> + +<pre class="brush: js">alpha = new Array("a", "b", "c"); +numeric = new Array(1, 2, 3); +alphaNumeric = alpha.concat(numeric); // tworzy tablicę ["a", "b", "c", 1, 2, 3] +</pre> + +<h3 id="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_trzech_tablic" name="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_trzech_tablic">Przykład: Połączenie trzech tablic</h3> + +<p>Następujący kod łączy trzy tablice:</p> + +<pre class="brush: js">num1 = [1, 2, 3]; +num2 = [4, 5, 6]; +num3 = [7, 8, 9]; +nums = num1.concat(num2,num3) // tworzy tablicę [1, 2, 3, 4, 5, 6, 7, 8, 9] +</pre> + +<h3 id="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_warto.C5.9Bci_z_tablic.C4.85" name="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_warto.C5.9Bci_z_tablic.C4.85">Przykład: Połączenie wartości z tablicą</h3> + +<p>Następujący kod łączy trzy wartości z tablicą:</p> + +<pre class="brush: js">alpha = ['a', 'b', 'c']; +alphaNumeric = alpha.concat(1, 2, 3); // tworzy tablicę ["a", "b", "c", 1, 2, 3] +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/array/copywithin/index.html b/files/pl/web/javascript/referencje/obiekty/array/copywithin/index.html new file mode 100644 index 0000000000..1a1917eabd --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/copywithin/index.html @@ -0,0 +1,181 @@ +--- +title: Array.prototype.copyWithin() +slug: Web/JavaScript/Referencje/Obiekty/Array/copyWithin +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Metodă + - Peototyp + - Prototype + - Reference + - Referencja + - Tablica + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>copyWithin()</strong></code> tworzy kopie płytkie części tablicy w innej części tej samej tablicy i zwraca tę tablicę bez modyfikowania jej długości.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-copywithin.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><var>arr</var>.copyWithin(<var>cel[, start[, koniec]]</var>) +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>cel</code></dt> + <dd>Indeks (liczony od zera), do którego ma zostać skopiowana sekwencja. Jeśli wartość <code>target</code> będzie ujemna, pozycja będzie liczona od końca tablicy.</dd> + <dd>Jeśli <code>cel</code> jest większy lub równy <code>arr.length</code>, nic nie zostanie skopiowane. Jeśli wartość <code>cel</code> będzie większa niż <code>start</code>, kopiowana sekwencja zostanie przycięta tak, aby pasować do <code>arr.length</code>.</dd> + <dt><code>start</code> {{optional_inline}}</dt> + <dd>Indeks (liczony od zera), określający pozycję początkową sekwencji, która ma zostać skopiowana. Jeśli wartość ta będzie ujemna, <code>start</code> będzie liczony od końca tablicy.</dd> + <dd>Jeśli wartość <code>start</code> nie jest podana, <code>copyWithin</code> skopiuje sekwencję zaczynając od indeksu <code>0</code>. </dd> + <dt><code>koniec</code> {{optional_inline}}</dt> + <dd>Indeks (liczony od zera), określający pozycję końcową sekwencji, która ma zostać skopiowana, z wyłączeniem wartości pod indeksem <code>koniec</code>. Jeśli wartość ta będzie ujemna, <code>koniec</code> będzie liczony od końca tablicy.</dd> + <dd>Jeśli wartość <code>koniec</code> nie jest podana, <code>copyWithin</code> skopiuje sekwencję do ostatniego indeksu (domyślnie do <code>arr.length</code>).</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Zmodyfikowana tablica.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda <code>copyWithin</code> działa jak <code>memmove</code> w C/C++ i jest wysokowydajną metodą przesuwania wartości w obiektach {{jsxref("Array")}}. Dotyczy to szczególnie metody o tej samej nazwie {{jsxref("TypedArray/copyWithin", "TypedArray")}}. Sekwencja jest kopiowana i wklejana w jednej operacji, a wklejona sekwencja będzie zawierać skopiowane wartości nawet wtedy, gdy zakres żródłowy (kopiowania) i docelowy (wklejania) nakładają się na siebie.</p> + +<p>Funkcja <code>copyWithin</code> jest celowo <em>ogólna</em>, nie wymaga, by jej wartość <code>this</code> była obiektem typu {{jsxref("Array")}}.</p> + +<p>Metoda <code>copyWithin</code> jest modyfikowalna. Nie zmienia długości <code>this</code>, ale zmienia zawartość <code>this</code> i tworzy nowe własności, jeśli jest to konieczne.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js notranslate">if (!Array.prototype.copyWithin) { + Object.defineProperty(Array.prototype, 'copyWithin', { + value: function(target, start/*, end*/) { + // Kroki 1-2. + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + var O = Object(this); + + // Kroki 3-5. + var len = O.length >>> 0; + + // Kroki 6-8. + var relativeTarget = target >> 0; + + var to = relativeTarget < 0 ? + Math.max(len + relativeTarget, 0) : + Math.min(relativeTarget, len); + + // Kroki 9-11. + var relativeStart = start >> 0; + + var from = relativeStart < 0 ? + Math.max(len + relativeStart, 0) : + Math.min(relativeStart, len); + + // Kroki 12-14. + var end = arguments[2]; + var relativeEnd = end === undefined ? len : end >> 0; + + var final = relativeEnd < 0 ? + Math.max(len + relativeEnd, 0) : + Math.min(relativeEnd, len); + + // Krok 15. + var count = Math.min(final - from, len - to); + + // Kroki 16-17. + var direction = 1; + + if (from < to && to < (from + count)) { + direction = -1; + from += count - 1; + to += count - 1; + } + + // Krok 18. + while (count > 0) { + if (from in O) { + O[to] = O[from]; + } else { + delete O[to]; + } + + from += direction; + to += direction; + count--; + } + + // Krok 19. + return O; + }, + configurable: true, + writable: true + }); +}</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_copyWithin">Użycie copyWithin</h3> + +<pre class="brush: js notranslate">[1, 2, 3, 4, 5].copyWithin(-2) +// [1, 2, 3, 1, 2] + +[1, 2, 3, 4, 5].copyWithin(0, 3) +// [4, 5, 3, 4, 5] + +[1, 2, 3, 4, 5].copyWithin(0, 3, 4) +// [4, 2, 3, 4, 5] + +[1, 2, 3, 4, 5].copyWithin(-2, -3, -1) +// [1, 2, 3, 3, 4] + +[].copyWithin.call({długość: 5, 3: 1}, 0, 3) +// {0: 1, 3: 1, długość: 5} + +// ES2015 Typowane tablice są podklasami zwykłej tablicy (Array) +var i32a = new Int32Array([1, 2, 3, 4, 5]) + +i32a.copyWithin(0, 2) +// Int32Array [3, 4, 5, 4, 5] + +// Na platformach niewspierających jeszcze ES 2015: +[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4); +// Int32Array [4, 2, 3, 4, 5] +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.copyWithin")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Array")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/entries/index.html b/files/pl/web/javascript/referencje/obiekty/array/entries/index.html new file mode 100644 index 0000000000..6ff83958f4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/entries/index.html @@ -0,0 +1,77 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Referencje/Obiekty/Array/entries +translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>entries()</strong></code> zwraca obiekt <code><strong>Iteratora</strong></code> który zawiera parę klucz/wartość dla każdej pozycji w tablicy.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-entries.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>a</var>.entries()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator {{jsxref("Tablicy")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_w_pętli_for…of">Użycie w pętli <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for…of</a></h3> + +<pre class="brush:js">var a = ['a', 'b', 'c']; +var iterator = a.entries(); + +for (let e of iterator) { + console.log(e); +} +// [0, 'a'] +// [1, 'b'] +// [2, 'c'] +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_w_przeglądarkach">Kompatybilność w przeglądarkach</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.entries")}}</p> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.values()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/every/index.html b/files/pl/web/javascript/referencje/obiekty/array/every/index.html new file mode 100644 index 0000000000..4b6cb612a2 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/every/index.html @@ -0,0 +1,89 @@ +--- +title: Array.prototype.every() +slug: Web/JavaScript/Referencje/Obiekty/Array/every +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/every +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Metoda <span style="line-height: 23.3333339691162px;"> </span><code style="font-style: normal; line-height: 23.3333339691162px;"><strong>every() </strong></code>sprawdza, czy wszystkie elementy w tablicy przechodzą test zrealizowany w postaci dostarczonej funkcji.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.every(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja sprawdzająca dla każdego elementu. Zawiera trzy argumenty.<br> + <strong style="font-family: consolas,monaco,andale mono,monospace; font-weight: bold; line-height: 23.3333339691162px;">currentValue<br> + </strong>Bieżący element przetwarzany w tablicy</dd> + <dt> <strong style="font-family: consolas,monaco,andale mono,monospace; font-weight: bold; line-height: 23.3333339691162px;">index</strong></dt> + <dd> + <p> Indeks bieżacego elementu przetwarzanego w tablicy</p> + + <p> <strong>array</strong><br> + Tablica na której została wywołana funkcja</p> + </dd> + <dt><code>thisObject</code></dt> + <dd>Opcjonalnie. Obiekt, na który będzie wskazywał <code>this</code>, gdy wykonana zostanie funkcja zwrotna <code>callback</code>. </dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>every</code> wykonuje dostarczoną funkcję <code>callback</code> raz dla każdego elementu tablicy do momentu, kiedy znajdzie taki element, dla którego funkcja <code>callback</code> zwróci wartość <code>false</code>. Jeżeli taki element zostanie znaleziony, test zostanie przerwany, a metoda <code>every</code> zwróci wartość <code>false</code>. W przeciwnym wypadku (<code>callback</code> zwraca wartość <code>true</code> dla wszystkich elementów) <code>every</code> zwróci <code>true</code>. Funkcja <code>callback</code> wywoływana jest jedynie dla indeksów tablicy, którym została przypisana wartość; nie jest wywoływana dla indeksów, które zostały usunięte i tych, którym nigdy nie została przypisana żadna wartość.</p> + +<p>Funkcja <code>callback</code> jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.</p> + +<p>Jeśli parametr <code>thisObject</code> został dostarczony do metody <code>every</code>, będzie on wskazywany przez <code>this</code> dla każdego wywołania funkcji <code>callback</code>. W przypadku, gdy nie został on przekazany lub jego wartość jest równa <code>null</code>, <code>this</code> będzie się odnosić do obiektu globalnego połączonego z funkcją <code>callback</code>.</p> + +<p>Metoda <code>every</code> nie modyfikuje tablicy, na której jest wywoływana.</p> + +<p>Zakres elementów przetwarzanych przez <code>every</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy dołączone do tablicy po momencie wywołania <code>every</code> są testowane przez <code>callback</code>. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji <code>callback</code> odpowiada wartości w momencie, w którym <code>every</code> się o nie zwróci; metoda <code>every</code> nie upomina się o elementy usunięte.</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>every</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>every</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.every) +{ + Array.prototype.every = function(fun /*, thisp*/) + { + var len = this.length; + if (typeof fun != "function") + throw new TypeError(); + + var thisp = arguments[1]; + for (var i = 0; i < len; i++) + { + if (i in this && + !fun.call(thisp, this[i], i, this)) + return false; + } + + return true; + }; +} +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy">Przykład: Sprawdzanie rozmiaru wszystkich elementów tablicy</h3> + +<p>Następujący przykład sprawdza, czy wszystkie elementy w tablicy są większe niż 10.</p> + +<pre class="brush: js">function isBigEnough(element, index, array) { + return (element >= 10); +} +passed = [12, 5, 8, 130, 44].every(isBigEnough); +// fałsz +passed = [12, 54, 18, 130, 44].every(isBigEnough); +// prawda +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/array/fill/index.html b/files/pl/web/javascript/referencje/obiekty/array/fill/index.html new file mode 100644 index 0000000000..1ab2ef4719 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/fill/index.html @@ -0,0 +1,185 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Referencje/Obiekty/Array/fill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>fill() </strong>uzupełnia wszystkie elementy tablicy, zaczynając od indeksu początkowego</code> <strong>(start)</strong> aż po indeks końcowy <strong>(end)</strong> statyczną wartością <strong>(value)</strong>.</p> + +<p>{{EmbedInteractiveExample("pages/js/array-fill.html")}}<br> + Źródło tego przykładu jest przechowywane w repozytorium na GitHub. Jeśli chciałbyś dodać coś od siebie do projektu interaktywnych przykładów, sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij pull request.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.fill(<var>value</var>[, <var>start<var> = 0[, <var>end</var> = this.length]])</var></var></code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Wartość, którą wypełniana będzie tablica.</dd> + <dt><code>start</code></dt> + <dd>Opcjonalnie. Indeks początkowy.</dd> + <dt><code>end</code></dt> + <dd>Opcjonalnie. Indeks końcowy.</dd> + <dt> + <h3 id="Wartość_zwracana">Wartość zwracana</h3> + + <p>Zmodyfikowana tablica.</p> + </dt> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Przedział elementów do wypełnienia to: [<code>start</code>, <code>end</code>).</p> + +<p><code>Metoda</code><strong><code> fill</code></strong> przyjmuje do trzech parametrów <code>value</code>, <code>start</code> i <code>end</code>. Argumenty <code>start i</code> <code>end</code> są opcjonalne i przyjmują, odpowiednio, <code>0</code> i długość (<code>length)</code> obiektu <code>this</code>.</p> + +<p>Jeżeli parametr <code>start</code> jest ujemny, jest to traktowane jako <code>length+start</code> gdzie <code>length</code> jest liczbą elementów tablicy. Jeżeli parametr <code>end</code> jest negatywny, jest to traktowane jako <code>length+end</code>. </p> + +<p>Funkcja<strong> fill</strong> została świdomie zaprojektowana jako generyczna, przez co nie wymaga, by wartość <font face="Consolas, Liberation Mono, Courier, monospace">this</font> była obiektem typu Array.</p> + +<p>Metoda<strong> fill </strong>jest zmienna (ang. mutalbe), metoda ta nie zwraca kopii this, a oryginalny obiekt po modyfikacjach.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">[1, 2, 3].fill(4); // [4, 4, 4] +[1, 2, 3].fill(4, 1); // [1, 4, 4] +[1, 2, 3].fill(4, 1, 2); // [1, 4, 3] +[1, 2, 3].fill(4, 1, 1); // [1, 2, 3] +[1, 2, 3].fill(4, -3, -2); // [4, 2, 3] +[1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3] +[].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3} +//Obiekty przez referencję +var arr = Array(3).fill({}) // [{}, {}, {}]; +arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }] +</pre> + +<p> </p> + +<p> </p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.fill) { + Array.prototype.fill = function(value) { + + // Steps 1-2. + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + var O = Object(this); + + // Steps 3-5. + var len = O.length >>> 0; + + // Steps 6-7. + var start = arguments[1]; + var relativeStart = start >> 0; + + // Step 8. + var k = relativeStart < 0 ? + Math.max(len + relativeStart, 0) : + Math.min(relativeStart, len); + + // Steps 9-10. + var end = arguments[2]; + var relativeEnd = end === undefined ? + len : end >> 0; + + // Step 11. + var final = relativeEnd < 0 ? + Math.max(len + relativeEnd, 0) : + Math.min(relativeEnd, len); + + // Step 12. + while (k < final) { + O[k] = value; + k++; + } + + // Step 13. + return O; + }; +} +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.fill', 'Array.prototype.fill')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definicja początkowa</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funckjonalność</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Wsparcie podstawowe</td> + <td>{{CompatChrome("36")}} [1]</td> + <td>{{CompatGeckoDesktop("31")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("7.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Wsparcie podstawowe</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("31")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] The feature is available behind a preference. In chrome://flags, activate the entry “Enable Experimental JavaScript”.</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("TypedArray.prototype.fill()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/filter/index.html b/files/pl/web/javascript/referencje/obiekty/array/filter/index.html new file mode 100644 index 0000000000..4b18a34c9c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/filter/index.html @@ -0,0 +1,150 @@ +--- +title: Array.prototype.filter() +slug: Web/JavaScript/Referencje/Obiekty/Array/filter +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong>filter()</strong> tworzy nową tablicę z wszystkimi elementami, które przechodzą test określony w postaci funkcji.</p> + +<pre class="brush: js">function isBigEnough(value) { + return value >= 10; +} + +var filtered = [12, 5, 8, 130, 44].filter(isBigEnough); +// filtered is [12, 130, 44] +</pre> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre><var>var newArray = arr</var>.filter(<var>callback(element[, index[, array]])</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja sprawdzająca każdy element tablicy. Funkcja powinna zwrócić <code>true,</code> aby zatrzymać element lub <code>false,</code> aby odrzucić element. Funkcja przyjmuje trzy argumenty:</dd> + <dd> + <dl> + <dt><code>element</code></dt> + <dd>Element tablicy do przetworzenia.</dd> + <dt><code>index</code></dt> + <dd>Numer indeksu procesowanego elementu tablicy.</dd> + <dt><code>array</code></dt> + <dd>Tablica na której <code>filter</code> został wywołany.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Obiekt na który będzie wskazywał <code>this</code>, przy wywoływaniu funkcji <code>callback</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>filter</code> wykonuje dostarczoną funkcję <code>callback</code> dla każdego elementu tablicy, tworząc nową tablicę z wszystkich tych elementów, dla których funkcja <code>callback</code> zwróciła wartość <code>true</code>. Wynikowa tablica jest zwarta; wartości, które nie przechodzą testu funkcji <code>callback,</code> są zwyczajnie pomijane i nie są przypisywane do indeksów nowej tablicy.</p> + +<p>Funkcja <code>callback</code> jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.</p> + +<p>Jeśli parametr <code>thisObject</code> został dostarczony do metody <code>filter</code>, będzie on wskazywany przez <code>this</code> dla każdego wywołania funkcji<code>callback</code>. W przypadku gdy nie został on przekazany lub jego wartość jest równa <code>null</code>, <code>this</code> będzie się odnosić do obiektu globalnego połączonego z funkcją <code>callback</code>.</p> + +<p>Metoda <code>filter</code> nie modyfikuje tablicy, na której jest wywoływana.</p> + +<p>Zakres elementów przetwarzanych przez <code>filter</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy dołączone do tablicy po momencie wywołania <code>filter</code> są testowane przez <code>callback</code>. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji <code>callback</code> odpowiada wartości w momencie, w którym <code>filter</code> się o nie zwróci; metoda <code>filter</code> nie upomina się o elementy usunięte.</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>filter</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>filter</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.filter) +{ + Array.prototype.filter = function(fun /*, thisp*/) + { + var len = this.length; + if (typeof fun != "function") + throw new TypeError(); + + var res = new Array(); + var thisp = arguments[1]; + for (var i = 0; i < len; i++) + { + if (i in this) + { + var val = this[i]; // in case fun mutates this + if (fun.call(thisp, val, i, this)) + res.push(val); + } + } + + return res; + }; +} +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Odfiltrowanie_wszystkich_ma.C5.82ych_warto.C5.9Bci" name="Przyk.C5.82ad:_Odfiltrowanie_wszystkich_ma.C5.82ych_warto.C5.9Bci">Przykład: Odfiltrowanie wszystkich małych wartości</h3> + +<p>Poniższy przykład używa <code>filter</code> by utworzyć przefiltrowaną tablicę, z której usunięto wszystkie elementy których wartość wynosi mniej niż 10.</p> + +<pre class="brush: js">function isBigEnough(element, index, array) { + return (element >= 10); +} +filtered = [12, 5, 8, 130, 44].filter(isBigEnough); +</pre> + +<h2 id="Kompatybilność_z_przeglądarkami" style="margin-bottom: 20px; font-size: 2.14285714285714rem;">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table" style="border-color: transparent;"> + <tbody> + <tr> + <th style="line-height: 16px;">Feature</th> + <th style="line-height: 16px;">Chrome</th> + <th style="line-height: 16px;">Firefox (Gecko)</th> + <th style="line-height: 16px;">Internet Explorer</th> + <th style="line-height: 16px;">Opera</th> + <th style="line-height: 16px;">Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table" style="border-color: transparent;"> + <tbody> + <tr> + <th style="line-height: 16px;">Feature</th> + <th style="line-height: 16px;">Android</th> + <th style="line-height: 16px;">Chrome for Android</th> + <th style="line-height: 16px;">Firefox Mobile (Gecko)</th> + <th style="line-height: 16px;">IE Mobile</th> + <th style="line-height: 16px;">Opera Mobile</th> + <th style="line-height: 16px;">Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.8")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/pl/web/javascript/referencje/obiekty/array/find/index.html b/files/pl/web/javascript/referencje/obiekty/array/find/index.html new file mode 100644 index 0000000000..6e8d67373b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/find/index.html @@ -0,0 +1,278 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Referencje/Obiekty/Array/find +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Metodă + - Prototype + - Referencja + - Tablica + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/find +--- +<p>{{JSRef}}<br> + Metoda <strong>find()</strong> zwraca pierwszy element tablicy, który spełnia warunek podanej funkcji testującej.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-find.html","shorter")}}</div> + + + +<ul> + <li>Jeśli potrzebujesz <strong>indeksu</strong> znalezionego elementu w tablicy, użyj {{jsxref("Array.findIndex", "findIndex()")}}.</li> + <li>Jesli potrzebujesz <strong>indeksu wartości</strong>, użyj {{jsxref("Array.prototype.indexOf()")}}. (Jest to podobne do {{jsxref("Array.findIndex", "findIndex()")}}, ale sprawdza każdy element tablicy pod kątem równości z zadaną wartością, zamiast używać funkcji testującej.)</li> + <li>Jeśli chcesz sprawdzić, czy wartość <strong>istnieje</strong> w tablicy, użyj {{jsxref("Array.prototype.includes()")}}. Tutaj także sprawdzana jest równość elementu z zadaną wartością zamiast używania funkcji testującej.</li> + <li>Jeśli chcesz znaleźć dowolny element, który spełnia warunek funkcji testującej, użyj {{jsxref("Array.prototype.some()")}}.</li> +</ul> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.find(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><em><code>callback</code></em></dt> + <dd>Funkcja do wykonania przy każdym elemencie tablicy, przyjmująca trzy wartości: + <dl> + <dt><em><code>element</code></em></dt> + <dd>Element obecnie przetwarzany przez funkcję.</dd> + <dt><em><code>index</code></em></dt> + <dd>Indeks obecnie przetwarzanego elementu.</dd> + <dt><em><code>array</code></em></dt> + <dd>Tablica, na której wywołano funkcję <code>find</code>.</dd> + </dl> + </dd> + <dt><em><code>thisArg</code></em></dt> + <dd>Opcjonalny. Obiekt, który będzie się znajdował pod <code>this</code> w czasie wykonywania funkcji <code>callback</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p><strong>Wartość pierwszego elementu</strong> w tablicy, spełniającego warunek funkcji testującej.<br> + W przeciwnym wypadku: {{jsxref("undefined")}}.</p> + +<h2 id="Description" name="Description">Opis</h2> + +<p>Metoda <code>find</code> wywołuje funkcję <code><var>callback</var></code> raz dla każdego indeksu tablicy, dopóki nie znajdzie takiego elementu, dla którego <em><code>callback</code></em> zwraca wartość <code>true</code>. Wówczas <code>find</code> natychmiast zwraca wartość tego elementu. W przeciwnym razie, gdy żaden z elementów nie spełni warunków funkcji testującej, <code>find</code> zwraca {{jsxref("undefined")}}.</p> + +<p><code><var>callback</var></code> jest wywoływany dla każdego indeksu tablicy, nie tylko tych z przypisanymi wartościami. Oznacza to, że może to być mniej efektywne w przypadku tablic rzadkich, w porównaniu z metodami, które odwiedzają jedynie indeksy z przypisanymi wartościami.</p> + +<p>Jeśli parametr <code><var>thisArg</var></code>jest przekazany do <code>find</code>, będzie użyty jako wartość <code>this</code> w każdym wywołaniu <code><var>callback</var></code>. Jeśli parametr ten nie jest przekazany, używana jest wartość {{jsxref("undefined")}}.</p> + +<p>Metoda <code>find</code> nie modyfikuje tablicy, na której jest wywoływana, ale może to robić funkcja przekazana do <code><var>callback</var></code>. Jeśli tak się stanie, elementy przetwarzane przez <code>find</code> są ustawiane <em>przed</em> pierwszym wywołaniem funkcji <code><em>callback</em></code>. Zatem:</p> + +<ul> + <li><code><var>callback</var></code> nie odwiedzi żadnych elementów dodanych do tablicy po rozpoczęciu wywowłania <code>find</code>.</li> + <li>Jeśli istniejący, jeszcze nieodwiedzony element tablicy jest zmieniony przez <code><em>callback</em></code>, jego wartość przekazana do <code><em>callback</em></code> będzie wartością w momencie, w którym <code>find</code> odwiedza indeks tego elementu.</li> + <li>Elementy {{jsxref("delete", "usunięte")}} dalej są odwiedzane.</li> +</ul> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Metoda ta została dodana do specyfikacji ECMAScript 2015 i może nie być jeszcze dostępna we wszystkich implementacjach języka JavaScript. Niemniej jednak, możesz użyć <em>polyfill</em> z <code>Array.prototype.find</code> z poniższym fragmentem kodu:</p> + +<pre class="brush: js notranslate">// https://tc39.github.io/ecma262/#sec-array.prototype.find +if (!Array.prototype.find) { + Object.defineProperty(Array.prototype, 'find', { + value: function(predicate) { + // 1. Let O be ? ToObject(this value). + if (this == null) { + throw TypeError('"this" is null or not defined'); + } + + var o = Object(this); + + // 2. Let len be ? ToLength(? Get(O, "length")). + var len = o.length >>> 0; + + // 3. If IsCallable(predicate) is false, throw a TypeError exception. + if (typeof predicate !== 'function') { + throw TypeError('predicate must be a function'); + } + + // 4. If thisArg was supplied, let T be thisArg; else let T be undefined. + var thisArg = arguments[1]; + + // 5. Let k be 0. + var k = 0; + + // 6. Repeat, while k < len + while (k < len) { + // a. Let Pk be ! ToString(k). + // b. Let kValue be ? Get(O, Pk). + // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)). + // d. If testResult is true, return kValue. + var kValue = o[k]; + if (predicate.call(thisArg, kValue, k, o)) { + return kValue; + } + // e. Increase k by 1. + k++; + } + + // 7. Return undefined. + return undefined; + }, + configurable: true, + writable: true + }); +} +</pre> + +<p>Jeśli potrzebujesz wspierać naprawdę przestarzałe silniki JavaScript, które nie wspierająt <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code>, najlepiej w ogóle nie używać <em>polyfill</em> z <code>Array.prototype</code>, gdyż nie da się go uczynić niewyliczeniowym.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Wyszukiwanie_obiektu_w_tablicy_na_podstawie_jednej_z_jego_własności">Wyszukiwanie obiektu w tablicy na podstawie jednej z jego własności</h3> + +<pre class="brush: js notranslate">const inventory = [ + {name: 'apples', quantity: 2}, + {name: 'bananas', quantity: 0}, + {name: 'cherries', quantity: 5} +]; + +function isCherries(fruit) { + return fruit.name === 'cherries'; +} + +console.log(inventory.find(isCherries)); +// { name: 'cherries', quantity: 5 }</pre> + +<h4 id="Użycie_funkcji_strzałkowej_i_destrukturyzacja">Użycie funkcji strzałkowej i destrukturyzacja</h4> + +<pre class="brush: js notranslate">const inventory = [ + {name: 'apples', quantity: 2}, + {name: 'bananas', quantity: 0}, + {name: 'cherries', quantity: 5} +]; + +const result = inventory.find( ({ name }) => name === 'cherries' ); + +console.log(result) // { name: 'cherries', quantity: 5 }</pre> + +<h3 id="Wyszukiwanie_liczby_pierwszej_w_tablicy">Wyszukiwanie liczby pierwszej w tablicy</h3> + +<p>Poniższy przykładowy kod znajduje element tablicy będący liczbą pierwszą (lub zwraca {{jsxref("undefined")}} jeśli w tablicy nie ma liczby pierwszej):</p> + +<pre class="brush: js notranslate">function czyPierwsza(element, indeks, tablica) { + let start = 2; + while (start <= Math.sqrt(element)) { + if (element % start++ < 1) { + return false; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].find(czyPierwsza)); // undefined, nie znaleziono +console.log([4, 5, 8, 12].find(czyPierwsza)); // 5 +</pre> + +<p>Poniższy przykład pokazuje, że nieistniejące i usunięte elementy <em>są</em> odwiedzane, oraz że wartość przekazana do <code><em>callback</em></code> jest ich wartością, kiedy są odwiedzane:</p> + +<pre class="brush: js notranslate">// Zadeklaruj tablicę bez elementów przy indeksach 2, 3 i 4 +const array = [0,1,,,,5,6]; + +// Pokazuje wszystkie indeksy, nie tylko te z przypisanymi wartościami +array.find(function(value, index) { + console.log('Odwiedzono indeks ', index, ' z wartością ', value); +}); + +// Pokazuje wszystkie indeksy, włączając usunięte +array.find(function(value, index) { + // Usuń element 5 w pierwszej iteracji + if (index === 0) { + console.log('Usuwanie array[5] z wartością ', array[5]); + delete array[5]; + } + // Element 5 jest wciąż odwiedzany, choć został usunięty + console.log('Odwiedzono indeks ', index, ' z wartością ', value); +}); +// Oczekiwane wyjście: +// Usuwanie array[5] z wartością 5 +// Odwiedzono indeks 0 z wartością 0 +// Odwiedzono indeks 1 z wartością 1 +// Odwiedzono indeks 2 z wartością undefined +// Odwiedzono indeks 3 z wartością undefined +// Odwiedzono indeks 4 z wartością undefined +// Odwiedzono indeks 5 z wartością undefined +// Odwiedzono indeks 6 z wartością 6 +</pre> + +<h2 id="Specifications" name="Specifications">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.find', 'Array.prototype.find')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Pierwotna definicja.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Wsparcie przeglądarek</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("45.0")}}</td> + <td>{{CompatGeckoDesktop("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("7.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>iOS 8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Zobacz też</h2> + +<ul> + <li>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/findindex/index.html b/files/pl/web/javascript/referencje/obiekty/array/findindex/index.html new file mode 100644 index 0000000000..86a9cf67cf --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/findindex/index.html @@ -0,0 +1,214 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Referencje/Obiekty/Array/findIndex +translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>findIndex()</strong></code> zwraca <strong>indeks</strong> pierwszego elementu tablicy, który spełnia kryteria postawione w funkcji testującej. W przeciwnym wypadku zwraca -1.</p> + +<pre class="brush: js">function isBigEnough(element) { + return element >= 15; +} + +[12, 5, 8, 130, 44].findIndex(isBigEnough); +// zostanie zwrócony indeks czwartego elementu tablicy, +// który wynosi 3</pre> + +<p>Zobacz także metodę {{jsxref("Array.find", "find()")}}, która zwraca <strong>wartość</strong> znalezionego elementu, zamiast jego indeksu.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>arr</var>.findIndex(<var>callback</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja wywoływana dla każdej wartości w tablicy, bierze trzy argumenty:</dd> + <dd> + <dl> + <dt><code>element</code></dt> + <dd>Obecnie przetwarzany element z tablicy.</dd> + <dt><code>index</code></dt> + <dd>Indeks obecnie przetwarzanego elementu z tablicy.</dd> + <dt><code>array</code></dt> + <dd>Tablica, na której została wywołana funkcja <code>findIndex</code>.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcjonalny. Obiekt do użycia jako <code>this </code>w czasie wykonywania <code>callback.</code></dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Indeks elementu tablicy, który pomyślnie przeszedł test, jeśli taki nie zostanie znaleziony, zwraca <strong>-1</strong>.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda <code>findIndex</code> wykonuje funkcję <code>callback</code> dla każdego indeksu tablicy 0..długość - 1 (włącznie) w tablicy dopóki nie znajdzie tego, na którym funkcja <code>callback</code> zwróci prawdę. Jeśli taki element zostanie znaleziony, <code>findIndex</code> natychmiast zwraca indeks dla tej iteracji. Jeśli callback nigdy nie zwróci prawdy lub wielkość tablicy wynosi 0, <code>findIndex</code> zwróci -1. W przeciwieństwie do innych metod tablicowych takich jak Array#some, w tablicach rzadkich <code>callback </code><strong>jest</strong> wywoływany nawet dla indeksów niewystępujących w tablicy.</p> + +<p><code>callback </code>jest wywoływany z trzema argumentami: wartością elementu, indeksem elementu i przetwarzaną tablicą.</p> + +<p>Jeśli <code>thisArg</code> jest dołączony do <code>findIndex</code>, zostanie użyty jako <code>this</code> dla każdego wywołania . Jeśli nie, zostanie użyte {{jsxref("undefined")}}.</p> + +<p><code>findIndex </code>nie zmienia tablicy na której jest wywoływany.</p> + +<p>Zakres elementów przetwarzanych przez <code>findIndex</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy, które są dodane po rozpoczęciu wywołania funkcji <code>findIndex </code>nie będą przetworzone przez <code>callback</code>. Jeśli istniejący, nieodwiedzony element tablicy zostanie zmieniony przez <code>callback</code>, jego wartość przekazana do odwiedzającego <code>callback</code> będzie tą wartością z momentu, w którym <code>findIndex</code> odwiedzi indeks tego elementu, elementy usunięte, nie będą odwiedzone.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Znajdź_indeks_liczby_pierwszej_w_tablicy">Znajdź indeks liczby pierwszej w tablicy</h3> + +<p>Poniższy przykład znajduje indeks elementu w tablicy, który jest liczbą pierwszą (lub zwraca -1 jeśli nie w tablicy nie ma liczby pierwszej).</p> + +<pre class="brush: js">function isPrime(element, index, array) { + var start = 2; + while (start <= Math.sqrt(element)) { + if (element % start++ < 1) { + return false; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, nie znaleziono +console.log([4, 6, 7, 12].findIndex(isPrime)); // 2 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.findIndex +if (!Array.prototype.findIndex) { + Object.defineProperty(Array.prototype, 'findIndex', { + value: function(predicate) { + // 1. Let O be ? ToObject(this value). + if (this == null) { + throw new TypeError('"this" ma wartość null lub undefined'); + } + + var o = Object(this); + + // 2. Niech len będzie ? ToLength(? Get(O, "length")). + var len = o.length >>> 0; + + // 3. Jeśli IsCallable(predicate) jest fałszem, rzuć wyjątek TypeError. + if (typeof predicate !== 'function') { + throw new TypeError('predykat musi być funkcją'); + } + + // 4. Jeśli thisArg został podany, niech T będzie thisArg; w przeciwnym wypadku, niech T będzie undefined. + var thisArg = arguments[1]; + + // 5. Let k be 0. + var k = 0; + + // 6. Powtarzaj, dopóki k < len + while (k < len) { + // a. Niech Pk będzie ! ToString(k). + // b. Niech kValue będzie ? Get(O, Pk). + // c. Niech testResult będzie ToBoolean(? Call(predicate, T, « kValue, k, O »)). + // d. Jeśli testResult jest prawdą, zwróć k. + var kValue = o[k]; + if (predicate.call(thisArg, kValue, k, o)) { + return k; + } + // e. Zwiększ wartość k o 1. + k++; + } + + // 7. Return -1. + return -1; + } + }); +} +</pre> + +<p>Jeśli musisz wspierać naprawdę przestarzałe silniki JavaScript, które nie wspierają <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code>, najlepiej nie korzystać z metod <code>Array.prototype</code> w ogóle, ponieważ nie można sprawić by były niepoliczalne.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.findindex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Podstawowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Edge</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(45.0)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>Tak</td> + <td>Tak</td> + <td>{{CompatSafari("7.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>45.0</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/flat/index.html b/files/pl/web/javascript/referencje/obiekty/array/flat/index.html new file mode 100644 index 0000000000..3c8de3a43c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/flat/index.html @@ -0,0 +1,173 @@ +--- +title: Array.prototype.flat() +slug: Web/JavaScript/Referencje/Obiekty/Array/flat +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat +--- +<div>{{JSRef}}</div> + +<div></div> + +<p>Metoda <code><strong>flat()</strong></code> tworzy nową tablicę ze wszystkich elementów, które są podtablicami, łącząc je rekursyjnie z podanym parametrem jak głęboko powinno nastąpić spłaszczenie.</p> + +<p class="hidden">\{{EmbedInteractiveExample("pages/js/array-flatten.html")}}</p> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>var newArray = arr</var>.flat(<em>[depth]</em>);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>depth</code> {{optional_inline}}</dt> + <dd>Parametr ten określa jak głęboko zagnieżdżona tablica powinna być spłaszczona. Wartość domyślna to 1.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowa tablica składająca się z połączonych elementów podtablic.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Spłaszczanie_zagnieżdżonych_tablic">Spłaszczanie zagnieżdżonych tablic</h3> + +<pre class="brush: js">var arr1 = [1, 2, [3, 4]]; +arr1.flat(); +// [1, 2, 3, 4] + +var arr2 = [1, 2, [3, 4, [5, 6]]]; +arr2.flat(); +// [1, 2, 3, 4, [5, 6]] + +var arr3 = [1, 2, [3, 4, [5, 6]]]; +arr3.flat(2); +// [1, 2, 3, 4, 5, 6] +</pre> + +<h3 id="Spłaszczanie_i_puste_miejsca_tablicy">Spłaszczanie i puste miejsca tablicy</h3> + +<p>Metoda flat() usuwa puste miejsca w tablicy:</p> + +<pre class="brush: js">var arr4 = [1, 2, , 4, 5]; +arr4.flat(); +// [1, 2, 4, 5] +</pre> + +<h2 id="Alternatywa">Alternatywa</h2> + +<h3 id="reduce_i_concat"><code>reduce</code> i <code>concat</code></h3> + +<pre class="brush: js">var arr1 = [1, 2, [3, 4]]; +arr1.flat(); + +//to flat single level array +arr1.reduce((acc, val) => acc.concat(val), []);// [1, 2, 3, 4] + +//or +const flatSingle = arr => [].concat(...arr); +</pre> + + + +<pre class="brush: js">//to enable deep level flatten use recursion with reduce and concat +var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]]; + +function flattenDeep(arr1) { + return arr1.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []); +} +flattenDeep(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4] +</pre> + + + +<pre class="brush: js">//non recursive flatten deep using a stack +var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]]; +function flatten(input) { + const stack = [...input]; + const res = []; + while (stack.length) { + // pop value from stack + const next = stack.pop(); + if (Array.isArray(next)) { + // push back array items, won't modify the original input + stack.push(...next); + } else { + res.push(next); + } + } + //reverse to restore input order + return res.reverse(); +} +flatten(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4] +</pre> + + + +<pre class="brush: js">//recursive flatten deep +function flatten(array) { + var flattend = []; + !(function flat(array) { + array.forEach(function(el) { + if (Array.isArray(el)) flat(el); + else flattend.push(el); + }); + })(array); + return flattend; +} +</pre> + + + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.flat) { + Array.prototype.flat = function(depth) { + var flattend = []; + (function flat(array, depth) { + for (let el of array) { + if (Array.isArray(el) && depth > 0) { + flat(el, depth - 1); + } else { + flattend.push(el); + } + } + })(this, Math.floor(depth) || 1); + return flattend; + }; +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td><a href="https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flat"><code>Array.prototype.flat</code> proposal</a></td> + <td>Finished (4)</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.flat")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Array.prototype.flatMap()")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("Array.prototype.reduce()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/foreach/index.html b/files/pl/web/javascript/referencje/obiekty/array/foreach/index.html new file mode 100644 index 0000000000..6968498311 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/foreach/index.html @@ -0,0 +1,104 @@ +--- +title: Array.prototype.forEach() +slug: Web/JavaScript/Referencje/Obiekty/Array/forEach +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wykonuje dostarczoną funkcję jeden raz na każdy element tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.forEach(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja wykonywana dla każdego elementu.</dd> + <dt><code>thisArg</code></dt> + <dd>Obiekt na który będzie wskazywał <code>this</code>, gdy wykonana zostanie funkcja zwrotna <code>callback</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>forEach</code> wykonuje dostarczoną funkcje <code>callback</code> raz dla każdego elementu tablicy. Funkcja <code>callback</code> wywoływana jest jedynie dla indeksów tablicy, którym została przypisana wartość; nie jest wywoływana dla indeksów, które zostały usunięte i tych, którym nigdy nie została przypisana żadna wartość.</p> + +<p>Funkcja <code>callback</code> jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.</p> + +<p>Jeśli parametr <code>thisArg</code> został dostarczony do metody <code>forEach</code>, będzie on wskazywany przez <code>this</code> dla każdego wywołania funkcji <code>callback</code>. W przypadku, gdy nie został on przekazany lub jego wartość jest równa <code>null</code>, <code>this</code> będzie się odnosić do obiektu globalnego połączonego z funkcją <code>callback</code>.</p> + +<p>Metoda <code>forEach</code> nie modyfikuje tablicy na której jest wywołana.</p> + +<p>Zakres elementów przetwarzanych przez <code>forEach</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy dołączone do końca tablicy po momencie wywołania <code>forEach</code> nie są przesyłane do funkcji <code>callback</code>. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji <code>callback</code> odpowiada wartości w momencie, w którym <code>forEach</code> się o nie zwróci; elementy usunięte zanim zostaną odwiedzone nie zostaną odwiedzone. Jeżeli element już odwiedzony zostanie usunięty (nastąpi skrócenie tablicy), element tablicy w kolejności po obecnie odwiedzanym zostanie pominięty.</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>forEach</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>forEach</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.forEach) +{ + Array.prototype.forEach = function(fun /*, thisp*/) + { + var len = this.length; + if (typeof fun != "function") + throw new TypeError(); + + var thisp = arguments[1]; + for (var i = 0; i < len; i++) + { + if (i in this) + fun.call(thisp, this[i], i, this); + } + }; +} +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy" name="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy">Przykład: Drukowanie zawartości tablicy</h3> + +<p>Następujący kod drukuje linie dla każdego elementu w tablicy (i przyjmuje obecność funkcji <code>print</code> do wywołania!):</p> + +<pre class="brush: js">function printElt(element, index, array) { + print("[" + index + "] jest " + element); +} +[2, 5, 9].forEach(printElt); +// Wydrukuje: +// [0] jest 2 +// [1] jest 5 +// [2] jest 9 +</pre> + +<h3 id="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy_z_metod.C4.85_obiektu" name="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy_z_metod.C4.85_obiektu">Przykład: Drukowanie zawartości tablicy z metodą obiektu</h3> + +<p>Następujący kod tworzy prosty obiekt wypisujący i następnie stosuje metodę <code>writeln</code> do wypisania jednej linii na element w tablicy (przyjmuje obecność funkcji <code>print</code> do wywołania!):</p> + +<pre class="brush: js">var writer = { + sb: [], + write: function (s) { + this.sb.push(s); + }, + writeln: function (s) { + this.write(s + "\n"); + }, + toString: function () { + return this.sb.join(""); + } +}; + +[2, 5, 9].forEach(writer.writeln, writer); +print(writer.toString()); + +// Wydrukuje: +// 2 +// 5 +// 9 +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/array/from/index.html b/files/pl/web/javascript/referencje/obiekty/array/from/index.html new file mode 100644 index 0000000000..bd5f0294de --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/from/index.html @@ -0,0 +1,248 @@ +--- +title: Array.from() +slug: Web/JavaScript/Referencje/Obiekty/Array/from +translation_of: Web/JavaScript/Reference/Global_Objects/Array/from +--- +<div>{{JSRef}}</div> + +<p><code><strong>Array.from() </strong></code> metoda tworzy nową instację tablicy z obiektu podobnego do tablicy lub obiektu iterowalnego.</p> + +<p>W ES2015, składania klas dopuszcza dziedziczenie obu rodzajów klas: wbudowanych oraz zdefiniowanych przez programistę; w rezultacie, statyczne metody jak <code><strong>Array.from</strong></code> są "dziedziczone" przez klasę pochodną i tworzą nową instancję klasy pochodnej, a nie klasy <code><strong>Array</strong></code>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Array.from(arrayLike[, mapFn[, thisArg]]) +</code></pre> + +<h3 id="Argumenty">Argumenty</h3> + +<dl> + <dt><code>arrayLike</code></dt> + <dd>Obiekt podobny do tablicy lub iterowalny.</dd> + <dt><code>mapFn</code></dt> + <dd>Opcjonalny. Funkcja mapująca wywoływany z każdym elementem tablicy.</dd> + <dt><code>thisArg</code></dt> + <dd>Opcjonalny. Wartość używana jako <code>this</code> podczas wykonywania <code>mapFn</code>.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p><code>Array.from()</code> pozwala tworzyć tablicę z:</p> + +<ul> + <li>obiektu podobnego do tablicy (obiekt z właściwością <code>length</code> property oraz liczbowymi elementami)</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterable objects</a> (objects where you can get its elements, such as {{jsxref("Map")}} and {{jsxref("Set")}}).</li> +</ul> + +<p><code>Array.from()</code> has an optional parameter <code>mapFn</code>, which allows you to execute a {{jsxref("Array.prototype.map", "map")}} function on each element of the array (or subclass object) that is being created. More clearly,<code> Array.from(obj, mapFn, thisArg)</code> is the same as <code>Array.from(obj).map(mapFn, thisArg)</code>, except that it does not create an intermediate array. This is especially important for certain array subclasses, like <a href="/en-US/docs/Web/JavaScript/Typed_arrays">typed arrays</a>, since the intermediate array would necessarily have values truncated to fit into the appropriate type.</p> + +<p>The <code>length</code> property of the <code>from()</code> method is 1.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">// Array-like object (arguments) to Array +function f() { + return Array.from(arguments); +} + +f(1, 2, 3); +// [1, 2, 3] + + +// Any iterable object... +// Set +var s = new Set(["foo", window]); +Array.from(s); +// ["foo", window] + + +// Map +var m = new Map([[1, 2], [2, 4], [4, 8]]); +Array.from(m); +// [[1, 2], [2, 4], [4, 8]] + + +// String +Array.from("foo"); +// ["f", "o", "o"] + + +// Using an arrow function as the map function to +// manipulate the elements +Array.from([1, 2, 3], x => x + x); +// [2, 4, 6] + + +// Generate a sequence of numbers +Array.from({length: 5}, (v, k) => k); +// [0, 1, 2, 3, 4] + +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>Array.from</code> was added to the ECMA-262 standard in the 6th edition; as such it may not be present in other implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of <code>Array.from</code> in implementations that don't natively support it. This algorithm is exactly the one specified in ECMA-262, 6th edition, assuming <code>Object</code> and <code>TypeError</code> have their original values and that <code>callback.call</code> evaluates to the original value of {{jsxref("Function.prototype.call")}}. In addition, since true iterables can not be polyfilled, this implementation does not support generic iterables as defined in the 6th edition of ECMA-262.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 6, 22.1.2.1 +// Reference: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from +if (!Array.from) { + Array.from = (function () { + var toStr = Object.prototype.toString; + var isCallable = function (fn) { + return typeof fn === 'function' || toStr.call(fn) === '[object Function]'; + }; + var toInteger = function (value) { + var number = Number(value); + if (isNaN(number)) { return 0; } + if (number === 0 || !isFinite(number)) { return number; } + return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); + }; + var maxSafeInteger = Math.pow(2, 53) - 1; + var toLength = function (value) { + var len = toInteger(value); + return Math.min(Math.max(len, 0), maxSafeInteger); + }; + + // The length property of the from method is 1. + return function from(arrayLike/*, mapFn, thisArg */) { + // 1. Let C be the this value. + var C = this; + + // 2. Let items be ToObject(arrayLike). + var items = Object(arrayLike); + + // 3. ReturnIfAbrupt(items). + if (arrayLike == null) { + throw new TypeError("Array.from requires an array-like object - not null or undefined"); + } + + // 4. If mapfn is undefined, then let mapping be false. + var mapFn = arguments.length > 1 ? arguments[1] : void undefined; + var T; + if (typeof mapFn !== 'undefined') { + // 5. else + // 5. a If IsCallable(mapfn) is false, throw a TypeError exception. + if (!isCallable(mapFn)) { + throw new TypeError('Array.from: when provided, the second argument must be a function'); + } + + // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 2) { + T = arguments[2]; + } + } + + // 10. Let lenValue be Get(items, "length"). + // 11. Let len be ToLength(lenValue). + var len = toLength(items.length); + + // 13. If IsConstructor(C) is true, then + // 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len. + // 14. a. Else, Let A be ArrayCreate(len). + var A = isCallable(C) ? Object(new C(len)) : new Array(len); + + // 16. Let k be 0. + var k = 0; + // 17. Repeat, while k < len… (also steps a - h) + var kValue; + while (k < len) { + kValue = items[k]; + if (mapFn) { + A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k); + } else { + A[k] = kValue; + } + k += 1; + } + // 18. Let putStatus be Put(A, "length", len, true). + A.length = len; + // 20. Return A. + return A; + }; + }()); +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.from', 'Array.from')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.from', 'Array.from')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Edge</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("45")}}</td> + <td>{{CompatGeckoDesktop("32")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9.0</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("32")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("TypedArray.from()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/includes/index.html b/files/pl/web/javascript/referencje/obiekty/array/includes/index.html new file mode 100644 index 0000000000..526e660571 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/includes/index.html @@ -0,0 +1,110 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Referencje/Obiekty/Array/includes +translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>includes()</strong></code> ustala czy dana tablica posiada szukany element, zwracając <code>true</code> lub <code>false.</code></p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">var<code><var> boolean = array</var>.includes(<var>searchElement</var>[, <var>fromIndex</var>])</code></pre> + +<h3 id="Zwraca">Zwraca</h3> + +<p>{{jsxref("Boolean")}}.</p> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Szukany element.</dd> + <dt><code>fromIndex</code></dt> + <dd>Opcjonalne. Jest to pozycja w tablicy, od której rozpoczyna się szukanie elementu <code>searchElement</code>. Ujemna wartość przeszukuje tablicę od końca tablicy. Domyślna wartość wynosi 0.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">[1, 2, 3].includes(2); // true +[1, 2, 3].includes(4); // false +[1, 2, 3].includes(3, 3); // false +[1, 2, 3].includes(3, -1); // true +[1, 2, NaN].includes(NaN); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.includes) { + Array.prototype.includes = function(searchElement /*, fromIndex*/ ) { + 'use strict'; + var O = Object(this); + var len = parseInt(O.length) || 0; + if (len === 0) { + return false; + } + var n = parseInt(arguments[1]) || 0; + var k; + if (n >= 0) { + k = n; + } else { + k = len + n; + if (k < 0) {k = 0;} + } + var currentElement; + while (k < len) { + currentElement = O[k]; + if (searchElement === currentElement || + (searchElement !== searchElement && currentElement !== currentElement)) { // NaN !== NaN + return true; + } + k++; + } + return false; + }; +} +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td> + <td>{{Spec2('ES7')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> + <p> </p> + </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Array.includes")}}</p> +</div> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("TypedArray.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.findIndex()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/index.html b/files/pl/web/javascript/referencje/obiekty/array/index.html new file mode 100644 index 0000000000..5cfe52578b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/index.html @@ -0,0 +1,279 @@ +--- +title: Array +slug: Web/JavaScript/Referencje/Obiekty/Array +tags: + - Array + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Array +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<p><code>Array</code> w języku JavaScript jest globalnym obiektem, który jest używany podczas tworzenia tablic – listo-podobnych obieków wysokiego poziomu.</p> + +<div class="boxed translate-rendered"> +<p><strong>Stwórz tablicę</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> owoce <span class="operator token">=</span> <span class="punctuation token">[</span><span class="string token">'Jabłko'</span><span class="punctuation token">,</span> <span class="string token">'Banan'</span><span class="punctuation token">]</span><span class="punctuation token">;</span> + +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>owoce<span class="punctuation token">.</span>length<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// 2</span></code></pre> +</div> + +<p><strong>Dostawanie się do elementu tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> pierwszy <span class="operator token">=</span> owoce<span class="punctuation token">[</span><span class="number token">0</span><span class="punctuation token">]</span><span class="punctuation token">;</span> +<span class="comment token">// Jablko</span> + +<span class="keyword token">var</span> ostatni <span class="operator token">=</span> owoce<span class="punctuation token">[</span>owoce<span class="punctuation token">.</span>length <span class="operator token">-</span> <span class="number token">1</span><span class="punctuation token">]</span><span class="punctuation token">;</span> +<span class="comment token">// Banan</span></code></pre> + +<p><strong>Pętla przechodząca przez zawartość tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">owoce<span class="punctuation token">.</span><span class="function token">forEach</span><span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span>item<span class="punctuation token">,</span> index<span class="punctuation token">,</span> array<span class="punctuation token">)</span> <span class="punctuation token">{</span> + console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>item<span class="punctuation token">,</span> index<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// Jablko 0</span> +<span class="comment token">// Banan 1</span></code></pre> + +<p><strong>Dodawanie elementu na końcu tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> nowaDługosc <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">push</span><span class="punctuation token">(</span><span class="string token">'Pomarańcz'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// ["Jabłko", "Banan", "Pomarańcz"]</span></code></pre> + +<p><strong>Usuwanie elemetu z końca tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> ostatni <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">pop</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// usuwa pomarańczę z końca</span> +<span class="comment token">// ["Jabłko", "Banan"];</span></code></pre> + +<p><strong>Usuwanie elementu z przodu tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> pierwszy <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">shift</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// usuwa jabłko z początku</span> +<span class="comment token">// ["Banan"];</span></code></pre> + +<p><strong>Dodawanie elementu z przodu tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> nowaDługość <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">unshift</span><span class="punctuation token">(</span><span class="string token">'Truskawki'</span><span class="punctuation token">)</span> <span class="comment token">// dodaje na początku</span> +<span class="comment token">// ["Truskawkę", "Banan"];</span></code></pre> + +<p><strong>Znajdowanie indeksu (numeru porządkowego) elementu t tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">owoce<span class="punctuation token">.</span><span class="function token">push</span><span class="punctuation token">(</span><span class="string token">'Mango'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// ["Truskawka", "Banan", "Mango"]</span> + +<span class="keyword token">var</span> pos <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">'Banan'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// 1</span></code></pre> + +<p><strong>Usuwanie obiektu przy użyciu indeksu </strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> usunElement <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">splice</span><span class="punctuation token">(</span>pos<span class="punctuation token">,</span> <span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// tak się usuwa element</span> + +<span class="comment token">// ["Truskawka", "Mango"]</span></code></pre> + +<p><strong>Usuwanie elementów przy użyciu pozycji w indeksie</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> warzywa <span class="operator token">=</span> <span class="punctuation token">["</span><span class="string token">Kapusta"</span><span class="punctuation token">,</span> "<span class="string token">Rzepa</span><span class="punctuation token">",</span> "<span class="string token">Rzodkiew"</span><span class="punctuation token">,</span> "<span class="string token">Marchew"</span><span class="punctuation token">]</span><span class="punctuation token">;</span> +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(warzywa</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// </span><span class="punctuation token">[</span><span class="string token">"Kapusta"</span><span class="punctuation token">,</span> "<span class="string token">Rzepa"</span><span class="punctuation token">,</span> "<span class="string token">Rzodkiew"</span><span class="punctuation token">,</span> "<span class="string token">Marchew"</span><span class="punctuation token">]</span> + +<span class="keyword token">var</span> pos <span class="operator token">=</span> <span class="number token">1</span><span class="punctuation token">,</span> n <span class="operator token">=</span> <span class="number token">2</span><span class="punctuation token">;</span> + +<span class="keyword token">var</span> usunieteElementy <span class="operator token">=</span> warzywa<span class="punctuation token">.</span><span class="function token">splice</span><span class="punctuation token">(</span>pos<span class="punctuation token">,</span> n<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// n oznacza liczbę elementów do usunięcia</span> +<span class="comment token">// zaczynając od elementu na określonej pozycji(pos)</span> + +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>warzywa<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// ["Kapusta", "Marchew"] (początkowa tablica została zmieniona)</span> + +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>usunieteElementy<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// ["Rzepa", "Rzodkiew"]</span></code> +</pre> + +<p><strong>Kopiowanie tablicy</strong></p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> płytkaKopia <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">slice</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// tak się tworzy kopię</span> +<span class="comment token">// ["Truskawka", "Mango"]</span></code> +</pre> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia:</h2> + +<pre class="syntaxbox"><code>[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>] +new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]]) +new Array(długoscTablicy)</code></pre> + +<dl> + <dt><code>elementN </code></dt> + <dd>Lista wartości elementów tablicy. Tablica jest inicjowana z określonymi wartościami jako jej elementami. Długość tablicy (<code>length</code>) odpowiada liczbie jej elementów.</dd> + <dt><code>długośćTablicy</code></dt> + <dd>Początkowa długość tablicy. Aby móc przetwarzać wartości używamy własności długości tablicy <code>length</code>. Jeśli określona wartość nie jest liczbą, zostanie utworzona tablica jednoelementowa, a jej pierwszy element będzie posiadał ową wartość. Maksymalna długość tablicy wynosi 4,294,967,295 elementów.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Tablica jest uporządkowanym zbiorem wartości przyporządkowanych ustalonej pojedynczej zmiennej.</p> + +<p>Poniższy przykład tworzy obiekt <code>Array</code> przy użyciu literału tablicy. Tablica <code>kawa</code> zawiera trzy elementy i ma długość (<code>length</code>) równą 3:</p> + +<pre class="brush: js">kawa = ["mocca", "cappucino", "zbożowa"] +</pre> + +<p>Można utworzyć tzw. zwartą tablicę składającą się z dwóch lub więcej elementów, o początkowym indeksie 0, jeśli poda się początkowe wartości wszystkich elementów. Zwarta tablica to taka, w której każdy element posiada wartość. Poniższy kod tworzy zwartą tablicę o trzech elementach:</p> + +<pre class="brush: js">myArray = new Array("Hello", myVar, 3.14159) +</pre> + +<h3 id="Dost.C4.99p_do_element.C3.B3w_tablicy" name="Dost.C4.99p_do_element.C3.B3w_tablicy">Dostęp do elementów tablicy</h3> + +<p>Do elementów tablicy odwołujemy się po ich liczbie porządkowej (zaczynając od zera). Przykładowo, jeśli mamy zdefiniowaną tablicę:</p> + +<pre class="brush: js">mojaTablica = new Array("Wiatr","Deszcz","Ogień") +</pre> + +<p>Do pierwszego elementu odwołujemy się poprzez <code>mojaTablica[0]</code>, a do drugiego poprzez <code>mojaTablica[1]</code>.</p> + +<h3 id="Podawanie_pojedynczego_parametru" name="Podawanie_pojedynczego_parametru">Podawanie pojedynczego parametru</h3> + +<p>Jeśli konstruktor <code>Array</code> zostanie wywołany z pojedynczym parametrem liczbowym, parametr ten zostanie uznany za początkową długość tablicy. Poniższy kod tworzy tablicę pięciu elementów:</p> + +<pre class="brush: js">rodzajPlatnosci = new Array(5) +</pre> + +<p>Zachowanie konstruktora <code>Array</code> zależy od tego, czy jedyny parametr jest liczbą.</p> + +<ul> + <li>Jeśli jedyny parametr jest liczbą, konstruktor konwertuje tę liczbą do 32-bitowej liczby całkowitej bez znaku i tworzy tablicę o długości (liczbie elementów, <code>length</code>) równej tej liczbie. Tablica początkowo nie zawiera żadnych elementów, mimo że ma niezerową długość.</li> + <li>Jeśli parametr ten nie jest liczbą, tworzona jest tablica o długości 1, a parametr ten staje się jej pierwszym elementem.</li> +</ul> + +<p>Poniższy kod tworzy tablicę o długości 25, a następnie przypisuje wartości pierwszym trzem elementom:</p> + +<pre class="brush: js">rodzajeMuzyki = new Array(25) +rodzajeMuzyki[0] = "R&B" +rodzajeMuzyki[1] = "Blues" +rodzajeMuzyki[2] = "Jazz" +</pre> + +<h3 id="Po.C5.9Brednie_zwi.C4.99kszanie_d.C5.82ugo.C5.9Bci_tablicy" name="Po.C5.9Brednie_zwi.C4.99kszanie_d.C5.82ugo.C5.9Bci_tablicy">Pośrednie zwiększanie długości tablicy</h3> + +<p>Długość tablicy wzrasta samoczynnie, jeśli elementowi o indeksie wyższym niż obecna długość zostanie przypisana wartość. Poniższy kod tworzy tablicę o zerowej długości, a następnie przypisuje do niej 99. element. W wyniku długość tablicy zostaje zmieniona na 100.</p> + +<pre class="brush: js">kolory = new Array(); +kolory[99] = "ciemnoniebieski"; +</pre> + +<h3 id="Tworzenie_tablicy_z_wynik.C3.B3w_wyra.C5.BCenia_regularnego" name="Tworzenie_tablicy_z_wynik.C3.B3w_wyra.C5.BCenia_regularnego">Tworzenie tablicy z wyników wyrażenia regularnego</h3> + +<p>Wynik porównania pomiędzy regularnym wyrażeniem a łańcuchem znaków może utworzyć tablicę. Ta tablica ma własności i elementy, które przekazują informacje dotyczące porównania. Tablica jest wartością zwracaną przez <code>RegExp.exec</code>, <code>String.match</code> i <code>String.replace</code>. Aby zrozumieć te własności spójrz na poniższy przykład odwołując się do poniższej tabeli:</p> + +<pre class="brush: js">//Porównuje łańcuch znaków złożony z jednego 'd' następnie kilku 'b' a następnie jednego 'd' +//Zapamiętuje porównane 'b' i następujące 'd' +//Ignoruje wielkość liter + +mojRe=/d(b+)(d)/i; +mojaTablica = mojRe.exec("cdbBdbsbz"); +</pre> + +<p>Własności i elementy zwracają wartości z poniższej tabeli:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Własność/Element</td> + <td class="header">Opis</td> + <td class="header">Przykład</td> + </tr> + <tr> + <td><code>input</code></td> + <td>Wartość tylko-do-odczytu, opisująca oryginalny łańcuch znaków, do którego porównano wyrażenie regularne.</td> + <td>cdbBdbsbz</td> + </tr> + <tr> + <td><code>index</code></td> + <td>Własność tylko-do-odczytu, będąca indeksem (zaczynając od 0) porównanego znaku w łańcuchu znaków.</td> + <td>1</td> + </tr> + <tr> + <td><code>[0]</code></td> + <td>Element tylko-do-odczytu, zawierający ostatnio porównane znaki.</td> + <td>dbBd</td> + </tr> + <tr> + <td><code>[1], ... [n]</code></td> + <td>Elementy tylko-do-odczytu, zawierające podobne podłańcuchy znaków, zawarte w wyrażeniu regularnym. Liczba możliwych podłańcuchów jest nieskończona.</td> + <td>[1]: bB<br> + [2]: d</td> + </tr> + </tbody> +</table> + +<h2 id="Własności">Własności</h2> + +<dl> + <dd> + <dl> + <dt>{{jsxref("Array.length")}}</dt> + <dd>Odzwierciedla ilość elementów tablicy.</dd> + <dt>{{jsxref("Array.prototype")}}</dt> + <dd>Pozwala na dodawanie własności do wszystkich obiektów.</dd> + </dl> + </dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Array.from()")}} {{experimental_inline}}</dt> + <dd>Tworzy nową instancję <code>Array</code> z obiektu podobnego do tablicy lub iterowalnego.</dd> + <dt>{{jsxref("Array.isArray()")}}</dt> + <dd>Zwraca true, jeśli zmienna jest tablicą, jeśli nie false.</dd> + <dt>{{jsxref("Array.observe()")}} {{experimental_inline}}</dt> + <dd>Asynchronicznie obserwuje zmiany w tablicach, podobnie jak {{jsxref ("Object.observe ()")}} dla obiektów. Zapewnia strumień zmian w kolejności występowania.</dd> + <dt>{{jsxref("Array.of()")}} {{experimental_inline}}</dt> + <dd>Tworzy nową instancję Array ze zmienną liczbą argumentów, niezależnie od liczby lub rodzaju argumentów.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad_Tworzenie_tablicy" name="Przyk.C5.82ad:_Tworzenie_tablicy">Przykład: Tworzenie tablicy</h3> + +<p>Poniższy kod tworzy tablicę <code>msgArray</code> o długości 0, a następnie przypisuje wartości do <code>msgArray[0]</code> i <code>msgArray[99]</code>, zwiększając długość tablicy do 100.</p> + +<pre class="brush: js">msgArray = new Array() +msgArray[0] = "Witaj," +msgArray[99] = "świecie" +// Poniższy warunek jest spełniony, +// ponieważ zdefiniowano element msgArray[99]. +if (msgArray.length == 100) + myVar="Długość tablicy jest równa 100." +</pre> + +<h3 id="Przyk.C5.82ad_Tworzenie_tablicy_dwuwymiarowej" name="Przyk.C5.82ad:_Tworzenie_tablicy_dwuwymiarowej">Przykład: Tworzenie tablicy dwuwymiarowej</h3> + +<p>Poniższy kod tworzy tablicę dwuwymiarową i przypisuje wyniki do zmiennej <code>myVar</code>.</p> + +<pre class="brush: js">myVar="Test tablicy wielowymiarowej; " +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+"]" + } +} +for (i=0; i < 4; i++) { + str = "Wiersz "+i+":" + for (j=0; j < 4; j++) { + str += a[i][j] + } + myVar += str +"; " +} +</pre> + +<p>Poniższy łańcuch znaków będzie przypisany do zmiennej <code>myVar</code> (linie zostały przełamane dla zwiększenia czytelności):</p> + +<pre>Test tablicy wielowymiarowej; +Wiersz 0:[0,0][0,1][0,2][0,3]; +Wiersz 1:[1,0][1,1][1,2][1,3]; +Wiersz 2:[2,0][2,1][2,2][2,3]; +Wiersz 3:[3,0][3,1][3,2][3,3]; +</pre> + +<div class="noinclude"></div> diff --git a/files/pl/web/javascript/referencje/obiekty/array/indexof/index.html b/files/pl/web/javascript/referencje/obiekty/array/indexof/index.html new file mode 100644 index 0000000000..db63c3384c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/indexof/index.html @@ -0,0 +1,95 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Referencje/Obiekty/Array/indexOf +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca pierwszy (najmniejszy) indeks elementu w tablicy równego podanej wartości lub -1, gdy nie znaleziono takiego elementu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><em>array</em>.indexOf(<em>searchElement</em>[,<em> fromIndex</em> = 0]); +</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Element do znalezienia w tablicy.</dd> + <dt><code>fromIndex</code></dt> + <dd>Indeks od którego ma zacząć się wyszukiwanie. Domyślnie 0 - przeszukana zostanie cała tablica. Jeżeli indeks będzie większy lub równy ilości elementów tablica nie zostanie przeszukana - funkcja zwróci -1. Jeżeli podana zostanie liczba ujemna zostanie dodany do niej rozmiar tablicy (np. podanie -5 oznacza przeszukiwanie od 5 elementu od końca). Jeżeli tak obliczony indeks jest mniejszy od zera przeszukana zostanie cała tablica. Uwaga, wyszukiwanie dalej będzie się odbywać w kierunku rosnących indeksów.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>indexOf</code> porównuje <code>searchElement</code> z elementami tablicy używając <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_por%c3%b3wnania#.22U.C5.BCywanie_operator.C3.B3w_por.C3.B3wnania">ścisłego porównania</a> (podobnie jak w przypadku operatora ===).</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>indexOf</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>indexOf</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.indexOf) +{ + Array.prototype.indexOf = function(elt /*, from*/) + { + var len = this.length; + + var from = Number(arguments[1]) || 0; + from = (from < 0) + ? Math.ceil(from) + : Math.floor(from); + if (from < 0) + from += len; + + for (; from < len; from++) + { + if (from in this && + this[from] === elt) + return from; + } + return -1; + }; +} +</pre> + +<p>Należy zwrócić uwagę, że ta implementacja ma na celu całkowitą zgodność z <code>indexOf</code> występującą w Firefoksie i silniku JavaScript SpiderMonkey, włączając w to przypadki w których przesyłany do <code>indexOf</code> indeks nie jest wartością liczbową. Jeśli masz zamiar wykorzystać przytoczone rozwiązanie w rzeczywistych aplikacjach, możesz nie potrzebować całego powyższego kodu (części odpowiedzialnej za obliczenie wartości <code>from</code>).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_indexOf" name="Przyk.C5.82ad:_Zastosowanie_indexOf">Przykład: Zastosowanie <code>indexOf</code></h3> + +<p>Następujący przykład stosuje <code>indexOf</code> do znalezienia pierwszego wystąpienia elementów.</p> + +<pre class="brush: js">array = [2, 5, 9]; +index = array.indexOf(2); +// index jest 0 +index = array.indexOf(7); +// index jest -1 +</pre> + +<h3 id="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_w_tablicy" name="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_w_tablicy">Przykład: Wyszukiwanie wszystkich wystąpień w tablicy</h3> + +<p>Poniższy przykład używa <code>indexOf</code> do znalezienia wszystkich wystąpień elementu w tablicy oraz dodaje ich indeksy do drugiej tablicy używając metody {{jsxref("Array.prototype.push()")}}.</p> + +<pre class="brush: js">indices = []; +idx = array.indexOf(element) +while (idx != -1) { + indices.push(idx); + idx = array.indexOf(element, idx + 1); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.indexOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/isarray/index.html b/files/pl/web/javascript/referencje/obiekty/array/isarray/index.html new file mode 100644 index 0000000000..62083e0853 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/isarray/index.html @@ -0,0 +1,139 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Referencje/Obiekty/Array/isArray +translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Podsumowanie</h2> + +<p><strong>Array.isArray()</strong> to metoda, która zwraca <code style="font-style: normal; line-height: 23.3333339691162px;">true</code><span style="line-height: 23.3333339691162px;"> </span> jeśli obiekt jest tablicą, fałsz jeśli nie jest.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox"><code>Array.isArray(<var>obj</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Obiekt do sprawdzenia</dd> +</dl> + +<h2 id="Description" name="Description">Opis</h2> + +<p>Zobacz artykuł <a href="http://web.mit.edu/jwalden/www/isArray.html">“Determining with absolute accuracy whether or not a JavaScript object is an array”</a> , aby poznać więcej szczegółów.</p> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<pre class="brush: js">// poniższe przykłady zwrócą true +Array.isArray([]); +Array.isArray([1]); +Array.isArray(new Array()); +// Mało znany fakt: Array.prototype sam w sobie jest tablicą: +Array.isArray(Array.prototype); + +// poniższe przykłady zwrócą false +Array.isArray(); +Array.isArray({}); +Array.isArray(null); +Array.isArray(undefined); +Array.isArray(17); +Array.isArray('Array'); +Array.isArray(true); +Array.isArray(false); +Array.isArray({ __proto__: Array.prototype }); +</pre> + +<h2 id="Polyfill" name="Polyfill">Dostępność wsteczna</h2> + +<p>Jeśli metody <span style="font-family: consolas,monaco,andale mono,monospace; line-height: 23.3333339691162px;">Array.isArray() nie jest natywnie dostępna, poniższy kod ją utworzy.</span></p> + +<pre class="brush: js">if (!Array.isArray) { + Array.isArray = function(arg) { + return Object.prototype.toString.call(arg) === '[object Array]'; + }; +} +</pre> + +<h2 id="Specifications" name="Specifications">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Wstępna definicja. Implementacja od JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Zgodność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("5")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("5")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("2.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>Based on <a href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p> + +<h2 id="See_also" name="See_also">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/Array", "Array")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/join/index.html b/files/pl/web/javascript/referencje/obiekty/array/join/index.html new file mode 100644 index 0000000000..b4b22afc49 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/join/index.html @@ -0,0 +1,50 @@ +--- +title: Array.prototype.join() +slug: Web/JavaScript/Referencje/Obiekty/Array/join +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/join +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Łączy wszystkie elementy tablicy w jeden łańcuch znaków.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var> = <var>arr</var>.join([<var>separator</var> = ','])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>separator</code> </dt> + <dd>Określa łańcuch znaków użyty do oddzielenia każdego z elementów tablicy. W razie konieczności separator jest konwertowany do łańcucha znaków. Jeśli parametr zostanie pominięty, elementy tablicy będą rozdzielone za pomocą przecinka.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>join</code> zmienia w łańcuchy znaków wszystkie elementy tablicy i łączy je w jeden łańcuch znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_.C5.81.C4.85czenie_tablicy_na_trzy_r.C3.B3.C5.BCne_sposoby" name="Przyk.C5.82ad:_.C5.81.C4.85czenie_tablicy_na_trzy_r.C3.B3.C5.BCne_sposoby">Przykład: Łączenie tablicy na trzy różne sposoby</h3> + +<p>Poniższy przykład tworzy trzyelementową tablicę <code>a</code> zawierającą trzy elementy, następnie trzykrotnie łączy ją: używając domyślnego separatora, przecinka i spacji oraz znaku plus.</p> + +<pre class="brush: js">var a = new Array("Wiatr","Deszcz","Ogień"); +var myVar1 = a.join() // przypisuje "Wiatr,Deszcz,Ogień" do myVar1 +var myVar2 = a.join(", ") // przypisuje "Wiatr, Deszcz, Ogień" do myVar2 +var myVar3 = a.join(" + ") // przypisuje "Wiatr + Deszcz + Ogień" do myVar3 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.toString()")}}</li> + <li>{{jsxref("TypedArray.prototype.join()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/keys/index.html b/files/pl/web/javascript/referencje/obiekty/array/keys/index.html new file mode 100644 index 0000000000..4ab6d7e18e --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/keys/index.html @@ -0,0 +1,120 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Referencje/Obiekty/Array/keys +translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>keys()</strong></code> zwraca nowy obiekt typu <code><strong>Array Iterator</strong></code> zawierający indeksy kolejnych elementów tablicy.</p> + +<pre class="brush: js">var arr = ['a', 'b', 'c']; +var iterator = arr.keys(); + +console.log(iterator.next()); // { value: 0, done: false } +console.log(iterator.next()); // { value: 1, done: false } +console.log(iterator.next()); // { value: 2, done: false } +console.log(iterator.next()); // { value: undefined, done: true } +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>arr</var>.keys()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator dla typu {{jsxref("Array")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Iterator_nie_ignoruje_dziur">Iterator nie ignoruje dziur</h3> + +<pre class="brush: js">var arr = ['a', , 'c']; +var sparseKeys = Object.keys(arr); +var denseKeys = [...arr.keys()]; +console.log(sparseKeys); // ['0', '2'] +console.log(denseKeys); // [0, 1, 2] +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Pierwsze wystąpienie.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Edge</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("38")}}</td> + <td>{{CompatGeckoDesktop("28")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</td> + <td>{{CompatSafari("7.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Array.prototype.values()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> + <li>{{jsxref("Iteration_protocols", "Iteratory")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/lastindexof/index.html b/files/pl/web/javascript/referencje/obiekty/array/lastindexof/index.html new file mode 100644 index 0000000000..3a6322d6b4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/lastindexof/index.html @@ -0,0 +1,114 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Referencje/Obiekty/Array/lastIndexOf +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca ostatni indeks, pod którym podany element może być znaleziony w tablicy, lub -1 jeśli nie jest obecny. Tablica jest przeszukiwana od końca, zaczynając od indeksu <code>fromIndex</code></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.lastIndexOf(<var>searchElement</var>[, <var>fromIndex</var> = arr.length])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Element do znalezienia w tablicy.</dd> + <dt><code>fromIndex</code></dt> + <dd>Indeks od którego ma zostać rozpoczęte wyszukiwanie od tyłu. Domyślnie jest to długość tablicy, tzn. przeszukana zostanie cała tablica. Jeśli indeks jest większy od lub równy długości tablicy, przeszukana zostanie cała tablica. Jeśli jest ujemny, traktowany będzie jako przesunięcie od końca tablicy. Należy pamiętać, że nawet jeśli indeks jest ujemny, to i tak tablica przeszukiwana jest od końca do początku. Jeśli obliczony indeks jest mniejszy od 0, zwracana jest wartość -1, innymi słowy, tablica nie zostanie przeszukana.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>lastIndexOf</code> porównuje <code>searchElement</code> z elementami tablicy używając <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_por%c3%b3wnania#.22U.C5.BCywanie_operator.C3.B3w_por.C3.B3wnania">ścisłego porównania</a> (podobnie jak w przypadku operatora ===).</p> + +<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3> + +<p><code>lastIndexOf</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>lastIndexOf</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p> + +<pre class="brush: js">if (!Array.prototype.lastIndexOf) +{ + Array.prototype.lastIndexOf = function(elt /*, from*/) + { + var len = this.length; + + var from = Number(arguments[1]); + if (isNaN(from)) + { + from = len - 1; + } + else + { + from = (from < 0) + ? Math.ceil(from) + : Math.floor(from); + if (from < 0) + from += len; + else if (from >= len) + from = len - 1; + } + + for (; from > -1; from--) + { + if (from in this && + this[from] === elt) + return from; + } + return -1; + }; +} +</pre> + +<p>Należy zwrócić uwagę, że ta implementacja ma na celu całkowitą zgodność z <code>lastIndexOf</code> występującą w Firefoksie i silniku JavaScript SpiderMonkey, włączając w to przypadki skrajne. Jeśli masz zamiar wykorzystać przytoczone rozwiązanie w rzeczywistych aplikacjach, możesz obliczyć <code>from</code> za pomocą mniej skomplikowanego kodu (z pominięciem części instrukcji warunkowych).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_lastIndexOf" name="Przyk.C5.82ad:_Zastosowanie_lastIndexOf">Przykład: Zastosowanie <code>lastIndexOf</code></h3> + +<p>Poniższy przykład używa <code>lastIndexOf</code> do znalezienia określonych wartości w tablicy.</p> + +<pre class="brush: js">array = [2, 5, 9, 2]; +index = array.lastIndexOf(2); +// index is 3 +index = array.lastIndexOf(7); +// index is -1 +index = array.lastIndexOf(2, 3); +// index is 3 +index = array.lastIndexOf(2, 2); +// index is 0 +index = array.lastIndexOf(2, -2); +// index is 0 +index = array.lastIndexOf(2, -1); +// index is 3 +</pre> + +<h3 id="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_danego_elementu" name="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_danego_elementu">Przykład: Wyszukiwanie wszystkich wystąpień danego elementu</h3> + +<p>Poniższy przykład używa <code>lastIndexOf</code> do znalezienia wszystkich wystąpień elementu w tablicy oraz dodaje ich indeksy do drugiej tablicy używając metody <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/push">push</a></code>.</p> + +<pre class="brush: js">indices = []; +idx = array.lastIndexOf(element) +while (idx != -1) { + indices.push(idx); + idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1); +} +</pre> + +<p>Warto zauważyć, że obsłużyliśmy warunek <code>idx == 0</code> oddzielnie, ponieważ element ten zostanie zawsze odnaleziony - bez względu na wartość parametru <code>fromIndex</code> - w przypadku gdy jest on pierwszym elementem tablicy. To różni tę metodę od metody {{jsxref("Array.prototype.indexOf()")}}.</p> + +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3> + +<ul> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/length/index.html b/files/pl/web/javascript/referencje/obiekty/array/length/index.html new file mode 100644 index 0000000000..0ce2bbde35 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/length/index.html @@ -0,0 +1,53 @@ +--- +title: Array.prototype.length +slug: Web/JavaScript/Referencje/Obiekty/Array/length +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/length +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>32-bitowa liczba całkowita bez znaku określająca liczbę elementów w tablicy.</p> + +<div>{{js_property_attributes(1, 0, 0)}}</div> + +<div> +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.length</code></pre> +</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością własności <code>length</code> jest dodatnia liczba całkowita mniejsza niż 2 do potęgi 32 (2<sup>32</sup>).</p> + +<p>W dowolnej chwili możesz ustalić wartość <code>length</code> w celu zmniejszenia rozmiaru tablicy. Ustawienie wartości <code>length</code> na większą niż rozmiar tablicy nie zwiększy liczby elementów, np. jeżeli ustawisz <code>length</code> na 3, podczas gdy obecną wartością jest liczba 2, tablica nadal będzie zawierać tylko 2 elementy.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Iteracja_przez_wszystkie_elementy_tablicy" name="Przyk.C5.82ad:_Iteracja_przez_wszystkie_elementy_tablicy">Przykład: Iteracja przez wszystkie elementy tablicy</h3> + +<p>W poniższym przykładzie ilość elementów w tablicy <code>numbers</code> jest określana w instrukcji iteracyjnej na podstawie wartości <code>length</code>, następnie wartość każdego elementu jest podwajana.</p> + +<pre class="brush: js">var numbers = [1,2,3,4,5]; +for (var i = 0; i < numbers.length; i++) { + numbers[i] *= 2; +} +// zawartość tablicy to teraz [2,4,6,8,10]; +</pre> + +<h3 id="Przyk.C5.82ad:_Skracanie_tablicy" name="Przyk.C5.82ad:_Skracanie_tablicy">Przykład: Skracanie tablicy</h3> + +<p>Poniższy przykład zmniejsza rozmiar tablicy <code>statesUS</code> do 50, jeżeli przekracza on tę wartość.</p> + +<pre class="brush: js">if (statesUS.length > 50) { + statesUS.length=50 +} +</pre> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/referencje/obiekty/array/map/index.html b/files/pl/web/javascript/referencje/obiekty/array/map/index.html new file mode 100644 index 0000000000..2b25e7f1cd --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/map/index.html @@ -0,0 +1,93 @@ +--- +title: Array.prototype.map() +slug: Web/JavaScript/Referencje/Obiekty/Array/map +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/map +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>map()</strong></code> tworzy nową tablicę zawierającą wyniki wywoływania podanej funkcji dla każdego elementu wywołującej tablicy.</p> + +<pre class="brush: js">var liczby = [1, 5, 10, 15]; +var podwojenia = liczby.map(function(x) { + return x * 2; +}); +// podwojenia to teraz [2, 10, 20, 30] +// liczby to dalej [1, 5, 10, 15] + +var liczby = [1, 4, 9]; +var pierwiastki = liczby.map(Math.sqrt); +// pierwiastki to teraz [1, 2, 3] +// liczby to dalej [1, 4, 9] +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>var new_array = arr</var>.map(<var>function callback(currentValue, index, array){ // Zwróć element nowej tablicy }</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><strong>callback</strong></code></dt> + <dd>Funkcja tworząca element nowej tablicy, przyjmująca trzy argumenty:</dd> + <dd> + <dl> + <dt><code><strong>currentValue</strong></code></dt> + <dd>Element tablicy nad którym obecnie pracujemy</dd> + <dt><code><strong>index</strong></code></dt> + <dd>Indeks elementu tablicy nad którym obecnie pracujemy</dd> + <dt><code><strong>array</strong></code></dt> + <dd>Oryginalna tablica na rzecz której wywołano metodę <code>map</code></dd> + </dl> + </dd> + <dt><code><strong>thisArg</strong></code></dt> + <dd>Opcjonalny. Wartość jaką użyć jako <code>this</code> podczas wywołania <code>callback</code></dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowa tablica zawierająca elementy będące wynikami wywoływani funkcji <code>callback</code>.</p> + +<h2 id="Opis">Opis</h2> + +<p><code>map</code> wykonuje funkcję (<code>callback</code>) raz na każdym z elementów tablicy w kolejności i tworzy nową tablicę na podstawie wyników. <code>callback</code> wywoływany jest tylko dla indeksów tablicy które mają przypisane wartości, włącznie z <a href="/pl/docs/Web/JavaScript/Referencje/Obiekty/undefined">undefined</a>. Nie jest wywoływany dla brakujących elementów tablicy (indeksów które nigdy nie były ustawione, usunięte lub nie miały nigdy przypisanych wartości).</p> + +<p><code>callback</code> wywoływana jest z trzema argumentami: wartością elementu, jego indeksem i tablicą która jest trawersowana.</p> + +<p>W przypadku podania argumentu <code>thisObject</code>, zostanie on przekazany jako <code>this</code> przy każdym wywołaniu <code>callback</code>. Gdy go brak, lub ma wartość <code>null</code>, użyty zostanie obiekt globalny przyporządkowany do <code>callback</code>.</p> + +<p><code>map</code> nie modyfikuje tablicy, na której jest wywołany.</p> + +<p>Zakres elementów przetwarzanych przez <code>map</code> ustalany jest przed pierwszym wywołaniem <code>callback</code>. Elementy dodane do tablicy po wywołaniu <code>map</code> nie zostaną odwiedzone przez <code>callback</code>. Jeśli istniejący, element tablicy zostanie zmieniony lub usunięty, wartością przekazaną do <code>callback</code> będzie wartość z momentu w którym <code>map</code> odwiedza dany element; elementy usunięte przed sprawdzeniem będą przekazane jako <code>undefined</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Wielkie_litery_.C5.82a.C5.84cuch.C3.B3w_w_tablicy" name="Przyk.C5.82ad:_Wielkie_litery_.C5.82a.C5.84cuch.C3.B3w_w_tablicy">Wielkie litery łańcuchów w tablicy</h3> + +<p>Poniższy kod tworzy nową tablicę zawierającą pisaną wielkimi literami wersję wszystkich oryginalnych łańcuchów.</p> + +<pre class="brush: js">var strings = ["hello", "Array", "WORLD"]; +function makeUpperCase(v) +{ + return v.toUpperCase(); +} +var uppers = strings.map(makeUpperCase); +// uppers są teraz pisane wielkimi literami ["HELLO", "ARRAY", "WORLD"] +// strings są niezmienione +</pre> + +<h3 id="Przyk.C5.82ad:_Mapowanie_tablicy_liczb_do_tablicy_pierwiastk.C3.B3w_kwadratowych" name="Przyk.C5.82ad:_Mapowanie_tablicy_liczb_do_tablicy_pierwiastk.C3.B3w_kwadratowych">Mapowanie tablicy liczb do tablicy pierwiastków kwadratowych</h3> + +<p>Poniższy kod pobiera tablicę liczb i tworzy nową tablicę z pierwiastkami kwadratowymi liczb z pierwszej tablicy.</p> + +<pre class="brush: js">var liczby = [1, 4, 9]; +var pierwiastki = liczby.map(Math.sqrt); +// otrzymane pierwiastki [1, 2, 3] +// pozostające nadal liczby [1, 4, 9] +</pre> + +<p> </p> diff --git a/files/pl/web/javascript/referencje/obiekty/array/of/index.html b/files/pl/web/javascript/referencje/obiekty/array/of/index.html new file mode 100644 index 0000000000..74c9974bd0 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/of/index.html @@ -0,0 +1,92 @@ +--- +title: Array.of() +slug: Web/JavaScript/Referencje/Obiekty/Array/of +translation_of: Web/JavaScript/Reference/Global_Objects/Array/of +--- +<div>{{JSRef}}</div> + +<p><code><font face="Verdana, arial, x-locale-body, sans-serif"><span style="background-color: #ffffff;">Metoda </span></font><strong>Array.of()</strong></code> tworzy nową instancję obiektu <code>Array</code>, która zawiera w sobie wszystkie argumenty przekazane do funkcji, niezależnie od ich liczby i typu.</p> + +<p>Różnica pomiędzy <code><strong>Array.of()</strong></code> i konstruktorem <code><strong>Array</strong></code> polega na różnej interpretacji argumentów - <code><strong>Array.of(7)</strong></code> tworzy nową tablicę z jednym elementem(<code>7</code>), gdzie <code><strong>Array(7)</strong></code> tworzy nową tablicę z właściwością <code>length</code> ustawioną na 7 (<strong>Notatka:</strong> Oznacza to tablicę z <code>7</code> wolnymi miejscami, nie miejscami z wartościami <code>undefined</code>).</p> + +<pre class="brush: js">Array.of(7); // [7] +Array.of(1, 2, 3); // [1, 2, 3] + +Array(7); // [ , , , , , , ] +Array(1, 2, 3); // [1, 2, 3] +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">Array.of(<var>element0</var>[, <var>element1</var>[, ...[, <var>elementN</var>]]])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Elementy, które tworzą tablicę.</dd> +</dl> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p>Nowa instancja obiektu {{jsxref("Array")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>Ta funkcja jest częścią standardu ECMAScript 2015. Po więcej informacji zobacz <a href="https://gist.github.com/rwaldron/1074126"><code>Array.of</code> and <code>Array.from</code> proposal</a> i <a href="https://gist.github.com/rwaldron/3186576"><code>Array.of</code> polyfill</a>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">Array.of(1); // [1] +Array.of(1, 2, 3); // [1, 2, 3] +Array.of(undefined); // [undefined] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Uruchomienie tego kodu przed innym stworzy <code>Array.of()</code> nawet jeśli nie jest ona dostępna natywnie.</p> + +<pre class="brush: js">if (!Array.of) { + Array.of = function() { + return Array.prototype.slice.call(arguments); + }; +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.of', 'Array.of')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.of', 'Array.of')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.of")}}</p> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.from()")}}</li> + <li>{{jsxref("TypedArray.of()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/pop/index.html b/files/pl/web/javascript/referencje/obiekty/array/pop/index.html new file mode 100644 index 0000000000..2b7483dbd7 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/pop/index.html @@ -0,0 +1,138 @@ +--- +title: Array.prototype.pop() +slug: Web/JavaScript/Referencje/Obiekty/Array/pop +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Metodă + - Prototype + - Tablica +translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Usuwa ostatni element z tablicy zwracając go. Metoda ta zmienia długość tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.pop()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Ostatni element tablicy;<br> + Jeśli tablica jest pusta zwraca {{jsxref("undefined")}}</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda pop usuwa ostatni element tablicy i zwraca tę wartość.</p> + +<p><code>pop</code> is intentionally generic. Metoda ta może być {{jsxref("Function.call", "called", "", 1)}} lub {{jsxref("Function.apply", "applied", "", 1)}} do obiektu przypominającego tablice. Obiekty, które nie posiadają właściwości <code>length</code> odzwierciedlającej ostani element w serii, przy właściwościach liczonych od zera nie mogą zachowywać się w żaden znaczący sposób.</p> + +<p>Jeśli zawołasz <code>pop()</code> na pustej tablicy, zwróci ona {{jsxref("undefined")}}.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<h3 id="Przyk.C5.82ad:_Usuwanie_ostatniego_elementu_tablicy" name="Przyk.C5.82ad:_Usuwanie_ostatniego_elementu_tablicy">Przykład: Usuwanie ostatniego elementu tablicy</h3> + +<p>Następujący kod tworzy tablicę <code>myFish</code> zawierającą cztery elementy, a następnie usuwa ostatni jej element.</p> + +<pre><code>var myFish = ['angel', 'clown', 'mandarin', 'sturgeon']; + +console.log(myFish); // ['angel', 'clown', 'mandarin', 'sturgeon'] + +var popped = myFish.pop(); + +console.log(myFish); // ['angel', 'clown', 'mandarin' ] + +console.log(popped); // 'sturgeon'</code></pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<table> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> + +<table> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/prototype/index.html b/files/pl/web/javascript/referencje/obiekty/array/prototype/index.html new file mode 100644 index 0000000000..94cbd2b287 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/prototype/index.html @@ -0,0 +1,12 @@ +--- +title: Array.prototype +slug: Web/JavaScript/Referencje/Obiekty/Array/prototype +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Reprezentuje prototyp tego obiektu. Pozwala na dodawanie własności lub metod do wszystkich instancji obiektu. Zobacz {{jsxref("Object.prototype")}}, aby uzyskać więcej informacji.</p> diff --git a/files/pl/web/javascript/referencje/obiekty/array/push/index.html b/files/pl/web/javascript/referencje/obiekty/array/push/index.html new file mode 100644 index 0000000000..92bf342cda --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/push/index.html @@ -0,0 +1,51 @@ +--- +title: Array.prototype.push() +slug: Web/JavaScript/Referencje/Obiekty/Array/push +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/push +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Dodaje jeden lub więcej elementów na koniec tablicy i zwraca jej nową długość. Metoda ta zmienia długość tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.push(<var>element1</var>, ..., <var>elementN</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>element + <i>N</i> + </code> </dt> + <dd>Elementy dodawane na końcu tablicy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Zachowanie metody <code>push</code> jest analogiczne do funkcji <code>push</code> w języku Perl 4. Uwaga: jej zachowanie różni się w języku Perl 5.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy" name="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy">Przykład: Dodawanie elementów do tablicy</h3> + +<p>Następujący kod tworzy tablicę <code>myFish</code> zawierającą dwa elementy, następnie dodaje do niej dwa kolejne. Po wykonaniu kodu, <code>pushed</code> zawiera wartość 4 (w JavaScript 1.2 po wykonaniu kodu zmienna <code>pushed</code> zawiera wartość "lew").</p> + +<pre class="brush: js">myFish = ["anioł", "klaun"]; +pushed = myFish.push("bęben", "lew"); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/reduce/index.html b/files/pl/web/javascript/referencje/obiekty/array/reduce/index.html new file mode 100644 index 0000000000..8699a308c5 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/reduce/index.html @@ -0,0 +1,300 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Referencje/Obiekty/Array/Reduce +translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Podsumowanie</h2> + +<p><code><font face="Open Sans, Arial, sans-serif">Metoda </font><strong>reduce()</strong></code> wywołuje funkcję względem wartości przyrostowej z każdego wywołania i kolejnego elementu tablicy (od lewej do prawej) w celu sprowadzenia tej tablicy do pojedynczej wartości.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])</var></code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja wykonywana na każdej wartości w tablicy, przyjmuje cztery argumenty: + <dl> + <dt><code>previousValue</code></dt> + <dt></dt> + <dd>Wartość zwróconą w ostatnim wywołaniu funkcji <code>callback</code>, lub <code>initialValue</code>, jeśli ta została dostarczona. (Patrz niżej.)</dd> + <dt><code>currentValue</code></dt> + <dd>Obecnie przetwarzany element w tablicy.</dd> + <dt><code>index</code></dt> + <dd>Indeks w tablicy obecnie przetwarzanego elementu.</dd> + <dt><code>array</code></dt> + <dd>Tablica, na której została wykonana funkcja <code>reduce</code> .</dd> + </dl> + </dd> + <dt><code>initialValue</code></dt> + <dd>Opcjonalne. Obiekt który będzie użyty jako pierwszy argument pierwszego wywołania funkcji <code>callback</code>.</dd> +</dl> + +<h2 id="Description" name="Description">Opis</h2> + +<p><code>reduce</code> wykonuje funkcję <code>callback</code> raz dla każdego elementu występującego w tablicy, wyłączając dziury. Funkcja <code>callback</code> przyjmuje cztery argumenty: wartość początkową (lub wartość poprzedniego wywołania <code>callback)</code>, wartość obecnego elementu, jego indeks, oraz tablicę na której zachodzi proces iteracji.</p> + +<p>Przy pierwszym wywołaniu funkcji <code>callback, previousValue</code> oraz <code>currentValue</code> mogą przyjąć jedną z dwóch wartości. Jeżeli <code>initialValue</code> było dostarczone w wywołaniu, wtedy <code>previousValue</code> przyjmie wartość podaną jako <code>initialValue</code>, natomiast <code>currentValue</code> przyjmie wartość pierwszego elementu tablicy. Jeśli <code>initialValue</code> nie było podane, wtedy <code>previousValue</code> będzie miało wartość pierwszego elementu tablicy, natomiast <code>currentValue</code> będzie równe elementowi drugiemu.</p> + +<p>Jeżeli tablica jest pusta oraz <code>initialValue</code> nie zostało dostarczone, będzie rzucony błąd {{jsxref("Global_Objects/TypeError", "TypeError")}}. Jeśli natomiast tablica ma jeden tylko element (bez względu na jego pozycję) i <code>initialValue</code> nie zostało podane, lub dostarczono <code>initialValue</code>, ale tablica jest pusta, wtedy ta jedyna wartość zostanie zwrócona, bez wywoływania funkcji <code>callback</code>.</p> + +<p>Przyjmijmy, że wystąpiło następujące wywolanie funkcji <code>reduce</code>:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) { + return previousValue + currentValue; +}); +</pre> + +<p>Funkcja callback będzie wywołana cztery razy, z argumentami i wartościami zwrotnymi przy każdym wołaniu jak następuje:</p> + +<table style="width: 100%;"> + <thead> + <tr> + <th scope="col"></th> + <th scope="col"><code>previousValue</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">wartość zwracana</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">pierwsze wywołanie</th> + <td><code>0</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>1</code></td> + </tr> + <tr> + <th scope="row">drugie wywołanie</th> + <td><code>1</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>3</code></td> + </tr> + <tr> + <th scope="row">trzecie wywołanie</th> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>6</code></td> + </tr> + <tr> + <th scope="row">czwarte wywołanie</th> + <td><code>6</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + </tbody> +</table> + +<p>Wartość zwrócona ostatecznie przez <code>reduce</code> będzie tą z ostatniego wywołania funcji callback (<code>10</code>).</p> + +<p>Natomiast, jeśli dostarczylibyśmy wartość początkową jako drugi argument funkcji przekazanej do <code>reduce</code>, wynik wyglądałby jak poniżej:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) { + return previousValue + currentValue; +}, 10); +</pre> + +<table style="width: 100%;"> + <thead> + <tr> + <th scope="col"></th> + <th scope="col"><code>previousValue</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">wartość zwracana</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">pierwsze wywołanie</th> + <td><code>10</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + <tr> + <th scope="row">drugie wywołanie</th> + <td><code>10</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>11</code></td> + </tr> + <tr> + <th scope="row">trzecie wywołanie</th> + <td><code>11</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>13</code></td> + </tr> + <tr> + <th scope="row">czwarte wywołanie</th> + <td><code>13</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>16</code></td> + </tr> + <tr> + <th scope="row">piąte wywołanie</th> + <td><code>16</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + </tbody> +</table> + +<p>Tym razem wartość zwrócona przez <code>reduce</code> będzie wynosiła <code>20</code>.</p> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<h3 id="Example_Sum_up_all_values_within_an_array" name="Example:_Sum_up_all_values_within_an_array">Przykład: Zsumowanie wszystkich wartości w tablicy.</h3> + +<pre class="brush: js">var total = [0, 1, 2, 3].reduce(function(a, b) { + return a + b; +}); +// total == 6 +</pre> + +<h3 id="Example_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Przykład: Spłaszczenie tablicy tablic</h3> + +<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) { + return a.concat(b); +}); +// flattened is [0, 1, 2, 3, 4, 5] +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p><code>Array.prototype.reduce</code> zostało dodane do standardu ECMA-262 w edycji piątej i jako takie może nie występować we wszystkich implementacji standardu. Można obejśc ten brak poprzez wstawienie poniższego kodu na początku skryptu, co pozwala na użycie <code>reduce</code> z implementacjami, które nie wspierają tej funkcji.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.21 +// Reference: http://es5.github.io/#x15.4.4.21 +if (!Array.prototype.reduce) { + Array.prototype.reduce = function(callback /*, initialValue*/) { + 'use strict'; + if (this == null) { + throw new TypeError('Array.prototype.reduce called on null or undefined'); + } + if (typeof callback !== 'function') { + throw new TypeError(callback + ' is not a function'); + } + var t = Object(this), len = t.length >>> 0, k = 0, value; + if (arguments.length == 2) { + value = arguments[1]; + } else { + while (k < len && !(k in t)) { + k++; + } + if (k >= len) { + throw new TypeError('Reduce of empty array with no initial value'); + } + value = t[k++]; + } + for (; k < len; k++) { + if (k in t) { + value = callback(value, t[k], k, t); + } + } + return value; + }; +} +</pre> + +<h2 id="Specifications" name="Specifications">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Stan</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definicja początkowa. Wprowadzon w JavaScript 1.8.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Wspierane przeglądarki</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.9")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("4.0")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Zobacz też</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduceRight()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/reduceright/index.html b/files/pl/web/javascript/referencje/obiekty/array/reduceright/index.html new file mode 100644 index 0000000000..fcb2b0e694 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/reduceright/index.html @@ -0,0 +1,344 @@ +--- +title: Array.prototype.reduceRight() +slug: Web/JavaScript/Referencje/Obiekty/Array/ReduceRight +translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>reduceRight()</strong></code> przekazuje do funkcji wartość przyrostową dla każdego elementu w tablicy zaczynając od prawej do lewej (od najwyższego indexu do najniższego) w celu sprowadzenia tablicy do pojedynczej wartości.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-reduce-right.html","shorter")}}</div> + + + +<p>Sprawdź również {{jsxref("Array.prototype.reduce()")}} dla redukowania tablicy od lewej do prawej (od najniższego indexu do najwyższego).</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>arr.reduceRight(callback(akumulator, obecnaWartość[, index[, tablica]])[, wartośćPoczątkowa])</var></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja która będzie wołana dla każdego elementu w tablicy, przyjmuje 4 argumenty: + <dl> + <dt><code>akumulator</code></dt> + <dd>Wartość zwrócona z poprzedniego wywołania funkcji <code>callback</code> lub <code>wartośćPoczątkowa</code>, jeśli została zdefiniowana. (Sprawdź poniżej.)</dd> + <dt><code>obecnaWartość</code></dt> + <dd>Element z tablicy, który aktualnie jest przetwarzany</dd> + <dt><code>index</code>{{optional_inline}}</dt> + <dd>Index aktualnie przetwarzanego elementu z tablicy.</dd> + <dt><code>tablica</code>{{optional_inline}}</dt> + <dd>Tablica, na której <code>reduceRight()</code> zostało zawołane.</dd> + </dl> + </dd> + <dt><code>wartośćPoczątkowa</code>{{optional_inline}}</dt> + <dd>Wartość, która zostanie użyta do pierwszego wykonania funkcji <code>callback</code>. Jeśli wartość ta nie zostanie zdefiniowana, ostatni element tablicy zostanie użyty i pominięty. Wołanie reduce lub reduceRight na pustej tablicy bez zdefiniowanej wartości początkowej spowoduje błąd <code>TypeError</code>.</dd> +</dl> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p>Wartość wynikowa redukcji.</p> + +<h2 id="Opis">Opis</h2> + +<p><code>reduceRight</code> wykonuje funkcję <code>callback</code> dla każdego elementu z tablicy, z wyłączeniem miejsc niezdefiniowanych w tablicy, przekazując cztery argumenty: wartość początkową (lub wartość z poprzedniego wywołania funkcji <code>callback</code>), wartość obecnie przetwarzanego elementu, obecny index oraz tablicę na której wykonywane są iteracje.</p> + +<p>Użycie funkcji <code>callback</code> w metodzie reduceRight może wyglądac następująco:</p> + +<pre class="brush: js">array.reduceRight(function(akumulator, obecnaWartość, index, tablica) { + // ... +}); +</pre> + +<p>Przy pierwszym wywołaniu funkcji, <code>akumulator</code> i <code>obecnaWartość</code> mogą mieć jedną z 2 wartości. Jeśli <code>wartośćPoczątkowa</code> została przekazana do <code>reduceRight</code>, to <code>akumulator</code> będzie równy <code>wartośćPoczątkowa</code> a <code>obecnaWartość</code> będzie równa ostatniej wartości z tablicy. Jeśli <code>wartośćPoczątkowa</code> nie została zdefiniowana, wtedy <code>akumulator</code> będzie równy ostatniej wartości z tablicy a <code>obecnaWartość</code> będzie równa przedostatniej wartości z tablicy.</p> + +<p>Jeśli tablica jest pusta i <code>wartośćPoczątkowa</code> nie została zdefiniowana, spowoduje to błąd: {{jsxref("TypeError")}}. Jeśli tablica ma tylko jeden element (niezależnie od jego pozycji) i <code>wartośćPoczątkowa</code> nie została zdefiniowana lub <code>wartośćPoczątkowa</code> została zdefiniowana ale tablica jest pusta, to ta pojedyncza wartość zostanie zwrócona bez wołania funkcji <code>callback</code>.</p> + +<p>Przykład pokazujący, jak przepływają dane do funkcji <code>callback</code>:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(akumulator, obecnaWartość, index, tablica) { + return akumulator + obecnaWartość; +}); +</pre> + +<p>Funkcja <code>callback</code> wykona się 4 razy a argumenty wywołań oraz wartości zwracane będą zgodne z poniższą tabelą:</p> + +<table> + <thead> + <tr> + <th scope="col"><code>callback</code></th> + <th scope="col"><code>akumulator</code></th> + <th scope="col"><code>obecnaWartość</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>tablica</code></th> + <th scope="col">zwrócona wartość</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">first call</th> + <td><code>4</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>7</code></td> + </tr> + <tr> + <th scope="row">second call</th> + <td><code>7</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>9</code></td> + </tr> + <tr> + <th scope="row">third call</th> + <td><code>9</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + <tr> + <th scope="row">fourth call</th> + <td><code>10</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + </tbody> +</table> + +<p>Wartość zwrócona przez <code>reduceRight</code> będzie tym, co zostało zwrócone przez ostatnie wywołanie funkcji <code>callback</code> (<code>10</code>).</p> + +<p>Jeśli <code>wartośćPoczątkowa</code> zostałaby zdefiniowana wyniki wyglądałyby następująco:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(akumulator, obecnaWartość, index, tablica) { + return akumulator + obecnaWartość; +}, 10); +</pre> + +<table> + <thead> + <tr> + <th scope="col"><code>callback</code></th> + <th scope="col"><code>akumulator</code></th> + <th scope="col"><code>obecnaWartość</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>tablica</code></th> + <th scope="col">zwrócona wartość</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">first call</th> + <td><code>10</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>14</code></td> + </tr> + <tr> + <th scope="row">second call</th> + <td><code>14</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>17</code></td> + </tr> + <tr> + <th scope="row">third call</th> + <td><code>17</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>19</code></td> + </tr> + <tr> + <th scope="row">fourth call</th> + <td><code>19</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + <tr> + <th scope="row">fifth call</th> + <td><code>20</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + </tbody> +</table> + +<p>Wartość zwrócona przez <code>reduceRight</code> w tym przypadku, będzie, oczywiście, <code>20</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Zsumuj_wszystkie_wartości_z_tablicy">Zsumuj wszystkie wartości z tablicy</h3> + +<pre class="brush: js">var sum = [0, 1, 2, 3].reduceRight(function(a, b) { + return a + b; +}); +// sum is 6 +</pre> + +<h3 id="Spłaszcz_tablicę_tablic">Spłaszcz tablicę tablic</h3> + +<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) { + return a.concat(b); +}, []); +// flattened is [4, 5, 2, 3, 0, 1] + +</pre> + +<h3 id="Uruchom_asynchroniczne_funkcje_z_callbackami_z_listy_w_taki_sposób_aby_każda_przekazywała_wynik_wykonania_do_następnej">Uruchom asynchroniczne funkcje z callbackami z listy w taki sposób aby każda przekazywała wynik wykonania do następnej</h3> + +<pre class="brush: js">const waterfall = (...functions) => (callback, ...args) => + functions.reduceRight( + (composition, fn) => (...results) => fn(composition, ...results), + callback + )(...args); + +const randInt = max => Math.floor(Math.random() * max) + +const add5 = (callback, x) => { + setTimeout(callback, randInt(1000), x + 5); +}; +const mult3 = (callback, x) => { + setTimeout(callback, randInt(1000), x * 3); +}; +const sub2 = (callback, x) => { + setTimeout(callback, randInt(1000), x - 2); +}; +const split = (callback, x) => { + setTimeout(callback, randInt(1000), x, x); +}; +const add = (callback, x, y) => { + setTimeout(callback, randInt(1000), x + y); +}; +const div4 = (callback, x) => { + setTimeout(callback, randInt(1000), x / 4); +}; + +const computation = waterfall(add5, mult3, sub2, split, add, div4); +computation(console.log, 5) // -> 14 + +// same as: + +const computation2 = (input, callback) => { + const f6 = x=> div4(callback, x); + const f5 = (x, y) => add(f6, x, y); + const f4 = x => split(f5, x); + const f3 = x => sub2(f4, x); + const f2 = x => mult3(f3, x); + add5(f2, input); +}</pre> + +<h3 id="Różnica_pomiędzy_reduce_i_reduceRight">Różnica pomiędzy <code>reduce</code> i <code>reduceRight</code></h3> + +<pre class="brush: js">var a = ['1', '2', '3', '4', '5']; +var left = a.reduce(function(prev, cur) { return prev + cur; }); +var right = a.reduceRight(function(prev, cur) { return prev + cur; }); + +console.log(left); // "12345" +console.log(right); // "54321"</pre> + +<h3 id="Przykład_na_rozwijanie_funkcji">Przykład na rozwijanie funkcji</h3> + +<p>W rozwijaniu funkcji chodzi o to, że w wywołaniu jednej funkcji możemy użyć wielu funkcji. Odbywa się to od prawej do lewej, wołając każdą funkcję z wynikiem zwróconym przez poprzednią.</p> + +<pre class="brush: js">/** + * Function Composition is way in which result of one function can + * be passed to another and so on. + * + * h(x) = f(g(x)) + * + * Function execution happens right to left + * + * https://en.wikipedia.org/wiki/Function_composition + */ + +const compose = (...args) => (value) => args.reduceRight((acc, fn) => fn(acc), value) + +// Increment passed number +const inc = (n) => n + 1 + +// Doubles the passed value +const double = (n) => n * 2 + +// using composition function +console.log(compose(double, inc)(2)); // 6 + +// using composition function +console.log(compose(inc, double)(2)); // 5 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>reduceRight</code> zostało dodane dostandardu ECMA-262 w piątej edycji, w związku z czym może jeszcze nie być dodane do wszystkich implementacji standardu. Można to rozwiązać poprzez użycie poniższego kodu na początku aplikacji, pozwoli to na używanie <code>reduceRight</code> w środowiskach, które tego nie implementują.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.22 +// Reference: http://es5.github.io/#x15.4.4.22 +if ('function' !== typeof Array.prototype.reduceRight) { + Array.prototype.reduceRight = function(callback /*, initialValue*/) { + 'use strict'; + if (null === this || 'undefined' === typeof this) { + throw new TypeError('Array.prototype.reduce called on null or undefined'); + } + if ('function' !== typeof callback) { + throw new TypeError(callback + ' is not a function'); + } + var t = Object(this), len = t.length >>> 0, k = len - 1, value; + if (arguments.length >= 2) { + value = arguments[1]; + } else { + while (k >= 0 && !(k in t)) { + k--; + } + if (k < 0) { + throw new TypeError('Reduce of empty array with no initial value'); + } + value = t[k--]; + } + for (; k >= 0; k--) { + if (k in t) { + value = callback(value, t[k], k, t); + } + } + return value; + }; +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_w_przeglądarkach">Zgodność w przeglądarkach</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.reduceRight")}}</p> +</div> + +<h2 id="Sprawdź_również">Sprawdź również</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduce()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/reverse/index.html b/files/pl/web/javascript/referencje/obiekty/array/reverse/index.html new file mode 100644 index 0000000000..bc6fd9082b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/reverse/index.html @@ -0,0 +1,55 @@ +--- +title: Array.prototype.reverse() +slug: Web/JavaScript/Referencje/Obiekty/Array/reverse +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Odwraca kolejność elementów w tablicy: pierwszy staje się ostatnim, ostatni pierwszym.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.reverse()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>reverse</code> zmienia zawartość tablicy, odwracając kolejność jej elementów.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Odwracanie_kolejno.C5.9Bci_element.C3.B3w_w_tablicy" name="Przyk.C5.82ad:_Odwracanie_kolejno.C5.9Bci_element.C3.B3w_w_tablicy">Przykład: Odwracanie kolejności elementów w tablicy</h3> + +<p>Poniższy przykład tworzy tablicę mojaTablica, posiadającą trzy elementy, następnie odwraca ich kolejność.</p> + +<pre class="brush: js">mojaTablica = new Array("jeden", "dwa", "trzy") +mojaTablica.reverse() +</pre> + +<p>W wyniku działania powyższego kodu:</p> + +<ul> + <li><code>mojaTablica[0]</code> ma wartość "trzy"</li> + <li><code>mojaTablica[1]</code> ma wartość "dwa"</li> + <li><code>mojaTablica[2]</code> ma wartość "jeden"</li> +</ul> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.join()")}}</li> + <li>{{jsxref("Array.prototype.sort()")}}</li> + <li>{{jsxref("TypedArray.prototype.reverse()")}}</li> +</ul> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/referencje/obiekty/array/shift/index.html b/files/pl/web/javascript/referencje/obiekty/array/shift/index.html new file mode 100644 index 0000000000..adf8ca36e4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/shift/index.html @@ -0,0 +1,48 @@ +--- +title: Array.prototype.shift() +slug: Web/JavaScript/Referencje/Obiekty/Array/shift +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Usuwa pierwszy element z tablicy i zwraca go. Metoda ta zmienia długość tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.shift()</code></pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Usuwanie_pierwszego_elementu_tablicy" name="Przyk.C5.82ad:_Usuwanie_pierwszego_elementu_tablicy">Przykład: Usuwanie pierwszego elementu tablicy</h3> + +<p>Następujący kod wyświetli tablicę <code>myFish</code>, przed i po usunięciu jej pierwszego elementu. Wyświetli również usunięty element:</p> + +<pre class="brush: js">// przyjmując że funkcja print jest zdefiniowana +var myFish = ["anioł", "klaun", "mandarynka", "chirurg"]; +console.log("myFish przed: " + myFish); +var shifted = myFish.shift(); +console.log("myFish po: " + myFish); +console.log("Usunięto element: " + shifted); +</pre> + +<p>Przykład wyświetli następujący rezultat:</p> + +<pre class="brush: js">myFish przed: ["anioł", "klaun", "mandarynka", "chirurg"] +myFish po: ["klaun", "mandarynka", "chirurg"] +//Usunięto element: anioł +</pre> + +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/slice/index.html b/files/pl/web/javascript/referencje/obiekty/array/slice/index.html new file mode 100644 index 0000000000..ced8efba96 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/slice/index.html @@ -0,0 +1,99 @@ +--- +title: Array.prototype.slice() +slug: Web/JavaScript/Referencje/Obiekty/Array/slice +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice +--- +<p>{{ JSRef }}</p> + +<p>{{EmbedInteractiveExample("pages/js/array-slice.html")}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wydobywa fragment tablicy i zwraca go jako nową tablicę.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.slice([<var>begin</var>[, <var>end</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>begin</code></dt> + <dd>Indeks (liczony od zera) od którego zaczyna się wydobywanie.</dd> + <dd>Jeżeli indeks jest ujemny, <code>begin</code> wskazuje przesunięcie w kolejności od końca. <code>slice(-2)</code> wydobywa kolejno drugi od końca i ostatni element tablicy.</dd> +</dl> + +<dl> + <dt><code>end</code></dt> + <dd>Indeks (liczony od zera) przed którym kończy się wydobywanie. <code>slice</code> wydobywa elementy jednakże nie zawiera <code>end</code>.</dd> +</dl> + +<dl> + <dd><code>slice(1,4)</code> wydobywa elementy od drugiego do czwartego (o indeksach 1, 2 i 3).</dd> +</dl> + +<dl> + <dd>Jeżeli parametr ten ma wartość ujemną to <code>end</code> określa odległość od końca tablicy. <code>slice(2,-1)</code> wydobywa kolejne elementy od trzeciego do przedostatniego.</dd> +</dl> + +<dl> + <dd>Jeżeli <code>end</code> jest pominięty, <code>slice</code> wydobywa wszystkie elementy do końca tablicy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>slice</code> nie zmienia zawartości oryginalnej tablicy, tylko zwraca nową kopię "o jednym poziomie głębokości" zawierającą elementy wyciągnięte z oryginalnej tablicy. Elementy oryginalnej tablicy są kopiowane do nowej tablicy następująco:</p> + +<ul> + <li>W przypadku referencji do obiektów (nie obiektów właściwych), <code>slice</code> kopiuje referencje do nowej tablicy. Obydwie - oryginalna i nowa tablica - odnoszą się do tego samego obiektu. Jeżeli zmienimy obiekt odniesienia, zmiany są widoczne dla obydwu tablic, nowej i oryginalnej.</li> +</ul> + +<ul> + <li>Dla łańcuchów znaków i liczb (nie będących obiektami {{jsxref("String")}} i {{jsxref("Number")}}, <code>slice</code> kopiuje łańcuchy znaków i liczby do nowej tablicy. Zmiana łańcucha znaków lub liczby w jednej z tablic nie wpływa na wartość w drugiej.</li> +</ul> + +<p>Jeżeli nowy element jest dodany do jednej z tablic, to nie wpływa to w żaden sposób na drugą.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_slice" name="Przyk.C5.82ad:_Zastosowanie_slice">Przykład: Zastosowanie <code>slice</code></h3> + +<p>W następującym przykładzie <code>slice</code> tworzy nową tablicę <code>newCar</code> z <code>myCar</code>. Obydwie zawierają odniesienie do obiektu <code>myHonda</code>. Kiedy kolor <code>myHonda</code> jest zmieniany na purpurowy, to obie tablice odzwierciedlają zmianę.</p> + +<pre class="brush: js">//Użycie slice, tworzenie newCar z myCar. +var myHonda = { color: "red", wheels: 4, engine: { cylinders: 4, size: 2.2 } }; +var myCar = [myHonda, 2, "cherry condition", "purchased 1997"]; +var newCar = myCar.slice(0, 2); + +//Wpisz wartości myCar, newCar i color myHonda +// referenced from both arrays. +console.log("myCar = " + myCar.toSource()); +console.log("newCar = " + newCar.toSource()); +console.log("myCar[0].color = " + myCar[0].color); +console.log("newCar[0].color = " + newCar[0].color); + +//zmienia kolor myHonda. +myHonda.color = "purple"; +console.log("Nowy kolor mojej Honda to " + myHonda.color); + +//Wpisz color myHonda odnoszący się do oby tablic +console.log("myCar[0].color = " + myCar[0].color); +console.log("newCar[0].color = " + newCar[0].color); +</pre> + +<p>Ten skrypt wypisze:</p> + +<pre class="brush: js">myCar = [{color:"red", wheels:4, engine:{cylinders:4, size:2.2}}, 2, "cherry condition", "purchased 1997"] +newCar = [{color:"red", wheels:4, engine:{cylinders:4, size:2.2}}, 2] +myCar[0].color = red +newCar[0].color = red +Nowym kolorem mojej Honda jest purpurowy +myCar[0].color = purple +newCar[0].color = purple +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/array/some/index.html b/files/pl/web/javascript/referencje/obiekty/array/some/index.html new file mode 100644 index 0000000000..6ba1777370 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/some/index.html @@ -0,0 +1,110 @@ +--- +title: Array.prototype.some() +slug: Web/JavaScript/Referencje/Obiekty/Array/some +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/some +--- +<p>{{ JSRef }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Sprawdza, czy jakikolwiek element tablicy zalicza test zaimplementowany przez dostarczoną funkcję .</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.some(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code> </dt> + <dd>Funkcja sprawdzająca dla każdego elementu.</dd> + <dt><code>thisArg</code></dt> + <dd>Obiekt do użycia jako <code>this</code> gdy wykonujemy funkcję <code>callback</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>some</code> wykonuje funkcję <code>callback</code>) na każdym elemencie tablicy, aż znajdzie taki, dla którego <code>callback</code> zwróci prawdę (<code>true</code>). Jeżeli taki element zostanie znaleziony, <code>some</code> zakończy swoje działanie i zwróci prawdę (<code>true</code>), w przeciwnym przypadku (gdy <code>callback</code> zwróci fałsz dla każdego z elementów) <code>some</code> zwróci <code>false</code>. Tablice nie są traktowane jako "zwarte" - czyli <code>callback</code> zostanie wywołany dla każdego indeksu tablicy dla którego wartość została przypisana. Nie zostanie wywołany dla indeksów, które zostały usunięte, bądź dla których nigdy nie została przypisana wartość.</p> + +<p><code>callback</code> wywoływana jest z trzema argumentami: wartością elementu, jego indeksem i przemierzaną tablicą.</p> + +<p>W przypadku podania argumentu <code>thisObject</code>, zostanie on przekazany jako <code>this</code> przy każdym wywołaniu <code>callback</code>. Gdy go brak, lub ma wartość <code>null</code>, użyty zostanie obiekt globalny przyporządkowany do <code>callback</code>.</p> + +<p><code>some</code> nie modyfikuje tablicy, na której jest wywołany.</p> + +<p>Zakres elementów przetwarzanych przez <code>some</code> ustalany jest przed pierwszym wywołaniem <code>callback</code>. Elementy dodane do tablicy po wywołaniu <code>some</code> nie zostaną sprawdzone przez <code>callback</code>. Jeśli istniejący, niesprawdzony jeszcze element tablicy zostanie zmieniony lub usunięty przez <code>callback</code>, wartością przekazaną do <code>callback</code> będzie wartość z momentu, w którym <code>some</code> sprawdza dany element; elementy usunięte przed sprawdzeniem będą przekazane jako <code>undefined</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy">Sprawdzanie rozmiaru wszystkich elementów tablicy</h3> + +<p>Następujący przykład sprawdza czy jakiś element tablicy jest większy, bądź równy 10.</p> + +<pre class="brush: js">function czyWiekszyNiz10(element, index, array) { + return element > 10; +} +[2, 5, 8, 1, 4].some(czyWiekszyNiz10); // false +[12, 5, 8, 1, 44].some(czyWiekszyNiz10); // true +</pre> + +<h3 id="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy">Sprawdzanie elementów używając funkcji strzałkowych</h3> + +<p>Funkcje strzałkowe dają krótszą składnię dla tego samego testu.</p> + +<pre class="brush: js">[2, 5, 8, 1, 4].some(x => x > 10); // false +[12, 5, 8, 1, 44].some(x => x > 10); // true +</pre> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<table> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> + +<table> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.8")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> diff --git a/files/pl/web/javascript/referencje/obiekty/array/sort/index.html b/files/pl/web/javascript/referencje/obiekty/array/sort/index.html new file mode 100644 index 0000000000..2b53d4e6d5 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/sort/index.html @@ -0,0 +1,122 @@ +--- +title: Array.prototype.sort() +slug: Web/JavaScript/Referencje/Obiekty/Array/sort +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Sortuje elementy tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.sort([<var>compareFunction</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>compareFunction</code> </dt> + <dd>jest nazwą funkcji porównującej elementy. Jeżeli parametr zostanie pominięty, tablica będzie posortowana w porządku leksykograficznym (alfabetycznie).</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeżeli <code>compareFunction</code> nie zostanie podana, elementy zostaną posortowane leksykograficznie (alfabetycznie - słownikowo) według porównania ich reprezentacji znakowej (łańcucha znaków). Przykładowo "80" znajdzie się przed "9" w porządku leksykograficznym, pomimo że numerycznie 9 poprzedza 80.</p> + +<p>Jeżeli <code>compareFunction</code> zostanie podana, elementy tablicy zostaną posortowane odpowiednio do wartości zwracanej przez funkcję porównującą. Jeżeli <code>a</code> oraz <code>b</code> są dwoma porównywanymi elementami tablicy to:</p> + +<ul> + <li><code>compareFunction(a, b)</code> zwróci wartość mniejszą od 0 - indeks elementu <code>a</code> będzie mniejszy niż indeks <code>b</code> (logicznie <code>a</code> < <code>b</code>).</li> +</ul> + +<ul> + <li><code>compareFunction(a, b)</code> zwróci 0 - pozostawia <code>a</code> oraz <code>b</code> w niezmienionej kolejności względem siebie, jednak w dalszym ciągu oba będą porównywane z innymi elementami (logicznie <code>b</code> = <code>a</code>). Uwaga: Standard ECMAscript nie gwarantuje niezmienionej kolejności (np. Mozilla wszystkie wersje do 2003 roku).</li> +</ul> + +<ul> + <li><code>compareFunction(a, b)</code> zwraca wartość większą od 0 - indeks elementu <code>a</code> będzie większy niż indeks <code>b</code> (logicznie <code>a</code> > <code>b</code>).</li> +</ul> + +<p>Ogólna postać funkcji porównującej wygląda następująco:</p> + +<pre class="brush: js">function compare(a, b) { + if (a mniejsze niż b według kryteriów sortowania) + return -1 + if (a większe od b według kryteriów sortowania) + return 1 + // a równe b + return 0 +} +</pre> + +<p>W celu porównania liczb, zamiast napisów, funkcja porównująca może odejmować <code>b</code> od <code>a</code>:</p> + +<pre class="brush: js">function compareNumbers(a, b) { + return a - b +} +</pre> + +<p>Niektóre implementacje JavaScript wykonują sortowanie stabilne: kolejność elementów <code>a</code> i <code>b</code> nie jest zmieniana jeśli <code>a</code> i <code>b</code> są sobie równe. Jeżeli przed sortowaniem <code>a</code> jest w tablicy wcześniej niż <code>b</code> oraz <code>a</code> i <code>b</code> są sobie równe, to po sortowaniu ich kolejność będzie taka sama (niezależnie od tego, jak zmienią się pozycje elementów <code>a</code> i <code>b</code>).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Tworzenie.2C_wy.C5.9Bwietlanie_i_sortowanie_tablic" name="Przyk.C5.82ad:_Tworzenie.2C_wy.C5.9Bwietlanie_i_sortowanie_tablic">Przykład: Tworzenie, wyświetlanie i sortowanie tablic</h3> + +<p>Następujący przykład tworzy cztery tablice i wyświetla oryginalną tablicę, potem posortowane tablice. Tablice liczbowe są sortowane najpierw bez podania funkcji porównującej, następnie z taką funkcją.</p> + +<pre class="brush: js">stringArray = new Array("Blue","Humpback","Beluga") +numericStringArray = new Array("80","9","700") +numberArray = new Array(40,1,5,200) +mixedNumericArray = new Array("80","9","700",40,1,5,200) + +function compareNumbers(a, b) { + return a - b +} + +console.log("tablicaNapisów: " + stringArray.join()) +console.log("Posortowana: " + stringArray.sort()) + +console.log("tablicaLiczbowa: " + numberArray.join()) +console.log("Posortowana bez funkcji porównującej: " + numberArray.sort()) +console.log("Posortowana z funkcją porównującą: " + numberArray.sort(compareNumbers)) + +console.log("tablicaNapisówLiczbowych: " + numericStringArray.join()) +console.log("Posortowana bez funkcji porównującej: " + numericStringArray.sort()) +console.log("Posortowana z funkcją porównującą: " + numericStringArray.sort(compareNumbers)) + +console.log("tablicaLiczbowaMieszna: " + mixedNumericArray.join()) +console.log("Posortowana bez funkcji porównującej: " + mixedNumericArray.sort()) +console.log("Posortowana z funkcją porównującą: " + mixedNumericArray.sort(compareNumbers)) +</pre> + +<p>Ten przykład wyświetla następujące dane. Jak widać, przy zastosowaniu funkcji porównującej, liczby są sortowane prawidłowo niezależnie od tego czy są przedstawiane jako wartości liczbowe bądź też napisy.</p> + +<pre>tablicaNapisów: Blue,Humpback,Beluga +Posortowana: Beluga,Blue,Humpback + +tablicaLiczbowa: 40,1,5,200 +Posortowana bez funkcji porównującej: 1,200,40,5 +Posortowana z funkcją porównującą: 1,5,40,200 + +tablicaNapisówLiczbowych: 80,9,700 +Posortowana bez funkcji porównującej: 700,80,9 +Posortowana z funkcją porównującą: 9,80,700 + +tablicaLiczbowaMieszna: 80,9,700,40,1,5,200 +Posortowana bez funkcji porównującej: 1,200,40,5,700,80,9 +Posortowana z funkcją porównującą: 1,5,9,40,80,200,700 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.reverse()")}}</li> + <li>{{jsxref("String.prototype.localeCompare()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/splice/index.html b/files/pl/web/javascript/referencje/obiekty/array/splice/index.html new file mode 100644 index 0000000000..cc4d13def3 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/splice/index.html @@ -0,0 +1,86 @@ +--- +title: Array.prototype.splice() +slug: Web/JavaScript/Referencje/Obiekty/Array/splice +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zmienia zawartość tablicy, dodając nowe elementy podczas usuwania starych elementów.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>array</var>.splice(<var>start</var>, <var>deleteCount</var>[, <var>item1</var>[, <var>item2</var>[, ...]]]) +</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>start</code></dt> + <dd>Indeks od którego rozpoczynamy modyfikację tablicy.</dd> +</dl> + +<dl> + <dt><code>deleteCount</code></dt> + <dd>Liczba całkowita określająca liczbę starych elementów tablicy do usunięcia. Jeżeli <font face="Consolas, Monaco, Andale Mono, monospace">deleteCount</font> wynosi 0, nic nie zostanie usunięte. W tym przypadku należy podać co najmniej jeden nowy element. W przypadku gdy parametr <font face="Consolas, Monaco, Andale Mono, monospace">deleteCount</font> nie został podany (druga forma składni podana powyżej, która jest rozszerzeniem SpiderMonkey), wszystkie elementy o indeksach wyższych <code>lub równych index</code> są usuwane.</dd> +</dl> + +<dl> + <dt><code>itemN</code></dt> + <dd>Elementy dodawane do tablicy. Jeżeli nie określimy żadnych elementów, <code>splice</code> usunie tylko podaną liczbę elementów.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeżeli podamy różną liczbę wstawianych elementów od liczby usuwanych elementów, tablica będzie posiadała inną długość po wywołaniu metody <code>splice</code>.</p> + +<p>Metoda <code>splice</code> zwraca tablicę zawierającą usunięte elementy. Jeżeli usunięty został tylko jeden element, zwracana jest tablica jednoelementowa.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_splice" name="Przyk.C5.82ad:_Zastosowanie_splice">Przykład: Zastosowanie <code>splice</code></h3> + +<p>Następujący skrypt ilustruje użycie splice:</p> + +<pre class="brush: js">myFish = ["anioł", "klaun", "mandarynka", "jesiotr"]; +console.log("myFish: " + myFish); + +removed = myFish.splice(2, 0, "bęben"); +console.log("Po dodaniu 1: " + myFish); +console.log("Usunięty jest: " + removed); + +removed = myFish.splice(3, 1) +console.log("Po usunięciu 1: " + myFish); +console.log("Usunięty jest: " + removed); + +removed = myFish.splice(2, 1, "trąba") +console.log("Po zastąpieniu 1: " + myFish); +console.log("Usunięty jest: " + removed); + +removed = myFish.splice(0, 2, "papuga", "zawilec", "niebieski") +console.log("Po zastąpieniu 2: " + myFish); +console.log("Usunięty jest: " + removed); +</pre> + +<p>Ten skrypt wyświetli:</p> + +<pre>myFish: ["anioł", "klaun", "mandarynka", "jesiotr"] + +Po dodaniu 1: ["anioł", "klaun", "bęben", "mandarynka", "jesiotr"] +Usunięty jest: undefined + +Po usunięciu 1: ["anioł", "klaun", "bęben, "jesiotr"] +Usunięty jest: mandarynka + +Po zastąpieniu 1: ["anioł", "klaun", "trąba", "jesiotr"] +Usunięty jest: bęben + +Po zastąpieniu 2: ["papuga", "zawilec", "niebieski", "trąba", "jesiotr"] +Usunięty jest: ["anioł", "klaun"] +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/array/tolocalestring/index.html b/files/pl/web/javascript/referencje/obiekty/array/tolocalestring/index.html new file mode 100644 index 0000000000..1dc476c413 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/tolocalestring/index.html @@ -0,0 +1,128 @@ +--- +title: Array.prototype.toLocaleString() +slug: Web/JavaScript/Referencje/Obiekty/Array/toLocaleString +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +--- +<div>{{JSRef}}</div> + +<div>Metoda <code><strong>toLocaleString()</strong></code> zwraca łańcuch znaków reprezentujący wszystkie elementy w tablicy. Każdy element jest konwerterowany do łańcucha znaku za pomocą lokalnych wywołań <code>toLocaleString. Elementy </code>łaczone są separatorem zdefiniowanym dla lokalnego języka (np. przecinek).</div> + +<div></div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.toLocaleString();</code></pre> + +<h2 id="Opis">Opis</h2> + +<p>Poniższe elementy tablic są konwertowane na łańcuchy znaków za pomocą wbudowanych metod <code>toLocaleString</code></p> + +<ul> + <li><code>Object</code>: {{jsxref("Object.prototype.toLocaleString()")}}</li> + <li><code>Number</code>: {{jsxref("Number.prototype.toLocaleString()")}}</li> + <li><code>Date</code>: {{jsxref("Date.prototype.toLocaleString()")}}</li> +</ul> + +<h2 id="Przykład">Przykład</h2> + +<h3 id="Użycie_toLocaleString">Użycie <code>toLocaleString</code></h3> + +<pre class="notranslate">let numer = 1337; +let data = new Date(); +let tablica = [numer , data, 'foo']; + +let str = tablica.toLocaleString(); + +console.log(str); +// logs '1337,19.11.2020, 17:21:06,foo' +// if run in a Polish (pl-PL) locale with timezone Europe/Warsaw + + +let strEn = tablica.toLocaleString("en-US"); // "1,337,11/19/2020, 5:21:06 PM,foo"</pre> + + + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarze</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Inicjalna definicja</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.4.3', 'Array.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/tosource/index.html b/files/pl/web/javascript/referencje/obiekty/array/tosource/index.html new file mode 100644 index 0000000000..675e8431a2 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/tosource/index.html @@ -0,0 +1,62 @@ +--- +title: Array.prototype.toSource() +slug: Web/JavaScript/Referencje/Obiekty/Array/toSource +tags: + - Array + - JavaScript + - Method + - Non-standard + - Prototype + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.toSource()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toSource</code> zwraca następujące wartości:</p> + +<p><span class="comment">This shouldn't be here, but until reorganization where pages are moved to their proper places, the title of this article is ambiguous, so it can stay. After reorganization, this should be removed.</span></p> + +<ul> + <li>Dla wbudowanego obiektu <code>Array</code>, <code>toSource</code> zwraca następujący łańcuch znaków sygnalizując, że kod źródłowy jest niedostępny: + + <pre class="brush: js">function Array() { + [natywny kod] +} +</pre> + </li> + <li>Dla instancji {{jsxref("Array")}}, <code>toSource</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Metoda ta jest zazwyczaj wywoływana wewnętrznie przez JavaScript, a nie bezpośrednio w kodzie. Możliwe jest wywołanie <code>toSource</code> podczas debugowania, aby zbadać zawartość tablicy.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Sprawdzanie_kodu_.C5.BAr.C3.B3d.C5.82owego_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_kodu_.C5.BAr.C3.B3d.C5.82owego_tablicy">Przykład: Sprawdzanie kodu źródłowego tablicy</h3> + +<p>Do sprawdzania kodu źródłowego tablicy:</p> + +<pre class="brush: js">var alpha = new Array("a", "b", "c"); + +alpha.toSource() //zwraca ["a", "b", "c"] +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("Array.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/array/tostring/index.html new file mode 100644 index 0000000000..e4801cbdc4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/tostring/index.html @@ -0,0 +1,42 @@ +--- +title: Array.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/Array/toString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>toString()</strong></code> zwraca łańcuch znaków reprezentujący daną tablicę wraz z jej elementami.</p> + +<pre class="brush: js">var months = ['Styczeń', 'Luty', 'Marzec', 'Kwiecień']; +months.toString(); // "Styczeń,Luty,Marzec,Kwiecień" +</pre> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.toString()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Array")}} przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}. Dla obiektów Array, metoda <code>toString</code> łączy tablicę i zwraca jeden łańcuch znaków zawierający wszystkie elementy tablicy oddzielone przecinkami. Przykładowo poniższy kod tworzy tablicę i stosuje metodę <code>toString</code>, aby przekształcić tablicę do łańcucha znaków.</p> + +<pre class="brush: js">var monthNames = new Array("Jan","Feb","Mar","Apr") +var myVar = monthNames.toString() // przypisuje "Jan,Feb,Mar,Apr" do zmiennej myVar +</pre> + +<p>JavaScript wywołuje metodę <code>toString</code> automatycznie, gdy tablica jest traktowana jako wartość tekstowa lub kiedy istnieje odniesienie do tej tablicy wewnątrz połączonego łańcucha znaków.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("Array.prototype.join()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/unshift/index.html b/files/pl/web/javascript/referencje/obiekty/array/unshift/index.html new file mode 100644 index 0000000000..56346f6552 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/unshift/index.html @@ -0,0 +1,56 @@ +--- +title: Array.prototype.unshift() +slug: Web/JavaScript/Referencje/Obiekty/Array/unshift +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Dodaje jeden lub więcej elementów na początek tablicy i zwraca jej nową długość.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>arr</var>.unshift([<var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>element + <i>N</i> + </code> </dt> + <dd>Elementy do dodania na początek tablicy.</dd> +</dl> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy" name="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy">Przykład: Dodawanie elementów do tablicy</h3> + +<p>Następujący kod wyświetli tablicę <code>myFish</code> przed i po dodaniu do niej elementów.</p> + +<pre class="brush: js">myFish = ["anioł", "klaun"]; +console.log("myFish przed: " + myFish); +unshifted = myFish.unshift("bęben", "lew"); +console.log("myFish po: " + myFish); +console.log("Nowa długość tablicy: " + unshifted); +</pre> + +<p>Powyższy przykład wyświetli:</p> + +<pre>myFish przed: ["anioł", "klaun"] +myFish po: ["bęben", "lew", "anioł", "klaun"] +Nowa długość tablicy: 4 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/array/values/index.html b/files/pl/web/javascript/referencje/obiekty/array/values/index.html new file mode 100644 index 0000000000..b079877dd9 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/array/values/index.html @@ -0,0 +1,84 @@ +--- +title: Array.prototype.values() +slug: Web/JavaScript/Referencje/Obiekty/Array/values +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Metodă + - Prototype + - Tablica +translation_of: Web/JavaScript/Reference/Global_Objects/Array/values +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>values()</code></strong> zwraca nowy obiekt <strong><code>Array Iterator</code></strong> , który zawiera wartości dla każdego indeksu w tablicy.</p> + +<pre class="brush: js">var a = ['w', 'y', 'k', 'o', 'p']; +var iterator = a.values(); + +console.log(iterator.next().value); // w +console.log(iterator.next().value); // y +console.log(iterator.next().value); // k +console.log(iterator.next().value); // o +console.log(iterator.next().value); // p</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>arr</var>.values()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy obiekt {{jsxref("Array")}} iterator.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Iteracja_używająca_pętli_for...of">Iteracja używająca pętli <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code></h3> + +<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p']; +var iterator = arr.values(); + +for (let letter of iterator) { + console.log(letter); +} +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.values', 'Array.prototype.values')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.values', 'Array.prototype.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.values")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/arraybuffer/index.html b/files/pl/web/javascript/referencje/obiekty/arraybuffer/index.html new file mode 100644 index 0000000000..f01e0fa67c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/arraybuffer/index.html @@ -0,0 +1,222 @@ +--- +title: ArrayBuffer +slug: Web/JavaScript/Referencje/Obiekty/ArrayBuffer +tags: + - ArrayBuffer + - JavaScript + - Konstruktor + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +--- +<div>{{JSRef}}</div> + +<p>Objekt<strong> <code>ArrayBuffer</code></strong> reprezentuje buffer z surowymi danymi binarnymi o niezmiennej długości. Nie możesz bezpośrednio wpływać na zawartość obiektu <code><strong>ArrayBuffer</strong></code>, możesz natomiast stworzyć jeden z obiektów<code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">typedArray</a></code> lub obiekt {{jsxref("DataView")}} reprezentujący buffer w specjalnym formacie i używać tego obiektu do odczytu oraz zapisu treści buffera.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">new ArrayBuffer(length) +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>długość<code>(length)</code></dt> + <dd>Rozmiar, w bajtach, tworzony z bufferu tablicy (array buffer).</dd> +</dl> + +<h3 id="Wartość_zwrócona">Wartość zwrócona</h3> + +<p>Nowy obiekt <code>ArrayBuffer</code> o określonym rozmiarze. Jego wartości początkowe wynoszą 0.</p> + +<h3 id="Wyjątki">Wyjątki</h3> + +<p>{{jsxref("RangeError")}} pojawi się, jeśli długość (<code>length</code>) jest większa niż {{jsxref("Number.MAX_SAFE_INTEGER")}} (>= 2 ** 53) lub ujemna.</p> + +<h2 id="Opis">Opis</h2> + +<p>Konstruktor <code>ArrayBuffer</code> tworzy nowy <code>ArrayBuffer </code>z podanej długości (<code>length</code>) w bajtach.</p> + +<h3 id="Otrzymywanie_bufferu_tablicy_z_istniejących_danych">Otrzymywanie bufferu tablicy z istniejących danych</h3> + +<ul> + <li><a href="/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">ze stringa Base64</a></li> + <li><a href="/en-US/docs/Web/API/FileReader#readAsArrayBuffer()">z lokalnego pliku</a></li> +</ul> + +<h2 id="Właściwości">Właściwości</h2> + +<dl> + <dt><code>ArrayBuffer.length</code></dt> + <dd>Właściwość długości konstruktura <code>ArrayBuffer</code>, której wartość wynosi 1.</dd> + <dt>{{jsxref("ArrayBuffer.@@species", "get ArrayBuffer[@@species]")}}</dt> + <dd>Funkcja konstruktora jest używana do tworzenia dostarczanych obiektów.</dd> + <dt>{{jsxref("ArrayBuffer.prototype")}}</dt> + <dd>Pozwala dodać właściwości do wszystkich obiektów <code>ArrayBuffer</code>.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("ArrayBuffer.isView", "ArrayBuffer.isView(arg)")}}</dt> + <dd>Zwraca <code>true</code>, jeśli <code>arg</code> jest jednym z widoków <code>ArrayBuffer</code>, jak obiekty <code>typedArray</code> lub {{jsxref("DataView")}}. W innych przypadkach zwraca <code>false</code>.</dd> + <dt>{{jsxref("ArrayBuffer.transfer", "ArrayBuffer.transfer(oldBuffer [, newByteLength])")}} {{experimental_inline}}</dt> + <dd> + <div class="line" id="file-arraybuffer-transfer-LC6">Zwraca nowy <code>ArrayBuffer</code>, którego zawartości są pobrane z danych <code>oldBuffer</code>. Następnie zostaje skrócony lub przedłużony od 0 przez <code>newByteLength</code>.</div> + </dd> +</dl> + +<h2 id="Instancje_ArrayBuffer"><code>Instancje ArrayBuffer</code></h2> + +<p>Wszystkie instancje <code>ArrayBuffer </code>dziedziczą z {{jsxref("ArrayBuffer.prototype")}}.</p> + +<h3 id="Właściwości_2">Właściwości</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Properties')}}</p> + +<h3 id="Metody_2">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Methods')}}</p> + +<dl> + <dt>{{jsxref("ArrayBuffer.slice()")}} {{non-standard_inline}}</dt> + <dd>Posiada tę samą funkcjonalność, jak {{jsxref("ArrayBuffer.prototype.slice()")}}.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<p>W niniejszym przykładzie tworzymy 8-bajtowy buffer z widokiem {{jsxref("Global_Objects/Int32Array", "Int32Array")}} odnoszącym się do buffera:</p> + +<pre class="brush: js">var buffer = new ArrayBuffer(8); +var view = new Int32Array(buffer);</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Zastępiony przez ECMAScript 6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definicja początkowa w standardzie ECMA. Zgłasza, że wymagany jest <code>new</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Cecha</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Wsparcie podstawowe</td> + <td>7.0</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>10</td> + <td>11.6</td> + <td>5.1</td> + </tr> + <tr> + <td><code>ArrayBuffer()</code> bez odsyłacza <code>new</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("44")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>ArrayBuffer.slice()</code> {{non-standard_inline}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}<br> + {{CompatNo}} {{CompatGeckoDesktop("53")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Cecha</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Wsparcie podstawowe</td> + <td>4.0</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("2")}}</td> + <td>10</td> + <td>11.6</td> + <td>4.2</td> + </tr> + <tr> + <td><code>ArrayBuffer()</code> bez odsyłacza <code>new</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("44")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>ArrayBuffer.slice()</code> {{non-standard_inline}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}<br> + {{CompatNo}} {{CompatGeckoMobile("53")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zapis_kompatybilny">Zapis kompatybilny</h2> + +<p>Od ECMAScript 2015 kontruktory <code>ArrayBuffer</code> muszą być tworzone poprzez operator {{jsxref("Operators/new", "new")}}. Wywoływanie kontruktora ArrayBuffer jako funkcji bez <code>new</code> zaskutkuje od teraz pojawieniem się {{jsxref("TypeError")}}.</p> + +<pre class="brush: js example-bad">var dv = ArrayBuffer(10); +// TypeError: calling a builtin ArrayBuffer constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new ArrayBuffer(10);</pre> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typed arrays</a></li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/bigint/asintn/index.html b/files/pl/web/javascript/referencje/obiekty/bigint/asintn/index.html new file mode 100644 index 0000000000..f3d7de5b66 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/bigint/asintn/index.html @@ -0,0 +1,79 @@ +--- +title: BigInt.asIntN() +slug: Web/JavaScript/Referencje/Obiekty/BigInt/asIntN +tags: + - BigInt + - JavaScript + - Metodă + - Referencja + - asIntN +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN +--- +<div>{{JSRef}}</div> + +<p>Metoda statyczna <strong><code>BigInt.asIntN</code></strong> jest używana do opakowywania wartości BigInt w wartości całkowite ze znakiem w zakresie od -2<sup>szerokość-1</sup> do 2<sup>szerokość-1</sup>-1.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-asintn.html", "taller")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">BigInt.asIntN(<em>szerokość</em>, <var>bigint</var>);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>szerokość</var></code></dt> + <dd>Liczba bitów dostępnych dla rozmiaru wartości całkowitej (integer).</dd> + <dt><code><var>bigint</var></code></dt> + <dd>Wartość całkowita, którą chcemy wpasować w daną liczbę bitów.</dd> +</dl> + +<h3 id="Wynik">Wynik</h3> + +<p>Wartość <code><var>bigint</var></code> modulo 2<sup><code><var>szerokość</var></code></sup> jako liczba całkowita ze znakiem.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Pozostawanie_w_zakresie_arytmetyki_64-bitowej">Pozostawanie w zakresie arytmetyki 64-bitowej</h3> + +<p>Metoda <code>BigInt.asIntN()</code> może być użyteczna do tego, by pozostać w zakresie obliczeń arytmetyki 64-bitowej.</p> + +<pre class="brush: js">const max = 2n ** (64n - 1n) - 1n; + +BigInt.asIntN(64, max); +// ↪ 9223372036854775807n + +BigInt.asIntN(64, max + 1n); +// ↪ -9223372036854775807n +// wartość ujemna ze względu na przepełnienie +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.asintn', 'BigInt.asIntN()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.BigInt.asIntN")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("BigInt")}}</li> + <li>{{JSxRef("BigInt.asUintN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/bigint/asuintn/index.html b/files/pl/web/javascript/referencje/obiekty/bigint/asuintn/index.html new file mode 100644 index 0000000000..0f290f50c4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/bigint/asuintn/index.html @@ -0,0 +1,78 @@ +--- +title: BigInt.asUintN() +slug: Web/JavaScript/Referencje/Obiekty/BigInt/asUintN +tags: + - BigInt + - JavaScript + - Metodă + - Referencja + - asUintN +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN +--- +<div>{{JSRef}}</div> + +<p>Metoda statyczna <strong><code>BigInt.asUintN</code></strong> jest używana do opakowywania wartości BigInt w wartości całkowite bez znaku w zakresie od 0 do 2<sup>szerokość</sup>-1.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-asuintn.html", "taller")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">BigInt.asUintN(<em>szerokość</em>, <var>bigint</var>);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>szerokość</var></code></dt> + <dd>Liczba bitów dostępnych dla rozmiaru wartości całkowitej (integer).</dd> + <dt><code><var>bigint</var></code></dt> + <dd>Wartość całkowita, którą chcemy wpasować w daną liczbę bitów.</dd> +</dl> + +<h3 id="Wynik">Wynik</h3> + +<p>Wartość <code><var>bigint</var></code> modulo 2<sup><code><var>szerokość</var></code></sup> jako wartość całkowita bez znaku.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Pozostawanie_w_zakresie_arytmetyki_64-bitowej">Pozostawanie w zakresie arytmetyki 64-bitowej</h3> + +<p>Metoda <code>BigInt.asUintN()</code> może być użyteczna do tego, by pozostać w zakresie obliczeń arytmetyki 64-bitowej.</p> + +<pre class="brush: js">const max = 2n ** 64n - 1n; + +BigInt.asUintN(64, max); +// ↪ 18446744073709551615n + +BigInt.asUintN(64, max + 1n); +// ↪ 0n +// zero z powodu przepełnienia</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.asuintn', 'BigInt.asUintN()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.BigInt.asUintN")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("BigInt")}}</li> + <li>{{JSxRef("BigInt.asIntN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/bigint/index.html b/files/pl/web/javascript/referencje/obiekty/bigint/index.html new file mode 100644 index 0000000000..650604b0c3 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/bigint/index.html @@ -0,0 +1,293 @@ +--- +title: BigInt +slug: Web/JavaScript/Referencje/Obiekty/BigInt +tags: + - BigInt + - JavaScript + - Referencja +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt +--- +<div>{{JSRef}}</div> + +<p><strong><code>BigInt</code></strong> jest wbudowanym obiektem umożliwiającym reprezentowanie całych liczb większch niż 2<sup>53</sup> - 1, ile wynosi największa liczba, którą JavaScript może faktycznie reprezentować przez prymityw {{JSxRef("Number")}}, co jest też reprezentowane przez stałą {{JSxRef("Number.MAX_SAFE_INTEGER")}}. <strong><code>BigInt</code></strong> może być używany do dowolnie dużych liczb całkowitych.</p> + +<dl> +</dl> + +<h2 id="Opis">Opis</h2> + +<p><code>BigInt</code> jest tworzony przez dodanie <code>n</code> na końcu literału liczby — <code>10n</code> — lub przez wywołanie funkcji <code>BigInt()</code>.</p> + +<pre class="brush: js">const najwiekszyInt = 9007199254740991n + +const tezDuzaLiczba = BigInt(9007199254740991) +// ↪ 9007199254740991n + +const duzyString = BigInt("9007199254740991") +// ↪ 9007199254740991n + +const duzyHex = BigInt("0x1fffffffffffff") +// ↪ 9007199254740991n + +const duzyBin = BigInt("0b11111111111111111111111111111111111111111111111111111") +// ↪ 9007199254740991n +</pre> + +<p><code>BigInt</code> jest w pewnym sensie podobny do {{JSxRef("Number")}} ale też różni się od niego w kilku kluczowych sprawach — nie może być używany z metodami wbudowanego obiektu {{JSxRef("Math")}}, a także nie może być mieszany z instancjami <code>Number</code> w żadnych operacjach; konieczne jest wymuszenie tego samego typu operandów. Należy uważać z wymuszaniem typów w jedną i drugą stronę, w szczególności precyzja <code>BigInt</code> może być utracona przy wymuszonej konwersji do typu <code>Number</code>.</p> + +<h3 id="Informacje_o_typie">Informacje o typie</h3> + +<p>Przy sprawdzeniu za pomocą <code>typeof</code>, <code>BigInt</code> zwróci "bigint":</p> + +<pre class="brush: js">typeof 1n === 'bigint' // true +typeof BigInt('1') === 'bigint' // true +</pre> + +<p>Obudowany w <code>Object</code>, <code>BigInt</code> będzie rozważany jako zwykły "obiekt":</p> + +<pre class="brush: js">typeof Object(1n) === 'object' // true +</pre> + +<h3 id="Operatory">Operatory</h3> + +<p>Z <code>BigInt</code>ami (lub <code>BigInt</code>ami obudowanymi w obiekty) mogą być używane następujące operatory: : <code>+</code>, <code>*</code>, <code>-</code>, <code>**</code>, <code>%</code>.</p> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Operatory bitowe</a> także są wspierane, z wyjątkiem <code>>>></code> (przesunięcie w prawo z dopełnieniem zerami), gdyż wszystkie <code>BigInt</code>y mają znak.</p> + +<p>Niewspierany jest także operator jednoargumentowy (<code>+</code>), <a href="https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs">aby nie złamać zasad asm.js</a>.</p> + +<pre class="brush: js">const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER) +// ↪ 9007199254740991n + +const maxPlusOne = previousMaxSafe + 1n +// ↪ 9007199254740992n + +const theFuture = previousMaxSafe + 2n +// ↪ 9007199254740993n, this works now! + +const multi = previousMaxSafe * 2n +// ↪ 18014398509481982n + +const subtr = multi – 10n +// ↪ 18014398509481972n + +const mod = multi % 10n +// ↪ 2n + +const bigN = 2n ** 54n +// ↪ 18014398509481984n + +bigN * -1n +// ↪ –18014398509481984n +</pre> + +<p>Operator <code>/</code> także działa zgodnie z założeniami z całymi liczbami.</p> + +<p>Jako że są to <code>BigInt</code>y, a nie <code>BigDecimal</code>, operacja dzielenia będzie zaokroąglała wynik do <code>0</code> (zatem można prościej powiedzieć, że nie zwraca ułamkowej części wyniku).</p> + +<div class="blockIndicator warning"> +<p>Ułamkowy wynik operacji będzie przycięty, kiedy używany jest <code>BigInt</code>.</p> +</div> + +<pre class="brush: js">const expected = 4n / 2n +// ↪ 2n + +const rounded = 5n / 2n +// ↪ 2n, not 2.5n + +</pre> + +<h3 id="Porównania">Porównania</h3> + +<p><code>BigInt</code> nie jest ściśle równy {{JSxRef("Number")}}, ale jest równy w luźnym sensie, zatem:</p> + +<pre class="brush: js">0n === 0 +// ↪ false + +0n == 0 +// ↪ true</pre> + +<p>{{JSxRef("Global_Objects/Number", "Number")}} i <code>BigInt</code> mogą być porównywane w zwyczajny sposób:</p> + +<pre class="brush: js">1n < 2 +// ↪ true + +2n > 1 +// ↪ true + +2 > 2 +// ↪ false + +2n > 2 +// ↪ false + +2n >= 2 +// ↪ true</pre> + +<p>Mogą być też mieszane w tablicach i sortowane:</p> + +<pre class="brush: js">const mixed = [4n, 6, -12n, 10, 4, 0, 0n] +// ↪ [4n, 6, -12n, 10, 4, 0, 0n] + +mixed.sort() +// ↪ [-12n, 0, 0n, 4n, 4, 6, 10] +</pre> + +<p>Zauważ, że porównania z <code>BigInt</code>ami opakowanymi w obiekty działają jak z innymi obiektami, wskazując równość tylko wtedy, kiedy ta sama instancja obiektu znajduje się po obu stronach porównania:</p> + +<pre class="brush: js">0n === Object(0n) // false +Object(0n) === Object(0n) // false + +const o = Object(0n) +o === o // true +</pre> + +<h3 id="Instrukcje_warunkowe">Instrukcje warunkowe</h3> + +<p><code>BigInt</code> zachowuje się jak {{JSxRef("Global_Objects/Number", "Number")}} w przypadkach, gdy:</p> + +<ul> + <li>jest konwertowany na {{JSxRef("Global_Objects/Boolean", "Boolean")}} za pomocą funkcji {{JSxRef("Global_Objects/Boolean", "Boolean")}};</li> + <li>jest używany z <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Logical_Operators">operatorami logicznymi</a> <code>||</code>, <code>&&</code> lub <code>!</code>;</li> + <li>w instrukcjach warunkowych {{JSxRef("Statements/if...else", "if")}}.</li> +</ul> + +<pre class="brush: js">if (0n) { + console.log('Hello from the if!') +} else { + console.log('Hello from the else!') +} + +// ↪ "Hello from the else!" + +0n || 12n +// ↪ 12n + +0n && 12n +// ↪ 0n + +Boolean(0n) +// ↪ false + +Boolean(12n) +// ↪ true + +!12n +// ↪ false + +!0n +// ↪ true +</pre> + +<h2 id="Konstruktor">Konstruktor</h2> + +<dl> + <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/BigInt">BigInt()</a></code></dt> + <dd>Tworzy obiekty {{jsxref("BigInt")}}.</dd> +</dl> + +<h2 id="Metody_statyczne">Metody statyczne</h2> + +<dl> + <dt>{{JSxRef("BigInt.asIntN()")}}</dt> + <dd>Opakowuje wartość <code>BigInt</code> w liczbę całkowitą ze znakiem o wartości między <code>-2<var><sup>width</sup></var><sup>-1</sup></code> a <code>2<var><sup>width</sup></var><sup>-1</sup> - 1</code>.</dd> + <dt>{{JSxRef("BigInt.asUintN()")}}</dt> + <dd>Opakowuje wartość <code>BigInt</code> w liczbę całkowitą bez znaku o wartości między <code>0</code> a <code>2<var><sup>width</sup></var> - 1</code>.</dd> +</dl> + +<h2 id="Metody_instancyjne">Metody instancyjne</h2> + +<dl> + <dt>{{JSxRef("BigInt.prototype.toLocaleString()")}}</dt> + <dd>Zwraca string z zależną od języka reprezentacją danej liczby. Nadpisuje metodę {{JSxRef("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{JSxRef("BigInt.prototype.toString()")}}</dt> + <dd>Zwraca string reprezentujący dany obiekt w określonym źródle. Nadpisuje metodę {{JSxRef("Object.prototype.toString()")}}.</dd> + <dt>{{JSxRef("BigInt.prototype.valueOf()")}}</dt> + <dd>Zwraca prymitywną wartość danego obiektu. Nadpisuje metodę {{JSxRef("Object.prototype.valueOf()")}}.</dd> +</dl> + +<h2 id="Zalecenia_w_użyciu">Zalecenia w użyciu</h2> + +<h3 id="Wymuszanie_typów">Wymuszanie typów</h3> + +<p>Ponieważ wymuszanie tupów między {{JSxRef("Number")}} a <code>BigInt</code> może prowadzić do utraty precyzji, zaleca się używanie jedynie typu <code>BigInt</code>, gdy można się spodziewać, że pojawią się wartości przekraczające 2<sup>53</sup> i nie należy wówczas przeprowadzać konwersji między tymi typami.</p> + +<h3 id="Kryptografia">Kryptografia</h3> + +<p>Operacje wspierane dla <code>BigInt</code>ów nie są stałe czasowo, dlatego też typ <code>BigInt</code> <a href="https://www.chosenplaintext.ca/articles/beginners-guide-constant-time-cryptography.html">nie nadaje się do użycia w kryptografii</a>.</p> + +<h3 id="Użycie_w_JSON">Użycie w JSON</h3> + +<p>Użycie {{jsxref("JSON.stringify()")}} z dowolną wartością typu <code>BigInt</code> spowoduje błąd <code>TypeError</code>, ponieważ wartości <code>BigInt</code> nie są domyślnie serialozowane w JSONie. Jednakże, jeśli taka operacja jest potrzebna, możesz zaimplemntować własną metodę <code>toJSON</code>:</p> + +<pre class="brush: js">BigInt.prototype.toJSON = function() { return this.toString() }</pre> + +<p>Zamiast wyrzucania wyjątku, <code>JSON.stringify</code> będzie teraz zwracać string:</p> + +<pre class="brush: js">JSON.stringify(BigInt(1)) +// '"1"'</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Obliczanie_liczb_pierwszych">Obliczanie liczb pierwszych</h3> + +<pre class="brush: js">// Zwraca true jeśl dany BigInt jest liczbą pierwszą +function isPrime(p) { + for (let i = 2n; i * i <= p; i++) { + if (p % i === 0n) return false; + } + return true +} + +// Przyjmuje BigInt n jako argument, zwraca n-tą liczbę pierwszą jako BigInt +function nthPrime(nth) { + let maybePrime = 2n + let prime = 0n + + while (nth >= 0n) { + if (isPrime(maybePrime)) { + nth-- + prime = maybePrime + } + maybePrime++ + } + + return prime +} + +nthPrime(20n) +// ↪ 73n</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName("ESDraft", "#sec-bigint-objects", "<code>BigInt</code> objects")}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div class="hidden">The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a class="external" href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</div> + +<p>{{Compat("javascript.builtins.BigInt")}}</p> + +<h3 id="Postęp_implementacji">Postęp implementacji</h3> + +<p>Poniższa tabela przedstawia postęp implementacji tej funkcji języka JavaScript, gdyż nie osiągnęła ona jeszcze pełnej stabilności między przeglądarkami. Dane są generowane przez uruchamianie odpowiednich testów tej funkcji w <a href="https://github.com/tc39/test262">Test262</a>,standrardowym zestawie testów JavaScript, „nocnych wersji” (ang. <em>nightly build</em>) lub ostatnich wydań silnika JavaScript w każdej przeglądarce.</p> + +<div>{{EmbedTest262ReportResultsTable("BigInt")}}</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("Number")}}</li> + <li>{{JSxRef("Number.MAX_SAFE_INTEGER")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/bigint/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/bigint/tostring/index.html new file mode 100644 index 0000000000..9cc06f15ea --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/bigint/tostring/index.html @@ -0,0 +1,95 @@ +--- +title: BigInt.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/BigInt/toString +tags: + - BigInt + - JavaScript + - Metodă + - Prototyp + - toString() +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toString +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>toString()</code></strong> zwraca ciąg znaków (<em>string</em>), reprezentujący dany obiekt {{jsxref("BigInt")}}. Końcowy znak "n" nie jest częścią wynikowego ciągu znaków.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-tostring.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>bigIntObj</var>.toString([podstawa])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>podstawa</code>{{optional_inline}}</dt> + <dd>Argument opcjonalny. Liczba całkowita w zakresie od 2 do 36, reprezentująca bazę systemu liczbowego, w którym ma być przedstawiona dana wartość {{jsxref("BigInt")}}.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Ciąg znaków reprezentujący dany obiekt {{jsxref("BigInt")}}.</p> + +<h3 id="Wyjątki">Wyjątki</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Jeśli do metody <code>toString()</code> przekazana jest podstawa systemu mniejsza niż 2 lub większa niż 36, wyrzucany jest błąd {{jsxref("RangeError")}}.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt {{jsxref("BigInt")}} nadpisuje metodę <code>toString()</code> obiektu {{jsxref("Object")}}; nie dziedziczy metody {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref( "BigInt")}}, metoda <code>toString()</code> zwraca ciąg znaków reprezentujący daną wartość w systemie pozycyjnym o zadanej bazie.</p> + +<p>Metoda <code>toString()</code> parsuje pierwszy argument i próbuje zwrócić ciąg znaków reprezentujący daną wartość w systemie o zadanej podstawie (bazie). Dla systemów o podstawie większej niż 10, do reprezentacji cyfr większych niż 9 używane są kolejne litery alfabetu łacińskiego. Przykładowo, dla wartości w systemie szesnastkowym (o podstawie równej 16), używane są litery od <code>a</code> do <code>f</code>.</p> + +<p>Jeśli <code>podstawa</code> nie jest podana, zakłada się, że preferowaną bazą systemu jest 10.</p> + +<p>Jeśli wartość <code>bigIntObj</code> jest ujemna, znak jest zachowywany. Dzieje się tak nawet wtedy, gdy podstawą jest 2; zwracany ciąg cyfr jest dodatnią reprezentacją <code>bigIntObj</code>, poprzedzoną znakiem <code>-</code>, <strong>nie</strong> dopełnieniem dwójkowym <code>bigIntObj</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_toString">Użycie <code>toString</code></h3> + +<pre class="brush: js">17n.toString(); // '17' +66n.toString(2); // '1000010' +254n.toString(16); // 'fe' +-10n.toString(2); // -1010' +-0xffn.toString(2); // '-11111111' +</pre> + +<h3 id="BigInt_z_ujemnym_zerem"><code>BigInt</code> z ujemnym zerem</h3> + +<p>Nie ma obiektów <code>BigInt</code> reprezentujących ujemne zero, tak jak nie ma ujemnych zer wśród liczb całkowitych.. <code>-0.0</code> jest zmiennoprzecinkową koncepcją zmiennoprzecinkową IEEE, która pojawia się w języku JavaScript jedynie w typie {{jsxref("Number")}}.</p> + +<pre class="brush: js">(-0n).toString(); // '0' +BigInt(-0).toString(); // '0'</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.prototype.tostring', 'BigInt.prototype.toString()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.BigInt.toString")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("BigInt.prototype.toLocaleString()")}}</li> + <li>{{jsxref("BigInt.prototype.valueOf()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/bigint/valueof/index.html b/files/pl/web/javascript/referencje/obiekty/bigint/valueof/index.html new file mode 100644 index 0000000000..a1d4c312fd --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/bigint/valueof/index.html @@ -0,0 +1,59 @@ +--- +title: BigInt.prototype.valueOf() +slug: Web/JavaScript/Referencje/Obiekty/BigInt/valueOf +tags: + - BigInt + - JavaScript + - Metodă + - Prototype + - valueOf() +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>valueOf()</code></strong> zwraca opakowaną wartość prymitywną obiektu {{jsxref("BigInt")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-valueof.html","shorter")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>bigIntObj</var>.valueOf()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>BigInt reprezentujący wartość prymitywną danego obiektu {{jsxref("BigInt")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_valueOf">Użycie <code>valueOf</code></h3> + +<pre class="brush: js">typeof Object(1n); // object +typeof Object(1n).valueOf(); // bigint +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.prototype.valueof', 'BigInt.prototype.valueOf()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.BigInt.valueOf")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("BigInt.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/boolean/index.html b/files/pl/web/javascript/referencje/obiekty/boolean/index.html new file mode 100644 index 0000000000..85e5a6a773 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/boolean/index.html @@ -0,0 +1,111 @@ +--- +title: Boolean +slug: Web/JavaScript/Referencje/Obiekty/Boolean +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +--- +<p>{{JSRef("Global_Objects", "Boolean")}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Obiekt <code>Boolean</code> jest obiektem opakowującym (ang.<em>wrapper</em> ) dla wartości logicznych.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>new Boolean([wartosc])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>wartosc</code> </dt> + <dd>Początkowa wartość obiektu <code>Boolean</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość przekazana jako pierwszy parametr jest w razie konieczności konwertowana do wartości logicznej. Jeśli wartość zostanie pominięta lub będzie równa 0, -0, null, false, <code>NaN</code>, będzie pustym łańcuchem znaków ("") lub będzie niezdefiniowana, obiekt przyjmie początkową wartość false. Dowolna inna wartość, włączając łańcuch znaków <code>"false"</code>, spowoduje utworzenie obiektu z początkową wartością true.</p> + +<p>Nie należy mylić prostych wartości logicznych true i false z wartościami <code>true</code> i <code>false</code> obiektu Boolean.</p> + +<p>Każdy obiekt, którego wartością nie jest wartość <code>undefined</code> lub <code>null</code>, w tym obiekt Boolean posiadający wartość <code>false</code>, traktowany jest w instrukcjach warunkowych jako <code>true</code>. Przykładowo warunek w poniższej instrukcji if będzie miał wartość <code>true</code>:</p> + +<pre class="eval">x = new Boolean(false); +if (x) { + // . . . ten kod zostanie wykonany +} +</pre> + +<p>Taka sytuacja nie zachodzi przy prostych wartościach logicznych. Przykładowo warunek w poniższej instrukcji if będzie miał wartość <code>false</code>::</p> + +<pre class="eval">x = false; +if (x) { + // . . . ten kod nie zostanie wykonany +} +</pre> + +<p>Nie należy zatem używać obiektu <code>Boolean</code> do konwersji wartości nie będącej wartością logiczną na wartość typu Boolean. Zamiast tego należy skorzystać z funkcji <code>Boolean()</code>:</p> + +<pre class="eval">x = Boolean(wyrazenie); // zalecane +x = new Boolean(wyrazenie); // nie należy używać +</pre> + +<p>Jeśli jako wartość początkową określony zostanie dowolny obiekt, w tym obiekt Boolean o wartości <code>false</code>, nowy obiekt Boolean będzie miał wartość <code>true</code>.</p> + +<pre class="eval">myFalse = new Boolean(false); // wartość początkowa: false +g = new Boolean(myFalse); // wartość początkowa: true +myString = new String("Hello"); // obiekt String (łańcuch znaków) +s = new Boolean(myString); // wartość początkowa: true +</pre> + +<p><strong>Nie należy</strong> używać obiektu Boolean zamiast prostej wartości logicznej.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt><code>Boolean.length</code></dt> + <dd>Length property whose value is 1.</dd> +</dl> + +<dl> + <dt>{{jsxref("Boolean.prototype")}}</dt> + <dd>Definiuje własność współdzieloną przez wszystkie obiekty Boolean.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<p>Globalny obiekt <code>Boolean</code> sam w sobie nie zawiera żadnych metod, jednak dziedziczy on niektóre metody poprzez łańcuch prototypu.</p> + +<div>{{jsOverrides("Function", "Methods")}}</div> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Efa.C5.82sz.E2.80.9D" name="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Efa.C5.82sz.E2.80.9D">Tworzenie obiektów <code>Boolean</code> z początkową wartością „fałsz”</h3> + +<pre class="brush: js">bNoParam = new Boolean(); +bZero = new Boolean(0); +bNull = new Boolean(null); +bEmptyString = new Boolean(""); +bfalse = new Boolean(false); +</pre> + +<h3 id="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Eprawda.E2.80.9D" name="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Eprawda.E2.80.9D">Tworzenie obiektów <code>Boolean</code> z początkową wartością „prawda”</h3> + +<pre class="brush: js">btrue = new Boolean(true); +btrueString = new Boolean("true"); +bfalseString = new Boolean("false"); +bSuLin = new Boolean("Su Lin"); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Boolean.prototype")}}</li> + <li>{{Glossary("Boolean")}}</li> + <li><a href="http://en.wikipedia.org/wiki/Boolean_data_type">Boolean data type (Wikipedia)</a></li> +</ul> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/referencje/obiekty/boolean/prototype/index.html b/files/pl/web/javascript/referencje/obiekty/boolean/prototype/index.html new file mode 100644 index 0000000000..5ba279ea35 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/boolean/prototype/index.html @@ -0,0 +1,48 @@ +--- +title: Boolean.prototype +slug: Web/JavaScript/Referencje/Obiekty/Boolean/prototype +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Reprezentuje prototyp konstruktora {{jsxref("Boolean")}}.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Instancje {{jsxref("Boolean")}} dziedziczą z <code>Boolean.prototype</code>. Możesz użyć obiektu prototypu konstruktora, by dodać własności lub metody do wszystkich instancji {{jsxref("Boolean")}}.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt><code>Boolean.prototype.constructor</code></dt> + <dd>Zwraca funkcję, która tworzy instancję prototypu. Jest to domyślnie funkcja {{jsxref("Boolean")}}.</dd> +</dl> + +<div>{{jsOverrides("Object", "properties", "constructor")}}</div> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Zwraca ciąg zawierający źródło obiektu <code>Boolean</code>; możesz użyć tego ciągu, by stworzyć równoważny obiekt. Przesłania metodę {{jsxref("Object.prototype.toSource()")}}.</dd> +</dl> + +<dl> + <dt>{{jsxref("Boolean.prototype.toString()")}}</dt> + <dd>Zwraca ciąg "true" albo "false", zależnie od wartości obiektu. Przesłania metodę {{jsxref("Object.prototype.toString()")}}.</dd> +</dl> + +<dl> + <dt>{{jsxref("Boolean.prototype.valueOf()")}}</dt> + <dd>Zwraca prostą wartość obiektu <code>Boolean</code>. Przesłania metodę {{jsxref("Object.prototype.valueOf()")}}.</dd> +</dl> + +<div>{{jsOverrides("Object", "methods", "toSource", "toString", "valueOf")}}</div> diff --git a/files/pl/web/javascript/referencje/obiekty/boolean/tosource/index.html b/files/pl/web/javascript/referencje/obiekty/boolean/tosource/index.html new file mode 100644 index 0000000000..b41f1c5806 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/boolean/tosource/index.html @@ -0,0 +1,51 @@ +--- +title: Boolean.prototype.toSource() +slug: Web/JavaScript/Referencje/Obiekty/Boolean/toSource +tags: + - Boolean + - JavaScript + - Method + - Non-standard + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków z kodem źródłowym obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>booleanObj</var>.toSource() +Boolean.toSource()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toSource</code> zwraca następujące wartości:</p> + +<ul> + <li>dla wbudowanego obiektu <code>Boolean</code> metoda <code>toSource</code> zwraca następujący łańcuch znaków, oznaczający, że kod źródłowy nie jest dostępny: + + <pre class="brush: js">function Boolean() { + [native code] +} +</pre> + </li> +</ul> + +<ul> + <li>dla instancji obiektu <code>Boolean</code> metoda <code>toSource</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Metoda ta jest zwykle stosowana wewnętrznie przez interpreter JavaScriptu, a nie bezpośrednio w kodzie programów.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/boolean/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/boolean/tostring/index.html new file mode 100644 index 0000000000..fe61d7bca9 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/boolean/tostring/index.html @@ -0,0 +1,41 @@ +--- +title: Boolean.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/Boolean/toString +tags: + - Boolean + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toString +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca ciąg znaków reprezentujący dany obiekt Boolean</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>bool</var>.toString()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Boolean")}} przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}, nie dziedziczy metody {{jsxref("Object.prototype.toString()")}}. Dla obiektów <code>Boolean</code> metoda <code>toString</code> zwraca ich tekstową reprezentację.</p> + +<p>JavaScript wywołuje metodę <code>toString</code> samoczynnie, kiedy instancja obiektu {{jsxref("Boolean")}} ma być reprezentowana jako wartość tekstowa lub kiedy instancja obiektu {{jsxref("Boolean")}} jest składnikiem konkatenacji ciągu(-ów) znaków.</p> + +<p>Dla obiektów i wartości {{jsxref("Boolean")}} wbudowana metoda <code>toString</code> zwraca ciąg znaków "<code>true</code>" lub "<code>false</code>" w zależności od wartości obiektu boolowskiego. W poniższym przykładzie <code>flaga.toString</code> zwraca "<code>true</code>".</p> + +<pre class="brush: js">var flaga = new Boolean(true) +var mojaZmienna=flaga.toString() +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/boolean/valueof/index.html b/files/pl/web/javascript/referencje/obiekty/boolean/valueof/index.html new file mode 100644 index 0000000000..1e20821efa --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/boolean/valueof/index.html @@ -0,0 +1,43 @@ +--- +title: Boolean.prototype.valueOf() +slug: Web/JavaScript/Referencje/Obiekty/Boolean/valueOf +tags: + - Boolean + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość prostą obiektu {{jsxref("Boolean")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>bool</var>.valueOf()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>valueOf</code> obiektu {{jsxref("Boolean")}} zwraca wartość prostą obiektu {{jsxref("Boolean")}} lub literału {{jsxref("Boolean")}} jako typ Boolean.</p> + +<p>Metoda ta jest zwykle wywoływana wewnętrznie przez interpreter JavaScriptu, a nie w typowym kodzie w JavaScripcie.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_valueOf" name="Przyk.C5.82ad:_Zastosowanie_valueOf">Przykład: Zastosowanie <code>valueOf</code></h3> + +<pre class="brush: js">var x = new Boolean(); +myVar = x.valueOf() // przypisuje myVar wartość false +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/dataview/index.html b/files/pl/web/javascript/referencje/obiekty/dataview/index.html new file mode 100644 index 0000000000..db3d459a82 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/dataview/index.html @@ -0,0 +1,118 @@ +--- +title: DataView +slug: Web/JavaScript/Referencje/Obiekty/DataView +translation_of: Web/JavaScript/Reference/Global_Objects/DataView +--- +<div>{{JSRef}}</div> + +<p><strong><code>DataView</code></strong> udostępnia niskopoziowy interfejs do zapisu i odczytu typów numerycznych w formie {{jsxref("ArrayBuffer")}} niezależnie od kodowania platformy.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">new DataView(buffer [, byteOffset [, byteLength]])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>buffer</code></dt> + <dd>Istniejący {{jsxref("ArrayBuffer")}} lub {{jsxref("SharedArrayBuffer")}} {{experimental_inline}} używany jako pamięć dla obiektu <code>DataView</code> .</dd> + <dt><code>byteOffset</code> {{optional_inline}}</dt> + <dd>The offset, in bytes, to the first byte in the specified buffer for the new view to reference. If not specified, the view of the buffer will start with the first byte.</dd> + <dt><code>byteLength</code> {{optional_inline}}</dt> + <dd>The number of elements in the byte array. If unspecified, length of the view will match the buffer's length.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>A new <code>DataView</code> object representing the specified data buffer.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt><code>{{jsxref("RangeError")}}</code></dt> + <dd>Thrown if the <code>byteOffset</code> and <code>byteLength</code> result in the specified view extending past the end of the buffer.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<h3 id="Endianness">Endianness</h3> + +<p>Multi-byte number formats are represented in memory differently depending on machine architecture, see {{Glossary("Endianness")}} for an explanation. DataView accessors provide explicit control of how data will be accessed irrespective of the platform architecture's endianness.</p> + +<pre class="brush: js">var littleEndian = (function() { + var buffer = new ArrayBuffer(2); + new DataView(buffer).setInt16(0, 256, true /* littleEndian */); + // Int16Array uses the platform's endianness. + return new Int16Array(buffer)[0] === 256; +})(); +console.log(littleEndian); // true or false +</pre> + +<h2 id="Properties">Properties</h2> + +<p>All <code>DataView</code> instances inherit from {{jsxref("DataView.prototype")}} and allows the addition of properties to all DataView objects.</p> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Properties')}}</p> + +<h2 id="Methods">Methods</h2> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Methods')}}</p> + +<h2 id="Example">Example</h2> + +<pre class="brush: js">var buffer = new ArrayBuffer(16); +var dv = new DataView(buffer, 0); + +dv.setInt16(1, 42); +dv.getInt16(1); //42 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Superseded by ECMAScript 6</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition in an ECMA standard</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview-constructor', 'DataView')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("javascript.builtins.DataView")}}</p> + +<h2 id="Compatibility_notes">Compatibility notes</h2> + +<p>Starting with Firefox 40, <code>DataView</code> requires to be constructed with a {{jsxref("Operators/new", "new")}} operator. Calling <code>DataView()</code> as a function without <code>new</code>, will throw a {{jsxref("TypeError")}} from now on.</p> + +<pre class="brush: js example-bad">var dv = DataView(buffer, 0); +// TypeError: calling a builtin DataView constructor without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new DataView(buffer, 0);</pre> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a class="link-https" href="https://github.com/jDataView/jDataView">jDataView</a>: JavaScript library that polyfills and extends the <code>DataView</code> API to all browsers and Node.js.</li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/constructor/index.html b/files/pl/web/javascript/referencje/obiekty/date/constructor/index.html new file mode 100644 index 0000000000..0d649b4fe6 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/constructor/index.html @@ -0,0 +1,18 @@ +--- +title: constructor +slug: Web/JavaScript/Referencje/Obiekty/Date/constructor +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> +<p>Zwraca referencję do funkcji <a href="../../../../en/Core_JavaScript_1.5_Reference/Global_Objects/Date" rel="internal">Date</a>, która tworzy prototyp instancji. Należy pamiętać, że wartość tej własności jest referencją do samej funkcji, nie zaś łańcuchem znaków zawierającym nazwę funkcji.</p> +<table class="fullwidth-table"> <tbody> <tr> <td class="header" colspan="2">Własność obiektu: <a href="/pl/Dokumentacja_j%C4%99zyka_JavaScript_1.5/Obiekty/Date" title="pl/Dokumentacja_języka_JavaScript_1.5/Obiekty/Date">Date</a></td> </tr> <tr> <td>Zaimplementowane w:</td> <td>JavaScript 1.1, NES 2.0</td> </tr> <tr> <td>Wersja ECMA:</td> <td>ECMA-262</td> </tr> </tbody> +</table><h3 id="Opis" name="Opis"> Opis </h3> +<p>Zobacz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Object/constructor">Object.constructor</a></code>. +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Date/constructor", "ja": "ja/Core_JavaScript_1.5_Reference/Global_Objects/Date/constructor" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/date/getdate/index.html b/files/pl/web/javascript/referencje/obiekty/date/getdate/index.html new file mode 100644 index 0000000000..2dcba53fa0 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getdate/index.html @@ -0,0 +1,47 @@ +--- +title: Date.prototype.getDate() +slug: Web/JavaScript/Referencje/Obiekty/Date/getDate +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca dzień miesiąca dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getDate()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getDate</code> to liczby całkowite z przedziału liczb pomiędzy 1 a 31.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getDate" name="Przyk.C5.82ad:_Zastosowanie_getDate">Przykład: Zastosowanie <code>getDate()</code></h3> + +<p>Druga instrukcja poniżej przydziela wartość 25 do zmiennej <code>dzien</code>, wartość oparta na <code>Date</code>, obiektu <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var dzien = Xmas95.getDate(); + +console.log(dzien), // 25 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getday/index.html b/files/pl/web/javascript/referencje/obiekty/date/getday/index.html new file mode 100644 index 0000000000..0c52e4e3dd --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getday/index.html @@ -0,0 +1,47 @@ +--- +title: Date.prototype.getDay() +slug: Web/JavaScript/Referencje/Obiekty/Date/getDay +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca dzień tygodnia określonej daty, stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getDay()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością zwracaną przez <code>getDay</code> jest liczba całkowita, odnosząca się do dnia tygodnia: 0 dla niedzieli, 1 dla poniedziałku, 2 dla wtorku, i tak dalej.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getDay" name="Przyk.C5.82ad:_Zastosowanie_getDay">Przykład: Zastosowanie <code>getDay()</code></h3> + +<p>Druga instrukcja poniżej przydziela wartość 1 do <code>dzienTyg</code>, opierając się o wartość <code>Date</code>, obiektu <code>Xmas95</code>. 25 grudnia 1995 roku wypadał w poniedziałek.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var weekday = Xmas95.getDay(); + +console.log(weekday); // 1 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getfullyear/index.html b/files/pl/web/javascript/referencje/obiekty/date/getfullyear/index.html new file mode 100644 index 0000000000..ecc7d868c0 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getfullyear/index.html @@ -0,0 +1,47 @@ +--- +title: Date.prototype.getFullYear() +slug: Web/JavaScript/Referencje/Obiekty/Date/getFullYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca rok określonej daty, stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getFullYear()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość <code>getFullYear</code> zwracana jest jako pełna liczba. Dla dat liczba lat zawiera się pomiędzy 1000 i 9999, <code>getFullYear</code> zwraca czterocyfrową liczbę, na przykład: 1995. Użyj tej funkcji, aby być pewnym, że wyświetlona będzie pełna data po roku 2000.</p> + +<p>Użyj tej metody zamiast metody <code>getYear</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getFullYear" name="Przyk.C5.82ad:_Zastosowanie_getFullYear">Przykład: Zastosowanie <code>getFullYear</code></h3> + +<p>Następujący przykład przydziela czterocyfrową wartość aktualnego roku do zmiennej <code>yr</code>.</p> + +<pre class="brush: js">var today = new Date(); +var yr = today.getFullYear(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/gethours/index.html b/files/pl/web/javascript/referencje/obiekty/date/gethours/index.html new file mode 100644 index 0000000000..a6010ec8c3 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/gethours/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.getHours() +slug: Web/JavaScript/Referencje/Obiekty/Date/getHours +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca godzinę określonej daty, stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getHours()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getHours</code> jest liczbą całkowitą z przedziału od 0 do 23.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getHours" name="Przyk.C5.82ad:_Zastosowanie_getHours">Przykład: Zastosowanie <code>getHours()</code></h3> + +<p>Druga instrukcja poniżej przydziela wartość liczby 23 zmiennej <code>hours</code>, opartej o wartość <code>Date</code> obiektu <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var hours = Xmas95.getHours(); + +console.log(hours); // 23 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getmilliseconds/index.html b/files/pl/web/javascript/referencje/obiekty/date/getmilliseconds/index.html new file mode 100644 index 0000000000..1ab98844fc --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getmilliseconds/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.getMilliseconds() +slug: Web/JavaScript/Referencje/Obiekty/Date/getMilliseconds +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca milisekundy określonej daty, stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMilliseconds()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getMilliseconds</code> jest liczbą pomiędzy 0 a 999.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_getMilliseconds">Przykład: Zastosowanie <code>getMilliseconds()</code></h3> + +<p>Następujący przykład przydziela liczbę milisekund aktualnego czasu do zmiennej <code>ms</code>.</p> + +<pre class="brush: js">var today = new Date(); +var ms = today.getMilliseconds(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getminutes/index.html b/files/pl/web/javascript/referencje/obiekty/date/getminutes/index.html new file mode 100644 index 0000000000..3ee877bd14 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getminutes/index.html @@ -0,0 +1,48 @@ +--- +title: Date.prototype.getMinutes() +slug: Web/JavaScript/Referencje/Obiekty/Date/getMinutes +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca minuty dla określonej daty w zależności od czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMinutes()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getMinutes</code> jest liczbą całkowitą z przedziału od 0 do 59.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getMinutes" name="Przyk.C5.82ad:_Zastosowanie_getMinutes">Przykład: Zastosowanie <code>getMinutes</code></h3> + +<p>Druga instrukcja poniżej przypisuje wartość 15 do zmiennej <code>minutes</code>, bazując na wartości obiektu <code>Xmas95</code> typu <code>Date</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var minutes = Xmas95.getMinutes(); + +console.log(minutes); // 15 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<div class="noinclude"> +<ul> + <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> +</div> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getmonth/index.html b/files/pl/web/javascript/referencje/obiekty/date/getmonth/index.html new file mode 100644 index 0000000000..bf3e74b56b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getmonth/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.getMonth() +slug: Web/JavaScript/Referencje/Obiekty/Date/getMonth +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca miesiąc dla określonej daty w zależności od czasu lokalnego.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMonth()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getMonth</code> jest liczbą całkowitą z przedziału od 0 do 11. 0 reprezentuje styczeń, 1 luty, i tak dalej.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getMonth" name="Przyk.C5.82ad:_Zastosowanie_getMonth">Przykład: Zastosowanie <code>getMonth()</code></h3> + +<p>Druga instrukcja z przykładu poniżej przypisuje wartość 11 zmiennej <code>month</code>, bazując na wartości obiektu <code>Xmas95</code> typu <code>Date</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00"); +var month = Xmas95.getMonth(); + +console.log(month); // 11 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getseconds/index.html b/files/pl/web/javascript/referencje/obiekty/date/getseconds/index.html new file mode 100644 index 0000000000..f471165425 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getseconds/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.getSeconds() +slug: Web/JavaScript/Referencje/Obiekty/Date/getSeconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca sekundy dla określonej daty w zależności od czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getSeconds()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getSeconds</code> jest liczbą całkowitą z przedziału od 0 do 59.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getSeconds" name="Przyk.C5.82ad:_Zastosowanie_getSeconds">Przykład: Zastosowanie <code>getSeconds()</code></h3> + +<p>Druga instrukcja poniżej przypisuje wartość 30 do zmiennej <code>secs</code>, bazując na wartości obiektu <code>Xmas95</code> typu <code>Date</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:30"); +var seconds = Xmas95.getSeconds(); + +console.log(seconds); // 30 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/gettime/index.html b/files/pl/web/javascript/referencje/obiekty/date/gettime/index.html new file mode 100644 index 0000000000..a57da23566 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/gettime/index.html @@ -0,0 +1,47 @@ +--- +title: Date.prototype.getTime() +slug: Web/JavaScript/Referencje/Obiekty/Date/getTime +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca liczbę reprezentującą czas dla określonej daty stosownie do czasu uniwersalnego.</p> + +<p>Może być wykorzystana do przypisania daty i czasu do innego obiektu {{jsxref("Date")}}. Ta metoda jest funkcjonalnie równoważna metodzie {{jsxref("Date.valueof", "valueOf()")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTime()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez metodę <code>getTime</code> jest liczbą milisekund liczoną od 1 stycznia 1970 00:00:00.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getTime" name="Przyk.C5.82ad:_Zastosowanie_getTime">Przykład: Zastosowanie <code>getTime()</code></h3> + +<p>Następująca instrukcja przypisuje wartość daty <code>theBigDay</code> do <code>sameAsBigDay</code>:</p> + +<pre class="brush: js">var theBigDay = new Date("July 1, 1999"); +var sameAsBigDay = new Date(); +sameAsBigDay.setTime(theBigDay.getTime()); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.setTime()")}}</li> + <li>{{jsxref("Date.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/gettimezoneoffset/index.html b/files/pl/web/javascript/referencje/obiekty/date/gettimezoneoffset/index.html new file mode 100644 index 0000000000..7805486fde --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/gettimezoneoffset/index.html @@ -0,0 +1,35 @@ +--- +title: Date.prototype.getTimezoneOffset() +slug: Web/JavaScript/Referencje/Obiekty/Date/getTimezoneOffset +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca przesunięcie strefy czasowej w minutach dla bieżącej lokalizacji.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTimezoneOffset()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Przesunięcie strefy czasowej jest to różnica, wyrażona w minutach, pomiędzy <strong>Greenwich Mean Time</strong> (<strong>GMT</strong>) a bieżącym czasem lokalnym. Na przykład, jeśli aktualna strefa to GMT+10, wynikiem jest -600. Wartość nie jest liczbą stałą ze względu na zmiany czasu na letni i zimowy.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_getTimezoneOffset" name="Przyk.C5.82ad:_Zastosowanie_getTimezoneOffset">Przykład: Zastosowanie <code>getTimezoneOffset()</code></h4> + +<pre class="brush: js">var x = new Date(); +var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60; +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getutcdate/index.html b/files/pl/web/javascript/referencje/obiekty/date/getutcdate/index.html new file mode 100644 index 0000000000..54f031b3d6 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getutcdate/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.getUTCDate() +slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCDate +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca dzień (datę) miesiąca dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDate()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością zwracaną przez <code>getUTCDate</code> jest liczba całkowita z przedziału od 1 do 31.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCDate" name="Przyk.C5.82ad:_Zastosowanie_getUTCDate">Przykład: Zastosowanie <code>getUTCDate()</code></h3> + +<p>Następujący przykład przypisuje aktualny dzień miesiąca do zmiennej <code>d</code>.</p> + +<pre class="brush: js">var today = new Date(); +var d = today.getUTCDate(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getutcday/index.html b/files/pl/web/javascript/referencje/obiekty/date/getutcday/index.html new file mode 100644 index 0000000000..4ce3b4207b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getutcday/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.getUTCDay() +slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCDay +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca dzień tygodnia dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDay()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCDay</code> jest liczbą całkowitą określającą dzień tygodnia: 0 dla niedzieli, 1 dla poniedziałku, 2 dla wtorku itd.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCDay" name="Przyk.C5.82ad:_Zastosowanie_getUTCDay">Przykład: Zastosowanie <code>getUTCDay()</code></h3> + +<p>Następujący przykład przypisuje aktualny dzień tygodnia do zmiennej <code>weekday</code>.</p> + +<pre class="brush: js">var today = new Date(); +var weekday = today.getUTCDay(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getutcfullyear/index.html b/files/pl/web/javascript/referencje/obiekty/date/getutcfullyear/index.html new file mode 100644 index 0000000000..646affed0e --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getutcfullyear/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.getUTCFullYear() +slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCFullYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca rok dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCFullYear()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością zwracaną przez <code>getUTCFullYear</code> jest dodatnia liczba całkowita, zgodna z rokiem 2000, na przykład 1995.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCFullYear" name="Przyk.C5.82ad:_Zastosowanie_getUTCFullYear">Przykład: Zastosowanie <code>getUTCFullYear()</code></h3> + +<p>Następujący przykład przypisuje czterocyfrową liczbę aktualnego roku do zmiennej <code>yr</code>.</p> + +<pre class="brush: js">var today = new Date(); +var year = today.getUTCFullYear(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getutchours/index.html b/files/pl/web/javascript/referencje/obiekty/date/getutchours/index.html new file mode 100644 index 0000000000..0006fab388 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getutchours/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.getUTCHours() +slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCHours +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca godziny dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCHours()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCHours</code> jest liczbą całkowitą z przedziału od 0 do 23.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCHours" name="Przyk.C5.82ad:_Zastosowanie_getUTCHours">Przykład: Zastosowanie <code>getUTCHours()</code></h3> + +<p>Następujący przykład przypisuje część aktualnej daty określającą godzinę do zmiennej <code>hrs</code>.</p> + +<pre class="brush: js">var today = new Date(); +var hours = today.getUTCHours(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getutcmilliseconds/index.html b/files/pl/web/javascript/referencje/obiekty/date/getutcmilliseconds/index.html new file mode 100644 index 0000000000..de048d2998 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getutcmilliseconds/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.getUTCMilliseconds() +slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca milisekundy dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMilliseconds()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana <code>getUTCMilliseconds</code> jest liczbą całkowitą z przedziału od 0 do 999.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_getUTCMilliseconds">Przykład: Zastosowanie <code>getUTCMilliseconds()</code></h3> + +<p>Następujący przykład przypisuje część aktualnej daty określającą liczbę milisekund do zmiennej <code>ms</code>.</p> + +<pre class="brush: js">var today = new Date(); +var ms = today.getUTCMilliseconds(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getutcminutes/index.html b/files/pl/web/javascript/referencje/obiekty/date/getutcminutes/index.html new file mode 100644 index 0000000000..aabc9f16e7 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getutcminutes/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.getUTCMinutes() +slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCMinutes +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca minuty dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMinutes()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCMinutes()</code> jest liczbą całkowitą z przedziału od 0 do 59.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCMinutes" name="Przyk.C5.82ad:_Zastosowanie_getUTCMinutes">Przykład: Zastosowanie <code>getUTCMinutes()</code></h3> + +<p>Następujący przykład przypisuje część aktualnej daty określającą minuty do zmiennej <code>min</code>.</p> + +<pre class="brush: js">var today = new Date(); +var min = today.getUTCMinutes(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getutcmonth/index.html b/files/pl/web/javascript/referencje/obiekty/date/getutcmonth/index.html new file mode 100644 index 0000000000..75899683a3 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getutcmonth/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.getUTCMonth() +slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCMonth +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca miesiąc dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMonth()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCMonth()</code> jest liczbą całkowitą z przedziału od 0 do 11 odpowiadającą miesiącowi: 0 dla stycznia, 1 dla lutego, 2 dla marca, i tak dalej.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCMonth" name="Przyk.C5.82ad:_Zastosowanie_getUTCMonth">Przykład: Zastosowanie <code>getUTCMonth()</code></h3> + +<p>Następujący przykład przypisuje aktualny miesiąc do zmiennej <code>mon</code>.</p> + +<pre class="brush: js">var today = new Date(); +var mon = today.getUTCMonth(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getutcseconds/index.html b/files/pl/web/javascript/referencje/obiekty/date/getutcseconds/index.html new file mode 100644 index 0000000000..82f9d40634 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getutcseconds/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.getUTCSeconds() +slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCSeconds +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca sekundy dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCSeconds()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>getUTCSeconds()</code> jest liczbą całkowitą z przedziału od 0 do 59.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCSeconds" name="Przyk.C5.82ad:_Zastosowanie_getUTCSeconds">Przykład: Zastosowanie <code>getUTCSeconds()</code></h3> + +<p>Następujący przykład przypisuje część aktualnej daty określającą liczbę sekund do zmiennej <code>sec</code>.</p> + +<pre class="brush: js">var today = new Date(); +var sec = today.getUTCSeconds(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/getyear/index.html b/files/pl/web/javascript/referencje/obiekty/date/getyear/index.html new file mode 100644 index 0000000000..fdb3c10d75 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/getyear/index.html @@ -0,0 +1,97 @@ +--- +title: Date.prototype.getYear() +slug: Web/JavaScript/Referencje/Obiekty/Date/getYear +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear +--- +<p>{{JSRef}}{{ Deprecated_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca rok dla określonej daty w zależności od czasu lokalnego. Metoda <code>getYear</code> nie jest dłużej wykorzystywana i została zastąpiona metodą {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getYear()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>getYear</code> zwraca rok minus 1900; tak więc:</p> + +<ul> + <li>Dla lat późniejszych lub równych 2000, wartość zwracana przez <code>getYear</code> wynosi 100 lub więcej. Przykładowo, dla roku 2026, <code>getYear</code> zwraca 126.</li> +</ul> + +<ul> + <li>Dla lat pomiędzy i włącznie z latami 1900 i 1999, wartość zwracana przez <code>getYear</code> zawiera się w przedziale od 0 do 99. Na przykład, jeśli mamy rok 1976, <code>getYear</code> zwraca 76.</li> +</ul> + +<ul> + <li>Dla lat wcześniejszych niż 1900, wartość zwracana przez <code>getYear</code> jest mniejsza niż 0. Na przykład, dla roku 1800, <code>getYear</code> zwraca -100.</li> +</ul> + +<p>Aby obsłużyć lata zarówno przed jak i po roku 2000, należy zamiast <code>getYear</code> użyć metody {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}, która zwraca pełną liczbę określającą rok.</p> + +<h2 id="Kompatybilno.C5.9B.C4.87_wsteczna" name="Kompatybilno.C5.9B.C4.87_wsteczna">Kompatybilność wstecz</h2> + +<h3 id="JavaScript_1.2_i_wersje_wcze.C5.9Bniejsze" name="JavaScript_1.2_i_wersje_wcze.C5.9Bniejsze">JavaScript 1.2 i wersje wcześniejsze</h3> + +<p>Metoda <code>getYear()</code> zwraca rok w formacie 2-cyfrowym lub 4-cyfrowym:</p> + +<ul> + <li>Dla roczników pomiędzy i włącznie z latami 1900 i 1999, wartość zwracana przez <code>getYear</code> jest to rok minus 1900. Na przykład, dla roku 1976 będzie to liczba 76.</li> +</ul> + +<ul> + <li>Dla roczników niższych niż 1900 lub wyższych niż 1999, wartość zwracana przez <code>getYear</code> jest cztero-cyfrowa. Na przykład, dla roku 1856, wartość jest równa 1856. Dla roku 2026, wartość wynosi 2026.</li> +</ul> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Lata_pomi.C4.99dzy_1900_i_1999" name="Przyk.C5.82ad:_Lata_pomi.C4.99dzy_1900_i_1999">Przykład: Lata pomiędzy 1900 i 1999</h3> + +<p>Druga instrukcja przypisuje wartość 95 do zmiennej <code>year</code>.</p> + +<pre class="brush: js">var Xmas = new Date("December 25, 1995 23:15:00"); +var year = Xmas.getYear(); // zwraca 95 +</pre> + +<h3 id="Przyk.C5.82ad:_Lata_powy.C5.BCej_1999" name="Przyk.C5.82ad:_Lata_powy.C5.BCej_1999">Przykład: Lata powyżej 1999</h3> + +<p>Druga instrukcja przypisuje wartość 100 do zmiennej <code>year</code>.</p> + +<pre class="brush: js">var Xmas = new Date("December 25, 2000 23:15:00"); +var year = Xmas.getYear(); // zwraca 100 +</pre> + +<h3 id="Przyk.C5.82ad:_Lata_powy.C5.BCej_1900" name="Przyk.C5.82ad:_Lata_powy.C5.BCej_1900">Przykład: Lata poniżej 1900</h3> + +<p>Druga instrukcja przypisuje wartość -100 do zmiennej <code>year</code>.</p> + +<pre class="brush: js">var Xmas = new Date("December 25, 1800 23:15:00"); +var year = Xmas.getYear(); // zwraca -100 +</pre> + +<h3 id="Przyk.C5.82ad:_Ustawienie_i_pobieranie_lat_pomi.C4.99dzy_1900_i_1999" name="Przyk.C5.82ad:_Ustawienie_i_pobieranie_lat_pomi.C4.99dzy_1900_i_1999">Przykład: Ustawianie i pobieranie roku pomiędzy 1900 i 1999</h3> + +<p>Druga instrukcja przypisuje wartość 95 do zmiennej <code>year</code>, reprezentując rok 1995.</p> + +<pre class="brush: js">var Xmas.setYear(95); +var year = Xmas.getYear(); // zwraca 95 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/index.html b/files/pl/web/javascript/referencje/obiekty/date/index.html new file mode 100644 index 0000000000..3636152933 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/index.html @@ -0,0 +1,138 @@ +--- +title: Date +slug: Web/JavaScript/Referencje/Obiekty/Date +tags: + - Date + - JavaScript + - data +translation_of: Web/JavaScript/Reference/Global_Objects/Date +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Tworzy instancje <code>Date</code>, które pozwalają na pracę z danymi opisującymi datę i czas.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia</h2> + +<pre class="syntaxbox"><code>new Date(); +new Date(<em>milisekundy</em>); +new Date(<em>dateString</em>); +new Date(<em>rok</em>, <em>indeksMiesiąca </em>[, <em>dzień </em>[, <em>godzina </em>[, <em>minuta </em>[, <em>sekunda </em>[, <em>milisekunda</em>]]]]]); +</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>milisekundy</code> </dt> + <dd>Wartość całkowita reprezentująca liczbę milisekund od 1 stycznia 1970, godz. 00:00:00 UTC.</dd> +</dl> + +<dl> + <dt><code>dateString</code> </dt> + <dd>Łańcuch znaków reprezentujący datę. Łańcuch znaków powinien być w formacie rozpoznawalnym przez metodę <a href="/pl/Dokumentacja_j%C4%99zyka_JavaScript_1.5/Obiekty/Date/parse" title="pl/Dokumentacja_języka_JavaScript_1.5/Obiekty/Date/parse">parse</a>.</dd> +</dl> + +<dl> + <dt><code>rok</code></dt> + <dd>Wartość całkowita reprezentująca rok. Dla zgodności (w celu uniknięcia problemu roku 2000) należy zawsze określać rok w pełnej formie, używając raczej <code>1998</code> niż <code>98</code>.</dd> +</dl> + +<dl> + <dt><code>indeksMiesiąca</code></dt> + <dd>Wartość całkowita reprezentująca miesiąc, począwszy od 0 dla stycznia, kończąc na 11 dla grudnia.</dd> +</dl> + +<dl> + <dt><code>dzień</code></dt> + <dd>Wartość całkowita reprezentująca dzień miesiąca.</dd> +</dl> + +<dl> + <dt><code>godzina</code></dt> + <dd>Wartość całkowita reprezentująca godzinę (w formacie 24-godzinnym).</dd> +</dl> + +<dl> + <dt><code>minuta</code></dt> + <dd>Wartość całkowita reprezentująca część minutową odczytywanego czasu.</dd> +</dl> + +<dl> + <dt><code>second</code></dt> + <dd>Wartość całkowita reprezentująca część sekundową odczytywanego czasu.</dd> +</dl> + +<dl> + <dt><code>millisecond</code></dt> + <dd>Wartość całkowita reprezentująca część milisekundową odczytywanego czasu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie dostarczasz żadnych argumentów, konstruktor tworzy obiekt <code>Date</code> dla dzisiejszej daty i czasu stosownie do czasu lokalnego. Jeśli dostarczasz jakieś argumenty, lecz nie wszystkie, brakujące argumenty mają ustawioną wartość 0. Jeśli jednak dostarczasz jakieś argumenty, musisz dostarczyć co najmniej rok, miesiąc i dzień. Pominąć możesz godzinę, minuty, sekundy i milisekundy.</p> + +<p>Data jest mierzona w milisekundach od północy 1 stycznia 1970 UTC. W jednym dniu jest 86,400,000 milisekund. Zakres wartości obiektu <code>Date</code> wynosi od -100,000,000 dni do 100,000,000 dni w stosunku do 01 stycznia 1970 UTC.</p> + +<p>Obiekt <code>Date</code> zapewnia jednolite działanie bez względu na platformę.</p> + +<p>Obiekt <code>Date</code> wspiera wiele metod UTC (uniwersalny czas światowy) i metody czasu lokalnego. UTC, także znany jako <em>Greenwich Mean Time</em> (GMT), odnosi się do czasu ustanowionego przez "światowy standard czasu" (ang. World Time Standard). Czas lokalny jest czasem, który zna komputer, na jakim jest wykonywany JavaScript.</p> + +<p>Dla kompatybilności z obliczeniami milenijnymi (inaczej, syndromem roku 2000), powinieneś zawsze określić pełen rok, czyli na przykład, używa 1998, nie 98. Aby pomóc Ci w określeniu całego roku, JavaScript zawiera metody {{jsxref("Date.prototype.getFullYear()")}}, {{jsxref("Date.prototype.setFullYear()")}}, {{jsxref("Date.getUTCFullYear()")}} i {{jsxref("Date.setUTCFullYear()")}}.</p> + +<p>Odwoływanie się do <code>Date </code>w kontekście innym niż konstruktor (np. bez operatora {{jsxref("new")}}) będzie zwracało ciąg reprezentujący aktualny czas.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("Date.prototype")}}</dt> + <dd>Pozwala dodać własności do obiektu <code>Date</code>.</dd> + <dt><code>Date.length</code></dt> + <dd>The value of <code>Date.length</code> is 7. This is the number of arguments handled by the constructor.</dd> + <dt> + <div>{{jsOverrides("Function", "properties", "prototype")}}</div> + </dt> +</dl> + +<h2 id="Metody_statyczne" name="Metody_statyczne">Metody</h2> + +<dl> + <dt>{{jsxref("Date.now()")}}</dt> + <dd>Zwraca wartość liczbową odnoszącą się do aktualnego czasu.</dd> + <dt>{{jsxref("Date.parse()")}}</dt> + <dd>Zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 czasu lokalnego do daty podanej jako argument string.</dd> + <dt>{{jsxref("Date.UTC()")}}</dt> + <dd>Zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 czasu uniwersalnego do daty podanej jako zestaw liczb (parametry jak w najdłuższej formie konstruktora).</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Kilka_sposob.C3.B3w_na_przypisywanie_dat" name="Przyk.C5.82ad:_Kilka_sposob.C3.B3w_na_przypisywanie_dat">Przykład: Kilka sposobów na przypisywanie dat</h3> + +<p>Poniżej przedstawiono kilka przykładowych przypisań dat:</p> + +<pre class="brush: js">var dzisiaj = new Date(); +var urodziny = new Date("December 17, 1995 03:24:00"); +var urodziny = new Date(1995,11,17); +var urodziny = new Date(1995,11,17,3,24,0); +</pre> + +<h3 id="Przyk.C5.82ad:_Obliczanie_czasu_trwania" name="Przyk.C5.82ad:_Obliczanie_czasu_trwania">Przykład: Obliczanie czasu trwania</h3> + +<p>Poniższy przykład pokazuje, jak określić czas, jaki minął pomiędzy dwoma datami:</p> + +<pre class="brush: js">// używając metod statycznych +var start = Date.now(); +// zdarzenie, dla którego chciałbyś zmierzyć czas trwania: +zrobCosPrzezDlugiCzas(); +var stop = Date.now(); +var roznica_czasow = stop - start; // czas w milisekundach +</pre> + +<pre class="brush: js">// wykorzystując obiekty Date +var start = new Date(); +// zdarzenie, dla którego chciałbyś zmierzyć czas trwania: +zrobCosPrzezDlugiCzas(); +var stop = new Date(); +var roznica_czasow = stop.getTime() - start.getTime(); // czas w milisekundach +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/date/now/index.html b/files/pl/web/javascript/referencje/obiekty/date/now/index.html new file mode 100644 index 0000000000..c0a4e1a690 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/now/index.html @@ -0,0 +1,43 @@ +--- +title: Date.now() +slug: Web/JavaScript/Referencje/Obiekty/Date/now +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/now +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca liczbę milisekund, która upłynęła od 1 stycznia 1970 00:00:00 UTC.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>var timeInMs = Date.now();</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda now zwraca milisekundy, które upłynęły od 1 stycznia 1970 00:00:00 UTC do teraz w postaci obiektu {{jsxref("Number")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_now" name="Przyk.C5.82ad:_Zastosowanie_now">Przykład: Zastosowanie <code>now</code></h3> + +<p>Poniższy przykład używa <code>now</code> do stworzenia znacznika czasu.</p> + +<pre class="brush: js">var timestamp = Date.now(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{domxref("Performance.now()")}}</li> + <li>{{domxref("Console.time()")}} / {{domxref("Console.timeEnd()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/parse/index.html b/files/pl/web/javascript/referencje/obiekty/date/parse/index.html new file mode 100644 index 0000000000..d500500484 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/parse/index.html @@ -0,0 +1,74 @@ +--- +title: Date.parse() +slug: Web/JavaScript/Referencje/Obiekty/Date/parse +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse +--- +<div> {{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Analizuje łańcuch znaków reprezentujący datę i zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 UTC.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Date.parse(<var>dateString</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>dateString</code> </dt> + <dd>Łańcuch znaków reprezentujący datę.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>parse</code> pobiera łańcuch znaków daty (na przykład: "<code>Dec 25, 1995</code>") i zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 UTC. Gdy parametr nie zawiera informacji na temat strefy czasowej, domyślnie używana jest lokalna strefa czasowa. Ta funkcja jest przydatna do ustawiania wartości daty w oparciu o wartość łańcucha znaków, przykładowo w połączeniu z metodą {{jsxref("Date.prototype.setTime()", "setTime()")}} oraz obiektem {{jsxref("Date")}}.</p> + +<p>Dla podanego łańcucha znaków reprezentującego czas, <code>parse</code> zwraca wartość czasu. Akceptuje składnię standardu daty - IETF: "<code>Mon, 25 Dec 1995 13:30:00 GMT</code>". Rozpoznaje skróty kontynentalnej strefy czasowej US, lecz w ogólnym zastosowaniu używa się przesunięć dla strefy czasowej, na przykład: "<code>Mon, 25 Dec 1995 13:30:00 GMT+0430</code>" (4 godziny i 30 minut na zachód od południka Greenwich). Jeśli nie określono strefy czasowej, domyślna jest strefa lokalna. GMT i UTC są rozpatrywane jako równoważne.</p> + +<p>Mimo iż specyfikatory strefy czasowej są brane pod uwagę podczas analizy łańcucha znaków do prawidłowej interpretacji argumentu, nie wpływają one jednak na zwracaną wartość, którą zawsze jest ilość milisekund pomiędzy 1 stycznia 1970 roku, 00:00:00 UTC a punktem w czasie reprezentowanym przez argument.</p> + +<p>Ponieważ <code>parse</code> jest metodą statyczną obiektu <code>Date</code>, używamy jej jako <code>Date.parse()</code>, raczej niż jako wywołanie metody utworzonego przez nas obiektu <code>Date</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_parse" name="Przyk.C5.82ad:_Zastosowanie_parse">Przykład: Zastosowanie <code>parse</code></h3> + +<p>Jeśli <code>IPOdate</code> jest istniejącym obiektem <code>Date</code>, możemy przypisać mu wartość 9 sierpnia 1995 (czasu lokalnego) w następujący sposób:</p> + +<pre class="brush: js">IPOdate.setTime(Date.parse("Aug 9, 1995")) ; +</pre> + +<p>Kilka innych przykładów:</p> + +<pre class="brush: js">// Zwraca 807937200000 w strefie czasowej GMT-0300, i inne wartości dla innych stref +// czasowych, ponieważ argument nie specyfikuje strefy czasowej. +Date.parse("Aug 9, 1995");</pre> + +<pre class="brush: js">// Zwraca 807926400000 niezależnie od lokalnej strefy czasowej. +Date.parse("Wed, 09 Aug 1995 00:00:00 GMT");</pre> + +<pre class="brush: js">// Zwraca 807937200000 w strefie czasowej GMT-0300, a inne wartości w innych +// strefach czasowych, ponieważ strefa nie jest wyspecyfikowana w argumencie. +Date.parse("Wed, 09 Aug 1995 00:00:00");</pre> + +<pre class="brush: js">// Zwraca 0 niezależnie od lokalnej strefy czasowej. +Date.parse("Thu, 01 Jan 1970 00:00:00 GMT");</pre> + +<pre class="brush: js">// Zwraca 14400000 w strefie czasowej GMT-0400, a inne wartości w innych +// strefach czasowych, ponieważ strefa nie jest podana w argumencie. +Date.parse("Thu, 01 Jan 1970 00:00:00");</pre> + +<pre class="brush: js">// Zwraca 14400000 niezależnie od lokalnej strefy czasowej. +Date.parse("Thu, 01 Jan 1970 00:00:00 GMT-0400");</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.UTC()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/prototype/index.html b/files/pl/web/javascript/referencje/obiekty/date/prototype/index.html new file mode 100644 index 0000000000..20f539e68b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/prototype/index.html @@ -0,0 +1,115 @@ +--- +title: Date.prototype +slug: Web/JavaScript/Referencje/Obiekty/Date/prototype +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Reprezentuje prototyp dla tej klasy. Można używać prototypu do dodawania własności lub metod wszystkim instancjom klasy. Aby uzyskać więcej informacji o prototypach, zobacz {{jsxref("Function.prototype")}}.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt><code>Date.prototype.constructor</code></dt> + <dd>Określa funkcję, która tworzy prototyp obiektu.</dd> +</dl> + +<div>{{jsOverrides("Object", "properties", "constructor")}}</div> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Date.prototype.getDate()")}}</dt> + <dd>Zwraca dzień miesiąca dla określonej daty, stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.getDay()")}}</dt> + <dd>Zwraca dzień tygodnia dla określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.getFullYear()")}}</dt> + <dd>Zwraca rok określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.getHours()")}}</dt> + <dd>Zwraca godzinę określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.getMilliseconds()")}}</dt> + <dd>Zwraca milisekundy określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.getMinutes()")}}</dt> + <dd>Zwraca minuty w określonej dacie czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.getMonth()")}}</dt> + <dd>Zwraca miesiąc w określonej dacie czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.getSeconds()")}}</dt> + <dd>Zwraca sekundy określone w dacie stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.getTime()")}}</dt> + <dd>Zwraca wartość numeryczną przesyłając czas określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.getTimezoneOffset()")}}</dt> + <dd>Zwraca czas przesunięcia wg strefy czasowej dla aktualnego czasu lokalnego. .</dd> + <dt>{{jsxref("Date.prototype.getUTCDate()")}}</dt> + <dd>Zwraca dzień (date) miesiąca określonej daty stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.getUTCDay()")}}</dt> + <dd>Zwraca dzień tygodnia określone w dacie stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.getUTCFullYear()")}}</dt> + <dd>Zwraca rok określony w dacie stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.getUTCHours()")}}</dt> + <dd>Zwraca godziny określone w dacie stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</dt> + <dd>Zwraca milisekundy określone w dacie stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.getUTCMinutes()")}}</dt> + <dd>Zwraca minuty określone w dacie stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.getUTCMonth()")}}</dt> + <dd>Zwraca nazwę miesięcy określone w dacie stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.getUTCSeconds()")}}</dt> + <dd>Zwraca sekundy określonej daty stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.getYear()")}} {{deprecated_inline}}</dt> + <dd>Zwraca rok określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.setDate()")}}</dt> + <dd>Ustawia dzień miesiąca dla określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.setFullYear()")}}</dt> + <dd>Ustawia pełny rok dla określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.setHours()")}}</dt> + <dd>Ustawia godziny dla określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.setMilliseconds()")}}</dt> + <dd>Ustawia milisekundy dla określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.setMinutes()")}}</dt> + <dd>Ustawia minuty dla określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.setMonth()")}}</dt> + <dd>Ustawia nazwę miesiąca dla określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.setSeconds()")}}</dt> + <dd>Ustawia sekundy dla określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.setTime()")}}</dt> + <dd>Ustawia wartość obiektu <code>Date</code> stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.setUTCDate()")}}</dt> + <dd>Ustawia dzień miesiąca dla określonej daty stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.setUTCFullYear()")}}</dt> + <dd>Ustawia pełen rok dla określonej daty stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.setUTCHours()")}}</dt> + <dd>Ustawia godzinę dla określonej daty stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</dt> + <dd>Ustawia milisekundy dla określonej daty stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.setUTCMinutes()")}}</dt> + <dd>Ustawia minuty dla określonej daty stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.setUTCMonth()")}}</dt> + <dd>Ustawia miesiąc dla określonej daty stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.setUTCSeconds()")}}</dt> + <dd>Ustawia sekundy dla określonej daty stosownie do czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.setYear()")}} {{deprecated_inline}}</dt> + <dd>Ustawia rok dla określonej daty stosownie do czasu lokalnego.</dd> + <dt>{{jsxref("Date.prototype.toGMTString()")}} {{deprecated_inline}}</dt> + <dd>Konwertuje datę na łańcuch znaków, używając konwencji czasu GMT.</dd> + <dt>{{jsxref("Date.prototype.toLocaleString()")}}</dt> + <dd>Konwertuje datę na łańcuch znaków (string), używając aktualnej lokalnej konwencji. Przesłania metodę {{jsxref("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("Date.prototype.toLocaleDateString()")}}</dt> + <dd>Zwraca datę (bez godziny) z obiektu <code>Date</code> jako ciąg znaków z wykorzystaniem lokalnych konwencji.</dd> + <dt>{{jsxref("Date.prototype.toLocaleTimeString()")}}</dt> + <dd>Zwraca godzinę (bez daty) z obiektu <code>Date</code> jako ciąg znaków z wykorzystaniem lokalnych konwencji.</dd> + <dt>{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Zwraca obiekt literału reprezentujący określony obiekt <code>Date</code>; możesz użyć tej wartości do tworzenia nowych obiektów. Przesłania metodę {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Date.prototype.toString()")}}</dt> + <dd>Zwraca łańcuch znaków, reprezentujący określony obiekt <code>Date</code>. Przesłania metodę {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Date.prototype.toUTCString()")}}</dt> + <dd>Konwertuje datę na łańcuch znaków, używając do konwencji czasu uniwersalnego.</dd> + <dt>{{jsxref("Date.prototype.valueOf()")}}</dt> + <dd>Zwraca wartość prostą obiektu <code>Date</code>. Przesłania metodę {{jsxref("Object.prototype.valueOf()")}}.<span id="cke_bm_120E" style="display: none;"> </span></dd> +</dl> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setdate/index.html b/files/pl/web/javascript/referencje/obiekty/date/setdate/index.html new file mode 100644 index 0000000000..9e0e3db5b9 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setdate/index.html @@ -0,0 +1,43 @@ +--- +title: Date.prototype.setDate() +slug: Web/JavaScript/Referencje/Obiekty/Date/setDate +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia dzień miesiąca dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setDate(<var>dayValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita z przedziału od 1 do 31, reprezentująca dzień miesiąca.</dd> +</dl> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setDate" name="Przyk.C5.82ad:_Zastosowanie_setDate">Przykład: Zastosowanie <code>setDate()</code></h3> + +<p>Druga instrukcja poniżej zmienia dzień miesiąca dla zmiennej <code>theBigDay</code> z jego oryginalnej wartości na 24 lipca.</p> + +<pre class="brush: js">var theBigDay = new Date("July 27, 1962 23:30:00"); +var theBigDay.setDate(24); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setfullyear/index.html b/files/pl/web/javascript/referencje/obiekty/date/setfullyear/index.html new file mode 100644 index 0000000000..6b9fe390a1 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setfullyear/index.html @@ -0,0 +1,58 @@ +--- +title: Date.prototype.setFullYear() +slug: Web/JavaScript/Referencje/Obiekty/Date/setFullYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia kompletny rok dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>yearValue</code> </dt> + <dd>Liczba całkowita określająca wartość numeryczną roku, na przykład; 1995.</dd> +</dl> + +<dl> + <dt><code>monthValue</code> </dt> + <dd>Liczba całkowita z przedziału od 0 do 11 (reprezentująca miesiące od stycznia do grudnia).</dd> +</dl> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita z przedziału od 1 do 31 reprezentująca dzień miesiąca. Jeśli zostaje podany parametr <code>dayValue</code>, należzy również podać <code>monthValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie zostały podane parametry <code>monthValue</code> i <code>dayValue</code>, biblioteka pobierze te dane z metod {{jsxref("Date.prototype.getMonth()", "getMonth()")}} i {{jsxref("Date.prototype.getDate()", "getDate()")}}.</p> + +<p>Jeżeli określony parametr jest poza oczekiwanym zakresem, <code>setFullYear()</code> spróbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Przykładowo, jeśli zostanie podana wartość 15 dla <code>monthValue</code> to rok zostanie zwiększony o 1 (rok+1), a miesiąc zostanie ustawiony na wartość 3.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setFullYear" name="Przyk.C5.82ad:_Zastosowanie_setFullYear">Przykład: Zastosowanie <code>setFullYear()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setFullYear(1997); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/sethours/index.html b/files/pl/web/javascript/referencje/obiekty/date/sethours/index.html new file mode 100644 index 0000000000..8e3f95ff7d --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/sethours/index.html @@ -0,0 +1,66 @@ +--- +title: Date.prototype.setHours() +slug: Web/JavaScript/Referencje/Obiekty/Date/setHours +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia godziny dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre> + +<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>)</code></pre> + +<h2 id="Parametry" name="Parametry">Parametry</h2> + +<dl> + <dt><code>hoursValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 23, reprezentująca godziny.</dd> +</dl> + +<dl> + <dt><code>minutesValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca minuty.</dd> +</dl> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, musisz także określić <code>minutesValue</code>.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>A Liczba pomiędzy 0 i 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, musisz także określić <code>minutesValue</code> i <code>secondsValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametrów <code>minutesValue</code>, <code>secondsValue</code> i <code>msValue</code>, wartość zwracana użytych metod {{jsxref("Date.prototype.getMinutes()", "getMinutes()")}}, {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} i {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setHours</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty będą wzrastać o 1 (min + 1), i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad_Zastosowanie_setHours" name="Przyk.C5.82ad:_Zastosowanie_setHours">Przykład: Zastosowanie <code>setHours()</code></h3> + +<pre class="brush: js">var the BigDay = new Date(); +theBigDay.setHours(7); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setmilliseconds/index.html b/files/pl/web/javascript/referencje/obiekty/date/setmilliseconds/index.html new file mode 100644 index 0000000000..c2a1359801 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setmilliseconds/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.setMilliseconds() +slug: Web/JavaScript/Referencje/Obiekty/Date/setMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia milisekundy dla określonej daty stosownie do czasu lokalnego.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMilliseconds(<var>millisecondsValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>millisecondsValue</code> </dt> + <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli sprecyzujesz liczbę z poza oczekiwanego szeregu, informacje zawarte w obiekcie <code>Date</code> będą aktualizowane. Na przykład, jeśli określisz 1005, liczba sekund rośnie o 1, i 5 jest użyte dla milisekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_setMilliseconds">Przykład: Zastosowanie <code>setMilliseconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setMilliseconds(100); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setminutes/index.html b/files/pl/web/javascript/referencje/obiekty/date/setminutes/index.html new file mode 100644 index 0000000000..011137c893 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setminutes/index.html @@ -0,0 +1,60 @@ +--- +title: Date.prototype.setMinutes() +slug: Web/JavaScript/Referencje/Obiekty/Date/setMinutes +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia minuty dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre> + +<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>minutesValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca minuty.</dd> +</dl> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, musisz także określić <code>minutesValue</code>.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba pomiędzy 0 i 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, musisz także określić <code>minutesValue</code> i <code>secondsValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określono parametrów <code>secondsValue</code> i <code>msValue</code>, są użyte wartości zwracanych metod <code>getSeconds</code> i <code>getMilliseconds</code>.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setMinutes</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty (<code>minutesValue</code>) będą wzrastać o 1 (<code>minutesValue</code> + 1) i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setMinutes" name="Przyk.C5.82ad:_Zastosowanie_setMinutes">Przykład: Zastosowanie <code>setMinutes()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setMinutes(45);</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setmonth/index.html b/files/pl/web/javascript/referencje/obiekty/date/setmonth/index.html new file mode 100644 index 0000000000..7016cb97e1 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setmonth/index.html @@ -0,0 +1,56 @@ +--- +title: Date.prototype.setMonth() +slug: Web/JavaScript/Referencje/Obiekty/Date/setMonth +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia nazwę miesiąca dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre> + +<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>)</code></pre> + +<h3 id="Parameter" name="Parameter">Parametry</h3> + +<dl> + <dt><code>monthValue</code> </dt> + <dd>Liczba całkowita z przedziału 0 i 11 (reprezentuje miesiące od stycznia do grudnia).</dd> +</dl> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita z przedziału 1 i 31, reprezentuje dzień miesiąca.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametru <code>dayValue</code>, zostanie zwrócona wartość użytej metody <code>getDate</code>.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setMonth()</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 15 dla <code>monthValue</code>, rok wzrośnie o 1 (year + 1) i 3 będzie użyte dla miesiąca.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setMonth" name="Przyk.C5.82ad:_Zastosowanie_setMonth">Przykład: Zastosowanie <code>setMonth()</code></h3> + +<pre class="brush: js">var theBigDay = new Date; +theBigDay.setMonth(6); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setseconds/index.html b/files/pl/web/javascript/referencje/obiekty/date/setseconds/index.html new file mode 100644 index 0000000000..7a50dd98a7 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setseconds/index.html @@ -0,0 +1,56 @@ +--- +title: Date.prototype.setSeconds() +slug: Web/JavaScript/Referencje/Obiekty/Date/setSeconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia sekundy dla określonej daty stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre> + +<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>)</code></pre> + +<h2 id="Parametry" name="Parametry">Parametry</h2> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita z przedziału 0 i 59.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba z przedziału 0 i 999, reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametru <code>msValue</code>, wartość zwracana użytej metody {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setSeconds()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty zawarte w obiekcie {{jsxref("Date")}} będą wzrastać o 1 i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setSeconds" name="Przyk.C5.82ad:_Zastosowanie_setSeconds">Przykład: Zastosowanie <code>setSeconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setSeconds(30); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/settime/index.html b/files/pl/web/javascript/referencje/obiekty/date/settime/index.html new file mode 100644 index 0000000000..5aca5a36d7 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/settime/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.setTime() +slug: Web/JavaScript/Referencje/Obiekty/Date/setTime +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setTime +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia wartość obiektu {{jsxref("Date")}} stosownie do czasu lokalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setTime(<var>timeValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>timeValue</code> </dt> + <dd>Liczba całkowita reprezentująca liczbę milisekund liczonych od 1 stycznia 1970, 00:00:00.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Użyj metody <code>setTime()</code>, aby pomóc przydzielić dacie czas następnego obiektu {{jsxref("Date")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setTime" name="Przyk.C5.82ad:_Zastosowanie_setTime">Przykład: Zastosowanie <code>setTime()</code></h3> + +<pre class="brush: js">var theBigDay = new Date("July 1, 1999"); +var sameAsBigDay = new Date(); +sameAsBigDay.setTime(theBigDay.getTime()) +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getTime()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setutcdate/index.html b/files/pl/web/javascript/referencje/obiekty/date/setutcdate/index.html new file mode 100644 index 0000000000..81496f9c1f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setutcdate/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.setUTCDate() +slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCDate +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia dzień miesiąca dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCDate(<var>dayValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita od 1 do 31, reprezentująca dni miesiąca.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCDate()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 40 dla <code>dayValue</code>, i nazwa miesiąca jaki jest w danym momencie przechowywany w obiekcie {{jsxref("Date")}} będzie czerwcem, to do dni przypiszemy wartość 10, ale wyświetlaną nazwą miesiąca będzie już lipiec.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCDate" name="Przyk.C5.82ad:_Zastosowanie_setUTCDate">Przykład: Zastosowanie <code>setUTCDate()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCDate(20); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setutcfullyear/index.html b/files/pl/web/javascript/referencje/obiekty/date/setutcfullyear/index.html new file mode 100644 index 0000000000..71ea1db756 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setutcfullyear/index.html @@ -0,0 +1,57 @@ +--- +title: Date.prototype.setUTCFullYear() +slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCFullYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia pełen rok dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>yearValue</code> </dt> + <dd>Liczba całkowita określająca numerycznie wartość roku, na przykład: 1995.</dd> +</dl> + +<dl> + <dt><code>monthValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 11, reprezentuje nazwy miesięcy, od stycznia do grudnia.</dd> +</dl> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita pomiędzy 1 a 31, reprezentuje dzień miesiąca. Jeśli określimy parametr <code>dayValue</code>, to musimy także sprecyzować <code>monthValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametrów <code>monthValue</code> i <code>dayValue</code>, wartość zwracana metod {{jsxref("Date.prototype.getUTCMonth()", "getUTCMonth()")}} i {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}} jest w użyciu.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCFullYear()</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 15 dla <code>monthValue</code>, lata będą wzrastać o 1 (rok + 1), i 3 jest użyta jako miesiąc.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCFullYear" name="Przyk.C5.82ad:_Zastosowanie_setUTCFullYear">Przykład: Zastosowanie <code>setUTCFullYear()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCFullYear(1997); +</pre> + +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setutchours/index.html b/files/pl/web/javascript/referencje/obiekty/date/setutchours/index.html new file mode 100644 index 0000000000..437e4bae2f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setutchours/index.html @@ -0,0 +1,62 @@ +--- +title: Date.prototype.setUTCHours() +slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCHours +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia godzinę dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>hoursValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 23, reprezentująca godzinę.</dd> +</dl> + +<dl> + <dt><code>minutesValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 59, reprezentująca minutami.</dd> +</dl> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, to musisz także określić parametr <code>minutesValue</code>.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, to musisz także określić parametry <code>minutesValue</code> i <code>secondsValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametrów <code>minutesValue</code>, <code>secondsValue</code> i <code>msValue</code>, wartość zwracana będzie użytych metod {{jsxref("Date.prototype.getUTCMinutes()", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} i {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCHours()</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty zawarte w obiekcie <code>Date</code> będą wzrastać o 1 i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCHours" name="Przyk.C5.82ad:_Zastosowanie_setUTCHours">Przykład: Zastosowanie <code>setUTCHours()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCHours(8); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setutcmilliseconds/index.html b/files/pl/web/javascript/referencje/obiekty/date/setutcmilliseconds/index.html new file mode 100644 index 0000000000..f12fd4c838 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setutcmilliseconds/index.html @@ -0,0 +1,45 @@ +--- +title: Date.prototype.UTCMilliseconds() +slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia milisekundy dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMilliseconds(<var>millisecondsValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>millisecondsValue</code> </dt> + <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli parametr, który określiłeś jest z poza szeregu, <code>setUTCMilliseconds()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz 1100 dla <code>millisecondsValue</code>, sekunda przechowana w obiekcie {{jsxref("Date")}} wzrośnie o 1 i wartość 100 będzie użyta dla milisekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_setUTCMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_setUTCMilliseconds">Przykład: Zastosowanie <code>setUTCMilliseconds()</code></h4> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCMilliseconds(500); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setutcminutes/index.html b/files/pl/web/javascript/referencje/obiekty/date/setutcminutes/index.html new file mode 100644 index 0000000000..d3ea20bafa --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setutcminutes/index.html @@ -0,0 +1,57 @@ +--- +title: Date.prototype.setUTCMinutes() +slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCMinutes +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia minuty dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>minutesValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca minuty.</dd> +</dl> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, musisz także określić <code>minutesValue</code>.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba pomiędzy 0 i 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, musisz także określić <code>minutesValue</code> i <code>secondsValue</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określono parametrów <code>secondsValue</code> i <code>msValue</code>, są użyte wartości zwracanych metod {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} i {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCMinutes()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty (<code>minutesValue</code>) będą wzrastać o 1 (<code>minutesValue</code> + 1) i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCMinutes" name="Przyk.C5.82ad:_Zastosowanie_setUTCMinutes">Przykład: Zastosowanie <code>setUTCMinutes()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCMinutes(43); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setutcmonth/index.html b/files/pl/web/javascript/referencje/obiekty/date/setutcmonth/index.html new file mode 100644 index 0000000000..78448e441f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setutcmonth/index.html @@ -0,0 +1,52 @@ +--- +title: Date.prototype.setUTCMonth() +slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCMonth +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia miesiąc dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>monthValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 11, reprezentująca nazwy miesięcy od stycznia do grudnia.</dd> +</dl> + +<dl> + <dt><code>dayValue</code> </dt> + <dd>Liczba całkowita od 1 do 31, reprezentująca dzień miesiąca.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametru <code>dayValue</code>, zostanie zwrócona wartość użytej metody {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCMonth()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 15 dla <code>monthValue</code>, rok wzrośnie o 1 (rok + 1) i 3, które pozostało będzie użyte dla miesiąca.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCMonth" name="Przyk.C5.82ad:_Zastosowanie_setUTCMonth">Przykład: Zastosowanie <code>setUTCMonth()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCMonth(11); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setutcseconds/index.html b/files/pl/web/javascript/referencje/obiekty/date/setutcseconds/index.html new file mode 100644 index 0000000000..8e8d003b67 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setutcseconds/index.html @@ -0,0 +1,52 @@ +--- +title: Date.prototype.setUTCSeconds() +slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCSeconds +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia sekundy dla określonej daty stosownie do czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>secondsValue</code> </dt> + <dd>Liczba całkowita pomiędzy 0 a 59.</dd> +</dl> + +<dl> + <dt><code>msValue</code> </dt> + <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli nie określisz parametru <code>msValue</code>, wartość zwracana jest z użytej metody {jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p> + +<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCSeconds()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty zawarte w obiekcie {{jsxref("Date")}} będą wzrastać o 1 i wartość 40 będzie użyta dla sekund.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCSeconds" name="Przyk.C5.82ad:_Zastosowanie_setUTCSeconds">Przykład: Zastosowanie <code>setUTCSeconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCSeconds(20); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/setyear/index.html b/files/pl/web/javascript/referencje/obiekty/date/setyear/index.html new file mode 100644 index 0000000000..ac89b296c7 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/setyear/index.html @@ -0,0 +1,52 @@ +--- +title: Date.prototype.setYear() +slug: Web/JavaScript/Referencje/Obiekty/Date/setYear +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setYear +--- +<p>{{jSRef}}{{ Deprecated_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Ustawia rok dla określonej daty stosownie do czasu lokalnego. Aby móc korzystać z roczników przed i po roku 2000, powinieneś użyć metody {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} zawierającej <code>setYear()</code>, która rok potrafi określić w pełni.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setYear(<var>yearValue</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>yearValue</code> </dt> + <dd>Liczba całkowita.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli <code>yearValue</code> jest liczbą pomiędzy 0 a 99 (inclusive), to rok dla <code>dateObjectName</code> jest ustawiany - 1900 + <code>yearValue</code>. W innym przypadku, rok dla <code>dateObjectName</code> jest ustawiany w postaci wyświetlenia <code>yearValue</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_setYear" name="Przyk.C5.82ad:_Zastosowanie_setYear">Przykład: Zastosowanie <code>setYear()</code></h3> + +<p>Dwie pierwsze linie ustawiają rok w dacie na 1996. Trzecia ustawia rok na 2000.</p> + +<pre class="brush: js">var theBigDay = new Date(); + +theBigDay.setYear(96) +theBigDay.setYear(1996) +theBigDay.setYear(2000) +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/togmtstring/index.html b/files/pl/web/javascript/referencje/obiekty/date/togmtstring/index.html new file mode 100644 index 0000000000..2b4c296723 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/togmtstring/index.html @@ -0,0 +1,44 @@ +--- +title: Date.prototype.toGMTString() +slug: Web/JavaScript/Referencje/Obiekty/Date/toGMTString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toGMTString +--- +<p>{{JSRef}}{{ Deprecated_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Konwertuje datę na łańcuch znaków używając konwersji czasu GMT. Dokładny format zwracanych wartości <code>toGMTString()</code> różni się w zależności platformy.</p> + +<div class="note"> +<p>Metoda <code>toGMTString</code> jest nie długo używana i została ona zastąpiona metodą {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}. Powinieneś używać {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}} zamiast <code>toGMTSTring</code>().</p> +</div> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toGMTString()</code></pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toGMTString" name="Przyk.C5.82ad:_Zastosowanie_toGMTString">Przykład: Zastosowanie <code>toGMTString()</code></h3> + +<p>W następującym przykładzie jest dzisiejsza data obiektu <code>Date</code>:</p> + +<pre class="brush: js">var today = new Date(); +var str = today.toGMTString(); + +console.log(str); // Mon, 18 Dec 1995 17:28:35 GMT</pre> + +<p>W tym przykładzie metoda <code>toGMTString</code> konwertuje datę w czasie GMT (UTC) używanego przez system operacyjny w odpowiedniej strefie czasowej i zwraca wartość łańcucha znaków, która jest podobna do następującej formy. Format jest w pełni zależny od platformy.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/tojson/index.html b/files/pl/web/javascript/referencje/obiekty/date/tojson/index.html new file mode 100644 index 0000000000..2509e99319 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/tojson/index.html @@ -0,0 +1,70 @@ +--- +title: Date.prototype.toJSON() +slug: Web/JavaScript/Referencje/Obiekty/Date/toJSON +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toJSON +--- +<div>{{JSRef}}</div> + +<div>Zwraca objekt {{jsxref("Date")}} w postaci tekstu.</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toJSON()</code> +</pre> + +<h2 id="Opis">Opis</h2> + +<p><code>toJSON()</code> zwraca ciąg znaków (using {{jsxref("Date.prototype.toISOString()", "toISOString()")}}) reprezentujący wartość obiektu {{jsxref("Date")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_toJSON()">Użycie <code>toJSON()</code></h3> + +<pre class="brush:js">var jsonDate = (new Date()).toJSON(); +var backToDate = new Date(jsonDate); + +console.log(jsonDate); //2015-10-26T07:46:36.611Z +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.44', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Początkowa definicja zaimplementowana w JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Date.toJSON")}}</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/tolocaledatestring/index.html b/files/pl/web/javascript/referencje/obiekty/date/tolocaledatestring/index.html new file mode 100644 index 0000000000..c3b4b44198 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/tolocaledatestring/index.html @@ -0,0 +1,55 @@ +--- +title: Date.prototype.toLocaleDateString() +slug: Web/JavaScript/Referencje/Obiekty/Date/toLocaleDateString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca "date", porcje daty jako łańcuch znaków, używając aktualnych lokalnych konwersji.</p> + +<p>Metoda <code>toLocaleDateString</code> polega na znalezieniu formatu daty w systemie operacyjnym. Konwertuje datę do łańcucha znakowego używając konwencji formatowania systemu operacyjnego, gdzie skrypt jest uruchomiony. Na przykład, w USA, miesiąc pojawia się przed dniem (04/15/98), gdzie w Niemczech data wyświetla miesiąc po dniu (15.04.98). Jeśli system operacyjny nie używa, nie spełnia roku 2000 i nie używa pełnego roku dla lat przed 1900 lub po 2000, <code>toLocaleDateString</code> zwraca łańcuch znakowy, który nie jest uległy wobec roku 2000. <code>toLocaleDateString</code> postępuje podobnie do <code>toString</code>, kiedy konwertuje rok, który system operacyjny ma w niewłaściwym formacie.</p> + +<p>Metody takie jak <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getHours">getHours</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getMinutes">getMinutes</a></code> i <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getSeconds">getSeconds</a></code> dają więcej przenośnych rezultatów niż <code>toLocaleDateString</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleDateString([<var>locales</var> [, <var>options</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Check the {{anch("Browser compatibility")}} section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleDateString$edit#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div> + +<p>The default value for each date-time component property is {{jsxref("Global_Objects/undefined", "undefined")}}, but if the <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code> properties are all {{jsxref("Global_Objects/undefined", "undefined")}}, then <code>year</code>, <code>month</code>, and <code>day</code> are assumed to be <code>"numeric"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toLocaleDateString" name="Przyk.C5.82ad:_Zastosowanie_toLocaleDateString">Przykład: Zastosowanie <code>toLocaleDateString()</code></h3> + +<p>Następujący przykład <code>today</code> jest obiektem <code>Date</code>:</p> + +<pre class="brush: js">var today = new Date(95,11,18,17,28,35) //miesiąc jest reprezentowany przez liczby od 0 do 11 +today.toLocaleDateString() +</pre> + +<p>W tym przykładzie, <code>toLocaleDateString</code> zwraca łańcuch znakowy, który jest podobny do poniższej formy. Dokładny format, jaki znajduje się na platformie.</p> + +<pre>12/18/95 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/tolocalestring/index.html b/files/pl/web/javascript/referencje/obiekty/date/tolocalestring/index.html new file mode 100644 index 0000000000..60cb1c2853 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/tolocalestring/index.html @@ -0,0 +1,51 @@ +--- +title: Date.prototype.toLocaleString() +slug: Web/JavaScript/Referencje/Obiekty/Date/toLocaleString +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Konwertuje datę na łańcuch znakowy, używając aktualnej lokalnej konwersji.</p> + +<p>Metoda <code>toLocaleString</code> polega na znalezieniu formatu daty w systemie operacyjnym. Konwertuje datę do łańcucha znakowego używając konwencji formatowania systemu operacyjnego, gdzie skrypt jest uruchomiony. Na przykład, w USA, miesiąc pojawia się przed dniem (<b>04</b>/15/98), gdzie w Niemczech data wyświetla miesiąc, zaraz po dniu (15.<b>04</b>.98). Jeśli system operacyjny nie używa, nie spełnia roku 2000 i nie używa pełnego roku dla lat przed 1900 lub po 2000, <code>toLocaleString</code> zwraca łańcuch znakowy, który nie jest uległy wobec roku 2000. <code>toLocaleString</code> postępuje podobnie do <code>toString</code>, kiedy konwertuje rok, który system operacyjny ma w niewłaściwym formacie.</p> + +<p>Metody, takie jak <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getHours">getHours</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getMinutes">getMinutes</a></code> i <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getSeconds">getSeconds</a></code> dają więcej przenośnych rezultatów niż <code>toLocaleString</code></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleString([<var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Check the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleString$edit#Browser_Compatibility">Browser compatibility</a> section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleString$edit#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div> + +<p>The default value for each date-time component property is {{jsxref("Global_Objects/undefined", "undefined")}}, but if the <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, <code>second</code> properties are all {{jsxref("Global_Objects/undefined", "undefined")}}, then <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, and <code>second</code> are assumed to be <code>"numeric"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Zastosowanie_toLocaleString" name="Zastosowanie_toLocaleString">Zastosowanie <code>toLocaleString()</code></h3> + +<p>W następującym przykładzie, obiekt <code>today</code> jest <code>Date</code>:</p> + +<pre class="brush: js">var today = new Date(95,11,18,17,28,35); //miesiące są reprezentowane poprzez liczby od 0 do 11 +today.toLocaleString(); // 12/18/95 17:28:35</pre> + +<p>W tym przykładzie, <code>toLocaleString</code> zwraca łańcuch znaków, który jest podobny do następującej formy. Dokładnie to taki format, jaki jest w systemie.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/tolocaletimestring/index.html b/files/pl/web/javascript/referencje/obiekty/date/tolocaletimestring/index.html new file mode 100644 index 0000000000..e41dce512d --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/tolocaletimestring/index.html @@ -0,0 +1,52 @@ +--- +title: Date.prototype.toLocaleTimeString() +slug: Web/JavaScript/Referencje/Obiekty/Date/toLocaleTimeString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca "czas", porcje daty jako łańcuch znaków, używając aktualnych lokalnych konwersji.</p> + +<p>Metoda <code>toLocaleTimeString</code> polega na znalezieniu formatu daty w systemie operacyjnym. Konwertuje datę do łańcucha znakowego używając konwencji formatowania systemu operacyjnego, gdzie skrypt jest uruchomiony. Na przykład, w USA, miesiąc pojawia się przed dniem (04/15/98), gdzie w Niemczech data wyświetla miesiąc po dniu (15.04.98). Jeśli system operacyjny nie używa, nie spełnia roku 2000 i nie używa pełnego roku dla lat przed 1900 lub po 2000, <code>toLocaleTimeString</code> zwraca łańcuch znakowy, który nie jest uległy wobec roku 2000. <code>toLocaleTimeString</code> postępuje podobnie do <code>toString</code>, kiedy konwertuje rok, który system operacyjny ma w nie właściwym formacie.</p> + +<p>Metody takie jak <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getHours">getHours</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getMinutes">getMinutes</a></code> i <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getSeconds">getSeconds</a></code> dają więcej podobnych rezultatów niż <code>toLocaleTimeString</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleTimeString([<var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Check the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleTimeString$edit#Browser_Compatibility">Browser compatibility</a> section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleTimeString$edit#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div> + +<p>The default value for each date-time component property is {{jsxref("Global_Objects/undefined", "undefined")}}, but if the <code>hour</code>, <code>minute</code>, <code>second</code> properties are all {{jsxref("Global_Objects/undefined", "undefined")}}, then <code>hour</code>, <code>minute</code>, and <code>second</code> are assumed to be <code>"numeric"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Zastosowanie_toLocaleTimeString" name="Zastosowanie_toLocaleTimeString">Zastosowanie <code>toLocaleTimeString()</code></h4> + +<p>W następującym przykładzie, <code>today</code> jest obiektem <code>Date</code> object:</p> + +<pre class="brush: js">var today = new Date(95,11,18,17,28,35); //miesiące są reprezentowane przez liczby od 0 do 11 +today.toLocaleTimeString(); // 17:28:35</pre> + +<p>W tym przykładzie, <code>toLocaleTimeString</code> zwraca wartość łańcucha znakowego, która jest podobna do następującej formy. Dokładny format, jaki znajduje się na platformie.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/tosource/index.html b/files/pl/web/javascript/referencje/obiekty/date/tosource/index.html new file mode 100644 index 0000000000..8c82e39b09 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/tosource/index.html @@ -0,0 +1,49 @@ +--- +title: Date.prototype.toSource() +slug: Web/JavaScript/Referencje/Obiekty/Date/toSource +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toSource() +Date.toSource()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Metoda <code>toSource()</code> zwraca następującą wartość:</p> + +<ul> + <li>Dla wewnętrznej budowy obiekt {{jsxref("Date")}}, <code>toSource()</code> zwraca następujący łańcuch znaków sygnalizując, który kod źródłowy jest nieosiągalny:</li> +</ul> + +<pre class="brush: js">function Date() { + [native code] +} +</pre> + +<ul> + <li>Dla instancji {{jsxref("Date")}}, <code>toSource()</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Ta metoda jest często nazywana wewnętrzną metodą JavaScript i jest nie wyraźna w kodzie.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/date/tostring/index.html new file mode 100644 index 0000000000..7d2ea5d92c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/tostring/index.html @@ -0,0 +1,49 @@ +--- +title: Date.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/Date/toString +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków, reprezentujący określony obiekt <code>Date</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toString()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Date")}} przesłania metodę <code>toString</code> z obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref("Date")}}, metoda <code>toString()</code> zwraca łańcuch znaków, które reprezentują obiekt.</p> + +<p>JavaScript wywołuje metodę <code>toString()</code> automatycznie wtedy, gdy data jest reprezentowana jako wartość tekstowa lub kieruje powiązanym łańcuchem znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toString" name="Przyk.C5.82ad:_Zastosowanie_toString">Przykład: Zastosowanie <code>toString()</code></h3> + +<p>Następujący przykład przydziela <code>toString</code> wartość obiektu <code>Date</code> do <code>myVar</code>:</p> + +<pre class="brush: js">var x = new Date(); +myVar=x.toString(); //przydziela wartość myVar, podobnie do: +// Mon Sep 28 14:36:22 GMT-0700 (Pacific Daylight Time) 1998 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/toutcstring/index.html b/files/pl/web/javascript/referencje/obiekty/date/toutcstring/index.html new file mode 100644 index 0000000000..529b9bf434 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/toutcstring/index.html @@ -0,0 +1,43 @@ +--- +title: Date.prototype.toUTCString() +slug: Web/JavaScript/Referencje/Obiekty/Date/toUTCString +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toUTCString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Konwertuje datę na łańcuch znaków, używając do konwersji czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toUTCString()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość zwracana przez <code>toUTCString()</code> jest sformatowanym i tylko do odczytu łańcuchem znaków, stosowanym do konwersji UTC. Wartość zwracanego formatu może być określona stosownie do platformy.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toUTCString" name="Przyk.C5.82ad:_Zastosowanie_toUTCString">Przykład: Zastosowanie <code>toUTCString()</code></h3> + +<pre class="brush: js language-js">var today = new Date(); +var UTCstring = today.toUTCString(); +<code class="language-js"><span class="token comment">// Mon, 03 Jul 2006 21:44:38 GMT</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toISOString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/utc/index.html b/files/pl/web/javascript/referencje/obiekty/date/utc/index.html new file mode 100644 index 0000000000..0bc3a38e6c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/utc/index.html @@ -0,0 +1,69 @@ +--- +title: Date.UTC() +slug: Web/JavaScript/Referencje/Obiekty/Date/UTC +tags: + - Date + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Akceptuje te same parametry co najdłuższa forma konstruktora i zwraca liczbę milisekund w obiekcie {{jsxref("Date")}}, które upłynęły od 1 stycznia, 1970, 00:00:00, czasu uniwersalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Date.UTC(<em>rok</em>,<em> miesiąc</em>[,<em> dzień</em>[,<em> godz</em>[,<em> min</em>[,<em> sek</em>[, ms]]]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>rok</code> </dt> + <dd>Rok po 1900.</dd> + <dt><code>miesiąc</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 11 reprezentująca miesiąc.</dd> + <dt><code>dzień</code> </dt> + <dd>Liczba całkowita pomiędzy 1 i 31 reprezentująca dzień miesiąca.</dd> + <dt><code>godz</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 23 reprezentująca godziny.</dd> + <dt><code>min</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59 reprezentująca minuty.</dd> + <dt><code>sek</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 59 reprezentująca sekundy.</dd> + <dt><code>ms</code> </dt> + <dd>Liczba całkowita pomiędzy 0 i 999 reprezentująca milisekundy.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>UTC</code> pobiera parametry daty oddzielone za pomocą przecinków i zwraca liczbę milisekund między 1 stycznia, 1970, 00:00:00, czasu uniwersalnego a określoną datą.</p> + +<p>Powinno używać się pełnego zapisu roku, na przykład 1998. Jeśli określony jest rok z przedziału pomiędzy 0 a 99, metoda konwertuje go do roku w 20 wieku (1900 + rok); na przykład, jeśli określiłeś go jako 95, zostanie użyty rok 1995.</p> + +<p>Metoda <code>UTC</code> różni się od konstruktora {{jsxref("Date")}} na dwa sposoby.</p> + +<ul> + <li><code>Date.UTC</code> używa czasu uniwersalnego zamiast lokalnego.</li> + <li><code>Date.UTC</code> zwraca wartość czasu jako liczbę zamiast tworzenia obiektu typu {{jsxref("Date")}}.</li> +</ul> + +<p>Jeśli parametr określony jest poza spodziewanym zasięgiem, metoda <code>UTC</code> zaktualizuje pozostałe parametry. Na przykład, jeśli użyjesz liczby 15 do określenia miesiąca, wartość parametru <code>rok</code> zostanie powiększona o 1 (rok + 1), a 3 zostanie użyte w parametrze <code>miesiąc</code>.</p> + +<p>Ponieważ <code>UTC</code> jest statyczną metodą obiektu {{jsxref("Date")}}, zawsze powinno używać się jej jako <code>Date.UTC()</code>, niż jako metodę utworzonego obiektu {{jsxref("Date")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Date.UTC" name="Przyk.C5.82ad:_Zastosowanie_Date.UTC">Przykład: Zastosowanie <code>Date.UTC()</code></h3> + +<p>Następująca instrukcja tworzy obiekt <code>Date</code> używający GMT (czasu uniwersalnego) zamiast czasu lokalnego:</p> + +<pre class="brush: js">var utcDate = new Date(Date.UTC(96, 11, 1, 0, 0, 0)); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.parse()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/date/valueof/index.html b/files/pl/web/javascript/referencje/obiekty/date/valueof/index.html new file mode 100644 index 0000000000..76d54c2187 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/date/valueof/index.html @@ -0,0 +1,46 @@ +--- +title: Date.prototype.valueOf() +slug: Web/JavaScript/Referencje/Obiekty/Date/valueOf +tags: + - Date + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date/valueOf +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca prymitywną wartość obiektu <code>Date</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.valueOf()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Metoda <code>valueOf</code> zwraca wartość prymitywną obiektu {{jsxref("Date")}} jako typ danych liczbowych, czyli liczbę milisekund od północy 1 stycznia 1970 UTC.</p> + +<p>Ta metoda jest funkcyjnie równoważna do metody {{jsxref("Date.prototype.getTime()")}}.</p> + +<p>Ta metoda często jest nazywana wewnętrzną metodą JavaScriptu i nie jest wyraźna w kodzie.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_valueOf" name="Przyk.C5.82ad:_Zastosowanie_valueOf">Przykład: Zastosowanie <code>valueOf()</code></h3> + +<pre class="brush: js">var x = new Date(56, 6, 17); +var myVar = x.valueOf(); // przydziela -424713600000 do myVar +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> + <li>{{jsxref("Date.prototype.getTime()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/decodeuri/index.html b/files/pl/web/javascript/referencje/obiekty/decodeuri/index.html new file mode 100644 index 0000000000..f88686b8a3 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/decodeuri/index.html @@ -0,0 +1,39 @@ +--- +title: decodeURI() +slug: Web/JavaScript/Referencje/Obiekty/decodeURI +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/decodeURI +--- +<div>{{jsSidebar("Objects")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Dekoduje Jednolity Identyfikator Zasobu (URI) utworzony wcześniej przez funkcję {{jsxref("encodeURI", "encodeURI()")}} lub podobną.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>decodeURI(<i>encodedURI</i>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>encodedURI</code> </dt> + <dd>Kompletny, odkodowany Jednolity Identyfikator Zasobu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Podmienia każdą sekwencję ucieczki (ang. + <i>escape sequence</i> + ) w zakodowanym URI znakiem, który reprezentuje.</p> + +<p>Nie dekoduje sekwencji, które nie mogłyby być wprowadzone przez {{jsxref("encodeURI", "encodeURI()")}}.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li> + <li>{{jsxref("encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/decodeuricomponent/index.html b/files/pl/web/javascript/referencje/obiekty/decodeuricomponent/index.html new file mode 100644 index 0000000000..a361e777d8 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/decodeuricomponent/index.html @@ -0,0 +1,41 @@ +--- +title: decodeURIComponent() +slug: Web/JavaScript/Referencje/Obiekty/decodeURIComponent +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Dekoduje komponent Jednolitego Identyfikatora Zasobu (URI) stworzonego przez {{jsxref("encodeURIComponent", "encodeURIComponent()")}} lub podobną.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>decodeURIComponent(<em>encodedURI</em>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>encodedURI</code> </dt> + <dd>Odkodowany komponent Jednolitego Identyfikatora Zasobu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Podmienia każdą sekwencję ucieczki (ang. + <i>escape sequence</i> + ) w zakodowanym komponencie URI znakiem, który ona reprezentuje.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/encodeuri/index.html b/files/pl/web/javascript/referencje/obiekty/encodeuri/index.html new file mode 100644 index 0000000000..b794a414b3 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/encodeuri/index.html @@ -0,0 +1,72 @@ +--- +title: encodeURI() +slug: Web/JavaScript/Referencje/Obiekty/encodeURI +tags: + - JavaScript + - URI +translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Koduje Jednolity Identyfikator Zasobu (URI) poprzez zamianę każdego z wystąpień pewnych znaków na jedną, dwie lub trzy sekwencje ucieczki (ang. + <i>escape sequences</i> + ) kodowania UTF-8 danego znaku.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>encodeURI(<em>URI</em>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>URI</code> </dt> + <dd>Kompletny Jednolity Identyfikator Zasobu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Zakłada się, iż URI jest kompletnym URI, więc nie koduje znaków zarezerwowanych, mających specjalne znaczenie w URI.</p> + +<p><code>encodeURI</code> zamienia wszystkie znaki, poza podanymi poniżej, odpowiednimi sekwencjami ucieczki.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Typ</td> + <td class="header">Zawiera</td> + </tr> + <tr> + <td>Znaki zarezerwowane</td> + <td><code>; , / ? : @ & = + $</code></td> + </tr> + <tr> + <td>Znaki nie podlegające ucieczce</td> + <td>Litery, cyfry, <code>- _ . ! ~ * ' ( )</code></td> + </tr> + <tr> + <td> + <i>Score</i> + </td> + <td><code>#</code></td> + </tr> + </tbody> +</table> + +<p>Zauważ, że <code>encodeURI</code> samo z siebie + + <i>nie</i> + potrafi utworzyć poprawnych żądań HTTP GET i POST, jak na przykład XMLHTTPRequest, ponieważ "&", "+", i "=" nie są kodowane, a są traktowane jako znaki specjalne w żądaniach GET i POST. Jednakże, {{jsxref("encodeURIComponent", "encodeURIComponent()")}}, koduje te znaki. Zachowania te są konsekwentnie wspomagane przez różne przeglądarki.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li> + <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/encodeuricomponent/index.html b/files/pl/web/javascript/referencje/obiekty/encodeuricomponent/index.html new file mode 100644 index 0000000000..577cff9840 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/encodeuricomponent/index.html @@ -0,0 +1,38 @@ +--- +title: encodeURIComponent() +slug: Web/JavaScript/Referencje/Obiekty/encodeURIComponent +tags: + - JavaScript + - URI +translation_of: Web/JavaScript/Reference/Global_Objects/encodeURIComponent +--- +<div>{{jsSidebar("Objects")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Koduje każdy komponent Jednolitego Identyfikatora Zasobu (URI) poprzez zamianę, każdego wystąpienia pewnych znaków jedną, dwoma lub trzema sekwencjami ucieczki reprezentujące kodowanie UTF-8 znaku.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox">encodeURIComponent(str);</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>str</code></dt> + <dd>Komponent Jednolitego Identyfikatora Zasobu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>encodeURIComponent()</code> zamienia wszystkie znaki na sekwencje ucieczki poza znakami: alfabetycznymi, cyframi, <code>- _ . ! ~ * ' ( )</code></p> + +<p>Ze względów bezpieczeństwa, powinieneś wywoływać <code>encodeURIComponent</code> na każdym parametrze podanym przez użytkownika, który będzie podany jako część URI. Na przykład, użytkownik mógł wpisać "<code>Thyme &time=again</code>" dla zmiennej <code>comment</code>. Nie użycie <code>encodeURIComponent</code> na tej zmiennej da <code>comment=Thyme%20&time=again</code>. Zauważ, że znak ampersand (<em>&</em>) i znak równości (<em>=</em> ) oznaczają nową parę kluczy i wartość. Więc, zamiast wysyłać klucz <code>comment</code> równy <code>Thyme &time=again</code>, dostaniesz dwa klucze POST, jeden równy "Thyme" , a drugi (<code>time</code>) równy again.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/columnnumber/index.html b/files/pl/web/javascript/referencje/obiekty/error/columnnumber/index.html new file mode 100644 index 0000000000..dbf51b3bf3 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/columnnumber/index.html @@ -0,0 +1,81 @@ +--- +title: Error.prototype.columnNumber +slug: Web/JavaScript/Referencje/Obiekty/Error/columnNumber +translation_of: Web/JavaScript/Reference/Global_Objects/Error/columnNumber +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>The <code><strong>columnNumber</strong></code> property contains the column number in the line of the file that raised this error.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_columnNumber">Using <code>columnNumber</code></h3> + +<pre class="brush: js">var e = new Error('Could not parse input'); +throw e; +console.log(e.columnNumber) // 0 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<p>Not part of any specification. Non-standard.</p> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/filename/index.html b/files/pl/web/javascript/referencje/obiekty/error/filename/index.html new file mode 100644 index 0000000000..a0290eac45 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/filename/index.html @@ -0,0 +1,49 @@ +--- +title: Error.prototype.fileName +slug: Web/JavaScript/Referencje/Obiekty/Error/fileName +tags: + - JavaScript + - Prototyp + - Prototype + - Właściwość + - niestandardowe +translation_of: Web/JavaScript/Reference/Global_Objects/Error/fileName +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Właściwość <code><strong>fileName</strong></code> zawiera ścieżkę do pliku, który spowodował błąd.</p> + +<h2 id="Opis">Opis</h2> + +<p>Ta nieopisana w żadnym standardzie właściwość zawiera ścieżkę do pliku, który spowodował błąd. Jeśli jest wywoływana z kontekstu debuggera, jak na przykład Firefox Developer Tools, zwracana jest wartość "debugger eval code".</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_fileName">Użycie <code>fileName</code></h3> + +<pre class="brush: js">var e = new Error('Błąd przy parsowaniu wejścia'); +throw e; +// wartość e.fileName powinna być czymś podobnym do "file:///C:/example.html" +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<p><span class="pl-s">Nie jest częścią żadnego standardu.</span></p> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Error.fileName")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}}</li> + <li>{{jsxref("Error.prototype.columnNumber")}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/index.html b/files/pl/web/javascript/referencje/obiekty/error/index.html new file mode 100644 index 0000000000..408b1b797b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/index.html @@ -0,0 +1,246 @@ +--- +title: Error +slug: Web/JavaScript/Referencje/Obiekty/Error +tags: + - Błąd + - CustomError + - Error + - JavaScript + - Obsługa błędów +translation_of: Web/JavaScript/Reference/Global_Objects/Error +--- +<div>{{JSRef}}</div> + +<div>Kontruktor klasy <strong><code>Error</code></strong> tworzy obiekt błędu. Instancja klasy <code>Error</code> jest rzucana w momencie napotkania błędu w trakcie wykonywania programu. Klasa <code>Error</code> może być także używana do tworzenia własnych wyjątków. Poniżej przestawione zostaną wbudowane standardowe typy błędów.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">new Error([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Opcjonalny. Opis błędu zrozumiały dla użytkownika.</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Opcjonalny. Wartość dla parametru <code>fileName</code> przy tworzeniu obiektu <code>Error</code>. Domyślnie to nazwa pliku zawierającego kod, który wywołał konstruktor.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Opcjonalny. Wartość dla paramteru <code>lineNumber</code> przy tworzeniu obiektu <code>Error</code>. Domyślnie zawiera numer linijki zawirającej wywołanie konstruktora klasy <code>Error</code>.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Błędy w trakcie wykonywania programu skutkują utworzeniem i rzuceniem nowego obiektu <code>Error</code>.</p> + +<p>This page documents the use of the <code>Error</code> object itself and its use as a constructor function. For a list of properties and methods inherited by <code>Error</code> instances, see {{jsxref("Error.prototype")}}.</p> + + + +<h3 id="Używanie_jako_funkcja">Używanie jako funkcja</h3> + +<p>Gdy <code>Error</code> jest używany jako funkcja -- bez słowa kluczowego <code>new</code>, zwraca on obiekt <code>Error</code>. Możemy więc zauważyć, że zwykłe wywołanie <code>Error</code> zwróci nam to samo co stworznie nowego obiektu <code>Error</code> przy pomocy słowa kluczowego <code>new</code>.</p> + +<pre class="notranslate"><code>// to: +const x = Error('Jestem stworzony przy pomocy wyowałania funkcji!'); +// działa tak samo jak to: +const y = new Error('Jestem stworzony przy pomocy słowa kluczowego "new"!');</code></pre> + + + +<h3 id="Typy_błędów">Typy błędów</h3> + +<p>Oprócz konstruktora generycznego <code>Error</code>, mamy jeszcze siedem innych podstawowych konstruktorów błędów w JavaScript. Dla wyjątów po stronie klienta zobacz <a href="/en-US/docs/Web/JavaScript/Guide/Statements#Exception_Handling_Statements">Exception Handling Statements</a>.</p> + +<dl> + <dt>{{jsxref("EvalError")}}</dt> + <dd>Tworzy instancje reprezentującą błąd dotyczący globalnej funkcji {{jsxref("Global_Objects/eval", "eval()")}}.</dd> + <dt>{{jsxref("InternalError")}} {{non-standard_inline}}</dt> + <dd>Tworzy instancje reprezentującą błąd, który występuje w momencie wyrzucenia wewnętrznego błędu silnika JavaScript np. "too much recursion".</dd> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tworzy instancje reprezentującą błąd, który występuje w momencie gdy zmienna numeryczna lub parametr wyjdzie poza zakres. </dd> + <dt>{{jsxref("ReferenceError")}}</dt> + <dd>Tworzy instancje reprezentującą błąd, który występuje przy próbie odwołania do nieistniejącego zasobu.</dd> + <dt>{{jsxref("SyntaxError")}}</dt> + <dd>Tworzy instancje reprezentującą błąd składni, który występuje przy parsowaniu kodu przy pomocy {{jsxref("Global_Objects/eval", "eval()")}}.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Tworzy instancję reprezentującą błąd, który występuje gdy zmienna lub parametr mają niepoprawny typ.</dd> + <dt>{{jsxref("URIError")}}</dt> + <dd>Tworzy instancję reprezentującą błąd, który występuje gdy {{jsxref("Global_Objects/encodeURI", "encodeURI()")}} i {{jsxref("Global_Objects/decodeURI", "decodeURI()")}} mają przekazane nieprawidłowe parametry.</dd> +</dl> + +<h2 id="Właściwości">Właściwości</h2> + +<dl> + <dt>{{jsxref("Error.prototype")}}</dt> + <dd>Pozwala na dodawanie właściwości do instancji klasy <code>Error</code>.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<p>Globalny obiekt <code>Error</code> sam w sobie nie zawiera metod, niemniej, dziedziczy on niektóre metody z łańcucha prototypów.</p> + +<h2 id="Error_instancje"><code>Error</code> instancje</h2> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/Error/prototype', 'Description')}}</div> + +<h3 id="Właściwości_2">Właściwości</h3> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/Error/prototype', 'Properties')}}</div> + +<h3 id="Metody_2">Metody</h3> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/Error/prototype', 'Methods')}}</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Rzucanie_ogólnego_błędu">Rzucanie ogólnego błędu</h3> + +<p>Zazwyczaj tworzysz obiekt <code>Error</code> w celu wywołania go przy użyciu słowa kluczowego {{jsxref("Statements/throw", "throw")}}. Możesz obsłużyć tak rzucony błąd przy pomocy konstrukcji {{jsxref("Statements/try...catch", "try...catch")}}:</p> + +<pre class="brush: js notranslate">try { + throw new Error('Whoops!'); +} catch (e) { + alert(e.name + ': ' + e.message); +} +</pre> + +<h3 id="Obsługa_specyficznych_błędów">Obsługa specyficznych błędów</h3> + +<p>Jeżeli chcesz możesz obsługiwać tylko specyficzny rodzaj błędu poprzez użycie właściwości jego {{jsxref("Object.prototype.constructor", "constructor")}} lub, jeżeli używasz nowoczesnego silnika JavaScript, poprzez słowo kluczowe {{jsxref("Operators/instanceof", "instanceof")}}:</p> + +<pre class="brush: js notranslate">try { + foo.bar(); +} catch (e) { + if (e instanceof EvalError) { + alert(e.name + ': ' + e.message); + } else if (e instanceof RangeError) { + alert(e.name + ': ' + e.message); + } + // ... etc +} +</pre> + +<h3 id="Niestandardowe_typy_błędów">Niestandardowe typy błędów</h3> + +<p>Możesz chcieć zdefiniować własny typ błędu pochodzący z klasy <code>Error</code> z możliwością rzucenia błędu <code>throw new MyError()</code> i użycia <code>instanceof MyError</code> w celu sprawdzenia jego rodzaju. Skutkuje to czystszym i spójniejszym kodem obsługi błędów. Zobacz <a href="http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript">"What's a good way to extend Error in JavaScript?"</a> na StackOverflow dla dogłębniejszej analizy.</p> + +<h4 id="ES6_Custom_Error_Class">ES6 Custom Error Class</h4> + +<div class="warning"> +<p>Babel i inne transpilatory nie potrafią poprawnie obsłużyć podanego kodu bez <a href="https://github.com/loganfsmyth/babel-plugin-transform-builtin-extend">dodatkowej konfiguracji</a>.</p> +</div> + +<div class="note"> +<p>Nie które przeglądarki dodają constructor <code>CustomError</code> w stosie błędu kiedy używamy klas ES2015</p> +</div> + +<pre class="brush: js notranslate">class CustomError extends Error { + constructor(foo = 'bar', ...params) { + // Pass remaining arguments (including vendor specific ones) to parent constructor + super(...params); + + // Maintains proper stack trace for where our error was thrown (only available on V8) + if (Error.captureStackTrace) { + Error.captureStackTrace(this, CustomError); + } + + // Custom debugging information + this.foo = foo; + this.date = new Date(); + } +} + +try { + throw new CustomError('baz', 'bazMessage'); +} catch(e){ + console.log(e.foo); //baz + console.log(e.message); //bazMessage + console.log(e.stack); //stacktrace +}</pre> + +<h4 id="ES5_Custom_Error_Object">ES5 Custom Error Object</h4> + +<div class="warning"> +<p><strong>Wszystkie</strong> przeględarki dodają konstruktor <code>CustomError </code>kiedy używasz konstruktora z wykorzystaniem prototype</p> +</div> + +<pre class="brush: js notranslate">function CustomError(foo, message, fileName, lineNumber) { + var instance = new Error(message, fileName, lineNumber); + instance.foo = foo; + Object.setPrototypeOf(instance, Object.getPrototypeOf(this)); + if (Error.captureStackTrace) { + Error.captureStackTrace(instance, CustomError); + } + return instance; +} + +CustomError.prototype = Object.create(Error.prototype, { + constructor: { + value: Error, + enumerable: false, + writable: true, + configurable: true + } +}); + +if (Object.setPrototypeOf){ + Object.setPrototypeOf(CustomError, Error); +} else { + CustomError.__proto__ = Error; +} + + +try { + throw new CustomError('baz', 'bazMessage'); +} catch(e){ + console.log(e.foo); //baz + console.log(e.message) ;//bazMessage +}</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Początkowa definicja. Zaimplementowana w JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11', 'Error')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-error-objects', 'Error')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-error-objects', 'Error')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error")}}</p> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Statements/throw", "throw")}}</li> + <li>{{jsxref("Statements/try...catch", "try...catch")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/linenumber/index.html b/files/pl/web/javascript/referencje/obiekty/error/linenumber/index.html new file mode 100644 index 0000000000..20d725f492 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/linenumber/index.html @@ -0,0 +1,57 @@ +--- +title: Error.prototype.lineNumber +slug: Web/JavaScript/Referencje/Obiekty/Error/lineNumber +tags: + - JavaScript + - Prototyp + - Prototype + - Referencja + - Własność + - niestandardowe +translation_of: Web/JavaScript/Reference/Global_Objects/Error/lineNumber +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Właściwość <code><strong>lineNumber</strong></code> zawiera numer linii w pliku, gdzie pojawił się błąd.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_lineNumber">Użycie <code>lineNumber</code></h3> + +<pre class="brush: js">var e = new Error('Błąd przy parsowaniu wejścia'); +throw e; +console.log(e.lineNumber) // 2 +</pre> + +<h3 id="Alternatywny_przykład_użycia_zdarzenia_error">Alternatywny przykład użycia zdarzenia <code>error</code></h3> + +<pre class="brush: js">window.addEventListener('error', function(e) { + console.log(e.lineNumber); // 5 +}); +var e = new Error('Błąd przy parsowaniu wejścia'); +throw e; +</pre> + +<p>Własność <code>lineNumber</code> jest niestandardowa i nie posiada szerokiego wsparcia – zobacz tabelę opisującą wsparcie przeglądarek dla tej własności.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<p><span class="pl-s">Nie jest częścią żadnego standardu.</span></p> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Error.lineNumber")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}}</li> + <li>{{jsxref("Error.prototype.columnNumber")}}</li> + <li>{{jsxref("Error.prototype.fileName")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/message/index.html b/files/pl/web/javascript/referencje/obiekty/error/message/index.html new file mode 100644 index 0000000000..1f3983fa6b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/message/index.html @@ -0,0 +1,108 @@ +--- +title: Error.prototype.message +slug: Web/JavaScript/Referencje/Obiekty/Error/message +translation_of: Web/JavaScript/Reference/Global_Objects/Error/message +--- +<div>{{JSRef}}</div> + +<p>Właściwość <code><strong>message</strong></code> jest komunikatem błędu zapisanym w sposób czytelny dla czlowieka.</p> + +<h2 id="Opis">Opis</h2> + +<p>Właściwość zawiera krótki opis błędu, jeśli jest dostępny, lub został ustawiony. <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> szeroko wykorzystuje właściwość <code>message</code> w wyjątkach. Właściwość <code>message</code> jest używany, wraz z właściwością {{jsxref("Error.prototype.name", "name")}} przez metodę {{jsxref("Error.prototype.toString()")}} do tworzenia tekstowej reprezentacji obiektu Error.</p> + +<p>Domyślnie właściwość <code>message </code>jest pustym stringiem, ale to zachowanie może zostać nadpisane w instancji, poprzez przekazanie komunikatu jako pierwszy parametr do {{jsxref("Error", "Error constructor")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Rzucanie_ustawionego_błędu">Rzucanie ustawionego błędu</h3> + +<pre class="brush: js">var e = new Error('Could not parse input'); // e.message is 'Could not parse input' +throw e; +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.4.3', 'Error.prototype.message')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype.message', 'Error.prototype.message')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.name")}}</li> + <li>{{jsxref("Error.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/name/index.html b/files/pl/web/javascript/referencje/obiekty/error/name/index.html new file mode 100644 index 0000000000..11521ec4fd --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/name/index.html @@ -0,0 +1,109 @@ +--- +title: Error.prototype.name +slug: Web/JavaScript/Referencje/Obiekty/Error/name +translation_of: Web/JavaScript/Reference/Global_Objects/Error/name +--- +<div>{{JSRef}}</div> + +<p>Właściwość <code><strong>name</strong></code> reprezentuję nazwę danego typu błędu. Początkową wartością jest "Error".</p> + +<h2 id="Opis">Opis</h2> + +<p>Domyślnie, instancje {{jsxref("Error")}} mają ustawioną nazwę "Error". Właściwość <code>name</code>, razem z właściwością {{jsxref("Error.prototype.message", "message")}}, jest używana przez metodę {{jsxref("Error.prototype.toString()")}} do tworzenia tekstowej reprezentacji obiektu Error.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Rzucanie_ustawionego_błędu">Rzucanie ustawionego błędu</h3> + +<pre class="brush: js">var e = new Error('Malformed input'); // e.name is 'Error' + +e.name = 'ParseError'; +throw e; +// e.toString() would return 'ParseError: Malformed input' +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.4.2', 'Error.prototype.name')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype.name', 'Error.prototype.name')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.message")}}</li> + <li>{{jsxref("Error.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/prototype/index.html b/files/pl/web/javascript/referencje/obiekty/error/prototype/index.html new file mode 100644 index 0000000000..37cb80c692 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/prototype/index.html @@ -0,0 +1,113 @@ +--- +title: Error.prototype +slug: Web/JavaScript/Referencje/Obiekty/Error/prototype +tags: + - Error + - JavaScript + - Właściwość +translation_of: Web/JavaScript/Reference/Global_Objects/Error +--- +<div>{{JSRef}}</div> + +<p>Właściwość <code><strong>Error.prototype</strong></code> reprezentuje prototyp dla konstruktora {{jsxref("Error")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis">Opis</h2> + +<p>Wszystkie instancje klasy {{jsxref("Error")}} oraz instancje {{jsxref("Global_Objects/Error", "non-generic errors", "#Error_types", 1)}} dziedziczą po <code>Error.prototype</code>. As with all constructor functions, you can use the prototype of the constructor to add properties or methods to all instances created with that constructor.</p> + +<h2 id="Właściwości">Właściwości</h2> + +<h3 id="Właściwości_standardowe">Właściwości standardowe</h3> + +<dl> + <dt><code>Error.prototype.constructor</code></dt> + <dd>Określa funkcję tworzącą instancję prototypu.</dd> + <dt>{{jsxref("Error.prototype.message")}}</dt> + <dd>Wiadomość błędu.</dd> + <dt>{{jsxref("Error.prototype.name")}}</dt> + <dd>Nazwa błędu.</dd> +</dl> + +<h3 id="Rozszerzenia_zależne_od_dostawcy">Rozszerzenia zależne od dostawcy</h3> + +<div>{{non-standard_header}}</div> + +<h4 id="Microsoft">Microsoft</h4> + +<dl> + <dt>{{jsxref("Error.prototype.description")}}</dt> + <dd>Opis błędu. Podobne do {{jsxref("Error.prototype.message", "message")}}.</dd> + <dt>{{jsxref("Error.prototype.number")}}</dt> + <dd>Numer błędu.</dd> +</dl> + +<h4 id="Mozilla">Mozilla</h4> + +<dl> + <dt>{{jsxref("Error.prototype.fileName")}}</dt> + <dd>Ścieżka do pliku, w którym wywołany został wyjątek.</dd> + <dt>{{jsxref("Error.prototype.lineNumber")}}</dt> + <dd>Numer linijki w pliku, która wywołała wyjątek.</dd> + <dt>{{jsxref("Error.prototype.columnNumber")}}</dt> + <dd>Numer znaku w wierszu, w którym został wywołany wyjątek.</dd> + <dt>{{jsxref("Error.prototype.stack")}}</dt> + <dd>Stack trace.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Zwraca łańcuch znaków zawierający źródło wybranego obiektu {{jsxref("Error")}}; możesz użyć tej. Overrides the {{jsxref("Object.prototype.toSource()")}} method.</dd> + <dt>{{jsxref("Error.prototype.toString()")}}</dt> + <dd>Zwraca ciąg znaków reprezentujący wybrany obiekt. Nadpisuje metodę {{jsxref("Object.prototype.toString()")}}.</dd> +</dl> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Początkowa definicja. Zaimplementowana w JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype', 'Error')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.prototype")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("Object.prototype")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/stack/index.html b/files/pl/web/javascript/referencje/obiekty/error/stack/index.html new file mode 100644 index 0000000000..01c2129f21 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/stack/index.html @@ -0,0 +1,127 @@ +--- +title: Error.prototype.stack +slug: Web/JavaScript/Referencje/Obiekty/Error/Stack +tags: + - JavaScript + - Prototyp + - Referencja + - Własność + - niestandardowe +translation_of: Web/JavaScript/Reference/Global_Objects/Error/Stack +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Niestandardowa własność <strong><code>stack</code></strong> obiektów {{jsxref("Error")}} podaje ścieżkę wywołań funkcji – które z nich były wywołane, w jakiej kolejności, z której linii i pliku, z jakimi argumentami. Stos wywołań zaczyna się od ostatnich wywołań, przez wcześniejsze, prowadząc do pierwotnego wywołania z zakresu globalnego.</p> + +<h2 id="Opis">Opis</h2> + +<p>Każdy krok będzie znajdował się w oddzielnej linii, zawierając w pierwszej części nazwę funkcji (jeśli nie jest to wywołanie z zakresu globalnego), następnie znak <em>at</em> (<code>@</code>), lokalizację pliku (z wyjątkiem sytuacji, w których funkcja jest konstruktorem zgłaszanego błędu), dwukropek oraz numer linii (jeśli zdefiniowana jest lokalizacja pliku). (Zauważ, że obiekt {{jsxref("Error")}} także posiada własności <code>fileName</code>, <code>lineNumber</code> i <code>columnNumber</code>, które można odczytać z danego błędu, jednak jedynie błędu, a nie jego stosu wywołań).</p> + +<p>Należy podkreślić, że opisany wyżej format jest formatem przeglądarki Firefox – nie ma standardu formatowania, jednakże Safari 6+ i Opera 12- używają bardzo podobnego formatu. Przeglądarki używające silnika JavaScript V8 (takie jak Chrome, Opera 15+, Android Browser) oraz IE10+, używają natomiast innego formatu (zobacz <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">archiwalną dokumentację MSDN dla error.stack</a>).</p> + +<p><strong>Wartości argumentów w stosie:</strong> w wersjach wcześniejszych niż Firefox 14, po nazwie funkcji następowały wartości argumentów przekonwertowane do łańcucha znaków (<em>string</em>) w nawiasach, przed znakiem <em>at</em> (<code>@</code>). Podczas gdy obiekt (lub tablica itp.) pojawia się w przekonwertowanej formie <code>"[object Object]"</code> i nie może być przekonwertowany z powrotem do właściwych obiektów, wartości skalarne mogą być odzyskane (choć być może — w Firefoksie 14 nadal jest to możliwe — łatwiej będzie użyć <code>arguments.callee.caller.arguments</code>, tak jak nazwa funkcji może być uzyskana przez <code>arguments.callee.caller.name</code>). <code>"undefined"</code> jest wylistowany jako <code>"(void 0)"</code>. Zauważ, że jeśli argumenty typu <em>string</em> były przekazane z wartościami takimi jak <code>"@"</code>, <code>"("</code>, <code>")"</code> (lub znaki te występują w nazwach plików), nie możesz polegać po prostu na podzieleniu linii na części składowe – <span class="tlid-translation translation" lang="pl"><span title="">dlatego w Firefoksie 14 i nowszych jest to mniejszy problem<strong>.</strong></span></span></p> + +<p>Różne przeglądarki ustawiają tę wartość w różnych momentach. Przykładowo, Firefox ustawia ją podczas tworzenia obiektu {{jsxref("Error")}}, natomiast PhantomJS ustawia ją jedynie podczas wyrzucania {{jsxref("Error")}} – i <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">archiwalna dokumentacja MSDN</a> również wydaje się zgadzać z implementacją PhantomJS.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_własności_stack">Użycie własności <code>stack</code></h3> + +<p>Poniższy dokument HTML prezentuje użycie własności <code>stack</code>.</p> + +<pre class="brush: html notranslate"><!DOCTYPE HTML> +<meta charset="UTF-8"> +<title>Stack Trace Example</title> +<body> +<script> +function trace() { + try { + throw new Error('myError'); + } + catch(e) { + alert(e.stack); + } +} +function b() { + trace(); +} +function a() { + b(3, 4, '\n\n', undefined, {}); +} +a('first call, firstarg'); +</script> +</pre> + +<p>Zakładając, że powyższy dokument zapisany jest pod adresem <code>C:\example.html</code> w systemie plików Windows, kod utworzy okno typu <em>alert</em> z następującą treścią:</p> + +<p>W przeglądarce Firefox 30 i późniejszych wersjach, wraz z numerem kolumny:</p> + +<pre class="notranslate"><samp>trace@file:///C:/example.html:9:17 +b@file:///C:/example.html:16:13 +a@file:///C:/example.html:19:13 +@file:///C:/example.html:21:9</samp></pre> + +<p>Od Firefoxa 14 do Firefoxa 29:</p> + +<pre class="notranslate"><samp>trace@file:///C:/example.html:9 +b@file:///C:/example.html:16 +a@file:///C:/example.html:19 +@file:///C:/example.html:21</samp></pre> + +<p>Firefox 13 i wcześniejsze zwróci zamiast tego następujący tekst:</p> + +<pre class="notranslate"><samp>Error("myError")@:0 +trace()@file:///C:/example.html:9 +b(3,4,"\n\n",(void 0),[object Object])@file:///C:/example.html:16 +a("first call, firstarg")@file:///C:/example.html:19 +@file:///C:/example.html:21</samp></pre> + +<h3 id="Stos_ewaluowanego_kodu">Stos ewaluowanego kodu</h3> + +<p>Od Firefoxa 30, stos błędu w wywołaniach <code>Function()</code> i <code>eval()</code> tworzy stos z bardziej szczegółową informacją o linii i kolumnie wewnątrz tych wywołań. Wywołania funkcji są wskazywane przez <code>"> Function"</code>, a eval przez <code>"> eval"</code>.</p> + +<pre class="brush: js notranslate">try { + new Function('throw new Error()')(); +} catch (e) { + console.log(e.stack); +} + +// anonymous@file:///C:/example.html line 7 > Function:1:1 +// @file:///C:/example.html:7:6 + + +try { + eval("eval('FAIL')"); +} catch (x) { + console.log(x.stack); +} + +// @file:///C:/example.html line 7 > eval line 1 > eval:1:1 +// @file:///C:/example.html line 7 > eval:1:1 +// @file:///C:/example.html:7:6 +</pre> + +<p>Możesz także użyć dyrektywy <code>//# sourceURL</code> do nazwania źródła <code>eval</code>. Zobacz też źródła <a href="/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources">Debug eval</a> w dokumentacji <a href="/en-US/docs/Tools/Debugger">Debuggera</a> oraz w <a href="http://fitzgeraldnick.com/weblog/59/">tym artykule</a>.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<p><span class="pl-s">Nie jest częścią żadnego standardu.</span></p> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Error.stack")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Components.stack">Components.stack</a></li> + <li>Projekty zewnetrzne: <a class="link-https" href="https://github.com/csnover/TraceKit/">TraceKit</a> i <a class="link-https" href="https://github.com/eriwen/javascript-stacktrace">javascript-stacktrace</a></li> + <li>MSDN: <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">archiwalna dokumentacja error.stack</a></li> + <li><a href="https://github.com/v8/v8/wiki/Stack%20Trace%20API">Przegląd API stosu wywołań w JavaScript V8</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/tosource/index.html b/files/pl/web/javascript/referencje/obiekty/error/tosource/index.html new file mode 100644 index 0000000000..f904d26f70 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/tosource/index.html @@ -0,0 +1,60 @@ +--- +title: Error.prototype.toSource() +slug: Web/JavaScript/Referencje/Obiekty/Error/toSource +tags: + - JavaScript + - Metodă + - Niestandardowy + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Metoda <code><strong>toSource()</strong></code> zwraca kod, który możemethod returns code that could eval to the same error.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><var>e</var>.toSource()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Łańcuch znaków (<em>string</em>) zawierający kod źródłowy błędu.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_toSource">Użycie toSource</h3> + +<p>Wywołanie metody <code>toSource</code> instancji {{jsxref("Error")}} (w tym <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types">NativeErrors</a></em>) zwróci łańcuch znaków zawierający kod źródłowy błędu. Zwrócony <em>string</em> może być ewaluowany do utworzenia (w przybliżeniu) takiego samego obiektu. Oczywiście ciąg znaków zawierający kod źródłowy jest zgodny ze strukturą konstruktora {{jsxref("Error")}}. Przykładowo:</p> + +<pre class="brush: js notranslate">(<em>newname</em>(<em>message</em>, <em>nazwaPliku</em>, <em>numerLinii</em>)) +</pre> + +<p>gdzie wymienione atrybuty odpowiadają właściwym własnościom instancji błędu.</p> + +<div class="note"> +<p><strong>Uwaga:</strong> należy pamiętać, że własności używanen przez metodę <code>toSource</code> podczas tworzenia tego ciągu znaków są modyfikowalne i mogą nie odzwierciedlać dokładnie funkcji użytej do stworzenia instancji błędu lub nazwy pliku czy numeru linii gdzie wystąpił dany błąd.</p> +</div> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<p>Nie należy do żadnego standardu.</p> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Error.toSource")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.fileName")}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}}</li> + <li>{{jsxref("Error.prototype.message")}}</li> + <li>{{jsxref("Error.prototype.name")}}</li> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/error/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/error/tostring/index.html new file mode 100644 index 0000000000..6b019bc60b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/error/tostring/index.html @@ -0,0 +1,98 @@ +--- +title: Error.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/Error/toString +tags: + - JavaScript + - Metodă + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>toString()</strong></code> zwraca iąg znaków reprezentujący dany obiekt {{jsxref("Error")}}.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><code><var>e</var>.toString()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Ciąg znaków reprezentujący dany obiekt {{jsxref("Error")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Error")}} nadpisuje metodę {{jsxref("Object.prototype.toString()")}} dziedziczoną przez wszystkie obiekty. Jego semantyka jest następująca (przy założeniu, że {{jsxref("Object")}} i {{jsxref("String")}} mają swoje oryginalne wartości):</p> + +<pre class="brush: js notranslate">Error.prototype.toString = function() { + 'use strict'; + + var obj = Object(this); + if (obj !== this) { + throw new TypeError(); + } + + var name = this.name; + name = (name === undefined) ? 'Error' : String(name); + + var msg = this.message; + msg = (msg === undefined) ? '' : String(msg); + + if (name === '') { + return msg; + } + if (msg === '') { + return name; + } + + return name + ': ' + msg; +}; +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_toString">Użycie toString()</h3> + +<pre class="brush: js notranslate">var e = new Error('fatal error'); +console.log(e.toString()); // 'Error: fatal error' + +e.name = undefined; +console.log(e.toString()); // 'Error: fatal error' + +e.name = ''; +console.log(e.toString()); // 'fatal error' + +e.message = undefined; +console.log(e.toString()); // '' + +e.name = 'hello'; +console.log(e.toString()); // 'hello' +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.toString")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error.prototype.toSource()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/escape/index.html b/files/pl/web/javascript/referencje/obiekty/escape/index.html new file mode 100644 index 0000000000..06d1d3d2c4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/escape/index.html @@ -0,0 +1,120 @@ +--- +title: escape() +slug: Web/JavaScript/Referencje/Obiekty/escape +translation_of: Web/JavaScript/Reference/Global_Objects/escape +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>The deprecated <code><strong>escape()</strong></code> function computes a new string in which certain characters have been replaced by a hexadecimal escape sequence. Use {{jsxref("encodeURI")}} or {{jsxref("encodeURIComponent")}} instead.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>escape(str)</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>str</code></dt> + <dd>A string to be encoded.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>The <code>escape</code> function is a property of the <em>global object</em>. Special characters are encoded with the exception of: @*_+-./</p> + +<p>The hexadecimal form for characters, whose code unit value is 0xFF or less, is a two-digit escape sequence: %xx. For characters with a greater code unit, the four-digit format %<strong>u</strong>xxxx is used.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">escape("abc123"); // "abc123" +escape("äöü"); // "%E4%F6%FC" +escape("ć"); // "%u0107" + +// znaki specjalne +escape("@*_+-./"); // "@*_+-./"</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.1', 'escape')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Defined in the (informative) Compatibility Annex B</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-escape-string', 'escape')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("encodeURI")}}</li> + <li>{{jsxref("encodeURIComponent")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/evalerror/index.html b/files/pl/web/javascript/referencje/obiekty/evalerror/index.html new file mode 100644 index 0000000000..6fd39a8789 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/evalerror/index.html @@ -0,0 +1,87 @@ +--- +title: EvalError +slug: Web/JavaScript/Referencje/Obiekty/EvalError +tags: + - EvalError + - JavaScript + - Klasa + - Obiekt + - Referencja +translation_of: Web/JavaScript/Reference/Global_Objects/EvalError +--- +<div>{{JSRef}}</div> + +<p>Obiekt <strong><code>EvalError</code></strong> wskazuje na błąd dotyczący globalnej funkcji {{jsxref("Global_Objects/eval", "eval()")}}. Ten wyjątek nie jest już wywoływany przez JavaScript, jednak obiekt <code>EvalError</code> został zachowany ze względu na kompatybilność wsteczną.</p> + +<h2 id="Konstruktor">Konstruktor</h2> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/EvalError"><code>EvalError()</code></a></dt> + <dd>Tworzy nowy obiekt <code>EvalError</code>.</dd> +</dl> + +<h2 id="Własności_instancji">Własności instancji</h2> + +<dl> + <dt>{{jsxref("Error.prototype.message", "EvalError.prototype.message")}}</dt> + <dd>Treść błędu. Choć ECMA-262 określa, że {{jsxref("EvalError")}} powinien mieć swoją własną wartość <code>message</code>, w <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> jest ona dziedziczona z {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "EvalError.prototype.name")}}</dt> + <dd>Nazwa błędu. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "EvalError.prototype.fileName")}}</dt> + <dd>Ścieżka do pliku, w którym został wywołany błąd. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "EvalError.prototype.lineNumber")}}</dt> + <dd>Numer linii w pliku, gdzie został wywołany błąd. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "EvalError.prototype.columnNumber")}}</dt> + <dd>Kolumna w linii, gdzie został wywołany błąd. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "EvalError.prototype.stack")}}</dt> + <dd>Stos wywołań. Dziedziczone z {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<p><code>EvalError</code> nie jest używany w obecnej specyfikacji ECMAScript, zatem nie będzie wywoływany podczas wykonania programu – jednakże sam obiekt został zachowany ze względu na wsteczną kompatybilność z wcześniejszymi wersjami specyfikacji.</p> + +<h3 id="Tworzenie_EvalError">Tworzenie EvalError</h3> + +<pre class="brush: js notranslate">try { + throw new EvalError('Hello', 'someFile.js', 10); +} catch (e) { + console.log(e instanceof EvalError); // true + console.log(e.message); // "Hello" + console.log(e.name); // "EvalError" + console.log(e.fileName); // "someFile.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:2:9\n" +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.EvalError")}}</p> +</div> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/function/apply/index.html b/files/pl/web/javascript/referencje/obiekty/function/apply/index.html new file mode 100644 index 0000000000..411b47423a --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/function/apply/index.html @@ -0,0 +1,289 @@ +--- +title: Function.prototype.apply() +slug: Web/JavaScript/Referencje/Obiekty/Function/apply +translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply +--- +<div>{{JSRef}}</div> + +<p>Metoda <code>apply()</code> wywołuje daną funkcję podstawiając daną wartość <code>this</code> i argumenty <span id="result_box" lang="pl"><span>przedstawione</span> <span>w postaci tablicy</span></span> (lub obiektu tablicopodobnego (<a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">array-like object</a>)).</p> + +<div class="note"> +<p><strong>Notka:</strong> <span id="result_box" lang="pl"><span>Składnia</span> <span>tej funkcji jest</span> <span>niemal identyczna </span><span>do</span></span> {{jsxref("Function.call", "call()")}}, podstawową różnicą jest to, iż <code>call()</code> przyjmuje <strong>listę argumentów</strong>, podczas gdy <code>apply()</code> akceptuje <strong>pojedynczą tablicę argumentów</strong>.</p> +</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><em><var>fun</var>ction</em>.apply(<var>thisArg, </var>[<var>argsArray</var>])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd>Optional. The value of <code>this</code> provided for the call to <em><code>func</code></em>. Note that <code>this</code> may not be the actual value seen by the method: if the method is a function in {{jsxref("Strict_mode", "non-strict mode", "", 1)}} code, {{jsxref("null")}} and {{jsxref("undefined")}} will be replaced with the global object, and primitive values will be boxed.</dd> + <dt><code>argsArray</code></dt> + <dd>Optional. An array-like object, specifying the arguments with which <em><code>fun</code></em> should be called, or {{jsxref("null")}} or {{jsxref("undefined")}} if no arguments should be provided to the function. Starting with ECMAScript 5 these arguments can be a generic array-like object instead of an array. See below for {{anch("Browser_compatibility", "browser compatibility")}} information.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Wynik wywoływanej funkcji z określoną wartością <code>this</code> i argumentami.</p> + +<h2 id="Opis">Opis</h2> + +<p><span id="result_box" lang="pl"><span>Można</span> <span>przypisać inny</span> <span>obiekt</span> <code>this</code> <span>podczas wywoływania</span> <span>istniejącej</span> <span>funkcji.</span></span> <code>this</code> <span id="result_box" lang="pl"><span>odnosi się do</span> <span>bieżącego obiektu</span><span>,</span> <span>obiektu</span> <span>wywołującego. </span></span><span lang="pl"><span>Z</span> <span>apply</span><span> można</span> <span>napisać metodę</span> <span>raz, a następnie</span> <span>dziedziczyć</span> <span>ją</span> <span>w innym</span> <span>obiekcie,</span> <span>bez konieczności</span> <span>przepisywania</span> <span>metody</span> <span>dla nowego</span> <span>obiektu.</span></span></p> + +<p><code>apply</code> jest bardzo podobne do {{jsxref("Function.call", "call()")}}, <span class="short_text" id="result_box" lang="pl"><span>z wyjątkiem typu danych</span> <span>argumentów</span><span>, które wspiera</span><span>. </span></span><span id="result_box" lang="pl"><span>Można</span> <span>używać tablicy</span> <span>argumentów</span> <span>zamiast</span> <span>zestawu argumentów (parametrów</span><span>).</span></span> Z metodą <code>apply</code>, możesz używać tablic w sensie dosłownym, na przykład <code><em>fun</em>c.apply(this, ['eat', 'bananas'])</code>, lub obiektów typu {{jsxref("Array")}}, na przykład, <code><em>func</em>.apply(this, new Array('eat', 'bananas'))</code>.</p> + +<p>Można używać również {{jsxref("Funkcje/arguments", "arguments")}} dla parametru <code>argsArray</code>. <code>arguments</code> jest zmienną lokalną dostępną wewnątrz każdej funkcji. Można to zastosować<span id="result_box" lang="pl"><span> do wszystkich</span> <span>nieokreślonych</span> <span>argumentów</span> wywoływanego <span>obiektu</span><span>.</span></span> <span id="result_box" lang="pl"><span>Tak więc</span> <span>nie trzeba</span> <span>znać</span> <span>argumentów</span> <span>wywoływanego obiektu</span> <span>przy</span> <span>użyciu</span> <span>metody</span> <span><code>apply</code>. </span></span> Możesz użyć <code>arguments</code>, aby <span class="short_text" id="result_box" lang="pl"><span>przekazać</span> <span>wszystkie argumenty do wywoływanego obiektu. </span></span><span id="result_box" lang="pl"><span>Wywołany</span> <span>obiekt</span> <span>jest</span> <span>odpowiedzialny za obsługę</span> <span>otrzymanych argumentów</span><span>.</span></span></p> + +<p><span lang="pl"><span>Od </span></span>ECMAScript 5th Edition możliwe jest również używanie wszelkiego rodzaju obiektów „tablicopodobnych” (array-like), co w praktyce oznacza, że obiekt taki musi mieć własność <code>length</code> i całkowite własności (indeksy) w zakresie <code>(0..length-1)</code>. Przykładowo możesz użyć {{domxref("NodeList")}} lub własnego oiektu jak np. <code>{ 'length': 2, '0': 'eat', '1': 'bananas' }</code>.</p> + +<div class="note"> +<p>Większość przeglądarek, w tym Chrome 14 i Internet Explorer 9, w dalszym ciągu nie akceptuje obiektów tablicopodobnych i będzie wyrzucać wyjątek.</p> +</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_apply_do_dodania_tablicy_do_innej_tablicy">Użycie <code>apply</code> do dodania tablicy do innej tablicy</h3> + +<p>Możemy użyć metody <code>push</code> do dodania elementu do tablicy. I, jako że <code>push</code> przyjmuje zmienną liczbę argumentów, możemy również dodać wiele elementów naraz – ale jeśli faktycznie przekażemy tablicę do funkcji <code>push</code>, wówczas rzeczywiście doda ona tablicę jako pojedynczy element, zamiast dodać jej elementy, więc skończymy z tablicą wewnątrz tablicy. Co jeśli to nie jest to, co chcieliśmy osiągnąć? <code>concat</code> ma zachowanie takie, jakiego oczekiwalibyśmy w tym przypadku, jednak funkcja ta nie dodaje w rzeczywistości tablicy do istniejącej tablicy, ale tworzy i zwraca nową. Ale chcieliśmy zmodyfikować naszą istniejącą tablicę… Więc co teraz? Napisać pętlę? No chyba nie?</p> + +<p><code>apply</code> przychodzi na ratunek!</p> + +<pre class="brush: js">var array = ['a', 'b']; +var elements = [0, 1, 2]; +array.push.apply(array, elements); +console.info(array); // ["a", "b", 0, 1, 2] +</pre> + +<p> </p> + +<h3 id="Using_apply_and_built-in_functions">Using <code>apply</code> and built-in functions</h3> + +<p> </p> + +<p>Clever usage of <code>apply</code> allows you to use built-ins functions for some tasks, that otherwise probably would have been written by looping over the array values. As an example here we are going to use <code>Math.max</code>/<code>Math.min</code>, to find out the maximum/minimum value in an array.</p> + +<pre class="brush: js">// min/max number in an array +var numbers = [5, 6, 2, 3, 7]; + +// using Math.min/Math.max apply +var max = Math.max.apply(null, numbers); +// This about equal to Math.max(numbers[0], ...) +// or Math.max(5, 6, ...) + +var min = Math.min.apply(null, numbers); + +// vs. simple loop based algorithm +max = -Infinity, min = +Infinity; + +for (var i = 0; i < numbers.length; i++) { + if (numbers[i] > max) { + max = numbers[i]; + } + if (numbers[i] < min) { + min = numbers[i]; + } +} +</pre> + +<p>But beware: in using <code>apply</code> this way, you run the risk of exceeding the JavaScript engine's argument length limit. The consequences of applying a function with too many arguments (think more than tens of thousands of arguments) vary across engines (JavaScriptCore has hard-coded <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=80797">argument limit of 65536</a>), because the limit (indeed even the nature of any excessively-large-stack behavior) is unspecified. Some engines will throw an exception. More perniciously, others will arbitrarily limit the number of arguments actually passed to the applied function. To illustrate this latter case: if such an engine had a limit of four arguments (actual limits are of course significantly higher), it would be as if the arguments <code>5, 6, 2, 3</code> had been passed to <code>apply</code> in the examples above, rather than the full array.</p> + +<p>If your value array might grow into the tens of thousands, use a hybrid strategy: apply your function to chunks of the array at a time:</p> + +<pre class="brush: js">function minOfArray(arr) { + var min = Infinity; + var QUANTUM = 32768; + + for (var i = 0, len = arr.length; i < len; i += QUANTUM) { + var submin = Math.min.apply(null, + arr.slice(i, Math.min(i+QUANTUM, len))); + min = Math.min(submin, min); + } + + return min; +} + +var min = minOfArray([5, 6, 2, 3, 7]); +</pre> + +<p> </p> + +<h3 id="Using_apply_to_chain_constructors">Using <code>apply</code> to chain constructors</h3> + +<p> </p> + +<p>You can use <code>apply</code> to chain {{jsxref("Operators/new", "constructors", "", 1)}} for an object, similar to Java. In the following example we will create a global {{jsxref("Function")}} method called <code>construct</code>, which will enable you to use an array-like object with a constructor instead of an arguments list.</p> + +<pre class="brush: js">Function.prototype.construct = function(aArgs) { + var oNew = Object.create(this.prototype); + this.apply(oNew, aArgs); + return oNew; +}; +</pre> + +<div class="note" style="height: 250px; overflow: auto;"> +<p><strong>Note:</strong> The <code>Object.create()</code> method used above is relatively new. For alternative methods, please consider one of the following approaches:</p> + +<p>Using {{jsxref("Object/__proto__", "Object.__proto__")}}:</p> + +<pre class="brush: js">Function.prototype.construct = function (aArgs) { + var oNew = {}; + oNew.__proto__ = this.prototype; + this.apply(oNew, aArgs); + return oNew; +}; +</pre> + +<p>Using <a href="/en-US/docs/Web/JavaScript/Closures">closures</a>:</p> + +<pre class="brush: js">Function.prototype.construct = function(aArgs) { + var fConstructor = this, fNewConstr = function() { + fConstructor.apply(this, aArgs); + }; + fNewConstr.prototype = fConstructor.prototype; + return new fNewConstr(); +};</pre> + +<p>Using the {{jsxref("Function")}} constructor:</p> + +<pre class="brush: js">Function.prototype.construct = function (aArgs) { + var fNewConstr = new Function(""); + fNewConstr.prototype = this.prototype; + var oNew = new fNewConstr(); + this.apply(oNew, aArgs); + return oNew; +}; +</pre> +</div> + +<p>Example usage:</p> + +<pre class="brush: js">function MyConstructor() { + for (var nProp = 0; nProp < arguments.length; nProp++) { + this['property' + nProp] = arguments[nProp]; + } +} + +var myArray = [4, 'Hello world!', false]; +var myInstance = MyConstructor.construct(myArray); + +console.log(myInstance.property1); // logs 'Hello world!' +console.log(myInstance instanceof MyConstructor); // logs 'true' +console.log(myInstance.constructor); // logs 'MyConstructor' +</pre> + +<div class="note"> +<p><strong>Note:</strong> This non-native <code>Function.construct</code> method will not work with some native constructors; like {{jsxref("Date")}}, for example. In these cases you have to use the {{jsxref("Function.prototype.bind")}} method. For example, imagine having an array like the following, to be used with {{jsxref("Global_Objects/Date", "Date")}} constructor: <code>[2012, 11, 4]</code>; in this case you have to write something like: <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()</code>. This is not the best way to do things, and probably not to be used in any production environment.</p> +</div> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>ES 5.1 generic array-like object as {{jsxref("Functions/arguments", "arguments")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>ES 5.1 generic array-like object as {{jsxref("Functions/arguments", "arguments")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("2.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Functions/arguments", "arguments")}} object</li> + <li>{{jsxref("Function.prototype.bind()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions", "Functions and function scope", "", 1)}}</li> + <li>{{jsxref("Reflect.apply()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/function/arguments/index.html b/files/pl/web/javascript/referencje/obiekty/function/arguments/index.html new file mode 100644 index 0000000000..abbb63eef4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/function/arguments/index.html @@ -0,0 +1,41 @@ +--- +title: Function.arguments +slug: Web/JavaScript/Referencje/Obiekty/Function/arguments +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments +--- +<p>{{JSRef}}{{ Deprecated_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Obiekt tablicopodobny odpowiadający argumentom przekazywanym funkcji.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Należy użyć obiektu <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments">arguments</a></code> dostępnego wewnątrz funkcji zamiast <code>Function.arguments</code>.</p> + +<p>W przypadku rekurencji, tzn. jeśli funkcja <code>f</code> pojawia się kilkakrotnie na stosie wywołania, wartość of <code>f.arguments</code> reprezentuje argumenty odpowiadające ostatniemu wywołaniu funkcji.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<pre class="brush: js">function f(n) { g(n-1) } + +function g(n) { + console.log("przed: " + g.arguments[0]); + if(n>0) { f(n); } + console.log("po: " + g.arguments[0]); +} +f(2); +</pre> + +<p>wyświetli:</p> + +<pre class="eval">przed: 1 +przed: 0 +po: 0 +po: 1 +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/function/arity/index.html b/files/pl/web/javascript/referencje/obiekty/function/arity/index.html new file mode 100644 index 0000000000..37a136e443 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/function/arity/index.html @@ -0,0 +1,23 @@ +--- +title: Function.arity +slug: Web/JavaScript/Referencje/Obiekty/Function/arity +tags: + - Function + - JavaScript + - Obsolete + - Property + - Unimplemented + - przestarzały +translation_of: Archive/Web/JavaScript/Function.arity +--- +<p>{{JSRef}}{{ obsolete_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Własność <code>arity</code> jest zewnętrzna dla funkcji i wskazuje, ile argumentów oczekuje funkcja. Ta właśność jest przestarzała, proszę używać {{jsxref("Function.prototype.length")}}, która dostarcza liczbę argumentów wymaganych przez deklarację funkcji.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Function.prototype.length")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/function/bind/index.html b/files/pl/web/javascript/referencje/obiekty/function/bind/index.html new file mode 100644 index 0000000000..028db6b6d4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/function/bind/index.html @@ -0,0 +1,332 @@ +--- +title: Function.prototype.bind() +slug: Web/JavaScript/Referencje/Obiekty/Function/bind +translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind +--- +<div>{{JSRef}}<br> +Metoda <span class="seoSummary"><code><strong>bind()</strong></code> </span> tworzy nową funkcję, której wywołanie powoduje ustawienie <strong>this</strong> na podaną wartość, z podaną sekwencją argumentów poprzedzającą dowolną podaną podczas wywołania nowej funkcji.<br> + </div> + +<div>{{EmbedInteractiveExample („pages / js / function-bind.html”, „taller”)}}<br> +Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do projektu interaktywnych przykładów, sklonuj https://github.com/mdn/interactive-examples i wyślij nam prośbę o pobranie.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate">let boundFunc = <var>func</var>.bind(thisAtr[, <var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]]]) +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>thisAtr</var></code></dt> + <dd>Wartość, która ma być przekazana jako <strong>this</strong> do funkcji docelowej func po wywołaniu funkcji powiązanej. Wartość jest ignorowana, jeśli funkcja powiązana jest konstruowana przy użyciu operatora {{jsxref („Operators / new”, „new”)}}. Podczas używania funkcji <strong>bind</strong> do utworzenia funkcji (dostarczonej jako wywołanie zwrotne) wewnątrz setTimeout, każda prymitywna wartość przekazywana, gdy <strong>thisAtr</strong> jest konwertowany na obiekt. Jeśli nie podano żadnych argumentów, aby powiązać (bind), lub jeśli thisArg jest <strong>null</strong> lub <strong>undefined</strong>, <strong>this</strong> z zakresu wykonania jest traktowany jako <strong>thisAtr</strong> dla nowej funkcji.</dd> + <dt><code><var>arg1</var>, <var>arg2</var>, ...<var>argN</var></code> {{optional_inline}}</dt> + <dd>Argumenty poprzedzające argumenty dostarczone funkcji powiązanej podczas wywoływania func.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Kopia podanej funkcji z podaną tą wartością i początkowymi argumentami (jeśli podano).</p> + +<h2 id="Opis">Opis</h2> + +<p>Funkcja <strong>bind</strong>() tworzy nową funkcję wiązania (bound function), która jest exotic function object (termin z ECMAScript 2015), który zawija oryginalny obiekt funkcji. Wywołanie funkcji powiązanej zazwyczaj skutkuje wykonaniem jej owrapowanej funkcji.</p> + +<p>Funckja wiązania <strong>(bound function)</strong> ma następujące właściwości wewnętrzne:</p> + +<dl> + <dt><strong><code>[[BoundTargetFunction]]</code> </strong></dt> + <dd>The wrapped function object</dd> + <dt><code><strong>[[BoundThis]]</strong></code></dt> + <dd>The value that is always passed as <code>this</code> value when calling the wrapped function.</dd> + <dt><code><strong>[[BoundArguments]]</strong></code></dt> + <dd>A list of values whose elements are used as the first arguments to any call to the wrapped function.</dd> + <dt><code><strong>[[Call]]</strong></code></dt> + <dd>Executes code associated with this object. Invoked via a function call expression. The arguments to the internal method are a <code>this</code> value and a list containing the arguments passed to the function by a call expression.</dd> +</dl> + +<p>When a bound function is called, it calls internal method <code>[[Call]]</code> on <code>[[BoundTargetFunction]]</code>, with following arguments <code>Call(<var>boundThis</var>, ...<var>args</var>)</code>. Where <code><var>boundThis</var></code> is <code>[[BoundThis]]</code>, <code><var>args</var></code> is <code>[[BoundArguments]]</code>, followed by the arguments passed by the function call.</p> + +<p>A bound function may also be constructed using the {{jsxref("Operators/new", "new")}} operator. Doing so acts as though the target function had instead been constructed. The provided <code>this</code> value is ignored, while prepended arguments are provided to the emulated function.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Creating_a_bound_function">Creating a bound function</h3> + +<p>The simplest use of <code>bind()</code> is to make a function that, no matter how it is called, is called with a particular <code>this</code> value.</p> + +<p>A common mistake for new JavaScript programmers is to extract a method from an object, then to later call that function and expect it to use the original object as its <code>this</code> (e.g., by using the method in callback-based code).</p> + +<p>Without special care, however, the original object is usually lost. Creating a bound function from the function, using the original object, neatly solves this problem:</p> + +<pre class="brush: js notranslate">this.x = 9; // 'this' refers to global 'window' object here in a browser +const module = { + x: 81, + getX: function() { return this.x; } +}; + +module.getX(); +// returns 81 + +const retrieveX = module.getX; +retrieveX(); +// returns 9; the function gets invoked at the global scope + +// Create a new function with 'this' bound to module +// New programmers might confuse the +// global variable 'x' with module's property 'x' +const boundGetX = retrieveX.bind(module); +boundGetX(); +// returns 81 +</pre> + +<p><strong>Funkcje częściowo zastosowane</strong><br> + Kolejnym najprostszym zastosowaniem bind () jest utworzenie funkcji z wcześniej określonymi argumentami początkowymi.</p> + +<p>Argumenty te (jeśli występują) są zgodne z podaną wartością, a następnie są wstawiane na początku argumentów przekazywanych do funkcji docelowej, a następnie wszelkie argumenty przekazywane funkcja powiązana w momencie jej wywołania.</p> + +<pre class="brush: js notranslate">function list() { + return Array.prototype.slice.call(arguments); +} + +function addArguments(arg1, arg2) { + return arg1 + arg2 +} + +const list1 = list(1, 2, 3); +// [1, 2, 3] + +const result1 = addArguments(1, 2); +// 3 + +// Create a function with a preset leading argument +const leadingThirtysevenList = list.bind(null, 37); + +// Create a function with a preset first argument. +const addThirtySeven = addArguments.bind(null, 37); + +const list2 = leadingThirtysevenList(); +// [37] + +const list3 = leadingThirtysevenList(1, 2, 3); +// [37, 1, 2, 3] + +const result2 = addThirtySeven(5); +// 37 + 5 = 42 + +const result3 = addThirtySeven(5, 10); +// 37 + 5 = 42 +// (the second argument is ignored) + + +</pre> + +<h3 id="With_setTimeout">With <code>setTimeout()</code></h3> + +<p>By default within <a href="/en-US/docs/Web/API/Window/setTimeout" title="REDIRECT WindowTimers.setTimeout"><code>window.setTimeout()</code></a>, the <code>this</code> keyword will be set to the <a href="/en-US/docs/Web/API/Window" title="The Window interface represents a window containing a DOM document; the document property points to the DOM document loaded in that window."><code>window</code></a> (or <code>global</code>) object. When working with class methods that require <code>this</code> to refer to class instances, you may explicitly bind <code>this</code> to the callback function, in order to maintain the instance.</p> + +<pre class="brush: js notranslate">function LateBloomer() { + this.petalCount = Math.floor(Math.random() * 12) + 1; +} + +// Declare bloom after a delay of 1 second +LateBloomer.prototype.bloom = function() { + window.setTimeout(this.declare.bind(this), 1000); +}; + +LateBloomer.prototype.declare = function() { + console.log(`I am a beautiful flower with ${this.petalCount} petals!`); +}; + +const flower = new LateBloomer(); +flower.bloom(); +// after 1 second, calls 'flower.declare()' +</pre> + +<h3 id="Funkcje_powiązane_używane_jako_kostruktory">Funkcje powiązane używane jako kostruktory</h3> + +<div class="warning"> +<p>Ostrzeżenie: ta sekcja pokazuje możliwości JavaScript i dokumentuje niektóre przypadki krawędzi metody bind ().</p> + +<p>Metody przedstawione poniżej nie są najlepszym sposobem na robienie rzeczy i prawdopodobnie nie powinny być stosowane w żadnym środowisku produkcyjnym.</p> +</div> + +<p>Funkcje powiązane są automatycznie odpowiednie do użycia z operatorem {{jsxref („Operators / new”, „new”)}} do tworzenia nowych instancji utworzonych przez funkcję docelową. Gdy do utworzenia wartości używana jest funkcja powiązana, pod warunkiem, że jest to ignorowane.</p> + +<p>Jednak pod warunkiem, że argumenty są nadal dołączane do wywołania konstruktora:</p> + +<pre class="brush: js notranslate">function Point(x, y) { + this.x = x; + this.y = y; +} + +Point.prototype.toString = function() { + return `${this.x},${this.y}`; +}; + +const p = new Point(1, 2); +p.toString(); +// '1,2' + + +// not supported in the polyfill below, + +// works fine with native bind: + +const YAxisPoint = Point.bind(null, 0/*x*/); + + +const emptyObj = {}; +const YAxisPoint = Point.bind(emptyObj, 0/*x*/); + +const axisPoint = new YAxisPoint(5); +axisPoint.toString(); // '0,5' + +axisPoint instanceof Point; // true +axisPoint instanceof YAxisPoint; // true +new YAxisPoint(17, 42) instanceof Point; // true +</pre> + +<p>Zauważ, że nie musisz robić nic specjalnego, aby utworzyć powiązaną funkcję do użycia z {{jsxref („Operators / new”, „new”)}}.</p> + +<p>Następstwem jest to, że nie musisz robić nic specjalnego, aby utworzyć funkcję powiązaną, która będzie wywoływana w sposób jawny, nawet jeśli wolisz, aby funkcja powiązana była wywoływana tylko za pomocą {{jsxref („Operators / new”, „new”)}} .</p> + +<pre class="brush: js notranslate">// Example can be run directly in your JavaScript console +// ...continued from above + +// Can still be called as a normal function +// (although usually this is undesired) +YAxisPoint(13); + +`${emptyObj.x},${emptyObj.y}`; +// > '0,13' +</pre> + +<p>If you wish to support the use of a bound function only using {{jsxref("Operators/new", "new")}}, or only by calling it, the target function must enforce that restriction.</p> + +<h3 id="Tworzenie_skrótów">Tworzenie skrótów</h3> + +<p>bind () jest również pomocny w przypadkach, w których chcesz utworzyć skrót do funkcji, która wymaga podania tej wartości.</p> + +<p>Weźmy na przykład {{jsxref ("Array.prototype.slice ()")}}, którego chcesz użyć do konwersji obiektu podobnego do tablicy na prawdziwą tablicę. Możesz utworzyć taki skrót:</p> + +<pre class="brush: js notranslate">const slice = Array.prototype.slice; + +// ... + +slice.apply(arguments); +</pre> + +<p>Za pomocą bind () można to uprościć.</p> + +<p>W poniższym fragmencie kodu slice () jest funkcją powiązaną z funkcją {{jsxref („Function.prototype.apply ()”, „Apply ()”)}} z {{jsxref („Function.prototype”) }}, z tą wartością ustawioną na {{jsxref („Array.prototype.slice ()”, „slice ()”)}} funkcji {{jsxref („Array.prototype”)}}. Oznacza to, że dodatkowe wywołania apply () można wyeliminować:</p> + +<pre class="brush: js notranslate">// same as "slice" in the previous example +const unboundSlice = Array.prototype.slice; +const slice = Function.prototype.apply.bind(unboundSlice); + +// ... + +slice(arguments); +</pre> + +<p>Polyfill<br> + Ponieważ starsze przeglądarki są na ogół również wolniejszymi przeglądarkami, jest to o wiele bardziej krytyczne niż większość ludzi rozpoznaje tworzenie polifillów wydajności, aby przeglądanie w przestarzałych przeglądarkach było nieco mniej straszne.</p> + +<p>W związku z tym poniżej przedstawiono dwie opcje dla funkcji wypełniania funkcji Function.prototype.bind ():</p> + +<p>Pierwszy jest znacznie mniejszy i bardziej wydajny, ale nie działa, gdy używasz nowego operatora.<br> + Drugi jest większy i mniej wydajny, ale pozwala na pewne użycie nowego operatora na powiązanych funkcjach.<br> + Zasadniczo w większości kodów bardzo rzadko widuje się nowe używane w funkcji powiązanej, więc najlepiej jest wybrać pierwszą opcję.</p> + +<pre class="brush: js notranslate">// Does not work with `new funcA.bind(thisArg, args)` +if (!Function.prototype.bind) (function(){ + var slice = Array.prototype.slice; + Function.prototype.bind = function() { + var thatFunc = this, thatArg = arguments[0]; + var args = slice.call(arguments, 1); + if (typeof thatFunc !== 'function') { + // closest thing possible to the ECMAScript 5 + // internal IsCallable function + throw new TypeError('Function.prototype.bind - ' + + 'what is trying to be bound is not callable'); + } + return function(){ + var funcArgs = args.concat(slice.call(arguments)) + return thatFunc.apply(thatArg, funcArgs); + }; + }; +})();</pre> + +<p>Możesz częściowo obejść ten problem, wstawiając następujący kod na początku skryptów, umożliwiając korzystanie z większości funkcji bind () w implementacjach, które nie obsługują go natywnie.</p> + +<pre class="brush: js notranslate">// Yes, it does work with `new funcA.bind(thisArg, args)` +if (!Function.prototype.bind) (function(){ + var ArrayPrototypeSlice = Array.prototype.slice; + Function.prototype.bind = function(otherThis) { + if (typeof this !== 'function') { + // closest thing possible to the ECMAScript 5 + // internal IsCallable function + throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable'); + } + + var baseArgs= ArrayPrototypeSlice .call(arguments, 1), + baseArgsLength = baseArgs.length, + fToBind = this, + fNOP = function() {}, + fBound = function() { + baseArgs.length = baseArgsLength; // reset to default base arguments + baseArgs.push.apply(baseArgs, arguments); + return fToBind.apply( + fNOP.prototype.isPrototypeOf(this) ? this : otherThis, baseArgs + ); + }; + + if (this.prototype) { + // Function.prototype doesn't have a prototype property + fNOP.prototype = this.prototype; + } + fBound.prototype = new fNOP(); + + return fBound; + }; +})(); +</pre> + +<p>Niektóre z wielu różnic (mogą być też inne, ponieważ ta lista nie próbuje być wyczerpująca) między tym algorytmem a określonym algorytmem to:</p> + +<p>Częściowa implementacja opiera się na {{jsxref ("Array.prototype.slice ()")}}, {{jsxref ("Array.prototype.concat ()")}}, {{jsxref ("Function.prototype.call ( ) ")}} i {{jsxref (" Function.prototype.apply () ")}}, wbudowane metody mające swoje oryginalne wartości.<br> + Częściowa implementacja tworzy funkcje, które nie mają niezmiennej „pigułki trucizny” {{jsxref („Function.caller”, „caller”)}} i właściwości argumentów, które wyrzucają {{jsxref („Global_Objects / TypeError”, „TypeError”) }} przy pobieraniu, ustawianiu lub usuwaniu. (Można to dodać, jeśli implementacja obsługuje {{jsxref („Object.defineProperty”)}} lub częściowo zaimplementowana [bez zachowania polegającego na rzucaniu przy usuwaniu], jeśli implementacja obsługuje {{jsxref („Object .__ zdefiniujGetter__”, „ __defineGetter__ ”)}} i {{jsxref („ Object .__ definiSetter__ ”,„ __defineSetter__ ”)}}).<br> + Częściowa implementacja tworzy funkcje, które mają właściwość prototypu. (Właściwie powiązane funkcje nie mają żadnych.)<br> + Częściowa implementacja tworzy powiązane funkcje, których właściwość {{jsxref („Function.length”, „length”)}}} nie zgadza się z właściwością nakazaną przez ECMA-262: tworzy funkcje o długości 0. Pełna implementacja - w zależności od długość funkcji docelowej i liczba wcześniej określonych argumentów - może zwrócić niezerową długość.<br> + Częściowa implementacja tworzy powiązane funkcje, których właściwość {{jsxref („Function.name”, „name”)}} nie jest pochodną oryginalnej nazwy funkcji. Według ECMA-262 nazwa zwróconej funkcji powiązanej powinna być „związana” + nazwa funkcji docelowej.<br> + Jeśli zdecydujesz się użyć tej częściowej implementacji, nie możesz polegać na przypadkach, w których zachowanie odbiega od ECMA-262, wydanie 5! Na szczęście te odchylenia od specyfikacji rzadko (jeśli w ogóle) pojawiają się w większości sytuacji kodowania. Jeśli nie rozumiesz żadnego z odchyleń od powyższej specyfikacji, w tym konkretnym przypadku można bezpiecznie nie martwić się o te niezgodne szczegóły odchylenia.</p> + +<p>Jeśli jest to absolutnie konieczne, a wydajność nie stanowi problemu, znacznie wolniejsze (ale bardziej zgodne ze specyfikacją rozwiązanie) można znaleźć na stronie https://github.com/Raynos/function-bind.</p> + +<h2 id="Dane_techniczne">Dane techniczne</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td> + </tr> + </tbody> +</table> + +<h5 id="Kompatybilność_z_przeglądarkami_Tabela_zgodności_na_tej_stronie_jest_generowana_z_danych_strukturalnych._Jeśli_chcesz_przyczynić_się_do_danych_sprawdź_httpsgithub.commdnbrowser-compat-data_i_wyślij_nam_żądanie_ściągnięcia._Compat_javascript.builtins.Function.bind">Kompatybilność z przeglądarkami<br> + Tabela zgodności na tej stronie jest generowana z danych strukturalnych. Jeśli chcesz przyczynić się do danych, sprawdź https://github.com/mdn/browser-compat-data i wyślij nam żądanie ściągnięcia.<br> + {{Compat ("javascript.builtins.Function.bind")}}</h5> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Function.prototype.apply()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions", "Functions", "", 1)}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/function/caller/index.html b/files/pl/web/javascript/referencje/obiekty/function/caller/index.html new file mode 100644 index 0000000000..1c86b7f92f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/function/caller/index.html @@ -0,0 +1,69 @@ +--- +title: Function.caller +slug: Web/JavaScript/Referencje/Obiekty/Function/caller +tags: + - Function + - JavaScript + - Non-standard + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Określa funkcję, która powołuje się na aktualnie wykonywaną funkcje.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli funkcja <code>f</code> została wywołana przez kod najwyższego poziomu, własność <code>f.caller</code> ma wartość {{jsxref("null")}}, w przeciwnym przypadku jest to funkcja, która wywołała <code>f</code>.</p> + +<p>Ta własność zastąpiła wycofaną własność {{jsxref("arguments.caller")}}.</p> + +<h3 id="Notes" name="Notes">Notes</h3> + +<p>Note that in case of recursion, you can't reconstruct the call stack using this property. Consider:</p> + +<pre class="brush: js">function f(n) { g(n-1); } +function g(n) { if(n>0) { f(n); } else { stop(); } } +f(2); +</pre> + +<p>At the moment <code>stop()</code> is called the call stack will be:</p> + +<pre class="eval">f(2) -> g(1) -> f(1) -> g(0) -> stop() +</pre> + +<p>The following is true:</p> + +<pre class="eval">stop.caller === g && f.caller === g && g.caller === f +</pre> + +<p>so if you tried to get the stack trace in the <code>stop()</code> function like this:</p> + +<pre class="brush: js">var f = stop; +var stack = "Stack trace:"; +while (f) { + stack += "\n" + f.name; + f = f.caller; +} +</pre> + +<p>the loop would never stop.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Sprawdzenie_warto.C5.9Bci_w.C5.82asno.C5.9Bci_funkcji_caller" name="Przyk.C5.82ad:_Sprawdzenie_warto.C5.9Bci_w.C5.82asno.C5.9Bci_funkcji_caller">Przykład: Sprawdzenie wartości własności funkcji <code>caller</code></h3> + +<p>Następujący kod sprawdza wartość własności funkcji <code>caller</code>.</p> + +<pre class="brush: js">function myFunc() { + if (myFunc.caller == null) { + return ("The function was called from the top!"); + } else { + return ("This function's caller was " + myFunc.caller); + } +} +</pre> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/referencje/obiekty/function/displayname/index.html b/files/pl/web/javascript/referencje/obiekty/function/displayname/index.html new file mode 100644 index 0000000000..72c8c41257 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/function/displayname/index.html @@ -0,0 +1,119 @@ +--- +title: Function.displayName +slug: Web/JavaScript/Referencje/Obiekty/Function/displayName +translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Właściwość <code><strong><em>function</em>.displayName</strong></code> zwraca wyświetlaną nazwę funkcji.</p> + +<h2 id="Opis">Opis</h2> + +<p>Gdy jest zdefiniowana, wlaściwość <code>displayName</code> zwraca wyświetlaną nazwę funkcji:</p> + +<pre class="brush: js">function doSomething() {} + +console.log(doSomething.displayName); // "undefined" + +var popup = function(content) { console.log(content); }; + +popup.displayName = 'Pokaż Popup'; + +console.log(popup.displayName); // "Pokaż Popup" +</pre> + +<p>Możesz zdefiniować funkcję z wyświetlaną nazwą {{jsxref("Functions", "function expression", "", 1)}}:</p> + +<pre class="brush: js">var object = { + someMethod: function() {} +}; + +object.someMethod.displayName = 'jakaśMetoda'; + +console.log(object.someMethod.displayName); // logs "jakaśMetoda" + +try { someMethod } catch(e) { console.log(e); } +// ReferenceError: jakaśMetoda is not defined +</pre> + +<p>Możesz dynamicznie zmieniać <code>displayName </code>z funkcji:</p> + +<pre class="brush: js">var object = { + // anonymous + someMethod: function(value) { + this.displayName = 'jakaśMetoda (' + value + ')'; + } +}; + +console.log(object.someMethod.displayName); // "undefined" + +object.someMethod('123') +console.log(object.someMethod.displayName); // "jakaśMetoda (123)" +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Zazwyczaj preferowane jest przez konsole i profilery podczas {{jsxref("Function.name", "func.name")}} aby wyświetlić nazwę funkcji.</p> + +<p>Umieszczony w konsoli powinien wyświetlić coś w rodzaju "<code>function Moja Funkcja()</code>":</p> + +<pre class="brush: js">var a = function() {}; +a.displayName = '<code>Moja Funkcja</code>'; + +a; // "function <code>Moja Funkcja</code>()"</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<p>Nie jest częścią żadnej specyfikacji.</p> + +<h2 id="Zgodność_z_przeglądarką">Zgodność z przeglądarką</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop(13)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/pl/web/javascript/referencje/obiekty/function/index.html b/files/pl/web/javascript/referencje/obiekty/function/index.html new file mode 100644 index 0000000000..2db4d33411 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/function/index.html @@ -0,0 +1,237 @@ +--- +title: Function +slug: Web/JavaScript/Referencje/Obiekty/Function +tags: + - Function + - JavaScript + - Konstruktor +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +<div>{{JSRef}}</div> + +<p><strong>Konstruktor</strong> <strong><code>Function</code> </strong>tworzy nowy obiekt Function(tworzy funkcję poprzez konstruktor). W JavaScripcie właściwie każda funkcja jest obiektem <code>Function</code>.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox"><code>new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Names to be used by the function as formal argument names. Each must be a string that corresponds to a valid JavaScript identifier or a list of such strings separated with a comma; for example "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd> + <dt><code>functionBody</code></dt> + <dd>A string containing the JavaScript statements comprising the function definition.</dd> +</dl> + +<h2 id="Description" name="Description">Opis</h2> + +<p><code>Function</code> objects created with the <code>Function</code> constructor are parsed when the function is created. This is less efficient than declaring a function with a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expression</a> or <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a> and calling it within your code, because such functions are parsed with the rest of the code.</p> + +<p>All arguments passed to the function are treated as the names of the identifiers of the parameters in the function to be created, in the order in which they are passed.</p> + +<div class="note"> +<p><strong>Note:</strong> Functions created with the <code>Function</code> constructor do not create closures to their creation contexts; they always are created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the <code>Function</code> constructor was called. This is different from using {{jsxref("Global_Objects/eval", "eval")}} with code for a function expression.</p> +</div> + +<p>Wywołanie konstruktora Function jako funkcję (bez użycia operatora 'new') ma taki sam efekt jak wywołanie konstruktora(z operatorem).</p> + +<h2 id="Właściwości_i_metody_Function">Właściwości i metody <code>Function</code></h2> + +<p>The global <code>Function</code> object has no methods or properties of its own, however, since it is a function itself it does inherit some methods and properties through the prototype chain from {{jsxref("Function.prototype")}}.</p> + +<h2 id="Function_prototype_object"><code>Function</code> prototype object</h2> + +<h3 id="Właściwości">Właściwości</h3> + +<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}</div> + +<h3 id="Methods" name="Methods">Metody</h3> + +<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}</div> + +<h2 id="Function_instances" name="Function_instances"><code>Function</code> instances</h2> + +<p><code>Function</code> instances inherit methods and properties from {{jsxref("Function.prototype")}}. As with all constructors, you can change the constructor's prototype object to make changes to all <code>Function</code> instances.</p> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<h3 id="Example.3A_Specifying_arguments_with_the_Function_constructor" name="Example.3A_Specifying_arguments_with_the_Function_constructor">Przykład: Specifying arguments with the <code>Function</code> constructor</h3> + +<p>Poniższy przykład tworzy obiekt Function(tworzy funkcję poprzez konstruktor), który przyjmuje dwa argumenty.</p> + +<pre class="brush: js">// Przykład może być uruchomiony bezpośrednio w konsoli JavaScript + +// Tworzy funkcję, która przyjmuje dwa argumenty i zwraca ich sumę +var adder = new Function('a', 'b', 'return a + b'); + +// Wywołanie funkcji +adder(2, 6); +// > 8 +</pre> + +<p>Argumenty "<code>a</code>" i "<code>b</code>" są formanie nazwami argumentrów, które są użyte w ciele funkcji, "<code>return a + b</code>".</p> + +<h3 id="Example:_A_recursive_shortcut_to_massively_modify_the_DOM" name="Example:_A_recursive_shortcut_to_massively_modify_the_DOM">Przykład: A recursive shortcut to massively modify the DOM</h3> + +<p>Creating functions with the <code>Function</code> constructor is one of the ways to dynamically create an indeterminate number of new objects with some executable code into the global scope from a function. The following example (a recursive shortcut to massively modify the DOM) is impossible without the invocation of the <code>Function</code> constructor for each new query if you want to avoid closures.</p> + +<pre class="brush: html language-html"><code class="language-html"><!doctype html> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>html</span><span class="punctuation token">></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>head</span><span class="punctuation token">></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>meta</span> <span class="attr-name token">http-equiv</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>Content-Type<span class="punctuation token">"</span></span> <span class="attr-name token">content</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>text/html; charset<span class="punctuation token">=</span>UTF-8<span class="punctuation token">"</span></span> <span class="punctuation token">/></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>title</span><span class="punctuation token">></span></span>MDN Example - a recursive shortcut to massively modify the DOM<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>title</span><span class="punctuation token">></span></span> +<span class="script token"><span class="tag token"><span class="tag token"><span class="punctuation token"><</span>script</span> <span class="attr-name token">type</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>text/javascript<span class="punctuation token">"</span></span><span class="punctuation token">></span></span> +<span class="keyword token">var</span> domQuery <span class="operator token">=</span> <span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> aDOMFunc <span class="operator token">=</span> <span class="punctuation token">[</span> + Element<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>removeAttribute<span class="punctuation token">,</span> + Element<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>setAttribute<span class="punctuation token">,</span> + CSSStyleDeclaration<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>removeProperty<span class="punctuation token">,</span> + CSSStyleDeclaration<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>setProperty + <span class="punctuation token">]</span><span class="punctuation token">;</span> + + <span class="keyword token">function</span> <span class="function token">setSomething<span class="punctuation token">(</span></span>bStyle<span class="punctuation token">,</span> sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> bSet <span class="operator token">=</span> <span class="function token">Boolean<span class="punctuation token">(</span></span>sVal<span class="punctuation token">)</span><span class="punctuation token">,</span> fAction <span class="operator token">=</span> aDOMFunc<span class="punctuation token">[</span>bSet <span class="operator token">|</span> bStyle <span class="operator token"><</span><span class="operator token"><</span> <span class="number token">1</span><span class="punctuation token">]</span><span class="punctuation token">,</span> + aArgs <span class="operator token">=</span> Array<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>slice<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span>arguments<span class="punctuation token">,</span> <span class="number token">1</span><span class="punctuation token">,</span> bSet <span class="operator token">?</span> <span class="number token">3</span> <span class="punctuation token">:</span> <span class="number token">2</span><span class="punctuation token">)</span><span class="punctuation token">,</span> + aNodeList <span class="operator token">=</span> bStyle <span class="operator token">?</span> <span class="keyword token">this</span><span class="punctuation token">.</span>cssNodes <span class="punctuation token">:</span> <span class="keyword token">this</span><span class="punctuation token">.</span>nodes<span class="punctuation token">;</span> + + <span class="keyword token">if</span> <span class="punctuation token">(</span>bSet <span class="operator token">&&</span> bStyle<span class="punctuation token">)</span> <span class="punctuation token">{</span> aArgs<span class="punctuation token">.</span><span class="function token">push<span class="punctuation token">(</span></span><span class="string token">''</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="punctuation token">}</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span> + <span class="keyword token">var</span> nItem <span class="operator token">=</span> <span class="number token">0</span><span class="punctuation token">,</span> nLen <span class="operator token">=</span> <span class="keyword token">this</span><span class="punctuation token">.</span>nodes<span class="punctuation token">.</span>length<span class="punctuation token">;</span> + nItem <span class="operator token"><</span> nLen<span class="punctuation token">;</span> + fAction<span class="punctuation token">.</span><span class="function token">apply<span class="punctuation token">(</span></span>aNodeList<span class="punctuation token">[</span>nItem<span class="operator token">++</span><span class="punctuation token">]</span><span class="punctuation token">,</span> aArgs<span class="punctuation token">)</span> + <span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">this</span><span class="punctuation token">.</span>follow <span class="operator token">=</span> setSomething<span class="punctuation token">.</span>caller<span class="punctuation token">;</span> + <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + + <span class="keyword token">function</span> <span class="function token">setStyles<span class="punctuation token">(</span></span>sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> setSomething<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span><span class="keyword token">this</span><span class="punctuation token">,</span> <span class="keyword token">true</span><span class="punctuation token">,</span> sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="punctuation token">}</span> + <span class="keyword token">function</span> <span class="function token">setAttribs<span class="punctuation token">(</span></span>sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> setSomething<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span><span class="keyword token">this</span><span class="punctuation token">,</span> <span class="keyword token">false</span><span class="punctuation token">,</span> sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="punctuation token">}</span> + <span class="keyword token">function</span> <span class="function token">getSelectors<span class="punctuation token">(</span></span><span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">.</span>selectors<span class="punctuation token">;</span> <span class="punctuation token">}</span><span class="punctuation token">;</span> + <span class="keyword token">function</span> <span class="function token">getNodes<span class="punctuation token">(</span></span><span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">.</span>nodes<span class="punctuation token">;</span> <span class="punctuation token">}</span><span class="punctuation token">;</span> + + <span class="keyword token">return</span> <span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span>sSelectors<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> oQuery <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Function</span><span class="punctuation token">(</span><span class="string token">'return arguments.callee.follow.apply(arguments.callee, arguments);'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>selectors <span class="operator token">=</span> sSelectors<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>nodes <span class="operator token">=</span> document<span class="punctuation token">.</span><span class="function token">querySelectorAll<span class="punctuation token">(</span></span>sSelectors<span class="punctuation token">)</span><span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>cssNodes <span class="operator token">=</span> Array<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>map<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span>oQuery<span class="punctuation token">.</span>nodes<span class="punctuation token">,</span> <span class="keyword token">function</span><span class="punctuation token">(</span>oInlineCSS<span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> oInlineCSS<span class="punctuation token">.</span>style<span class="punctuation token">;</span> <span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>attributes <span class="operator token">=</span> setAttribs<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>inlineStyle <span class="operator token">=</span> setStyles<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>follow <span class="operator token">=</span> getNodes<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>toString <span class="operator token">=</span> getSelectors<span class="punctuation token">;</span> + oQuery<span class="punctuation token">.</span>valueOf <span class="operator token">=</span> getNodes<span class="punctuation token">;</span> + <span class="keyword token">return</span> oQuery<span class="punctuation token">;</span> + <span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>script</span><span class="punctuation token">></span></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>head</span><span class="punctuation token">></span></span> + +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>body</span><span class="punctuation token">></span></span> + +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>div</span> <span class="attr-name token">class</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>testClass<span class="punctuation token">"</span></span><span class="punctuation token">></span></span>Lorem ipsum<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>div</span><span class="punctuation token">></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>p</span><span class="punctuation token">></span></span>Some text<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>p</span><span class="punctuation token">></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"><</span>div</span> <span class="attr-name token">class</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>testClass<span class="punctuation token">"</span></span><span class="punctuation token">></span></span>dolor sit amet<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>div</span><span class="punctuation token">></span></span> + +<span class="script token"><span class="tag token"><span class="tag token"><span class="punctuation token"><</span>script</span> <span class="attr-name token">type</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>text/javascript<span class="punctuation token">"</span></span><span class="punctuation token">></span></span> +<span class="function token">domQuery<span class="punctuation token">(</span></span><span class="string token">'.testClass'</span><span class="punctuation token">)</span> + <span class="punctuation token">.</span><span class="function token">attributes<span class="punctuation token">(</span></span><span class="string token">'lang'</span><span class="punctuation token">,</span> <span class="string token">'en'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'title'</span><span class="punctuation token">,</span> <span class="string token">'Risus abundat in ore stultorum'</span><span class="punctuation token">)</span> + <span class="punctuation token">.</span><span class="function token">inlineStyle<span class="punctuation token">(</span></span><span class="string token">'background-color'</span><span class="punctuation token">,</span> <span class="string token">'black'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'color'</span><span class="punctuation token">,</span> <span class="string token">'white'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'width'</span><span class="punctuation token">,</span> <span class="string token">'100px'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'height'</span><span class="punctuation token">,</span> <span class="string token">'50px'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>script</span><span class="punctuation token">></span></span></span> +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>body</span><span class="punctuation token">></span></span> + +<span class="tag token"><span class="tag token"><span class="punctuation token"></</span>html</span><span class="punctuation token">></span></span></code></pre> + +<p> </p> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<p> </p> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Zobacz również</h2> + +<ul> + <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Statements/function*", "function* statement")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/function/length/index.html b/files/pl/web/javascript/referencje/obiekty/function/length/index.html new file mode 100644 index 0000000000..e34ecb8154 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/function/length/index.html @@ -0,0 +1,42 @@ +--- +title: Function.length +slug: Web/JavaScript/Referencje/Obiekty/Function/length +tags: + - Function + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/length +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Określa liczbę argumentów oczekiwanych przez funkcję.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt <code>length</code> znajduje się na zewnątrz funkcji i określa jak wiele argumentów ma oczekiwać funkcja, i.e. liczbę oficjalnych parametrów. W przeciwieństwie do obiektu {{jsxref("arguments.length")}}, który znajduje się wewnątrz funkcji, określa liczbę argumentów faktycznie przekazywanych do funkcji.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length" name="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length">Przykład: Zastosowanie <code>Function.length</code> i <code>arguments.length</code></h3> + +<p>Następujący przykład pokazuje w jaki należy zastosować <code>Function.length</code> i <code>arguments.length</code>.</p> + +<pre class="brush: js">function addNumbers(x, y){ + if (arguments.length == addNumbers.length) { + return (x + y); + } + else + return 0; +} +</pre> + +<p>Jeśli podamy więcej niż dwa argumenty do tej funkcji, funkcja zwróci 0:</p> + +<pre class="eval">addNumbers(3,4,5) // zwraca 0 +addNumbers(3,4) // zwraca 7 +addNumbers(103,104) // zwraca 207 +</pre> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/referencje/obiekty/function/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/function/tostring/index.html new file mode 100644 index 0000000000..2f158219b9 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/function/tostring/index.html @@ -0,0 +1,56 @@ +--- +title: Function.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/Function/toString +tags: + - Function + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy funkcji.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code><var>function</var>.toString(indentation)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>indentation</code> {{non-standard_inline}} {{obsolete_inline(17)}}</dt> + <dd>The amount of spaces to indent the string representation of the source code. If <code>indentation</code> is less than or equal to <code>-1</code>, most unnecessary spaces are removed.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("Function")}} przesłania metodę {{jsxref("Object.prototype.toString", "toString")}} obiektu {{jsxref("Function")}}; nie dziedziczy {{jsxref("Object.prototype.toString")}}. Dla obiektów <code>Function</code>, metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt.</p> + +<p>JavaScript wywołuje metodę <code>toString()</code> automatycznie, gdy {{jsxref("Function")}} jest reprezentowana jako wartość tekstowa lub kiedy <code>Function</code> jest odsyłana do połączenia łańcuchów znaków.</p> + +<p>Dla obiektów {{jsxref("Function")}}, wbudowana metoda <code>toString)=</code> dekompiluje funkcję z powrotem do kodu JavaScript, który tę funkcję definiuje. Łańcuch znaków zawiera słowa kluczowe <code>function</code>, listę argumentów, nawiasy klamrowe oraz ciało funkcji.</p> + +<p>Załóżmy na przykład, że masz poniższy kod, który definiuje obiektowy typ <code>Dog</code> i tworzy <code>theDog</code>, obiekt typu <code>Dog</code>:</p> + +<pre class="brush:js">function Dog(name, breed, color, sex) { + this.name = name + this.breed = breed + this.color = color + this.sex = sex +} + +theDog = new Dog( "Gabby", "Lab", "chocolate", "girl" ); +</pre> + +<p>W dowolnej chwili, gdy <code>Dog</code> jest użyty w kontekście jako łańcuch znaków, JavaScript automatycznie wywołuje funkcję <code>toString</code>, która zwraca poniższy łańcuch znaków:</p> + +<pre class="brush: js">function Dog(name, breed, color, sex) { this.name = name; this.breed = breed; this.color = color; this.sex = sex; }</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/generator/index.html b/files/pl/web/javascript/referencje/obiekty/generator/index.html new file mode 100644 index 0000000000..8d181f0dcc --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/generator/index.html @@ -0,0 +1,178 @@ +--- +title: Generator +slug: Web/JavaScript/Referencje/Obiekty/Generator +translation_of: Web/JavaScript/Reference/Global_Objects/Generator +--- +<div>{{JSRef}}</div> + +<p>Obiekt <code><strong>Generator</strong></code> jest zwracany przez {{jsxref("Polecenia/function*", "generator function", "", 1)}} i odpowiada obu: <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable">iterable protocol</a> i <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator">iterator protocol</a>.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); // "Generator { }"</pre> + +<h2 id="Methods">Methods</h2> + +<dl> + <dt>{{jsxref("Generator.prototype.next()")}}</dt> + <dd>Returns a value yielded by the {{jsxref("Operators/yield", "yield")}} expression.</dd> + <dt>{{jsxref("Generator.prototype.return()")}}</dt> + <dd>Returns the given value and finishes the generator.</dd> + <dt>{{jsxref("Generator.prototype.throw()")}}</dt> + <dd>Throws an error to a generator.</dd> +</dl> + +<h2 id="Example">Example</h2> + +<h3 id="An_infinite_iterator">An infinite iterator</h3> + +<pre class="brush: js">function* idMaker() { + var index = 0; + while(true) + yield index++; +} + +var gen = idMaker(); // "Generator { }" + +console.log(gen.next().value); // 0 +console.log(gen.next().value); // 1 +console.log(gen.next().value); // 2 +// ...</pre> + +<h2 id="Legacy_generator_objects">Legacy generator objects</h2> + +<p>Firefox (SpiderMonkey) also implements an earlier version of generators in <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.7">JavaScript 1.7</a>, where the star (*) in the function declaration was not necessary (you just use the <code>yield</code> keyword in the function body). However, legacy generators are deprecated. Do not use them; they are going to be removed ({{bug(1083482)}}).</p> + +<h3 id="Legacy_generator_methods">Legacy generator methods</h3> + +<dl> + <dt><code>Generator.prototype.next() </code>{{non-standard_inline}}</dt> + <dd>Returns a value yielded by the {{jsxref("Operatory/yield", "yield")}} expression. This corresponds to <code>next()</code> in the ES2015 generator object.</dd> + <dt><code>Generator.prototype.close()</code> {{non-standard_inline}}</dt> + <dd>Closes the generator, so that when calling <code>next()</code> an {{jsxref("StopIteration")}} error will be thrown. This corresponds to the <code>return()</code> method in the ES2015 generator object.</dd> + <dt><code>Generator.prototype.send()</code> {{non-standard_inline}}</dt> + <dd>Used to send a value to a generator. The value is returned from the {{jsxref("Operatory/yield", "yield")}} expression, and returns a value yielded by the next {{jsxref("Operatory/yield", "yield")}} expression. <code>send(x)</code> corresponds to <code>next(x)</code> in the ES2015 generator object.</dd> + <dt><strong><code>Generator.</code></strong><code>prototype.</code><strong><code>throw()</code> </strong> {{non-standard_inline}}</dt> + <dd>Throws an error to a generator. This corresponds to the <code>throw()</code> method in the ES2015 generator object.</dd> +</dl> + +<h3 id="Legacy_generator_example">Legacy generator example</h3> + +<pre class="brush: js">function fibonacci() { + var a = yield 1; + yield a * 2; +} + +var it = fibonacci(); +console.log(it); // "Generator { }" +console.log(it.next()); // 1 +console.log(it.send(10)); // 20 +console.log(it.close()); // undefined +console.log(it.next()); // throws StopIteration (as the generator is now closed) +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(39.0)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(39.0)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(39.0)}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<h3 id="Legacy_generators">Legacy generators</h3> + +<ul> + <li>{{jsxref("Statements/Legacy_generator_function", "The legacy generator function", "", 1)}}</li> + <li>{{jsxref("Operators/Legacy_generator_function", "The legacy generator function expression", "", 1)}}</li> + <li>{{jsxref("StopIteration")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features/The_legacy_Iterator_protocol">The legacy Iterator protocol</a></li> +</ul> + +<h3 id="ES2015_generators">ES2015 generators</h3> + +<ul> + <li>{{jsxref("Functions", "Functions", "", 1)}}</li> + <li>{{jsxref("Statements/function", "function")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function*", "function*")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/index.html b/files/pl/web/javascript/referencje/obiekty/index.html new file mode 100644 index 0000000000..ebe6dfe63f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/index.html @@ -0,0 +1,193 @@ +--- +title: Obiekty +slug: Web/JavaScript/Referencje/Obiekty +tags: + - Dokumentacja + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>W tym rozdziale opisano wszystkie standardowe obiekty wbudowane JavaScript, w tym ich metody i właściwości.</p> + +<p>Pojęcie "obiekty globalne" (lub standardowe obiekty wbudowane) tutaj nie są tym samym, co <strong>obiekt globalny</strong>, który odnosi się do <strong>obiektów o zasięgu globalnym</strong>. Dostęp do <strong>obiektu globalnego</strong> można uzyskać za pomocą operatoa {{jsxref("Operatory/this", "this")}} w zakresie globalnym (ale tylko, jeśli nie jest właczony tryb ścisły ECMAScript 5. W trybie ścisłym, w takim przypadku zostanie zwrócona wartość {{jsxref("undefined")}}). W rzeczywistości, zakres globalny <strong>składa się</strong> z własciwości obiektu globalnego, w tym właściwości dziedziczonych, jeśli istnieją.</p> + +<p>Innymi obiektami o zasięgu globalnym są <a href="/pl/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">obiekty tworzone w skryptach przez użytkowników</a> albo dostarczane przez aplikacje hosta. Obiekty hosta dostępne w kontekście przeglądarki są opisane w <a href="/pl/docs/Web/API/Reference">informatorze API</a>. Więcej informacji o różnicach dzielących <a href="/pl/docs/DOM/DOM_Reference">DOM</a> i rdzeń <a href="/pl/docs/Web/JavaScript">JavaScript</a>, znajdziesz we <a href="/pl/docs/Web/JavaScript/JavaScript_technologies_overview">Przeglądzie technologii JavaScript</a>.</p> + +<h2 id="Obiekty_standardowe_wg_kategorii">Obiekty standardowe wg kategorii</h2> + +<h3 id="Wartości">Wartości</h3> + +<p>Właściwości globalne zwracają proste wartości, które nie mają swoich własciwości ani metod</p> + +<ul> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("NaN")}}</li> + <li>{{jsxref("undefined")}}</li> + <li>literał {{jsxref("null")}}</li> +</ul> + +<h3 id="Funkcje">Funkcje</h3> + +<p>Należą tu funkcje globalne (wywoływane globalnie a nie w jakimś obiekcie), które zwracają swoją wartość bezpośredni do wywołania.</p> + +<ul> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> + <li>{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline}}</li> + <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> + <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li> + <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> + <li>{{jsxref("Global_Objects/decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent()")}}</li> + <li>{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}</li> + <li>{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline}}</li> + <li>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline}}</li> +</ul> + +<h3 id="Obiekty_podstawowe">Obiekty podstawowe</h3> + +<p>Są to fundamentalne, podstawowe obiekty, stanowiące podstawę do tworzenia innych obiektów. Obejmuje to obiekty reprezentujace obiekty ogólne, funkcje i błędy.</p> + +<ul> + <li>{{jsxref("Object")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Boolean")}}</li> + <li>{{jsxref("Symbol")}}</li> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("EvalError")}}</li> + <li>{{jsxref("InternalError")}}</li> + <li>{{jsxref("RangeError")}}</li> + <li>{{jsxref("ReferenceError")}}</li> + <li>{{jsxref("SyntaxError")}}</li> + <li>{{jsxref("TypeError")}}</li> + <li>{{jsxref("URIError")}}</li> +</ul> + +<h3 id="Liczby_i_daty">Liczby i daty</h3> + +<p>Są to obiekty podstawowe reprezentujace liczby, daty i obliczenia matematyczne.</p> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("Math")}}</li> + <li>{{jsxref("Date")}}</li> +</ul> + +<h3 id="Przetwarzanie_tekstu">Przetwarzanie tekstu</h3> + +<p>Kategorie te tworzą obiekty reprezentujące łańcuchy i obsługujace manipulowanie łańcuchami.</p> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("RegExp")}}</li> +</ul> + +<h3 id="Indeksowane_kolekcje">Indeksowane kolekcje</h3> + +<p>Obiekty te reprezentują kolekcje danych, ktore są uporządkowane według wartości indeksu. Opejmuje to tablice, typowane tablice i konstrukcje podobne do tablic.</p> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Int8Array")}}</li> + <li>{{jsxref("Uint8Array")}}</li> + <li>{{jsxref("Uint8ClampedArray")}}</li> + <li>{{jsxref("Int16Array")}}</li> + <li>{{jsxref("Uint16Array")}}</li> + <li>{{jsxref("Int32Array")}}</li> + <li>{{jsxref("Uint32Array")}}</li> + <li>{{jsxref("Float32Array")}}</li> + <li>{{jsxref("Float64Array")}}</li> +</ul> + +<h3 id="Kolekcje_z_kluczami">Kolekcje z kluczami</h3> + +<p>Są to obiekty reprezentujące kolekcje stosujace klucze. Zawierają elementy, które są iterowalne w kolejności estawiania.</p> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> + +<h3 id="Kolekcje_wektorowe">Kolekcje wektorowe</h3> + +<p>Typy danych wektorowych {{Glossary("SIMD")}} są obiektami, w których dane formowane są w potoki.</p> + +<ul> + <li>{{jsxref("SIMD")}} {{experimental_inline}}</li> + <li>{{jsxref("Float32x4", "SIMD.Float32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Float64x2", "SIMD.Float64x2")}} {{experimental_inline}}</li> + <li>{{jsxref("Int8x16", "SIMD.Int8x16")}} {{experimental_inline}}</li> + <li>{{jsxref("Int16x8", "SIMD.Int16x8")}} {{experimental_inline}}</li> + <li>{{jsxref("Int32x4", "SIMD.Int32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Uint8x16", "SIMD.Uint8x16")}} {{experimental_inline}}</li> + <li>{{jsxref("Uint16x8", "SIMD.Uint16x8")}} {{experimental_inline}}</li> + <li>{{jsxref("Uint32x4", "SIMD.Uint32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool8x16", "SIMD.Bool8x16")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool16x8", "SIMD.Bool16x8")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool32x4", "SIMD.Bool32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool64x2", "SIMD.Bool64x2")}} {{experimental_inline}}</li> +</ul> + +<h3 id="Dane_strukturalne">Dane strukturalne</h3> + +<p>Obiekty tej kategorii reprezentują i współdziałają ze strukturyzowanymi buforami danych i danymi kodowymi uzywającymi notacji JSON (JavaScript Object Notation).</p> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}} {{experimental_inline}}</li> + <li>{{jsxref("Atomics")}} {{experimental_inline}}</li> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("JSON")}}</li> +</ul> + +<h3 id="Kontrola_obiektów_abstrakcyjnych">Kontrola obiektów abstrakcyjnych</h3> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Generator")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li>{{experimental_inline}} {{jsxref("AsyncFunction")}}</li> +</ul> + +<h3 id="Refleksy">Refleksy</h3> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Proxy")}}</li> +</ul> + +<h3 id="Internacjonalizacja">Internacjonalizacja</h3> + +<p>Dodatki do jadra ECMAScript dla funkcji językowych.</p> + +<ul> + <li>{{jsxref("Intl")}}</li> + <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</li> +</ul> + +<h3 id="WebAssembly">WebAssembly</h3> + +<ul> + <li>{{jsxref("WebAssembly")}}</li> + <li>{{jsxref("WebAssembly.Module")}}</li> + <li>{{jsxref("WebAssembly.Instance")}}</li> + <li>{{jsxref("WebAssembly.Memory")}}</li> + <li>{{jsxref("WebAssembly.Table")}}</li> + <li>{{jsxref("WebAssembly.CompileError")}}</li> + <li>{{jsxref("WebAssembly.LinkError")}}</li> + <li>{{jsxref("WebAssembly.RuntimeError")}}</li> +</ul> + +<h3 id="Pozostałe">Pozostałe</h3> + +<ul> + <li><code><a href="/pl/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></code></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/infinity/index.html b/files/pl/web/javascript/referencje/obiekty/infinity/index.html new file mode 100644 index 0000000000..7a2bd7ca45 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/infinity/index.html @@ -0,0 +1,35 @@ +--- +title: Infinity +slug: Web/JavaScript/Referencje/Obiekty/Infinity +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Infinity +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość numeryczna reprezentująca nieskończoność.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Infinity </code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>Infinity</code> jest własnością najwyższego rzędu i nie jest przypisana do żadnego obiektu.</p> + +<p>Początkową wartością <code>Infinity</code> jest {{jsxref("Number.POSITIVE_INFINITY")}}.</p> + +<p>Wartość <code>Infinity</code> (+nieskończoność) jest większa niż jakakolwiek liczba. Wartość ta ma wszystkie cechy matematycznej nieskończoności; np. cokolwiek pomnożone przez <code>Infinity</code> jest równe <code>Infinity</code>, a cokolwiek podzielone przez <code>Infinity</code> jest równe 0.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/isfinite/index.html b/files/pl/web/javascript/referencje/obiekty/isfinite/index.html new file mode 100644 index 0000000000..3b699e33c2 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/isfinite/index.html @@ -0,0 +1,56 @@ +--- +title: isFinite() +slug: Web/JavaScript/Referencje/Obiekty/isFinite +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/isFinite +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Przetwarza argument w celu stwierdzenia czy jest on liczbą skończoną.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox">isFinite(<em>liczba</em>)</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>liczba</code> </dt> + <dd>Liczba do przetworzenia.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>isFinite()</code> jest funkcją najwyższego poziomu, niepowiązaną z żadnym obiektem.</p> + +<p>Można użyć tej metody do określenia czy dana liczba jest skończona. Metoda <code>isFinite()</code> sprawdza liczbę podaną jako jej argument. Jeśli argument ma wartość {{jsxref("NaN")}} (nie jest liczbą), jest dodatnią lub ujemną nieskończonością, metoda ta zwraca <code>false</code>, w przeciwnym wypadku zwraca wartość <code>true</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<pre class="brush: js">isFinite(Infinity); // false +isFinite(NaN); // false +isFinite(-Infinity); // false + +isFinite(0); // true +isFinite(2e64); // true + + +isFinite("0"); // true, would've been false with the + // more robust Number.isFinite("0") +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Number.NaN()")}}</li> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/isnan/index.html b/files/pl/web/javascript/referencje/obiekty/isnan/index.html new file mode 100644 index 0000000000..f2730b9c00 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/isnan/index.html @@ -0,0 +1,53 @@ +--- +title: isNaN() +slug: Web/JavaScript/Referencje/Obiekty/isNaN +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/isNaN +--- +<p>{{jsSidebar("Objects")}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Sprawdza, czy argument nie ma wartości NaN ("nie-liczba").</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>isNaN(<em>testowanaWartość</em>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>testowanaWartość</code> </dt> + <dd>Wartość do sprawdzenia.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>isNaN</code> jest funkcją najwyższego rzędu i nie jest przypisana do żadnego obiektu.</p> + +<p>Funkcje <code>parseFloat</code> i <code>parseInt</code> zwracają <code>NaN</code>, kiedy wyliczą wartość, która nie jest liczbą. <code>isNaN</code> zwraca <code>true</code>, jeśli przekazano jej <code>NaN</code>, a <code>false</code> w przeciwnym wypadku.</p> + +<p>Funkcja ta jest o tyle przydatna, że wartości {{jsxref("NaN", "NaN")}} nie można skutecznie sprawdzać przy użyciu operatorów równości. <code>x == NaN</code> i <code>x === NaN</code> mają zawsze wartość <code>false</code>, bez względu na to, jaką wartość ma <code>x</code>, nawet jeśli <code>x</code> to <code>NaN</code>. Na przykład, zarówno <code>1 == NaN</code>, jak i <code>NaN == NaN</code> zwracają <code>false</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_isNaN" name="Przyk.C5.82ad:_Zastosowanie_isNaN">Przykład: Zastosowanie <code>isNaN</code></h3> + +<p>Poniższy przykład wylicza wartość <code>floatValue</code>, by sprawdzić, czy jest liczbą, a następnie wywołuje odpowiednią procedurę.</p> + +<pre class="brush: js">var floatValue = parseFloat(toFloat); + +if (isNaN(floatValue)) { + notFloat(); +} else { + isFloat(); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("NaN")}}</li> + <li>{{jsxref("Number.isNaN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/java/index.html b/files/pl/web/javascript/referencje/obiekty/java/index.html new file mode 100644 index 0000000000..94e53a85b0 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/java/index.html @@ -0,0 +1,29 @@ +--- +title: java +slug: Web/JavaScript/Referencje/Obiekty/java +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/java +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p><b>Obiekt główny</b> +</p><p>Obiekt najwyższego poziomu używany do korzystania z klas języka Java z pakietu <code>java.*</code>. +</p> +<h3 id="Tworzony_przez" name="Tworzony_przez"> Tworzony przez </h3> +<p>Obiekt <code>java</code> w języku JavaScript jest predefiniowanym obiektem najwyższego poziomu. Nie ma potrzeby stosowania konstruktora lub wywoływania jakiejkolwiek metody by z niego korzystać. +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Obiekt <code>java</code> jest synonimem dla własności <code>Packages.java</code>. +</p> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages/java">Packages.java</a></code> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/java", "es": "es/Referencia_de_JavaScript_1.5/Objetos_globales/java" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/javaarray/index.html b/files/pl/web/javascript/referencje/obiekty/javaarray/index.html new file mode 100644 index 0000000000..ad4f84b0c4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/javaarray/index.html @@ -0,0 +1,68 @@ +--- +title: JavaArray +slug: Web/JavaScript/Referencje/Obiekty/JavaArray +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/JavaArray +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p><b>Obiekt główny</b> </p><p>Zapakowana tablica Javy, do której dostęp uzyskuje się poprzez kod JavaScript jest członkiem typu <code>JavaArray</code>. </p> +<h3 id="Tworzone_przez" name="Tworzone_przez"> Tworzone przez </h3> +<p>Jakąkolwiek metodę Javy, która zwraca tablicę. W dodatku, możesz stworzyć obiekt <code>JavaArray</code> z dowolnym typem danych używając metody <code>newInstance</code> klasy <code>Array</code>: +</p> +<pre class="eval">public static Object newInstance(Class componentType, + int length) + throws NegativeArraySizeException +</pre> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Obiekt <code>JavaArray</code> jest wystąpieniem tablicy Javy, która jest stworzona wewnątrz kody JavaScript lub do niego przekazana. <code>JavaArray</code> jest opakowaniem (ang. <i>wrapper</i>) dla tej instancji; wszystkie referencje do niej są robione przez <code>JavaArray</code>. +</p><p>W JavaScript 1.4 i późniejszym, parametr <code>componentType</code> jest albo obiektem typu <code>JavaClass</code> reprezentującym typ tablicy albo obiektem klasowym, jak na przykład obiekt zwracany przez <code>java.lang.Class.forName</code>. W JavaScript 1.3 i wcześniejszych, <code>componentType</code> musi być obiektem klasowym. +</p><p>Użyj indeksy oparte na zerze, aby uzyskać dostęp do obiektu <code>JavaArray</code>, tak samo jak robisz to w Javie. Na przykład: +</p> +<pre>var javaString = new java.lang.String("Hello world!"); +var byteArray = javaString.getBytes(); +byteArray[0] // zwraca 72 +byteArray[1] // zwraca 101 +</pre> +<p>Jakiekolwiek dane Javy przeniesione do JavaScriptu są konwertowane do typów danych JavaScriptu. Kiedy obiekt <code>JavaArray</code> jest przekazany z powrotem do Javy, obiekt jest rozpakowywany i może być użyty przez kod Javy. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5">Przewodnik po języku JavaScript 1.5</a>, aby uzyskać więcej informacji na temat konwersji typów danych. </p><p>W JavaScripcie 1.4 i późniejszym, metody <code>java.lang.Object</code> są dziedziczone przez <code>JavaArray</code>. +</p> +<h3 id="Zgodno.C5.9B.C4.87_wsteczna" name="Zgodno.C5.9B.C4.87_wsteczna"> Zgodność wsteczna </h3> +<h4 id="JavaScript_1.3_i_wersje_wcze.C5.9Bniejsze" name="JavaScript_1.3_i_wersje_wcze.C5.9Bniejsze"> JavaScript 1.3 i wersje wcześniejsze </h4> +<p>Metody <code>java.lang.Object</code> nie są dziedziczone przez <code>JavaArray</code>. W dodatku, metoda <code>toString</code> jest dziedziczona z obiektu <code>Object</code> i zwraca następującą wartość: +</p> +<pre class="eval">[object JavaArray] +</pre> +<p>Musisz określić klasę obiektu, tak jak jeden zwracany przez <code>java.lang.Object.forName</code>, dla parametru <code>componentType</code>, <code>newInstance</code> kiedy użyjesz tej metody do utworzenia tablicy. Nie możesz użyć obiektu <code>JavaClass</code> dla parametru <code>componentType</code>. +</p> +<h3 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci"> Własności </h3> +<p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaArray/length">length</a>: Numer elementu w Java array reprezentowana przez <code>JavaArray</code>. +</p> +<h3 id="Metody" name="Metody"> Metody </h3> +<p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaArray/toString">toString</a>: W JavaScript 1.4, ta metoda ta nie jest uwzględniana przez odziedziczona metodę <code>java.lang.Object.toString</code>. W JavaScript 1.3 lub lub wcześniejszym, metoda ta zwraca ciąg znaków (stringa) identyfikującego obiekt jako <code>JavaArray</code>. +</p><p>W JavaScript 1.4 lub późniejszym, <code>JavaArray</code> dziedziczy również metody z superklasy tablicy Javy, <code>java.lang.Object</code>. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Tworzenie_JavaArray_w_JavaScript" name="Przyk.C5.82ad:_Tworzenie_JavaArray_w_JavaScript"> Przykład: Tworzenie <code>JavaArray</code> w JavaScript </h4> +<p>W tym przykładzie, <code>JavaArray</code> <code>tablicaBitowa</code> jest stworzona przez metodę <code>java.lang.String.getBytes</code>, która zwraca tablicę. +</p> +<pre class="eval">var stringJavy = new java.lang.String("Witaj świecie!"); +var tablicaBitowa = stringJavy.getBytes(); +</pre> +<h4 id="Przyk.C5.82ad:_Tworzenie_JavaArray_w_JavaScript_z_metod.C4.85_newInstance" name="Przyk.C5.82ad:_Tworzenie_JavaArray_w_JavaScript_z_metod.C4.85_newInstance"> Przykład: Tworzenie <code>JavaArray</code> w JavaScript z metodą <code>newInstance</code> </h4> +<p>W JavaScript 1.4, możesz użyć obiekt <code>JavaClass</code> jako argument dla metody <code>newInstance</code>, która tworzy tablicę, jak jest to pokazane w następującym kodzie: +</p> +<pre class="eval">var dogs = java.lang.reflect.Array.newInstance(java.lang.String, 5); +</pre> +<p>W JavaScript 1.1, użyj obiektu klasy, zwracanego <code>java.lang.Class.forName</code> jako argument dla metody newInstance, jak pokazuje następujący kod: +</p> +<pre class="eval">var dataType = java.lang.Class.forName("java.lang.String"); +var dogs = java.lang.reflect.Array.newInstance(dataType, 5); +</pre> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/JavaArray", "es": "es/Referencia_de_JavaScript_1.5/Objetos_globales/JavaArray" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/javaarray/length/index.html b/files/pl/web/javascript/referencje/obiekty/javaarray/length/index.html new file mode 100644 index 0000000000..584bf347e8 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/javaarray/length/index.html @@ -0,0 +1,29 @@ +--- +title: length +slug: Web/JavaScript/Referencje/Obiekty/JavaArray/length +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/JavaArray/length +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Liczba elementów tablicy w Javie reprezentowana przez obiekt <code>JavaArray</code>. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Własność obiektu: <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaArray">JavaArray</a></td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.1, NES 2.0</td> +</tr> +</tbody></table> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Niepodobny do <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/length">Array.length</a></code>, <code>JavaArray.length</code> jest własnością tylko do odczytu. Nie możemy zmieniać wartości własności <code>JavaArray.length</code>, ponieważ tablice w Javie mają fałszywą liczbę elementów. </p> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/length">Array.length</a></code> +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/JavaArray/length" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/javaarray/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/javaarray/tostring/index.html new file mode 100644 index 0000000000..384cb3ab8b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/javaarray/tostring/index.html @@ -0,0 +1,38 @@ +--- +title: toString +slug: Web/JavaScript/Referencje/Obiekty/JavaArray/toString +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/JavaArray/toString +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Zwraca łańcuch znakowy reprezentowany przez <code>JavaArray</code>. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Metoda obiektu <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaArray">JavaArray</a></td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.1, NES 2.0</td> +</tr> +</tbody></table> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<p>Brak. +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Nazywamy metodę <code>java.lang.Object.toString</code>, która zwróci wartość następującego wyrażenia: </p> +<pre>JavaArray.getClass().getName() + '@' + + java.lang.Integer.toHexString(JavaArray.hashCode()) +</pre> +<h3 id="Zgodno.C5.9B.C4.87_wsteczna" name="Zgodno.C5.9B.C4.87_wsteczna"> Zgodność wsteczna </h3> +<h4 id="JavaScript_1.3_i_wersje_wcze.C5.9Bniejsze" name="JavaScript_1.3_i_wersje_wcze.C5.9Bniejsze"> JavaScript 1.3 i wersje wcześniejsze </h4> +<p>Metoda <code>toString</code> jest dziedziczona z obiektu <code>Object</code> i zwraca następującą wartość: </p> +<pre>[object JavaArray] +</pre> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/JavaArray/toString" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/javaclass/index.html b/files/pl/web/javascript/referencje/obiekty/javaclass/index.html new file mode 100644 index 0000000000..6a71eb42fe --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/javaclass/index.html @@ -0,0 +1,60 @@ +--- +title: JavaClass +slug: Web/JavaScript/Referencje/Obiekty/JavaClass +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/JavaClass +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p><b>Obiekt główny</b> +</p><p>Referencja JavaScriptu do klasy Javy. +</p> +<h3 id="Tworzony_przez" name="Tworzony_przez"> Tworzony przez </h3> +<p>Referencja do nazwy klasy użyta wraz z obiektem <code>Packages</code>: +</p> +<pre class="eval">Packages.<i>KlasaJavy</i> +</pre> +<p><i>KlasaJavy</i> jest w pełni podaną nazwą klasy Javy obiektu. LiveConnect obiektów <code>java</code>, <code>sun</code> i <code>netscape</code> zawierają skróty do często używanych w pakietach Javy jak również tworzą obiekty <code>JavaClass</code>. +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Obiekt <code>JavaClass</code> jest referencją do jednej z klas pakietu Javy, jak na przykład <code>netscape.javascript.JSObject</code>. Obiekt <code>JavaPackage</code> jest referencją do pakietu Javy, jak na przykład <code>netscape.javascript</code>. W JavaScript, hierarchia <code>JavaPackage</code> i <code>JavaClass</code> jest odbiciem pakietów Javy i hierarchii klas. +</p><p>Przechodząc obiekt <code>JavaClass</code> do metody, która żąda argument typu <code>java.lang.Class</code>. +</p> +<h3 id="Zgodno.C5.9B.C4.87_wsteczna" name="Zgodno.C5.9B.C4.87_wsteczna"> Zgodność wsteczna </h3> +<h4 id="JavaScript_1.3_i_wersje_wcze.C5.9Bniejsze" name="JavaScript_1.3_i_wersje_wcze.C5.9Bniejsze"> JavaScript 1.3 i wersje wcześniejsze </h4> +<p>Musisz utworzyć opakowanie dla instancji <code>java.lang.Class</code>, zanim przekażesz ją jako parametr dla metody Javy - obiektu <code>JavaClass</code> nie są automatycznie konwertowane do instancji <code>java.lang.Class</code>. +</p> +<h3 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci"> Własności </h3> +<p>Własności obiektu <code>JavaClass</code> są statycznymi polami tej klasy Javy. +</p> +<h3 id="Metody" name="Metody"> Metody </h3> +<p>Metody obiektu <code>JavaClass</code> są statycznymi metodami tej klasy Javy. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_JavaClass" name="Przyk.C5.82ad:_Zastosowanie_JavaClass"> Przykład: Zastosowanie <code>JavaClass</code> </h4> +<p>W poniższym przykładzie, <code>x</code> jest obiektem typu JavaClass odpowiadającym <code>java.awt.Font</code>. Ponieważ <code>BOLD</code> jest statycznym polem klasy Font, jest również własnością obiektu JavaClass. +</p> +<pre class="eval">x = java.awt.Font; +mojFont = x("helv", x.BOLD, 10); // tworzy obiekt Font +</pre> +<p>Powyższy przykład pomija słowo kluczowe <code>Packages</code> i używa synonimu <code>java</code>, ponieważ klasa <code>Font</code> należy do pakietu <code>java</code>. +</p> +<h4 id="Przyk.C5.82ad" name="Przyk.C5.82ad"> Przykład </h4> +<p>W poniższym przykładzie, obiekt typu <code>JavaClass</code>, <code>java.lang.String</code> jest przekazany jako argument do metody <code>newInstance</code>, która tworzy tablicę: +</p> +<pre class="eval">var samochody = java.lang.reflect.Array.newInstance(java.lang.String, 15); +</pre> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaArray">JavaArray</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaObject">JavaObject</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaPackage">JavaPackage</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a></code> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/JavaClass", "es": "es/Referencia_de_JavaScript_1.5/Objetos_globales/JavaClass" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/javaobject/index.html b/files/pl/web/javascript/referencje/obiekty/javaobject/index.html new file mode 100644 index 0000000000..3fe6012fd0 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/javaobject/index.html @@ -0,0 +1,67 @@ +--- +title: JavaObject +slug: Web/JavaScript/Referencje/Obiekty/JavaObject +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/JavaObject +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p><b>Obiekt główny</b> +</p><p>Typ zapakowanego (ang. <i>wrapped</i>) obiektu Javy, do którego dostęp uzyskuje się z wnętrza kodu JavaScriptu. +</p> +<h3 id="Tworzone_przez" name="Tworzone_przez"> Tworzone przez </h3> +<p>Jakąkolwiek metodę Javy, która zwraca typ obiektu. Na dodatek, możesz stworzyć obiekt <code>JavaObject</code> używając konstruktora obiektu w Javie za pomocą słowa kluczowego <code>Packages</code>: +</p> +<pre class="eval">new Packages.<i>KlasaJavy</i>(<i>listaParametrow</i>) +</pre> +<p><i>KlasaJavy</i> jest dokładną nazwą klasy obiektu w Javie. +</p> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>listaParametrow</code></dt><dd> Opcjonalna lista parametrów, określona przez konstruktor klasy Javy. +</dd></dl> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Obiekt <code>JavaObject</code> jest instancją klasy Javy, która jest stworzona wewnątrz kodu JavaScriptu lub jemu przekazana. <code>JavaObject</code> jest opakowaniem (<i>wrapper</i>) instancji; wszystkie referencje do instancji klasy są robione poprzez <code>JavaObject</code>. +</p><p>Jakiekolwiek dane Javy użyte wewnątrz JavaScript-u są konwertowane do typów danych JavaScriptu. Kiedy <code>JavaObject</code> jest przekazany z powrotem do Javy, jest on rozpakowywany i może być użyty przez kod Javy. Zobacz <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5">Przewodnik po języku JavaScript 1.5</a>, aby uzyskać więcej informacji na temat konwersji typów danych. +</p> +<h3 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci"> Własności </h3> +<p>Dziedziczy publicznych członków danych (ang. <i>public data members</i>) klasy Javy, której jest instancją, jako własność. Dziedziczy również publicznych członków danych z jakiejkolwiek superklasy jako własność. +</p> +<h3 id="Metody" name="Metody"> Metody </h3> +<p>Dziedziczy publiczne metody klasy Javy, której jest instancją. <code>JavaObject</code> dziedziczy również metody z <code>java.lang.Object</code> i każdej innej superklasy. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Tworzenie_instancji_JavaObject_w_JavaScripcie" name="Przyk.C5.82ad:_Tworzenie_instancji_JavaObject_w_JavaScripcie"> Przykład: Tworzenie instancji <code>JavaObject</code> w JavaScripcie </h4> +<p>Poniższy kod tworzy obiekt <code>ciagZnakow</code> typu <code>JavaObject</code>, który jest instancją klasy <code>java.lang.String</code>: +</p> +<pre class="eval">var ciagZnakow = new Packages.java.lang.String("Witaj, świecie"); +</pre> +<p>Ponieważ klasa <code>String</code> jest wewnątrz pakietu <code>java</code>, możesz również użyć synonimu <code>java</code> i opuścić słowo kluczowe <code>Packages</code>, kiedy tworzysz instancję klasy: +</p> +<pre class="eval">var ciagZnakow = new java.lang.String("Witaj, świecie"); +</pre> +<h4 id="Przyk.C5.82ad:_Uzyskanie_dost.C4.99pu_do_metod_obiektu_Javy" name="Przyk.C5.82ad:_Uzyskanie_dost.C4.99pu_do_metod_obiektu_Javy"> Przykład: Uzyskanie dostępu do metod obiektu Javy </h4> +<p>Ponieważ obiekt <code>ciagZnakow</code> jest instancją <code>java.labg.String</code>, dziedziczy on wszystkie publiczne metody <code>java.lang.String</code>. Poniższy przykład używa metody <code>startsWith</code> by sprawdzić czy <code>ciagZnakow</code> zaczyna się od <code>"Witaj"</code>. +</p> +<pre class="eval">var ciagZnakow = new java.lang.String("Witaj, świecie"); +ciagZnakow.startsWith("Witaj"); // zwraca true +</pre> +<h4 id="Przyk.C5.82ad:_Uzyskanie_dost.C4.99pu_do_odziedziczonych_metod" name="Przyk.C5.82ad:_Uzyskanie_dost.C4.99pu_do_odziedziczonych_metod"> Przykład: Uzyskanie dostępu do odziedziczonych metod </h4> +<p>Ponieważ, <code>getClass</code> jest metodą <code>Object</code> i <code>java.lang.String</code> rozszerza <code>Object</code>, klasa <code>String</code> dziedziczy metodę <code>getClass</code>. Konsekwentnie, <code>getClass</code> jest również metodą <code>JavaObject</code>, która tworzy instancję <code>String</code> w JavaScripcie. +</p> +<pre class="eval">var ciagZnakow = new java.lang.String("Witaj, świecie"); +ciagZnakow.getClass(); // zwraca java.lang.String +</pre> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaArray">JavaArray</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaClass">JavaClass</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaPackage">JavaPackage</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a></code> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/JavaObject", "es": "es/Referencia_de_JavaScript_1.5/Objetos_globales/JavaObject" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/javapackage/index.html b/files/pl/web/javascript/referencje/obiekty/javapackage/index.html new file mode 100644 index 0000000000..cd356d6547 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/javapackage/index.html @@ -0,0 +1,46 @@ +--- +title: JavaPackage +slug: Web/JavaScript/Referencje/Obiekty/JavaPackage +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/JavaPackage +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p><b>Obiekt główny</b> +</p><p>Odwołanie JavaScriptu do pakietu (ang. <i>package</i>) Javy. +</p> +<h3 id="Tworzony_przez" name="Tworzony_przez"> Tworzony przez </h3> +<p>Odwołanie do nazwy pakietu zastosowane ze słowem kluczowym <code>Package</code>: +</p> +<pre class="eval">Packages.<i>JavaPackage</i> +</pre> +<p><i>JavaPackage</i> jest nazwą pakietu obiektu Javy. Jeśli pakiet znajduje się wewnątrz pakietów <code>java</code>, <code>netscape</code> lub <code>sun</code>, słowo <code>Packages</code> jest opcjonalne. +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>W Javie, pakiet jest kolekcją klas Javy i innych pakietów Javy. Na przykład, pakiet <code>netscape</code> zawiera pakiet <code>netscape.javascript</code>; pakiet <code>netscape.javascript</code> zawiera klasy <code>JSObject</code> i <code>JSException</code>. +</p><p>W JavaScripcie, <code>JavaPackage</code> jest referencją do pakietu Javy. Na przykład, referencja do <code>netscape</code> jest typu <code>JavaPackage</code>. <code>netscape.javascript</code> jest za równo typu <code>JavaPackage</code> jak i własnością obiektu JavaPackage, <code>netscape</code>. +</p><p>Obiekt <code>JavaClass</code> jest referencją do jednej z klas w pakiecie, jak na przykład <code>netscape.javascript.JSObject</code>. Hierarchie <code>JavaPackage</code> i <code>JavaClass</code> odzwierciedlają hierarchie pakietu i klasy Javy. +</p><p>Jakkolwiek pakiety i klasy zawarte w <code>JavaPackage</code> są ich własnościami, nie możesz stosować struktury <code>for...in</code>, aby nadać im numery tak jak możesz zrobić to z innymi obiektami. +</p> +<h3 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci"> Własności </h3> +<p>Własności <code>JavaPackage</code> są obiektami <code>JavaClass</code> i jakimikolwiek innymi obiektami zawartymi w danej <code>JavaPackage</code>. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<p>Przypuśćmy, że korporacja Redwood stosuje pakiet <code>redwood</code> Javy, aby przechowywać różne klasy Javy przez nich zaimplementowane. Poniższy kod tworzy <code>JavaPackage</code> <code>red</code>: +</p> +<pre class="eval">var red = Packages.redwood; +</pre> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaArray">JavaArray</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaClass">JavaClass</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/JavaObject">JavaObject</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a></code> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/JavaPackage", "es": "es/Referencia_de_JavaScript_1.5/Objetos_globales/JavaPackage" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/json/index.html b/files/pl/web/javascript/referencje/obiekty/json/index.html new file mode 100644 index 0000000000..7a4b6c0812 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/json/index.html @@ -0,0 +1,147 @@ +--- +title: JSON +slug: Web/JavaScript/Referencje/Obiekty/JSON +tags: + - JSON + - JavaScript + - Obiekt +translation_of: Web/JavaScript/Reference/Global_Objects/JSON +--- +<div>{{JSRef}}</div> + +<p>Obiekt <strong><code>JSON</code></strong> zawiera metody do analizy składniowej <a class="external" href="https://json.org/">JavaScript Object Notation</a> ({{glossary("JSON")}}) i konwertowania wartości do formatu JSON. Nie może być on wywołany lub utworzony i oprócz jego dwóch metod, sam w sobie nie ma interesującej funkcjonalności .</p> + +<h2 id="Różnice_między_językiem_JavaScript_i_formatem_JSON">Różnice między językiem JavaScript i formatem JSON</h2> + +<p>Format JSON jest składnią do serializowania obiektów, tablic, liczb, napisów, wartości logicznych oraz {{jsxref("null")}}. Bazuje na składni języka JavaScript, ale różni się od niego: <em>nie każdy</em> JavaScript to JSON.</p> + +<p><strong>Obiekty i tablice</strong>: Nazwy właściwości muszą znajdować się w podwójnym cudzysłowie; przecinki na końcach (<a href="https://wiki.developer.mozilla.org/pl/docs/Web/JavaScript/Reference/Trailing_commas">trailing commas</a>) nie są dozwolone.</p> + +<p><strong>Liczby</strong>: Zera nieznaczące są zakazane. Po przecinku musi się znaleźć co najmniej jedna liczba. Wartości NaN i Infinity nie są wspierane.</p> + +<p><strong>Każdy tekst w formacie JSON jest poprawnym wyrażeniem w języku JavaScript</strong> – ale wyłącznie w silnikach JavaScript, które mają zaimplementową możliwości, <a href="https://github.com/tc39/proposal-json-superset">by wszystkie dokumenty w formacie JSON były zgodne ze standardem ECMA-262</a>. W przeciwnym razie, znaki U+2028 (separator linii) i U+2029 (separator akapitów) są dozwolone w literałach znakowych i kluczach w formacie JSON, ale ich użycie w tym konteksie w języku JavaScript skutkuje zgłoszeniem błędu {{jsxref("SyntaxError")}}.</p> + +<p>Rozważmy przykład, gdzie funkcja {{jsxref("JSON.parse()")}} przetwarza poniższy literał znakowy jako obiekt JSON, a funkcja <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval">eval</a></code> wykonuje go jako tekst w języku JavaScript:</p> + +<pre class="brush: js">var code = '"\u2028\u2029"'; +JSON.parse(code); // działa poprawnie +eval(code); // zgłasza błąd SyntaxError +</pre> + +<p>Inne różnice to zgoda wyłącznie na literały znakowe w podwójnym cudzysłowie, brak zabezpieczenia dla {{jsxref("undefined")}} lub komentarzy.</p> + +<h2 id="Pełna_składnia_JSON">Pełna składnia JSON</h2> + +<p>Pełna składnia JSON jest następująca:</p> + +<pre class="syntaxbox"><var>JSON</var> = <strong>null</strong> + <em>or</em> <strong>true</strong> <em>or</em> <strong>false</strong> + <em>or</em> <var>JSONNumber</var> + <em>or</em> <var>JSONString</var> + <em>or</em> <var>JSONObject</var> + <em>or</em> <var>JSONArray</var> + +<var>JSONNumber</var> = <strong>-</strong> <var>PositiveNumber</var> + <em>or</em> <var>PositiveNumber</var> +<var>PositiveNumber</var> = DecimalNumber + <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> + <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> <var>ExponentPart</var> + <em>or</em> <var>DecimalNumber</var> <var>ExponentPart</var> +<var>DecimalNumber</var> = <strong>0</strong> + <em>or</em> <var>OneToNine</var> <var>Digits</var> +<var>ExponentPart</var> = <strong>e</strong> <var>Exponent</var> + <em>or</em> <strong>E</strong> <var>Exponent</var> +<var>Exponent</var> = <var>Digits</var> + <em>or</em> <strong>+</strong> <var>Digits</var> + <em>or</em> <strong>-</strong> <var>Digits</var> +<var>Digits</var> = <var>Digit</var> + <em>or</em> <var>Digits</var> <var>Digit</var> +<var>Digit</var> = <strong>0</strong> through <strong>9</strong> +<var>OneToNine</var> = <strong>1</strong> through <strong>9</strong> + +<var>JSONString</var> = <strong>""</strong> + <em>or</em> <strong>"</strong> <var>StringCharacters</var> <strong>"</strong> +<var>StringCharacters</var> = <var>StringCharacter</var> + <em>or</em> <var>StringCharacters</var> <var>StringCharacter</var> +<var>StringCharacter</var> = any character + <em>except</em> <strong>"</strong> <em>or</em> <strong>\</strong> <em>or</em> U+0000 through U+001F + <em>or</em> <var>EscapeSequence</var> +<var>EscapeSequence</var> = <strong>\"</strong> <em>or</em> <strong>\/</strong> <em>or</em> <strong>\\</strong> <em>or</em> <strong>\b</strong> <em>or</em> <strong>\f</strong> <em>or</em> <strong>\n</strong> <em>or</em> <strong>\r</strong> <em>or</em> <strong>\t</strong> + <em>or</em> <strong>\u</strong> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> +<var>HexDigit</var> = <strong>0</strong> through <strong>9</strong> + <em>or</em> <strong>A</strong> through <strong>F</strong> + <em>or</em> <strong>a</strong> through <strong>f</strong> + +<var>JSONObject</var> = <strong>{</strong> <strong>}</strong> + <em>or</em> <strong>{</strong> <var>Members</var> <strong>}</strong> +<var>Members</var> = <var>JSONString</var> <strong>:</strong> <var>JSON</var> + <em>or</em> <var>Members</var> <strong>,</strong> <var>JSONString</var> <strong>:</strong> <var>JSON</var> + +<var>JSONArray</var> = <strong>[</strong> <strong>]</strong> + <em>or</em> <strong>[</strong> <var>ArrayElements</var> <strong>]</strong> +<var>ArrayElements</var> = <var>JSON</var> + <em>or</em> <var>ArrayElements</var> <strong>,</strong> <var>JSON</var> +</pre> + +<p>Nieznaczące białe znaki nie mogą występować tylko wewnątrz <code><var>JSONNumber</var></code> (liczby nie mogą zawierać białych znaków) oraz <code><var>JSONString</var></code> (gdzie jest to interpretowane jako odpowiedni znak w litarale znakowym lub może spowodować błąd). Tabulacja pozioma (<a href="https://unicode-table.com/pl/#0009">U+0009</a>), powrót karetki (<a href="https://unicode-table.com/pl/#000D">U+000D</a>), nowa linia (<a href="https://unicode-table.com/pl/#000A">U+000A</a>) oraz spacja (<a href="https://unicode-table.com/pl/#0020">U+0020</a>) to jedyne prawidłowe białe znaki.</p> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("JSON.parse()")}}</dt> + <dd>Parsuje literał znakowy na JSON, opcjonalnie przekształca otrzymaną wartosć i ją zwraca. Każde naruszenie składni JSON, wliczając w różnice między językiem JavaScript i JSON, powodują zgłosznie błędu {{jsxref("SyntaxError")}}. Opcja <code>reviver</code> pozwala zinterpretować, co <code>replacer</code> użył zamiast innych typów danych.</dd> + <dt>{{jsxref("JSON.stringify()")}}</dt> + <dd>Zwraca literał znakowy JSON odpowiadający określonej wartosci, ewentualnie zawierający jedynie niektóre wartości lub ze zamienionymi wartościami w sposób zdefinowany przez użytkownika. Domyślnie, wszystkie instance {{jsxref("undefined")}} są zastępowane przez {{jsxref("null")}} i inne niewspierane typy danych są ocenzurowywane. Opcja <code>replacer</code> pozwala określić inne zachowanie.</dd> +</dl> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.12', 'JSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-json-object', 'JSON')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-json-object', 'JSON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.JSON")}}</p> +</div> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Date.prototype.toJSON()")}}</li> +</ul> + +<h2 id="Tools">Tools</h2> + +<ul> + <li><a href="http://jsoncompare.org/">JSON Diff</a> checker.</li> + <li><a href="http://jsonbeautifier.org/">JSON Beautifier/editor</a>.</li> + <li><a href="http://jsonparser.org/">JSON Parser</a></li> + <li><a href="https://tools.learningcontainer.com/json-validator/">JSON Validator</a>.</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/clear/index.html b/files/pl/web/javascript/referencje/obiekty/map/clear/index.html new file mode 100644 index 0000000000..a4e7374127 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/clear/index.html @@ -0,0 +1,87 @@ +--- +title: Map.prototype.clear() +slug: Web/JavaScript/Referencje/Obiekty/Map/clear +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/clear +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>clear()</strong></code> usuwa wszystkie elementy z obiektu <code>Map</code>.</p> + +<pre class="brush: js">var map1 = new Map(); + +map1.set('bar', 'baz'); +map1.set(1, 'foo'); + +console.log(map1.size); +// wartość zwracana: 2 + +map1.clear(); + +console.log(map1.size); +// wartość zwracana: 0 +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.clear();</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_metody_clear">Używanie metody <code>clear</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'baz'); +myMap.set(1, 'foo'); + +myMap.size; // 2 +myMap.has('bar'); // true + +myMap.clear(); + +myMap.size; // 0 +myMap.has('bar') // false +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.clear")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/delete/index.html b/files/pl/web/javascript/referencje/obiekty/map/delete/index.html new file mode 100644 index 0000000000..2016e577f8 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/delete/index.html @@ -0,0 +1,85 @@ +--- +title: Map.prototype.delete() +slug: Web/JavaScript/Referencje/Obiekty/Map/delete +tags: + - Mapa + - Metodă +translation_of: Web/JavaScript/Reference/Global_Objects/Map/delete +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>delete()</strong></code> usuwa określony element z obiektu <code>Map</code>.</p> + +<pre class="brush: js">var map1 = new Map(); +map1.set('bar', 'foo'); + +console.log(map1.delete('bar')); +// oczekiwany wynik: true +// (true wskazuje na poprawne usunięcie) + +console.log(map1.has('bar')); +// oczekiwany wynik: false +</pre> + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js">myMap.delete(key);</pre> + +<h3 id="Parametery">Parametery</h3> + +<dl> + <dt>key</dt> + <dd>Wymagany. Klucz elementu, który ma zostać usunięty z obiektu <code>Map</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<dl> + <dt>Boolean</dt> + <dd>Zwraca <code>true</code>, jeśli element w <code>Map</code> istniał i został usunięty lub <code>false</code>, jeśli nie.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_metody_delete">Używanie metody <code>delete</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'foo'); + +myMap.delete('bar'); // Zwraca true. Udało się usunąć. +myMap.has('bar'); // Zwraca false. Element "bar" już nie istnieje. +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.delete")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/entries/index.html b/files/pl/web/javascript/referencje/obiekty/map/entries/index.html new file mode 100644 index 0000000000..97c049b150 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/entries/index.html @@ -0,0 +1,128 @@ +--- +title: Map.prototype.entries() +slug: Web/JavaScript/Referencje/Obiekty/Map/entries +tags: + - ECMAScript2015 + - Iterator + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/entries +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>entries()</strong></code> zwraca nowy obiekt typu <a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a> który zawiera pary<code>[klucz, wartość]</code> dla każdego elementu <code>Mapy</code>. Można się do nich odnieść w takiej kolejności, jakiej zostały wstawione.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-entries.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.entries()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator obiektu typu {{jsxref("Map")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_entries()">Używanie <code>entries()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +var mapIter = myMap.entries(); + +console.log(mapIter.next().value); // ["0", "foo"] +console.log(mapIter.next().value); // [1, "bar"] +console.log(mapIter.next().value); // [Object, "baz"] +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoDesktop("20") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("20")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map.prototype.keys()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/foreach/index.html b/files/pl/web/javascript/referencje/obiekty/map/foreach/index.html new file mode 100644 index 0000000000..7280020397 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/foreach/index.html @@ -0,0 +1,104 @@ +--- +title: Map.prototype.forEach() +slug: Web/JavaScript/Referencje/Obiekty/Map/forEach +tags: + - ECMAScript2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/forEach +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>forEach()</strong></code> wykonuje dostarczoną funcję <code>callback</code> raz dla każdej pary klucz-wartosć <code>Mapy</code> w kolejności, w jakiej zostały zostały wstawione.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-foreach.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.forEach(<em>callback</em>[, <em>thisArg</em>])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funkcja wykonywana dla każdego elementu.</dd> + <dt><code>thisArg</code></dt> + <dd>Wartość przypisywana do <code>this</code> poczas wywołania zwrotnego (funkcja <code>callback</code>).</dd> +</dl> + +<h3 id="Zwracana_wartosć">Zwracana wartosć</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda <code>forEach</code> wykonuje dostarczoną funkcję <code>callback</code> raz dla każdego klucza mapy, który istnieje. Nie jest wywoływana dla usuniętych kluczy, ale dla istniejących z wartością <code>undefined</code> już tak.</p> + +<p>Funkcja <code>callback</code> przyjmuje <strong>trzy argumenty</strong>:</p> + +<ul> + <li><strong>wartość elementu</strong></li> + <li><strong>klucz elementu</strong></li> + <li>obiekt typu <strong><code>Map</code> do przetworzenia</strong></li> +</ul> + +<p>Jeśli argument <code>thisArg</code> jest dostarczony do <code>forEach</code>, zostaje przekazany do fukncji <code>callback</code> podczas jej wywołania, jako jej własna wartość <code>this</code>. W przeciwnym wypadku, <code>this</code> przyjmuje wartość <code>undefined</code>. </p> + +<p>Każda wartość jest odwiedzana raz, oprócz przypadku, gdzie została usunięta, a następnie dodana ponownie, nim metoda <code>forEach</code> zakończyła swoje działanie. Funkcja <code>callback</code> nie jest wywoływana dla wartości usuniętych przed ich odwiedzeniem. Nowe wartości dodane jeszcze przed zakończeniem <code>forEach</code> zostaną odwiedzone.</p> + +<p>Metoda <code>forEach</code> nie zwraca żadnej wartości.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Wyświetlanie_zawartości_Mapy">Wyświetlanie zawartości <code>Mapy</code></h3> + +<p>Poniższy kod wyświetla jedną linię dla każdej pary klucz-wartość <code>Mapy</code>:</p> + +<pre class="brush:js">function logMapElements(value, key, map) { + console.log(`m[${key}] = ${value}`); +} +new Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(logMapElements); +// logs: +// "m[foo] = 3" +// "m[bar] = [object Object]" +// "m[baz] = undefined" +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.forEach")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Set.prototype.forEach()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/get/index.html b/files/pl/web/javascript/referencje/obiekty/map/get/index.html new file mode 100644 index 0000000000..a8cb900ed7 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/get/index.html @@ -0,0 +1,80 @@ +--- +title: Map.prototype.get() +slug: Web/JavaScript/Referencje/Obiekty/Map/get +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/get +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>get()</strong></code> zwraca podany element <code>Mapy</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-get.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.get(key);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>key</dt> + <dd>Wymagany. Klucz elementu, który ma zostać zwrócony.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Element powiązany z danym kluczym lub <code>undefined</code>, jeśli klucz nie został odnaleziony.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_metody_get">Używanie metody <code>get</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'foo'); + +myMap.get('bar'); // zwraca "foo". +myMap.get('baz'); // zwraca undefined. +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.get")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/has/index.html b/files/pl/web/javascript/referencje/obiekty/map/has/index.html new file mode 100644 index 0000000000..14bf4f71dc --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/has/index.html @@ -0,0 +1,85 @@ +--- +title: Map.prototype.has() +slug: Web/JavaScript/Referencje/Obiekty/Map/has +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/has +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>has()</strong></code> zwraca <a href="/pl/docs/Web/JavaScript/Referencje/Obiekty/Boolean">Boolean</a>, który określa czy element o podanym kluczu istnieje.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-has.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.has(key);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>key</dt> + <dd>Wymagany. Klucz elementu, którego istnienie w <code>Mapie</code> zostanie sprawdzone.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<dl> + <dt>Boolean</dt> + <dd> + <p><code>true</code>, jeśli dany element istnieje w <code>Mapie</code> - w przeciwnym wypadku <code>false</code>.</p> + </dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_metody_has">Używanie metody <code>has</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', "foo"); + +myMap.has('bar'); // zwraca true +myMap.has('baz'); // zwraca false +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.has', 'Map.prototype.has')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.has', 'Map.prototype.has')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.has")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/index.html b/files/pl/web/javascript/referencje/obiekty/map/index.html new file mode 100644 index 0000000000..8c0a9833eb --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/index.html @@ -0,0 +1,458 @@ +--- +title: Map +slug: Web/JavaScript/Referencje/Obiekty/Map +tags: + - ECMAScript 2015 + - JavaScript + - Map +translation_of: Web/JavaScript/Reference/Global_Objects/Map +--- +<div>{{JSRef}}</div> + +<p><strong>Map </strong>jest prostym obiektem mapującym klucze na wartości. Każdy element (zarówno obiekt jak i {{Glossary("Primitive", "wartości proste")}}) mogą być użyte zarówno jako klucz jak i wartość.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">new Map([iterable])</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>iterable</code></dt> + <dd>Iterable jest tablicą lub innym iterowalnym obiektem, którego elementy są parami typu klucz-wartość (np. 2 elementowa tablica). Każda para klucz-wartość jest dodawana do obiektu new Map. <code>null</code> jest traktowane jako <code>undefined.</code></dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt Map iteruje swoje elementy we wprowadzonej kolejności — pętla {{jsxref("Statements/for...of", "for...of")}} zwraca tablicę <code>[key, value] </code>dla każdej iteracji.</p> + +<p>Należy pamiętać, że kolejność iteracji dla <code>Map</code> mapującej obiekty, w szczególności np. dla słownika słowników, odzwieciedlać będzie jedynie kolejność dodawania obiektów do kolekcji, natomiast kolejność dodawania elementów do samych obiektów nie jest gwarantowana i powinna być traktowana jako losowa.</p> + +<h3 id="Równość_kluczy">Równość kluczy</h3> + +<p>Klucze porównywane są według algorytmu "same-value" (tej samej wartości).</p> + +<p><code>NaN</code> jest traktowana jako równa <code>NaN</code> (mimo tego, że <code>NaN !== NaN</code>). Wszystkie inne wartości są uważane za równe zgodnie z semantyką <code>===</code> operatora równości.</p> + +<p>W obecnej specyfikacji ECMAScript <code>-0 === +0</code>, choć wcześniejsze propozycje zakładały inne zachowanie, co zaowocowało implementacją w niektórych wersjach przeglądarek. Szczegóły zawarte są w "Value equality for -0 and 0" w tabeli <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Map$edit#Browser_compatibility">kompatybilności przeglądarek</a>.</p> + +<h3 id="Porównanie_Obiektów_i_Map">Porównanie Obiektów i Map</h3> + +<p>{{jsxref("Object", "Obiekty")}} są podobne do Map. W obu przypadkach pozwalają ustawić klucze dla wartości, zwracają te wartości, usuwają klucze i wykrywają czy coś jest przechowywane jako klucz. Z tego powodu (i ponieważ nie było innych wbudowanych alternatyw), <code>Object</code> był używany wcześniej jako <code>Map</code>. Istnieją jednak ważne różnice pomiędzy <code>Obiektami</code> i <code>Mapami</code>, które powodują, że <code>Map</code> jest lepszym wyborem w pewnych przypadkach:</p> + +<ul> + <li>Klucze obiektu są {{jsxref("String", "Stringami")}}' i {{jsxref("Symbol", "Symbolami")}}, podczas gdy dla <code>Map</code> mogą być dowolną wartością, włączając w to funkcje, obiekty czy wartości proste.</li> + <li>Można łatwo pobrać wielkość mapy używając właściwości <code>size</code>, podczas gdy wielkość obiektu musi być określana ręcznie.</li> + <li>Po mapie można iterować bezpośrednio, iteracja po obiekcie wymaga pobrania jego kluczy i iteracji po ich liście.</li> + <li>Obiekt posiada prototyp, istnieją więc domyślne klucze, które mogą kolidować z Twoimi kluczami, jeśli nie jesteś ostrożny. Można ominąć ten problem używając <code>Object.create(null)</code> (dostępne od ES5), ale było to rzadko stosowane rozwiązanie.</li> + <li>Mapa może osiągnąć lepszą wydajność w scenariuszu, w którym często dodajemy i usuwamy pary klucz-wartość.</li> +</ul> + +<p>Nie oznacza to, że powinno się używać <code>Maps</code> wszędzie. Obiekty są wciąż używane w większości przypadków. Instancje <code>Map</code> są użyteczne dla kolekcji, warto rozważyć ich zaadaptowanie jedynie w przypadkach, gdy wcześniej używano dla nich obiektów. Obiekty powinny być używane jako rejestr z polami i metodami. Jeśli wciąż nie jesteś pewien czego użyć, pomocne mogą okazać się poniższe pytania:</p> + +<ul> + <li>Czy klucze są nieznane do momentu uruchomienia programu? Czy potrzebujesz wyszukiwać lub tworzyć je dynamicznie?</li> + <li>Czy wszystkie wartości mają ten sam typ? Czy mogą być użyte wymiennie?</li> + <li>Czy potrzebujesz kluczy, które nie są typu string?</li> + <li>Czy pary klucz-wartość są często dodawane lub usuwane?</li> + <li>Czy kolekcja powinna być iterowalna?</li> +</ul> + +<p>Jeśli odpowiedziałeś 'tak' na którekolwiek z tych pytań, prawdopodobnie powinieneś użyć <code>Map</code>. I przeciwnie, jeśli masz zamknięty zbiór kluczy, jeśli musisz odwoływać się do poszczególnych, specyficznych kluczy a każdy z nich ma swoje, odrębne od innych znaczenie, najprawdopodobniej potrzebujesz obiektu.</p> + +<h2 id="Własności">Własności</h2> + +<dl> + <dt><code>Map.length</code></dt> + <dd>Wartość <code>length</code> jest zawsze równa 0.</dd> + <dt>{{jsxref("Map.@@species", "get Map[@@species]")}}</dt> + <dd>Funkcja konstruktora używana do tworzenia obiektów pochodnych.</dd> + <dt>{{jsxref("Map.prototype")}}</dt> + <dd>Reprezentuje prototyp funkcji konstruktora <code>Map</code>. Pozwala rozszerzać prototyp wszystkich obiektów <code>Map</code> o własne własności.</dd> +</dl> + +<h2 id="Instancje_Map">Instancje <code>Map</code></h2> + +<p>Wszystkie instancje <code>Map</code> dziedziczą po {{jsxref("Map.prototype")}}.</p> + +<h3 id="Własności_2">Własności</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Map/prototype','Properties')}}</p> + +<h3 id="Metody">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Map/prototype','Methods')}}</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_obiektu_typu_Map">Używanie obiektu typu <code>Map</code></h3> + +<pre class="brush: js notranslate">var myMap = new Map(); + +var keyString = 'a string', + keyObj = {}, + keyFunc = function() {}; + +// setting the values +myMap.set(keyString, "value associated with 'a string'"); +myMap.set(keyObj, 'value associated with keyObj'); +myMap.set(keyFunc, 'value associated with keyFunc'); + +myMap.size; // 3 + +// getting the values +myMap.get(keyString); // "value associated with 'a string'" +myMap.get(keyObj); // "value associated with keyObj" +myMap.get(keyFunc); // "value associated with keyFunc" + +myMap.get('a string'); // "value associated with 'a string'" + // because keyString === 'a string' +myMap.get({}); // undefined, because keyObj !== {} +myMap.get(function() {}) // undefined, because keyFunc !== function () {} +</pre> + +<h3 id="Użycie_NaN_jako_kluczy_w_Map">Użycie <code>NaN</code> jako kluczy w <code>Map</code></h3> + +<p><code>NaN</code> can also be used as a key. Even though every <code>NaN</code> is not equal to itself (<code>NaN !== NaN</code> is true), the following example works, because <code>NaN</code>s are indistinguishable from each other:</p> + +<pre class="brush: js notranslate">var myMap = new Map(); +myMap.set(NaN, 'not a number'); + +myMap.get(NaN); // "not a number" + +var otherNaN = Number('foo'); +myMap.get(otherNaN); // "not a number" +</pre> + +<h3 id="Iteracja_po_Map_przy_użyciu_for..of">Iteracja po <code>Map</code> przy użyciu <code>for..of</code></h3> + +<pre class="brush: js notranslate">var myMap = new Map(); +myMap.set(0, 'zero'); +myMap.set(1, 'one'); +for (var [key, value] of myMap) { + console.log(key + ' = ' + value); +} +// 0 = zero +// 1 = one + +for (var key of myMap.keys()) { + console.log(key); +} +// 0 +// 1 + +for (var value of myMap.values()) { + console.log(value); +} +// zero +// one + +for (var [key, value] of myMap.entries()) { + console.log(key + ' = ' + value); +} +// 0 = zero +// 1 = one +</pre> + +<h3 id="Iteracja_po_Map_przy_użyciu_forEach">Iteracja po <code>Map</code> przy użyciu <code>forEach()</code></h3> + +<pre class="brush: js notranslate">myMap.forEach(function(value, key) { + console.log(key + ' = ' + value); +}); +// Will show 2 logs; first with "0 = zero" and second with "1 = one" +</pre> + +<h3 id="Relacja_do_obiektów_typu_Array">Relacja do obiektów typu <code>Array</code></h3> + +<pre class="brush: js notranslate">var kvArray = [['key1', 'value1'], ['key2', 'value2']]; + +// Use the regular Map constructor to transform a 2D key-value Array into a map +var myMap = new Map(kvArray); + +myMap.get('key1'); // returns "value1" + +// Use the spread operator to transform a map into a 2D key-value Array. +console.log(uneval([...myMap])); // Will show you exactly the same Array as kvArray + +// Or use the spread operator on the keys or values iterator to get +// an array of only the keys or values +console.log(uneval([...myMap.keys()])); // Will show ["key1", "key2"] +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map-objects', 'Map')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map-objects', 'Map')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td> + <p>{{ CompatChrome(38) }} [1]</p> + </td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Constructor argument: <code>new Map(iterable)</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatSafari("9")}}</td> + </tr> + <tr> + <td>iterable</td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("17") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Map.clear()</code></td> + <td>{{ CompatChrome(31) }}<br> + {{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("19")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Map.keys(), Map.values(), Map.entries()</code></td> + <td>{{ CompatChrome(37) }}<br> + {{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("20")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Map.forEach()</code></td> + <td>{{ CompatChrome(36) }}<br> + {{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Key equality for -0 and 0</td> + <td>{{ CompatChrome(34) }}<br> + {{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatSafari("9")}}</td> + </tr> + <tr> + <td>Constructor argument: <code>new Map(null)</code></td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>11</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + <tr> + <td>Monkey-patched <code>set()</code> in Constructor</td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + <tr> + <td><code>Map[@@species]</code></td> + <td>{{CompatChrome("51")}}</td> + <td>13</td> + <td>{{CompatGeckoDesktop("41")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("38")}}</td> + <td>{{CompatSafari("10")}}</td> + </tr> + <tr> + <td><code>Map()</code> without <code>new</code> throws</td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("42") }}</td> + <td>11</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }} [1]</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Constructor argument: <code>new Map(iterable)</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td>iterable</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile("17") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Map.clear()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(31) }}<br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("19")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Map.keys(), Map.values(), Map.entries()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(37) }}<br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("20")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Map.forEach()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(36) }}<br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Key equality for -0 and 0</td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(34) }}<br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Constructor argument: <code>new Map(null)</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td>Monkey-patched <code>set()</code> in Constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td><code>Map[@@species]</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("41")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>10</td> + </tr> + <tr> + <td><code>Map()</code> without <code>new</code> throws</td> + <td>5.1</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("42")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Starting with Chrome 31, the feature was available behind a preference. In <code>chrome://flags</code>, activate the entry “Enable Experimental JavaScript”.</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697479">Map and Set bug at Mozilla</a></li> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets">ECMAScript Harmony proposal</a></li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/keys/index.html b/files/pl/web/javascript/referencje/obiekty/map/keys/index.html new file mode 100644 index 0000000000..8723e295ab --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/keys/index.html @@ -0,0 +1,78 @@ +--- +title: Map.prototype.keys() +slug: Web/JavaScript/Referencje/Obiekty/Map/keys +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/keys +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>keys()</strong></code> zwraca nowy obiekt typu <strong><a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong>, który zawiera klucze dla każdego elementu w <code>Mapie</code>. Można się do nich odnieść w takiej kolejności, jakiej zostały wstawione.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-keys.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.keys()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator obiektu typu {{jsxref("Map")}}</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_keys()">Używanie <code>keys()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +var mapIter = myMap.keys(); + +console.log(mapIter.next().value); // "0" +console.log(mapIter.next().value); // 1 +console.log(mapIter.next().value); // Object +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.keys")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/set/index.html b/files/pl/web/javascript/referencje/obiekty/map/set/index.html new file mode 100644 index 0000000000..951cefd229 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/set/index.html @@ -0,0 +1,96 @@ +--- +title: Map.prototype.set() +slug: Web/JavaScript/Referencje/Obiekty/Map/set +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/set +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>set()</strong></code> dodaje lub zmienia element o podany <code>kluczu</code> i <code>wartości</code> w <code>Mapie</code>. </p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-set.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.set(key, value);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>key</dt> + <dd>Wymagany. Klucz elementu, który zostanie dodany do <code>Mapy</code>.</dd> + <dt>value</dt> + <dd>Wymagany. Wartość elementu, który zostanie dodany do <code>Mapy</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p> Obiekt typu <code>Map</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_set()">Używanie <code>set()</code></h3> + +<pre class="brush: js">var myMap = new Map(); + +// Dodawanie nowych elementu +myMap.set('bar', 'foo'); +myMap.set(1, 'foobar'); + +// Zmiana istniejącego już elementu +myMap.set('bar', 'baz'); +</pre> + +<h3 id="Używanie_set_w_połączeniu_z_łańcuchowaniem">Używanie <code>set</code> w połączeniu z łańcuchowaniem</h3> + +<p>Ponieważ <code>set()</code> zwraca ten sam obiekt typu <code>Mapa</code>, można użyć chainingu (uruchamianie metod jedna po drugiej na danym obiekcie przy użyciu kropek).</p> + +<pre class="brush: js">// Dodawanie elementów do mapy za pomocą chainingu +myMap.set('bar', 'foo') + .set(1, 'foobar') + .set(2, 'baz'); + +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.set', 'Map.prototype.set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.set', 'Map.prototype.set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.set")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/size/index.html b/files/pl/web/javascript/referencje/obiekty/map/size/index.html new file mode 100644 index 0000000000..0ec1025e46 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/size/index.html @@ -0,0 +1,65 @@ +--- +title: Map.prototype.size +slug: Web/JavaScript/Referencje/Obiekty/Map/size +tags: + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Map/size +--- +<div>{{JSRef}}</div> + +<p>Atrybut <code><strong>size</strong></code> zwraca ilość elementów znajdujących się w obiekcie {{jsxref("Map")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-size.html")}}</div> + +<p class="hidden">Żródło dla tego przykładu interaktywnego jest przechowywane w repozytorium w serwisie GitHub. Jeśli chciałbyś pomoć przy projekcie przykładów, prosimy o sklonowanie repozytorium <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wysłanie pull request.</p> + +<h2 id="Opis">Opis</h2> + +<p>Wartość <code>size</code> to liczba reprezentująca ile elementów posiada obiekt <code>Map</code>. Funkcja set dla <code>size</code> to <code>undefined</code>; nie można edytować tego atrybutu.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_size">Użycie <code>size</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('a', 'alpha'); +myMap.set('b', 'beta'); +myMap.set('g', 'gamma'); + +myMap.size // 3 +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<div class="hidden">Tabela kompatybilności na tej stronie jest generowana z danych zewnętrznych. Jeśli chciałbyś pomóc przy tych danych, polecamy zajrzeć na <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> i wysłać pull request.</div> + +<p>{{Compat("javascript.builtins.Map.size")}}</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/map/values/index.html b/files/pl/web/javascript/referencje/obiekty/map/values/index.html new file mode 100644 index 0000000000..50a7d72d0f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/map/values/index.html @@ -0,0 +1,77 @@ +--- +title: Map.prototype.values() +slug: Web/JavaScript/Referencje/Obiekty/Map/values +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Mapa + - Metodă + - Prototyp +translation_of: Web/JavaScript/Reference/Global_Objects/Map/values +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>values()</strong></code> zwraca nowy obiekt typu <strong><a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong>, który zawiera wartości dla każdego elementu w <code>Mapie</code>. Można się do nich odnieść w takiej kolejności, jakiej zostały wstawione.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-values.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.values()</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy iterator obiektu typu {{jsxref("Map")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_values()">Używanie <code>values()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +var mapIter = myMap.values(); + +console.log(mapIter.next().value); // "foo" +console.log(mapIter.next().value); // "bar" +console.log(mapIter.next().value); // "baz"</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.values', 'Map.prototype.values')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.values', 'Map.prototype.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.builtins.Map.values")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.keys()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/abs/index.html b/files/pl/web/javascript/referencje/obiekty/math/abs/index.html new file mode 100644 index 0000000000..c3b333a4ce --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/abs/index.html @@ -0,0 +1,54 @@ +--- +title: Math.abs() +slug: Web/JavaScript/Referencje/Obiekty/Math/abs +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość bezwzględną danej liczby.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>></mo><mn>0</mn></mtd></mtr><mtr><mtd><mi>0</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>=</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo><</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{if} \quad x \geq 0 \\ -x & \text{if} \quad x < 0 \end{cases} </annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.abs(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>abs</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.abs()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.abs" name="Przyk.C5.82ad:_Zastosowanie_Math.abs">Przykład: Zastosowanie <code>Math.abs()</code></h3> + +<p>Poniższa funkcja zwraca wartość bezwzględną zmiennej <code>x</code>:</p> + +<pre class="brush: js">Math.abs('-1'); // 1 +Math.abs(-2); // 2 +Math.abs(null); // 0 +Math.abs('string'); // NaN +Math.abs(); // NaN +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/acos/index.html b/files/pl/web/javascript/referencje/obiekty/math/acos/index.html new file mode 100644 index 0000000000..afb1485ada --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/acos/index.html @@ -0,0 +1,59 @@ +--- +title: Math.acos() +slug: Web/JavaScript/Referencje/Obiekty/Math/acos +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca arcus cosinus (w radianach) danej liczby.</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.acos(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>acos</code> zwraca wartość numeryczną od 0 do pi dla <code>x</code> pomiędzy -1 a 1. Jeśli liczba <code>x</code> jest spoza przedziału [-1, 1], zwracany jest {{jsxref("NaN")}}.</p> + +<p>Ponieważ <code>acos</code> jest statyczną metodą obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.acos()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.acos" name="Przyk.C5.82ad:_Zastosowanie_Math.acos">Przykład: Zastosowanie <code>Math.acos()</code></h3> + +<p>Poniższa funkcja zwraca arcus cosinus zmiennej <code>x</code>:</p> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 3.141592653589793 +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1.5707963267948966 +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">0.5</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.0471975511965979 +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN</span></code></pre> + +<p>Jeśli do <code>getAcos</code> przekazana zostanie wartość -1, funkcja zwróci 3.141592653589793; jeśli przekazana zostanie wartość 2, zwrócony zostanie <code>NaN</code>, ponieważ 2 jest poza zakresem (tj. dziedziną funkcji arcus cosinus).</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/asin/index.html b/files/pl/web/javascript/referencje/obiekty/math/asin/index.html new file mode 100644 index 0000000000..e473586a49 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/asin/index.html @@ -0,0 +1,58 @@ +--- +title: Math.asin() +slug: Web/JavaScript/Referencje/Obiekty/Math/asin +tags: + - JavaScript + - Math +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin +--- +<p>{{jsref}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca arcus sinus (w radianach) danej liczby.</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.asin(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>Math.asin()</code> zwraca wartość liczbową pomiędzy <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> i <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianów dla <code>x</code> z przedziału [-1, 1]. Jeśli <code>x</code> jest poza tym zakresem, zwracany jest <code>NaN</code>.</p> + +<p>Ponieważ <code>asin</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.asin()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.asin" name="Przyk.C5.82ad:_Zastosowanie_Math.asin">Przykład: Zastosowanie <code>Math.asin()</code></h3> + +<p>Poniższa funkcja zwraca arcus sinus zmiennej <code>x</code>:</p> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -1.5707963267948966 (-pi/2) +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">0.5</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.5235987755982989 +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1.570796326794897 (pi/2) +</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN</span></code></pre> + +<p>Jeśli do funkcji <code>getAsin</code> przekazana zostanie wartość 1, funkcja ta zwróci 1.570796326794897 (pi/2); jeśli przekazana zostanie wartość 2, funkcja zwróci {{jsxref("<code>NaN</code>")}}, ponieważ 2 jest poza dziedziną funkcji arcus sinus.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/atan/index.html b/files/pl/web/javascript/referencje/obiekty/math/atan/index.html new file mode 100644 index 0000000000..4e452e1f13 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/atan/index.html @@ -0,0 +1,51 @@ +--- +title: Math.atan() +slug: Web/JavaScript/Referencje/Obiekty/Math/atan +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca arcus tangens (w radianach) danej liczby.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.atan(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>atan</code> zwraca wartość liczbową pomiędzy <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> i <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianów.</p> + +<p>Ponieważ <code>atan</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.atan()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.atan" name="Przyk.C5.82ad:_Zastosowanie_Math.atan">Przykład: Zastosowanie <code>Math.atan()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">atan<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0.7853981633974483 +</span>Math<span class="token punctuation">.</span><span class="token function">atan<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/atan2/index.html b/files/pl/web/javascript/referencje/obiekty/math/atan2/index.html new file mode 100644 index 0000000000..81f4606036 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/atan2/index.html @@ -0,0 +1,63 @@ +--- +title: Math.atan2() +slug: Web/JavaScript/Referencje/Obiekty/Math/atan2 +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca kąta (w radianach) utworzony przez oś OX i prostą przechodzącą przez punkt o podanych współrzędnych.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.atan2(<var>y</var>, <var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>y, x</code> </dt> + <dd>liczby.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>atan2</code> zwraca wartość liczbową pomiędzy -π a π, reprezentującą kąt theta punktu <code>(x, y)</code>. Kąt ten, mierzony w radianach, został utworzony przez dodatnią oś OX i punkt <code>(x,y)</code>, z obrotem w kierunku przeciwnym do ruchu wskazówek zegara. Należy zwrócić uwagę na to, że pierwszym argumentem tej funkcji jest współrzędna y, a x jest argumentem drugim.</p> + +<p>Do metody Math.<code>atan2</code>() przekazywane są osobno argumenty <code>x</code> i <code>y</code>, podczas gdy do metody <code>atan</code> przekazywany jest stosunek tych dwóch wartości.</p> + +<p>Ponieważ <code>atan2()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.atan2()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.atan2" name="Przyk.C5.82ad:_Zastosowanie_Math.atan2">Przykład: Zastosowanie <code>Math.atan2()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span><span class="token number">90</span><span class="token punctuation">,</span> <span class="token number">15</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.4056476493802699 +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span><span class="token number">15</span><span class="token punctuation">,</span> <span class="token number">90</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.16514867741462683 +</span> +Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±PI. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> <span class="token operator">+</span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> <span class="token operator">-</span>x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±PI for x > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±0 for x > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span><span class="token operator">-</span>y<span class="token punctuation">,</span> ±<span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -PI/2 for y > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>y<span class="token punctuation">,</span> ±<span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // PI/2 for y > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±y<span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±PI for finite y > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±y<span class="token punctuation">,</span> <span class="token operator">+</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±0 for finite y > 0. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">Infinity</span><span class="token punctuation">,</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // ±PI/2 for finite x. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">Infinity</span><span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // ±3*PI/4. +</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">Infinity</span><span class="token punctuation">,</span> <span class="token operator">+</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // ±PI/4.</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/ceil/index.html b/files/pl/web/javascript/referencje/obiekty/math/ceil/index.html new file mode 100644 index 0000000000..8e48d70931 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/ceil/index.html @@ -0,0 +1,49 @@ +--- +title: Math.ceil() +slug: Web/JavaScript/Referencje/Obiekty/Math/ceil +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca najmniejszą liczbę całkowitą większą od lub równą danej.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.ceil(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>ceil</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.ceil()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_Math.ceil" name="Przyk.C5.82ad:_Zastosowanie_Math.ceil">Przykład: Zastosowanie <code>Math.ceil()</code></h4> + +<p>Poniższa funkcja zwraca wartość metody ceil dla zmiennej <code>x</code>:</p> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">ceil<span class="token punctuation">(</span></span><span class="token punctuation">.</span><span class="token number">95</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1 +</span>Math<span class="token punctuation">.</span><span class="token function">ceil<span class="token punctuation">(</span></span><span class="token number">4</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 4 +</span>Math<span class="token punctuation">.</span><span class="token function">ceil<span class="token punctuation">(</span></span><span class="token number">7.004</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 8</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/cos/index.html b/files/pl/web/javascript/referencje/obiekty/math/cos/index.html new file mode 100644 index 0000000000..6634e7d96e --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/cos/index.html @@ -0,0 +1,52 @@ +--- +title: Math.cos() +slug: Web/JavaScript/Referencje/Obiekty/Math/cos +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca cosinus danej liczby.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code>Math.cos(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>cos</code> zwraca wartość liczbową pomiędzy -1 a 1, która reprezentuje cosinus kąta.</p> + +<p>Ponieważ <code>cos()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.cos()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.cos" name="Przyk.C5.82ad:_Zastosowanie_Math.cos">Przykład: Zastosowanie <code>Math.cos()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1 +</span>Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0.5403023058681398 +</span> +Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span>Math<span class="token punctuation">.</span>PI<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -1 +</span>Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span><span class="token number">2</span> <span class="token operator">*</span> Math<span class="token punctuation">.</span>PI<span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/e/index.html b/files/pl/web/javascript/referencje/obiekty/math/e/index.html new file mode 100644 index 0000000000..76659e8c1d --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/e/index.html @@ -0,0 +1,40 @@ +--- +title: Math.E +slug: Web/JavaScript/Referencje/Obiekty/Math/E +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/E +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Stała Eulera stanowiąca podstawę logarytmów naturalnych, w przybliżeniu 2.718.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2.718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2.718</annotation></semantics></math></p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>E</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.E</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_E" name="Przyk.C5.82ad:_Zastosowanie_E">Przykład: Zastosowanie <code>Math.E</code></h3> + +<p>Poniższa funkcja zwraca e:</p> + +<pre class="brush: js language-js">function getNapier() { + return Math.E; +} + +<code class="language-js"><span class="token function">getNapier<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 2.718281828459045</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/exp/index.html b/files/pl/web/javascript/referencje/obiekty/math/exp/index.html new file mode 100644 index 0000000000..f7bc13ecbb --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/exp/index.html @@ -0,0 +1,49 @@ +--- +title: Math.exp() +slug: Web/JavaScript/Referencje/Obiekty/Math/exp +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca e<sup>x</sup>, gdzie <code>x</code> to argument, a e to {{jsxref("Math.E", "stała Eulera", "", 1)}}, podstawa logarytmu naturalnego.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.exp(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>exp</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.exp()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.exp" name="Przyk.C5.82ad:_Zastosowanie_Math.exp">Przykład: Zastosowanie <code>Math.exp()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">exp<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.36787944117144233 +</span>Math<span class="token punctuation">.</span><span class="token function">exp<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1 +</span>Math<span class="token punctuation">.</span><span class="token function">exp<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 2.718281828459045</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.E")}}</li> + <li>{{jsxref("Math.expm1()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/floor/index.html b/files/pl/web/javascript/referencje/obiekty/math/floor/index.html new file mode 100644 index 0000000000..3fea41b72f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/floor/index.html @@ -0,0 +1,46 @@ +--- +title: Math.floor() +slug: Web/JavaScript/Referencje/Obiekty/Math/floor +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca największą liczbę całkowitą mniejszą od lub równą danej.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.floor(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>floor</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.floor()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.floor" name="Przyk.C5.82ad:_Zastosowanie_Math.floor">Przykład: Zastosowanie <code>Math.floor()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">floor<span class="token punctuation">(</span></span> <span class="token number">45.95</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 45 +</span>Math<span class="token punctuation">.</span><span class="token function">floor<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">45.95</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // -46</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/index.html b/files/pl/web/javascript/referencje/obiekty/math/index.html new file mode 100644 index 0000000000..350fb3a7de --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/index.html @@ -0,0 +1,94 @@ +--- +title: Math +slug: Web/JavaScript/Referencje/Obiekty/Math +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Math +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wbudowany obiekt zawierający własności i metody związane z funkcjami i stałymi matematycznymi. Na przykład własność {{jsxref("Math.PI", "PI")}} obiektu <code>Math</code> zawiera wartość liczby pi.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Tworzony przez</h2> + +<p>Obiekt <code>Math</code> w języku JavaScript jest predefiniowanym obiektem najwyższego poziomu. Można z niego korzystać od razu, bez korzystania z konstruktora lub wywoływania tworzącej metody.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wszystkie własności i metody obiektu <code>Math</code> są statyczne. Do stałej pi odwołujemy się poprzez <code>Math.PI</code>, a funkcję sinus wywołujemy jako <code>Math.sin(x)</code>, gdzie <code>x</code> jest argumentem metody. Stałe zdefiniowane są z pełną precyzją liczb rzeczywistych JavaScriptu.</p> + +<p>Czasami wygodniej jest skorzystać z polecenia {{jsxref("with")}}, kiedy w pewnym fragmencie kodu wykonywane jest wiele obliczeń korzystających z metod i stałych obiektu <code>Math</code>. Unika się wtedy wielokrotnego wpisywania "Math". Na przykład:</p> + +<pre class="brush: js">with (Math) { + a = PI * r*r; + y = r*sin(theta); + x = r*cos(theta); +} +</pre> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("Math.E")}}</dt> + <dd>stała Eulera, podstawa logarytmu naturalnego, w przybliżeniu 2.718.</dd> + <dt>{{jsxref("Math.LN2")}}</dt> + <dd>logarytm naturalny liczby 2, w przybliżeniu 0.693.</dd> + <dt>{{jsxref("Math.LN10")}}</dt> + <dd>logarytm naturalny liczby 10, w przybliżeniu 2.302.</dd> + <dt>{{jsxref("Math.LOG2E")}}</dt> + <dd>logarytm o podstawie 2 z liczby E, w przybliżeniu 1.442.</dd> + <dt>{{jsxref("Math.LOG10E")}}</dt> + <dd>logarytm o podstawie 10 z liczby E, w przybliżeniu 0.434.</dd> + <dt>{{jsxref("Math.PI")}}</dt> + <dd>stosunek obwodu okręgu do jego średnicy, w przybliżeniu 3.14159.</dd> + <dt>{{jsxref("Math.SQRT1_2")}}</dt> + <dd>pierwiastek kwadratowy z liczby 1/2, albo, inaczej mówiąc, odwrotność pierwiastka kwadratowego z liczby 2, w przybliżeniu 0.707.</dd> + <dt>{{jsxref("Math.SQRT2")}}</dt> + <dd>pierwiastek kwadratowy z liczby 2, w przybliżeniu 1.414.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Math.abs()")}}</dt> + <dd>zwraca wartość bezwzględną danej liczby.</dd> + <dt>{{jsxref("Math.acos()")}}</dt> + <dd>zwraca arcus cosinus (w radianach) danej liczby.</dd> + <dt>{{jsxref("Math.asin()")}}</dt> + <dd>zwraca arcus sinus (w radianach) danej liczby.</dd> + <dt>{{jsxref("Math.atan()")}}</dt> + <dd>zwraca arcus tangens (w radianach) danej liczby.</dd> + <dt>{{jsxref("Math.atan2()")}}</dt> + <dd>zwraca kąt (w radianach) utworzony przez oś OX i prostą przechodzącą przez punkt o podanych współrzędnych.</dd> + <dt>{{jsxref("Math.ceil()")}}</dt> + <dd>zwraca najmniejszą liczbę całkowitą większą od lub równą danej.</dd> + <dt>{{jsxref("Math.cos()")}}</dt> + <dd>zwraca cosinus danej liczby.</dd> + <dt>{{jsxref("Math.exp()")}}</dt> + <dd>zwraca <code>E<sup>x</sup></code>, gdzie <code>x</code> to argument, a <code>E</code> to stała Eulera.</dd> + <dt>{{jsxref("Math.floor()")}}</dt> + <dd>zwraca największą liczbę całkowitą mniejszą od lub równą danej.</dd> + <dt>{{jsxref("Math.log()")}}</dt> + <dd>zwraca logarytm naturalny (tj. o podstawie E) z danej liczby.</dd> + <dt>{{jsxref("Math.max()")}}</dt> + <dd>zwraca większą z dwóch liczb.</dd> + <dt>{{jsxref("Math.min()")}}</dt> + <dd>zwraca mniejszą z dwóch liczb.</dd> + <dt>{{jsxref("Math.pow()")}}</dt> + <dd>zwraca daną liczbę podniesioną do danej potęgi.</dd> + <dt>{{jsxref("Math.random()")}}</dt> + <dd>zwraca liczbą pseudolosową z przedziału [0, 1).</dd> + <dt>{{jsxref("Math.round()")}}</dt> + <dd>zwraca daną liczbę zaokrągloną do najbliższej liczby całkowitej.</dd> + <dt>{{jsxref("Math.sin()")}}</dt> + <dd>zwraca sinus danej liczby.</dd> + <dt>{{jsxref("Math.sqrt()")}}</dt> + <dd>zwraca pierwiastek kwadratowy danej liczby.</dd> + <dt>{{jsxref("Math.tan()")}}</dt> + <dd>zwraca tangens danej liczby.</dd> +</dl> diff --git a/files/pl/web/javascript/referencje/obiekty/math/ln10/index.html b/files/pl/web/javascript/referencje/obiekty/math/ln10/index.html new file mode 100644 index 0000000000..7b05143a06 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/ln10/index.html @@ -0,0 +1,42 @@ +--- +title: Math.LN10 +slug: Web/JavaScript/Referencje/Obiekty/Math/LN10 +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Logarytm naturalny liczby 10, w przybliżeniu 2.302.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2.302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>LN10</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.LN10</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_LN10" name="Przyk.C5.82ad:_Zastosowanie_LN10">Przykład: Zastosowanie <code>Math.LN10</code></h3> + +<p>Poniższa funkcja zwraca logarytm naturalny liczby 10:</p> + +<pre class="brush:js language-js">function getNatLog10() { + return Math.LN10; +} + +getNatLog10(); <code class="language-js"><span class="token comment">// 2.302585092994046</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/ln2/index.html b/files/pl/web/javascript/referencje/obiekty/math/ln2/index.html new file mode 100644 index 0000000000..aed4335b9f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/ln2/index.html @@ -0,0 +1,40 @@ +--- +title: Math.LN2 +slug: Web/JavaScript/Referencje/Obiekty/Math/LN2 +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Logarytm naturalny liczby 2, w przybliżeniu 0.693</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0.693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693</annotation></semantics></math></p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>LN2</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.LN2</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_LN2" name="Przyk.C5.82ad:_Zastosowanie_LN2">Przykład: Zastosowanie <code>Math.LN2</code></h3> + +<p>Poniższa funkcja zwraca logarytm naturalny liczby 2:</p> + +<pre class="brush:js language-js">function getNatLog2() { + return Math.LN2; +} + +getNatLog2(); <code class="language-js"><span class="token comment">// 0.6931471805599453</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/log/index.html b/files/pl/web/javascript/referencje/obiekty/math/log/index.html new file mode 100644 index 0000000000..14e292b04f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/log/index.html @@ -0,0 +1,54 @@ +--- +title: Math.log() +slug: Web/JavaScript/Referencje/Obiekty/Math/log +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca logarytm naturalny (o podstawie {{jsxref("Math.E", "e")}}) z danej liczby.</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.log(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli wartość liczby <code>x</code> jest ujemna, zwracaną wartością jest zawsze {{jsxref("NaN")}}.</p> + +<p>Ponieważ <code>log()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.log()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.log" name="Przyk.C5.82ad:_Zastosowanie_Math.log">Przykład: Zastosowanie <code>Math.log()</code></h3> + +<p> </p> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // NaN, out of range +</span>Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -Infinity +</span>Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token number">10</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 2.302585092994046</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/log10e/index.html b/files/pl/web/javascript/referencje/obiekty/math/log10e/index.html new file mode 100644 index 0000000000..33765632e0 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/log10e/index.html @@ -0,0 +1,44 @@ +--- +title: Math.LOG10E +slug: Web/JavaScript/Referencje/Obiekty/Math/LOG10E +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Logarytm o podstawie 10 z E, w przybliżeniu 0.434.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0.434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="sect1"> </h2> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Ponieważ <code>LOG10E</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.LOG10E</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_LOG10E" name="Przyk.C5.82ad:_Zastosowanie_LOG10E">Przykład: Zastosowanie <code>Math.LOG10E</code></h3> + +<p>Poniższa funkcja zwraca logarytm o podstawie 10 z E:</p> + +<pre class="brush:js language-js">function getLog10e() { + return Math.LOG10E; +} + +getLog10e();<code class="language-js"><span class="token comment"> // 0.4342944819032518</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/log2e/index.html b/files/pl/web/javascript/referencje/obiekty/math/log2e/index.html new file mode 100644 index 0000000000..29d465fe42 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/log2e/index.html @@ -0,0 +1,42 @@ +--- +title: Math.LOG2E +slug: Web/JavaScript/Referencje/Obiekty/Math/LOG2E +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Logarytm o podstawie 2 z E, w przybliżeniu 1.442.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1.442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>LOG2E</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.LOG2E</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_LOG2E" name="Przyk.C5.82ad:_Zastosowanie_LOG2E">Przykład: Zastosowanie <code>Math.LOG2E</code></h3> + +<p>Poniższa funkcja zwraca logarytm o podstawie 2 z E:</p> + +<pre class="brush: js language-js">function getLog2e() { + return Math.LOG2E; +} + +getLog2e(); <code class="language-js"><span class="token comment">// 1.4426950408889634</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/max/index.html b/files/pl/web/javascript/referencje/obiekty/math/max/index.html new file mode 100644 index 0000000000..40946461d5 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/max/index.html @@ -0,0 +1,43 @@ +--- +title: Math.max() +slug: Web/JavaScript/Referencje/Obiekty/Math/max +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/max +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca największą z podanych liczb.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code>Math.max([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>value1, value2, ...</code></dt> + <dd>liczby.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>max</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez Math.max(), a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.max" name="Przyk.C5.82ad:_Zastosowanie_Math.max">Przykład: Zastosowanie <code>Math.max()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="punctuation token">.</span><span class="function token">max<span class="punctuation token">(</span></span><span class="number token">10</span><span class="punctuation token">,</span> <span class="number token">20</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token"> // 20 +</span>Math<span class="punctuation token">.</span><span class="function token">max<span class="punctuation token">(</span></span><span class="operator token">-</span><span class="number token">10</span><span class="punctuation token">,</span> <span class="operator token">-</span><span class="number token">20</span><span class="punctuation token">)</span><span class="punctuation token">;</span><span class="comment token"> // -10 +</span>Math<span class="punctuation token">.</span><span class="function token">max<span class="punctuation token">(</span></span><span class="operator token">-</span><span class="number token">10</span><span class="punctuation token">,</span> <span class="number token">20</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token"> // 20</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.min()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/min/index.html b/files/pl/web/javascript/referencje/obiekty/math/min/index.html new file mode 100644 index 0000000000..75a892461b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/min/index.html @@ -0,0 +1,44 @@ +--- +title: Math.min() +slug: Web/JavaScript/Referencje/Obiekty/Math/min +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/min +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca najmniejszą z podanych liczb.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.min([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>value1, value2, ...</code></dt> + <dd>liczby.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Ponieważ <code>min</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.min()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Przykład_Zastosowanie_Math.min()">Przykład: Zastosowanie <code>Math.min()</code></h3> + +<p>Poniższa funkcja porównuje zmienne <code>x</code> and <code>y</code> i zwraca mniejszą <code>z</code> nich:</p> + +<pre class="brush: js language-js"><code class="language-js">var x = 10, y = -20; +var z = Math.min(x, y);</code></pre> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.max()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/pi/index.html b/files/pl/web/javascript/referencje/obiekty/math/pi/index.html new file mode 100644 index 0000000000..429a21db09 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/pi/index.html @@ -0,0 +1,40 @@ +--- +title: Math.PI +slug: Web/JavaScript/Referencje/Obiekty/Math/PI +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Stosunek obwodu okręgu do jego średnicy, w przybliżeniu 3.14159.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3.14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3.14159</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>PI</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.PI</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_PI" name="Przyk.C5.82ad:_Zastosowanie_PI">Przykład: Zastosowanie <code>Math.PI</code></h4> + +<p>Poniższa funkcja zwraca wartość pi:</p> + +<pre class="brush: js language-js">function getPi() { + return Math.PI; +} + +<code class="language-js"><span class="token function">calculateCircumference<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 6.283185307179586</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Global_Objects/Math", "Math")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/pow/index.html b/files/pl/web/javascript/referencje/obiekty/math/pow/index.html new file mode 100644 index 0000000000..89d0a1c21b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/pow/index.html @@ -0,0 +1,49 @@ +--- +title: Math.pow() +slug: Web/JavaScript/Referencje/Obiekty/Math/pow +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca liczbę <code>podstawa</code> podniesioną do potęgi o wykładniku <code>wykładnik</code>, tj. <code>podstawa<sup>wykładnik</sup></code>.</p> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<pre class="syntaxbox"><code>Math.pow(podstawa, wykładnik)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>podstawa</code> </dt> + <dd>liczba podnoszona do potęgi.</dd> +</dl> + +<dl> + <dt><code>wykładnik</code> </dt> + <dd>wykładnik potęgi, do której podnoszona jest liczba <code>podstawa</code>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>pow</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.pow()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.pow" name="Przyk.C5.82ad:_Zastosowanie_Math.pow">Przykład: Zastosowanie <code>Math.pow()</code></h3> + +<pre class="brush: js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">pow<span class="token punctuation">(</span></span><span class="token number">7</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 49</span></code></pre> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.cbrt()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/random/index.html b/files/pl/web/javascript/referencje/obiekty/math/random/index.html new file mode 100644 index 0000000000..af6fa11aa7 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/random/index.html @@ -0,0 +1,67 @@ +--- +title: Math.random() +slug: Web/JavaScript/Referencje/Obiekty/Math/random +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/random +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca pseudolosową, zmiennoprzecinkową liczbę z przedziału <code>[0, 1)</code> ( jedynka nie należy do przedziału). Podstawą generatora liczb losowych (ang.<em> seed</em> ) jest aktualny czas, tak samo jak w języku Java. Ponieważ <code>random</code> jest statyczną metodą obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.random()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p> + +<div class="note"> +<p><strong>Notatka:</strong> <code>Math.random()</code> <strong>nie zapewnia</strong><span class="tlid-translation translation"><span title=""> kryptograficznie bezpiecznych liczb losowych.</span></span> <span class="tlid-translation translation"><span title="">Nie używaj ich do niczego związanego z bezpieczeństwem (np. generowanie haseł).</span></span> <span class="tlid-translation translation"><span title="">Zamiast tego użyj Web Crypto API, a dokładniej:</span></span> metodę {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.</p> +</div> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.random()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p><span class="tlid-translation translation"><span title="">Liczba pseudolosowa, zmiennoprzecinkowa zawarta w przedziale <code>[0, 1)</code> (od 0 (włącznie) do 1 (wykluczając 1)).</span></span></p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad_Zastosowanie_Math.random" name="Przyk.C5.82ad:_Zastosowanie_Math.random">Zastosowanie <code>Math.random()</code></h3> + +<p>Zwraca losową liczbę większą lub równą 0 i mniejszą od 1.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> getRandom<span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></pre> + +<h3 id="Uzyskanie_losowej_liczby_między_dwiema_wartościami"><span class="tlid-translation translation"><span title="">Uzyskanie losowej liczby między dwiema wartościami</span></span></h3> + +<p><span class="tlid-translation translation"><span title="">Ten przykład zwraca losową liczbę znajdującą się pomiędzy określonymi wartościami.</span> <span title="">Zwrócona wartość jest większa lub równa <code>min</code>, i jest mniejsza niż <code>max</code>.</span></span></p> + +<pre><code class="language-js"><span class="keyword token">function</span> <span class="function token">getRandomInt</span><span class="punctuation token">(</span>min<span class="punctuation token">,</span> max<span class="punctuation token">)</span> <span class="punctuation token">{</span> + min <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">ceil</span><span class="punctuation token">(</span>min<span class="punctuation token">)</span><span class="punctuation token">;</span> + max <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>max<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">*</span> <span class="punctuation token">(</span>max <span class="operator token">-</span> min<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">+</span> min<span class="punctuation token">;</span> +<span class="punctuation token">}</span></code> +</pre> + +<h3 id="Uzyskanie_losowej_liczby_między_dwiema_wartościami_z_przedziału_min_max_max_włącznie"><span class="tlid-translation translation"><span title="">Uzyskanie losowej liczby między dwiema wartościami z przedziału <code>[min, max]</code> (<code>max</code> włącznie)</span></span></h3> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">getRandomIntInclusive</span><span class="punctuation token">(</span>min<span class="punctuation token">,</span> max<span class="punctuation token">)</span> <span class="punctuation token">{</span> + min <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">ceil</span><span class="punctuation token">(</span>min<span class="punctuation token">)</span><span class="punctuation token">;</span> + max <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>max<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">*</span> <span class="punctuation token">(</span>max <span class="operator token">-</span> min <span class="operator token">+</span> <span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">+</span> min<span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></pre> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div class="hidden"> +<p><span class="tlid-translation translation"><span title="">Tabela zgodności na tej stronie jest generowana na podstawie danych strukturalnych.</span> <span title="">Jeśli chcesz przyczynić się do danych, sprawdź <a href="/pl/docs/">https://github.com/mdn/browser-compat-data</a> i wyślij nam pull request'a.</span></span></p> +</div> + +<p>{{Compat("javascript.builtins.Math.random")}}</p> diff --git a/files/pl/web/javascript/referencje/obiekty/math/round/index.html b/files/pl/web/javascript/referencje/obiekty/math/round/index.html new file mode 100644 index 0000000000..4f0729568b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/round/index.html @@ -0,0 +1,50 @@ +--- +title: Math.round() +slug: Web/JavaScript/Referencje/Obiekty/Math/round +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/round +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca daną liczbę zaokrągloną do najbliższej liczby całkowitej.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.round(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli część ułamkowa liczby <code>x</code> wynosi 0.5 lub więcej, argument jest zaokrąglany do najbliższej większej liczby całkowitej. Jeśli część ułamkowa liczby <code>x</code> jest mniejsza niż 0.5, argument jest zaokrąglany do najbliższej mniejszej liczby całkowitej.</p> + +<p>Ponieważ <code>round</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.round()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.round" name="Przyk.C5.82ad:_Zastosowanie_Math.round">Przykład: Zastosowanie <code>Math.round()</code></h3> + +<pre class="brush: js">// zwraca 20 +x = Math.round(20.49) + +// zwraca 21 +x = Math.round(20.5) + +// zwraca -20 +x = Math.round(-20.5) + +// zwraca -21 +x = Math.round(-20.51) +</pre> + +<p> </p> diff --git a/files/pl/web/javascript/referencje/obiekty/math/sign/index.html b/files/pl/web/javascript/referencje/obiekty/math/sign/index.html new file mode 100644 index 0000000000..d6c21d59a1 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/sign/index.html @@ -0,0 +1,118 @@ +--- +title: Math.sign() +slug: Web/JavaScript/Referencje/Obiekty/Math/sign +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Podsumowanie</h2> + +<p>Funkcja<strong style="font-weight: bold;"> </strong><code><strong>Math.sign() </strong></code>zwraca znak liczby. Wynik wskazuje czy liczba przekazana jako argument jest dodatnia, ujemna lub czy jest zerem.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox"><code>Math.sign(<em>x</em>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Liczba, której znak ma zostać określony.</dd> +</dl> + +<h2 id="Description" name="Description">Opis</h2> + +<p>Metoda <code>sign</code> powinna być zawsze używana jako <code>Math.sign()</code>, ponieważ jest metodą statyczną w obiekcie <code>Math</code>. (Nie jako metoda stworzonego obiektu (<code>Math</code> nie jest konstruktorem)).</p> + +<p>Funkcja ma pięć wartości wynikowych <code>1, -1, 0, -0, NaN,</code> które reprezentują odpowiednio: "liczbę dodatnią", "liczbę ujemną", "zero "dodatnie"", <span style="line-height: 1.572;"> "zero "ujemne"" </span><span style="line-height: 1.572;">oraz NaN (parametr nie jest liczbą).</span></p> + +<p>Argument funkcji jest domyślnie konwertowany do <code>number</code>.</p> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<h3 id="Example:_Using_Math.log" name="Example:_Using_Math.log">Przykład: Użycie <code>Math.sign</code></h3> + +<pre class="brush:js">Math.sign(3) // 1 +Math.sign(-3) // -1 +Math.sign("-3") // -1 +Math.sign(0) // 0 +Math.sign(-0) // -0 +Math.sign(NaN) // NaN +Math.sign("foo") // NaN +Math.sign() // NaN +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sign', 'Math.sign')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Tabela_zgodności_przeglądarek">Tabela zgodności przeglądarek</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Zobacz również</h2> + +<ul> + <li>Obiekt {{jsxref("Math")}}, który definiuje tą funkcję.</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/sin/index.html b/files/pl/web/javascript/referencje/obiekty/math/sin/index.html new file mode 100644 index 0000000000..56d31ef74c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/sin/index.html @@ -0,0 +1,51 @@ +--- +title: Math.sin() +slug: Web/JavaScript/Referencje/Obiekty/Math/sin +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca sinus danej liczby.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.sin(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>sin</code> zwraca wartość numeryczną większą lub równą -1 i mniejszą lub równą 1, stanowiącą sinus argumentu.</p> + +<p>Ponieważ <code>sin</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.sin()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.sin" name="Przyk.C5.82ad:_Zastosowanie_Math.sin">Przykład: Zastosowanie <code>Math.sin()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">sin<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">sin<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0.8414709848078965 +</span> +Math<span class="token punctuation">.</span><span class="token function">sin<span class="token punctuation">(</span></span>Math<span class="token punctuation">.</span>PI <span class="token operator">/</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/sqrt/index.html b/files/pl/web/javascript/referencje/obiekty/math/sqrt/index.html new file mode 100644 index 0000000000..76c5b33a3e --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/sqrt/index.html @@ -0,0 +1,46 @@ +--- +title: Math.sqrt() +slug: Web/JavaScript/Referencje/Obiekty/Math/sqrt +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca pierwiastek kwadratowy danej liczby.</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>s</mi><mi>q</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mi>x</mi></msqrt><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x</annotation></semantics></math></p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.sqrt(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli wartość <code>x</code> jest ujemna, funkcja <code>sqrt</code> zwraca {{jsxref("NaN")}}.</p> + +<p>Ponieważ <code>sqrt()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.sqrt()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.sqrt" name="Przyk.C5.82ad:_Zastosowanie_Math.sqrt">Przykład: Zastosowanie <code>Math.sqrt()</code></h3> + +<pre class="brush: js language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">9</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 3 +</span>Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.414213562373095 +</span> +Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1 +</span>Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0 +</span>Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // NaN</span></code></pre> + +<p> </p> diff --git a/files/pl/web/javascript/referencje/obiekty/math/sqrt1_2/index.html b/files/pl/web/javascript/referencje/obiekty/math/sqrt1_2/index.html new file mode 100644 index 0000000000..224739b4ce --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/sqrt1_2/index.html @@ -0,0 +1,39 @@ +--- +title: Math.SQRT1 2 +slug: Web/JavaScript/Referencje/Obiekty/Math/SQRT1_2 +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +--- +<p>{{jsref}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Pierwiastek kwadratowy z liczby 1/2, albo, inaczej mówiąc, odwrotność pierwiastka kwadratowego z liczby 2, w przybliżeniu 0.707.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0.707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707</annotation></semantics></math></p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>SQRT1_2</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.SQRT1_2</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_SQRT1_2" name="Przyk.C5.82ad:_Zastosowanie_SQRT1_2">Przykład: Zastosowanie <code>Math.SQRT1_2</code></h3> + +<p>Poniższa funkcja zwraca pierwiastek kwadratowy z 1/2:</p> + +<pre class="brush:js language-js">function getRoot1_2() { + return Math.SQRT1_2 +} + +<code class="language-js"><span class="token function">getRoot1_2<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.7071067811865476</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/sqrt2/index.html b/files/pl/web/javascript/referencje/obiekty/math/sqrt2/index.html new file mode 100644 index 0000000000..6f247b5abe --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/sqrt2/index.html @@ -0,0 +1,41 @@ +--- +title: Math.SQRT2 +slug: Web/JavaScript/Referencje/Obiekty/Math/SQRT2 +tags: + - JavaScript + - Math + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Pierwiastek kwadratowy z liczby 2, w przybliżeniu 1.414.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1.414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ponieważ <code>SQRT2</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez {{jsxref("Math")}}<code>.SQRT2</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_SQRT2" name="Przyk.C5.82ad:_Zastosowanie_SQRT2">Przykład: Zastosowanie <code>Math.SQRT2</code></h3> + +<p>Poniższa funkcja zwraca pierwiastek kwadratowy z liczby 2:</p> + +<pre class="brush: js language-js">function getRoot2() { + return Math.SQRT2; +} + +<code class="language-js"><span class="token function">getRoot2<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.4142135623730951</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/math/tan/index.html b/files/pl/web/javascript/referencje/obiekty/math/tan/index.html new file mode 100644 index 0000000000..844ca8cf12 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/math/tan/index.html @@ -0,0 +1,53 @@ +--- +title: Math.tan() +slug: Web/JavaScript/Referencje/Obiekty/Math/tan +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca tangens danej liczby.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Math.tan(<var>x</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>x</code> </dt> + <dd>liczba.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>tan</code> zwraca wartość numeryczną reprezentującą tangens kąta.</p> + +<p>Ponieważ <code>tan()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.tan()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_Math.tan" name="Przyk.C5.82ad:_Zastosowanie_Math.tan">Przykład: Zastosowanie <code>Math.tan()</code></h4> + +<p>Poniższa funkcja zwraca tangens zmiennej <code>x</code>:</p> + +<pre class="brush: js">function getTan(x) { + return Math.tan(x) +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/nan/index.html b/files/pl/web/javascript/referencje/obiekty/nan/index.html new file mode 100644 index 0000000000..738e9a2a01 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/nan/index.html @@ -0,0 +1,45 @@ +--- +title: NaN +slug: Web/JavaScript/Referencje/Obiekty/NaN +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/NaN +--- +<div> +<div> +<div>{{jsSidebar("Obiekty")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość reprezentująca + <i>Not-A-Number</i> + , tj. nie będąca liczbą.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>NaN</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>NaN</code> jest własnością najwyższego rzędu i nie jest powiązana z żadnym obiektem.</p> + +<p>Wartością początkową <code>NaN</code> jest <code>NaN</code>.</p> + +<p><code>NaN</code> nigdy nie jest równa innej liczbie, nie jest równa nawet samej sobie. Nie jest możliwe sprawdzenie, czy dana wartość jest NaN przez porównanie z {{jsxref("Number.NaN")}} – należy zamiast tego stosować funkcję {{jsxref("Obiekty.isNaN", "isNaN()")}}.</p> + +<p>Wiele metod języka JavaScript (m. in. konstruktor <code>Number</code>, <code>parseFloat</code> i <code>parseInt</code>) zwracają <code>NaN</code>, jeśli wartość ich parametrów nie jest liczbą lub nie daje się na liczbę skonwertować.</p> + +<p><code>NaN</code> można zastosować do zasygnalizowania błędu w funkcji, która zazwyczaj zwraca poprawną liczbę.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.NaN")}}</li> + <li>{{jsxref("Number.isNaN()")}}</li> + <li>{{jsxref("Obiekty.isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/netscape/index.html b/files/pl/web/javascript/referencje/obiekty/netscape/index.html new file mode 100644 index 0000000000..e30cf9671c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/netscape/index.html @@ -0,0 +1,29 @@ +--- +title: netscape +slug: Web/JavaScript/Referencje/Obiekty/netscape +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/netscape +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p><b>Obiekt główny</b> +</p><p>Obiekt najwyższego poziomu używany do korzystania z klas języka Java z pakietu <code>netscape.*</code>. +</p> +<h3 id="Tworzony_przez" name="Tworzony_przez"> Tworzony przez </h3> +<p>Obiekt <code>netscape</code> w języku JavaScript jest predefiniowanym obiektem najwyższego poziomu. Nie ma potrzeby stosowania konstruktora lub wywoływania jakiejkolwiek metody by z niego korzystać. +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Obiekt <code>netscape</code> jest synonimem dla własności <code>Packages.netscape</code>. +</p> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages/netscape">Packages.netscape</a></code> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/netscape", "es": "es/Referencia_de_JavaScript_1.5/Objetos_globales/netscape" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/null/index.html b/files/pl/web/javascript/referencje/obiekty/null/index.html new file mode 100644 index 0000000000..34e20e399c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/null/index.html @@ -0,0 +1,134 @@ +--- +title: 'null' +slug: Web/JavaScript/Referencje/Obiekty/null +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/null +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Wartość <code>null</code> reprezentuje zamierzony brak wartości jakiegoś obiektu. Jest jedną z {{Glossary("Primitive", "podstawowych wartości")}} w JavaSript.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>null </code></pre> + +<h2 id="Opis">Opis</h2> + +<p>Wartość <code>null</code>, jak podpowiada nazwa, zapisujemy używając słowa "<code>null</code>". <code>null</code> nie jest zmienną globalną, w przeciwieństwie do {{jsxref("Global_Objects/undefined","undefined")}}. Zamiast tego <code>null</code> wyraża brak identyfikacji, mówiąc nam, że zmienna nie wskazuje na obiekt. W wielu API <code>null</code> jest często zwracany tam, gdzie może być obiekt, ale aktualnie jeszcze go tam nie ma.</p> + +<pre class="brush: js">// foo nie istnieje. Nie jest zdefiniowany oraz nigdy nie był zainicjalizowany: +> foo +"ReferenceError: foo is not defined" + +// Teraz wiadomo że null istnieje, ale nie ma on żadnego typu ani wartości: +> var foo = null; foo; +"null" +</pre> + +<h3 id="Różnice_pomiędzy_null_i_undefined">Różnice pomiędzy <code>null</code> i <code>undefined</code></h3> + +<p>Podczas sprawdzania <code>null</code> lub <font face="Consolas, Liberation Mono, Courier, monospace">undefined</font>, uważaj na <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_porównania">róźnice pomiędzy operatorami równości (==) oraz identyczności (===)</a>, ponieważ ten pierwszy wykonuje konwersję typu.</p> + +<pre class="brush: js">typeof null // "object" (nie jest to "null" ze względu na starsze przyczyny) +typeof undefined // "undefined" +null === undefined // false +null == undefined // true +null === null // true +null == null // true +!null // true +isNaN(1 + null) // false +isNaN(1 + undefined) // true</pre> + +<p> </p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-4.3.11', 'null value')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-null-value', 'null value')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-null-value', 'null value')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("undefined")}}</li> + <li>{{jsxref("NaN")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/constructor/index.html b/files/pl/web/javascript/referencje/obiekty/number/constructor/index.html new file mode 100644 index 0000000000..01315b7ad5 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/constructor/index.html @@ -0,0 +1,22 @@ +--- +title: constructor +slug: Web/JavaScript/Referencje/Obiekty/Number/constructor +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Global_Objects/Number +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p><b>Własność obiektu: <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Number">Number</a></b> +</p><p>Określa funkcję tworzącą prototyp obiektu. Należy pamiętać, że wartość tej własności jest referencją do funkcji, a nie łańcuchem znaków zawierającym jej nazwę. +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Zobacz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Object/constructor">Object.constructor</a></code>. +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Number/constructor", "ja": "ja/Core_JavaScript_1.5_Reference/Global_Objects/Number/constructor" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/number/epsilon/index.html b/files/pl/web/javascript/referencje/obiekty/number/epsilon/index.html new file mode 100644 index 0000000000..289e33ad79 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/epsilon/index.html @@ -0,0 +1,76 @@ +--- +title: Number.EPSILON +slug: Web/JavaScript/Referencje/Obiekty/Number/EPSILON +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Właściwość +translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON +--- +<div>{{JSRef}}</div> + +<p>Właściwość <strong><code>Number.EPSILON</code></strong> reprezentuje różnicę pomiędzy 1 a najmniejszą liczbą zmiennoprzecinkową większą niż 1.</p> + +<p>Jest to właściwość statyczna. Nie musisz tworzyć obiektu {{jsxref("Number")}}, żeby mieć do niej dostęp (użyj <code>Number.EPSILON</code>).</p> + +<div>{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis">Opis</h2> + +<p>Wartość właściwości <code>EPSILON</code> to w przybliżeniu <code>2.2204460492503130808472633361816E-16</code> lub <code>2<sup>-52</sup></code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Testowanie_równości">Testowanie równości</h3> + +<pre class="brush: js">x = 0.2; +y = 0.3; +z = 0.1; +equal = (Math.abs(x - y + z) < Number.EPSILON); +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (Number.EPSILON === undefined) { + Number.EPSILON = Math.pow(2, -52); +} +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.epsilon', 'Number.EPSILON')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.EPSILON")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Number")}} obiekt, do którego należy ta właściwość.</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/index.html b/files/pl/web/javascript/referencje/obiekty/number/index.html new file mode 100644 index 0000000000..78fc243a0b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/index.html @@ -0,0 +1,111 @@ +--- +title: Number +slug: Web/JavaScript/Referencje/Obiekty/Number +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Number +--- +<div>{{JSRef}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Pozwala pracować z wartościami liczbowymi. Obiekt <code>Number</code> jest opakowaniem (ang.<em>wrapper</em> ) dla prymitywnych wartości numerycznych.</p> + +<h2 id="Tworzone_przez" name="Tworzone_przez">Tworzone przez</h2> + +<p>Konstruktor <code>Number</code>:</p> + +<pre class="syntaxbox">new Number(value);</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>value</code> </dt> + <dd>Wartość numeryczna tworzonego obiektu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt <code>Number</code> jest głównie stosowany do:</p> + +<ul> + <li>Uzyskania dostępu do jego stałych własnościach, które reprezentują najmniejszą i największa możliwą (przestawialną) liczbę, dodatnią lub ujemną nieskończoność i wartość nieliczbową (<em>Not-a-Number</em> ).</li> +</ul> + +<ul> + <li>Aby stworzyć obiekty liczbowe do których możesz dodać własności. Najprawdopodobniej rzadko, kiedy będziesz musiał stworzyć obiekt typu <code>Number</code>.</li> +</ul> + +<p>Własności <code>Number</code> są własnościami jego klasy, nieindywidualnymi własnościami obiektu.</p> + +<p><strong>JavaScript 1.2</strong>: <code>Number(x)</code> teraz tworzy raczej <code>NaN</code> niż błąd jeśli <code>x</code> jest ciągiem znaków, który nie zawiera poprawnie sformatowanej liczby. Na przykład, poniższy kod drukuje <code>NaN</code>:</p> + +<pre class="brush: js">var x = Number("three"); +document.write(x + "<BR>"); +</pre> + +<p>Możesz przekonwertować, każdy obiekt na liczbę używając funkcji wysokiego poziomu <code>Number</code>.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("Number.constructor")}}</dt> + <dd>Oznacza funkcję, która tworzy prototyp obiektu.</dd> + <dt>{{jsxref("Number.MAX_VALUE")}}</dt> + <dd>Największa możliwa do przedstawienia liczba.</dd> + <dt>{{jsxref("Number.MIN_VALUE")}}</dt> + <dd>Najmniejsza możliwa do przedstawienia liczba.</dd> + <dt>{{jsxref("Number.NaN")}}</dt> + <dd>Specjalna wartość "nie jest liczbą" (Not-a-Number).</dd> + <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt> + <dd>Specjalna wartość reprezentująca negatywną nieskończoność; zwracana przy przepełnieniu.</dd> + <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt> + <dd>Specjalna wartość reprezentująca nieskończoność; zwracana przy przepełnieniu.</dd> + <dt>{{jsxref("Number.prototype")}}</dt> + <dd>Pozwala na dodawanie (tworzenie) nowych własności obiektu <code>Number</code>.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<p><strong>{{jsxref("Number.isInteger()")}}</strong></p> + +<p> Sprawdza czy liczba jest całkowita.</p> + +<dl> + <dt>{{jsxref("Number.toExponential()")}}</dt> + <dd>Zwraca ciąg znaków, reprezentujący liczbę zapisaną w postaci wykładniczej.</dd> + <dt>{{jsxref("Number.toFixed()")}}</dt> + <dd>Zwraca ciąg znaków, reprezentujący liczbę stałoprzecinkową.</dd> + <dt>{{jsxref("Number.toLocaleString()")}}</dt> + <dd>Zwraca czytelny dla ludzi ciąg znaków reprezentujący liczbę zapisaną przy wykorzystaniu lokalnego formatu zapisu liczb. Przesłania metodę {{jsxref("Object.toLocaleString()")}}.</dd> + <dt>{{jsxref("Number.toPrecision()")}}</dt> + <dd>Zwraca ciąg znaków reprezentujący liczbę stałoprzecinkową o podanej precyzji.</dd> + <dt>{{jsxref("Number.toSource()")}}</dt> + <dd>Zwraca literał obiektu reprezentujący podany obiekt <code>Number</code>; możesz użyć tą wartość, przy tworzeniu nowego obiektu. Przesłania metodę {{jsxref("Object.toSource()")}}.</dd> + <dt>{{jsxref("Number.toString()")}}</dt> + <dd>Zwraca ciąg znaków reprezentujący podany obiekt. Przesłania metodę {{jsxref("Object.toString()")}}.</dd> + <dt>{{jsxref("Number.valueOf()")}}</dt> + <dd>Zwraca zmienną typu prostego reprezentującą wartość podanego obiektu. Przesłania metodę {{jsxref("Object.valueOf()")}}.</dd> +</dl> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_obiektu_Number.2C_przy_przypisaniu_warto.C5.9Bci_zmiennym_liczbowym" name="Przyk.C5.82ad:_Zastosowanie_obiektu_Number.2C_przy_przypisaniu_warto.C5.9Bci_zmiennym_liczbowym">Przykład: Zastosowanie obiektu <code>Number</code>, przy przypisaniu wartości zmiennym liczbowym</h3> + +<p>Poniższy przykład używa własności obiektu <code>Number</code>, aby przypisać wartości do kilku wartości numerycznych:</p> + +<pre class="brush: js">var najwiekszaLiczba = Number.MAX_VALUE; +var najmniejszaLiczba = Number.MIN_VALUE; +var nieskonczonosc = Number.POSITIVE_INFINITY; +var negatywnaNieskonczonosc = Number.NEGATIVE_INFINITY; +var nieJestLiczba = Number.NaN; +</pre> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_obiektu_Number_do_modyfikacji_wszystkich_obiekt.C3.B3w_Number" name="Przyk.C5.82ad:_Zastosowanie_obiektu_Number_do_modyfikacji_wszystkich_obiekt.C3.B3w_Number">Przykład: Zastosowanie obiektu <code>Number</code> do modyfikacji wszystkich obiektów <code>Number</code></h3> + +<p>Poniższy przykład tworzy obiekt typu <code>Number</code>, <code>.mojaLiczba</code>, wtedy dodaje własność <code>opis</code>, wszystkim obiektom <code>Number</code>. Następnie wartość jest przypisana do własności <code>opis</code> obiektu <code>mojaLiczba</code>.</p> + +<pre class="brush: js">var mojaLiczba = new Number(65); +Number.prototype.opis = null; +var mojaLiczba.opis = "prędkość wiatru"; +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/number/isinteger/index.html b/files/pl/web/javascript/referencje/obiekty/number/isinteger/index.html new file mode 100644 index 0000000000..aaf93ab5fb --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/isinteger/index.html @@ -0,0 +1,88 @@ +--- +title: Number.isInteger() +slug: Web/JavaScript/Referencje/Obiekty/Number/isInteger +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>Number.isInteger()</code></strong> sprawdza czy wpisana wartość jest liczbą całkowitą.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Number.isInteger(v<var>alue</var>)</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>zmienna</code></dt> + <dd>Zmienna będzie testowana jako liczba.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Metoda zwraca wartość typu {{jsxref("Boolean")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>Jeśli sprawdzana zmienna jest liczbą całkowitą metoda zwraca <code>true</code>, w innym przypadku zwraca <code>false</code>. Jeśli zmienna jest typu {{jsxref("NaN")}} lub spoza zakresu metoda zwraca <code>false</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">Number.isInteger(0); // true +Number.isInteger(1); // true +Number.isInteger(-100000); // true + +Number.isInteger(0.1); // false +Number.isInteger(Math.PI); // false + +Number.isInteger(NaN); // false +Number.isInteger(Infinity); // false +Number.isInteger(-Infinity); // false +Number.isInteger('10'); // false +Number.isInteger(true); // false +Number.isInteger(false); // false +Number.isInteger([1]); // false +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) { + return typeof value === 'number' && + isFinite(value) && + Math.floor(value) === value; +}; +</pre> + +<h2 id="Dokumentacja">Dokumentacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.isinteger', 'Number.isInteger')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilne_przegladarki">Kompatybilne przegladarki</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.isInteger")}}</p> + +<h2 id="Sprawdź_również">Sprawdź również</h2> + +<ul> + <li>Metoda ta należy do klasy {{jsxref("Number")}}.</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/isnan/index.html b/files/pl/web/javascript/referencje/obiekty/number/isnan/index.html new file mode 100644 index 0000000000..ddb723b409 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/isnan/index.html @@ -0,0 +1,108 @@ +--- +title: Number.isNaN() +slug: Web/JavaScript/Referencje/Obiekty/Number/isNaN +tags: + - ECMAScript 2015 + - JavaScript + - Metodă + - NaN + - Number + - isNaN +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>Number.isNaN()</code></strong> określa czy podany parametr ma wartość {{jsxref("NaN")}} i czy jest typu {{jsxref("Number")}}. Jest to ulepszona wersja oryginalnej, globalne funkcji {{jsxref("isNaN", "isNaN()")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-isnan.html", "taller")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Number.isNaN(<var>value</var>)</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>value</var></code></dt> + <dd>Wartość, którą będziemy testować {{jsxref("NaN")}}.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p><strong>true</strong>, jeśli podana wartość jest {{jsxref("NaN")}}, a jej typem jest {{jsxref("Number")}}; w przeciwnym razie, <strong>false</strong>.</p> + +<h2 id="Opis">Opis</h2> + +<p>Ponieważ oba operatory porównania, {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} i {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}, dla zapytania czy {{jsxref("NaN")}} <em>jest równe</em> {{jsxref("NaN")}} zwracają <code>false</code> funkcja <code>Number.isNaN()</code> staje się niezbędna. Jest sytuacja wyjątkowa i nie występuje, gdy porównujemy dowolne inne wartości w języku JavaScript.</p> + +<p>W porównaniu do funkcji globalnej {{jsxref("isNaN", "isNaN()")}}, metoda <code>Number.isNaN()</code> nie ma problemu z usilnym konwertowaniem parametru na liczbę. To oznacza, że można bezpiecznie przekazywać wartości, które normalnie mogłyby zostać skonwertowane na {{jsxref("NaN")}}, ale nie mają tej samej wartości co {{jsxref("NaN")}}. To również oznacza, że jedynie wartości typu {{jsxref("Number")}}, które są również {{jsxref("NaN")}}, zwrócą <code>true</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">Number.isNaN(NaN); // true +Number.isNaN(Number.NaN); // true +Number.isNaN(0 / 0); // true + +// Gdybyśmy użyli funkcji isNaN(), te przykłady zwróciłby true +Number.isNaN('NaN'); // false +Number.isNaN(undefined); // false +Number.isNaN({}); // false +Number.isNaN('blabla'); // false + +// Wszystkie zwracają false +Number.isNaN(true); +Number.isNaN(null); +Number.isNaN(37); +Number.isNaN('37'); +Number.isNaN('37.37'); +Number.isNaN(''); +Number.isNaN(' '); +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Następujący przykład działa, ponieważ {{jsxref("NaN")}} jest jedyną wartością w języku JavaScript, która nie jest równa samej sobie.</p> + +<pre class="brush: js">Number.isNaN = Number.isNaN || function(value) { + return value !== null && (value != value || +value != value); +} +</pre> + +<h2 id="Opis_2">Opis</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isnan', 'Number.isnan')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.isnan', 'Number.isnan')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + + + +<div>{{Compat("javascript.builtins.Number.isNaN")}}</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/max_value/index.html b/files/pl/web/javascript/referencje/obiekty/number/max_value/index.html new file mode 100644 index 0000000000..4ec6b77eb3 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/max_value/index.html @@ -0,0 +1,35 @@ +--- +title: Number.MAX_VALUE +slug: Web/JavaScript/Referencje/Obiekty/Number/MAX_VALUE +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Największa liczba, której reprezentacja jest możliwa w języku JavaScript.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Własność <code>MAX_VALUE</code> ma wartość ok. 1.79E+308. Wartości większe niż <code>MAX_VALUE</code> są reprezentowane jako "<code>Infinity</code>" (nieskończoność).</p> + +<p>Ponieważ <code>MAX_VALUE</code> jest statyczną własnością {{jsxref("Number")}}, używa jej się zawsze jako <code>Number.MAX_VALUE</code>, a nie jako własność utworzonego przez programistę obiektu {{jsxref("Number")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h2 id="Przyk.C5.82ad:_Zastosowanie_MAX_VALUE" name="Przyk.C5.82ad:_Zastosowanie_MAX_VALUE">Przykład: Zastosowanie <code>MAX_VALUE</code></h2> + +<p>Poniższy kod mnoży dwie liczby. Jeśli wynik jest większy lub równy <code>MAX_VALUE</code>, wywoływana jest funkcja <code>func1</code>, w przeciwnym wypadku wywoływana jest funkcja <code>func2</code>.</p> + +<pre class="eval">if (num1 * num2 <= Number.MAX_VALUE) { + func1(); +} else { + func2(); +} +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/number/min_value/index.html b/files/pl/web/javascript/referencje/obiekty/number/min_value/index.html new file mode 100644 index 0000000000..7010abe1af --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/min_value/index.html @@ -0,0 +1,39 @@ +--- +title: Number.MIN VALUE +slug: Web/JavaScript/Referencje/Obiekty/Number/MIN_VALUE +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Najmniejsza dodatnia wartość liczbowa, której reprezentacja jest możliwa w języku JavaScript.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Własność <code>MIN_VALUE</code> to najbliższa zeru liczba dodatnia, jakiej reprezentacja jest możliwa w języku JavaScript - nie jest to najmniejsza liczba ujemna.</p> + +<p><code>MIN_VALUE</code> ma wartość ok. 5e-324. Wartości mniejsze niż <code>MIN_VALUE</code> (ang. "underflow values") konwertowane są do 0.</p> + +<p>Ponieważ <code>MIN_VALUE</code> jest statyczną własnością {{jsxref("Number")}}, używa jej się zawsze jako <code>Number.MIN_VALUE</code>, a nie jako własność utworzonego przez programistę obiektu {{jsxref("Number")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_MIN_VALUE" name="Przyk.C5.82ad:_Zastosowanie_MIN_VALUE">Przykład: Zastosowanie <code>Number.MIN_VALUE</code></h3> + +<p>Poniższy kod dzieli jedną liczbę przez drugą. Jeśli wynik jest większy lub równy <code>MIN_VALUE</code>, wywoływana jest funkcja <code>func1</code>, w przeciwnym wypadku wywoływana jest funkcja <code>func2</code>.</p> + +<pre class="brush: js">if (num1 / num2 >= Number.MIN_VALUE) { + func1(); +} else { + func2(); +} +</pre> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/referencje/obiekty/number/nan/index.html b/files/pl/web/javascript/referencje/obiekty/number/nan/index.html new file mode 100644 index 0000000000..987a48ee6d --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/nan/index.html @@ -0,0 +1,48 @@ +--- +title: Number.NaN +slug: Web/JavaScript/Referencje/Obiekty/Number/NaN +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość reprezentująca Not-A-Number (Nie-Liczbę).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartością <code>Number.NaN</code> jest Not-A-Number, taką samą jak wartość własności {{jsxref("Obiekty/NaN", "NaN")}} obiektu globalnego.</p> + +<p><span class="comment">Keep text below in sync with Properties:NaN page</span> <code>NaN</code> jest zawsze różna od dowolnej liczby, włączając również <code>NaN</code>; nie możesz sprawdzić wartości nieliczbowej poprzez porównanie do <code>Number.NaN</code>. Użyj zamiast tego funkcji {{jsxref("Obiekty/isNaN", "isNaN()")}}.</p> + +<p>Kilka metod JavaScript (takie jak konstruktor <code>Number</code>, <code>parseFloat</code> i <code>parseInt</code>) zwracają <code>NaN</code>, jeśli wartość określona w parametrze nie może być przetworzona jako liczba.</p> + +<p>Możesz użyć własności <code>NaN</code>, aby wskazać warunek błędu dla Twojej funkcji, która zwraca liczbę w przypadku sukcesu.</p> + +<p>JavaScript wyświetla wartość <code>Number.NaN</code> jako <code>NaN</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_NaN" name="Przyk.C5.82ad:_Zastosowanie_NaN">Przykład: Zastosowanie <code>Number.NaN</code></h3> + +<p>W poniższym przykładzie, jeśli miesiąc (month) jest wartość większą niż 12, zostaje mu przypisane <code>NaN</code> i wyświetlana jest informacja o nieprawidłowych wartościach.</p> + +<pre class="brush: js">var month = 13; +if (month < 1 || month > 12) { + month = Number.NaN; + console.log("Miesiąc musi być liczbą między 1 i 12."); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Obiekty/NaN", "NaN")}}</li> + <li>The {{jsxref("Number")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/negative_infinity/index.html b/files/pl/web/javascript/referencje/obiekty/number/negative_infinity/index.html new file mode 100644 index 0000000000..90de86af6d --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/negative_infinity/index.html @@ -0,0 +1,53 @@ +--- +title: Number.NEGATIVE INFINITY +slug: Web/JavaScript/Referencje/Obiekty/Number/NEGATIVE_INFINITY +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość reprezentująca ujemną nieskończoność.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość własności <code>Number.NEGATIVE_INFINITY</code> jest taka sama jak ujemna wartość własności {{jsxref("Infinity")}} obiektu globalnego.</p> + +<p>Wartość ta zachowuje się nieco inaczej niż matematyczna nieskończoność:</p> + +<ul> + <li>Dowolna dodatnia wartość, włączając {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, pomnożona przez <code>NEGATIVE_INFINITY</code> jest równa <code>NEGATIVE_INFINITY</code>.</li> + <li>Dowolna ujemna wartość, włączając <code>NEGATIVE_INFINITY</code>, pomnożona przez <code>NEGATIVE_INFINITY</code> jest równa {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li>Zero pomnożone przez <code>NEGATIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>NaN pomnożone przez <code>NEGATIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>Wartość <code>NEGATIVE_INFINITY</code> podzielona przez dowolną wartość ujemną za wyjątkiem <code>NEGATIVE_INFINITY</code> jest równa {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li>Wartość <code>NEGATIVE_INFINITY</code> podzielona przez dowolną wartość dodatnią za wyjątkiem {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}} jest równa <code>NEGATIVE_INFINITY</code>.</li> + <li>Wartość <code>NEGATIVE_INFINITY</code> podzielona przez <code>NEGATIVE_INFINITY</code> lub {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}} zwraca wartość NaN.</li> + <li>Dowolna liczba podzielona przez <code>NEGATIVE_INFINITY</code> jest równa zero.</li> +</ul> + +<p>Własności <code>Number.NEGATIVE_INFINITY</code> można użyć do wskazania błędu warunku, który zwraca liczbę skończoną w przypadku powodzenia. Należy jednak zauważyć, że funkcja {{jsxref("Obiekty/isFinite", "isFinite")}} będzie w tym wypadku bardziej odpowiednia.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<p>W poniższym przykładzie do zmiennej smallNumber została przypisana wartość mniejsza niż wartość minimalna. Gdy zostaje wykonana instrukcja <code>if</code>, smallNumber posiada wartość "<code>-Infinity</code>", więc przed kontynuowaniem do zmiennej smallNumber jest przypisywana bardziej wykonywalna wartość.</p> + +<pre class="brush: js">var smallNumber = (-Number.MAX_VALUE) * 2; + +if (smallNumber == Number.NEGATIVE_INFINITY) { + smallNumber = returnFinite(); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Obiekty/Infinity", "Infinity")}}</li> + <li>{{jsxref("Obiekty/isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/positive_infinity/index.html b/files/pl/web/javascript/referencje/obiekty/number/positive_infinity/index.html new file mode 100644 index 0000000000..e0be5b9e2a --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/positive_infinity/index.html @@ -0,0 +1,57 @@ +--- +title: Number.POSITIVE INFINITY +slug: Web/JavaScript/Referencje/Obiekty/Number/POSITIVE_INFINITY +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość reprezentująca dodatnią nieskończoność.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartość własności <code>Number.POSITIVE_INFINITY</code> jest taka sama jak wartość własności {{jsxref("Infinity")}} obiektu globalnego.</p> + +<p>Wartość ta zachowuje się nieco inaczej niż matematyczna nieskończoność:</p> + +<ul> + <li>Dowolna dodatnia wartość, włączając <code>POSITIVE_INFINITY</code>, pomnożona przez <code>POSITIVE_INFINITY</code> jest równa <code>POSITIVE_INFINITY</code>.</li> + <li>Dowolna ujemna wartość, włączając {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, pomnożona przez <code>POSITIVE_INFINITY</code> jest równa {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li> + <li>Zero pomnożone przez <code>POSITIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>NaN pomnożone przez <code>POSITIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>Wartość <code>POSITIVE_INFINITY</code> podzielona przez dowolną wartość ujemną za wyjątkiem {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} jest równa {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li> + <li>Wartość <code>POSITIVE_INFINITY</code> podzielona przez dowolną wartość dodatnią za wyjątkiem <code>POSITIVE_INFINITY</code> jest równa <code>POSITIVE_INFINITY</code>.</li> + <li>Wartość <code>POSITIVE_INFINITY</code> podzielona przez {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} lub <code>POSITIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li> + <li>Dowolna liczba podzielona przez <code>POSITIVE_INFINITY</code> jest równa <code>0</code>.</li> +</ul> + +<p>Niektóre metody JavaScript (takie jak konstruktor <code>Number</code>, <code>parseFloat</code> i <code>parseInt</code>) zwracają wartość <code>NaN</code>, jeśli wartość określona w parametrze znacznie przewyższa wartość <code>Number.MAX_VALUE</code>.</p> + +<p>Własności <code>Number.POSITIVE_INFINITY</code> można użyć do wskazania błędu warunku, który zwraca liczbę skończoną w przypadku powodzenia. Należy jednak zauważyć, że funkcja {{jsxref("Obiekty/isFinite", "isFinite")}} będzie w tym wypadku bardziej odpowiednia.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<p>W poniższym przykładzie do zmiennej largeNumber została przypisana wartość większa niż wartość maksymalna. Gdy zostaje wykonana instrukcja {{jsxref("Polecenia/if...else", "if")}}, largeNumber posiada wartość <code>Infinity</code>, więc przed kontynuowaniem do zmiennej <code>bigNumber</code> jest przypisywana bardziej wykonywalna wartość.</p> + +<pre class="brush: js">var bigNumber = Number.MAX_VALUE * 2; + +if (bigNumber == Number.POSITIVE_INFINITY) { + bigNumber = returnFinite(); +} +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("Obiekty/isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/toexponential/index.html b/files/pl/web/javascript/referencje/obiekty/number/toexponential/index.html new file mode 100644 index 0000000000..1eef2782e4 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/toexponential/index.html @@ -0,0 +1,53 @@ +--- +title: Number.prototype.toExponential() +slug: Web/JavaScript/Referencje/Obiekty/Number/toExponential +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący Number w notacji wykładniczej.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toExponential([<var>fractionDigits</var>])</code></pre> + +<h3 id="Parametr" name="Parametr">Parametr</h3> + +<dl> + <dt>fractionDigits</dt> + <dd>Liczba całkowita określająca liczbę cyfr występujących po kropce dziesiętnej. Domyślną wartością jest tyle cyfr, ile potrzeba do określenia liczby.</dd> +</dl> + +<h3 id="Zwraca" name="Zwraca">Zwraca</h3> + +<p>Łańcuch znaków reprezentujący obiekt {{jsxref("Number")}} w notacji wykładniczej z jedną cyfrą przed kropką dziesiętną i zaokrągleniem do tylu cyfr po kropce, ile określa parametr <code>fractionDigits</code>. Jeśli argument <code>fractionDigits</code> zostanie pominięty, domyślnie przyjmowana jest taka wartość zaokrąglenia, która pozwala na przedstawienie wartości w sposób unikatowy.</p> + +<p>Jeśli metoda <code>toExponential()</code> zostanie użyta do literałów liczbowych, które nie posiadają wykładnika i kropki dziesiętnej, należy wstawić spację przed kropką poprzedzającą wywołanie metody, aby zapobiec zinterpretowaniu tej kropki jako kropki dziesiętnej.</p> + +<p>Jeśli liczba posiada więcej cyfr niż określono przez parametr <code>fractionDigits</code>, jest ona zaokrąglana do najbliższej liczby o ilości cyfr wskazanej przez wartość <code>fractionDigits</code>. Zobacz dyskusję na temat zaokrąglania w opisie metody <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Number/toFixed">toFixed</a>, która również odnosi się do metody <code>toExponential()</code>.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<pre>var num=77.1234; + +console.log("num.toExponential() is " + num.toExponential()); //wyświetla 7.71234e+1 +console.log("num.toExponential(4) is " + num.toExponential(4)); //wyświetla 7.7123e+1 +console.log("num.toExponential(2) is " + num.toExponential(2)); //wyświetla 7.71e+1 +console.log("77.1234.toExponential() is " + 77.1234.toExponential()); //wyświetla 7.71234e+1 +console.log("77 .toExponential() is " + 77 .toExponential()); //wyświetla 7.7e+1 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/tofixed/index.html b/files/pl/web/javascript/referencje/obiekty/number/tofixed/index.html new file mode 100644 index 0000000000..9394bf1db9 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/tofixed/index.html @@ -0,0 +1,61 @@ +--- +title: Number.prototype.toFixed() +slug: Web/JavaScript/Referencje/Obiekty/Number/toFixed +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Formatuje liczbę stosując notację stałoprzecinkową.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toFixed([<var>digits</var>])</code></pre> + +<h3 id="Parametr" name="Parametr">Parametr</h3> + +<dl> + <dt>digits</dt> + <dd>Liczba cyfr, które mają zostać wyświetlone po kropce dziesiętnej; może to być wartość z zakresu od 0 do 20 włącznie, ale implementacje mogą opcjonalnie wprowadzać większe zakresy. Jeśli argument zostanie pominięty, przyjmowana jest wartość 0.</dd> +</dl> + +<h3 id="Zwraca" name="Zwraca">Zwraca</h3> + +<p>Reprezentację wartości <code>number</code> w postaci łańcucha znaków, która nie stosuje notacji wykładniczej i posiada dokładnie tyle cyfr po separatorze dziesiętnym, ile wskazuje na to wartość parametru <code>digits</code>. Liczba w razie konieczności jest zaokrąglana, a część ułamkowa wypełniana zerami, aby liczba posiadała określoną długość. Jeśli liczba <code>number</code> jest większa niż 1e+21, metoda ta po prostu wywołuje {{jsxref("Number.prototype.toString()")}} i zwraca łańcuch znaków w notacji wykładniczej.</p> + +<h3 id="Wyrzuca" name="Wyrzuca">Wyrzuca</h3> + +<dl> + <dt>{{jsxref("Obiekty/RangeError", "RangeError")}}</dt> + <dd>Jeśli wartość parametru <code>digits</code> jest za duża lub za mała. Wartości z zakresu od 0 do 20 włącznie nie spowodują wystąpienia {{jsxref("Obiekty/RangeError", "RangeError")}}. Dopuszcza się na obsługę mniejszych lub większych wartości przez różne implementacje.</dd> +</dl> + +<dl> + <dt>{{jsxref("Obiekty/TypeError", "TypeError")}}</dt> + <dd>Jeśli ta metoda jest przywołana w obiekcie, który nie jest obiektem {{jsxref("Number")}}.</dd> +</dl> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<pre class="brush: js">var n = 12345.6789; + +n.toFixed(); // zwraca 12346: zauważ zaokrąglenie i brak części ułamkowej +n.toFixed(1); // zwraca 12345.7: zauważ zaokrąglenie +n.toFixed(6); // zwraca 12345.678900: zauważ dodane zera +(1.23e+20).toFixed(2); // zwraca 123000000000000000000.00 +(1.23e-10).toFixed(2) // zwraca 0.00 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/tolocalestring/index.html b/files/pl/web/javascript/referencje/obiekty/number/tolocalestring/index.html new file mode 100644 index 0000000000..6ca88bba30 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/tolocalestring/index.html @@ -0,0 +1,182 @@ +--- +title: Number.prototype.toLocaleString() +slug: Web/JavaScript/Referencje/Obiekty/Number/toLocaleString +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>toLocaleString()</code></strong> zwraca łańcuch znaków przedstawiający dany numer w formacie wybranej lokalizacji.</p> + +<p>Nowe argumenty - <code>lokalizacje</code> i <code>opcje</code> - pozwalają na wybranie lokalizacji w jakiej ma zostać przedstawiona liczba. Starsza implementacja, która nie posiadała tych argumentów, zwracała łańcuch znaków zależny od implementacji danego środowiska.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>numObj</em>.toLocaleString(</code><code>[lokalizacje [, opcje]])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<p>W sekcji <a href="#Browser_compatibility">kompatybilności</a> możesz sprawdzić, które przeglądarki obsługują argumenty <code>lokalizacji</code> i <code>opcji</code> . W sekcji <a href="#Checking_for_support_for_locales_and_options_arguments">Przykład: Sprawdzanie obsługi argumentów <code>lokalizacji</code> i <code>opcji</code> </a>rozpisane są sposoby na przetestowanie obsługiwanych przez przeglądarkę argumentów tej metody.</p> + +<div class="note"> +<p><strong>Info:</strong> ECMAScript Internationalization API, zaimplementowane w Firefoxie 29, dodaje obsługę parametry<code>lokalizacje</code> do metody<code>Number.toLocaleString()</code>. Jeśli argument nie zostanie podany ({{jsxref("undefined")}}) metoda przyjmię lokalizację systemu operacyjnego. Poprzednie wersje Firefoxa zwracały liczby z lokalizacji <a href="https://en.wikipedia.org/wiki/Arabic_numerals">Western Arabic</a>. Zmiana zostala zgłoszona jako regresja rzutująca na wsteczną kompatybilność metody, i wkrótce zostanie naprawiona. ({{bug(999003)}})</p> +</div> + +<div>{{page('/pl-PL/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat', 'Parameters')}}</div> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Łańcuch znaków przedstawiający liczbę w danym formacie.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Przykłady_użycia_metody_toLocaleString">Przykłady użycia metody <code>toLocaleString</code></h3> + +<p>Podstawowy sposób użycia, bez podanych argumentów, zwróci nam łańcuch znaków w domyślnej lokalizacji i z domyślnymi opcjami.</p> + +<pre class="brush: js">var liczba = 3500; + +console.log(liczba.toLocaleString()); // Wyświetli "3 500", jeśli twoją lokalizacją jest „pl-PL” +</pre> + +<h3 id="Sprawdzanie_dostępności_argumentów_lokalizacji_i_opcji">Sprawdzanie dostępności argumentów <code>lokalizacji</code> i <code>opcji</code></h3> + +<p>Nie wszystkie przeglądarki obsługuję argumenty <code>lokalizacji</code> i <code>opcji</code>. Aby to sprawdzić w wersji języka ES5.1 i późniejszych możemy użyć wyjątku {{jsxref("Global_Objects/RangeError", "RangeError")}}, który zostanie rzucony gdy niepoprawna nazwa lokalizacji zostanie użyta:</p> + +<pre class="brush: js">function toLocaleStringSupportsLocales() { + var liczba = 0; + try { + liczba.toLocaleString('i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<p>W wersjach przed ES5.1 nie było obowiązku wyrzucania wyjątku Range Error jeśli metoda <code>toLocaleString</code> została wywołana z argumentami.</p> + +<p>Sprawdzenie działające na wszystkich wersjach języka przed 5.1 polega na użyciu funkcjonalności niezbędnych do działania tych argumentów bezpośrednio na <code>Number.prototype.toLocaleString</code>:</p> + +<pre class="brush: js">function toLocaleStringSupportsOptions() { + return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function'); +} +</pre> + +<p>Sprawdzamy tutaj czy istnieje globalny obiekt <code>Intl</code>, czy nie jest <code>nullem</code>, a także czy posiada właściwość <code>NumberFormat</code>, która jest funkcją.</p> + +<h3 id="Przykłady_użycia_lokalizacji">Przykłady użycia <code>lokalizacji</code></h3> + +<p>Przykład ten pokazuje kilka różnych lokalizacji. Aby uzyskać foramt języka interfejsu użytkownika upewnij się, że podajesz tę lokalizację (i dla pewności kilka innych jako fallbacki) przy pomocy aargumentu <code>localizacji</code>:</p> + +<pre class="brush: js">var liczba = 123456.789; + +// Język niemiecki oddziela części dziesiętne przecinkiem, a tysiące kropką +console.log(liczba.toLocaleString('de-DE')); +// → 123.456,789 + +// W większości krajów arabskich używa cyfr <a href="https://en.wikipedia.org/wiki/Eastern_Arabic_numerals">Eastern Arabic</a> +console.log(liczba.toLocaleString('ar-EG')); +// → ١٢٣٤٥٦٫٧٨٩ + +// Indyjski używa separatorów tysięcy/lakh/crore +console.log(liczba.toLocaleString('en-IN')); +// → 1,23,456.789 + +// Klucz rozszerzeń „nu” pyta o system numeryczny, np. Chiński system dziesiętny +console.log(liczba.toLocaleString('zh-Hans-CN-u-nu-hanidec')); +// → 一二三,四五六.七八九 + +// jeśli masz zamiar użyć lokalizacji, która może nie być obsługiwana +// jak np. Balinese, zawsze dodaj drugi lokalizację, tutaj Indonezyjską +console.log(liczba.toLocaleString(['ban', 'id'])); +// → 123.456,789 +</pre> + +<h3 id="Przykłady_użycia_opcji">Przykłady użycia <code>opcji</code></h3> + +<p>Rezultaty metody<code>toLocaleString</code> mogą być dostosowywane przy pomocy argumentu <code>opcje</code>:</p> + +<pre class="brush: js">var liczba = 123456.789; + +// format walutowy +console.log(liczba.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' })); +// → 123.456,79 € + +// Japoński yen +console.log(liczba.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' })) +// → ￥123,457 + +// ogranicz wyświetlanie do 3 miejsc znaczących +console.log(liczba.toLocaleString('en-IN', { maximumSignificantDigits: 3 })); +// → 1,23,000 + +// Użyj domyślnego języka hosta z opcjami formatowania liczby +var num = 30000.65; +console.log(num.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2})); +// → "30,000.65" w języku angielskim lub +// → "30.000,65" w języku niemieckiem lub +// → "30 000,65" w języku francuskim +</pre> + +<h2 id="Wydajność">Wydajność</h2> + +<p>Jeśli zamierzasz formatować wiele liczb, lepiej użyć obiektu {{jsxref("NumberFormat")}} i formatować przy pomocy metody {{jsxref("NumberFormat.format")}}.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Pierwsza definicja. Zaimplementowane w JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.3', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Number.prototype.toLocaleString', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.toLocaleString")}}</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/toprecision/index.html b/files/pl/web/javascript/referencje/obiekty/number/toprecision/index.html new file mode 100644 index 0000000000..33d5c0f1ed --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/toprecision/index.html @@ -0,0 +1,56 @@ +--- +title: Number.prototype.toPrecision() +slug: Web/JavaScript/Referencje/Obiekty/Number/toPrecision +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision +--- +<p>{{jsref}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący dany obiekt Number z określoną dokładnością.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toPrecision([<var>precision</var>])</code></pre> + +<h3 id="Parametr" name="Parametr">Parametr</h3> + +<dl> + <dt>precision</dt> + <dd>Liczba całkowita określająca liczbę cyfr po kropce dziesiętnej.</dd> +</dl> + +<h3 id="Zwraca" name="Zwraca">Zwraca</h3> + +<p>Łańcuch znaków reprezentujący obiekt {{jsxref("Number")}} w notacji stałoprzecinkowej lub wykładniczej z zaokrągleniem do tylu ważnych cyfr, ile wskazuje wartość <code>precision</code>.</p> + +<p>Jeśli metoda <code>toPrecision()</code> zostanie użyta do literałów liczbowych, które nie posiadają wykładnika i kropki dziesiętnej, należy wstawić spację przed kropką poprzedzającą wywołanie metody, aby zapobiec zinterpretowaniu tej kropki jako kropki dziesiętnej.</p> + +<p>Jeśli argument <code>precision</code> zostanie pominięty, metoda zachowuje się jak {{jsxref("Number.prototype.toString()")}}.</p> + +<p>Jeśli liczba posiada więcej cyfr niż określono przez parametr <code>precision</code>, jest ona zaokrąglana do najbliższej liczby o ilości cyfr wskazanej przez wartość <code>precision</code>. Zobacz dyskusję na temat zaokrąglania w opisie metody {{jsxref("Number.prototype.toFixed()")}}, która również odnosi się do metody <code>toPrecision</code>.</p> + +<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2> + +<pre class="brush: js">var num=5.123456; + +console.log("num.toPrecision() is " + num.toPrecision()); //wyświetli 5.123456 +console.log("num.toPrecision(4) is " + num.toPrecision(4)); //wyświetli 5.123 +console.log("num.toPrecision(2) is " + num.toPrecision(2)); //wyświetli 5.1 +console.log("num.toPrecision(1) is " + num.toPrecision(1)); //wyświetli 5 +console.log("1250 .toPrecision(2) is " + 1250 .toPrecision(2)); //wyświetli 1.3e+3 +console.log("1250 .toPrecision(5) is " + 1250 .toPrecision(5)); //wyświetli 1250.0 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/number/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/number/tostring/index.html new file mode 100644 index 0000000000..cd29571aee --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/number/tostring/index.html @@ -0,0 +1,59 @@ +--- +title: Number.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/Number/toString +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący dany obiekt {{jsxref("Number")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toString([<var>radix</var>])</code></pre> + +<h3 id="Parametr" name="Parametr">Parametr</h3> + +<dl> + <dt>radix</dt> + <dd>Liczba całkowita z zakresu od 2 do 36 określająca podstawę użytą do reprezentacji wartości liczbowych.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt <code>Number</code> przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektów <code>Number</code> metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt w danej podstawie wyliczeń.</p> + +<p>Metoda toString przetwarza pierwszy podany argument i próbuje zwrócić reprezentację w postaci łańcucha znaków w określonej podstawie wyliczeń. Dla podstawy większej od 10 litery alfabetu wskazują liczby większe niż 9. Przykładowo dla liczb heksadecymalnych (podstawa 16) użyte zostaną litery od A do F.</p> + +<p>Jeśli jako argument <code>toString()</code> podano podstawę nie będącą w zakresie od 2 do 36, zostanie wywołany wyjątek.</p> + +<p>Jeśli podstawa nie została określona, JavaScript przyjmuje za podstawę wartość 10.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<pre class="brush: js language-js"><code class="language-js"><span class="token keyword">var</span> count <span class="token operator">=</span> <span class="token number">10</span><span class="token punctuation">;</span> + +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>count<span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // displays '10' +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token number">17</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // displays '17' +</span> +<span class="token keyword">var</span> x <span class="token operator">=</span> <span class="token number">6</span><span class="token punctuation">;</span> + +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>x<span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // displays '110' +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token number">254</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">16</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // displays 'fe' +</span> +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token operator">-</span><span class="token number">10</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // displays '-1010' +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token operator">-</span><span class="token number">0xff</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // displays '-11111111'</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/assign/index.html b/files/pl/web/javascript/referencje/obiekty/object/assign/index.html new file mode 100644 index 0000000000..81e764456a --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/assign/index.html @@ -0,0 +1,307 @@ +--- +title: Object.assign() +slug: Web/JavaScript/Referencje/Obiekty/Object/assign +translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>Object.assign()</code></strong> kopiuje wszystkie wartości wyliczalnych własnych właściwości z jednego lub więcej obiektów źródłowych do obiektu docelowego. Zwraca obiekt docelowy.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">Object.assign(<var>cel</var>, ...<var>zrodla</var>)</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>cel</code></dt> + <dd>Obiekt docelowy.</dd> + <dt><code>zrodla</code></dt> + <dd>Obiekt(y) żródłowe.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Obiekt docelowy.</p> + +<h2 id="Opis">Opis</h2> + +<p>Właściwości w obiekcie docelowym zostaną nadpisane właściwościami obiektów źródłowych, jeśli właściwości te mają takie same nazwy. Właściwości obiektów źródłowych występujących później na liście argumentów, podobnie, nadpiszą właściwości obiektów występujących wcześniej.</p> + +<p>Metoda <code>Object.assign()</code> jedynie kopiuje <em>wyliczalne</em> i <em>własne</em> właściwości z obiektów źródłowych do obiektu docelowego. Używa do tego <code>[[Get]]</code> na źródle oraz <code>[[Set]]</code> na obiekcie docelowym, więc wywołuje gettery i settery odpowiednich obiektów. Dlatego też mowa tu o <em>przypisaniu</em> właściwości, a nie o ich kopiowaniu czy tworzeniu nowych. Metoda ta może być więc nieodpowiednia do przyłączania nowych właściwości do prototypu, w przypadku gdy źródła przyłączenia zawierają gettery. Do kopiowania definicji właściwości, wliczając ich wyliczalność, do prototypów należy użyć {{jsxref("Object.getOwnPropertyDescriptor()")}} oraz {{jsxref("Object.defineProperty()")}}.</p> + +<p>Obie właściwości {{jsxref("String")}} jak i {{jsxref("Symbol")}} są kopiowane.</p> + +<p>W przypadku błędu, na przykład gdy wartość jest zabezpieczona przed zapisem, zostanie rzucony błąd {{jsxref("TypeError")}}, a obiekt docelowy może zostać zmieniony, jeśli jakieś właściwości zostały do niego dodane przed wystąpieniem błędu.</p> + +<p>Zauważ, że <code>Object.assign()</code> nie rzuci błędu, gdy źródłem jest {{jsxref("null")}} lub {{jsxref("undefined")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Klonowanie_obiektu">Klonowanie obiektu</h3> + +<pre class="brush: js">var obiekt = { a: 1 }; +var kopia = Object.assign({}, obiekt); +console.log(kopia); // { a: 1 } +</pre> + +<h3 id="Deep_Clone" name="Deep_Clone">Ostrzeżenie przed Głębokim Klonowaniem</h3> + +<p>W przypadku głębokiego klonowania musimy użyć innych sposóbów, ponieważ <code>Object.assign()</code> kopiuje jedynie wartości przechowywane we właściwościach. Jeżeli właściwość źródłowa jest referencją do obiektu, to skopiowana zostanie jedynie ta referencja (wówczas zarówno źródło jak i cel będą posiadać referencję do tego samego obiektu, a nie osobne kopie tych obiektów).</p> + +<pre><code>function test() { + 'use strict'; + + let obj1 = { a: 0 , b: { c: 0}}; // a: wartość, b: referencja, c: wartość + let obj2 = Object.assign({}, obj1); + console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}} + + obj1.a = 1; // zmiana wartości, dotyczy tylko obj1 + console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}} + console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}} + + obj2.a = 2; // zmiana wartości, dotyczy tylko obj2 + console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}} + console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 0}} + + obj2.b.c = 3; // zmiana wartości w obiekcie o współdzielonej referencji + console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 3}} // teraz b.c == 3 + console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 3}} // i tu też b.c == 3, bo obj1.b === obj2.b + + // Klonowanie głębokie + obj1 = { a: 0 , b: { c: 0}}; + let obj3 = JSON.parse(JSON.stringify(obj1)); + obj1.a = 4; + obj1.b.c = 4; + console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}} // obj1.b !== obj2.b +} + +test();</code></pre> + +<h3 id="Łączenie_obiektów">Łączenie obiektów</h3> + +<pre class="brush: js">var o1 = { a: 1 }; +var o2 = { b: 2 }; +var o3 = { c: 3 }; + +var obj = Object.assign(o1, o2, o3); +console.log(obj); // { a: 1, b: 2, c: 3 } +console.log(o1); // { a: 1, b: 2, c: 3 }, sam obiekt docelowy został zmieniony.</pre> + +<h3 id="Łączenie_obiektów_z_tymi_samymi_właściowściami">Łączenie obiektów z tymi samymi właściowściami</h3> + +<pre class="brush: js">var o1 = { a: 1, b: 1, c: 1 }; +var o2 = { b: 2, c: 2 }; +var o3 = { c: 3 }; + +var obj = Object.assign({}, o1, o2, o3); +console.log(obj); // { a: 1, b: 2, c: 3 }</pre> + +<p>Właściwość jest nadpisywana przez ostatni obiekt w liście parametrów, który ma taką samą właściwość.</p> + +<h3 id="Kopiowanie_właściwości-symboli">Kopiowanie właściwości-symboli</h3> + +<pre class="brush: js">var o1 = { a: 1 }; +var o2 = { [Symbol('foo')]: 2 }; + +var obj = Object.assign({}, o1, o2); +console.log(obj); // { a : 1, [Symbol("foo")]: 2 } (cf. bug 1207182 on Firefox) +Object.getOwnPropertySymbols(obj); // [Symbol(foo)] +</pre> + +<h3 id="Właściwości_nieprzeliczalne_oraz_te_z_łańcucha_prototypów_nie_są_kopiowane">Właściwości nieprzeliczalne oraz te z łańcucha prototypów nie są kopiowane</h3> + +<pre class="brush: js">var obj = Object.create({ foo: 1 }, { // foo jest właściwością prototypu obiektu obj + bar: { + value: 2 // bar jest nieprzeliczalną właściwością + }, + baz: { + value: 3, + enumerable: true // baz jest własną, przeliczalną właściwością obiektu obj + } +}); + +var kopia = Object.assign({}, obj); +console.log(kopia); // { baz: 3 } +</pre> + +<h3 id="Wartości_podstawowe_zostaną_włożone_do_ich_wrapperów">Wartości podstawowe zostaną włożone do ich wrapperów</h3> + +<pre class="brush: js">var v1 = 'abc'; +var v2 = true; +var v3 = 10; +var v4 = Symbol('foo'); + +var obj = Object.assign({}, v1, null, v2, undefined, v3, v4); +// Wartości podstawowe będą we wrapperach, null i undefined zostaną zignorowane. +// Zauważ, że jedynie wrapper string'a ma przeliczalne właściwości: +console.log(obj); // { "0": "a", "1": "b", "2": "c" } +</pre> + +<h3 id="Wyjątki_przerwą_wykonywanie_kopiowania">Wyjątki przerwą wykonywanie kopiowania</h3> + +<pre class="brush: js">var cel = Object.defineProperty({}, 'foo', { + value: 1, + writable: false +}); // cel.foo jest właściwością tylko do odczytu + +Object.assign(cel, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 }); +// TypeError: "foo" is read-only +// Wyjątek został wyrzucony podczas próby zapisania cel.foo + +console.log(cel.bar); // 2, pierwsze źródło zostało skopiowane pomyślnie +console.log(cel.foo2); // 3, pierwsza właściwość drugiego źródła zostało skopiowana pomyślnie +console.log(cel.foo); // 1, tutaj został wyrzucony wyjątek +console.log(cel.foo3); // undefined, kopiowanie dobiegło końca, foo3 nie zostanie skopiowane +console.log(cel.baz); // undefined, trzecie źródło również nie zostanie skopiowane +</pre> + +<h3 id="Kopiowanie_operatorów_pamięci">Kopiowanie operatorów pamięci</h3> + +<pre class="brush: js">var obj = { + foo: 1, + get bar() { + return 2; + } +}; + +var kopia = Object.assign({}, obj); +console.log(kopia); +// { foo: 1, bar: 2 }, wartość kopia.bar jest wartością zwracaną przez metodę getter właściwości obj.bar + +// Funkcja przypisania kopiująca całe deskryptory: +function completeAssign(cel, ...zrodla) { + zrodla.forEach(zrodlo => { + let deskryptory = Object.keys(zrodlo).reduce((deskryptory, klucz) => { + deskryptory[klucz] = Object.getOwnPropertyDescriptor(zrodlo, klucz); + return deskryptory; + }, {}); + // domyślnie Object.assign kopiuje również przeliczalne symbole + Object.getOwnPropertySymbols(zrodlo).forEach(sym => { + let deskryptor = Object.getOwnPropertyDescriptor(zrodlo, sym); + if (deskryptor.enumerable) { + deskryptory[sym] = deskryptor; + } + }); + Object.defineProperties(cel, deskryptory); + }); + return target; +} + +var kopia = completeAssign({}, obj); +console.log(kopia); +// { foo:1, get bar() { return 2 } } +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Ten {{Glossary("Polyfill","polyfill")}} nie wspiera właściwości-symboli, ponieważ ES5 i tak ich nie ma.</p> + +<pre class="brush: js">if (typeof Object.assign != 'function') { + Object.assign = function(target, varArgs) { // .length of function is 2 + 'use strict'; + if (target == null) { // TypeError if undefined or null + throw new TypeError('Cannot convert undefined or null to object'); + } + + var to = Object(target); + + for (var index = 1; index < arguments.length; index++) { + var nextSource = arguments[index]; + + if (nextSource != null) { // Skip over if undefined or null + for (var nextKey in nextSource) { + // Avoid bugs when hasOwnProperty is shadowed + if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) { + to[nextKey] = nextSource[nextKey]; + } + } + } + } + return to; + }; +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-object.assign', 'Object.assign')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.assign', 'Object.assign')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Edge</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("45")}}</td> + <td>{{CompatGeckoDesktop("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatOpera("32")}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("45")}}</td> + <td>{{CompatGeckoMobile("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Object.defineProperties()")}}</li> + <li><a href="/pl/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Przeliczalność i własność właściwości</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/constructor/index.html b/files/pl/web/javascript/referencje/obiekty/object/constructor/index.html new file mode 100644 index 0000000000..3de20f1350 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/constructor/index.html @@ -0,0 +1,49 @@ +--- +title: Object.prototype.constructor +slug: Web/JavaScript/Referencje/Obiekty/Object/constructor +tags: + - JavaScript + - Object + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Object/constructor +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Określa funkcję tworzącą prototyp obiektu. Należy pamiętać, że wartość tej własności jest referencją do funkcji, a nie łańcuchem znaków zawierającym jej nazwę.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wszystkie obiekty dziedziczą własność <code>constructor</code> z ich prototypu (<code>prototype</code>):</p> + +<pre class="brush: js">var o = {}; +o.constructor === Object; // true + +var a = []; +a.constructor === Array; // true + +var n = new Number(3); +n.constructor === Number; // true +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_konstruktora_obiektu" name="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_konstruktora_obiektu">Przykład: Wyświetlanie konstruktora obiektu</h3> + +<p>Poniższy przykład tworzy prototyp, <code>Drzewo</code> i obiekt tego typu <code>sosna</code>. Następnie wyświetlana jest własność <code>constructor</code> obiektu <code>Drzewo</code>.</p> + +<pre class="brush: js">function Drzewo(nazwa) { + this.nazwa=nazwa; +} + +sosna = new Drzewo("sosna"); +console.log("sosna.constructor to " + sosna.constructor) +</pre> + +<p>Przykład ten wyświetla:</p> + +<pre>sosna.constructor to function Drzewo(nazwa) { + this.nazwa = nazwa; +} +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/object/eval/index.html b/files/pl/web/javascript/referencje/obiekty/object/eval/index.html new file mode 100644 index 0000000000..7f8b355d65 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/eval/index.html @@ -0,0 +1,64 @@ +--- +title: Object.prototype.eval() +slug: Web/JavaScript/Referencje/Obiekty/Object/eval +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/JavaScript/Object.eval +--- +<p>{{ Deprecated_header() }}</p> + +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> + +<p>Metoda przestarzała. Wykonuje kod JavaScriptu zawarty w łańcuchu znaków w kontekście danego obiektu.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header" colspan="2">Metoda obiektu: <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Object">Object</a></td> + </tr> + <tr> + <td>Zaimplementowana w:</td> + <td>JavaScript 1.1, NES2.0 + <p>JavaScript 1.2, NES 3.0: przestarzała jako metoda obiektów, pozostawiona jako funkcja najwyższego poziomu.</p> + + <p>JavaScript 1.4: usunięta jako metoda obiektów.</p> + </td> + </tr> + </tbody> +</table> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<p><code>eval( + <i>łańcuch znaków</i> + ) </code></p> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>łańcuch znaków</code> </dt> + <dd>dowolny łańcuch znaków reprezentujący wyrażenie, polecenie lub sekwencję poleceń JavaScriptu. Wyrażenie może zawierać zmienne i własności istniejących obiektów.</dd> +</dl> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Metoda <code>eval</code> nie jest już dostępna jako metoda obiektu <code>Object</code>. Należy używać funkcji najwyższego rzędu <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/eval">eval</a></code>.</p> + +<h3 id="Zgodno.C5.9B.C4.87_wsteczna" name="Zgodno.C5.9B.C4.87_wsteczna">Zgodność wsteczna</h3> + +<h4 id="JavaScript_1.2_i_1.3" name="JavaScript_1.2_i_1.3">JavaScript 1.2 i 1.3</h4> + +<p><code>eval</code> jako metoda obiektu <code>Object</code> i każdego obiektu dziedziczącego po <code>Object</code> jest przestarzała (ale nadal dostępna).</p> + +<h4 id="JavaScript_1.1" name="JavaScript_1.1">JavaScript 1.1</h4> + +<p><code>eval</code> jest dostępna jako metoda obiektu <code>Object</code> i każdego obiektu dziedziczącego po <code>Object</code>.</p> + +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3> + +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/eval">eval</a></code></p> + +<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Object/eval", "ja": "ja/Core_JavaScript_1.5_Reference/Global_Objects/Object/eval" } ) }}</p> diff --git a/files/pl/web/javascript/referencje/obiekty/object/freeze/index.html b/files/pl/web/javascript/referencje/obiekty/object/freeze/index.html new file mode 100644 index 0000000000..73e0139f31 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/freeze/index.html @@ -0,0 +1,201 @@ +--- +title: Object.freeze() +slug: Web/JavaScript/Referencje/Obiekty/Object/freeze +translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze +--- +<div>{{JSRef}}</div> + +<div>Metoda <code><strong>Object.freeze()</strong> </code>"zamraża" obiekt, tzn. uniemożliwia dodawania nowych właściwości do obiektu; uniemożliwia usuwanie istniejących właściwości; uniemożliwia zmianę istniejących właściwości; oraz uniemożliwia zmianę prototypu obiektu. W efekcie obiekt jest naprawdę stały. Metoda zwraca obiekt w stanie "zamrożonym".</div> + +<div> </div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Object.freeze(<var>obj</var>)</code></pre> + +<h3 id="Argumenty">Argumenty</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Obiekt który ma zostać "zamrożony".</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>"Zamrożony" obiekt.</p> + +<h2 id="Opis">Opis</h2> + +<p>Nic nie może zostać dodane ani usunięte z "zamrożonego" obiektu. Każda próba tego wywoła błąd, albo po cichu, albo rzucając wyjątek {{jsxref("TypeError")}}(zawzwyczaj, choć nie zawsze, w przypadku używania {{jsxref("Strict_mode", "strict mode", "", 1)}}).</p> + +<p>Nie ma możliwości zmiany wartości właściwości obiektu. Metody dostępu (gettery i settery) działają bez zmian (sprawiają wrażenie skutecznej zmiany właściwości obiektu). Zwróć uwagę na to, że wartości, które są obiektami w dalszym ciągu mogą być modyfikowane, chyba że również są "zamrożone". Z uwagi na to, że Tablica (Array) jest obiektem, również może zostać zamrożona co uniemożliwi zmianę jej elementów, ich usuwanie oraz dodawanie nowych. </p> + +<h2 id="Przykłady">Przykłady</h2> + +<p> </p> + +<h3 id="Zamrażanie_Obiektów">Zamrażanie Obiektów</h3> + +<p> </p> + +<pre class="brush: js">var obj = { + prop: function() {}, + foo: 'bar' +}; + +// Nowe właściwości mogą być dodawane, istniejące mogą być zmieniane oraz usuwane +obj.foo = 'baz'; +obj.lumpy = 'woof'; +delete obj.prop; + +// Zarówno obiekt przekazywany w funkcji freeze() jak i obiekt zwracany bedą "zamrożone" +// Nie ma potrzeby przypisywania zwracanego obiektu do zmiennej jeśli chcemy tylko "zamrozić" obiekt przekazywany w funkcji +var o = Object.freeze(obj); + +o === obj; // true +Object.isFrozen(obj); // === true + +// Teraz wszelkie zmiany są niemożliwe +obj.foo = 'quux'; // brak rezultatu nieskutkujący wyświetleniem błędu +obj.quaxxor = 'the friendly duck'; // brak rezultatu nieskutkujący wyświetleniem błędu + +// przy strict mode tego typu próby spowodują wyświetlenie komunikatu o błędzie +function fail(){ + 'use strict'; + obj.foo = 'sparky'; // TypeError + delete obj.quaxxor; // TypeError + obj.sparky = 'arf'; // TypeError +} + +fail(); + +// Próby zmian poprzez Object.defineProperty spowodują wyświetlenie komunikatu o błędzie +Object.defineProperty(obj, 'ohai', { value: 17 }); // TypeError +Object.defineProperty(obj, 'foo', { value: 'eit' }); // TypeError + +// Niemożliwa jest również zmiana prototypu obiektu. Obie instrukcje poniżej wygenerują błąd +Object.setPrototypeOf(obj, { x: 20}) +obj.__proto__ = { x: 20} +</pre> + +<h3 id="Zamrażanie_Tablic_(Array)">Zamrażanie Tablic (Array)</h3> + +<p> </p> + +<pre class="brush: js"><code>let a = [0]; +Object.freeze(a); // Tablica nie może być teraz modyfikowana + +a[0]=1; // brak rezultatu nieskutkujący wyświetleniem błędu +a.push(2); // brak rezultatu nieskutkujący wyświetleniem błędu + +// </code>przy strict mode tego typu próby spowodują wyświetlenie komunikatu o błędzie<code> TypeErrors +function fail() { + "use strict" + a[0] = 1; + a.push(2); +} + +fail();</code></pre> + +<p>"Zamrożony" obiekt jest <em>niemutowalny</em>. Nie jest on jednak <em>stałą</em>. Obrazuje to poniższy przykład.</p> + +<pre class="brush: js"><code>obj1 = { + internal: {} +}; + +Object.freeze(obj1); +obj1.internal.a = 'aValue'; + +obj1.internal.a // 'aValue'</code> +</pre> + +<p> </p> + +<p>To be a constant object, the entire reference graph (direct and indirect references to other objects) must reference only immutable frozen objects. The object being frozen is said to be immutable because the entire object <em>state </em>(values and references to other objects) within the whole object is fixed. Note that strings, numbers, and booleans are always immutable and that Functions and Arrays are objects. </p> + +<p>To make an object constant, recursively freeze each property which is of type object (deep freeze). Use the pattern on a case-by-case basis based on your design when you know the object contains no <em><a href="https://en.wikipedia.org/wiki/Cycle_(graph_theory)">cycles</a> </em>in the reference graph, otherwise an endless loop will be triggered. An enhancement to deepFreeze() would be to have an internal function that receives a path (e.g. an Array) argument so you can supress calling deepFreeze() recursively when an object is in the process of being made constant. You still run a risk of freezing an object that shouldn't be frozen, such as [window].</p> + +<pre class="brush: js"><code>// To do so, we use this function. +function deepFreeze(obj) { + + // Retrieve the property names defined on obj + var propNames = Object.getOwnPropertyNames(obj); + + // Freeze properties before freezing self + propNames.forEach(function(name) { + var prop = obj[name]; + + // Freeze prop if it is an object + if (typeof prop == 'object' && prop !== null) + deepFreeze(prop); + }); + + // Freeze self (no-op if already frozen) + return Object.freeze(obj); +} + +obj2 = { + internal: {} +}; + +deepFreeze(obj2); +obj2.internal.a = 'anotherValue'; +obj2.internal.a; // unde</code></pre> + +<p> </p> + +<p> </p> + +<h2 id="Notes">Notes</h2> + +<p>In ES5, if the argument to this method is not an object (a primitive), then it will cause a {{jsxref("TypeError")}}. In ES2015, a non-object argument will be treated as if it were a frozen ordinary object, and be simply returned.</p> + +<pre class="brush: js">> Object.freeze(1) +TypeError: 1 is not an object // ES5 code + +> Object.freeze(1) +1 // ES2015 code +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.9', 'Object.freeze')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-object.freeze', 'Object.freeze')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.freeze', 'Object.freeze')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> +<p>{{Compat("javascript.builtins.Object.freeze")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Object.isFrozen()")}}</li> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> + <li>{{jsxref("Object.seal()")}}</li> + <li>{{jsxref("Object.isSealed()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/getownpropertydescriptor/index.html b/files/pl/web/javascript/referencje/obiekty/object/getownpropertydescriptor/index.html new file mode 100644 index 0000000000..3f9498b26e --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/getownpropertydescriptor/index.html @@ -0,0 +1,121 @@ +--- +title: Object.getOwnPropertyDescriptor() +slug: Web/JavaScript/Referencje/Obiekty/Object/getOwnPropertyDescriptor +translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>Object.getOwnPropertyDescriptor()</strong></code> zwraca deskryptor definiujący stan właściwości (właściwość musi być zdefiniowana bezpośrednio na obiekcie, ponieważ metoda nie sprawdza właściwości w łańcuchu prototypów obiektu) dla podanego obiektu.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Object.getOwnPropertyDescriptor(<var>obj</var>, <var>prop</var>)</code></pre> + +<h3 id="Argumenty">Argumenty</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Obiekt, w którym będzie poszukiwana właściwość.</dd> + <dt><code>prop</code></dt> + <dd>Nazwa właściwości, dla której będzie pobrany deskryptor.</dd> +</dl> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p>Jeżeli obiekt posiada podaną właściwość, wówczas zostanie zwrócony jej deskryptor, w przeciwnym razie zostanie zwrócony {{jsxref("undefined")}}.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda ta pozwala na dokładne zbadanie stanu właściwości. W rzeczywistości właściwość obiektu w JavaScript to nie tylko jej nazwa oraz wartość ale również odpowiadający jej deskryptor. Więcej informacji o atrybutach deskryptora można znaleźć w {{jsxref("Object.defineProperty()")}}.</p> + +<p>Deskryptor właściwości jest obiektem zawierającym poniższe atrybuty:</p> + +<dl> + <dt><code>value</code></dt> + <dd>Wartość związana z odpowiadającą właściwością (tylko dla deskryptorów danych).</dd> + <dt><code><strong>writable</strong></code></dt> + <dd>Jeżeli <code>true</code> odpowiadająca wartość właściwości może być zmieniona (tylko dla deskryptorów danych).</dd> + <dt><code>get</code></dt> + <dd>Funkcja, która zwraca getter dla odpowiadającej właściwości lub {{jsxref("undefined")}} jeżeli getter nie występuje (tylko dla deskryptorów dostępowych).</dd> + <dt><code>set</code></dt> + <dd>Funkcja, która zwraca setter dla odpowiadającej właściwości lub {{jsxref("undefined")}} jeżeli setter nie występuje (tylko dla deskryptorów dostępowych).</dd> + <dt><code>configurable</code></dt> + <dd>Jeżeli <code>true</code> odpowiadająca wartość właściwości może być zmieniona (również ich rodzaj - z właściwości danych na właściwość funkcji dostępowych, i odwrotnie) oraz usunięta z odopowiadającego obiektu.</dd> + <dt><code>enumerable</code></dt> + <dd>Jeżeli <code>true</code> odpowiadająca wartość właściwości będzie dostępna podczas iteracji po właściwosciach odpowiadającego obiektu.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">var o, d; + +o = { get foo() { return 17; } }; +d = Object.getOwnPropertyDescriptor(o, 'foo'); +// d is { configurable: true, enumerable: true, get: /*the getter function*/, set: undefined } + +o = { bar: 42 }; +d = Object.getOwnPropertyDescriptor(o, 'bar'); +// d is { configurable: true, enumerable: true, value: 42, writable: true } + +o = {}; +Object.defineProperty(o, 'baz', { value: 8675309, writable: false, enumerable: false }); +d = Object.getOwnPropertyDescriptor(o, 'baz'); +// d is { value: 8675309, writable: false, enumerable: false, configurable: false } +</pre> + +<h2 id="Uwagi">Uwagi</h2> + +<p>W ES5, jeżeli pierwszy argument dla podanej metody nie jest obiektem (jest typem prostym), wówczas zostanie wyrzucony wyjątek {{jsxref("TypeError")}}. Natomiast w ES2015, na typie prymitywnym najpierw zostanie wykonana koercja do obiektu.</p> + +<pre class="brush: js">Object.getOwnPropertyDescriptor('foo', 0); +// TypeError: "foo" is not an object // ES5 code + +Object.getOwnPropertyDescriptor('foo', 0); +// {configurable:false, enumerable:true, value:"f", writable:false} // ES2015 code +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.3', 'Object.getOwnPropertyDescriptor')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarkowa">Kompatybilność przeglądarkowa</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Object.getOwnPropertyDescriptor")}}</p> +</div> +</div> + +<p> </p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/hasownproperty/index.html b/files/pl/web/javascript/referencje/obiekty/object/hasownproperty/index.html new file mode 100644 index 0000000000..42bb16783b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/hasownproperty/index.html @@ -0,0 +1,150 @@ +--- +title: Object.prototype.hasOwnProperty() +slug: Web/JavaScript/Referencje/Obiekty/Object/hasOwnProperty +translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty +--- +<div>{{JSRef("Global_Objects", "Object")}}</div> + +<h2 id="Summary" name="Summary">Wstęp</h2> + +<p>Metoda <code><strong>hasOwnProperty()</strong></code> zwraca wartość <code>true</code> jeśli obiekt, na którym została wywołana posiada konkretną własność.</p> + +<h2 id="Syntax" name="Syntax">Składnia</h2> + +<pre class="syntaxbox notranslate"><code><var>obj</var>.hasOwnProperty(<var>prop</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parametry</h3> + +<dl> + <dt><code>prop</code></dt> + <dd>Nazwa ({{jsxref("String")}}) własności lub <a href="https://developer.mozilla.org/en-US/docs/Glossary/Symbol">Symbol</a>, do sprawdzenia.</dd> +</dl> + +<h3 id="Wartość_zwracana">Wartość zwracana</h3> + +<p><span class="tlid-translation translation"><span class="alt-edited">A {{jsxref ("Boolean")}} wskazujący, czy obiekt zawiera w sobie określoną właściwość.</span></span></p> + +<h2 id="Description" name="Description">Opis</h2> + +<p>Każdy obiekt pochodzący od {{jsxref("Global_Objects/Object", "Object")}} dziedziczy metodę <code>hasOwnProperty</code>. Może być ona użyta do stwierdzenia czy obiekt posiada określoną własność, jako bezpośrednią (direct) własność. W przeciwieństwie do operatora {{jsxref("Operators/in", "in")}}, metoda <code style="font-style: normal;">hasOwnProperty</code> nie sprawdza <u>w głąb łańcucha</u> własności obiektu.</p> + +<h2 id="Examples" name="Examples">Notatka</h2> + +<p><span class="tlid-translation translation"><span title=""><code>hasOwnProperty</code> zwraca <code>true</code>, nawet jeśli wartość właściwości to <code>null</code> lub <code>undefined</code>.</span></span></p> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">o <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Object</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +o<span class="punctuation token">.</span>propOne <span class="operator token">=</span> <span class="keyword token">null</span><span class="punctuation token">;</span> +o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'propOne'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// zwraca true</span> +o<span class="punctuation token">.</span>propTwo <span class="operator token">=</span> undefined<span class="punctuation token">;</span> +o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'propTwo'</span><span class="punctuation token">)</span><span class="punctuation token">; // zwraca true</span></code> +</pre> + +<h2 id="Examples" name="Examples">Przykłady</h2> + +<h3 id="Example_Using_hasOwnProperty_to_test_for_a_property.27s_existence" name="Example:_Using_hasOwnProperty_to_test_for_a_property.27s_existence">Użycie <code>hasOwnProperty</code> do testowania istnienia własności</h3> + +<p>Poniższy przykład określa czy obiekt <code>o</code> posiada własność o nazwie <code>prop</code>:</p> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">o <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Object</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'prop'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// zwraca false</span> +o<span class="punctuation token">.</span>prop <span class="operator token">=</span> <span class="string token">'istnieje'</span><span class="punctuation token">;</span> +o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'prop'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// zwraca true</span></code></pre> + +<h3 id="Example_Direct_versus_inherited_properties" name="Example:_Direct_versus_inherited_properties">Własności bezpośrednie kontra odziedziczone</h3> + +<p>Poniższy przykład rozróżnia bezpośrednie właściwości z właściwościami dziedziczonymi w łańcuchu prototypów:</p> + +<pre class="brush: js notranslate">o = new Object(); +o.prop = 'istnieje'; +o.hasOwnProperty('prop'); // zwraca true +o.hasOwnProperty('toString'); // zwraca false +o.hasOwnProperty('hasOwnProperty'); // zwraca false +</pre> + +<h3 id="Example_Itarate_over_properties_not_considering_inherited_properties" name="Example:_Itarate_over_properties_not_considering_inherited_properties">Iterowanie przez właściwości obiektu</h3> + +<p><span class="tlid-translation translation"><span title="">Poniższy przykład ilustruje sposób iteracji po właściwościach obiektu bez wykonywania iteracji na dziedziczonych właściwościach.</span></span></p> + +<pre class="notranslate">const obj = { + prop: 'Wartość', + secondProp: 'Wartość 2' +} + +for (const name in obj) { + if (obj.hasOwnProperty(name)) { + console.log('Znaleziono własność ' + name + ' o wartości ' + obj[name]) + } else { + console.log('Brak własności: ', name) + } +}</pre> + +<div class="blockIndicator warning"> +<p><span class="tlid-translation translation"><span title="">Zwróć uwagę, że pętla </span></span>{{jsxref("Statements/for...in", "for...in")}}<span class="tlid-translation translation"><span title=""> tylko iteruje właściwości przeliczalne</span></span>, a <a href="http://zduck.com/2013/non-enumerable-properties-in-javascript/">nieprzeliczanych</a> nie zauważa.</p> +</div> + +<h3 id="Używanie_hasOwnProperty_jako_nazwy_właściwości"><span class="tlid-translation translation"><span title="">Używanie <code>hasOwnProperty</code> jako nazwy właściwości</span></span></h3> + +<p><span class="tlid-translation translation"><span title="">JavaScript nie chroni nazwy właściwości <code>hasOwnProperty</code>;</span> <span title="">tak więc, jeśli istnieje możliwość, że obiekt może mieć właściwość o tej nazwie, konieczne jest użycie zewnętrznej właściwości <code>hasOwnProperty</code>, aby uzyskać poprawne wyniki:</span></span></p> + +<pre class="brush: js notranslate">const obj = { + hasOwnProperty: function() { + return false; + }, + prop: 'Kolejna właściwość' +}; + +obj.hasOwnProperty('prop'); // zawsze zwróci false + +// <span class="tlid-translation translation"><span class="alt-edited">Użyj właściwości hasOwnProperty innego obiektu i wywołaj ją, ustawiając "this" na obj</span></span> +({}).hasOwnProperty.call(obj, 'prop'); // zwraca true + +// <span class="tlid-translation translation"><span title="">W tym celu można również użyć własności hasOwnProperty z prototypu Object</span></span> +Object.prototype.hasOwnProperty.call(obj, 'prop'); // zwraca true +</pre> + +<p><span class="tlid-translation translation"><span title="">Zwróć uwagę, że w ostatnim przypadku nie ma żadnych nowo utworzonych obiektów.</span></span></p> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 3rd Edition.</td> + <td>Standard</td> + <td>Initial definition. Implemented in JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.4.5', 'Object.prototype.hasOwnProperty')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div class="hidden"> +<p><span class="tlid-translation translation"><span title="">Tabela zgodności na tej stronie jest generowana na podstawie danych strukturalnych.</span> <span title="">Jeśli chcesz przyczynić się do danych, sprawdź <a href="/pl/docs/">https://github.com/mdn/browser-compat-data</a> i wyślij nam pull request'a.</span></span></p> +</div> + +<div>{{Compat("javascript.builtins.Object.hasOwnProperty")}}</div> + +<h2 id="See_also" name="See_also">Zobacz także</h2> + +<ul> + <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li> + <li>{{jsxref("Object.getOwnPropertyNames()")}}</li> + <li>{{jsxref("Statements/for...in", "for...in")}}</li> + <li>{{jsxref("Operators/in", "in")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_Revisited">JavaScript Guide: Inheritance revisited</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/index.html b/files/pl/web/javascript/referencje/obiekty/object/index.html new file mode 100644 index 0000000000..88ed5060cb --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/index.html @@ -0,0 +1,212 @@ +--- +title: Object +slug: Web/JavaScript/Referencje/Obiekty/Object +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Object +--- +<div>{{JSRef}}</div> + +<p>Konstruktor <strong>Object</strong> tworzy wrapper obiektu.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia</h2> + +<pre class="syntaxbox"><code>// Notacja literałowa +{ [ <var>paraWartoscNazwa1</var>[, <var>paraWartoscNazwa2</var>[, ...<var>paraWartoscNazwaN</var>] ] ] } + +// Wywoływany jako konstruktor +new Object([<var>wartosc</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code><var>paraWartoscNazwa1</var>, <var>paraWartoscNazwa2</var>, ... <var>paraWartoscNazwaN</var></code></dt> + <dd>Pary nazw (string) oraz wartości (jakakolwiek wartość) przyczym nazwa oddzielona jest od wartości dwukropkiem.</dd> + <dt><code><var>wartosc</var></code></dt> + <dd>Jakakolwiek wartość.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Kostruktor obiektu tworzy wrapper dla danej wartości. Jeżeli podana wartość to {{jsxref("null")}} albo {{jsxref("undefined")}}, konstruktor stworzy i zwróci pusty obiekt. W przeciwnym razie stworzy i zwróci obiekt o takim samym typie jak podana wartość. Jeżeli podana wartość jest obiektem to konstruktor zwróci ten właśnie obiekt.</p> + +<p>Zobacz również <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">Inicjator obiektu / notacja literałowa</a>.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Właściwości</h2> + +<dl> + <dt><code>Object.length</code></dt> + <dd>Przyjmuje wartość 1.</dd> + <dt>{{jsxref("Object.prototype")}}</dt> + <dd>Pozwala na dodawanie właściwości i metod do wszystkich obiektów typu Object.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Object.assign()")}}</dt> + <dd>Kopiuje wszystkie <strong>własne </strong>właściwości z jednego lub więcej obiektów żródłowych do obiektu docelowego.</dd> + <dt>{{jsxref("Object.create()")}}</dt> + <dd>Tworzy nowy obiekt z podanym prototypem oraz właściwościami</dd> + <dt>{{jsxref("Object.defineProperty()")}}</dt> + <dd>Dodaje do obiektu wymienioną właściwość opisywaną przez podany deskryptor.</dd> + <dt>{{jsxref("Object.defineProperties()")}}</dt> + <dd>Dodaje do obiektu wymienione właściwości opisywane przez podane deskryptory.</dd> + <dt>{{jsxref("Object.freeze()")}}</dt> + <dd>Zamraża obiekt. Uniemożliwia usuwanie oraz modyfikowanie jego właściwości.</dd> + <dt>{{jsxref("Object.getOwnPropertyDescriptor()")}}</dt> + <dd>Zwraca z obiektu deskryptor dla wymienionej właściwości. </dd> + <dt>{{jsxref("Object.getOwnPropertyNames()")}}</dt> + <dd>Zwraca tablicę zawierającą nazwy wszystkich <strong>własnych</strong> właściwości obiektu. (Zarówno przeliczalnych jak i nieprzeliczalnych)</dd> + <dt>{{jsxref("Object.getOwnPropertySymbols()")}}</dt> + <dd>Zwraca tablicę zawierającą wszystkie <strong>własne</strong> właściwości-symbole danego obiektu</dd> + <dt>{{jsxref("Object.getPrototypeOf()")}}</dt> + <dd>Zwraca prototyp określonego obiektu.</dd> + <dt>{{jsxref("Object.is()")}}</dt> + <dd>Sprawdza czy dwie podane wartości są takie same.</dd> + <dt>{{jsxref("Object.isExtensible()")}}</dt> + <dd>Sprawdza czy obiekt można rozszerzyć.</dd> + <dt>{{jsxref("Object.isFrozen()")}}</dt> + <dd>Sprawdza czy obiekt jest zamrożony.</dd> + <dt>{{jsxref("Object.isSealed()")}}</dt> + <dd>Sprawdza czy obiekt jest zapieczętowany.</dd> + <dt>{{jsxref("Object.keys()")}}</dt> + <dd>Zwraca tablicę zawierającą nazwy wszystkich <strong>własnych</strong> właściwości obiektu. (Tylko przeliczalnych)</dd> + <dt>{{jsxref("Object.preventExtensions()")}}</dt> + <dd>Zabopiega rozszerzaniu obiektu (tj. dodawaniu właściwości).</dd> + <dt>{{jsxref("Object.seal()")}}</dt> + <dd>Zapieczętowuje obiekt, zapobiegając dodawaniu oraz usuwaniu jego właściwości.</dd> + <dt>{{jsxref("Object.setPrototypeOf()")}}</dt> + <dd>Ustawia prototyp obiektu.</dd> + <dt>{{jsxref("Object.values()")}} {{experimental_inline}}</dt> + <dd>Zwraca tablicę zawierającą wszystkie <strong>własne</strong>, przeliczalne wartości obiektu.</dd> +</dl> + +<h2 id="Instancje_i_prototyp_Object">Instancje i prototyp <code>Object</code></h2> + +<p>W Javascript, wsyzstkie obiekty pochodzą od obiektu <code>Object</code>, tymsamym dziedziczą metody i właściwości z {{jsxref("Object.prototype")}}, jednak mogą być one nadpisane. Na przykład, prototypy innych konstruktorów nadpisują właściwość <code>constructor</code> oraz metody <code>toString</code><code>()</code>. Wszelkie zmiany w prototypie <code>Object</code> są przekazywane do wszystkich obiektów, chyba że właściwości lub metody do których zmiany się odnośiły zostały gdzieś po drodze nadpisane.</p> + +<h3 id="Właściwości">Właściwości</h3> + +<div>{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Object/prototype', 'W.C5.82asno.C5.9Bci') }}</div> + +<h3 id="Metody_2">Metody</h3> + +<div>{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Object/prototype', 'Metody') }}</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_typów_null_i_undefined">Używanie <font face="Consolas, Liberation Mono, Courier, monospace">typów</font> <code>null</code> i <code>undefined</code></h3> + +<p>W poniższych przykładach zmienna o przechowuje pusty obiekt <code>Object</code>:</p> + +<pre class="brush: js">var o = new Object(); +</pre> + +<pre class="brush: js">var o = new Object(undefined); +</pre> + +<pre class="brush: js">var o = new Object(null); +</pre> + +<h3 id="Tworzenie_obiektu_Boolean">Tworzenie obiektu <code>Boolean</code></h3> + +<p>W poniższych przykładach zmienna o przechowuje obiekty {{jsxref("Boolean")}}:</p> + +<pre class="brush: js">// równoznaczne z: o = new Boolean(true); +var o = new Object(true); +</pre> + +<pre class="brush: js">// równoznaczne z: o = new Boolean(false); +var o = new Object(Boolean()); +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Początkowa definicja. Zaimplementowana w JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2', 'Object')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object-objects', 'Object')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Dodano Object.assign, Object.getOwnPropertySymbols, Object.setPrototypeOf, Object.is</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object-objects', 'Object')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Dodano Object.entries, Object.values oraz Object.getOwnPropertyDescriptors.</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">Inicjalizator obiektu</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/proto/index.html b/files/pl/web/javascript/referencje/obiekty/object/proto/index.html new file mode 100644 index 0000000000..6d4dd4653e --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/proto/index.html @@ -0,0 +1,193 @@ +--- +title: Object.prototype.__proto__ +slug: Web/JavaScript/Referencje/Obiekty/Object/proto +translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto +--- +<div class="warning"> +<p><strong>Ostrzeżenie:</strong> Zmiana <code>[[Prototype]]</code> obiektu, ze względu na sposób w jaki współczesny JavaScript optymalizuje dostęp do właściwości, jest bardzo powolną operacją (W każdej przeglądarce!). Efekty modyfikacji łańcucha dziedziczenia są rozległe, nie chodzi tu tylko o wydłużenie czasu potrzebnego na wykonanie operacji <code>obj.__proto__ = ...</code>, skutki wpływają na <strong>każdy</strong> fragment kodu który odwołuje się do <strong>jakiejkolwiek</strong> właściwości obiektu, którego <code>[[Prototype]]</code> został zmieniony. Dlatego jeżeli zależy ci na wydajności powinieneś unikać tej operacji. Zamiast tego, stwórz nowy obiekt z porządanym <code>[[Prototype]]</code> za pomocą {{jsxref("Object.create()")}}.</p> +</div> + +<div class="warning"> +<p><strong>Ostrzeżenie:</strong> Mimo że w dzisiejszych czasach <code>Object.prototype.__proto__</code> jest wspierany w niemal każdej przeglądarce, jego istnienie oraz zachowanie zostały ujednolicone w specyfikacji ECMAScript 2015 jedynie jako <em>legacy feature</em> aby zapewnić kompatybilność z przeglądarkami. Dla lepszego wsparcia rekomenduje się używanie {{jsxref("Object.getPrototypeOf()")}}.</p> +</div> + +<div>{{JSRef}}</div> + +<p>Właściwość <code>__proto__</code> obiektu {{jsxref("Object.prototype")}} jest operatorem dostępu (metoda getter i setter) która operuje na wewnętrznym <code>[[Prototype]]</code> (na obiekcie lub na {{jsxref("Global_Objects/null", "null")}}) obiektu do którego się odnosi.</p> + +<p>Użycie <code>__proto__</code> jest kontrowersyjne i podchodzi się do niego z niechęcią. Oryginalnie nigdy nie pojawiło się w specyfikacji EcmaScript, ale nowoczesne przeglądarki postanowiły mimo wszystko to zaimplementować. Dopiero niedawno właściwość <code>__proto__</code> znalazła swoje miejsce w specyfikacji ECMAScript 2015 aby zapewnić kompatybilność z tymi przeglądarkami. Jest ona jednak przestarzała ze względu na {{jsxref("Object.getPrototypeOf")}}/{{jsxref("Reflect.getPrototypeOf")}} oraz {{jsxref("Object.setPrototypeOf")}}/{{jsxref("Reflect.setPrototypeOf")}} (choć modyfikowanie <code>[[Prototype]]</code> wciąż jest operacją powolną, która powinna być unikana przez wzgląd na wydajność).</p> + +<p><code>Właściwość __proto__</code> może być również używana w notacji literałowej aby ustawić <code>[[Prototype]]</code> tworzonego obiektu, jako alterantywa do {{jsxref("Object.create()")}}. Zobacz: <a href="/pl/docs/Web/JavaScript/Reference/Operators/Object_initializer">inicjalizator obiektu / notacja literałowa</a>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js">var Kolo = function () {}; +var ksztalt = {}; +var kolo = new Kolo(); + +// Ustawianie prototypu obiektu +// ZDEPRECJONOWANE. Używamy tego tylko dla przykładu. NIE RÓB TEGO w prawdziwym kodzie. +ksztalt.__proto__ = kolo; + +// Sprawdzenie prototypu obiektu +console.log(ksztalt.__proto__ === kolo); // true +</pre> + +<pre class="brush: js">var ksztalt = function () {}; +var p = +{ + a: function () + { + console.log('aaa'); + } +}; +ksztalt.prototype.__proto__ = p; + +var kolo = new ksztalt(); +kolo.a(); // aaa + +console.log(ksztalt.prototype === kolo.__proto__); // true + +// albo + +var ksztalt = function () {}; +var p = +{ + a: function () + { + console.log('aaa'); + } +}; + +var kolo = new ksztalt(); +kolo.__proto__ = p; +circle.a(); // aaa + +console.log(ksztalt.prototype === kolo.__proto__); // false + +// albo + +function ksztalt() {}; +ksztalt.prototype.a = function () +{ + console.log('aaa'); +} +var kolo = new ksztalt(); +kolo.a(); // aaa + +console.log(kolo.__proto__ === ksztalt.prototype); // true + +// albo + +var ksztalt = function () {}; +ksztalt.prototype.a = function () +{ + console.log('aaa'); +} + +var kolo = +{ + __proto__: ksztalt.prototype +}; +kolo.a(); // aaa + +console.log(kolo.__proto__ === ksztalt.prototype); // true +</pre> + +<p>Uwaga: <code>__proto__</code> zapisujemy jako dwie <em>podłogi</em>, następnie pięć liter "proto", następnie dwie kolejne <em>podłogi</em>.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda getter właściwości <code>__proto__</code> daje nam dostęp do wewnętrznej wartości <code>[[Prototype]]</code> obiektu. Dla obiektów stworzonych przy użyciu literału jest to {{jsxref("Object.prototype")}}. Dla tablic stworzonych przy użyciu literału jest to {{jsxref("Array.prototype")}}. Dla funkcji ta wartość to {{jsxref("Function.prototype")}}. Dla obiektów stworzonych przy użyciu <code>new Funkcja</code>, gdzie <code>Funkcja</code> to jeden z wbudowanych konstruktorów dostarczanych przez JavaScript ({{jsxref("Array")}}, {{jsxref("Boolean")}}, {{jsxref("Date")}}, {{jsxref("Number")}}, {{jsxref("Object")}}, {{jsxref("String")}}, i tak dalej — wliczając nowe konstrukotry, które mogą zostać dodane w przyszłości), ta wartość to zawsze <code>Funkcja.prototype</code>. Dla obiektów stworzonych przy użyciu <code>new Funkcja</code>, gdzie <code>Funkcja</code> to funkcja zdefiniowana w kodzie, wartość ta przyjmuje taką samą wartość jak <code>Funkcja.prototype</code>.</p> + +<p>Metoda setter właściwości <code>__proto__ </code>umożliwia modyfikowanie <code>[[Prototype]]</code> obiektu. W tym celu obiekt musi być roszerzalny według funkcji {{jsxref("Object.isExtensible()")}}, jeżeli nie jest {{jsxref("Global_Objects/TypeError", "TypeError")}} zostanie wyrzucony. Dostarczana wartość musi być obiektem albo typem {{jsxref("Global_Objects/null", "null")}}. Podanie jakiejkolwiek innej wartości nie zrobi nic.</p> + +<p>Aby zrozumieć w jaki sposób prototypy używane są do dziedziczenia, zobacz artykuł o <a href="/pl/docs/Web/JavaScript/dziedziczenie_lancuch_prototypow">dziedziczeniu oraz łańcuchu prototypów</a>.</p> + +<p>Właściwość <code>__proto__</code> jest prostym operatorem pamięci na {{jsxref("Object.prototype")}} składającym się z metody getter i setter. Dostęp do właściwości <code>__proto__</code> który ostatecznie konsultuje się z {{jsxref("Object.prototype")}} znajdzie tę właściwość, ale dostęp który nie konsultuje {{jsxref("Object.prototype")}} nie znajdzie jej. Jeżeli jakaś inna właściwość <code>__proto__</code> zostanie znaleziona, zanim {{jsxref("Object.prototype")}} zostanie skonsultowany, to właściwość ta przesłoni tą znalezioną w {{jsxref("Object.prototype")}}.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Dołączony (normatywnie) jako jeden z dodatkowych ECMAScript <em>legacy features</em> dla przeglądarek (zauważ że specyfikacja jedynie ujednoliciła coś, co było już zaimplementowane w przeglądarkach).</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatIE("11")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Uwagi_odnośnie_kompatybilności">Uwagi odnośnie kompatybilności</h2> + +<p>Mimo, że specyfikacja ECMAScript 2015 określa iż wsparcie dla <code>__proto__</code> jest wymagane <em>tylko</em> dla przeglądarek internetowych (w zasadzie normatywnie), to inne środowiska równieź mogą wspierać tę funkcjonalność.</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li> + <li>{{jsxref("Object.getPrototypeOf()")}}</li> + <li>{{jsxref("Object.setPrototypeOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/prototype/index.html b/files/pl/web/javascript/referencje/obiekty/object/prototype/index.html new file mode 100644 index 0000000000..2e4e257602 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/prototype/index.html @@ -0,0 +1,218 @@ +--- +title: Object.prototype +slug: Web/JavaScript/Referencje/Obiekty/Object/prototype +tags: + - JavaScript + - Obiekt + - Object + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object +--- +<p>{{JSRef}}</p> + +<p><code style="font-style: normal;"><strong>Object.prototype</strong></code> reprezentuje prototyp obiektów klasy {{jsxref("Object")}}.</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wszystkie obiekty w języku JavaScript wywodzą się od {{jsxref("Object")}}; wszystkie obiekty dziedziczą metody i pola po <code>Object.prototype,</code> chociaż mogą one zostać przeciążone (z wyjątkiem <code>Object</code>'u o prototypie <code>null</code>, tj. <code>Object.create(null)</code>). Na przykład, prototypy innych konstruktorów przeciążają pole <code>constructor</code> i zapewniają swoje własne wersje metod {{jsxref("Object.prototype.toString()", "toString()")}}. Zmiany do prototypu <code>Object</code> propagowane są do wszystkich obiektów, chyba że dane metody i pola zostały przeciążone w prototypie którejś z klas bazowych.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("Object.prototype.constructor")}}</dt> + <dd>Określa konstruktor obiektu - funkcję, która tworzy prototyp obiektu.</dd> + <dt>{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}</dt> + <dd>Wskazuje na obiekt który był użyty jako prototyp, kiedy dany obiekt był inicjalizowany.</dd> + <dt>{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}</dt> + <dd>Pozwala zdefiniować funkcję, która będzie wykonana kiedy niezdefiniowany element obiektu zostanie wywołany jako metoda.</dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__count__")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Własność zwracała liczbę właściwości tzw. enumerable posiadanych przez zdefiniowany przez użytkownika obiekt. Własność ta została usunięta.</s></dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__parent__")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Była używana do wskazywania kontwkstu obiektu.</s><span class="obsoleteElement" style="opacity: 0.3;"> Własność ta została usunięta.</span></dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Przypisuje funkcję do pola, do którego odwołanie wywoła tę funkcję, która zwróci odpowiednią wartość.</dd> + <dt>{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Przypisuje funkcję do pola, którego ustawienie wywoła tę funkcję, która zmodyfikuje wartość pola.</dd> + <dt>{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Zwraca funkcję powiązaną z danym polem poprzez metodę {{jsxref("Object.defineGetter", "__defineGetter__")}}.</dd> + <dt>{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Zwraca funkcję powiązaną z danym polem poprzez metodę {{jsxref("Object.defineSetter", "__defineSetter__")}}.</dd> + <dt>{{jsxref("Object.prototype.hasOwnProperty()")}}</dt> + <dd>Zwraca wartość boolean wskazującą czy obiekt posiada dane pole (wykluczając przypadki, gdy pole jest odziedziczone).</dd> + <dt>{{jsxref("Object.prototype.isPrototypeOf()")}}</dt> + <dd>Zwraca wartość boolean wskazującą czy dany obiekt znajduje się w łańcuchu prototypów obiektu podanego jako parametr funkcji.</dd> + <dt>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</dt> + <dd>Zwraca wartość boolean wskazującą czy ustawiony jest atrybut <a href="/en-US/docs/ECMAScript_DontEnum_attribute" title="ECMAScript_DontEnum_attribute">ECMAScript DontEnum attribute</a>.</dd> + <dt>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Zwraca literał obiektowy reprezentujący dany obiekt; można go użyć do utworzenia nowego obiektu.</dd> + <dt>{{jsxref("Object.prototype.toLocaleString()")}}</dt> + <dd>Wywołuje {{jsxref("Object.toString", "toString()")}}.</dd> + <dt>{{jsxref("Object.prototype.toString()")}}</dt> + <dd>Zwraca łańcuch znaków reprezentujący dany obiekt.</dd> + <dt>{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}</dt> + <dd>Usuwa funkcję monitorującą daną własność obiektu.</dd> + <dt>{{jsxref("Object.prototype.valueOf()")}}</dt> + <dd>Zwraca wartość prostą danego obiektu.</dd> + <dt>{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}</dt> + <dd>Dodaje funkcję monitorującą daną własność obiektu.</dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Wykonuje kod JavaScriptu zawarty w łańcuchu znaków w kontekście danego obiektu.</s></dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Jako, iż JavaScript nie posiada typowego rozróżnienia na klasę bazową i dziedziczącą, prototype jest przydatnym obejściem pozwalającym na utworzenie “klasy bazowej” z pewnych funkcji, które działają jak obiekty. Na przykład:</p> + +<pre class="brush: js">var Osoba = function() { + this.umieMowic = true; +}; + +Osoba.prototype.powitaj = function() { + if (this.umieMowic) { + console.log('Hej, jestem ' + this.imie); + } +}; + +var Pracownik = function(imie, tytul) { + Osoba.call(this); + this.imie = imie; + this.tytul = tytul; +}; + +Pracownik.prototype = Object.create(Osoba.prototype); +Pracownik.prototype.constructor = Pracownik; + +Pracownik.prototype.powitaj = function() { + if (this.umieMowic) { + console.log('Hej, jestem ' + this.imie + ', ' + this.tytul); + } +}; + +var Klient = function(imie) { + Osoba.call(this); + this.imie = imie; +}; + +Klient.prototype = Object.create(Osoba.prototype); +Klient.prototype.constructor = Klient; + +var Mim = function(imie) { + Osoba.call(this); + this.imie = imie; + this.umieMowic = false; +}; + +Mim.prototype = Object.create(Osoba.prototype); +Mim.prototype.constructor = Mim; + +var bob = new Pracownik('Bob', 'Builder'); +var joe = new Klient('Joe'); +var rg = new Pracownik('Red Green', 'Handyman'); +var mike = new Klient('Mike'); +var mim = new Mim('Mim'); + +bob.powitaj(); +// Hej, jestem Bob, Builder + +joe.powitaj(); +// Hej, jestem Joe + +rg.powitaj(); +// Hej, jestem Red Green, Handyman + +mike.powitaj(); +// Hej, jestem Mike + +mim.powitaj(); +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Początkowa definicja. Zaimplementowano w JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introduction to Object-Oriented JavaScript</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/seal/index.html b/files/pl/web/javascript/referencje/obiekty/object/seal/index.html new file mode 100644 index 0000000000..ba52ba9665 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/seal/index.html @@ -0,0 +1,165 @@ +--- +title: Object.seal() +slug: Web/JavaScript/Referencje/Obiekty/Object/seal +translation_of: Web/JavaScript/Reference/Global_Objects/Object/seal +--- +<div>{{JSRef}}</div> + +<p>Metoda <code><strong>Object.seal()</strong></code> "uszczelnia" obiekt, zabezpieczając przed dodaniem nowych właściwości oraz czyniąc wszystkie już istniejące jako niekonfigurowalne. Wartość znajdujące się już w obiekcie mogą być cały czas zmieniane tak długo dopóki posiadają atrybut <strong>writable</strong>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>Object.seal(<var>obj</var>)</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Obiekt który powinien zostać zamknięty.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Uszczelniony obiekt.</p> + +<h2 id="Opis">Opis</h2> + +<p>Standardowo obiekty są {{jsxref("Object.isExtensible()", "extensible", "", 1)}} (nowe właściwości mogą być do nich dodawane). Zamknięcie obiektu zabezpiecza przed możliwością ich dodawania oraz oznacza wszystkie już obecne jako niekonfigurowalne. To skutkuje tym, że zestaw właściwości obiektu staje się niemutowalny. Sprawienie, że wszystkie właściwości są również niekonfigurowalne zabezpiecza je przed byciem przekonwertowane na akcesory/mutatory i odwrotnie, jednak nie zapobiega to zmianie wartości. Próba usunięcia lub dodania nowych właściwości do uszczelnionego obiektu lub konwersja jakiejś właściwości do akcesorów/mutatorów zawiedzie bez wyjątku lub wywołując {{jsxref("TypeError")}} (tak jest najczęściej, choć nie całkowicie, kiedy skrypt jest w {{jsxref("Strict_mode", "strict mode", "", 1)}}).</p> + +<p>Łancuch prototypów pozostaje nie zmieniony, jednakże właściwość {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}} jest również niemożliwa do zmiany.</p> + +<h2 id="Examples">Examples</h2> + +<pre class="brush: js">var obj = { + prop: function() {}, + foo: 'bar' +}; + +// Nowe właściwości mogą być dodane, +// istniejące - zmienione lub usunięte. +obj.foo = 'baz'; +obj.lumpy = 'woof'; +delete obj.prop; + +var o = Object.seal(obj); + +o === obj; // true +Object.isSealed(obj); // === true + +// Zmiana wartości na zamkniętym obiekcie nadal działa. +obj.foo = 'quux'; + +// Jednak nie możesz zmienić właściwości obieku do akcesorów i odwrotnie +Object.defineProperty(obj, 'foo', { get: function() { return 'g'; } }); // throws a TypeError + +// W tym momencie jakiekolwiek inne zmiany właściwości obiektu zawiodą +obj.quaxxor = 'the friendly duck'; // nie doda właściwości, nie rzucając wyjątku +delete obj.foo; // nie usunie właściwości, nie rzucając wyjątku + +// ...w trybie strict takie operacje będą rzucać wyjątkami. +function fail() { + 'use strict'; + delete obj.foo; // rzuca TypeError + obj.sparky = 'arf'; // rzuca TypeError +} +fail(); + +// Próba dodania właściwości przez Object.defineProperty zawiedzie +Object.defineProperty(obj, 'ohai', { value: 17 }); // rzuca TypeError +Object.defineProperty(obj, 'foo', { value: 'eit' }); // zmienia istniejącą wartość +</pre> + +<h2 id="Uwagi">Uwagi</h2> + +<p>W ES5, jeżeli argumentem metody nie jest obiekt (jest to prymitywna struktura), spowoduje to wywołanie {{jsxref("TypeError")}}. W ES6, argument nie będący obiektem zostanie potraktowany jakby już był uszczelnionym, zwykłym obiektem i będzie zwrócony.</p> + +<pre class="brush: js">Object.seal(1); +// TypeError: 1 is not an object (ES5 code) + +Object.seal(1); +// 1 (ES6 code) +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.8', 'Object.seal')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Wstępna definicja. Implementowano w JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.seal', 'Object.seal')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_w_przeglądarkach">Kompatybilność w przeglądarkach</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("6")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12")}}</td> + <td>{{CompatSafari("5.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Object.isSealed()")}}</li> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> + <li>{{jsxref("Object.freeze()")}}</li> + <li>{{jsxref("Object.isFrozen()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/tolocalestring/index.html b/files/pl/web/javascript/referencje/obiekty/object/tolocalestring/index.html new file mode 100644 index 0000000000..1cd0074d45 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/tolocalestring/index.html @@ -0,0 +1,35 @@ +--- +title: Object.prototype.toLocaleString() +slug: Web/JavaScript/Referencje/Obiekty/Object/toLocaleString +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący obiekt. Ta metoda najczęściej jest przysłonięta przez pochodne obiekty.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>obj</var>.toLocaleString();</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>Object</code> <code>toLocaleString</code> zwraca rezultat, który nazywamy {{jsxref("Object.toString", "toString()")}}.</p> + +<p>Ta metoda jest dostarczona dając obiektom generującą metodę <code>toLocaleString()</code>, nawet mimo to nie wszystkie go używają. Aktualnie, tylko <code>Array</code>, <code>Number</code> i <code>Date</code> nadpisują <code>toLocaleString</code>.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/tosource/index.html b/files/pl/web/javascript/referencje/obiekty/object/tosource/index.html new file mode 100644 index 0000000000..4aa67db90c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/tosource/index.html @@ -0,0 +1,73 @@ +--- +title: Object.prototype.toSource() +slug: Web/JavaScript/Referencje/Obiekty/Object/toSource +tags: + - JavaScript + - Method + - Non-standard + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca literał obiektowy reprezentujący kod źródłowy danego obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>Object.toSource(); +<var>obj</var>.toSource(); +</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toSource()</code> zwraca następujące wartości:</p> + +<ul> + <li>dla obiektu wbudowanego {{jsxref("Object")}} metoda <code>toSource()</code> zwraca następujący ciąg znaków, wskazujący na niedostępność kodu źródłowego: + + <pre class="brush: js">function Object() { + [native code] +} +</pre> + </li> + <li>dla instancji {{jsxref("Object")}} metoda <code>toSource()</code> zwraca ciąg reprezentujący ich kod źródłowy.</li> +</ul> + +<p>Metoda ta zazwyczaj jest używana wewnętrznie przez interpreter JavaScriptu, a nie bezpośrednio w kodzie. Można jednak wywołać <code>toSource()</code> podczas debugowania, by zbadać zawartość danego obiektu.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toSource" name="Przyk.C5.82ad:_Zastosowanie_toSource">Przykład: Zastosowanie <code>toSource()</code></h3> + +<p>Poniższy kod definiuje typ obiektowy <code>Pies</code> i tworzy instancję <code>piesek</code> jako obiekt typu <code>Pies</code>:</p> + +<pre class="brush: js language-js"><code class="language-js"><span class="token keyword">function</span> </code>Pies<code class="language-js"><span class="token function"><span class="token punctuation">(</span></span></code>nazwa<code class="language-js"><span class="token punctuation">)</span> <span class="token punctuation">{</span> + <span class="token keyword">this</span><span class="token punctuation">.</span></code>nazwa<code class="language-js"> <span class="token operator">=</span> </code>nazwa<code class="language-js"><span class="token punctuation">;</span> +<span class="token punctuation">}</span> + +</code><code>Pies</code><code class="language-js"><span class="token punctuation">.</span>prototype<span class="token punctuation">.</span>toSource <span class="token operator">=</span> <span class="token keyword">function</span> </code><code>Pies</code><code class="language-js"><span class="token function">_toSource<span class="token punctuation">(</span></span><span class="token punctuation">)</span> <span class="token punctuation">{</span> + <span class="token keyword">return</span> <span class="token string">'new </span></code><code>Pies</code><code class="language-js"><span class="token string">('</span> <span class="token operator">+</span> <span class="token function">uneval<span class="token punctuation">(</span></span><span class="token keyword">this</span><span class="token punctuation">.</span>nazwa<span class="token punctuation">)</span> <span class="token operator">+</span> <span class="token string">')'</span><span class="token punctuation">;</span> +<span class="token punctuation">}</span><span class="token punctuation">;</span> + +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token keyword">new</span> </code><code>Pies</code><code class="language-js"><span class="token punctuation">(</span><span class="token string">'Joe'</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toSource<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // ---> new </span></code> <code>Pies</code><code class="language-js"><span class="token comment">("Joe")</span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Array", "Array")}} Object method.</li> + <li>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Boolean", "Boolean")}} Object method.</li> + <li>{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Date", "Date")}} Object method.</li> + <li>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Function", "Function")}} Object method.</li> + <li>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Number", "Number")}} Object method.</li> + <li>{{jsxref("Regexp.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/RegExp", "RegExp")}} Object method.</li> + <li>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/String", "String")}} Object method.</li> + <li>{{jsxref("Symbol.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Symbol", "Symbol")}} Object method.</li> + <li><code>Math.toSource()</code> — Returns the String "Math".</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/object/tostring/index.html new file mode 100644 index 0000000000..e18d93d79a --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/tostring/index.html @@ -0,0 +1,98 @@ +--- +title: Object.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/Object/toString +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący dany obiekt.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>obj</var>.toString()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Każdy obiekt posiada metodę <code>toString</code>, która jest wywoływana automatycznie, kiedy obiekt ma zostać przedstawiony jako wartość tekstowa, albo kiedy obiekt jest dołączany do ciągu znakowego. Poniższe przykłady wymagają, by <code>jakisPies</code> był reprezentowany jako łańcuch znaków:</p> + +<pre class="brush: js">console.log(jakisPies); +console.log("jakisPies to " + jakisPies); +</pre> + +<p>Domyślnie metoda <code>toString</code> jest dziedziczona przez każdy obiekt wyprowadzony z obiektu <code>Object</code>. Można przesłonić tę metodę dla własnych obiektów. Jeśli <code>toString</code> nie zostanie przesłonięta we własnych obiektach użytkownika, zwróci ona <code>[object + <i>typ</i> + ]</code>, gdzie <code> + <i>typ</i> + </code> jest typem obiektu lub nazwą funkcji konstruktora, która utworzyła ten obiekt.</p> + +<p>Na przykład:</p> + +<pre class="brush: js">var o = new Object() +o.toString() // zwraca "[object Object]" +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przes.C5.82anianie_domy.C5.9Blnej_metody_toString" name="Przes.C5.82anianie_domy.C5.9Blnej_metody_toString">Przesłanianie domyślnej metody <code>toString()</code></h3> + +<p>Można utworzyć funkcję, która będzie wywoływana zamiast domyślnej metody <code>toString()</code>. Metoda <code>toString()</code> nie pobiera żadnych argumentów i powinna zwrócić łańcuch znaków. Utworzona przez użytkownika metoda <code>toString()</code> może zwracać dowolną wartość, ale najlepiej, by przekazywała użyteczne informacje na temat obiektu.</p> + +<p>Poniższy kod definiuje typ obiektowy <code>Pies</code> i tworzy obiekt <code>jakisPies</code> typu <code>Pies</code>:</p> + +<pre class="brush: js">function Pies(nazwa,rasa,wiek,plec) { + this.nazwa=nazwa; + this.rasa=rasa; + this.wiek=wiek; + this.plec=plec; +} + +jakisPies = new Pies("Szarik","owczarek niemiecki","5","samiec");</pre> + +<p>Jeśli wywołana zostanie metoda <code>toString</code> tego obiektu, zwrócona zostanie domyślna wartość odziedziczona po <code>Object</code>:</p> + +<pre class="brush: js">jakisPies.toString(); // zwraca [object Object] +</pre> + +<p>Poniższy kod tworzy funkcję <code>piesToString</code>, która to funkcja będzie przesłaniać domyślną metodę <code>toString</code>. Funkcja ta tworzy łańcuch znaków zawierający każdą własność; budowany łańcuch będzie postaci "<code>własność = wartość;</code>".</p> + +<pre class="brush: js">function piesToString() { + var ret = "Pies " + this.nazwa + " to: [\n"; + for (var prop in this) + ret += " " + prop + " = " + this[prop] + ";\n"; + return ret + "]"; +} +</pre> + +<p>Poniższy kod przypisuje zdefiniowaną powyżej funkcję do metody <code>toString</code> obiektów typu obiektowego Pies:</p> + +<pre class="brush: js">Pies.prototype.toString = piesToString; +</pre> + +<p>Dzięki powyższemu kodowi za każdym razem, kiedy <code>jakisPies</code> używany jest w kontekście łańcucha znaków, interpreter JavaScriptu automatycznie wywołuje funkcję <code>piesToString</code>, która zwraca poniższy łańcuch:</p> + +<pre>Pies Szarik to: [ + nazwa = Szarik; + rasa = owczarek niemiecki; + wiek = 5; + plec = samiec; +] +</pre> + +<p>Metoda <code>toString</code> danego obiektu jest zazwyczaj wywoływana przez interpreter JavaScriptu, ale można ją wywołać samodzielnie, jak poniżej:</p> + +<pre class="brush: js">var piesString = jakisPies.toString(); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/unwatch/index.html b/files/pl/web/javascript/referencje/obiekty/object/unwatch/index.html new file mode 100644 index 0000000000..fde03bf1eb --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/unwatch/index.html @@ -0,0 +1,39 @@ +--- +title: Object.prototype.unwatch() +slug: Web/JavaScript/Referencje/Obiekty/Object/unwatch +tags: + - JavaScript + - Method + - Non-standard + - Object + - Prototype +translation_of: Archive/Web/JavaScript/Object.unwatch +--- +<p>{{JSRef}}{{ Non-standard_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Usuwa funkcję monitorującą ustawioną poprzez metodę {{jsxref("Object.prototype.watch", "watch()")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>obj</var>.unwatch(<var>wlasnosc</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>wlasnosc</code> </dt> + <dd>Nazwa obserwowanej własności obiektu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Debuger JavaScriptu posiada możliwości podobne do tych dostarczonych przez metodę <code>watch</code>, jak również wiele innych narzędzi przydatnych podczas analizy kodu. Więcej informacji można znaleźć na stronie <a href="/pl/docs/Venkman">Venkman</a>.</p> + +<p>Domyślnie metoda ta jest dziedziczona przez każdy obiekt wyprowadzony z obiektu <code>Object</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<ul> + <li>{{jsxref("Object.watch()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/valueof/index.html b/files/pl/web/javascript/referencje/obiekty/object/valueof/index.html new file mode 100644 index 0000000000..db3cf7a346 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/valueof/index.html @@ -0,0 +1,63 @@ +--- +title: Object.prototype.valueOf() +slug: Web/JavaScript/Referencje/Obiekty/Object/valueOf +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf +--- +<p>{{jsRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość podstawową danego obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>object</var>.valueOf()</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>JavaScript wywołuje metodę <code>valueOf()</code> by przekonwertować obiekt do wartości podstawowej. Metodę <code>valueOf</code> rzadko wykorzystuje się w pisanych programach, zazwyczaj JavaScript wywołuje ją automatycznie, kiedy oczekując wartości podstawowej napotka obiekt.</p> + +<p>Domyślnie metoda <code>valueOf()</code> jest dziedziczona przez każdy obiekt potomny obiektu {{jsxref("Object")}}. Każdy wbudowany obiekt jądra JavaScriptu przesłania tę metodą by zwracała właściwą wartość. Jeśli obiekt nie ma wartości podstawowej, <code>valueOf()</code> zwraca sam obiekt, który jest wyświetlany jako:</p> + +<pre>[object Object] +</pre> + +<p>We własnych programach można oczywiście używać metody <code>valueOf</code> do konwersji obiektów na wartości podstawowe. Kiedy użytkownik tworzy własne obiekty, może przesłonić metodę <code>valueOf()</code> własną wersją.</p> + +<h3 id="Przes.C5.82anianie_metody_valueOf_dla_w.C5.82asnych_obiekt.C3.B3w" name="Przes.C5.82anianie_metody_valueOf_dla_w.C5.82asnych_obiekt.C3.B3w">Przesłanianie metody <code>valueOf</code> dla własnych obiektów</h3> + +<p>Można utworzyć funkcję, która będzie wywoływana zamiast domyślnej metody <code>valueOf</code>. Taka funkcja nie powinna mieć argumentów.</p> + +<p>Załóżmy, że mamy typ obiektowy <code>MojTypLiczbowy</code> i chcemy utworzyć dla niego metodę <code>valueOf</code>. Poniższy kod przypisuje zdefiniowaną przez użytkownika funkcję do metody <code>valueOf</code> obiektu:</p> + +<pre class="brush: js">MojTypLiczbowy.prototype.valueOf = new Function(tekstFunkcji); +</pre> + +<p>Dzięki powyższej instrukcji za każdym razem, kiedy obiekt typu <code>MojTypLiczbowy</code> jest używany w kontekście wartości prostej, JavaScript automatycznie wywoła funkcję zdefiniowaną powyżej.</p> + +<p>Metoda <code>valueOf</code> obiektu jest zwykle wywoływana przez interpreter JavaScriptu, ale można ją wywołać samodzielnie:</p> + +<pre class="brush: js">mojaLiczba.valueOf(); +</pre> + +<h3 id="Uwaga" name="Uwaga">Uwaga</h3> + +<p>Obiekty używane w kontekście łańcucha znaków konwertowane są przy użyciu metody <code><a href="/pl/docs/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Object/toString">toString</a></code>, co różni się od konwertowania obiektów <code>String</code> do prostych łańcuchów znaków poprzez <code>valueOf</code>. Wszystkie obiekty posiadają konwersję do łańcucha znaków, choćby <code>[object + <i>typ</i> + ]</code>. Ale wiele obiektów nie posiada domyślnej konwersji do liczby, wartości logicznej lub funkcji.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> + <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/object/watch/index.html b/files/pl/web/javascript/referencje/obiekty/object/watch/index.html new file mode 100644 index 0000000000..f13e38aaa1 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/object/watch/index.html @@ -0,0 +1,78 @@ +--- +title: Object.prototype.watch() +slug: Web/JavaScript/Referencje/Obiekty/Object/watch +tags: + - JavaScript + - Method + - Non-standard + - Object + - Prototype +translation_of: Archive/Web/JavaScript/Object.watch +--- +<p>{{JSRef}}{{ Non-standard_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Obserwuje własność obiektu i wywołuje funkcję, kiedy nastąpi przypisanie wartości do tej własności.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>obj.watch(<i>wlasnosc</i> , +<i>monitor</i>) </code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>wlasnosc</code> </dt> + <dd>Nazwa obserwowanej własności obiektu.</dd> +</dl> + +<dl> + <dt><code>monitor</code> </dt> + <dd>Funkcja, która ma zostać wywołana przy zmianie własności.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obserwuje własność <code>wlasnosc</code> danego obiektu i wywołuje <code>monitor(wlasnosc, stara_wartosc, nowa_wartosc)</code> kiedy tylko <code>wlasnosc</code> jest ustawiana. Funkcja monitorująca może filtrować (lub zerować <span class="nowiki">[ang. 'nullify']</span>) przypisanie wartości, zwracając zmodyfikowaną <code>nowa_wartosc</code> (lub <code>stara_wartosc</code>).</p> + +<p>Jeśli zostanie usunięta własność, która miała funkcję monitorującą, ta funkcja monitorująca nie znika. Jeśli później własność ta zostanie odtworzona, funkcja monitorująca ciągle działa.</p> + +<p>Aby usunąć funkcję monitorującą, należy użyć metody {{jsxref("Object.unwatch", "unwatch()")}} Domyślnie metoda <code>watch</code> jest dziedziczona przez każdy obiekt pochodzący od {{jsxref("Object")}}.</p> + +<p>Debuger JavaScriptu posiada możliwości podobne do tych dostarczonych przez metodę <code>watch</code>, jak również wiele innych narzędzi przydatnych podczas analizy kodu. Więcej informacji można znaleźć na stronie <a href="/pl/docs/Venkman">Venkman</a>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_watch_i_unwatch" name="Przyk.C5.82ad:_Zastosowanie_watch_i_unwatch">Przykład: Zastosowanie <code>watch</code> i <code>unwatch</code></h3> + +<pre class="brush: js">var o = {p:1}; +o.watch("p", + function (id,oldval,newval) { + document.writeln("o." + id + " zmieniona z " + + oldval + " na " + newval); + return newval; + }); + +o.p = 2; +o.p = 3; +delete o.p; +o.p = 4; + +o.unwatch('p'); +o.p = 5; +</pre> + +<p>Powyższy skrypt wyświetla:</p> + +<pre>o.p zmieniona z 1 na 2 +o.p zmieniona z 2 na 3 +o.p zmieniona z undefined na 4 +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.unwatch()")}}</li> + <li>{{jsxref("Object.observe()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/packages/index.html b/files/pl/web/javascript/referencje/obiekty/packages/index.html new file mode 100644 index 0000000000..a676a3f297 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/packages/index.html @@ -0,0 +1,50 @@ +--- +title: Packages +slug: Web/JavaScript/Referencje/Obiekty/Packages +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/Packages +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p><b>Obiekt główny</b> +</p><p>Obiekt najwyższego rzędu umożliwiający dostęp do klas języka Java z poziomu kodu JavaScriptu. +</p> +<h3 id="Tworzony_przez" name="Tworzony_przez"> Tworzony przez </h3> +<p>Obiekt <code>Packages</code> jest predefiniowanym obiektem najwyższego rzędu. Dostęp do niego nie wymaga stosowania konstruktora ani wywoływania żadnych metod. +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Obiekt <code>Packages</code> pozwala na dostęp do publicznych metod i pól klas języka Java z poziomu kodu w JavaScripcie. Własności <code>java</code>, <code>netscape</code> i <code>sun</code> odpowiadają pakietom <code>java.*</code>, <code>netscape.*</code> i <code>sun.*</code>. Aby uzyskać dostęp do klas, metod i pól w tych pakietach można stosować standardową notację Javy. Na przykład, aby wywołać konstruktor klasy <code>Frame</code> można wykonać poniższy kod: +</p> +<pre>var ramka = new Packages.java.awt.Frame(); +</pre> +<p>Dla wygody programisty JavaScript dostarcza trzech obiektów najwyższego poziomu: <code>netscape</code>, <code>sun</code> i <code>java</code>, które stanowią synonimy dla odpowiednich własności obiektu Packages. Dlatego też z tych pakietów można korzystać bez użycia słowa Packages: +</p> +<pre>var ramka = new java.awt.Frame(); +</pre> +<p>Własność <code><i>nazwaKlasy</i></code> reprezentuje pełną kwalifikowaną nazwę dowolnej innej klasy dostępnej dla JavaScriptu. Aby mieć dostęp do klas poza pakietami <code>netscape</code>, <code>sun</code> i <code>java</code>, należy stosować obiekt <code>Packages</code> +</p> +<h3 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci"> Własności </h3> +<p><i><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages/nazwaKlasy">nazwaKlasy</a></i>: pełna kwalifikowana nazwa klasy Javy w pakiecie innym niż netscape, java i sun, która jest dostępna dla JavaScriptu. </p><p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages/java">java</a>: Dowolna klasa w pakiecie Javy java.*. </p><p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages/netscape">netscape</a>: Dowolna klasa w pakiecie Javy netscape.*. </p><p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages/sun">sun</a>: Dowolna klasa w pakiecie Javy sun.*. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Funkcja_JavaScriptu_tworz.C4.85ca_okno_dialogowe_Javy" name="Przyk.C5.82ad:_Funkcja_JavaScriptu_tworz.C4.85ca_okno_dialogowe_Javy"> Przykład: Funkcja JavaScriptu tworząca okno dialogowe Javy </h4> +<p>Poniższa funkcja JavaScriptu tworzy okno dialogowe Javy: +</p> +<pre>function utworzOkno() { + var ramka = new Packages.java.awt.Frame(); + var okno = new Packages.java.awt.Dialog(ramka); + okno.setSize(350,200); + okno.setTitle("Witaj, świecie!"); + okno.setVisible(true); +} +</pre> +<p>W powyższym przykładzie funkcja tworzy <code>okno</code> z użyciem obiektu <code>Packages</code>. Metody <code>setSize</code>, <code>setTitle</code> i <code>setVisible</code> są dostępne dla JavaScriptu jako publiczne metody klasy <code>java.awt.Dialog</code>. +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Packages", "es": "es/Referencia_de_JavaScript_1.5/Objetos_globales/Packages" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/packages/java/index.html b/files/pl/web/javascript/referencje/obiekty/packages/java/index.html new file mode 100644 index 0000000000..1bd592f727 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/packages/java/index.html @@ -0,0 +1,49 @@ +--- +title: java +slug: Web/JavaScript/Referencje/Obiekty/Packages/java +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/Packages/java +--- +<p> </p> + +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> + +<p>Dowolna klasa Javy z pakietu <code>java.*</code>.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header" colspan="2">Własność obiektu: <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a></td> + </tr> + <tr> + <td>Zaimplementowana w:</td> + <td>JavaScript 1.1, NES2.0</td> + </tr> + </tbody> +</table> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<p><code>Packages.java </code></p> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Własność <code>java</code> stosuje się by uzyskać dostęp do dowolnej klasy Javy z pakietu <code>java</code> z poziomu JavaScriptu. Warto pamiętać, że obiekt najwyższego rzędu <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/java">java</a></code> jest synonimem <code>Packages.java</code>.</p> + +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_Packages.java" name="Przyk.C5.82ad:_Zastosowanie_Packages.java">Przykład: Zastosowanie <code>Packages.java</code></h4> + +<p>Poniższy kod wywołuje konstruktor klasy <code>java.awt.Frame</code>:</p> + +<pre>var ramka = new Packages.java.awt.Frame(); +</pre> + +<p>Kod ten można uprościć stosując obiekt najwyższego rzędu <code>java</code>:</p> + +<pre>var ramka = new java.awt.Frame(); +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/packages/nazwaklasy/index.html b/files/pl/web/javascript/referencje/obiekty/packages/nazwaklasy/index.html new file mode 100644 index 0000000000..9ce2d335ef --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/packages/nazwaklasy/index.html @@ -0,0 +1,41 @@ +--- +title: nazwaKlasy +slug: Web/JavaScript/Referencje/Obiekty/Packages/nazwaKlasy +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/Packages/className +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Pełna kwalifikowana nazwa klasy Javy w pakiecie innym niż <code>netscape</code>, <code>java</code> i <code>sun</code>, która jest dostępna dla JavaScriptu. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Własność obiektu: <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a></td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.1, NES2.0</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<p><code> +Packages.<i>nazwaKlasy</i> +</code> +</p><p>gdzie <code><i>nazwaKlasy</i></code> jest pełną kwalifikowaną nazwą klasy Javy. +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Aby uzyskać dostęp do klas Javy poza pakietami <code>netscape</code>, <code>sun</code> i <code>java</code>, należy stosować własność <code><i>nazwaKlasy</i></code> pakietu <code>Packages</code>. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Stosowanie_Packages.nazwaKlasy" name="Przyk.C5.82ad:_Stosowanie_Packages.nazwaKlasy"> Przykład: Stosowanie <code>Packages.<i>nazwaKlasy</i></code> </h4> +<p>Poniższy kod wywołuje konstruktor klasy <code>CorbaObject</code> w pakiecie <code>mojaFirma</code> z poziomu JavaScriptu: +</p> +<pre>var obiekt = new Packages.mojaFirma.CorbaObject() +</pre> +<p>W powyższym przykładzie wartością własności <code><i>nazwaKlasy</i></code> jest <code>mojaFirma.CorbaObject</code>, pełna kwalifikowana nazwa klasy <code>CorbaObject</code>. +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Packages/className" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/packages/netscape/index.html b/files/pl/web/javascript/referencje/obiekty/packages/netscape/index.html new file mode 100644 index 0000000000..e1ca87b6bd --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/packages/netscape/index.html @@ -0,0 +1,35 @@ +--- +title: netscape +slug: Web/JavaScript/Referencje/Obiekty/Packages/netscape +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/Packages/netscape +--- +<p> </p> + +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> + +<p>Dowolna klasa Javy z pakietu <code>netscape.*</code>.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header" colspan="2">Własność obiektu: <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a></td> + </tr> + <tr> + <td>Zaimplementowana w:</td> + <td>JavaScript 1.1, NES2.0</td> + </tr> + </tbody> +</table> + +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> + +<p><code>Packages.netscape </code></p> + +<h3 id="Opis" name="Opis">Opis</h3> + +<p>Własność <code>netscape</code> stosuje się, by uzyskać dostęp do dowolnej klasy Javy z pakietu <code>netscape</code> z poziomu JavaScriptu. Warto pamiętać, że obiekt najwyższego rzędu <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/netscape">netscape</a></code> jest synonimem <code>Packages.netscape</code>.</p> diff --git a/files/pl/web/javascript/referencje/obiekty/packages/sun/index.html b/files/pl/web/javascript/referencje/obiekty/packages/sun/index.html new file mode 100644 index 0000000000..d7ab3781a6 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/packages/sun/index.html @@ -0,0 +1,32 @@ +--- +title: sun +slug: Web/JavaScript/Referencje/Obiekty/Packages/sun +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/Packages/sun +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Dowolna klasa Javy z pakietu <code>sun.*</code>. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Własność obiektu: <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a></td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.1, NES2.0</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<p><code> +Packages.sun +</code> +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Własność <code>sun</code> stosuje się, by uzyskać dostęp do dowolnej klasy Javy z pakietu <code>sun</code> z poziomu JavaScriptu. Warto pamiętać, że obiekt najwyższego rzędu <code>sun</code> jest synonimem <code>Packages.sun</code>. +</p>{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Packages/sun" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/parsefloat/index.html b/files/pl/web/javascript/referencje/obiekty/parsefloat/index.html new file mode 100644 index 0000000000..9afb58d074 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/parsefloat/index.html @@ -0,0 +1,68 @@ +--- +title: parseFloat() +slug: Web/JavaScript/Referencje/Obiekty/parseFloat +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/parseFloat +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Przetwarza argument w postaci łańcucha znaków zwracając liczbę zmiennoprzecinkową.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox">parseFloat(<em>string</em>)</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>string</code> </dt> + <dd>Łańcuch znaków do przetworzenia.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>parseFloat()</code> jest funkcją najwyższego poziomu, niepowiązaną z żadnym obiektem.</p> + +<p><code>parseFloat()</code> przetwarza argument będący łańcuchem znaków i zwraca liczbę zmiennoprzecinkową. Jeśli natknie się na znak inny niż <code>+</code>, <code>-</code>, liczbę (<code>0</code>-<code>9</code>), kropkę dziesiętną ("<code>.</code>") lub wykładnik potęgi, zwraca wartość do tego miejsca i ignoruje dany znak oraz wszystkie dalsze znaki. Dozwolone są spacje na początku i na końcu łańcucha znaków.</p> + +<p>Jeśli pierwszy znak nie może być przekonwertowany do liczby, <code>parseFloat()</code> zwraca <code>NaN</code>.</p> + +<p>W zastosowaniach arytmetycznych, wartość <code>NaN</code> nie jest liczbą w żadnej podstawie wyliczeń (ang. + + <i>radix</i> + ). Aby stwierdzić, czy wynik <code>parseFloat</code> będzie <code>NaN</code>, można wywołać funkcję {{jsxref("isNan", "isNaN()")}}. Jeśli wartość <code>NaN</code> użyta zostanie w operacji arytmetycznej, wynikiem operacji także będzie <code>NaN</code>.</p> + +<p><b>Uwaga:</b> Funkcja <code>parseFloat</code> wymaga, aby punktem dziesiętnym była kropka, a nie przecinek. Zastosowanie przecinka spowoduje pominięcie części ułamkowej.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h2 id="Przyk.C5.82ad:_parseFloat_zwraca_liczb.C4.99" name="Przyk.C5.82ad:_parseFloat_zwraca_liczb.C4.99">Przykład: <code>parseFloat()</code> zwraca liczbę</h2> + +<p>Wszystkie poniższe przykłady zwracają 3.14.</p> + +<pre class="brush: js"><code>parseFloat("3.14"); +<code>parseFloat("314e-2"); +<code>parseFloat("0.0314E+2"); +<code>parseFloat("3.14 więcej znaków nienumerycznych");</code></code></code></code></pre> + +<h3 id="Przyk.C5.82ad:_parseFloat_zwraca_NaN" name="Przyk.C5.82ad:_parseFloat_zwraca_NaN">Przykład: <code>parseFloat()</code> zwraca NaN</h3> + +<p>Poniższy przykład zwraca <code>NaN</code>:</p> + +<pre class="brush: js"><code>parseFloat("FF2");</code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("parseInt", "parseInt()")}}</li> + <li>{{jsxref("Number.parseFloat()")}}</li> + <li>{{jsxref("Number.parseInt()")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/parseint/index.html b/files/pl/web/javascript/referencje/obiekty/parseint/index.html new file mode 100644 index 0000000000..fb05b9fc8e --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/parseint/index.html @@ -0,0 +1,112 @@ +--- +title: parseInt() +slug: Web/JavaScript/Referencje/Obiekty/parseInt +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/parseInt +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Przetwarza argument w postaci łańcucha znaków i zwraca liczbę całkowitą typu + <i>integer</i> + , o zadanej podstawie.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox">parseInt(<em>string</em>, <em>radix</em>);</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>string</code> </dt> + <dd>Łańcuch znaków zawierający wartość do przetworzenia.</dd> +</dl> + +<dl> + <dt><code>radix</code> </dt> + <dd>Liczba typu + <i>integer</i> + określająca podstawę powyższego łańcucha (np. 2 - system dwójkowy, 10 - system dziesiętny, przyp. tłum.)</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>parseInt</code> jest funkcją najwyższego poziomu i nie jest związana z żadnym obiektem.</p> + +<p>Funkcja <code>parseInt</code> parsuje jej pierwszy argument, łańcuch znaków, i próbuje zwrócić liczbę całkowitą typu + + <i>integer</i> + o podanej podstawie. Na przykład, podstawa 10 oznacza że liczba w łańcuchu jest liczbą dziesiętną, podstawa 8 - ósemkową, 16 - szesnastkową (heksadecymalną), itd. Dla podstaw większych niż 10, litery alfabetu oznaczają cyfry większe niż 9. Dla przykładu, dla liczb szesnastkowych (o podstawie 16), używane są litery od A do F.</p> + +<p>Jeśli <code>parseInt</code> natknie się na znak nie będący cyfrą o danej podstawie, ignoruje ona ten znak i wszystkie następne znaki, a następnie zwraca wartość przetworzoną do tej pory. <code>parseInt</code> przycina liczby do wartości całkowitych. Początkowe i grupujące spacje są dozwolone.</p> + +<p>Jeśli podstawa nie jest podana lub jest podana jako 0, JavaScript przyjmuje:</p> + +<ul> + <li>Podstawę <code>16</code>, jeśli łańcuch wejściowy zaczyna się od "<code>0x</code>".</li> + <li>Podstawę <code>8</code> jeśli łańcuch wejściowy rozpoczyna się od "<code>0</code>". Ta cecha jest wycofywana.</li> + <li>Podstawę <code>10</code> jeśli łańcuch zaczyna się od jakiejkolwiek innej wartości.</li> +</ul> + +<p>Jeśli pierwszy znak nie może być skonwertowany na liczbę, <code>parseInt</code> zwraca <code>NaN</code>.</p> + +<p>Dla potrzeb arytmetycznych, wartość <code>NaN</code> nie jest liczbą o żadnej podstawie. Możesz wywołać funkcję {{jsxref("isNaN", "isNaN()")}}, by stwierdzić czy wynik <code>parseInt</code> będzie <code>NaN</code>. Jeśli <code>NaN</code> jest podane do jakichkolwiek operacji arytmetycznych, wynikiem tych operacji również będzie <code>NaN</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_parseInt" name="Przyk.C5.82ad:_Zastosowanie_parseInt">Przykład: Zastosowanie <code>parseInt()</code></h3> + +<p>Wszystkie poniższe przykłady zwracają 15:</p> + +<pre class="brush: js"><code>parseInt(" 0xF, 16); +parseInt(" F", 16); +<code>parseInt("17", 8); +<code>parseInt(021, 8); +<code>parseInt(15.99, 10); +<code><code><code><code>parseInt(<code>"FXX123", 16);</code></code></code></code></code></code></code></code></code> +<code><code>parseInt("1111", 2); +<code>parseInt("15*3", 10); +parseInt("15e2", 10); +parseInt("15px", 10); +<code>parseInt("12", 13);</code></code></code></code></pre> + +<p>Wszystkie poniższe przykłady zwracają <strong><code>NaN</code></strong>:</p> + +<pre class="brush: js"><code>parseInt("Hello", 8); // nie jest wcale liczbą</code> +<code>parseInt("546", 2); // te cyfry nie są używane do zapisu liczb binarnych</code></pre> + +<p>Wszystkie poniższe przykłady zwracają <strong>-15</strong>:</p> + +<pre class="brush: js"><code><code><code><code>parseInt("-F", 16); +parseInt("-0F", 16); +parseInt("-0XF", 16);</code></code></code></code> +parseInt("-15.1, 10); +parseInt(" -17", 8); +parseInt(" -15", 10); +parseInt("-1111", 2); +parseInt("-15e1", 10); +parseInt("-12", 13); +</pre> + +<p>Wszystkie poniższe przykłady zwracają <strong>224</strong>:</p> + +<pre class="brush: js"><code><code><code><code>parseInt("0e0", 16);</code></code></code></code></pre> + +<p> </p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("parseFloat", "parseFloat()")}}</li> + <li>{{jsxref("Number.parseFloat()")}}</li> + <li>{{jsxref("Number.parseInt()")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> + <li>{{jsxref("Number.toString()")}}</li> + <li>{{jsxref("Object.valueOf")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/promise/index.html b/files/pl/web/javascript/referencje/obiekty/promise/index.html new file mode 100644 index 0000000000..3da2498ca1 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/promise/index.html @@ -0,0 +1,256 @@ +--- +title: Promise +slug: Web/JavaScript/Referencje/Obiekty/Promise +tags: + - JavaScript + - Obietnice +translation_of: Web/JavaScript/Reference/Global_Objects/Promise +--- +<div>{{JSRef}}</div> + +<p>Obiekt <strong><code>Promise</code></strong> reprezentuje ewentualne zakończenie (lub porażkę) asynchronicznej operacji i jej wartości.</p> + +<div class="note"> +<p>Artykuł opisuje konstruktor, metody i właściwości obiektu <code>Promise</code>. By nauczyć się jak działają obietnice i jak można ich używać zalecamy przeczytać najpierw <a href="/en-US/docs/Web/JavaScript/Guide/Using_promises">Użycie obietnic</a> . Ten konstruktor jest głównie używany do opakowania funkcji, które nie wspierają jeszcze obietnic.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/promise-constructor.html")}}</div> + +<p class="hidden">Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do interaktywnego projektu sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij do nas pull request.</p> + +<p class="hidden">Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do interaktywnego projektu sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij do nas pull request.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js notranslate">new Promise( /* wykonawca */ function(resolve, reject) { ... } );</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>wykonawca (executor)</dt> + <dd>Funkcja przekazywana z argumentami <code>resolve</code> i <code>reject</code>. Funkcja ta wykonywana jest natychmiast przez implementację obietnicy, przekazując funkcje <code>resolve</code> i <code>reject</code> (ta funkcja jest wywoływana, zanim konstruktor Promise zwróci utworzony obiekt). Funkcje <code>resolve</code> i <code>reject</code> , gdy są wywoływane, odpowiednio rozwiązują lub odrzucają obietnicę. Ta funkcja zwykle inicjuje pracę asynchroniczną, a następnie, po jej zakończeniu, wywołuje funkcję <code>resolve</code> w celu rozwiązania obietnicy lub odrzuca ją, jeśli wystąpił błąd. Jeśli błąd zostanie zgłoszony w tej funkcji, obietnica zostaje odrzucona. Wartość zwracana tej funkcji jest ignorowana.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p><code><strong>Promise</strong></code> jest proxy dla wartości niekoniecznie znanej, gdy jest tworzona. Pozwala na kojarzenie uchwytu z ewentualnym sukcesem lub porażką asynchroniczne akcji. Pozwala to metodom asynchronicznym zwracać wartości takie jak metody synchroniczne, zamiast natychmiastowego zwracania wartości końcowej, metoda asynchroniczna zwraca <em>obietnicę </em>dostarczenia wartości w pewnym momencie w przyszłości.</p> + +<p><code>Promise</code> jest dostępny w jednym z tych stanów:</p> + +<ul> + <li><em>pending</em>: stan inicjacji, ani wypełnione, ani odrzucone.</li> + <li><em>fulfilled</em>: operacja zakończona sukcesem.</li> + <li><em>rejected</em>: operacja zakończona porażką.</li> +</ul> + +<p>Obowiązująca objetnica może być <em>zakończona </em>z wartością lub <em>odrzucona </em>z powodem(błędem). Kiedy dzieje się jedna z tych opcji, wywoływane są zakolejkowane, powiązane za pomocą metody <code>then</code> procedury. (Jeśli obietnica została już spełniona lub odrzucona, gdy dołączony jest odpowiedni moduł obsługi, zostanie on wywołany, więc nie ma potrzeby wyścigu między zakończeniem operacji asynchronicznej a jej obsługą).</p> + +<p>Tak jak w <code>{{jsxref("Promise.then", "Promise.prototype.then()")}}</code> oraz <code>{{jsxref("Promise.catch", "Promise.prototype.catch()")}}</code> gdy metoda zwróci obietnice, mogą one być łączone w łańcuchy.</p> + +<p><img alt="" src="https://mdn.mozillademos.org/files/8633/promises.png" style="height: 297px; width: 801px;"></p> + +<div class="note"> +<p><strong>Nie mylić z:</strong> Kilka innych języków ma mechanizmy leniwego oceniania i odraczania obliczeń, które nazywają również "obietnicami", np. Scheme. Obietnice w JavaScript oznaczają procesy, które już się odbywają, które mogą być powiązane z funkcjami wywołania zwrotnego. Jeśli chcesz leniwie oceniać wyrażenie, rozważ <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">funkcje strzałkowe</a> bez argumentów: <code>f = () => <em>wyrażenie</em></code> by stworzyć leniwo oszacowane wyrażenie, i <code>f()</code> by ocenić.</p> +</div> + +<div class="note"> +<p>Mówi się, że obietnica zostanie uregulowana, jeśli zostanie spełniona lub odrzucona, ale nie oczekuje na rozpatrzenie. Usłyszysz także termin <em>rozwiązany </em>używany z obietnicami - oznacza to, że obietnica jest ustalona lub "zamknięta", aby dopasować się do stanu innej obietnicy. <a href="https://github.com/domenic/promises-unwrapping/blob/master/docs/states-and-fates.md">Stany i losy</a> zawierają więcej szczegółów na temat obiecanej terminologii.</p> +</div> + +<h2 id="Właściwości">Właściwości</h2> + +<dl> + <dt><code>Promise.length</code></dt> + <dd>Właściwość Length, której wartość wynosi zawsze 1 (liczba argumentów konstruktora).</dd> + <dt>{{jsxref("Promise.prototype")}}</dt> + <dd>Reprezentuje prototyp konstruktora <code>Promise</code>.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Promise.all", "Promise.all(iterable)")}}</dt> + <dd>Zwraca obietnice, która albo kończy się sukcesem gdy wszystkie z obietnic w <code>iterable</code> się zakończą powodzeniem lub kończy sie porażką tak szybko jak jedna z obietnic skończy się porażką. Jeżeli zwrócona obietnica kończy się sukcesem jest ona wypełniana tablicą wartości z obietnic zakończonych sukcesem w takim samym układzie jak były one zdefiniowane w <code>iterable</code>. Jeżeli zwrócona obietnica zakończyła się porażką, jest ona odrzucana z Powodem z pierwszej obietnicy w <code>iterable</code>, która zakończyła się porażką. Ta metoda może być pomocna do zachowywania rezultatów różnych obietnic.</dd> + <dt>{{jsxref("Promise.race", "Promise.race(iterable)")}}</dt> + <dd>Returns a promise that fulfills or rejects as soon as one of the promises in the iterable fulfills or rejects, with the value or reason from that promise.</dd> +</dl> + +<dl> + <dt>{{jsxref("Promise.reject", "Promise.reject(reason)")}}</dt> + <dd>Returns a <code>Promise</code> object that is rejected with the given reason.</dd> +</dl> + +<dl> + <dt>{{jsxref("Promise.resolve", "Promise.resolve(value)")}}</dt> + <dd>Returns a <code>Promise</code> object that is resolved with the given value. If the value is a thenable (i.e. has a <code>then</code> method), the returned promise will "follow" that thenable, adopting its eventual state; otherwise the returned promise will be fulfilled with the value. Generally, if you don't know if a value is a promise or not, {{jsxref("Promise.resolve", "Promise.resolve(value)")}} it instead and work with the return value as a promise.</dd> +</dl> + +<h2 id="Promise_prototype">Promise prototype</h2> + +<h3 id="Właściwości_2">Właściwości</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Properties')}}</p> + +<h3 id="Metody_2">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Methods')}}</p> + +<h2 id="Tworzenie_Promise">Tworzenie Promise</h2> + +<p>A <code>Promise</code> object is created using the <code>new </code>keyword and its constructor. This constructor takes as its argument a function, called the "executor function". This function should take two functions as parameters. The first of these functions (<code>resolve</code>) is called when the asynchronous task completes successfully and returns the results of the task as a value. The second (<code>reject</code>) is called when the task fails, and returns the reason for failure, which is typically an error object.</p> + +<pre class="brush: js notranslate">const myFirstPromise = new Promise((resolve, reject) => { + // do something asynchronous which eventually calls either: + // + // resolve(someValue); // fulfilled + // or + // reject("failure reason"); // rejected +}); +</pre> + +<p>To provide a function with promise functionality, simply have it return a promise:</p> + +<pre class="brush: js notranslate">function myAsyncFunction(url) { + return new Promise((resolve, reject) => { + const xhr = new XMLHttpRequest(); + xhr.open("GET", url); + xhr.onload = () => resolve(xhr.responseText); + xhr.onerror = () => reject(xhr.statusText); + xhr.send(); + }); +}</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Podstawowy_przykład">Podstawowy przykład</h3> + +<pre class="brush: js notranslate">let myFirstPromise = new Promise((resolve, reject) => { + // We call resolve(...) when what we were doing asynchronously was successful, and reject(...) when it failed. + // In this example, we use setTimeout(...) to simulate async code. + // In reality, you will probably be using something like XHR or an HTML5 API. + setTimeout(function(){ + resolve("Success!"); // Yay! Everything went well! + }, 250); +}); + +myFirstPromise.then((successMessage) => { + // successMessage is whatever we passed in the resolve(...) function above. + // It doesn't have to be a string, but if it is only a succeed message, it probably will be. + console.log("Yay! " + successMessage); +}); +</pre> + +<h3 id="Zaawansowany_Przykład">Zaawansowany Przykład</h3> + +<pre class="brush: html hidden notranslate"><button id="btn">Make a promise!</button> +<div id="log"></div> +</pre> + +<p>This small example shows the mechanism of a <code>Promise</code>. The <code>testPromise()</code> method is called each time the {{HTMLElement("button")}} is clicked. It creates a promise that will be fulfilled, using {{domxref("window.setTimeout()")}}, to the promise count (number starting from 1) every 1-3 seconds, at random. The <code>Promise()</code> constructor is used to create the promise.</p> + +<p>The fulfillment of the promise is simply logged, via a fulfill callback set using {{jsxref("Promise.prototype.then()","p1.then()")}}. A few logs show how the synchronous part of the method is decoupled from the asynchronous completion of the promise.</p> + +<pre class="brush: js notranslate">'use strict'; +var promiseCount = 0; + +function testPromise() { + let thisPromiseCount = ++promiseCount; + + let log = document.getElementById('log'); + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Started (<small>Sync code started</small>)<br/>'); + + // We make a new promise: we promise a numeric count of this promise, starting from 1 (after waiting 3s) + let p1 = new Promise( + // The resolver function is called with the ability to resolve or + // reject the promise + (resolve, reject) => { + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Promise started (<small>Async code started</small>)<br/>'); + // This is only an example to create asynchronism + window.setTimeout( + function() { + // We fulfill the promise ! + resolve(thisPromiseCount); + }, Math.random() * 2000 + 1000); + } + ); + + // We define what to do when the promise is resolved with the then() call, + // and what to do when the promise is rejected with the catch() call + p1.then( + // Log the fulfillment value + function(val) { + log.insertAdjacentHTML('beforeend', val + + ') Promise fulfilled (<small>Async code terminated</small>)<br/>'); + }) + .catch( + // Log the rejection reason + (reason) => { + console.log('Handle rejected promise ('+reason+') here.'); + }); + + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Promise made (<small>Sync code terminated</small>)<br/>'); +}</pre> + +<pre class="brush:js hidden notranslate">if ("Promise" in window) { + let btn = document.getElementById("btn"); + btn.addEventListener("click",testPromise); +} else { + log = document.getElementById('log'); + log.innerHTML = "Live example not available as your browser doesn't support the <code>Promise<code> interface."; +} +</pre> + +<p>This example is started by clicking the button. You need a browser that supports <code>Promise</code>. By clicking the button several times in a short amount of time, you'll even see the different promises being fulfilled one after another.</p> + +<p>{{EmbedLiveSample("Advanced_Example", "500", "200")}}</p> + +<h2 id="Ładowanie_obrazka_z_XHR">Ładowanie obrazka z XHR</h2> + +<p>Another simple example using <code>Promise</code> and <code><a href="/en-US/docs/Web/API/XMLHttpRequest">XMLHttpRequest</a></code> to load an image is available at the MDN GitHub<a href="https://github.com/mdn/js-examples/tree/master/promises-test"> js-examples</a> repository. You can also <a href="https://mdn.github.io/js-examples/promises-test/">see it in action</a>. Each step is commented and allows you to follow the Promise and XHR architecture closely.</p> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-promise-objects', 'Promise')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition in an ECMA standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-promise-objects', 'Promise')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2> + +<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Promise")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Using_promises">Using promises</a></li> + <li><a href="http://promisesaplus.com/">Promises/A+ specification</a></li> + <li><a href="https://medium.com/@ramsunvtech/promises-of-promise-part-1-53f769245a53">Venkatraman.R - JS Promise (Part 1, Basics)</a></li> + <li><a href="https://medium.com/@ramsunvtech/js-promise-part-2-q-js-when-js-and-rsvp-js-af596232525c#.dzlqh6ski">Venkatraman.R - JS Promise (Part 2 - Using Q.js, When.js and RSVP.js)</a></li> + <li><a href="https://tech.io/playgrounds/11107/tools-for-promises-unittesting/introduction">Venkatraman.R - Tools for Promises Unit Testing</a></li> + <li><a href="http://www.html5rocks.com/en/tutorials/es6/promises/">Jake Archibald: JavaScript Promises: There and Back Again</a></li> + <li><a href="http://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript">Domenic Denicola: Callbacks, Promises, and Coroutines – Asynchronous Programming Patterns in JavaScript</a></li> + <li><a href="http://www.mattgreer.org/articles/promises-in-wicked-detail/">Matt Greer: JavaScript Promises ... In Wicked Detail</a></li> + <li><a href="https://www.promisejs.org/">Forbes Lindesay: promisejs.org</a></li> + <li><a href="https://github.com/jakearchibald/es6-promise/">Promise polyfill</a></li> + <li><a href="https://www.udacity.com/course/javascript-promises--ud898">Udacity: JavaScript Promises</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/proxy/handler/apply/index.html b/files/pl/web/javascript/referencje/obiekty/proxy/handler/apply/index.html new file mode 100644 index 0000000000..4931dd2beb --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/proxy/handler/apply/index.html @@ -0,0 +1,117 @@ +--- +title: handler.apply() +slug: Web/JavaScript/Referencje/Obiekty/Proxy/handler/apply +tags: + - ECMAScript 2015 + - JavaScript + - Metodă + - Proxy +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>handler.apply()</code></strong> jest pułapką na wywołanie funkcji.</p> + +<div>{{EmbedInteractiveExample("pages/js/proxyhandler-apply.html", "taller")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js">var p = new Proxy(target, { + apply: function(target, thisArg, argumentsList) { + } +}); +</pre> + +<h3 id="Parametry">Parametry</h3> + +<p>Następujące parametry są przekazywane do metody <code>apply</code>. Wartością <code>this</code> jest handler.</p> + +<dl> + <dt><code>target</code></dt> + <dd>Obiekt, na którym została wywołana metoda.</dd> + <dt><code>thisArg</code></dt> + <dd>Obiekt, który jest <code>this</code> w metodzie.</dd> + <dt><code>argumentsList</code></dt> + <dd>Lista argumentów, które zostały przekazane do metody.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Metoda <code>apply</code> może zwrócić dowolną wartość.</p> + +<h2 id="Opis">Opis</h2> + +<p>Metoda <code><strong>handler.apply</strong></code> jest pułapką na wywołanie funkcji.</p> + +<h3 id="Przechwycenia">Przechwycenia</h3> + +<p>Ta pułapka może przechwycić poniższe operacje:</p> + +<ul> + <li><code>proxy(...args)</code></li> + <li>{{jsxref("Function.prototype.apply()")}} i {{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Reflect.apply()")}}</li> +</ul> + +<h3 id="Niezmienniki">Niezmienniki</h3> + +<p>Jeśli poniższe zmiemienniki są naruszone, poxy rzuci wyjątek TypeError:</p> + +<p><code>target</code> musi być obiektem, który da się wywołać. To znaczy, że musi być obiektem funkcyjnym.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Poniższy kod przechwytuje wywołanie funkcji.</p> + +<pre class="brush: js">var p = new Proxy(function() {}, { + apply: function(target, thisArg, argumentsList) { + console.log('called: ' + argumentsList.join(', ')); + return argumentsList[0] + argumentsList[1] + argumentsList[2]; + } +}); + +console.log(p(1, 2, 3)); // "called: 1, 2, 3" + // 6 +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist', '[[Call]]')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist', '[[Call]]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Proxy.handler.apply")}}</p> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Proxy")}}</li> + <li>{{jsxref("Proxy.handler", "handler")}}</li> + <li>{{jsxref("Function.prototype.apply")}}</li> + <li>{{jsxref("Function.prototype.call")}}</li> + <li>{{jsxref("Reflect.apply()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/proxy/handler/index.html b/files/pl/web/javascript/referencje/obiekty/proxy/handler/index.html new file mode 100644 index 0000000000..15fbc4d469 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/proxy/handler/index.html @@ -0,0 +1,77 @@ +--- +title: Proxy handler +slug: Web/JavaScript/Referencje/Obiekty/Proxy/handler +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy +--- +<div>{{JSRef}}</div> + +<p>Obiekt obsługujący proxy (proxy's handler object) jest obiektem zastępczym który zawiera pułapki dla obiektów {{jsxref("Proxy", "proxy", "", 1)}}.</p> + +<h2 id="Metody">Metody</h2> + +<p>Wszystkie pułapki są opcjonalne. Jeśli pułapka nie została zdefiniowana, domyślnym zachowaniem jest przekazanie operacji do obiektu docelowego.</p> + +<dl> + <dt>{{jsxref("Global_Objects/Proxy/handler/getPrototypeOf", "handler.getPrototypeOf()")}}</dt> + <dd>Pułapka na {{jsxref("Object.getPrototypeOf")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/setPrototypeOf", "handler.setPrototypeOf()")}}</dt> + <dd>Pułapka na {{jsxref("Object.setPrototypeOf")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/isExtensible", "handler.isExtensible()")}}</dt> + <dd>Pułapka na {{jsxref("Object.isExtensible")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/preventExtensions", "handler.preventExtensions()")}}</dt> + <dd>Pułapka na {{jsxref("Object.preventExtensions")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/getOwnPropertyDescriptor", "handler.getOwnPropertyDescriptor()")}}</dt> + <dd>Pułapka na {{jsxref("Object.getOwnPropertyDescriptor")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/defineProperty", "handler.defineProperty()")}}</dt> + <dd>Pułapka na {{jsxref("Object.defineProperty")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/has", "handler.has()")}}</dt> + <dd>Pułapka na operator {{jsxref("Operators/in", "in")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/get", "handler.get()")}}</dt> + <dd>Pułapka na pobieranie wartości atrybutu.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/set", "handler.set()")}}</dt> + <dd>Pułapka na ustawianie wartości atrybutu.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/deleteProperty", "handler.deleteProperty()")}}</dt> + <dd>Pułapka na operator {{jsxref("Operators/delete", "delete")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/ownKeys", "handler.ownKeys()")}}</dt> + <dd>Pułapka na {{jsxref("Object.getOwnPropertyNames")}} i {{jsxref("Object.getOwnPropertySymbols")}}.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/apply", "handler.apply()")}}</dt> + <dd>Pułapka na wywołanie funkcji.</dd> + <dt>{{jsxref("Global_Objects/Proxy/handler/construct", "handler.construct()")}}</dt> + <dd>Pułapka na operator {{jsxref("Operators/new", "new")}}.</dd> +</dl> + +<p>Niektóre niestandardowe pułapki są <a href="/en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features#Proxy">przestarzałe i zostały usunięte</a>.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots', 'Proxy Object Internal Methods and Internal Slots')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots', 'Proxy Object Internal Methods and Internal Slots')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Usunięto funkcję obsługującą <code>enumerate</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.Proxy.handler")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Proxy")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/proxy/index.html b/files/pl/web/javascript/referencje/obiekty/proxy/index.html new file mode 100644 index 0000000000..7dc7695f00 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/proxy/index.html @@ -0,0 +1,401 @@ +--- +title: Proxy +slug: Web/JavaScript/Referencje/Obiekty/Proxy +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy +--- +<div> +<div>{{JSRef}}</div> +</div> + +<p>Obiekt <strong>Proxy</strong> jest używany w celu definiowania specyficznego zachowania dla podstawowych operacji (n.p. wyszukiwanie atrybutu, przypisanie, wyliczanie, wywołanie funkcji, etc).</p> + +<h2 id="Terminologia">Terminologia</h2> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler">handler</a></dt> + <dd>Zastępczy obiekt zawierający pułapki (traps).</dd> + <dt>traps</dt> + <dd>Metody zapewniające dostęp do atrybutów. Pojęcie to jest analogiczne do pułapek w systemie operacyjnym.</dd> + <dt>target</dt> + <dd>Obiekt wirtualizowany przez proxy. Często jest używany aby magazyować dane obiektu proxy. Niezmienniki (wartości które pozostają niezmienione) dotyczące nierozszerzalności obiektu lub niekonfigurowalnnych atrybutów są weryfikowane w oparciu o <strong>target</strong>.</dd> +</dl> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">var p = new Proxy(target, handler); +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>target</code></dt> + <dd>Docelowy obiekt (może być obiektem dowolnego typu, włącznie z wbudowanymi tablicami, funkcjami, a nawet innyi obiektami proxy) przeznaczony do opakowania przez <code>Proxy</code>.</dd> + <dt><code>handler</code></dt> + <dd>Obiekt obsługujący którego atrybuty są funkcjami definiującymi zachowanie proxy podczas wykonania na nim operacji.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Proxy.revocable()")}}</dt> + <dd>Tworzy odwracalny obiekt <code>Proxy</code>.</dd> +</dl> + +<h2 id="Metody_obiektu_obsługującego">Metody obiektu obsługującego</h2> + +<p>Obiekt obsługujący jest obiektem zastępczym zawierającym pułapki dla obieku <code>Proxy</code>.</p> + +<div>{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Proxy/handler', 'Metody') }}</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Podstawowy_przykład">Podstawowy przykład</h3> + +<p>W tym prostym przykładzie liczba <code>37</code> jest zwracana jako domyślna wartość kiedy nazwa atrybutu nie istnieje w obiekcie. W tym celu użyty jest handler <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get"><code>get</code></a>.</p> + +<pre class="brush: js">var handler = { + get: function(target, name) { + return name in target ? + target[name] : + 37; + } +}; + +var p = new Proxy({}, handler); +p.a = 1; +p.b = undefined; + +console.log(p.a, p.b); // 1, undefined +console.log('c' in p, p.c); // false, 37 +</pre> + +<h3 id="Puste_proxy_przekazujące">Puste proxy przekazujące</h3> + +<p>W tym przykładzie używamy wbudowanego obiektu JavaScript do którego proxy przekaże wszystkie zaaplikowane na nim operacje.</p> + +<pre class="brush: js">var target = {}; +var p = new Proxy(target, {}); + +p.a = 37; // operacja przekazana do obiektu target + +console.log(target.a); // 37. Operacja została prawidłowo przekazana +</pre> + +<p>Zwróć uwagę, że ten przykład działa dla obiektów JavaScript jednak nie sprawdzi się w przypadku obiektów przeglądarki takich jak elementy DOM. <a href="/en-US/docs/">Sprawdź jedno rozwiązanie</a>.</p> + +<h3 id="Walidacja">Walidacja</h3> + +<p>Używając <code>Proxy</code>, łatwo możesz zwalidować wartości przekazywane do obiektu. Poniższy przykład używa metody obsługującej <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"><code>set</code></a>.</p> + +<pre class="brush: js">let validator = { + set: function(obj, prop, value) { + if (prop === 'age') { + if (!Number.isInteger(value)) { + throw new TypeError('The age is not an integer'); + } + if (value > 200) { + throw new RangeError('The age seems invalid'); + } + } + + // domyślnym zachowaniem jest zapisanie wartości + obj[prop] = value; + + // oznacza pomyślne wykonanie + return true; + } +}; + +let person = new Proxy({}, validator); + +person.age = 100; +console.log(person.age); // 100 +person.age = 'young'; // rzuca wyjątek +person.age = 300; // rzuca wyjątek</pre> + +<h3 id="Rozszerzanie_konstruktora">Rozszerzanie konstruktora</h3> + +<p>Funkcja proxy może w łatwy sposób rozszerzyć konstruktor innym konstruktorem. W tym przykładzie użyto funkcje obsługujące <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/construct"><code>construct</code></a> oraz <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/apply"><code>apply</code></a>.</p> + +<pre class="brush: js">function extend(sup, base) { + var descriptor = Object.getOwnPropertyDescriptor( + base.prototype, 'constructor' + ); + base.prototype = Object.create(sup.prototype); + var handler = { + construct: function(target, args) { + var obj = Object.create(base.prototype); + this.apply(target, obj, args); + return obj; + }, + apply: function(target, that, args) { + sup.apply(that, args); + base.apply(that, args); + } + }; + var proxy = new Proxy(base, handler); + descriptor.value = proxy; + Object.defineProperty(base.prototype, 'constructor', descriptor); + return proxy; +} + +var Person = function(name) { + this.name = name; +}; + +var Boy = extend(Person, function(name, age) { + this.age = age; +}); + +Boy.prototype.sex = 'M'; + +var Peter = new Boy('Peter', 13); +console.log(Peter.sex); // "M" +console.log(Peter.name); // "Peter" +console.log(Peter.age); // 13</pre> + +<h3 id="Manipulacja_węzłami_DOM">Manipulacja węzłami DOM</h3> + +<p>Czasami konieczne jest przełączenie atrybutu lub nazwy klasy dwóch innych elementów. Poniższy przykład pokazuje wykonanie funkcją obsługującą <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"><code>set</code></a>.</p> + +<pre class="brush: js">let view = new Proxy({ + selected: null +}, +{ + set: function(obj, prop, newval) { + let oldval = obj[prop]; + + if (prop === 'selected') { + if (oldval) { + oldval.setAttribute('aria-selected', 'false'); + } + if (newval) { + newval.setAttribute('aria-selected', 'true'); + } + } + + // The default behavior to store the value + obj[prop] = newval; + + // Indicate success + return true; + } +}); + +let i1 = view.selected = document.getElementById('item-1'); +console.log(i1.getAttribute('aria-selected')); // 'true' + +let i2 = view.selected = document.getElementById('item-2'); +console.log(i1.getAttribute('aria-selected')); // 'false' +console.log(i2.getAttribute('aria-selected')); // 'true'</pre> + +<h3 id="Korekcja_wartości_i_dodatkowych_atrybutów">Korekcja wartości i dodatkowych atrybutów</h3> + +<p>Obiekt proxy <code>products</code> wylicza przekazaną wartość i konwertuje to tablicy w razie potrzeby. Obiekt dodatkowo obsługuje dodatkowy atrybut <code>latestBrowser</code> zarówno jako getter i setter.</p> + +<pre class="brush: js">let products = new Proxy({ + browsers: ['Internet Explorer', 'Netscape'] +}, +{ + get: function(obj, prop) { + // An extra property + if (prop === 'latestBrowser') { + return obj.browsers[obj.browsers.length - 1]; + } + + // The default behavior to return the value + return obj[prop]; + }, + set: function(obj, prop, value) { + // An extra property + if (prop === 'latestBrowser') { + obj.browsers.push(value); + return true; + } + + // Convert the value if it is not an array + if (typeof value === 'string') { + value = [value]; + } + + // The default behavior to store the value + obj[prop] = value; + + // Indicate success + return true; + } +}); + +console.log(products.browsers); // ['Internet Explorer', 'Netscape'] +products.browsers = 'Firefox'; // przekazano string (przez pomyłkę) +console.log(products.browsers); // ['Firefox'] <- nie ma problemu, wartość jest typu array + +products.latestBrowser = 'Chrome'; +console.log(products.browsers); // ['Firefox', 'Chrome'] +console.log(products.latestBrowser); // 'Chrome'</pre> + +<h3 id="Wyszukiwanie_elementu_tablicy_po_jego_właściwości">Wyszukiwanie elementu tablicy po jego właściwości</h3> + +<p>Poniższe proxy rozszerza tablicę o różne użyteczne funkcjonalności. Jak widać, można elastycznie "definiować" właściwości bez użycia <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties"><code>Object.defineProperties</code></a>. Ten przykład może być użyty aby znaleźć wiersz tabeli po jego komórce. W takim przypadku, celem będzie <a href="/en-US/docs/DOM/table.rows"><code>table.rows</code></a>.</p> + +<pre class="brush: js">let products = new Proxy([ + { name: 'Firefox', type: 'browser' }, + { name: 'SeaMonkey', type: 'browser' }, + { name: 'Thunderbird', type: 'mailer' } +], +{ + get: function(obj, prop) { + // domyślnym zachowaniem jest zwrócenie wartości; prop jest zwykle typu integer + if (prop in obj) { + return obj[prop]; + } + + // zwróć liczbę produktów; alias dla products.length + if (prop === 'number') { + return obj.length; + } + + let result, types = {}; + + for (let product of obj) { + if (product.name === prop) { + result = product; + } + if (types[product.type]) { + types[product.type].push(product); + } else { + types[product.type] = [product]; + } + } + + // znajdź product po nazwie + if (result) { + return result; + } + + // znajdź produkty po typie + if (prop in types) { + return types[prop]; + } + + // zwróć typy produktów + if (prop === 'types') { + return Object.keys(types); + } + + return undefined; + } +}); + +console.log(products[0]); // { name: 'Firefox', type: 'browser' } +console.log(products['Firefox']); // { name: 'Firefox', type: 'browser' } +console.log(products['Chrome']); // undefined +console.log(products.browser); // [{ name: 'Firefox', type: 'browser' }, { name: 'SeaMonkey', type: 'browser' }] +console.log(products.types); // ['browser', 'mailer'] +console.log(products.number); // 3 +</pre> + +<h3 id="Pełna_lista_przykładów_pułapek">Pełna lista przykładów <code>pułapek</code></h3> + +<p>W celu stworzenia pełnej listy przykładów <code>pułapek</code>, w celach dydaktycznych, spróbujemy zastosować proxy na<em>nie natywnym obiekcie </em>który się szczególnie nadaje do tego typu operacji: globalny obiekt <code>docCookies</code> stworzony przez <a href="https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie/Simple_document.cookie_framework" title="https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support">"mały framework" opublikowany na stronie <code>document.cookie</code></a>.</p> + +<pre class="brush: js">/* + var docCookies = ... pobranie obiektu "docCookies" tutaj: + https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support +*/ + +var docCookies = new Proxy(docCookies, { + get: function (oTarget, sKey) { + return oTarget[sKey] || oTarget.getItem(sKey) || undefined; + }, + set: function (oTarget, sKey, vValue) { + if (sKey in oTarget) { return false; } + return oTarget.setItem(sKey, vValue); + }, + deleteProperty: function (oTarget, sKey) { + if (sKey in oTarget) { return false; } + return oTarget.removeItem(sKey); + }, + enumerate: function (oTarget, sKey) { + return oTarget.keys(); + }, + ownKeys: function (oTarget, sKey) { + return oTarget.keys(); + }, + has: function (oTarget, sKey) { + return sKey in oTarget || oTarget.hasItem(sKey); + }, + defineProperty: function (oTarget, sKey, oDesc) { + if (oDesc && 'value' in oDesc) { oTarget.setItem(sKey, oDesc.value); } + return oTarget; + }, + getOwnPropertyDescriptor: function (oTarget, sKey) { + var vValue = oTarget.getItem(sKey); + return vValue ? { + value: vValue, + writable: true, + enumerable: true, + configurable: false + } : undefined; + }, +}); + +/* Cookies test */ + +console.log(docCookies.my_cookie1 = 'First value'); +console.log(docCookies.getItem('my_cookie1')); + +docCookies.setItem('my_cookie1', 'Changed value'); +console.log(docCookies.my_cookie1);</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES2016', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2016')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES2017', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2017')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.Proxy", 2)}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a class="external" href="https://www.youtube.com/watch?v=sClk6aB_CPk">"Proxies are awesome" Brendan Eich presentation at JSConf</a> (<a class="external" href="http://www.slideshare.net/BrendanEich/metaprog-5303821">slides</a>)</li> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies">ECMAScript Harmony Proxy proposal page</a> and <a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies_semantics">ECMAScript Harmony proxy semantics page</a></li> + <li><a class="external" href="http://soft.vub.ac.be/~tvcutsem/proxies/">Tutorial on proxies</a></li> + <li><a href="/en-US/docs/JavaScript/Old_Proxy_API" title="/en-US/docs/JavaScript/Old_Proxy_API">SpiderMonkey specific Old Proxy API</a></li> + <li>{{jsxref("Object.watch()")}} is a non-standard feature but has been supported in Gecko for a long time.</li> +</ul> + +<h2 id="Licensing_note">Licensing note</h2> + +<p>Some content (text, examples) in this page has been copied or adapted from the <a class="external" href="http://wiki.ecmascript.org/doku.php">ECMAScript wiki</a> which content is licensed <a class="external" href="http://creativecommons.org/licenses/by-nc-sa/2.0/">CC 2.0 BY-NC-SA</a>.</p> diff --git a/files/pl/web/javascript/referencje/obiekty/rangeerror/index.html b/files/pl/web/javascript/referencje/obiekty/rangeerror/index.html new file mode 100644 index 0000000000..13c2981e8d --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/rangeerror/index.html @@ -0,0 +1,162 @@ +--- +title: RangeError +slug: Web/JavaScript/Referencje/Obiekty/RangeError +translation_of: Web/JavaScript/Reference/Global_Objects/RangeError +--- +<div>{{JSRef}}</div> + +<p>Obiekt <code><strong>RangeError</strong></code> wskazuje na błąd, gdy wartość jest poza zakresem dozwolonych wartości.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code>new RangeError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>message</code></dt> + <dd><code>Opcjonalne. Czytelny opis błędu.</code></dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Opcjonalne. Nazwa pliku zawierającego kod, któy wywołał wyjątek.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Opcjonalne. Numer linii kodu, gdzie wywołany został wyjątek.</dd> +</dl> + +<h2 id="sect1"> </h2> + +<h2 id="Opis">Opis</h2> + +<p><code>RangeError</code> rzucany jest podczas próby przesłaniu numeru, jako argumentu do funkcji, która nie pozwala na zakresy zawierające ten numer. To może zdarzyć się podczas próby stworzenia listy (array) o niedozwolonej długości za pomocą konstruktora {{jsxref("Array")}}, lub podczas wywołania metod {{jsxref("Number.toExponential()")}}, {{jsxref("Number.toFixed()")}} lub {{jsxref("Number.toPrecision()")}} z przekazaną złą wartością.</p> + +<p> </p> + +<h2 id="Właściwości">Właściwości</h2> + +<dl> + <dt>{{jsxref("RangeError.prototype")}}</dt> + <dd>Pozwala na dodanie właściwości do obiektu RangeError.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<p><code>RangeError</code> nie posiada metod jako takich, ale dziedziczy pewne metody z łańcucha prototypów.</p> + +<h2 id="Instancje_RangeError"><code>Instancje RangeError</code></h2> + +<h3 id="Właściwości_2">Właściwości</h3> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/RangeError/prototype', 'Właściwości')}}</div> + +<h3 id="Metody_2">Metody</h3> + +<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/RangeError/prototype', 'Metody')}}</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_RangeError">Użycie <code>RangeError</code></h3> + +<pre class="brush: js">var check = function(num) { + if (num < MIN || num > MAX) { + throw new RangeError('Parameter must be between ' + MIN + ' and ' + MAX); + } +}; + +try { + check(500); +} +catch (e) { + if (e instanceof RangeError) { + // Handle range error + } +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.2', 'RangeError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-rangeerror', 'RangeError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Bazowe wsparcie</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Bazowe wsparcie</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("RangeError.prototype")}}</li> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Number.toExponential()")}}</li> + <li>{{jsxref("Number.toFixed()")}}</li> + <li>{{jsxref("Number.toPrecision()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/rangeerror/prototype/index.html b/files/pl/web/javascript/referencje/obiekty/rangeerror/prototype/index.html new file mode 100644 index 0000000000..55beba5bc8 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/rangeerror/prototype/index.html @@ -0,0 +1,123 @@ +--- +title: RangeError.prototype +slug: Web/JavaScript/Referencje/Obiekty/RangeError/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/RangeError +--- +<div>{{JSRef}}</div> + +<p><code><font face="Open Sans, Arial, sans-serif">Właściwość </font><strong>RangeError.prototype</strong></code> reprezentuje prototyp konstuktora {{jsxref("RangeError")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Opis">Opis </h2> + +<p>Wszystkie instancje {{jsxref("RangeError")}} dziedziczą z prototyup RangeError. Możesz użyć prototypu, by dodać właściwości lub metody do wszystkich instancji.</p> + +<h2 id="Właściwości">Właściwości</h2> + +<dl> + <dt><code>RangeError.prototype.constructor</code></dt> + <dd>Funkcja, która tworzy prototyp instancji.</dd> + <dt>{{jsxref("Error.prototype.message", "RangeError.prototype.message")}}</dt> + <dd>Wiadomość błędu. Chociaż specyfikacja ECMA-262 mówi, że <span style="line-height: 1.5;">{{jsxref("RangeError")}} powinien dostarczyć swoją własną właściwość </span><code style="font-style: normal; line-height: 1.5;">message</code><span style="line-height: 1.5;">, w </span><a href="/en-US/docs/Mozilla/Projects/SpiderMonkey" style="line-height: 1.5;">SpiderMonkey</a><span style="line-height: 1.5;">, dziedziczy z {{jsxref("Error.prototype.message")}}.</span></dd> + <dt>{{jsxref("Error.prototype.name", "RangeError.prototype.name")}}</dt> + <dd>Nazwa błędu, dziedziczona z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "RangeError.prototype.fileName")}}</dt> + <dd>Ścieżka do pliku, w którym wywołany został błąd. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "RangeError.prototype.lineNumber")}}</dt> + <dd>Numer linii, gdzie wywołany został błąd. Dziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "RangeError.prototype.columnNumber")}}</dt> + <dd>Numer kolumny w linii, gdzie wywołany został błąd. Dziedziczone z <span style="line-height: 1.5;">{{jsxref("Error")}}.</span></dd> + <dt>{{jsxref("Error.prototype.stack", "RangeError.prototype.stack")}}</dt> + <dd>Ślad stosu. Dziedziczone z {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<p>Chociaż prototyp <span style="line-height: 1.5;">{{jsxref("RangeError")}} nie zawiera metod jako taki, instancja </span><span style="line-height: 1.5;">{{jsxref("RangeError")}} dziedziczy pewne metody z łańcucha prototypów.</span></p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Defined as <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Defined as <code><em>NativeError</em>.prototype</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Bazowe wsparcie</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Bazowe wsparcie</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/exec/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/exec/index.html new file mode 100644 index 0000000000..618ec13d69 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/exec/index.html @@ -0,0 +1,144 @@ +--- +title: RegExp.prototype.exec() +slug: Web/JavaScript/Referencje/Obiekty/RegExp/exec +tags: + - JavaScript + - Method + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec +--- +<p>{{ JSRef }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wykonuje operacje wyszukiwania danego łańcucha znaków. Wynikiem jest macierz.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>regexObj</var>.exec(<var>str</var>)</code></pre> + +<p> </p> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>str</code> </dt> + <dd>Łańcuch znaków, do którego ma być porównane wyrażenie.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jak wynika z opisu składni metoda exec może być wywołana w sposób bezpośredni (za pomocą <code>regexp.exec(str)</code>) lub pośredni (za pomocą <code>regexp(str)</code>).</p> + +<p>Jeśli wynik będzie pozytywny metoda <code>exec</code> zwróci macierz oraz zaktualizuje własności obiektu. W przeciwnym wypadku zostanie zwrócone <code>null</code>.</p> + +<p>Przejrzyj poniższy przykład:</p> + +<pre class="brush: js">//Znajdź pojedyncze "d" poprzedzone przez jedno lub więcej "b", po których następuje pojedyncze "d" +//Zapamiętaj znalezione "b" oraz następujące "d" +//Ignoruj wielkość liter +var re=/d(b+)(d)/ig; +var myArray = re.exec("cdbBdbsbz"); +</pre> + +<p>Poniższa tabela pokazuje rezultaty wygenerowane przez skrypt:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Obiekt</td> + <td class="header">Właściwość/Indeks</td> + <td class="header">Opis</td> + <td class="header">Przykład</td> + </tr> + <tr> + <td rowspan="5"><code>myArray</code></td> + <td><code> </code></td> + <td>Zawartość <code>myArray</code>.</td> + <td><code>[ \"dbBd\", \"bB\", \"d\"') ]</code></td> + </tr> + <tr> + <td><code>index</code></td> + <td>Indeks wyszukania łańcucha znaków rozpoczynający się od 0.</td> + <td><code>1</code></td> + </tr> + <tr> + <td><code>input</code></td> + <td>Ciąg bazowy.</td> + <td><code>cdbBdbsbz</code></td> + </tr> + <tr> + <td><code>[0]</code></td> + <td>Ostatnie odnalezione znaki.</td> + <td><code>dbBd</code></td> + </tr> + <tr> + <td><code>[1], ...[<em>n</em> ]</code></td> + <td>Wyszukane podłańcuch w nawiasach. Liczba możliwych podłańcuch jest nieokreślona.</td> + <td><code>[1] = bB<br> + [2] = d</code></td> + </tr> + <tr> + <td rowspan="5"><code>myRe</code></td> + <td><code>lastIndex</code></td> + <td>Indeks, od którego rozpocząć nowe wyszukiwanie.</td> + <td><code>5</code></td> + </tr> + <tr> + <td><code>ignoreCase</code></td> + <td>Wskazuje czy flaga "<code>i</code>" została użyta.</td> + <td><code>true</code></td> + </tr> + <tr> + <td><code>global</code></td> + <td>Wskazuje czy flaga "<code>g</code>" została użyta do globalnego przeszukiwania.</td> + <td><code>true</code></td> + </tr> + <tr> + <td><code>multiline</code></td> + <td>Wskazuje czy flaga "<code>m</code>" została użyta do globalnego przeszukiwania.</td> + <td><code>false</code></td> + </tr> + <tr> + <td><code>source</code></td> + <td>Tekst wyszukiwanego łańcucha znaków.</td> + <td><code>d(b+)(d)</code></td> + </tr> + </tbody> +</table> + +<p>Jeżeli twoje wyrażenie regularne korzysta z flagi "g", możesz wielokrotnie używać metody exec() aby porównać je z tym samym ciągiem znaków. W takim wypadku porównywanie rozpoczyna się od elementu zdefiniowanego jako <code>lastIndex. </code>Na przykład:</p> + +<pre class="brush: js language-js"><code class="language-js"><span class="keyword token">var</span> myRe <span class="operator token">=</span> <span class="regex token">/ab*/g</span><span class="punctuation token">;</span> +<span class="keyword token">var</span> str <span class="operator token">=</span> <span class="string token">'abbcdefabh'</span><span class="punctuation token">;</span> +<span class="keyword token">var</span> myArray<span class="punctuation token">;</span> +<span class="keyword token">while</span> <span class="punctuation token">(</span><span class="punctuation token">(</span>myArray <span class="operator token">=</span> myRe<span class="punctuation token">.</span><span class="function token">exec<span class="punctuation token">(</span></span>str<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">!</span><span class="operator token">==</span> <span class="keyword token">null</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> msg <span class="operator token">=</span> <span class="string token">'Found '</span> <span class="operator token">+</span> myArray<span class="punctuation token">[</span><span class="number token">0</span><span class="punctuation token">]</span> <span class="operator token">+</span> <span class="string token">'. '</span><span class="punctuation token">;</span> + msg <span class="operator token">+</span><span class="operator token">=</span> <span class="string token">'Next match starts at '</span> <span class="operator token">+</span> myRe<span class="punctuation token">.</span>lastIndex<span class="punctuation token">;</span> + console<span class="punctuation token">.</span><span class="function token">log<span class="punctuation token">(</span></span>msg<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></pre> + +<p>Skrypt ten wyświetli następujący tekst:</p> + +<pre>Found abb. Next match starts at 3 +Found ab. Next match starts at 9 +</pre> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_exec" name="Przyk.C5.82ad:_Zastosowanie_exec">Przykład: Zastosowanie <code>exec()</code></h3> + +<p>You can also use <code>exec()</code> without creating a {{jsxref("RegExp")}} object:</p> + +<pre class="brush: js language-js"><code class="language-js"><span class="keyword token">var</span> matches <span class="operator token">=</span> <span class="regex token">/(hello \S+)/</span><span class="punctuation token">.</span><span class="function token">exec<span class="punctuation token">(</span></span><span class="string token">'This is a hello world!'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +console<span class="punctuation token">.</span><span class="function token">log<span class="punctuation token">(</span></span>matches<span class="punctuation token">[</span><span class="number token">1</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>This will display an alert containing 'hello world!'.</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="https://developer.mozilla.org//pl/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("RegExp")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/global/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/global/index.html new file mode 100644 index 0000000000..e393cbeed0 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/global/index.html @@ -0,0 +1,35 @@ +--- +title: RexExp.prototype.global +slug: Web/JavaScript/Referencje/Obiekty/RegExp/global +tags: + - JavaScript + - Property + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/global +--- +<div>{{JSRef("Global_Objects", "RegExp")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Określa czy z wyrażeniem regularnym została użyta flaga "<code>g</code>".</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>global</code> jest własnością pojedynczego obiektu wyrażenia regularnego.</p> + +<p>Wartość <code>global</code> wynosi true, jeśli użyta została flaga "<code>g</code>"; w przeciwnym przypadku będzie to wartość <code>false</code>. Flaga "<code>g</code>" wskazuje, że wyrażenie regularne powinno zostać sprawdzone w stosunku do wszystkich możliwych wyników w łańcuchu znaków.</p> + +<p>Tej własności nie można zmieniać bezpośrednio.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("RegExp.lastIndex")}}</li> + <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li> + <li>{{jsxref("RegExp.prototype.multiline")}}</li> + <li>{{jsxref("RegExp.prototype.source")}}</li> + <li>{{jsxref("RegExp.prototype.sticky")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/ignorecase/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/ignorecase/index.html new file mode 100644 index 0000000000..f847bf1221 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/ignorecase/index.html @@ -0,0 +1,35 @@ +--- +title: RegExp.prototype.ignoreCase +slug: Web/JavaScript/Referencje/Obiekty/RegExp/ignoreCase +tags: + - JavaScript + - Property + - RegExp + - protype +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Określa czy z wyrażeniem regularnym została użyta flaga "<code>i</code>".</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>ignoreCase</code> jest własnością pojedynczego obiektu wyrażenia regularnego.</p> + +<p>Wartość <code>ignoreCase</code> wynosi <code>true</code>, jeśli użyta została flaga "<code>i</code>"; w przeciwnym przypadku będzie to wartość <code>false</code>. Flaga "<code>i</code>" wskazuje, że wielkość znaków ma być ignorowana podczas dokonywania porównań w łańcuchu znaków.</p> + +<p>Tej własności nie można zmieniać bezpośrednio.</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("RegExp.lastIndex")}}</li> + <li>{{jsxref("RegExp.prototype.global")}}</li> + <li>{{jsxref("RegExp.prototype.multiline")}}</li> + <li>{{jsxref("RegExp.prototype.source")}}</li> + <li>{{jsxref("RegExp.prototype.sticky")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/index.html new file mode 100644 index 0000000000..7fb605c26f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/index.html @@ -0,0 +1,383 @@ +--- +title: RegExp +slug: Web/JavaScript/Referencje/Obiekty/RegExp +tags: + - Constructor + - JavaScript + - RegExp + - Regular Expressions +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Obiekt wyrażeń regularnych (ang. <em>regular expression</em>) zawiera wzór regularnego wyrażenia. Posiada ono właściwości i metody, które umożliwiają znalezienie lub zmianę ciągu znaków w innym ciągu znaków.</p> + +<p>W dodatku do właściwości pojedynczego obiektu wyrażenia regularnego, które tworzysz używając funkcji konstruktora <code>RegExp</code>, predefiniowany obiekt <code>RegExp</code> posiada własności statyczne, które są ustawione, kiedy jakiekolwiek wyrażenie regularne jest użyte.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Tworzony przez</h2> + +<p>Odpowiednik tekstowy lub funkcja-konstruktor <code>RegExp</code>.</p> + +<p>Odpowiednik tekstowy jest używany jak poniżej:</p> + +<pre class="brush: js"><em>/wzór/flagi</em> +</pre> + +<p>Konstruktor jest używany jak poniżej:</p> + +<pre class="brush: js">new RegExp("<em>wzór</em>"[, "<em>flagi</em>"]) +</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>wzór</code></dt> + <dd>Tekst wyrażenia regularnego.</dd> + <dt><code>flagi</code></dt> + <dd>Jeśli podane, flagi mogą mieć jakąkolwiek kombinację poniższych wartości: <code>g</code> - wyszukiwanie globalne, <code>i</code> - ignoruje wielkość liter, <code>m</code> - wyszukiwanie w wielu liniach.</dd> +</dl> + +<p>Zauważ, że parametry w formacie tekstowym nie używają cudzysłowu do oznaczenia ciągów znaków, kiedy parametry funkcji konstruktora używają cudzysłów. Tak, więc poniższe wyrażenia tworzą to samo wyrażenie regularne:</p> + +<pre class="brush: js">/ab+c/i; +new RegExp("ab+c", "i"); +</pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Podczas użycia funkcji konstruktora, standardowe znaki ucieczki (<em>string escape rule</em>, poprzedzanie znaków specjalnych <em>backslash'’ "\" kiedy użyte w ciągu znaków) są wymagane. Na przykład poniższe dwa przykłady są identyczne:</em></p> + +<pre class="brush: js">re = new RegExp("\\w+"); +re = /\w+/; +</pre> + +<h3 id="Znaki_specjalne_w_wyra.C5.BCeniach_regularnych" name="Znaki_specjalne_w_wyra.C5.BCeniach_regularnych">Znaki specjalne w wyrażeniach regularnych</h3> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Znak</td> + <td class="header">Znaczenie</td> + </tr> + <tr> + <td><code>\</code></td> + <td> + <p>Dla znaków które zwykle są traktowane dosłownie, oznacza że następny znak jest specjalny i nie ma być interpretowany standardowo.</p> + + <p>Na przykład, <code>/b/</code> szuka znaku "b". Wstawiając backslash (<code>\</code>) przed b, to jest używając <code>/\b/</code>, znak staje się specjalny "znajdź granicę wyrazu".</p> + + <p>-lub-</p> + + <p>Dla znaków, które zwykle są traktowane jako specjalne oznacza, że następny znak jest zwykły powinien być interpretowany dosłownie.</p> + + <p>Na przykład, <code>*</code> jest znakiem specjalnym oznaczającym 0 lub więcej wystąpień poprzedzającego znaku powinno być znalezionych; na przykład, <code>/a*/</code> oznacza "znajdź 0 lub więcej znaków <code>a</code>". Aby znaleźć dosłownie <code>*</code>, poprzedź ten znak backslashem (<code>\</code>), na przykład <code>/a\*/</code> znajduje "a*".</p> + </td> + </tr> + <tr> + <td><code>^</code></td> + <td> + <p>Znajduje początek wejścia. Jeśli flaga wielu linii (ang. <em>multiline</em>) jest ustawiona na <em>prawda</em> (<code>true</code>), znajduje również od razu po znaku nowej linii.</p> + + <p>Na przykład, <code>/^B/</code> nie znajdzie "B" w "Andrzej B" ale znajdzie "B" w "Bogusław A".</p> + </td> + </tr> + <tr> + <td><code>$</code></td> + <td> + <p>Oznacza koniec wejścia. Jeśli flaga wielu linii (ang. <em>multiline</em>) jest ustawiona na <em>prawda</em> (<code>true</code>), znajduje również bezpośrednio przed znakiem końca linii.</p> + + <p>Na przykład, <code>/a$/</code> nie znajdzie "a" w "mrówkojad" ale znajdzie "a" w "mrówka".</p> + </td> + </tr> + <tr> + <td><code>*</code></td> + <td> + <p>Znajduje poprzedzającą pozycję 0 lub więcej razy.</p> + + <p>Na przykład, <code>/bu*/</code> znajdzie "buuuu" w "Duch krzyknął buuuu" i "b" w "Głośnik zabrzmiał basowo" ale nic w "Ptak zaśpiewał".</p> + </td> + </tr> + <tr> + <td><code>+</code></td> + <td> + <p>Znajduje poprzedzającą pozycję 1 lub więcej razy. Równoważne do <code>{1,}</code>.</p> + + <p>Na przykład, <code>/r+/</code> dopasuje się do "r" w "cukierek" i do wszystkich "r" w "cukierrrrrrrek".</p> + </td> + </tr> + <tr> + <td><code>?</code></td> + <td> + <p>Znajduje poprzedzającą pozycję 0 razy lub 1 raz.</p> + + <p>Na przykład <code>/o?ąt?/</code> znajdzie "oł" w "anioł" i "ąt" w "kąt".</p> + + <p>Jeśli zostanie użyte zaraz po którymś ze znaków *, +, ?, lub {}, to wymusza przejście do trybu niezachłannego (domyślne jest dopasowanie zachłanne), czyli dopasowanie następuje do najmniejszego ciągu spełniającego wyrażenie, a nie do największego.</p> + + <p>Pytajnik używany jest także w <em>lookahead assertions</em>, opisanych pod <code>(?=)</code>, <code>(?!)</code> i <code>(?:)</code> w tej tabeli.</p> + </td> + </tr> + <tr> + <td><code>.</code></td> + <td> + <p>(Kropka) znajduje jakikolwiek pojedynczy znak poza znakiem nowej linii.</p> + + <p>Na przykład, <code>/.a/</code> znajdzie "ja" i "na" w "jabłko rośnie na drzewie ale arbuz nie", ale nie znajdzie "al" i "ar".</p> + </td> + </tr> + <tr> + <td><code>(x)</code></td> + <td> + <p>Znajduje "x" i zapamiętuje to dopasowanie. Nazywa się to "nawiasy wychwytujące" (ang. <em>capturing parentheses</em>).</p> + + <p>Na przykład, <code>/(foo)/</code> znajduje i zapamiętuje "foo" w "foo bar". Znaleziony pod-ciąg (<em>substring</em>) może być ponownie wywołany elementów tablicy wynikowej <code>1, ..., n</code> jak również z predefiniowanych własności obiektu <code>RegExp</code>, <code>$1, ..., $9</code>.</p> + </td> + </tr> + <tr> + <td><code>(?:x)</code></td> + <td> + <p>Znajduje "x", ale nie pamięta dopasowania. Nazywa się to "nawiasy niewychwytujące" (ang. <em>non-capturing parentheses</em>). Znaleziony podciąg (<em>substring</em>) nie może być wywołany ponownie z elementów wynikowych tablicy <code>1, ..., n</code> ani za pomocą właściwości obiektu <code>RegExp</code>, <code>$1, ..., $9</code>.</p> + </td> + </tr> + <tr> + <td><code>x(?=y)</code></td> + <td> + <p>Znajduje "x", tylko wtedy, gdy zaraz po "x" jest "y". Na przykład, <code>/Jacek(?=Szprotka)/</code> znajdzie "Jacek" tylko, jeśli zaraz po tym jest wyraz "Szprotka". <code>/Jacek(?=Szprotka|Mróz)/</code> znajdzie "Jacek" tylko, jeśli po tym jest zaraz wyraz "Szprotka" lub "Mróz"). Jednakże, ani "Szprotka" ani "Mróz" nie jest częścią wyników.</p> + </td> + </tr> + <tr> + <td><code>x(?!y)</code></td> + <td> + <p>Znajduje "x", tylko, jeśli po "x" nie ma "y". Na przykład, <code>/\d+(?!\,)/</code> zostanie dopasowane do liczby całkowitej, tylko jeśli nie ma po niej przecinka.</p> + + <p><code>/\d+(?!\,)/.exec("3,141")</code> zostanie dopasowane tylko do 141, nie zostanie dopasowane do 3, bo wystąpił po niej przecinek.</p> + </td> + </tr> + <tr> + <td><code>x|y</code></td> + <td> + <p>Znajduje "x" lub "y".</p> + + <p>Na przykład, <code>/zielone|czerwone/</code> znajdzie "zielone" w "zielone jabłko" i "czerwone" w "czerwone jabłko".</p> + </td> + </tr> + <tr> + <td><code>{n}</code></td> + <td> + <p>Gdzie <code>n</code> jest dodatnią liczbą całkowitą. Znajduje dokładnie <code>n</code> wystąpień poprzedzającej pozycji.</p> + + <p>Na przykład, <code>/u{2}/</code> nie znajdzie "u" w "cukierek", ale znajdzie wszystkie "u" w "cuukierek" i pierwsze dwa "u" w "cuuukierek".</p> + </td> + </tr> + <tr> + <td><code>{n,}</code></td> + <td> + <p>Gdzie <code>n</code> jest dodatnią liczbą całkowitą. Znajduje, co najmniej <code>n</code> wystąpień poprzedzającej pozycji.</p> + + <p>Na przykład, <code>/u{2,}/</code> nie znajdzie "u" w "cukierek", ale znajdzie wszystkie "u" w "cuukierek" i w "cuuukierek".</p> + </td> + </tr> + <tr> + <td><code>{n,m}</code></td> + <td> + <p>Gdzie <code>n</code> i <code>m</code> są pozytywnymi liczbami całkowitymi. Wyszukuje, co najmniej <code>n</code> i co najwyżej <code>m</code> wystąpień poprzedzającego wyrażenia.</p> + + <p>Na przykład, <code>/u{1,3}/</code> nie znajdzie niczego w "ckierek", znajdzie "u" w "cukierek", znajdzie dwa "u" w "cuukierek" i pierwsze trzy "u" w "cuuuuukierek". Zauważ, że podczas wyszukiwania w "cuuuuukierek", wynik wyszukiwania to "uuu" mimo iż ciąg oryginalny zawiera więcej liter "u".</p> + </td> + </tr> + <tr> + <td><code>xyz</code></td> + <td> + <p>Zestaw znaków. Wyszukuje jakikolwiek z podanych znaków. Możesz podać przedział znaków używając myślnika.</p> + + <p>Na przykład, <code>abcd</code> oznacza tyle samo, co <code>a-d</code>. Wyrażenia te znajdą "b" w "buziak" i "d" w "kasza".</p> + </td> + </tr> + <tr> + <td><code>^xyz</code></td> + <td> + <p>Przeciwny zestaw znaków. Wyszukuje cokolwiek, co nie jest wewnątrz nawiasów. Podobnie jak powyżej można podać zakres znaków używając myślnika.</p> + + <p>Na przykład, <code>^abc</code> oznacza tyle samo, co <code>^a-c</code>. Wyrażenia te znajdą "u" w "buziak" i "k" w "kasza".</p> + </td> + </tr> + <tr> + <td><code>\\b</code></td> + <td> + <p>Wyszukuje znak backspace (nie mylić z <code>\b</code>).</p> + </td> + </tr> + <tr> + <td><code>\b</code></td> + <td> + <p>Wyszukuje granicę wyrazów (ang. <em>word boundary</em>), jak na przykład spację (nie mylić z <code>\\b</code>).</p> + + <p>Na przykład, <code>/\bn\w/</code> zaznaczy "no" w "noonday"; <code>/\wy\b/</code> zaznaczy "ly" w "possibly yesterday".</p> + </td> + </tr> + <tr> + <td><code>\B</code></td> + <td> + <p>Znajduje brak granicy niewyrazu (ang. <em>non-word boundary</em>).</p> + + <p>Na przykład, <code>/\w\Bn/</code> zaznaczy "on" w "noonday", a <code>/y\B\w/</code> zaznaczy "ye" w "possibly yesterday".</p> + </td> + </tr> + <tr> + <td><code>\cX</code></td> + <td> + <p>Gdzie <code>X</code> jest literą od A do Z. Zaznacza znak kontrolny w ciągu.</p> + + <p>Na przykład, <code>/\cM/</code> zaznaczy <code>control-M</code> w <em>string</em>u.</p> + </td> + </tr> + <tr> + <td><code>\d</code></td> + <td> + <p>Znajduje cyfrę. Odpowiednik <code>0-9</code>.</p> + + <p>Na przykład, <code>/\d/</code> lub <code>/0-9/<code> zaznaczy "2" w "B2 jest numerem pokoju". </td> </tr> </code></p> + </td> + </tr> + <tr> + <td>\D</td> + <td> + <p>Wyszukuje jakikolwiek znak nieliczbowy. Odpowiednik <code>^0-9') }}</code>.</p> + + <p>Na przykład, <code>/\D/</code> lub <code>/^0-9/</code> zaznaczy "B" w "B2 jest numerem pokoju".</p> + </td> + </tr> + <tr> + <td><code>\f</code></td> + <td> + <p>Znajduje znak wysuwu wiersza (<em>form feed</em>).</p> + </td> + </tr> + <tr> + <td><code>\n</code></td> + <td> + <p>Znajduje znak następnego wiersza (<em>line feed</em>).</p> + </td> + </tr> + <tr> + <td><code>\r</code></td> + <td> + <p>Znajduje znak powrotu karetki (<em>carriage return</em>).</p> + </td> + </tr> + <tr> + <td><code>\s</code></td> + <td> + <p>Znajduje pojedynczy biały znak (ang. <em>white space character</em>), wliczając w to spację, tabulator, znak wysuwu wiersza, znak następnego wiersza. Odpowiednik <code>\\f\\n\\r\\t\\u00A0\\u2028\\u2029</code>.</p> + + <p>Na przykład, <code>/\s\w*/</code> zaznaczy " bar" w "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\S</code></td> + <td> + <p>Zaznacza jakikolwiek znak inny niż biały (ang. <em>white space</em>). Odpowiednik <code>^ \\f\\n\\r\\t\\u00A0\\u2028\\u2029</code>.</p> + + <p>Na przykład, <code>/\S/\w*</code> zaznaczy "foo" w "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\t</code></td> + <td> + <p>Znajduje tabulator.</p> + </td> + </tr> + <tr> + <td><code>\v</code></td> + <td> + <p>Znajduje pionowy tabulator (ang. <em>vertical tab</em>).</p> + </td> + </tr> + <tr> + <td><code>\w</code></td> + <td> + <p>Znajduje jakikolwiek znak alfanumeryczny i znak podkreślenia <code>_</code>. Odpowiednik <code>A-Za-z0-9_</code>.</p> + + <p>Na przykład, <code>/\w/</code> zaznaczy "j" w "jabłko", "5" w "??5.28", i "3" w "3D".</p> + </td> + </tr> + <tr> + <td><code>\W</code></td> + <td> + <p>Zaznaczy jakikolwiek znak niewyrazowy. Odpowiednik <code>^A-Za-z0-9_</code>.</p> + + <p>Na przykład, <code>/\W/</code> lub <code>/^$A-Za-z0-9_/</code> znajdzie "%" w "50%".</p> + </td> + </tr> + <tr> + <td><code>\n</code></td> + <td> + <p>Gdzie <code>n</code> jest pozytywną liczbą całkowitą. Odwołanie wsteczne (ang. <em>back reference</em>) do ostatniego podciągu (<em>substring</em>) pasującego do n wyrażenia umieszczonego w nawiasie (licząc od nawiasu otwierającego "(").</p> + + <p>Na przykład, <code>/jabłko(,)\spomarańcz\1/</code> pasuje do "jabłko, pomarańcz," w "jabłko, pomarańcz, wiśnia, brzoskwinia". Dokładniejszy przykład znajduje się po tabeli.</p> + </td> + </tr> + <tr> + <td><code>\0</code></td> + <td> + <p>Wyszukuje znak NUL. Bezpośrednio po <code>\0</code> nie powinna znajdować się żadna liczba.</p> + </td> + </tr> + <tr> + <td><code>\xhh</code></td> + <td> + <p>Znajduje znak o kodzie hh (dwie cyfry szesnastkowe)</p> + </td> + </tr> + <tr> + <td><code>\uhhhh</code></td> + <td> + <p>Znajduje znak o kodzie hhhh (cztery cyfry szesnastkowe).</p> + </td> + </tr> + </tbody> +</table> + +<p>Notacja tekstowa zostaje skompilowana, kiedy wyrażenie regularne jest wykonane. Używaj notacji tekstowej wtedy, kiedy wyrażenie regularne pozostanie niezmienione. Na przykład, jeśli użyjesz notacji tekstowej do konstrukcji wyrażenia regularnego w pętli, wyrażenie to nie zostanie przekompilowane podczas każdej iteracji.</p> + +<p>Konstruktor obiektu wyrażenia regularnego, na przykład <code>new RegExp("ab+c")</code>, pozwala na kompilację podczas czasu wykonywania (ang. <em>runtime compilation</em>) wyrażenia. Używaj funkcji konstruktora, kiedy wiesz, że wzór wyrażenia regularnego będzie się zmieniać lub gdy nie znasz tego wzoru i pobierasz go z innego źródła, jak na przykład wejście użytkownika.</p> + +<p>Oddzielny predefiniowany obiekt <code>RegExp</code> jest dostępny dla każdego okna, to jest każdy oddzielny wątek uruchomienia JavaScriptu dostaje jego własny obiekt <code>RegExp</code>. Jako że każdy skrypt uruchamiany jest cały w oddzielnym wątku, zapewnia to, iż oddzielne skrypty nie nadpisują wartości obiektu <code>RegExp</code>.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("RegExp.prototype")}}</dt> + <dd>Pozwala na dodanie własności wszystkim obiektom.</dd> + <dt><code>RegExp.length</code></dt> + <dd>Wartość parametru <code>RegExp.length</code> wynosi 2.</dd> + <dt>{{jsxref("RegExp.lastIndex")}}</dt> + <dd>Indeks, od którego rozpoczynać następne szukanie.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<p>Globalny objekt <code>RegExp</code> nie posiada własnych metod, jednam może dziedziczyć metody z innych obiektów.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_replace" name="Przyk.C5.82ad:_Zastosowanie_metody_replace">Przykład: Zastosowanie metody <code>replace</code></h3> + +<p>Poniższy przykład używa metodę <code>replace</code> do zamiany wyrazów w ciągu (<em>stringu</em>). Podczas zamiany tekstu, skrypt używa "<code>$1</code>" i "<code>$2</code>" do oznaczenia wyników odpowiadających im nawiasów we wzorze wyrażenia regularnego.</p> + +<pre class="brush: js">var re = /(\w+)\s(\w+)/; +var str = "Jan Kowalski"; +var newstr = str.replace(re, "$2, $1"); +document.write(newstr); +</pre> + +<p>Wyświetli "Kowalski, Jan".</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>Rozdział w <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a> o <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a></li> + <li>{{jsxref("String.prototype.match()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/lastmatch/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/lastmatch/index.html new file mode 100644 index 0000000000..4d229d5d81 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/lastmatch/index.html @@ -0,0 +1,54 @@ +--- +title: RegExp.lastMatch ($&) +slug: Web/JavaScript/Referencje/Obiekty/RegExp/lastMatch +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/lastMatch +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Niestandardowa właściwość <strong>lastMatch</strong> jest właściwością statyczną, tylko do odczytu wyrażeń regularnych, który zawiera ostatnie dopasowane znaki. <code>RegExp.$&</code> jest aliasem tej właściwości.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>RegExp</var>.lastMatch +RegExp['$&'] +</pre> + +<h2 id="Description">Description</h2> + +<p>The <code>lastMatch</code> property is static, it is not a property of an individual regular expression object. Instead, you always use it as <code>RegExp.lastMatch</code> or <code>RegExp['$&'].</code></p> + +<p>The value of the <code>lastMatch</code> property is read-only and modified whenever a successful match is made.</p> + +<p>You can not use the shorthand alias with the dot property accessor (<code>RegExp.$&</code>), because the parser expects an expression with "&" in that case and a {{jsxref("SyntaxError")}} is thrown. Use the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors">bracket notation for property access</a>.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_lastMatch_and">Using <code>lastMatch</code> and <code>$&</code></h3> + +<pre class="brush: js">var re = /hi/g; +re.test('hi there!'); +RegExp.lastMatch; // "hi" +RegExp['$&']; // "hi" +</pre> + +<h2 id="Specifications">Specifications</h2> + +<p>Niestandardowe. Nie jest częścią aktualnej specyfikacji.</p> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.builtins.RegExp.lastMatch")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}</li> + <li>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</li> + <li>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</li> + <li>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</li> + <li>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/prototype/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/prototype/index.html new file mode 100644 index 0000000000..0a9312a1e1 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/prototype/index.html @@ -0,0 +1,53 @@ +--- +title: RegExp.prototype +slug: Web/JavaScript/Referencje/Obiekty/RegExp/prototype +tags: + - JavaScript + - Property + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Reprezentuje prototyp obiektów danej klasy. Pozwala na dodawanie własności i metod do wszystkich instancji tej klasy.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<p>Zauważ, że niektóre własności obiektu <code>RegExp</code> mają dwie nazwy: długą i krótką (Perl<em>ową</em>). Obydwie nazwy zawsze odwołują się do tej samej wartości. Perl jest językiem programowania, z którego uformowały się wyrażenia regularne JavaScriptu.</p> + +<dl> + <dt><code>RegExp.prototype.constructor</code></dt> + <dd>Określa funkcję, która tworzy prototyp obiektu.</dd> + <dt>{{jsxref("RegExp.prototype.flags")}} {{experimental_inline}}</dt> + <dd>A string that contains the flags of the <code>RegExp</code> object.</dd> + <dt>{{jsxref("RegExp.prototype.global")}}</dt> + <dd>Czy przeszukiwać cały ciąg w poszukiwaniu wszystkich możliwych dopasowań czy tylko w poszukiwaniu pierwszego.</dd> + <dt>{{jsxref("RegExp.prototype.ignoreCase")}}</dt> + <dd>Czy ignorować wielkość liter podczas wyszukiwania.</dd> + <dt>{{jsxref("RegExp.prototype.multiline")}}</dt> + <dd>Czy w ciągach z wieloma liniami, szukać w wielu liniach.</dd> + <dt>{{jsxref("RegExp.prototype.source")}}</dt> + <dd>Tekst wzoru.</dd> + <dt>{{jsxref("RegExp.prototype.sticky")}} {{experimental_inline}}</dt> + <dd>Whether or not the search is sticky.</dd> + <dt>{{jsxref("RegExp.prototype.unicode")}} {{experimental_inline}}</dt> + <dd>Whether or not Unicode features are enabled.</dd> +</dl> + +<h2 id="Metody" name="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("RegExp.prototype.compile()")}} {{deprecated_inline}}</dt> + <dd>(Re-)compiles a regular expression during execution of a script.</dd> + <dt>{{jsxref("RegExp.prototype.exec()")}}</dt> + <dd>Uruchamia wyszukiwanie dopasowania w ciągu podanym poprzez parametr tej metody.</dd> + <dt>{{jsxref("RegExp.prototype.test()")}}</dt> + <dd>Testuje dopasowanie w ciągu podanym poprzez parametr tej metody.</dd> + <dt>{{jsxref("RegExp.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Zwraca literał obiektu reprezentujący podany obiekt; możesz użyć tej wartości do utworzenia nowego obiektu. Przesłania metodę <a href="/pl/Dokumentacja_j%C4%99zyka_JavaScript_1.5/Obiekty/Object/toSource" title="pl/Dokumentacja_języka_JavaScript_1.5/Obiekty/Object/toSource">Object.toSource</a>.</dd> + <dt>{{jsxref("RegExp.prototype.toString()")}}</dt> + <dd>Zwraca ciąg znaków reprezentujący podany obiekt. Przesłania metodę <a href="/pl/Dokumentacja_j%C4%99zyka_JavaScript_1.5/Obiekty/Object/toString" title="pl/Dokumentacja_języka_JavaScript_1.5/Obiekty/Object/toString">Object.toString</a>.</dd> +</dl> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/source/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/source/index.html new file mode 100644 index 0000000000..78cf4c2a64 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/source/index.html @@ -0,0 +1,29 @@ +--- +title: RegExp.prototype.source +slug: Web/JavaScript/Referencje/Obiekty/RegExp/source +tags: + - JavaScript + - Property + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/source +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Własność tylko do odczytu stanowiąca wzór tekstu, wykluczając przesyłanie slashy.</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>source</code> jest własnością indywidualnej instancji wyrażenia regularnego obiektu.</p> + +<p>Nie możesz zmienić tej własności bezpośrednio.</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("RegExp.prototype.flags")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/test/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/test/index.html new file mode 100644 index 0000000000..e654bfb236 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/test/index.html @@ -0,0 +1,53 @@ +--- +title: RegExp.prototype.test() +slug: Web/JavaScript/Referencje/Obiekty/RegExp/test +tags: + - JavaScript + - Method + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wykonuje poszukiwanie łańcucha znaków pomiędzy wyrażeniem regularnym i określonym wzorcem. Zwraca <code>true</code> lub <code>false</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>regexObj</var>.test(<var>str</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>str</code> </dt> + <dd>Łańcuch znaków w zależności od tego, czym jest wyrażenie regularne.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli chcesz wiedzieć, czy wzorzec został znaleziony w łańcuchu znaków zastosuj metodę <code>test</code> (podobną do metody {{jsxref("String.prototype.search()")}}); aby uzyskać więcej informacji (lecz powolniej wykonywana) zastosuj metodę {{jsxref("RegExp.prototype.exec()", "exec()")}}(podobną do metody {{jsxref("String.prototype.match()")}} ).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_test" name="Przyk.C5.82ad:_Zastosowanie_test">Przykład: Zastosowanie <code>test()</code></h3> + +<p>Poniższy funkcja wypisuje wiadomość, której tekst zależy od powodzenia testu:</p> + +<pre class="brush: js">function testinput(re, str){ + if (re.test(str)) { + midstring = " zawiera "; + } else { + midstring = " nie zawiera "; + } + console.log(str + midstring + re.source); +} +</pre> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("RegExp")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/tosource/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/tosource/index.html new file mode 100644 index 0000000000..4ac074392b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/tosource/index.html @@ -0,0 +1,47 @@ +--- +title: RegExp.prototype.toSource() +slug: Web/JavaScript/Referencje/Obiekty/RegExp/toSource +tags: + - JavaScript + - Method + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toSource +--- +<p>{{JSRef}}{{Non-standard_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>regexObj</var>.toSource() +</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toSource()</code> zwraca następujące wartości:</p> + +<ul> + <li>Dla wbudowanego obiektu {{jsxref("RegExp")}}, <code>toSource()</code> zwraca następujący łańcuch znaków sygnalizujący, który kod źródłowy nie jest dostępny: + + <pre class="brush: js">function RegExp() { + [native code] +} +</pre> + </li> + <li>Dla instancji {{jsxref("RegExp")}}, <code>toSource()</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Ta metoda jest często nazywana wewnętrzną metodą JavaScriptu i nie jest widoczna w kodzie.</p> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/regexp/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/regexp/tostring/index.html new file mode 100644 index 0000000000..fb78233ff2 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/regexp/tostring/index.html @@ -0,0 +1,46 @@ +--- +title: RegExp.prototype.toString() +slug: Web/JavaScript/Referencje/Obiekty/RegExp/toString +tags: + - JavaScript + - Method + - Prototype + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący określony obiekt.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>regexObj</var>.toString();</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<p>Brak.</p> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("RegExp")}} przypisuje <code>toString()</code> metodzie obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektu {{jsxref("RegExp")}}, metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toString" name="Przyk.C5.82ad:_Zastosowanie_toString">Przykład: Zastosowanie <code>toString()</code></h3> + +<p>Następujący przykład wyświetla wartość łańcucha znaków obiektu <code>RegExp</code>:</p> + +<pre class="brush: js"><code class="language-js"><span class="token keyword">var</span> myExp <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">RegExp</span><span class="token punctuation">(</span><span class="token string">'a+b+c'</span><span class="token punctuation">)</span><span class="token punctuation">;</span> +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>myExp<span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // </span></code><code class="language-js"><span class="token comment">wyświetli</span></code><code class="language-js"><span class="token comment"> '/a+b+c/' +</span> +<span class="token keyword">var</span> foo <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">RegExp</span><span class="token punctuation">(</span><span class="token string">'bar'</span><span class="token punctuation">,</span> <span class="token string">'g'</span><span class="token punctuation">)</span><span class="token punctuation">;</span> +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>foo<span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // </span></code><code class="language-js"><span class="token comment">wyświetli</span></code><code class="language-js"><span class="token comment"> '/bar/g'</span></code> +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/set/index.html b/files/pl/web/javascript/referencje/obiekty/set/index.html new file mode 100644 index 0000000000..ca9cc37a93 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/set/index.html @@ -0,0 +1,486 @@ +--- +title: Set +slug: Web/JavaScript/Referencje/Obiekty/Set +tags: + - ECMAScript 2015 + - ECMAScript6 + - Global Objects + - JavaScript + - Object + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set +--- +<div>{{JSRef}}</div> + +<p>Obiekt <code><strong>Set</strong></code> umożliwia przechowywanie <em>unikalnych </em>wartości każdego typu, zarówno {{Glossary("Primitive", "primitywów")}} jak i obiektów.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">new Set([<em>iterable</em>]);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>iterable</code></dt> + <dd>Jeżeli przekażesz <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of">obiekt iterowalny</a>, wszystkie jego elementy zostaną dodane do nowego <code>Set</code>. Podczas gdy nie przekażemy żadnego parametru lub wartość parametru będzie równa <em><code>null</code></em>, zostanie stworzony pusty <code>Set</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Nowy obiekt <code>Set</code>.</p> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt <code><em>Set</em></code> jest kolekcją wartości. Możesz iterować po elementach <code><em>Set</em></code> w kolejności, w której zostały dodane. Wartość w <code><em>Set</em></code> <strong>może występować tylko jeden raz</strong>.</p> + +<h3 id="Równość_wartości">Równość wartości</h3> + +<p>Dlatego, że każda wartość w <code>Set </code>musi być unikalna, musi zostać to sprawdzone. We wcześniejszych specyfikacjach ECMAScript nie było to oparte na tym samym algorytmie co w przypadku operatora ===. Konkretnie dla Set +0 (co jest tym samym co -0) i -0 były innymi wartościami. W specyfikacji ECMAScript 2015 zostało to zmienione. Zobacz "Value equality for -0 and 0" w tabeli <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Set#Kompatybilność_przeglądarek">Kompatybilność z przeglądarkami</a>.</p> + +<p><code>NaN</code> i <code>undefined</code> mogą być przechowywane w <code>Set</code>. <code>NaN</code> w <code>Set</code> uważane jest za równe <code>NaN</code>, podczas gdy <code>NaN !== NaN</code> zwraca <code>true</code></p> + +<h2 id="Własności">Własności</h2> + +<dl> + <dt><code>Set.length</code></dt> + <dd>Wartość <code>length</code> zawsze wynosi 0.</dd> + <dt>{{jsxref("Set.@@species", "get Set[@@species]")}}</dt> + <dd>Funkcja wykorzystywana do stworzenia pochodnych obiektów.</dd> + <dt>{{jsxref("Set.prototype")}}</dt> + <dd>Reprezentuje prototyp konstruktora <code>Set.</code> Pozwala na dodanie własności do obiektu <code>Set</code>.</dd> +</dl> + +<h2 id="Instancje_Set"><font face="consolas, Liberation Mono, courier, monospace">Instancje <code>Set</code></font></h2> + +<p>Wszystkie instancje <code>Set</code> dziedziczą od {{jsxref("Set.prototype")}}.</p> + +<h3 id="Własności_2">Własności</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Properties')}}</p> + +<h3 id="Metody">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Methods')}}</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_obiektu_Set">Użycie obiektu <code>Set</code></h3> + +<pre class="brush: js">var mySet = new Set(); + +mySet.add(1); // Set { 1 } +mySet.add(5); // Set { 1, 5 } +mySet.add(5); // Set { 1, 5 } +mySet.add('some text'); // Set { 1, 5, 'some text' } +var o = {a: 1, b: 2}; +mySet.add(o); + +mySet.add({a: 1, b: 2}); // o jest referencją do innego obiektu, więc dwa obiekty zostają dodane do Set. + +mySet.has(1); // true +mySet.has(3); // false, 3 nie zostało dodane do Set. +mySet.has(5); // true +mySet.has(Math.sqrt(25)); // true +mySet.has('Some Text'.toLowerCase()); // true +mySet.has(o); // true + +mySet.size; // 5 + +mySet.delete(5); // Usuwa 5 z Set. +mySet.has(5); // false, 5 zostało usunięte. + +mySet.size; // 4, usuneliśmy jedną wartość. +console.log(mySet);// Set {1, "some text", Object {a: 1, b: 2}, Object {a: 1, b: 2}}</pre> + +<h3 id="Iterowanie_po_Set.">Iterowanie po Set.</h3> + +<pre class="brush: js">// Iterowanie po items w Set. +// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2} +for (let item of mySet) console.log(item); + +// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2} +for (let item of mySet.keys()) console.log(item); + +// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2} +for (let item of mySet.values()) console.log(item); + +// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2} +//(key i value są takie same) +for (let [key, value] of mySet.entries()) console.log(key); + +// zamienia Set na Array, przy użyciu Array.from +var myArr = Array.from(mySet); // [1, "some text", {"a": 1, "b": 2}] + +// następujące funkcje również zadziałają, jeżeli skrypt odpalony jest w dokumencie HTML +mySet.add(document.body); +mySet.has(document.querySelector('body')); // true + +// zamiana Array na Set i na odwrót +mySet2 = new Set([1, 2, 3, 4]); +mySet2.size; // 4 +[...mySet2]; // [1, 2, 3, 4] + +// Set z wartościami, które są w set1 i set2, może być uzyskany następująco +var intersection = new Set([...set1].filter(x => set2.has(x))); + +// Set z różnicami wartości set1 i set2 może być uzyskany następująco +var difference = new Set([...set1].filter(x => !set2.has(x))); + +// iterowanie po Set za pomocą .forEach +mySet.forEach(function(value) { + console.log(value); +}); +// 1 +// 2 +// 3 +// 4</pre> + +<h3 id="Implementacja_podstawowych_operacji_Set">Implementacja podstawowych operacji <code>Set</code></h3> + +<pre class="brush: js">Set.prototype.isSuperset = function(subset) { + for (var elem of subset) { + if (!this.has(elem)) { + return false; + } + } + return true; +} + +Set.prototype.union = function(setB) { + var union = new Set(this); + for (var elem of setB) { + union.add(elem); + } + return union; +} + +Set.prototype.intersection = function(setB) { + var intersection = new Set(); + for (var elem of setB) { + if (this.has(elem)) { + intersection.add(elem); + } + } + return intersection; +} + +Set.prototype.difference = function(setB) { + var difference = new Set(this); + for (var elem of setB) { + difference.delete(elem); + } + return difference; +} + +// Przykłady +var setA = new Set([1, 2, 3, 4]), + setB = new Set([2, 3]), + setC = new Set([3, 4, 5, 6]); + +setA.isSuperset(setB); // => true +setA.union(setC); // => Set [1, 2, 3, 4, 5, 6] +setA.intersection(setC); // => Set [3, 4] +setA.difference(setC); // => Set [1, 2] + +</pre> + +<h3 id="Relacje_z_Tablicami_(Array)">Relacje z Tablicami (<code>Array</code>)</h3> + +<pre class="brush: js">var myArray = ['value1', 'value2', 'value3']; + +// Użycie konstruktora Set do zamiany Array na Set. +var mySet = new Set(myArray); + +mySet.has('value1'); // => true + +// Użycie spread operator do zamiany Set na Array. +console.log([...mySet]); // Will show you exactly the same Array as myArray</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td> + <p>{{ CompatChrome(38) }} [1]</p> + </td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Constructor argument: <code>new Set(iterable)</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>9.0</td> + </tr> + <tr> + <td>iterable</td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("17") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.add()</code> returns the set</td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.clear()</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("19")}}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.keys(), Set.values(), Set.entries()</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("24")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.forEach()</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Value equality for -0 and 0</td> + <td>{{ CompatChrome(38) }}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatSafari(9)}}</td> + </tr> + <tr> + <td>Constructor argument: <code>new Set(null)</code></td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatIE(11)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari(7.1)}}</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> in Constructor</td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari(9)}}</td> + </tr> + <tr> + <td><code>Set[@@species]</code></td> + <td>{{ CompatChrome(51) }}</td> + <td>13</td> + <td>{{CompatGeckoDesktop("41")}}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatOpera(38) }}</td> + <td>{{CompatSafari(10)}}</td> + </tr> + <tr> + <td><code>Set()</code> without <code>new</code> throws</td> + <td>{{CompatVersionUnknown}}</td> + <td>12</td> + <td>{{CompatGeckoDesktop("42")}}</td> + <td>{{CompatIE(11)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>9</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(38)}} [1]</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Constructor argument: <code>new Set(iterable)</code></td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(38)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td>iterable</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("17") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Set.clear()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("19")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Set.keys(), Set.values(), Set.entries()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("24")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Set.forEach()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Value equality for -0 and 0</td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td>Constructor argument: <code>new Set(null)</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>8</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> in Constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td><code>Set[@@species]</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("41")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>10</td> + </tr> + <tr> + <td><code>Set()</code> without <code>new</code> throws</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("42")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] The feature was available behind a preference from Chrome 31. In <code>chrome://flags</code>, activate the entry “Enable Experimental JavaScript”.</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/set/set.prototype.add()/index.html b/files/pl/web/javascript/referencje/obiekty/set/set.prototype.add()/index.html new file mode 100644 index 0000000000..397939f84e --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/set/set.prototype.add()/index.html @@ -0,0 +1,134 @@ +--- +title: Set.prototype.add() +slug: Web/JavaScript/Referencje/Obiekty/Set/Set.prototype.add() +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/add +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong>add()</strong> dodaje nowy element o określonej wartości (<code>value</code>) na koniec obieku <code>Set</code>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.add(value);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>value</dt> + <dd>Wymagany parametr. Wartość elementu, która zostanie dodana do obieku <code>Set</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Obiekt <code>Set</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_metody_add">Użycie metody add</h3> + +<pre class="brush: js">var mySet = new Set(); + +mySet.add(1); +mySet.add(5).add('some text'); // można stworzyć "łańcuch" + +console.log(mySet); +// Set [1, 5, "some text"] +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-set.prototype.add', 'Set.prototype.add')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.add', 'Set.prototype.add')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Specyficzne_zachowania_w_przeglądarkach">Specyficzne zachowania w przeglądarkach</h2> + +<ul> + <li>W Firefox 33 {{geckoRelease("33")}} i wcześniejszych wersjach, <code>Set.prototype.add</code> zwracał <code>undefined</code> i nie można było stworzyć "łańcucha". Błąd został naprawiony ({{bug(1031632)}}). Również w Chrome/v8 występuje ten <a href="https://code.google.com/p/v8/issues/detail?id=3410">problem</a>.</li> +</ul> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> + <li>{{jsxref("Set.prototype.has()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/set/set.prototype.clear()/index.html b/files/pl/web/javascript/referencje/obiekty/set/set.prototype.clear()/index.html new file mode 100644 index 0000000000..85ca894da9 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/set/set.prototype.clear()/index.html @@ -0,0 +1,124 @@ +--- +title: Set.prototype.clear() +slug: Web/JavaScript/Referencje/Obiekty/Set/Set.prototype.clear() +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/clear +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong>clear()</strong> usuwa wszystkie elementy obiektu <code>Set</code>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.clear();</code></pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_metody_clear">Użycie metody clear</h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add(1); +mySet.add('foo'); + +mySet.size; // 2 +mySet.has('foo'); // true + +mySet.clear(); + +mySet.size; // 0 +mySet.has('bar') // false +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("19.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("19.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/set/set.prototype.delete()/index.html b/files/pl/web/javascript/referencje/obiekty/set/set.prototype.delete()/index.html new file mode 100644 index 0000000000..7071c9e4eb --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/set/set.prototype.delete()/index.html @@ -0,0 +1,102 @@ +--- +title: Set.prototype.delete() +slug: Web/JavaScript/Referencje/Obiekty/Set/Set.prototype.delete() +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/delete +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong>delete()</strong> usuwa określony element z obiektu <code>Set</code>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.delete(value);</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt>value</dt> + <dd>Wymagany parametr. Wartość elementu, która zostanie usunięta z obiektu <code>Set</code>.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p><code>true </code>jeżeli element został pomyślnie usunięty, w innym wypadku <code>false</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_metody_delete">Użycie metody delete</h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add('foo'); + +mySet.delete('bar'); // Zwraca false. Brak elementu "bar" do usunięca. +mySet.delete('foo'); // Zwraca true. Usunięto pomyślnie. + +mySet.has('foo'); // Zwraca false. Element "foo" nie znajduje się już w Set. +</pre> + +<p>Jak usunąć obiekt z Set:</p> + +<pre class="brush: js">var points = new Set(); // Tworzy Set + +points.add({x: 10, y: 20}); // Dodaje obiekt do Set +points.add({x: 20, y: 30}); // Dodaje obiekt do Set + +// Usuwa point, dla którego `x > 10` +points.forEach(function(point){ + if(point.x > 10){ + points.delete(point); + } +}) +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p> </p> + +<div class="hidden"> +<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> +</div> + +<p>{{Compat("javascript.builtins.Set.delete")}}</p> + +<p> </p> + +<div id="compat-desktop"> </div> + +<div id="compat-mobile"> </div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.clear()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/anchor/index.html b/files/pl/web/javascript/referencje/obiekty/string/anchor/index.html new file mode 100644 index 0000000000..737c385889 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/anchor/index.html @@ -0,0 +1,56 @@ +--- +title: String.prototype.anchor() +slug: Web/JavaScript/Referencje/Obiekty/String/anchor +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Tworzy kotwicę HTML {{HTMLElement("a")}} do użycia jako cel odnośnika.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.anchor(<var>name</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>name</code></dt> + <dd>Łańcuch znaków.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Use the <code>anchor()</code> method to programmatically create and display an anchor in a document.</p> + +<p>W składni łańcuch znaków reprezentuje literał tekstowy, który ma zobaczyć użytkownik. Łańcuch <code>name</code> reprezentuje atrybut <code>name</code> znacznika <code>a</code>.</p> + +<p>Kotwice stworzone za pomocą metody <code>anchor</code> stają się elementami tablicy <code>document.anchors</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_anchor" name="Przyk.C5.82ad:_Zastosowanie_anchor">Przykład: Zastosowanie <code>anchor()</code></h3> + +<p>Następujący przykład wewnątrz kodu HTML elementu <code>script</code>:</p> + +<pre class="brush: js">var myString = "Tabela zawartości"; + +document.body.innerHTML = myString.anchor("contents_anchor"); +</pre> + +<p>spowoduje otrzymanie na wyjściu kodu HTML:</p> + +<pre class="brush: js"><a name="contents_anchor">Tabela zawartości</a> +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.link()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/big/index.html b/files/pl/web/javascript/referencje/obiekty/string/big/index.html new file mode 100644 index 0000000000..62914dfa9c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/big/index.html @@ -0,0 +1,43 @@ +--- +title: String.prototype.big() +slug: Web/JavaScript/Referencje/Obiekty/String/big +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/big +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch znaków zostanie wyświetlony jakby znajdował się wewnątrz znacznika {{HTMLElement("big")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.big()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>big()</code> method embeds a string in a <code><big></code> tag: <code>"<big>str</big>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_big" name="Przyk.C5.82ad:_Zastosowanie_big">Przykład: Zastosowanie <code>big()</code></h3> + +<p>Następujący przykład stosuje metodę string do zmiany rozmiaru łańcucha znaków:</p> + +<pre class="brush: js">var worldString = "Witaj, Świecie"; + +console.log(worldString.small())<code class="language-js"><span class="token punctuation">;</span> <span class="token comment"> // </span></code><small>Witaj, Świecie</small> +console.log(worldString.big()); // <big>Witaj, Świecie</big> +console.log(worldString.fontsize(7)); // <fontsize=7>Witaj, Świecie</fontsize></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/blink/index.html b/files/pl/web/javascript/referencje/obiekty/string/blink/index.html new file mode 100644 index 0000000000..056dbc3792 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/blink/index.html @@ -0,0 +1,50 @@ +--- +title: String.prototype.blink() +slug: Web/JavaScript/Referencje/Obiekty/String/blink +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/blink +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch będzie migotał tak, jakby był on wewnątrz znacznika {{HTMLElement("blink")}}.</p> + +<div class="warning"> +<p><strong>Warning:</strong> Blinking text is frowned upon by several accessibility standards. The <code><blink></code> element itself is non-standard and deprecated!</p> +</div> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.blink()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>blink()</code> method embeds a string in a <code><blink></code> tag: <code>"<blink>str</blink>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <code>blink()</code></h3> + +<p>Następujący przykład stosuje metodę string do zmiany formatowania łańcucha znaków:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.blink()); // <blink>Witaj, Świecie</blink> +console.log(worldString.bold()); // <bold>Witaj, Świecie</bold> +console.log(worldString.italics()); // <i>Witaj, Świecie</i> +console.log(worldString.strike()); // <s>Witaj, Świecie</s> +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/bold/index.html b/files/pl/web/javascript/referencje/obiekty/string/bold/index.html new file mode 100644 index 0000000000..0708d5799e --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/bold/index.html @@ -0,0 +1,45 @@ +--- +title: String.prototype.bold() +slug: Web/JavaScript/Referencje/Obiekty/String/bold +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/bold +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje wyświetlenie łańcucha znaków jako pogrubienia, jakby był w znaczniku {{HTMLElement("b")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.bold()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>bold()</code> method embeds a string in a <code><b></code> tag: <code>"<b>str</b>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <strong><code>bold()</code></strong></h4> + +<p>Następujący przykład stosuje metodę string do zmiany rozmiaru łańcucha znaków:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.blink()); // <blink>Witaj, Świecie</blink> +console.log(worldString.bold()); // <bold>Witaj, Świecie</bold> +console.log(worldString.italics()); // <i>Witaj, Świecie</i> +console.log(worldString.strike()); // <s>Witaj, Świecie</s></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/charat/index.html b/files/pl/web/javascript/referencje/obiekty/string/charat/index.html new file mode 100644 index 0000000000..30ce5303c2 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/charat/index.html @@ -0,0 +1,68 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Referencje/Obiekty/String/charAt +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca określony znak z łańcucha znaków.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.charAt(<var>index</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>index</code> </dt> + <dd>Liczba całkowita z przedziału od 0 do liczby o 1 mniejszej od długości łańcucha.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Znaki w łańcuchu znaków są indeksowane od lewej do prawej strony. Indeksem pierwszego znaku jest 0, a indeksem ostatniego znaku w łańcuchu znaków o nazwie <code>stringName</code> jest <code>stringName.length - 1</code>. Jeśli dostarczona wartość parametru <code>index</code> znajduje się poza zakresem, JavaScript zwróci pusty łańcuch znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_r.C3.B3.C5.BCnych_znak.C3.B3w_z_okre.C5.9Blonego_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_r.C3.B3.C5.BCnych_znak.C3.B3w_z_okre.C5.9Blonego_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Wyświetlanie różnych znaków z określonego łańcucha znaków</h3> + +<p>Poniższy przykład wyświetla różne znaki łańcucha "<code>Brave new world</code>":</p> + +<pre class="brush: js">var anyString="Brave new world"; + +console.log("Znakiem o indeksie 0 jest '" + anyString.charAt(0) + "'"); +console.log("Znakiem o indeksie 1 jest '" + anyString.charAt(1) + "'"); +console.log("Znakiem o indeksie 2 jest '" + anyString.charAt(2) + "'"); +console.log("Znakiem o indeksie 3 jest '" + anyString.charAt(3) + "'"); +console.log("Znakiem o indeksie 4 jest '" + anyString.charAt(4) + "'"); +console.log("Znakiem o indeksie 999 jest '" + anyString.charAt(999) + "'"); +</pre> + +<p>Powyższy kod wyświetli:</p> + +<pre>Znakiem o indeksie 0 jest 'B' +Znakiem o indeksie 1 jest 'r' +Znakiem o indeksie 2 jest 'a' +Znakiem o indeksie 3 jest 'v' +Znakiem o indeksie 4 jest 'e' +Znakiem o indeksie 999 jest '' +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/charcodeat/index.html b/files/pl/web/javascript/referencje/obiekty/string/charcodeat/index.html new file mode 100644 index 0000000000..21c7822f12 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/charcodeat/index.html @@ -0,0 +1,42 @@ +--- +title: String.prototype.charCodeAt() +slug: Web/JavaScript/Referencje/Obiekty/String/charCodeAt +tags: + - JavaScript + - Method + - Prototype + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca liczbę oznaczającą wartość Unicode znaku o podanym indeksie.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.charCodeAt(<var>index</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>index</code> </dt> + <dd>Liczba całkowita z przedziału od 0 do liczby o 1 mniejszej od długości łańcucha.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wartości Unicode mieszczą się w zakresie od 0 do 65535. Pierwsze 128 wartości Unicode jest takie same jak w zbiorze znaków ASCII. Aby dowiedzieć się więcej o Unicode, zobacz <a href="/pl/docs/Web/JavaScript/Guide/Grammar_and_types#Unicode">Przewodnik po języku JavaScript</a>.</p> + +<p>Zgodność wsteczna: JavaScript 1.2 — Metoda <code>charCodeAt</code> zwraca liczbę wskazującą wartość ze zbioru kodowania ISO-Latin-1 znaku o podanym indeksie. Zbiór kodowania ISO-Latin-1 posiada zakres od 0 do 255. Znaki od 0 do 127 są identyczne, co te w zbiorze znaków ASCII.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_charCodeAt" name="Przyk.C5.82ad:_Zastosowanie_charCodeAt">Przykład: Zastosowanie <code>charCodeAt()</code></h3> + +<p>Następujący przykład zwróci 65, wartość A w Unicode.</p> + +<pre class="brush: js">"ABC".charCodeAt(0); // zwróci 65 +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/string/concat/index.html b/files/pl/web/javascript/referencje/obiekty/string/concat/index.html new file mode 100644 index 0000000000..b4361f0fd7 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/concat/index.html @@ -0,0 +1,44 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Referencje/Obiekty/String/concat +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Łączy tekst dwóch lub więcej łańcuchów znaków i zwraca nowy łańcuch.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.concat(<var>string2</var>, <var>string3</var>[, ..., <var>stringN</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>string2...string + <i>N</i> + </code> </dt> + <dd>Łańcuchy znaków mające być dołączone do tego łańcucha.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>concat()</code> łączy tekst jednego lub więcej łańcuchów znaków i zwraca nowy łańcuch znaków. Zmiana tekstu w jednym łańcuchu znaków nie ma wpływu na drugi łańcuch.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_concat" name="Przyk.C5.82ad:_Zastosowanie_concat">Przykład: Zastosowanie <code>concat()</code></h3> + +<p>Następujący przykład łączy łańcuchy znaków w nowy łańcuch znaków.</p> + +<pre class="brush: js">var s1="Och, "; +var s2="jaki piękny "; +var s3="poranek."; +var s4=s1.concat(s2,s3); // zwraca "Och, jaki piękny poranek." +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/string/fontcolor/index.html b/files/pl/web/javascript/referencje/obiekty/string/fontcolor/index.html new file mode 100644 index 0000000000..0cc7fa1ccc --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/fontcolor/index.html @@ -0,0 +1,50 @@ +--- +title: String.prototype.fontcolor() +slug: Web/JavaScript/Referencje/Obiekty/String/fontcolor +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony podanym kolorem tak jakby był wewnątrz znacznika {{HTMLElement("font")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.fontcolor(<var>color</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>color</code> </dt> + <dd>Łańcuch znaków wyrażający kolor jako trójka heksadecymalna RGB lub jako łańcuch znaków. Lista nazw w postaci łańcucha znaków dla kolorów jest dostępna w <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5">przewodniku po języku JavaScript 1.5</a>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli wyrażamy kolor w postaci trójki heksadecymalnej RGB, to musisz zastosować format <code>rrggbb</code>. Na przykład, wartość heksadecymalna koloru łososiowego składa się z red=FA, green=80 i blue=72, więc trójka RGB dla łososiowego będzie miała wartość "<code>FA8072</code>".</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_fontcolor" name="Przyk.C5.82ad:_Zastosowanie_fontcolor">Przykład: Zastosowanie <code>fontcolor()</code></h3> + +<p>Następujący przykład stosuje metodę <code>string</code> do zmiany koloru łańcucha znaków:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.fontcolor("red") + " jest koloru czerwonego w tej linii"); +// <font color="red">Witaj, Świecie</font> jest koloru czerwonego w tej linii + +console.log(worldString.fontcolor("FF00") +" linia jest czerwona i podany kolor heksadecymalny"); +// <font color="FF00">Witaj, Świecie</font> linia jest czerwona i podany kolor heksadecymalny +</pre> + +<div class="noinclude"> </div> + +<p> </p> diff --git a/files/pl/web/javascript/referencje/obiekty/string/fontsize/index.html b/files/pl/web/javascript/referencje/obiekty/string/fontsize/index.html new file mode 100644 index 0000000000..3de3c5bb4c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/fontsize/index.html @@ -0,0 +1,48 @@ +--- +title: String.prototype.fontsize() +slug: Web/JavaScript/Referencje/Obiekty/String/fontsize +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize +--- +<p>{{JSRef}}{{ Non-standard_header() }}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje wyświetlenie łańcucha znaków w określonym rozmiarze czcionki, tak jak to było w znaczniku {{HTMLElement("font")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.fontsize(<var>size</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>size</code> </dt> + <dd>Liczba całkowita pomiędzy 1 a 7, łańcuch znaków reprezentujący rozmiar znaku liczby całkowitej między 1 a 7.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Kiedy określisz rozmiar jako liczbę całkowitą, ustaw rozmiar <code>stringName</code> na jeden z 7 innych rozmiarów. Kiedy określisz <code>size</code> łańcucha znaków jako "-2", to dostosujesz rozmiar czcionki <code>stringName</code> relatywnie do rozmiaru jaki został ustawiony w znaczniku {{HTMLElement("basefont")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <strong><code>fontsize()</code></strong></h3> + +<pre class="brush: js language-js"><code class="language-js"><span class="token keyword">var</span> worldString <span class="token operator">=</span> <span class="token string">"Witaj, Świecie"</span><span class="token punctuation">;</span> + +console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>worldString<span class="token punctuation">.</span><span class="token function">small<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // <small>Witaj, Świecie</small> +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>worldString<span class="token punctuation">.</span><span class="token function">big<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // <big>Witaj, Świecie</big> +</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>worldString<span class="token punctuation">.</span><span class="token function">fontsize<span class="token punctuation">(</span></span><span class="token number">7</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // <fontsize=7>Witaj, Świecie</fontsize></span></code></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.big()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/fromcharcode/index.html b/files/pl/web/javascript/referencje/obiekty/string/fromcharcode/index.html new file mode 100644 index 0000000000..7d00613db2 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/fromcharcode/index.html @@ -0,0 +1,50 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Referencje/Obiekty/String/fromCharCode +tags: + - JavaScript + - Method + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków stworzony przez podaną sekwencję kodów Unicode.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em> </code> </dt> + <dd>Sekwencja liczb, które są wartościami Unicode.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Ta metoda zwraca łańcuch znaków nie będący {{jsxref("String")}}.</p> + +<p>Ponieważ <code>fromCharCode()</code> jest metodą statyczną {{jsxref("String")}}, używaj ją zawsze jako <code>String.fromCharCode()</code>, a nie jako metodę obiektu {{jsxref("String")}}.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_fromCharCode" name="Przyk.C5.82ad:_Zastosowanie_fromCharCode">Przykład: Zastosowanie <code>fromCharCode()</code></h3> + +<p>Następujący przykład zwraca łańcuch znaków <code>"ABC"</code>.</p> + +<pre class="brush: js">String.fromCharCode(65,66,67); // "ABC" +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/fromcodepoint/index.html b/files/pl/web/javascript/referencje/obiekty/string/fromcodepoint/index.html new file mode 100644 index 0000000000..a8c17af7f1 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/fromcodepoint/index.html @@ -0,0 +1,149 @@ +--- +title: String.fromCodePoint() +slug: Web/JavaScript/Referencje/Obiekty/String/fromCodePoint +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +--- +<div>{{JSRef}}</div> + +<p>The static <strong><code>String.fromCodePoint()</code></strong> method returns a string created by using the specified sequence of code points.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-fromcodepoint.html","shorter")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate">String<code>.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code><var>num1</var>, ..., <var>numN</var></code></dt> + <dd>A sequence of code points.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>A string created by using the specified sequence of code points.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>A {{jsxref("Errors/Not_a_codepoint", "RangeError")}} is thrown if an invalid Unicode code point is given (e.g. <code>"RangeError: NaN is not a valid code point"</code>).</li> +</ul> + +<h2 id="Description">Description</h2> + +<p>This method returns a string (and <em>not</em> a {{jsxref("String")}} object).</p> + +<p>Because <code>fromCodePoint()</code> is a static method of {{jsxref("String")}}, you must call it as <code>String.fromCodePoint()</code>, rather than as a method of a {{jsxref("String")}} object you created.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>The <code>String.fromCodePoint()</code> method has been added to ECMAScript 2015 and may not be supported in all web browsers or environments yet.</p> + +<p>Use the code below for a polyfill:</p> + +<pre class="brush: js notranslate">if (!String.fromCodePoint) (function(stringFromCharCode) { + var fromCodePoint = function(_) { + var codeUnits = [], codeLen = 0, result = ""; + for (var index=0, len = arguments.length; index !== len; ++index) { + var codePoint = +arguments[index]; + // correctly handles all cases including `NaN`, `-Infinity`, `+Infinity` + // The surrounding `!(...)` is required to correctly handle `NaN` cases + // The (codePoint>>>0) === codePoint clause handles decimals and negatives + if (!(codePoint < 0x10FFFF && (codePoint>>>0) === codePoint)) + throw RangeError("Invalid code point: " + codePoint); + if (codePoint <= 0xFFFF) { // BMP code point + codeLen = codeUnits.push(codePoint); + } else { // Astral code point; split in surrogate halves + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + codePoint -= 0x10000; + codeLen = codeUnits.push( + (codePoint >> 10) + 0xD800, // highSurrogate + (codePoint % 0x400) + 0xDC00 // lowSurrogate + ); + } + if (codeLen >= 0x3fff) { + result += stringFromCharCode.apply(null, codeUnits); + codeUnits.length = 0; + } + } + return result + stringFromCharCode.apply(null, codeUnits); + }; + try { // IE 8 only supports `Object.defineProperty` on DOM elements + Object.defineProperty(String, "fromCodePoint", { + "value": fromCodePoint, "configurable": true, "writable": true + }); + } catch(e) { + String.fromCodePoint = fromCodePoint; + } +}(String.fromCharCode)); +</pre> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_fromCodePoint">Using <code>fromCodePoint()</code></h3> + +<p>Valid input:</p> + +<pre class="brush: js notranslate">String.fromCodePoint(42); // "*" +String.fromCodePoint(65, 90); // "AZ" +String.fromCodePoint(0x404); // "\u0404" == "Є" +String.fromCodePoint(0x2F804); // "\uD87E\uDC04" +String.fromCodePoint(194564); // "\uD87E\uDC04" +String.fromCodePoint(0x1D306, 0x61, 0x1D307); // "\uD834\uDF06a\uD834\uDF07" +</pre> + +<p>Invalid input:</p> + +<pre class="brush: js notranslate">String.fromCodePoint('_'); // RangeError +String.fromCodePoint(Infinity); // RangeError +String.fromCodePoint(-1); // RangeError +String.fromCodePoint(3.14); // RangeError +String.fromCodePoint(3e-2); // RangeError +String.fromCodePoint(NaN); // RangeError +</pre> + +<h3 id="Compared_to_fromCharCode">Compared to <code>fromCharCode()</code></h3> + +<p>{{jsxref("String.fromCharCode()")}} cannot return supplementary characters (i.e. code points <code>0x010000</code> – <code>0x10FFFF</code>) by specifying their code point. Instead, it requires the UTF-16 surrogate pair in order to return a supplementary character:</p> + +<pre class="brush: js notranslate">String.fromCharCode(0xD83C, 0xDF03); // Code Point U+1F303 "Night with +String.fromCharCode(55356, 57091); // Stars" == "\uD83C\uDF03" +</pre> + +<p><code>String.fromCodePoint()</code>, on the other hand, can return 4-byte supplementary characters, as well as the more common 2-byte BMP characters, by specifying their code point (which is equivalent to the UTF-32 code unit):</p> + +<pre class="brush: js notranslate">String.fromCodePoint(0x1F303); // or 127747 in decimal +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.fromCodePoint")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/index.html b/files/pl/web/javascript/referencje/obiekty/string/index.html new file mode 100644 index 0000000000..ff27fbc81a --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/index.html @@ -0,0 +1,194 @@ +--- +title: String +slug: Web/JavaScript/Referencje/Obiekty/String +tags: + - JavaScript + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Tworzy obiekt pozwalający działać na ciągach znaków.</p> + +<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia</h2> + +<p>Literały znakowe są postaci:</p> + +<pre class="syntaxbox notranslate">'string text' +"string text" +"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ்" +</pre> + +<p>Beside regular, printable characters, special characters can be encoded using escape notation:</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Code</th> + <th scope="col">Output</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>\0</code></td> + <td>the NUL character</td> + </tr> + <tr> + <td><code>\'</code></td> + <td>single quote</td> + </tr> + <tr> + <td><code>\"</code></td> + <td>double quote</td> + </tr> + <tr> + <td><code>\\</code></td> + <td>backslash</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>new line</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>carriage return</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>vertical tab</td> + </tr> + <tr> + <td><code>\t</code></td> + <td>tab</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>\uXXXX</code></td> + <td>unicode codepoint</td> + </tr> + <tr> + <td><code>\xXX</code></td> + <td>the Latin-1 character</td> + </tr> + </tbody> +</table> + +<p>Or, using the <code>String</code> global object directly:</p> + +<pre class="syntaxbox notranslate">String(thing) +new String(thing) +</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>thing</code></dt> + <dd>Dowolny łańcuch znaków.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>trings are useful for holding data that can be represented in text form. Some of the most-used operations on strings are to check their {{jsxref("String.length", "length")}}, to build and concatenate them using the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">+ and += string operators</a>, checking for the existence or location of substrings with the {{jsxref("String.prototype.indexOf()", "indexOf()")}} method, or extracting substrings with the {{jsxref("String.prototype.substring()", "substring()")}} method.</p> + +<h3 id="Character_access" name="Character_access">Character access</h3> + +<p>There are two ways to access an individual character in a string. The first is the {{jsxref("String.prototype.charAt()", "charAt()")}} method:</p> + +<pre class="brush: js notranslate">return 'cat'.charAt(1); // returns "a"</pre> + +<div class="line-number" style="top: 0px;"></div> + +<p>The other way (introduced in ECMAScript 5) is to treat the string as an array-like object, where individual characters correspond to a numerical index:</p> + +<pre class="brush: js notranslate">return 'cat'[1]; // returns "a"</pre> + +<div class="line-number" style="top: 0px;"></div> + +<p>For character access using bracket notation, attempting to delete or assign a value to these properties will not succeed. The properties involved are neither writable nor configurable. (See {{jsxref("Object.defineProperty()")}} for more information.)</p> + +<h3 id="Comparing_strings" name="Comparing_strings">Comparing strings</h3> + +<p>C developers have the <code>strcmp()</code> function for comparing strings. In JavaScript, you just use the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">less-than and greater-than operators</a>:</p> + +<pre class="brush: js notranslate">var a = 'a'; +var b = 'b'; +if (a < b) { // true + print(a + ' is less than ' + b); +} else if (a > b) { + print(a + ' is greater than ' + b); +} else { + print(a + ' and ' + b + ' are equal.'); +}</pre> + +<p>A similar result can be achieved using the {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} method inherited by <code>String</code> instances.</p> + +<h3 id="Distinction_between_string_primitives_and_String_objects">Distinction between string primitives and <code>String</code> objects</h3> + +<p>Note that JavaScript distinguishes between <code>String</code> objects and primitive string values. (The same is true of {{jsxref("Global_Objects/Boolean", "Boolean")}} and {{jsxref("Global_Objects/Number", "Numbers")}}.)</p> + +<p>String literals (denoted by double or single quotes) and strings returned from <code>String</code> calls in a non-constructor context (i.e., without using the {{jsxref("Operators/new", "new")}} keyword) are primitive strings. JavaScript automatically converts primitives to <code>String</code> objects, so that it's possible to use <code>String</code> object methods for primitive strings. In contexts where a method is to be invoked on a primitive string or a property lookup occurs, JavaScript will automatically wrap the string primitive and call the method or perform the property lookup.</p> + +<pre class="brush: js notranslate">var s_prim = 'foo'; +var s_obj = new String(s_prim); + +console.log(typeof s_prim); // Logs "string" +console.log(typeof s_obj); // Logs "object"</pre> + +<div class="line-number" style="top: 76px;"></div> + +<p>String primitives and <code>String</code> objects also give different results when using {{jsxref("Global_Objects/eval", "eval()")}}. Primitives passed to <code>eval</code> are treated as source code; <code>String</code> objects are treated as all other objects are, by returning the object. For example:</p> + +<pre class="brush: js notranslate">var s1 = '2 + 2'; // creates a string primitive +var s2 = new String('2 + 2'); // creates a String object +console.log(eval(s1)); // returns the number 4 +console.log(eval(s2)); // returns the string "2 + 2"</pre> + +<p>For these reasons, code may break when it encounters <code>String</code> objects when it expects a primitive string instead, although generally authors need not worry about the distinction.</p> + +<p>A <code>String</code> object can always be converted to its primitive counterpart with the {{jsxref("String.prototype.valueOf()", "valueOf()")}} method.</p> + +<pre class="brush: js notranslate">console.log(eval(s2.valueOf())); // returns the number 4</pre> + +<div class="note"><strong>Note:</strong> For another possible approach to strings in JavaScript, please read the article about <a href="https://developer.mozilla.org/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — a C-like representation of strings based on typed arrays</a>.</div> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt>{{jsxref("String.prototype")}}</dt> + <dd>Pozwala na dodawanie własności do obiektu <code>String</code>.</dd> +</dl> + +<div>{{jsOverrides("Function", "Properties", "prototype")}}</div> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("String.fromCharCode()")}}</dt> + <dd>Zwraca łańcuch znaków stworzony przez podaną sekwencję kodów Unicode.</dd> + <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt> + <dd>Returns a string created by using the specified sequence of code points.</dd> + <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt> + <dd>Returns a string created from a raw template string.</dd> +</dl> + +<div>{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint", "raw")}}</div> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Example_String_conversion">Example: String conversion</h3> + +<p>It's possible to use <code>String</code> as a "safer" {{jsxref("String.prototype.toString()", "toString()")}} alternative, as although it still normally calls the underlying <code>toString()</code>, it also works for {{jsxref("null")}} and {{jsxref("undefined")}}. For example:</p> + +<pre class="brush: js notranslate">var outputStrings = []; +for (var i = 0, n = inputValues.length; i < n; ++i) { + outputStrings.push(String(inputValues[i])); +}</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/string/italics/index.html b/files/pl/web/javascript/referencje/obiekty/string/italics/index.html new file mode 100644 index 0000000000..016a400805 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/italics/index.html @@ -0,0 +1,45 @@ +--- +title: String.prototype.italics() +slug: Web/JavaScript/Referencje/Obiekty/String/italics +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/italics +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony kursywą tak jakby był wewnątrz znacznika {{HTMLElement("i")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.italics()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>italics()</code> method embeds a string in an <code><i></code> tag: <code>"<i>str</i>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego">Przykład: Zastosowanie metody <code>italics()</code></h3> + +<p>Następujący przykład stosuje metodę <code>string</code> do zmiany formatowania łańcucha znakowego:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.blink()); // <blink>Witaj, Świecie</blink> +console.log(worldString.bold()); // <bold>Witaj, Świecie</bold> +console.log(worldString.italics()); // <i>Witaj, Świecie</i> +console.log(worldString.strike()); // <s>Witaj, Świecie</s></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/link/index.html b/files/pl/web/javascript/referencje/obiekty/string/link/index.html new file mode 100644 index 0000000000..6d8baeb078 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/link/index.html @@ -0,0 +1,43 @@ +--- +title: String.prototype.link() +slug: Web/JavaScript/Referencje/Obiekty/String/link +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/link +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Tworzy <a class="external" href="http://www.w3.org/TR/html401/struct/links.html#adef-href">łącze hipertekstowe</a>, które wywołuje inny URL.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.link(<var>url</var>)</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>url</code></dt> + <dd>Jakikolwiek łańcuch określony w <code>href</code> ze znacznika <code>a</code>; powinien być umieszczany poprawny URL (relatywny lub absolutny).</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Linki tworzymy poprzez metodę <code>link</code> stającą się elementami tablicy <code>links</code> z obiektu <code>document</code>. Zobacz <code>document.links</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_link" name="Przyk.C5.82ad:_Zastosowanie_link">Przykład: Zastosowanie <code>link()</code></h3> + +<p>Następujący przykład wyświetla słowo "MDN" jako odnośnik hipertekstowy, poprzez który użytkownik będzie mógł przejść na stronę domową Netscape:</p> + +<pre class="brush: js">var hotText="MDN"; +var URL="<code class="language-js"><span class="token string">https://developer.mozilla.org/</span></code>"; + +console.log("Kliknij, aby powrócić do " + hotText.link(URL)); +// Kliknij, aby powrócić do <a href="https://developer.mozilla.org">MDN</a> +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/string/prototype/index.html b/files/pl/web/javascript/referencje/obiekty/string/prototype/index.html new file mode 100644 index 0000000000..eccba2efdf --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/prototype/index.html @@ -0,0 +1,220 @@ +--- +title: String.prototype +slug: Web/JavaScript/Referencje/Obiekty/String/prototype +tags: + - JavaScript + - Property + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Reprezentuje prototyp obiektów danej klasy. Pozwala na dodawanie własności i metod do wszystkich instancji tej klasy.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Opis</h2> + +<p>Wszystkie instancje {{jsxref("Global_Objects/String", "String")}} dziedziczą z <code>String.prototype</code>. Zmiany w prototypie obiektu <code>String</code> są propagowane do wszystkich instancji {{jsxref("Global_Objects/String", "String")}}.</p> + +<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2> + +<dl> + <dt><code>String.prototype.constructor</code></dt> + <dd>Oznacza funkcję, która tworzy prototyp obiektu.</dd> + <dt>{{jsxref("String.prototype.length")}}</dt> + <dd>Odzwierciedla długość łańcucha znaków.</dd> + <dt><code><em>N</em></code></dt> + <dd>Używane celem uzyskania dostępu do znaku na pozycji <em>N-tej</em> gdzie <em>N</em> jest dodatnią liczbą całkowitą między 0 a o jeden mniejszą od {{jsxref("String.length", "length")}}. Własności te są tylko do odczytu.</dd> +</dl> + +<h2 id="Methods" name="Methods">Metody</h2> + +<h3 id="Metody_niezwi.C4.85zane_z_HTML" name="Metody_niezwi.C4.85zane_z_HTML">Metody niezwiązane z HTML</h3> + +<dl> + <dt>{{jsxref("String.prototype.charAt()")}}</dt> + <dd>Zwraca znak o podanym indeksie.</dd> + <dt>{{jsxref("String.prototype.charCodeAt()")}}</dt> + <dd>Zwraca liczbę oznaczającą wartość Unicode znaku o podanym indeksie.</dd> + <dt>{{jsxref("String.prototype.codePointAt()")}} {{experimental_inline}}</dt> + <dd>Returns a non-negative integer that is the UTF-16 encoded code point value at the given position.</dd> + <dt>{{jsxref("String.prototype.concat()")}}</dt> + <dd>Łączy dwa łańcuchy znaków i zwraca nowy łańcuch.</dd> + <dt>{{jsxref("String.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Determines whether one string may be found within another string.</dd> + <dt>{{jsxref("String.prototype.endsWith()")}} {{experimental_inline}}</dt> + <dd>Determines whether a string ends with the characters of another string.</dd> + <dt>{{jsxref("String.prototype.indexOf()")}}</dt> + <dd>Zwraca indeks pierwszego wystąpienia podanego znaku w obiekcie <code>String</code> lub <code>-1</code>, gdy niczego nie znaleziono.</dd> + <dt>{{jsxref("String.prototype.lastIndexOf()")}}</dt> + <dd>Zwraca indeks ostatniego wystąpienia podanego znaku w obiekcie <code>String</code> lub <code>-1</code>, gdy niczego nie znaleziono.</dd> + <dt>{{jsxref("String.prototype.localeCompare()")}}</dt> + <dd>Returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order.</dd> + <dt>{{jsxref("String.prototype.match()")}}</dt> + <dd>Używane do porównania wyrażenia regularnego z łańcuchem znaków.</dd> + <dt>{{jsxref("String.prototype.normalize()")}} {{experimental_inline}}</dt> + <dd>Returns the Unicode Normalization Form of the calling string value.</dd> + <dt><s class="obsoleteElement">{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Wraps the string in double quotes ("<code>"</code>").</s></dd> + <dt>{{jsxref("String.prototype.repeat()")}} {{experimental_inline}}</dt> + <dd>Returns a string consisting of the elements of the object repeated the given times.</dd> + <dt>{{jsxref("String.prototype.replace()")}}</dt> + <dd>Używane do znalezienia podobieństwa pomiędzy wyrażeniem regularnym a łańcuchem znaków, a następnie do podmiany znalezionego podłańcucha nowym podłańcuchem.</dd> + <dt>{{jsxref("String.prototype.search()")}}</dt> + <dd>Uruchamia wyszukiwanie podobieństwa pomiędzy wyrażeniem regularnym a podanym łańcuchem.</dd> + <dt>{{jsxref("String.prototype.slice()")}}</dt> + <dd>Wyciąga kawałek łańcucha i zwraca nowy łańcuch.</dd> + <dt>{{jsxref("String.prototype.split()")}}</dt> + <dd>Dzieli obiekt {{jsxref("String")}} na tablicę łańcuchów poprzez dzielenie łańcucha na podłańcuchy.</dd> + <dt>{{jsxref("String.prototype.startsWith()")}} {{experimental_inline}}</dt> + <dd>Determines whether a string begins with the characters of another string.</dd> + <dt>{{jsxref("String.prototype.substr()")}}</dt> + <dd>Zwraca podłańcuch znaków z łańcucha, zaczynający się w podanym miejscu i podanej długości znaków.</dd> + <dt>{{jsxref("String.prototype.substring()")}}</dt> + <dd>Zwraca znaki w podłańcuchu pomiędzy dwoma indeksami w łańcuchu.</dd> + <dt>{{jsxref("String.prototype.toLocaleLowerCase()")}}</dt> + <dd>The characters within a string are converted to lower case while respecting the current locale. For most languages, this will return the same as {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.</dd> + <dt>{{jsxref("String.prototype.toLocaleUpperCase()")}}</dt> + <dd>The characters within a string are converted to upper case while respecting the current locale. For most languages, this will return the same as {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}.</dd> + <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt> + <dd>Zwraca wywołujący łańcuch skonwertowany do małych liter.</dd> + <dt>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Zwraca literał obiektu reprezentujący podany obiekt; możesz użyć tej wartości do utworzenia nowego obiektu. Przesłania metodę {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("String.prototype.toString()")}}</dt> + <dd>Zwraca łańcuch reprezentujący podany obiekt. Przesłania metodę {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt> + <dd>Zwraca wywołujący łańcuch skonwertowany do wielkich liter.</dd> + <dt>{{jsxref("String.prototype.trim()")}}</dt> + <dd>Trims whitespace from the beginning and end of the string. Part of the ECMAScript 5 standard.</dd> + <dt>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</dt> + <dd>Trims whitespace from the left side of the string.</dd> + <dt>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</dt> + <dd>Trims whitespace from the right side of the string.</dd> + <dt>{{jsxref("String.prototype.valueOf()")}}</dt> + <dd>Zwraca wartość prymitywną podanego obiektu. Przesłania metodę {{jsxref("Object.prototype.valueOf()")}}.</dd> + <dt>{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}} {{experimental_inline}}</dt> + <dd>Returns a new <code>Iterator</code> object that iterates over the code points of a String value, returning each code point as a String value.</dd> +</dl> + +<h3 id="Metody_zwi.C4.85zane_z_HTML" name="Metody_zwi.C4.85zane_z_HTML">Metody związane z HTML</h3> + +<p>These methods are of limited use, as they provide only a subset of the available HTML tags and attributes.</p> + +<dl> + <dt>{{jsxref("String.prototype.anchor()")}}</dt> + <dd>{{htmlattrxref("name", "a", "<a name=\"name\">")}} (hypertext target)</dd> + <dt>{{jsxref("String.prototype.big()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("big")}}</dd> + <dt>{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("blink")}}</dd> + <dt>{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("b")}}</dd> + <dt>{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("tt")}}</dd> + <dt>{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}</dt> + <dd>{{htmlattrxref("color", "font", "<font color=\"color\">")}}</dd> + <dt>{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}</dt> + <dd>{{htmlattrxref("size", "font", "<font size=\"size\">")}}</dd> + <dt>{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("i")}}</dd> + <dt>{{jsxref("String.prototype.link()")}}</dt> + <dd>{{htmlattrxref("href", "a", "<a href=\"rul\">")}} (link to URL)</dd> + <dt>{{jsxref("String.prototype.small()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("small")}}</dd> + <dt>{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("strike")}}</dd> + <dt>{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("sub")}}</dd> + <dt>{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("sup")}}</dd> +</dl> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">See also</h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/repeat/index.html b/files/pl/web/javascript/referencje/obiekty/string/repeat/index.html new file mode 100644 index 0000000000..76bf932753 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/repeat/index.html @@ -0,0 +1,166 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Referencje/Obiekty/String/repeat +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +--- +<div>{{JSRef}}</div> + +<p>The <strong><code>repeat()</code></strong> method constructs and returns a new string which contains the specified number of copies of the string on which it was called, concatenated together.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>str</var>.repeat(<var>count</var>)</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>count</code></dt> + <dd>An integer between 0 and +∞: [0, +∞), indicating the number of times to repeat the string in the newly-created string that is to be returned.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>A new string containing the specified number of copies of the given string.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: repeat count must be non-negative.</li> + <li>{{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: repeat count must be less than infinity and not overflow maximum string size.</li> +</ul> + +<h2 id="Przykłady">Przykłady</h2> + +<pre class="brush: js">'abc'.repeat(-1); // RangeError +'abc'.repeat(0); // '' +'abc'.repeat(1); // 'abc' +'abc'.repeat(2); // 'abcabc' +'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer) +'abc'.repeat(1/0); // RangeError + +({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2); +// 'abcabc' (repeat() is a generic method) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>This method has been added to the ECMAScript 6 specification and may not be available in all JavaScript implementations yet. However, you can polyfill <code>String.prototype.repeat()</code> with the following snippet:</p> + +<pre class="brush: js">if (!String.prototype.repeat) { + String.prototype.repeat = function(count) { + 'use strict'; + if (this == null) { + throw new TypeError('can\'t convert ' + this + ' to object'); + } + var str = '' + this; + count = +count; + if (count != count) { + count = 0; + } + if (count < 0) { + throw new RangeError('repeat count must be non-negative'); + } + if (count == Infinity) { + throw new RangeError('repeat count must be less than infinity'); + } + count = Math.floor(count); + if (str.length == 0 || count == 0) { + return ''; + } + // Ensuring count is a 31-bit integer allows us to heavily optimize the + // main part. But anyway, most current (August 2014) browsers can't handle + // strings 1 << 28 chars or longer, so: + if (str.length * count >= 1 << 28) { + throw new RangeError('repeat count must not overflow maximum string size'); + } + var rpt = ''; + for (;;) { + if ((count & 1) == 1) { + rpt += str; + } + count >>>= 1; + if (count == 0) { + break; + } + str += str; + } + // Could we try: + // return Array(count + 1).join(this); + return rpt; + } +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("41")}} </td> + <td>{{CompatGeckoDesktop("24")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("36")}}</td> + <td>{{CompatGeckoMobile("24")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/pl/web/javascript/referencje/obiekty/string/search/index.html b/files/pl/web/javascript/referencje/obiekty/string/search/index.html new file mode 100644 index 0000000000..29b9d8e8fb --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/search/index.html @@ -0,0 +1,49 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Referencje/Obiekty/String/search +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wykonuje przeszukanie dla dopasowanych wyrażeń regularnych i tego obiektu {{jsxref("String")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><var>str</var>.search(<var>regexp</var>)</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>regexp</code> </dt> + <dd>Nazwa wyrażenia regularnego. Może być to nazwa zmiennej lub literał.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli sukces, rezultat przeszukania indeksu wyrażenia regularnego wewnątrz łańcucha znaków. Inaczej zwróci -1.</p> + +<p>Kiedy chcesz wiedzieć gdzie jest znaleziony wzorzec w łańcuchu znaków zastosuj <code>search()</code> (podobne do wyrażenia regularnego metody {{jsxref("RegExp.prototype.test()", "test()")}}); aby uzyskać więcej informacji (lecz wolniej wykonywanie) zastosuj {{jsxref("String.prototype.match()", "match()")}} (podobne do wyrażenia regularnego metody {{jsxref("RegExp.prototype.exec()", "exec()")}} method).</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_search" name="Przyk.C5.82ad:_Zastosowanie_search">Przykład: Zastosowanie <code>search</code>()</h3> + +<p>Następujący przykład drukuje wiadomość, która zależy od sukcesu testu.</p> + +<pre class="brush: js">function testinput(re, str){ + var midstring; + if (str.search(re) != -1) { + midstring = " contains "; + } else { + midstring = " does not contain "; + } + console.log (str + midstring + re.source); +} +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/string/slice/index.html b/files/pl/web/javascript/referencje/obiekty/string/slice/index.html new file mode 100644 index 0000000000..4fca8a78ca --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/slice/index.html @@ -0,0 +1,51 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Referencje/Obiekty/String/slice +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wydobywa część łańcucha znaków i zwraca go jako nowy łańcuch znaków.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.slice(<var>beginSlice</var>[, <var>endSlice</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>beginSlice</code> </dt> + <dd>Oparty na zerze początek indeksu rozpoczynający wyciąganie.</dd> +</dl> + +<dl> + <dt><code>endSlice</code> </dt> + <dd>Oparty na zerze początek indeksu, który kończy wyciąganie. Jeśli pominięty <code>slice()</code> wydobywa do końca łańcuch znaków.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>slice()</code> wyciąga tekst z jednego łańcucha znaków i zwraca nowy łańcuch znaków. Zmiany w treści jednego łańcucha znaków nie mają wpływu na drugi.</p> + +<p><code>slice()</code> wyciąga tekst do <code>endSlice</code> lecz go nie włącza. <code>string.slice(1,4)</code> wyciąga drugi znak aż do czwartego (znaki o indeksach 1, 2 i 3).</p> + +<p>Jako ujemny indeks <code>endSlice</code> sygnalizuje przesunięcie z końca łańcucha znaków. <code>str.slice(2,-1)</code> wyciąga trzeci przez ostatni znak w łańcuchu znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad_Zastosowanie_slice_do_stworzenia_nowego_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_slice_do_stworzenia_nowego_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <code>slice()</code></h3> + +<p>Poniższy przykład używa <code>slice</code> do stworzenia nowego łańcucha znaków.</p> + +<pre class="brush: js">var str1 = 'The morning is upon us.'; +var str2 = str1.slice(4,-2); + +console.log(str2); // OUTPUT: morning is upon u +</pre> diff --git a/files/pl/web/javascript/referencje/obiekty/string/small/index.html b/files/pl/web/javascript/referencje/obiekty/string/small/index.html new file mode 100644 index 0000000000..be9d33a5bb --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/small/index.html @@ -0,0 +1,37 @@ +--- +title: String.prototype.small() +slug: Web/JavaScript/Referencje/Obiekty/String/small +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/String/small +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje to, że łańcuch znaków będzie wyświetlany małą czcionką, jakby znajdował się wewnątrz znacznika {{HTMLElement("small")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.small()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>small()</code> method embeds a string in a <code><small></code> tag: <code>"<small>str</small>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znakowego" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znakowego">Przykład: Zastosowanie metody <code>small()</code></h3> + +<pre class="brush: js">var worldString = "Witaj, Świecie"; + +console.log(worldString.small()); // <small>Witaj, Świecie</small> +console.log(worldString.big()); // <big>Witaj, Świecie</big> +console.log(worldString.fontsize(7)); // <fontsize=7>Witaj, Świecie</fontsize></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.big()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/strike/index.html b/files/pl/web/javascript/referencje/obiekty/string/strike/index.html new file mode 100644 index 0000000000..cef74018f1 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/strike/index.html @@ -0,0 +1,44 @@ +--- +title: String.prototype.strike() +slug: Web/JavaScript/Referencje/Obiekty/String/strike +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/strike +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony przekreślony, tak jakby był wewnątrz znacznika {{HTMLElement("strike")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.strike()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>strike()</code> method embeds a string in a <code><strike></code> tag: <code>"<strike>str</strike>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego">Przykład: Zastosowanie metody <code>strike()</code></h3> + +<p>Następujący przykład stosuje metodę <code>string</code> do zmiany formatowania łańcucha znakowego:</p> + +<pre class="brush: js">var worldString="Witaj, Świecie"; + +console.log(worldString.blink()); // <blink>Witaj, Świecie</blink> +console.log(worldString.bold()); // <bold>Witaj, Świecie</bold> +console.log(worldString.italics()); // <i>Witaj, Świecie</i> +console.log(worldString.strike()); // <s>Witaj, Świecie</s></pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/sub/index.html b/files/pl/web/javascript/referencje/obiekty/string/sub/index.html new file mode 100644 index 0000000000..4c36c53a39 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/sub/index.html @@ -0,0 +1,44 @@ +--- +title: String.prototype.sub() +slug: Web/JavaScript/Referencje/Obiekty/String/sub +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sub +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony jako indeks dolny tak jakby był wewnątrz znacznika {{HTMLElement("sub")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.sub()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>sub()</code> method embeds a string in a <code><sub></code> tag: <code>"<sub>str</sub>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_metod_sub_i_sup_do_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metod_sub_i_sup_do_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie metod <code>sub()</code> i <code>sup()</code></h4> + +<p>Następujący przykład stosuje metody <code>sub()</code> i {{jsxref("String.prototype.sup()", "sup()")}} do formatowania łańcucha znaków:</p> + +<pre class="brush: js">var superText="superscript"; +var subText="subscript"; + +console.log("This is what a " + superText.sup() + " looks like."); +// This is what a <sup>superscript</sup> looks like + +console.log("This is what a " + subText.sub() + " looks like."); +// This is what a <sub>subscript</sub> looks like.</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.sup()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/substr/index.html b/files/pl/web/javascript/referencje/obiekty/string/substr/index.html new file mode 100644 index 0000000000..61487db384 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/substr/index.html @@ -0,0 +1,66 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Referencje/Obiekty/String/substr +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca określoną liczbę początkowych znaków w łańcuchu znaków w określonej lokalizacji.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.substr(<var>start</var>[, <var>length</var>])</code></pre> + +<h2 id="Parametry" name="Parametry">Parametry</h2> + +<dl> + <dt><code>start</code> </dt> + <dd>Lokalizacja, w której rozpoczyna się wyciąganie znaków (wartość liczbowa pomiędzy 0, a jeden znak mniej niż długość łańcucha znaków).</dd> +</dl> + +<dl> + <dt><code>length</code> </dt> + <dd>Liczba znaków do wyciągnięcia.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>start</code> jest indeksem znaków. Pierwszym znakiem w indeksie jest 0 i ostatnim znakiem w indeksie jest liczba o 1 mniejsza niż długość łańcucha znaków. <code>substr()</code> rozpoczyna wyciąganie znaków w <code>start</code> i ściąga liczbę <code>length</code> znaków.</p> + +<p>Jeśli <code>start</code> jest dodatnie i jest długością łańcucha znaków lub dłuższą wartością, <code>substr()</code> nie zwraca znaków.</p> + +<p>Jeśli <code>start</code> jest ujemne, <code>substr()</code> stosuje to jako indeks znaków z końca łańcucha znaków. Jeśli <code>start</code> jest ujemne i <code>abs(start)</code> jest większe niż długość łańcucha znaków to <code>substr()</code> stosuje 0 jako początek indeksu.</p> + +<p>Jeśli <code>length</code> jest 0 lub ujemne, <code>substr()</code> nie zwróci znaków. Jeśli <code>length</code> jest opuszczone, <code>substr()</code> wyciągnie znaki aż do końca łańcucha znaków.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_substr" name="Przyk.C5.82ad:_Zastosowanie_substr">Przykład: Zastosowanie <code>substr()</code></h3> + +<p>Rozpatrz poniższy skrypt:</p> + +<pre class="brush: js">var str = 'abcdefghij'; + +console.log('(1, 2): ' + str.substr(1, 2)); // '(1, 2): bc' +console.log('(-3, 2): ' + str.substr(-3, 2)); // '(-3, 2): hi' +console.log('(-3): ' + str.substr(-3)); // '(-3): hij' +console.log('(1): ' + str.substr(1)); // '(1): bcdefghij' +console.log('(-20, 2): ' + str.substr(-20, 2)); // '(-20, 2): ab' +console.log('(20, 2): ' + str.substr(20, 2)); // '(20, 2): ' +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<p> </p> + +<ul> + <li>{{jsxref("String.prototype.slice()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/substring/index.html b/files/pl/web/javascript/referencje/obiekty/string/substring/index.html new file mode 100644 index 0000000000..5a446e0225 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/substring/index.html @@ -0,0 +1,90 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Referencje/Obiekty/String/substring +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca podciąg obiektu <code>String</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.substring(<var>indexA</var>[, <var>indexB</var>])</code></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>indexA</code> </dt> + <dd>Liczba całkowita pomiędzy 0, a liczbą o jeden mniejszą niż długość łańcucha znaków.</dd> + <dt><code>indexB</code> </dt> + <dd>Opcjonalny. Liczba całkowita pomiędzy 0 i długością łańcucha znaków.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>substring</code> urywa znaki z <code>indexA</code> lecz nie włącza ich do <code>indexB</code>. W szczególności:</p> + +<ul> + <li>Jeśli <code>indexA</code> jest mniejsze niż 0, <code>indexA</code> zostanie potraktowany tak, jakby był 0.</li> + <li>Jeśli <code>indexB</code> jest większe niż <code>stringName.length</code>, <code>indexB</code> zostanie potraktowany tak, jakby był <code>stringName.length</code>.</li> + <li>Jeśli <code>indexA</code> jest równe <code>indexB</code>, <code>substring</code> zwraca pusty łańcuch znaków.</li> + <li>Jeśli <code>indexB</code> jest pominięty, <code>substring</code> urwie znaki znajdujące się na końcu łańcucha znaków.</li> +</ul> + +<p>Jeśli <code>indexA</code> jest większy niż <code>indexB</code>, JavaScript zwróci <code>substring(indexB, indexA)</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_substring" name="Przyk.C5.82ad:_Zastosowanie_substring">Przykład: Zastosowanie <code>substring()</code></h3> + +<p>Następujący przykład <code>substring</code> stosujemy do wyświetlenia znaków ze słowa "<code>Mozilla</code>":</p> + +<pre class="brush: js">var anyString = "Mozilla"; + +// Wyświetli "Moz" +console.log(anyString.substring(0,3)); +console.log(anyString.substring(3,0)); + +// Wyświetli "lla" +console.log(anyString.substring(4)); +console.log(anyString.substring(4,7)); +console.log(anyString.substring(7,4)); + +// Wyświetli "Mozill" +console.log(anyString.substring(0,6)); + +// Wyświetli "Mozilla" +console.log(anyString.substring(0,7)); +console.log(anyString.substring(0,10)); +</pre> + +<h3 id="Przyk.C5.82ad:_Zamina_podci.C4.85gu_wewn.C4.85trz_ci.C4.85gu" name="Przyk.C5.82ad:_Zamina_podci.C4.85gu_wewn.C4.85trz_ci.C4.85gu">Przykład: Zamiana podciągu wewnątrz ciągu</h3> + +<p>Następujący przykład zamienia podciąg wewnątrz ciągu. Zostaną zamienione oba poszczególne znaki i podciągi. Funkcja zostanie wywołana na koniec przykładu zmieniając łańcuch znaków; "<code>Brave New World</code>" na "<code>Brave New Web</code>".</p> + +<pre class="brush: js">function replaceString(oldS, newS, fullS) { +// Replaces oldS with newS in the string fullS + for (var i = 0; i < fullS.length; i++) { + if (fullS.substring(i, i + oldS.length) == oldS) { + fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length); + } + } + return fullS; +} + +replaceString("World", "Web", "Brave New World"); +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.slice()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/sup/index.html b/files/pl/web/javascript/referencje/obiekty/string/sup/index.html new file mode 100644 index 0000000000..dbf33ea3ed --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/sup/index.html @@ -0,0 +1,45 @@ +--- +title: String.prototype.sup() +slug: Web/JavaScript/Referencje/Obiekty/String/sup +tags: + - Deprecated + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sup +--- +<p>{{JSRef}}{{deprecated_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Powoduje, iż łańcuch zostanie wyświetlony jako indeks górny tak jakby był wewnątrz znacznika {{HTMLElement("sup")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.sup()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>The <code>sup()</code> method embeds a string in a <code><sup></code> tag: <code>"<sup>str</sup>"</code>.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_metody_sub_i_sup_do_zmiany_formatu_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_sub_i_sup_do_zmiany_formatu_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie metody <code>sub()</code> i <code>sup()</code></h4> + +<p>Następujący przykład stosuje metodę {{jsxref("String.prototype.sub()", "sub()")}} i <code>sup()</code> do zmiany formatu łańcucha znaków:</p> + +<pre class="brush: js">var superText="superscript"; +var subText="subscript"; + +console.log("This is what a " + superText.sup() + " looks like."); +// This is what a <sup>superscript</sup> looks like + +console.log("This is what a " + subText.sub() + " looks like."); +// This is what a <sub>subscript</sub> looks like.</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.sub()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/tolowercase/index.html b/files/pl/web/javascript/referencje/obiekty/string/tolowercase/index.html new file mode 100644 index 0000000000..0b871b9ca6 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/tolowercase/index.html @@ -0,0 +1,40 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Referencje/Obiekty/String/toLowerCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +--- +<p>{{jsref}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość wywołującego łańcucha znaków, skonwertowaną na małe litery.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.toLowerCase()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toLowerCase()</code> zwraca wartość łańcucha znaków skonwertowanego na małe litery. <code>toLowerCase()</code> nie wpływa na wartość samego łańcucha.</p> + +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3> + +<h4 id="Przyk.C5.82ad:_Zastosowanie_toLowerCase" name="Przyk.C5.82ad:_Zastosowanie_toLowerCase">Przykład: Zastosowanie <code>toLowerCase</code></h4> + +<p>Następujący przykład wyświetli łańcuch "<code>alfabet</code>" złożony z małych liter:</p> + +<pre class="brush: js">console.log('ALFABET'.toLowerCase()); // 'alfabet' +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/tosource/index.html b/files/pl/web/javascript/referencje/obiekty/string/tosource/index.html new file mode 100644 index 0000000000..cb372d673c --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/tosource/index.html @@ -0,0 +1,41 @@ +--- +title: String.prototype.toSource() +slug: Web/JavaScript/Referencje/Obiekty/String/toSource +tags: + - JavaScript + - Method + - Non-standard + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource +--- +<p>{{JSRef}}{{non-standard_header}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący kod źródłowy obiektu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>String.toSource() +<var>str</var>.toSource() +</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toSource()</code> zwraca następujące wartości:</p> + +<ul> + <li>Dla wbudowanego obiektu {{jsxref("String")}}, <code>toSource()</code> zwraca następujący łańcuch znaków wskazujący, że kod źródłowy nie jest dostępny: + + <pre class="brush: js">function String() { + [natywny kod] +} +</pre> + </li> + <li>W przypadku obiektu {{jsxref("String")}} lub łańcuchów znaków, <code>toSource()</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li> +</ul> + +<p>Ta metoda jest w JavaScript wywoływana zazwyczaj wewnętrznie, nie bezpośrednio w kodzie.</p> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/referencje/obiekty/string/tostring/index.html b/files/pl/web/javascript/referencje/obiekty/string/tostring/index.html new file mode 100644 index 0000000000..16028dff15 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/tostring/index.html @@ -0,0 +1,41 @@ +--- +title: String.protype.toString() +slug: Web/JavaScript/Referencje/Obiekty/String/toString +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toString +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca łańcuch znaków reprezentujący dany obiekt.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.toString()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Obiekt {{jsxref("String")}} przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref("String")}}, metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toString" name="Przyk.C5.82ad:_Zastosowanie_toString">Przykład: Zastosowanie <code>toString()</code></h3> + +<p>Następujący przykład wyświetli wartość łańcuch znaków obiektu {{jsxref("String")}}:</p> + +<pre class="brush: js">var x = new String("Witaj świecie"); + +console.log(x.toString()) // Wyświetla "Witaj świecie" +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("String.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/touppercase/index.html b/files/pl/web/javascript/referencje/obiekty/string/touppercase/index.html new file mode 100644 index 0000000000..4b792076fe --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/touppercase/index.html @@ -0,0 +1,38 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Referencje/Obiekty/String/toUpperCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca wartość wywołującego łańcucha znaków, skonwertowaną na duże litery.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.toUpperCase()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>toUpperCase()</code> zwraca wartość łańcucha znaków skonwertowanego na duże litery. <code>toUpperCase()</code> nie wpływa na wartość samego łańcucha.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_toUpperCase" name="Przyk.C5.82ad:_Zastosowanie_toUpperCase">Przykład: Zastosowanie <code>toUpperCase()</code></h3> + +<pre class="brush: js">console.log('alfabet'.toUpperCase()); // 'ALFABET' +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/string/valueof/index.html b/files/pl/web/javascript/referencje/obiekty/string/valueof/index.html new file mode 100644 index 0000000000..1eda0e3021 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/string/valueof/index.html @@ -0,0 +1,40 @@ +--- +title: String.prototype.valueOf() +slug: Web/JavaScript/Referencje/Obiekty/String/valueOf +tags: + - JavaScript + - Method + - Property + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf +--- +<p>{{JSRef}}</p> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Zwraca pierwotną wartość obiektu {{jsxref("String")}}.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>str</var>.valueOf()</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Metoda <code>valueOf()</code> obiektu {{jsxref("String")}} zwraca pierwotną wartość obiektu {{jsxref("String")}} jako łańcuch znaków. Ta wartość jest równoważna do {{jsxref("String.prototype.toString()")}}.</p> + +<p>Ta metoda jest w JavaScript wywoływana zazwyczaj wewnętrznie, nie bezpośrednio w kodzie.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<h3 id="Przyk.C5.82ad:_Zastosowanie_valueOf" name="Przyk.C5.82ad:_Zastosowanie_valueOf">Przykład: Zastosowanie <code>valueOf()</code></h3> + +<pre class="brush: js">var x = new String("Witaj świecie"); +console.log(x.valueOf()); // Wyświetla "Witaj świecie" +</pre> + +<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2> + +<ul> + <li>{{jsxref("String.prototype.toString()")}}</li> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/sun/index.html b/files/pl/web/javascript/referencje/obiekty/sun/index.html new file mode 100644 index 0000000000..8bf832b3e5 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/sun/index.html @@ -0,0 +1,29 @@ +--- +title: sun +slug: Web/JavaScript/Referencje/Obiekty/sun +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Archive/Web/LiveConnect_Reference/sun +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p><b>Obiekt główny</b> +</p><p>Obiekt najwyższego poziomu używany do korzystania z klas języka Java z pakietu <code>sun.*</code>. +</p> +<h3 id="Tworzony_przez" name="Tworzony_przez"> Tworzony przez </h3> +<p>Obiekt <code>sun</code> w języku JavaScript jest predefiniowanym obiektem najwyższego poziomu. Nie ma potrzeby stosowania konstruktora lub wywoływania jakiejkolwiek metody by z niego korzystać. +</p> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Obiekt <code>sun</code> jest synonimem dla własności <code>Packages.sun</code>. +</p> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages">Packages</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Packages/sun">Packages.sun</a> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/sun", "es": "es/Referencia_de_JavaScript_1.5/Objetos_globales/sun" } ) }} diff --git a/files/pl/web/javascript/referencje/obiekty/symbol/index.html b/files/pl/web/javascript/referencje/obiekty/symbol/index.html new file mode 100644 index 0000000000..4124cb2a46 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/symbol/index.html @@ -0,0 +1,227 @@ +--- +title: Symbol +slug: Web/JavaScript/Referencje/Obiekty/Symbol +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol +--- +<div>{{JSRef}}</div> + +<p>Funkcja <code>Symbol()</code> zwraca wartość typu <strong>symbol</strong>, posiada statyczne własności wystawiające kilka wartości używanych we wbudowanych obiektach, posiada statyczne metody wystawiające globalny rejestr symboli i przypomina wbudowaną klasę obiektu, jest jednak niekompletna jako konstruktor ponieważ nie wspiera składni "<code>new Symbol()</code>". </p> + +<p>Każdy symbol zwrócony przez <code>Symbol()</code> jest unikalny. Symbol powinien być użyty jako identyfikator własności obiektu, został zaprojektowany jedynie w tym celu. Pełniejsze wyjaśnienie dotyczące jego przeznaczenia i użycia można znaleźć w <a href="/en-US/docs/Glossary/Symbol">poświęconym mu wpisie w glosariuszu</a>.</p> + +<p>Typ <strong>symbol</strong> jest {{Glossary("Primitive", "typem prostym")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-constructor.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">Symbol(<em>[opis]</em>)</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>opis</code> {{optional_inline}}</dt> + <dd>Ciąg znaków, parametr opcjonalny. Opis symbolu, może być użyty do debugowania, ale nie do dostania się do samego symbolu.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Aby stworzyć nowy symbol należy użyć funkcji <code>Symbol()</code>, opcjonalnie przekazując jej opisowy ciąg znaków:</p> + +<pre class="brush: js">var sym1 = Symbol(); +var sym2 = Symbol('foo'); +var sym3 = Symbol('foo'); +</pre> + +<p>Powyższy kod tworzy trzy nowe symbole. Należy zwrócić uwagę, że <code>Symbol("foo")</code> nie konwertuje ciągu znaków "foo" na symbol, tylko tworzy za każdym razem nowy symbol:</p> + +<pre class="brush: js">Symbol('foo') === Symbol('foo'); // false</pre> + +<p>Następująca składnia z operatorem {{jsxref("Operators/new", "new")}} spowoduje wyjątek {{jsxref("TypeError")}}:</p> + +<pre class="brush: js">var sym = new Symbol(); // TypeError</pre> + +<p>Dzieje się tak dlatego żeby powstrzymać programistów przed opakowywaniem wartości symboli w obiekty i może być zaskakujące, gdyż tworzenie opakowanych wartości dla typów prostych jest zazwyczaj możliwe (na przykład <code>new Boolean</code>, <code>new String</code> i <code>new Number</code>).</p> + +<p>Jeśli stworzenie opakowanego symbolu jest dokładnie tym czego chce programista, może do tego użyć funkcji <code>Object()</code>:</p> + +<pre class="brush: js">var sym = Symbol('foo'); +typeof sym; // "symbol" +var symObj = Object(sym); +typeof symObj; // "object" +</pre> + +<h3 id="Symbole_współdzielone_w_globalnym_rejestrze_symboli">Symbole współdzielone w globalnym rejestrze symboli</h3> + +<p>Powyższa składnia używająca funkcji <code>Symbol()</code> nie stworzy globalnego symbolu, który będzie dostępny w całym kodzie. Aby stworzyć symbol dostępny między plikami, a nawet między sferami (z których każda ma swoją globalną przestrzeń) należy użyć metody {{jsxref("Symbol.for()")}}. Z kolei metody {{jsxref("Symbol.keyFor()")}} można użyć aby uzyskać nazwę globalnego klucza dla posiadanego symbolu.</p> + +<h3 id="Znajdowanie_własności_indeksowanych_symbolami_na_obiekcie">Znajdowanie własności indeksowanych symbolami na obiekcie</h3> + +<p>Metoda {{jsxref("Object.getOwnPropertySymbols()")}} zwraca tablicę symboli i pozwala znaleźć własności indeksowane symbolami na danym obiekcie. Każdy obiekt jest inicjowany bez takich własności, więc metoda ta zwróci pustą tablicę do czasu ustawienia na obiekcie własności pod kluczem typu symbol.</p> + +<h2 id="Własności">Własności</h2> + +<dl> + <dt><code>Symbol.length</code></dt> + <dd>Własność length której wartością jest 0.</dd> + <dt>{{jsxref("Symbol.prototype")}}</dt> + <dd>Reprezentuje prototyp konstruktora <code>Symbol</code>.</dd> +</dl> + +<h3 id="Znane_symbole">Znane symbole</h3> + +<p>Oprócz symboli zdefiniowanych przez programistę, JavaScript posiada wbudowane symbole reprezentujące wewnętrzne mechanizmy języka, które nie były widoczne dla programisty w wersji ECMAScript 5 i wcześniejszych. Dostęp do tych symboli jest możliwy za pomocą następujących własności statycznych:</p> + +<h4 id="Symbole_iteracji">Symbole iteracji</h4> + +<dl> + <dt>{{jsxref("Symbol.iterator")}}</dt> + <dd>Metoda zwracająca domyślny iterator dla obiektu. Używana przez <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>.</dd> + <dt>{{jsxref("Symbol.asyncIterator")}} {{experimental_inline}}</dt> + <dd>Metoda zwracająca domyślny asynchroniczny iterator dla obiektu. Używana przez <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for-await-of"><code>for await of</code></a>.</dd> +</dl> + +<h4 id="Symbole_wyrażeń_regularnych">Symbole wyrażeń regularnych</h4> + +<dl> + <dt>{{jsxref("Symbol.match")}}</dt> + <dd>Metoda dopasowująca dla ciągu znaków, używana również dla określenia czy obiekt może zostać użyty jako wyrażenie regularne. Używana przez {{jsxref("String.prototype.match()")}}.</dd> + <dt>{{jsxref("Symbol.replace")}}</dt> + <dd>Metoda zastępująca dopasowany ciąg w ciągu znaków. Używana przez {{jsxref("String.prototype.replace()")}}.</dd> + <dt>{{jsxref("Symbol.search")}}</dt> + <dd>Metoda zwracająca indeks początku ciągu znaków który został dopasowany do wyrażenia regularnego. Używana przez {{jsxref("String.prototype.search()")}}.</dd> + <dt>{{jsxref("Symbol.split")}}</dt> + <dd>Metoda dzieląca łańcuch znaków w miejscu w którym został dopasowany do wyrażenia regularnego. Używana przez {{jsxref("String.prototype.split()")}}.</dd> +</dl> + +<h4 id="Pozostałe_symbole">Pozostałe symbole</h4> + +<dl> + <dt>{{jsxref("Symbol.hasInstance")}}</dt> + <dd>Metoda określająca czy konstruktor rozpoznaje obiekt jako swoją instancję. Używana przez {{jsxref("Operators/instanceof", "instanceof")}}.</dd> + <dt>{{jsxref("Symbol.isConcatSpreadable")}}</dt> + <dd>Wartość logiczna określająca czy obiekt powinien zostać spłaszczony do jego elementów tablicy. Używana przez {{jsxref("Array.prototype.concat()")}}.</dd> + <dt>{{jsxref("Symbol.unscopables")}}</dt> + <dd>Wartość obiektu którego własne i dziediczone nazwy własności są wykluczone ze środowiska <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> powiązanego obiektu.</dd> + <dt>{{jsxref("Symbol.species")}}</dt> + <dd>Funkcja konstruktora używana do tworzenia obiektów wywodzących się z danego.</dd> + <dt>{{jsxref("Symbol.toPrimitive")}}</dt> + <dd>Metoda konwertująca obiekt na typ prosty.</dd> + <dt>{{jsxref("Symbol.toStringTag")}}</dt> + <dd>Ciąg znaków używany dla domyślnego opisu obiektu. Używany przez {{jsxref("Object.prototype.toString()")}}.</dd> +</dl> + +<h2 id="Metody">Metody</h2> + +<dl> + <dt>{{jsxref("Symbol.for()", "Symbol.for(key)")}}</dt> + <dd>Szuka istniejącego symbolu o podanym kluczu i zwraca go, jeśli został znaleziony. W przeciwnym razie w globalnym rejestrze tworzony jest nowy symbol o podanym kluczu i również zwracany.</dd> + <dt>{{jsxref("Symbol.keyFor", "Symbol.keyFor(sym)")}}</dt> + <dd>Zwraca klucz w globalnym rejestrze zapisany dla danego symbolu.</dd> +</dl> + +<h2 id="Symbol_prototype"><code>Symbol</code> prototype</h2> + +<p>Wszystkie symbole dziecidzą po {{jsxref("Symbol.prototype")}}.</p> + +<h3 id="Własności_2">Własności</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Properties')}}</p> + +<h3 id="Metody_2">Metody</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Methods')}}</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Używanie_operatora_typeof_z_symbolami">Używanie operatora <code>typeof</code> z symbolami</h3> + +<p>Operator {{jsxref("Operators/typeof", "typeof")}} może pomóc w identyfikacji symboli.</p> + +<pre class="brush: js">typeof Symbol() === 'symbol' +typeof Symbol('foo') === 'symbol' +typeof Symbol.iterator === 'symbol' +</pre> + +<h3 id="Konwersje_typu_symbol">Konwersje typu symbol</h3> + +<ul> + <li>Podczas próby konwersji symbolu na liczbę zostanie rzucony wyjątek {{jsxref("TypeError")}}.<br> + (np. <code>+sym</code> lub <code>sym | 0</code>).</li> + <li>Przy porównaniu z pominięciem typu <code>Object(sym) == sym</code> zwraca <code>true.</code></li> + <li><code>Symbol("foo") + "bar" </code>wyrzuci {{jsxref("TypeError")}} (nie można skonwertować symbolu na ciąg znaków). Służy to powstrzymaniu programisty na przykład przed stworzeniem nowej nazwy własności z użyciem symbolu.</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#String_conversion">"Bezpieczniejsza" konwersja <code>String(sym)</code></a> działa jak wywołanie {{jsxref("Symbol.prototype.toString()")}} ale należy mieć na uwadze, że <code>new String(sym)</code> rzuci wyjątkiem.</li> +</ul> + +<h3 id="Symbole_i_iteracja_for...in">Symbole i iteracja <code>for...in</code></h3> + +<p>Symbole nie są iterowalne w pętlach <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a>. Dodatkowo, {{jsxref("Object.getOwnPropertyNames()")}} nie zwróci własności obiektu zapisanych pod kluczem którym jest symbol, do tego celu można użyć {{jsxref("Object.getOwnPropertySymbols()")}}.</p> + +<pre class="brush: js">var obj = {}; + +obj[Symbol('a')] = 'a'; +obj[Symbol.for('b')] = 'b'; +obj['c'] = 'c'; +obj.d = 'd'; + +for (var i in obj) { + console.log(i); // loguje "c" i "d" +}</pre> + +<h3 id="Symbole_i_JSON.stringify()">Symbole i <code>JSON.stringify()</code></h3> + +<p>Własności obiektu znajdujące się pod kluczem w postaci symbolu są ignorowane przez <code>JSON.stringify()</code>:</p> + +<pre class="brush: js">JSON.stringify({[Symbol('foo')]: 'foo'}); +// '{}'</pre> + +<p>Żeby dowiedzieć się więcej zobacz {{jsxref("JSON.stringify()")}}.</p> + +<h3 id="Symbole_opakowane_w_obiekty_jako_klucze_własności">Symbole opakowane w obiekty jako klucze własności</h3> + +<p>Gdy symbol opakowany w obiekt jest użyty jako klucz własności, obiekt opakowujący zostanie skonwertowany do symbolu który opakowuje:</p> + +<pre class="brush: js">var sym = Symbol('foo'); +var obj = {[sym]: 1}; +obj[sym]; // 1 +obj[Object(sym)]; // nadal 1 +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-symbol-objects', 'Symbol')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Wstępna definicja</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-symbol-objects', 'Symbol')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.Symbol")}}</p> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Glossary/Symbol">Glosariusz: typ Symbol</a></li> + <li>{{jsxref("Operators/typeof", "typeof")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Data_structures">Typy i struktury danych</a></li> + <li><a href="https://hacks.mozilla.org/2015/06/es6-in-depth-symbols/">"ES6 In Depth: Symbols" na hacks.mozilla.org</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/syntaxerror/index.html b/files/pl/web/javascript/referencje/obiekty/syntaxerror/index.html new file mode 100644 index 0000000000..c8a65cd46b --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/syntaxerror/index.html @@ -0,0 +1,100 @@ +--- +title: SyntaxError +slug: Web/JavaScript/Referencje/Obiekty/SyntaxError +tags: + - Błąd składniowy + - JavaScript + - Klasa + - Obiekt + - Referencja + - SyntaxError +translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError +--- +<div>{{JSRef}}</div> + +<p>Obiekt <code><strong>SyntaxError</strong></code> reprezentuje błąd przy próbie interpretacji kodu niepoprawnego pod względem składni. Jest wyrzucany wtedy, gdy silnik JavaScript podczas interpretacji kodu napotyka znak lub ciąg znaków niezgodny ze składnią języka.</p> + +<h2 id="Konstruktor">Konstruktor</h2> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/SyntaxError"><code>SyntaxError()</code></a></dt> + <dd>Tworzy nowy obiekt <code>SyntaxError</code>.</dd> +</dl> + +<h2 id="Właściwości_instancji">Właściwości instancji</h2> + +<dl> + <dt>{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}</dt> + <dd>Wiadomość błędu. Chociaż ECMA-262 mówi, że {{jsxref("SyntaxError")}} powinien dostarczać własną właściwość <code>message</code>, w <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> jest ona dziedziczona z {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}</dt> + <dd>Nazwa błędu. Odziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}</dt> + <dd>Ścieżka do pliku zawierającego błąd. Odziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}</dt> + <dd>Numer zawierającej błąd linii w pliku. Odziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}</dt> + <dd>Numer zawierającej błąd kolumny w linii kodu. Odziedziczone z {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}}</dt> + <dd>Stos wywołań. Odziedziczone z {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Obsługa_SyntaxError">Obsługa <code>SyntaxError</code></h3> + +<pre class="brush: js">try { + eval('hoo bar'); +} catch (e) { + console.error(e instanceof SyntaxError); + console.error(e.message); + console.error(e.name); + console.error(e.fileName); + console.error(e.lineNumber); + console.error(e.columnNumber); + console.error(e.stack); +} +</pre> + +<h3 id="Tworzenie_SyntaxError">Tworzenie <code>SyntaxError</code></h3> + +<pre class="brush: js">try { + throw new SyntaxError('Hej', 'jakisPlik.js', 10); +} catch (e) { + console.error(e instanceof SyntaxError); // true + console.error(e.message); // Hej + console.error(e.name); // SyntaxError + console.error(e.fileName); // jakisPlik.js + console.error(e.lineNumber); // 10 + console.error(e.columnNumber); // 0 + console.error(e.stack); // @debugger eval code:3:9 +} +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-syntaxerror', 'SyntaxError')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.builtins.SyntaxError")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Error")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/uint16array/index.html b/files/pl/web/javascript/referencje/obiekty/uint16array/index.html new file mode 100644 index 0000000000..ef744c5848 --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/uint16array/index.html @@ -0,0 +1,224 @@ +--- +title: Uint16Array +slug: Web/JavaScript/Referencje/Obiekty/Uint16Array +translation_of: Web/JavaScript/Reference/Global_Objects/Uint16Array +--- +<div>{{JSRef("Global_Objects", "TypedArray", "Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array")}}</div> + +<h2 id="Summary">Summary</h2> + +<p>The <strong><code>Uint16Array</code></strong> typed array represents an array of 16-bit unsigned integers in the platform byte order. If control over byte order is needed, use {{jsxref("DataView")}} instead. The contents are initialized to <code>0</code>. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Uint16Array(length); +Uint16Array(typedArray); +Uint16Array(object); +Uint16Array(buffer [, byteOffset [, length]]);</pre> + +<p>For more information about the constructor syntax and the parameters, see <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Uint16Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Returns a number value of the element size. <code>2</code> in the case of an <code>Uint16Array</code>.</dd> + <dt>Uint16Array.length</dt> + <dd>Length property whose value is 3.</dd> + <dt>{{jsxref("TypedArray.name", "Uint16Array.name")}}</dt> + <dd>Returns the string value of the constructor name. In the case of the <code>Uint16Array</code> type: "Uint16Array".</dd> + <dt>{{jsxref("TypedArray.prototype", "Uint16Array.prototype")}}</dt> + <dd>Prototype for the <em>TypedArray</em> objects.</dd> +</dl> + +<h2 id="Methods">Methods</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Uint16Array.from()")}}</dt> + <dd>Creates a new <code>Uint16Array</code> from an array-like or iterable object. See also {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Uint16Array.of()")}}</dt> + <dd>Creates a new <code>Uint16Array</code> with a variable number of arguments. See also {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Boolean_instances" name="Boolean_instances"><code>Uint16Array</code> prototype</h2> + +<p>All <code>Uint16Array</code> objects inherit from {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p> + +<h3 id="Properties_2">Properties</h3> + +<dl> + <dt><code>Uint16Array.prototype.constructor</code></dt> + <dd>Returns the function that created an instance's prototype. This is the <code>Uint16Array</code> constructor by default.</dd> + <dt>{{jsxref("TypedArray.prototype.buffer", "Uint16Array.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Returns the {{jsxref("ArrayBuffer")}} referenced by the <code>Uint16Array</code> Fixed at construction time and thus <strong>read only</strong>.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Uint16Array.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Returns the length (in bytes) of the <code>Uint16Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Uint16Array.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Returns the offset (in bytes) of the <code>Uint16Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd> + <dt>{{jsxref("TypedArray.prototype.length", "Uint16Array.prototype.length")}} {{readonlyInline}}</dt> + <dd>Returns the number of elements hold in the <code>Uint16Array</code>. Fixed at construction time and thus <strong>read only.</strong></dd> +</dl> + +<h3 id="Methods_2">Methods</h3> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Uint16Array.prototype.copyWithin()")}}</dt> + <dd>Copies a sequence of array elements within the array. See also {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Uint16Array.prototype.entries()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> object that contains the key/value pairs for each index in the array. See also {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Uint16Array.prototype.every()")}}</dt> + <dd>Tests whether all elements in the array pass the test provided by a function. See also {{jsxref("Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Uint16Array.prototype.fill()")}}</dt> + <dd>Fills all the elements of an array from a start index to an end index with a static value. See also {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Uint16Array.prototype.filter()")}}</dt> + <dd>Creates a new array with all of the elements of this array for which the provided filtering function returns true. See also {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Uint16Array.prototype.find()")}}</dt> + <dd>Returns the found value in the array, if an element in the array satisfies the provided testing function or <code>undefined</code> if not found. See also {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Uint16Array.prototype.findIndex()")}}</dt> + <dd>Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found. See also {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Uint16Array.prototype.forEach()")}}</dt> + <dd>Calls a function for each element in the array. See also {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Uint16Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Determines whether a typed array includes a certain element, returning <code>true</code> or <code>false</code> as appropriate. See also {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Uint16Array.prototype.indexOf()")}}</dt> + <dd>Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Uint16Array.prototype.join()")}}</dt> + <dd>Joins all elements of an array into a string. See also {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Uint16Array.prototype.keys()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> that contains the keys for each index in the array. See also {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Uint16Array.prototype.lastIndexOf()")}}</dt> + <dd>Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Uint16Array.prototype.map()")}}</dt> + <dd>Creates a new array with the results of calling a provided function on every element in this array. See also {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.move", "Uint16Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt> + <dd>Former non-standard version of {{jsxref("TypedArray.copyWithin", "Uint16Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Uint16Array.prototype.reduce()")}}</dt> + <dd>Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Uint16Array.prototype.reduceRight()")}}</dt> + <dd>Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduceRight()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Uint16Array.prototype.reverse()")}}</dt> + <dd>Reverses the order of the elements of an array — the first becomes the last, and the last becomes the first. See also {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Uint16Array.prototype.set()")}}</dt> + <dd>Stores multiple values in the typed array, reading input values from a specified array.</dd> + <dt>{{jsxref("TypedArray.slice", "Uint16Array.prototype.slice()")}}</dt> + <dd>Extracts a section of an array and returns a new array. See also {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Uint16Array.prototype.some()")}}</dt> + <dd>Returns true if at least one element in this array satisfies the provided testing function. See also {{jsxref("Array.prototype.some()")}}.</dd> + <dt>{{jsxref("TypedArray.sort", "Uint16Array.prototype.sort()")}}</dt> + <dd>Sorts the elements of an array in place and returns the array. See also {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Uint16Array.prototype.subarray()")}}</dt> + <dd>Returns a new <code>Uint16Array</code> from the given start and end element index.</dd> + <dt>{{jsxref("TypedArray.values", "Uint16Array.prototype.values()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array. See also {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Uint16Array.prototype.toLocaleString()")}}</dt> + <dd>Returns a localized string representing the array and its elements. See also {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Uint16Array.prototype.toString()")}}</dt> + <dd>Returns a string representing the array and its elements. See also {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Uint16Array.prototype[@@iterator]()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array.</dd> +</dl> + +<h2 id="Examples">Examples</h2> + +<pre class="brush: js">// From a length +var uint16 = new Uint16Array(2); +uint16[0] = 42; +console.log(uint16[0]); // 42 +console.log(uint16.length); // 2 +console.log(uint16.BYTES_PER_ELEMENT); // 2 + +// From an array +var arr = new Uint16Array([21,31]); +console.log(arr[1]); // 31 + +// From another TypedArray +var x = new Uint16Array([21, 31]); +var y = new Uint16Array(x); +console.log(y[0]); // 21 + +// From an ArrayBuffer +var buffer = new ArrayBuffer(8); +var z = new Uint16Array(buffer, 0, 4); +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td><a href="https://www.khronos.org/registry/typedarray/specs/latest/#7">Typed Array Specification</a></td> + <td>Obsolete</td> + <td><span><span>Superseded by ECMAScript 6.</span></span></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#table-45', 'TypedArray constructors')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition in an ECMA standard.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>7.0</td> + <td>{{ CompatGeckoDesktop("2") }}</td> + <td>10</td> + <td>11.6</td> + <td>5.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>4.0</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatGeckoMobile("2") }}</td> + <td>10</td> + <td>11.6</td> + <td>4.2</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/obiekty/undefined/index.html b/files/pl/web/javascript/referencje/obiekty/undefined/index.html new file mode 100644 index 0000000000..9b9460985f --- /dev/null +++ b/files/pl/web/javascript/referencje/obiekty/undefined/index.html @@ -0,0 +1,40 @@ +--- +title: undefined +slug: Web/JavaScript/Referencje/Obiekty/undefined +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/undefined +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Wartość niezdefiniowana.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><code>undefined</code></pre> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p><code>undefined</code> jest własnością najwyższego rzędu i nie jest przypisana do żadnego obiektu.</p> + +<p>Zmienna, której nie przypisano wartości, jest typu undefined. Metoda lub wyrażenie zwraca <code>undefined</code>, jeśli wyliczana zmienna nie posiada wartości.</p> + +<p>Można wykorzystać <code>undefined</code> do zbadania, czy dana zmienna ma wartość. W poniższym kodzie zmienna <code>x</code> nie jest zdefiniowana i wyrażenie <code>if</code> ma wartość "prawda" (true).</p> + +<pre class="brush: js">var x; +if (x === undefined) { + // polecenia tu umieszczone są wykonywane +} else { + // polecenia tu umieszczone nie są wykonywane +} +</pre> + +<p><code>undefined</code> jest także wartością prostą.</p> diff --git a/files/pl/web/javascript/referencje/operatory/bitwise_operators/index.html b/files/pl/web/javascript/referencje/operatory/bitwise_operators/index.html new file mode 100644 index 0000000000..c394b726d0 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/bitwise_operators/index.html @@ -0,0 +1,558 @@ +--- +title: Operatory bitowe +slug: Web/JavaScript/Referencje/Operatory/Bitwise_Operators +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators +--- +<div>{{jsSidebar("Operators")}}</div> + +<p><strong>Operatory bitowe</strong> traktuję swoje operandy jako sekwencje 32 bitów (zer i jedynek), bardziej niż jako dziesiętne, szesnastkowe czy ósemkowe <a href="pl/docs/Web/JavaScript/Referencje/Obiekty/Number">wartości liczbowe</a>. Przykładowo, reprezentacją binarną dziesiętnej liczby 9 jest 1001. Operatory bitowe dokonują operacji na takich właśnie reprezentacjach bitowych, zwracają jednak standardowe JavaScriptowe wartości liczbowe.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}</div> + + + +<p>Poniższa tabela zawiera podsumowanie operatorów bitowych w języku JavaScript:</p> + +<table class="standard-table"> + <tbody> + <tr> + <th>Operator</th> + <th>Użycie</th> + <th>Opis</th> + </tr> + <tr> + <td><a href="#Bitowe_AND">Bitowe AND</a></td> + <td><code>a & b</code></td> + <td>Zwraca <code>1</code> na każdej pozycji bitowej, dla której odpowiadające jej bity obydwu operandów mają wartość <code>1</code>.</td> + </tr> + <tr> + <td><a href="#Bitowe_OR">Bitowe OR</a></td> + <td><code>a | b</code></td> + <td>Zwraca <code>1</code> na każdej pozycji bitowej, dla której jeden lub oba odpowiadające jej bity operandów mają wartość <code>1</code>.</td> + </tr> + <tr> + <td><a href="#Bitowe_XOR">Bitowe XOR</a></td> + <td><code>a ^ b</code></td> + <td>Zwraca <code>1</code> na każdej pozycji bitowej, dla której dokładnie jeden bit spośród odpowiadających jej bitów operandów ma wartość jeden.</td> + </tr> + <tr> + <td><a href="#Bitowe_NOT">Bitowe NOT</a></td> + <td><code>~ a</code></td> + <td>Neguje bity swojego operandu.</td> + </tr> + <tr> + <td><a href="#Przesuniecie_w_lewo">Przesunięcie w lewo</a></td> + <td><code>a << b</code></td> + <td>Przesuwa <code>a</code> w binarnej reprezentacji o <code>b</code> bitów w lewo (gdzie <code>b</code> < 32), dodając zera z prawej strony.</td> + </tr> + <tr> + <td><a href="#Przesuniecie_w_prawo_z_propagacja_znaku">Przesunięcie w prawo z propagacją znaku</a></td> + <td><code>a >> b</code></td> + <td>Przesuwa <code>a</code> w binarnej reprezentacji o <code>b</code> bitów w prawo (gdzie <code>b</code> < 32), odrzucając <code>b</code> bitów z prawej strony.</td> + </tr> + <tr> + <td><a href="#Przesuniecie_w_prawo_z_dopelnieniem_zerami">Przesunięcie w prawo z dopełnieniem zerami</a></td> + <td><code>a >>> b</code> </td> + <td>Przesuwa <code>a</code> w binarnej reprezentacji o <code>b</code> bitów w prawo (gdzie <code>b</code> < 32), odrzucając <code>b</code> bitów z prawej strony i uzupełniając sekwencję zerami z lewej strony.</td> + </tr> + </tbody> +</table> + +<h2 id="32-bitowe_wartości_całkowite_ze_znakiem">32-bitowe wartości całkowite ze znakiem</h2> + +<p>Operandy wszystkich operatorów bitowych są konwertowane do 32-bitowych wartości całkowitych w dwójkowym <a href="https://en.wikipedia.org/wiki/Method_of_complements">kodzie uzupełnieniowym</a>, z wyjątkiem przesunięcia w prawo z dopełnieniem zerami, które zwraca 32-bitową wartość całkowitą bez znaku. Dwójkowy kod uzupełnieniowy oznacza, że liczba przeciwna danej wartości (na przykład 5 i -5) ma wszystkie bity zanegowane w stosunku do tejże wartości (bitowe NOT liczby, znane również jako jedynkowe dopełnienie liczby) plus jeden. Przykładowo, dziesiętna liczba 314 ma następującą postać dwójkową:</p> + +<pre class="brush: js">00000000000000000000000100111010 +</pre> + +<p>Reprezentacja binarna <code>~314</code>, czyli jedynkowe dopełnienie <code>314</code>:</p> + +<pre class="brush: js">11111111111111111111111011000101 +</pre> + +<p><code>-314</code> ma ostatecznie następującą postać, będącą dwójkowym dopełnieniem <code>314</code>:</p> + +<pre class="brush: js">11111111111111111111111011000110 +</pre> + +<p>Dopełnienie dwójkowe gwarantuje, że skrajny lewy bit będzie zerem dla liczby dodatniej i jedynką dla liczby ujemnej – bit ten zwany jest stąd <em>bitem znaku</em>.</p> + +<p>Liczba <code>0</code> jest wartością całkowitą, złożoną w całości z bitów o wartości <code>0</code>.</p> + +<pre class="brush: js">0 (base 10) = 00000000000000000000000000000000 (base 2) +</pre> + +<p>Liczba <code>-1</code> jest wartością całkowitą, złożoną z samych bitów o wartości <code>1</code>.</p> + +<pre class="brush: js">-1 (base 10) = 11111111111111111111111111111111 (base 2) +</pre> + +<p>Liczba <code>-2147483648</code> (reprezentacja szesnastkowa: <code>-0x80000000</code>) jest wartością całkowitą, złożoną z samych bitów o wartości <code>0</code>, z wyjątkiem pierwszego (znajdującego się najbardziej z lewej strony) bitu.</p> + +<pre class="brush: js">-2147483648 (base 10) = 10000000000000000000000000000000 (base 2) +</pre> + +<p>Liczba <code>2147483647</code> (rprezentacja szesnastkowa: <code>0x7fffffff</code>) jest wartością całkowitą, złożoną jedynie z bitów o wartości 1, z wyjątkiem pierwszego (skrajnie lewego) bitu.</p> + +<pre class="brush: js">2147483647 (base 10) = 01111111111111111111111111111111 (base 2) +</pre> + +<p>Liczby <code>-2147483648</code> i <code>2147483647</code> stanowią odpowiednio minimalną i maksymalną wartość całkowitą, którą można zapisać przy użyciu 32-bitowej liczby ze znakiem.</p> + +<h2 id="Bitowe_operatory_logiczne">Bitowe operatory logiczne</h2> + +<p>Idea działania bitowych operatorów logicznych jest następująca:</p> + +<ul> + <li>Operandy są konwertowane do 32-bitowych wartości całkowitych, wyrażanych jako sekwencja bitów (zer i jedynek). Dla liczb o więcej niż 32 bitach odrzuca się najbardziej znaczące bity. Przykładowo, następująca wartość całkowita zajmująca więcej niż 32 bity będzie przekonwertowana do 32-bitowej wartości w następujący sposób: + <pre class="brush: js">Przed: 11100110111110100000000000000110000000000001 +Po: 10100000000000000110000000000001</pre> + </li> + <li>Każdy z bitów pierwszego operandu parowany jest z odpowiadającym mu bitem drugiego operandu: pierwszy z pierwszym, drugi z drugim i tak dalej (idąc od prawej strony).</li> + <li>Operator jest stosowany na każdej parze bitów, a wynik jest tworzony bitowo.</li> +</ul> + +<h3 id="Bitowe_AND_2"><a id="Bitowe_AND" name="Bitowe_AND">& (Bitowe AND)</a></h3> + +<p>Stosuje operację AND (koniunkcję) na każdej parze bitów. <code>a</code> AND <code>b</code> daje <code>1</code> wtedy i tylko wtedy, gdy zarówno <code>a</code>, jak i <code>b</code> będą miały wartość <code>1</code>. Tablica prawdy dla operacji AND przedstawiona jest poniżej:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">b</td> + <td class="header">a AND b</td> + </tr> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<pre class="brush: js">. 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10) +</pre> + +<p>Bitowa koniunkcja (AND) dowolnej wartości <code>x</code> i <code>0</code> zawsze daje <code>0</code>.</p> + +<h3 id="Bitowe_OR_2"><a id="Bitowe_OR" name="Bitowe_OR">| (Bitowe OR)</a></h3> + +<p>Stosuje operację OR (alternatywę) na każdej parze bitów. <code>a</code> OR <code>b</code> daje <code>1</code> wtedy i tylko wtedy, gdy <code>a</code> lub <code>b</code> ma wartość <code>1</code>. Tablica prawdy dla operacji OR przedstawina jest poniżej:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">b</td> + <td class="header">a OR b</td> + </tr> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<pre class="brush: js">. 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10) +</pre> + +<p>Zastosowanie alternatywy bitowej (OR) dowlonej wartości <code>x</code> i <code>0</code> zawsze daje <code>x</code>.</p> + +<h3 id="Bitowe_XOR_2"><a id="Bitowe_XOR" name="Bitowe_XOR">^ (Bitowe XOR)</a></h3> + +<p>Stosuje bitowe XOR (alternatywę wykluczającą) na każdej parze bitów. <code>a</code> XOR <code>b</code> daje <code>1</code> wtedy i tylko wtedy, gdy <code>a</code> i<strong> </strong><code>b</code> mają różne wartości. Tablica prawdy dla operacji XOR przedstawiona jest poniżej:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">b</td> + <td class="header">a XOR b</td> + </tr> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>0</td> + </tr> + </tbody> +</table> + +<pre class="brush: js">. 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10) +</pre> + +<p>Zastosowanie bitowej alternatywy wykluczającej (XOR) dowolnej wartości <code>x</code> i <code>0</code> daje <code>x</code>.</p> + +<h3 id="Bitowe_NOT_2"><a id="Bitowe_NOT" name="Bitowe_NOT">~ (Bitowe NOT)</a></h3> + +<p>Stosuje operator NOT (negację) na każdym bicie. NOT <code>a</code> zwraca odwróconą wartość (inaczej zwaną dopełnieniem jedynkowym) <code>a</code>. Tablica prawdy operacji NOT przedstawiona jest poniżej:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">NOT a</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + </tr> + </tbody> +</table> + +<pre class="brush: js"> 9 (base 10) = 00000000000000000000000000001001 (base 2) + -------------------------------- +~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10) +</pre> + +<p>Bitowa negacja (NOT) dowolnej wartości <code>x</code> daje <code>-(x + 1)</code>. Przykładowo, <code>~-5</code> daje <code>4</code>.</p> + +<p>Zauważmy, że z powodu używania 32-bitowej reprezentacji liczb, zarówno <code>~-1</code>, jak i <code>~4294967295</code> (2<sup>32</sup>-1) daje wynik <code>0</code>.</p> + +<h2 id="Bitowe_operatory_przesunięcia">Bitowe operatory przesunięcia</h2> + +<p>Bitowe operatory przesunięcia przyjmują dwa operandy: pierwszy jest wartością do przesunięcia, a drugi wskazuje liczbę pozycji bitowych, o którą pierszy operand ma być przesunięty. Kierunek operacji przesunięcia jest zdefiniowany przez użycie danego operatora.</p> + +<p>Operatory przesunięcia konwertują swoje operandy do 32-bitowych wartości całkowitych w porządku big-endian (znanym też pod nazwą <em>grubokońcowość</em>) i zwraca wynik tego samego typu, co lewy operand. Użytych będzie przy tym jedynie pięć najniższych bitów prawego operandu.</p> + +<h3 id="<<_Przesunięcie_w_lewo"><a id="Przesuniecie_w_lewo" name="Przesuniecie_w_lewo"><< (Przesunięcie w lewo)</a></h3> + +<p>Operator ten przesuwa pierwszy operand o określoną liczbę bitów w lewo. Nadmiarowe bity przesunięte poza zakres z lewej strony są odrzucane. Z prawej strony sekwencja uzupełniana jest zerami.</p> + +<p>Przykładowo, <code>9 << 2</code> daje 36:</p> + +<pre class="brush: js">. 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- +9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10) +</pre> + +<p>Bitowe przesuwanie dowolnej wartości <code>x</code> w lewo o <code>y</code> bitów daje <code>x * 2 ** y</code>.<br> + Tak więc, przykładowo: <code>9 << 3</code> można przetłumaczyć jako: <code>9 * (2 ** 3) = 9 * (8) =</code><code> 72</code>.</p> + +<h3 id=">>_Przesunięcie_w_prawo_z_propagacją_znaku"><a id="Przesuniecie_w_prawo_z_propagacja_znaku" name="Przesuniecie_w_prawo_z_propagacja_znaku">>> (Przesunięcie w prawo z propagacją znaku)</a></h3> + +<p>Operator ten przesuwa pierwszy operand o określoną liczbę bitów w prawo. Nadmiarowe bity przesunięte z prawej strony poza zakres są odrzucane. Sekwencja jest uzupełniana z lewej strony wartościami skrajnie lewego bitu. Kiedy skrajnie lewy bit ma taką samą wartość, jak poprzedni skrajnie lewy bit, znak się nie zmienia – stąd nazwa „z propagacją znaku”.</p> + +<p>Przykładowo, <code>9 >> 2</code> daje 2:</p> + +<pre class="brush: js">. 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- +9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) +</pre> + +<p>Podobnie, <code>-9 >> 2</code> daje <code>-3</code>, ponieważ zachowywany jest znak:</p> + +<pre class="brush: js">. -9 (base 10): 11111111111111111111111111110111 (base 2) + -------------------------------- +-9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10) +</pre> + +<h3 id=">>>_Przesunięcie_w_prawo_z_dopełnieniem_zerami"><a id="Przesuniecie_w_prawo_z_dopelnieniem_zerami" name="Przesuniecie_w_prawo_z_dopelnieniem_zerami">>>> (Przesunięcie w prawo z dopełnieniem zerami)</a></h3> + +<p>Operator ten przesuwa pierwszy operand o określoną liczbę bitów w prawo. Nadmiarowe bity przesunięte poza zakres z prawej strony są odrzucane. Sekwencja jest uzupełniana z lewej strony zerami. Bit znaku staje się zerem, dlatego też wynik jest zawsze nieujemny. W przeciwieństwie do pozostałych operatorów bitowych, przesunięcie w prawo z dopełnieniem zerami zwraca 32-bitową wartość całkowitą bez znaku.</p> + +<p>Dla liczb nieujemnych, przesunięcie w prawo z zerami i z zachowaniem znaku dają taki sam wynik. Przykładowo, <code>9 >>> 2</code> daje 2, tak samo jak <code>9 >> 2</code>:</p> + +<pre class="brush: js">. 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- +9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) +</pre> + +<p>Inaczej wygląda to jednak w przypadku liczb ujemnych. Przykładowo, <code>-9 >>> 2</code> daje 1073741821, co jest różne od <code>-9 >> 2</code> (które daje <code>-3</code>):</p> + +<pre class="brush: js">. -9 (base 10): 11111111111111111111111111110111 (base 2) + -------------------------------- +-9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10) +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Flagi_i_maski_bitowe">Flagi i maski bitowe</h3> + +<p>Bitowe operatory logiczne są często używane do tworzenia, manipulowania i odczytywania sekwencji <em>flag</em>, które działają jak zmienne binarne. Zmienne mogą być używane zamiast tych sekwencji, ale flagi zajmują znacznie mniej pamięci (32-krotnie).</p> + +<p>Załóżmy, że mamy następujące 4 flagi:</p> + +<ul> + <li>flaga A: mamy problem z mrówkami,</li> + <li>flaga B: mamy nietoperza,</li> + <li>flaga C: mamy kota,</li> + <li>flaga D: mamy kaczkę.</li> +</ul> + +<p>Flagi te są reprezentowane przez sekwencję bitów: DCBA. Kiedy flaga jest <em>ustawiona</em>, odpowiedni bit ma wartość 1. Kiedy flaga jest <em>wyczyszczona</em>, właściwy bit ma wartość 0. Załóżmy, że zmienna <code>flagi</code> ma binarną wartość 0101:</p> + +<pre class="brush: js">var flagi = 5; // binarnie 0101 +</pre> + +<p>Wartość ta wskazuje, że:</p> + +<ul> + <li>flaga A ma wartość „prawda” (mamy problem z mrówkami);</li> + <li>flaga B ma wartość „fałsz” (nie mamy nietoperza);</li> + <li>flaga C ma wartość „prawda” (mamy kota);</li> + <li>flaga D ma wartość „fałsz” (nie mamy kaczki);</li> +</ul> + +<p>Ponieważ operatory bitowe są 32-bitowe, 0101 to faktycznie 00000000000000000000000000000101, ale zera wiodące mogą być pominięte, gdyż nie zawierają żadnej znaczącej informacji.</p> + +<p><em>Maska bitowa</em> jest sekwencją bitów pozwalającą na manipulowanie flagami lub odczytywanie ich wartości. Zazwyczaj „podstawowe” maski bitowe dla każdej flagi będą zdefiniowane w następujący sposób:</p> + +<pre class="brush: js">var FLAGA_A = 1; // 0001 +var FLAGA_B = 2; // 0010 +var FLAGA_C = 4; // 0100 +var FLAGA_D = 8; // 1000 +</pre> + +<p>Nowe maski bitowe mogą być stworzone przy użyciu operatorów bitowych na tychże podstawowych maskach. Przykładowo, maska 1011 może być stworzona przy użyciu operatora OR na zmiennych FLAGA_A, FLAGA_B i FLAGA_D.</p> + +<pre class="brush: js">var maska = FLAGA_A | FLAGA_B | FLAGA_D; // 0001 | 0010 | 1000 => 1011 +</pre> + +<p>Pojedyncze wartości flag mogą być wyekstrahowane przez użycie operatora AND na fladze i właściwej masce – bit z wartością 1 „ekstrahuje” odpowiednią flagę. Maska bitowa <em>maskuje</em> wszystkie nieistotne flagi przez koniunkcję ich bitów z zerami maski (stąd nazwa „maska”). Przykładowo, maska 0100 może być użyta do sprawdzenia, czy flaga C jest ustawiona:</p> + +<pre class="brush: js">// czy mamy kota +if (flagi & FLAGA_C) { // 0101 & 0100 => 0100 => true + // coś zrób +} +</pre> + +<p>Maska z ustawionymi wieloma flagami działa jak alternatywa logiczna. Przykładowo, poniższe dwie wersje są równoważne:</p> + +<pre class="brush: js">// czy mamy nietoperza lub czy mamy kota +// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true +if ((flagi & FLAGA_B) || (flagi & FLAGA_C)) { + // coś zrób +} +</pre> + +<pre class="brush: js">// czy mamy nietoperza lub kota +var maska = FLAGA_B | FLAGA_C; // 0010 | 0100 => 0110 +if (flagi & maska) { // 0101 & 0110 => 0100 => true + // coś zrób +} +</pre> + +<p>Flagi mogą być ustawione przez użycie na nich i masce operacji OR, gdzie każdy z bitów z wartością 1 będzie ustawiał odpowiednią flagę, jeśli nie jest już ustawiona. Przykładowo, maska 1100 może być użyta do ustawienia flag C i D:</p> + +<pre class="brush: js">// tak, możemy mieć kota i kaczkę +var maska = FLAGA_C | FLAGA_D; // 0100 | 1000 => 1100 +flagi |= maska; // 0101 | 1100 => 1101 +</pre> + +<p>Flagi mogą być czyszczone przez użycie operatora AND z maską, gdzie każdy z bitów z wartością 0 będzie czyścił odpowiednią flagę, jeśli nie jest już wyczyszczona. Maska może być stworzona przez użycie operatora NOT na maskach podstawowych. Przykładowo, maska 1010 może być użyta do wyczyszczenia flag A i C:</p> + +<pre class="brush: js">// nieprawdą jest, że mamy problem z mrówkami lub posiadamy kota +var maska = ~(FLAG_A | FLAG_C); // ~0101 => 1010 +flagi &= maska; // 1101 & 1010 => 1000 +</pre> + +<p>Maska może być również stworzona przez wyrażenie <code>~FLAG_A & ~FLAG_C</code> (z praw De Morgana):</p> + +<pre class="brush: js">// nie, nie mamy problemu z mrówkami i nie posiadamy kota +var maska = ~FLAGA_A & ~FLAGA_C; +flagi &= maska; // 1101 & 1010 => 1000 +</pre> + +<p>Flagi mogą być przełączane przez użycie operatora XOR z maską bitową, gdzie każðy bit będzie przełączał odpowiednią flagę. Przykładowo, maska 0110 może być użyta do przełączenia flag B i C:</p> + +<pre class="brush: js">// jeśli nie mieliśmy nietoperza, teraz go mamy, +// a jeśli go mieliśmy – pa, pa, nietoperku! +// tak samo z kotami +var maska = FLAGA_B | FLAGA_C; +flagi = flagi ^ maska; // 1100 ^ 0110 => 1010 +</pre> + +<p>Flagi mogą być odwracane przez operator NOT:</p> + +<pre class="brush: js">// przechodzimy do równoległego wszechświata... +flagi = ~flagi; // ~1010 => 0101 +</pre> + +<h3 id="Conversion_snippets">Conversion snippets</h3> + +<p>Konwersja binarnej zmiennej typu <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> do liczby dziesiętnej typu <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code>:</p> + +<pre class="brush: js">var sBinString = '1011'; +var nMojaLiczba = parseInt(sBinString, 2); +alert(nMojaLiczba); // wypisuje 11, tzn. binarnie 1011 +</pre> + +<p>Konwersja dziesiętnej liczby do binarnego Stringa:</p> + +<pre class="brush: js">var nMojaLiczba = 11; +var sBinString = nMojaLiczba.toString(2); +alert(sBinString); // wypisuje 1011, tzn. dziesiętnie 11 +</pre> + +<h3 id="Automatyczne_tworzenie_masek">Automatyczne tworzenie masek</h3> + +<p>Możesz stworzyć wiele masek ze zbioru wartości typu <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code> values, na przykład:</p> + +<pre class="brush: js">function createMask() { + var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length; + for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++); + return nMask; +} +var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011 +var mask2 = createMask(false, false, true); // 4, i.e.: 0100 +var mask3 = createMask(true); // 1, i.e.: 0001 +// itd. + +alert(mask1); // wypisuje 11, czyli binarnie: 1011 +</pre> + +<h3 id="Algorytm_odwrotny_tablica_zmiennych_boolowskich_z_maski">Algorytm odwrotny: tablica zmiennych boolowskich z maski</h3> + +<p>Jeśli chcesz stworzyć tablicę złożoną ze zmiennych boolowskich, możesz użyć następującego kodu:</p> + +<pre class="brush: js">function arrayFromMask(nMask) { + // nMask musi być pomiędzy -2147483648 a 2147483647 + if (nMask > 0x7fffffff || nMask < -0x80000000) { + throw new TypeError('arrayFromMask - out of range'); + } + for (var nShifted = nMask, aFromMask = []; nShifted; + aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1); + return aFromMask; +} + +var array1 = arrayFromMask(11); +var array2 = arrayFromMask(4); +var array3 = arrayFromMask(1); + +alert('[' + array1.join(', ') + ']'); +// wypisuje "[true, true, false, true]", tzn.: 11, tzn.: 1011 +</pre> + +<p>Możesz przetestować obydwa algorytmy naraz:</p> + +<pre class="brush: js">var nTest = 19; // nasza maska +var nResult = createMask.apply(this, arrayFromMask(nTest)); + +alert(nResult); // 19 +</pre> + +<p>Jedynie dla celów dydaktycznych (jako że istnieje metoda <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number/toString">Number.toString(2)</a></code>), pokażemy jak można zmodyfikować algorytm <code>arrayFromMask</code> tak, by tworzył zmienną <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> zawierającą binarną reprezentację danej liczby, zamiast tablicy zmiennych typu <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code>:</p> + +<pre class="brush: js">function createBinaryString(nMask) { + // nMask musi być pomiędzy -2147483648 a 2147483647 + for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32; + nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1); + return sMask; +} + +var string1 = createBinaryString(11); +var string2 = createBinaryString(4); +var string3 = createBinaryString(1); + +alert(string1); +// wypisuje 00000000000000000000000000001011, i.e. 11 +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.7')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Zdefiniowane w kilku sekcjach specyfikacji: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.8">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.7">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.10">Binary bitwise operators</a></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-bitwise-shift-operators')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Zdefiniowane w kilku sekcjach specyfikacji: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-bitwise-operators">Binary bitwise operators</a></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Zdefiniowane w kilku sekcjach specyfikacji: <a href="http://tc39.github.io/ecma262/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://tc39.github.io/ecma262/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-bitwise-operators">Binary bitwise operators</a></td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div class="hidden"> +<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> +</div> + +<p>{{Compat("javascript.operators.bitwise")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Logical_Operators">Operatory logiczne</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/destructuring_assignment/index.html b/files/pl/web/javascript/referencje/operatory/destructuring_assignment/index.html new file mode 100644 index 0000000000..851acea725 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/destructuring_assignment/index.html @@ -0,0 +1,493 @@ +--- +title: Przypisanie destrukturyzujące +slug: Web/JavaScript/Referencje/Operatory/Destructuring_assignment +translation_of: Web/JavaScript/Reference/Operators/Destructuring_assignment +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Składnia <strong>przypisania destrukturyzującego</strong> jest wyrażeniem w JavaScript, które pozwala na wyciągnięcie danych z tablic bądź obiektów do odrębnych zmiennych.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js notranslate">var a, b, rest; +[a, b] = [1, 2]; +console.log(a); // 1 +console.log(b); // 2 + +[a, b, ...rest] = [1, 2, 3, 4, 5]; +console.log(a); // 1 +console.log(b); // 2 +console.log(rest); // [3, 4, 5] + +({a, b} = {a:1, b:2}); +console.log(a); // 1 +console.log(b); // 2 + +// ES2016 - nie zaimplementowane w przeglądarce Firefox 47a01 +({a, b, ...rest} = {a:1, b:2, c:3, d:4}); </pre> + +<h2 id="Opis">Opis</h2> + +<p>Wyrażenie literału obiektowego i tablicowego umożliwiają łatwe tworzenie paczek danych <em>ad-hoc</em>. </p> + +<pre class="brush: js notranslate">var x = [1, 2, 3, 4, 5];</pre> + +<p>Składnia przypisania destrukturyzacyjnego używa podobnej składni, ale z lewej strony przypisania definiujemy, które elementy wyciągnąć ze zmiennej źródłowej.</p> + +<pre class="brush: js notranslate">var x = [1, 2, 3, 4, 5]; +var [y, z] = x; +console.log(y); // 1 +console.log(z); // 2 +</pre> + +<p>Funkcjonalność ta jest podobna do tych obecnych w językach takich jak Perl i Python.</p> + +<h2 id="Destrukturyzacja_tablic">Destrukturyzacja tablic</h2> + +<h3 id="Podstawowe_przypisanie_zmiennych">Podstawowe przypisanie zmiennych</h3> + +<pre class="brush: js notranslate">var foo = ["one", "two", "three"]; + +var [one, two, three] = foo; +console.log(one); // "one" +console.log(two); // "two" +console.log(three); // "three" +</pre> + +<h3 id="Przypisanie_oddzielne_od_deklaracji">Przypisanie oddzielne od deklaracji</h3> + +<p>Zmiennej można przypisać wartość poprzez destrukturyzację oddzielnie od deklaracji tej zmiennej.</p> + +<pre class="brush:js notranslate">var a, b; + +[a, b] = [1, 2]; +console.log(a); // 1 +console.log(b); // 2 +</pre> + +<h3 id="Domyślne_wartości">Domyślne wartości</h3> + +<p>Zmiennej można przypisać wartość domyślną, w wypadku, gdy wartość wyciągnięta z tablicy jest niezdefiniowana - <code>undefined</code>.</p> + +<pre class="brush: js notranslate">var a, b; + +[a=5, b=7] = [1]; +console.log(a); // 1 +console.log(b); // 7 +</pre> + +<h3 id="Zamiana_zmiennych">Zamiana zmiennych</h3> + +<p>Dwie zmienne mogą zamienić się miejscami przy wykorzystaniu jednego wyrażenia destrukturyzującego.</p> + +<p>Bez wyrażenia destrukturyzującego, zamiana zmiennych wymaga zmiennej tymaczasowej (bądź, w niektórych językach niskiego poziomu, tricku <a class="external" href="https://en.wikipedia.org/wiki/XOR_swap_algorithm">XOR-swap</a>).</p> + +<pre class="brush:js notranslate">var a = 1; +var b = 3; + +[a, b] = [b, a]; +console.log(a); // 3 +console.log(b); // 1 +</pre> + +<h3 id="Parsowanie_tablicy_zwróconej_przez_funkcję">Parsowanie tablicy zwróconej przez funkcję</h3> + +<p>Zwrócenie tablicy poprzez funkcję zawsze było możliwe. Destrukturyzacja może sprawić, że praca ze zwróconymi wartościami typu array będzie bardziej zwięzła.</p> + +<p>W tym przykładzie, <code>f()</code> zwraca wartości <code>[1, 2]</code> jako jej wyjście, mogą one być sparsowane w jednej linijce poprzez użycie destrukturyzacji.</p> + +<pre class="brush:js notranslate">function f() { + return [1, 2]; +} + +var a, b; +[a, b] = f(); +console.log(a); // 1 +console.log(b); // 2 +</pre> + +<h3 id="Ignorowanie_niektórych_zwróconych_wartości">Ignorowanie niektórych zwróconych wartości</h3> + +<p>Możesz zignorować zwrócone wartości, którymi nie jesteś zainteresowany.</p> + +<pre class="brush:js notranslate">function f() { + return [1, 2, 3]; +} + +var [a, , b] = f(); +console.log(a); // 1 +console.log(b); // 3 +</pre> + +<p>Możesz także zignorować wszystkie zwrócone wartości:</p> + +<pre class="brush:js notranslate">[,,] = f(); +</pre> + + + +<h3 id="Przypisanie_reszty_tablicy_do_zmiennej">Przypisanie reszty tablicy do zmiennej</h3> + +<p>Podczas destrukturyzacji array'a możesz wypakować i przypisać jego pozostałą część do zmiennej używając operatora reszty:</p> + +<pre class="brush: js notranslate">var [a, ...b] = [1, 2, 3]; +console.log(a); // 1 +console.log(b); // [2, 3]</pre> + +<p>Zwróć uwagę, że zostanie wyrzucony {{jsxref("SyntaxError")}} jeśli końcowy przecinek będzie użyty z prawej strony wyrażenia z elementem reszty: </p> + +<pre class="brush: js notranslate">var [a, ...b,] = [1, 2, 3]; +// SyntaxError: rest element may not have a trailing comma</pre> + +<h3 id="Wypakowywanie_wartości_z_wyników_wyrażenia_regularnego">Wypakowywanie wartości z wyników wyrażenia regularnego</h3> + +<p>Gdy metoda wyrażenia regularnego <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec">exec()</a></code> znajdzie pasujący element, zwraca ona tablicę zawierającą kolejno cały string zawierajacy pasujące elementy, a później elementy stringa, które pasowały do każdej grupy wyrażenia regularnego znajdującej się w nawiasach. Wyrażenie destrukturyzujące pozwala na łatwe wypakowanie elementów tej tablicy ignorując pełny string, gdy nie jest on potrzebny. </p> + +<pre class="brush: js notranslate">function parseProtocol(url) { + var parsedURL = /^(\w+)\:\/\/([^\/]+)\/(.*)$/.exec(url); + if (!parsedURL) { + return false; + } + console.log(parsedURL); // ["https://developer.mozilla.org/en-US/Web/JavaScript", "https", "developer.mozilla.org", "en-US/Web/JavaScript"] + + var [, protocol, fullhost, fullpath] = parsedURL; + return protocol; +} + +console.log(parseProtocol('https://developer.mozilla.org/en-US/Web/JavaScript')); // "https"</pre> + +<h2 id="Destrukturyzacja_obiektów">Destrukturyzacja obiektów</h2> + +<h3 id="Podstawowe_przypisanie">Podstawowe przypisanie</h3> + +<pre class="brush: js notranslate">var o = {p: 42, q: true}; +var {p, q} = o; + +console.log(p); // 42 +console.log(q); // true +</pre> + +<h3 id="Przypisanie_bez_deklaracji">Przypisanie bez deklaracji</h3> + +<p>Zmiennej można przypisać wartość poprzez destrukturyazację oddzielnie od deklaracji tej zmiennej.</p> + +<pre class="brush:js notranslate">var a, b; + +({a, b} = {a:1, b:2});</pre> + +<div class="note"> +<p>Nawiasy<code>( .. )</code> na krawędziach wyrażenia przypisania są składnią wymaganą podczas używania wyrażenia destrukturyzującego literał obiektowy bez deklaracji.</p> + +<p><code>{a, b} = {a:1, b:2}</code> nie jest poprawną składnią samą w sobie, ponieważ <code>{a, b}</code> z lewej strony wyrażenia jest odbierana jako blok, a nie literał obiektowy.</p> + +<p>Ale już, <code>({a, b} = {a:1, b:2})</code> jest poprawne, tak samo jak <code>var {a, b} = {a:1, b:2}</code></p> +</div> + +<h3 id="Przypisanie_do_nowych_nazw_zmiennych">Przypisanie do nowych nazw zmiennych</h3> + +<p>Zmienna może być wyciągnięta z obiektu i przypisana do zmiennej z inną nazwą niż nazwa właściwości obiektu.</p> + +<pre class="brush: js notranslate">var o = {p: 42, q: true}; +var {p: foo, q: bar} = o; + +console.log(foo); // 42 +console.log(bar); // true </pre> + +<h3 id="Wartości_domyślne">Wartości domyślne</h3> + +<p>Zmiennej można przypisać wartość domyślną, w wypadku, gdy wartość wyciągnięta z obiektu jest <code>undefined</code>.</p> + +<pre class="brush: js notranslate">var {a=10, b=5} = {a: 3}; + +console.log(a); // 3 +console.log(b); // 5</pre> + + + +<h3 id="Przypisywanie_do_nowych_nazw_zmiennych_i_zapewnienie_wartości_domyślnych">Przypisywanie do nowych nazw zmiennych i zapewnienie wartości domyślnych</h3> + +<p>Właściwość może być zarówno 1) wypakowana z obiektu i przypisana do zmiennej z inną nazwą 2) może być jej przypisana wartość domyślna, gdy wypakowana wartość jest <code>undefined</code>.</p> + +<pre class="brush: js notranslate">var {a:aa = 10, b:bb = 5} = {a: 3}; + +console.log(aa); // 3 +console.log(bb); // 5</pre> + + + +<h3 id="Ustawianie_domyślnej_wartości_parametru_funkcji">Ustawianie domyślnej wartości parametru funkcji </h3> + +<h4 id="Wersja_ES5">Wersja ES5</h4> + +<pre class="brush: js notranslate">function drawES5Chart(options) { + options = options === undefined ? {} : options; + var size = options.size === undefined ? 'big' : options.size; + var cords = options.cords === undefined ? { x: 0, y: 0 } : options.cords; + var radius = options.radius === undefined ? 25 : options.radius; + console.log(size, cords, radius); + // now finally do some chart drawing +} + +drawES5Chart({ + cords: { x: 18, y: 30 }, + radius: 30 +});</pre> + +<h4 id="Wersja_ES2015_ES6">Wersja ES2015 (ES6)</h4> + +<pre class="brush: js notranslate">function drawES2015Chart({size = 'big', cords = { x: 0, y: 0 }, radius = 25} = {}) { + console.log(size, cords, radius); + // do some chart drawing +} + +// In Firefox, default values for destructuring assignments are not yet implemented (as described below). +// The workaround is to write the parameters in the following way: +// ({size: size = 'big', cords: cords = { x: 0, y: 0 }, radius: radius = 25} = {}) + +drawES2015Chart({ + cords: { x: 18, y: 30 }, + radius: 30 +});</pre> + +<div class="note"> +<p>W definicji funkcji <strong><code>drawES2015Chart()</code></strong> powyżej, destrukturyzowana lewa strona wyrażenia jest przypisana do pustego literału obiektowego z prawej strony: <code>{size = 'big', cords = {x: 0, y: 0}, radius = 25} = {}</code>. Można by było również napisać funkcję bez prawostronnego przypisania. Jednakże jeśli zostawisz prawą stroę przypisania, funkcja będzie szukać przynajmniej jednego argumentu podczas wywołania, natomiast w jej obecnej formie możesz po prostu wywołać <code><strong>drawES2015Chart()</strong></code> bez podawania parametrów. Ten sposób jest użyteczny gdy chcesz mieć możliwość wywołania funkcji bez podawania parametrów, ten drugi może być użyteczny, gdy chcesz być pewny, że obiekt został wprowadzony do funkcji.</p> +</div> + +<h3 id="Obiekt_zagnieżdżony_i_destrukturyzacja_tablic">Obiekt zagnieżdżony i destrukturyzacja tablic</h3> + +<pre class="brush:js notranslate">var metadata = { + title: "Scratchpad", + translations: [ + { + locale: "de", + localization_tags: [ ], + last_edit: "2014-04-14T08:43:37", + url: "/de/docs/Tools/Scratchpad", + title: "JavaScript-Umgebung" + } + ], + url: "/en-US/docs/Tools/Scratchpad" +}; + +var { title: englishTitle, translations: [{ title: localeTitle }] } = metadata; + +console.log(englishTitle); // "Scratchpad" +console.log(localeTitle); // "JavaScript-Umgebung"</pre> + +<h3 id="Iteracja_for..of_i_destrukturyzacja">Iteracja for..of i destrukturyzacja</h3> + +<pre class="brush: js notranslate">var people = [ + { + name: "Mike Smith", + family: { + mother: "Jane Smith", + father: "Harry Smith", + sister: "Samantha Smith" + }, + age: 35 + }, + { + name: "Tom Jones", + family: { + mother: "Norah Jones", + father: "Richard Jones", + brother: "Howard Jones" + }, + age: 25 + } +]; + +for (var {name: n, family: { father: f } } of people) { + console.log("Name: " + n + ", Father: " + f); +} + +// "Name: Mike Smith, Father: Harry Smith" +// "Name: Tom Jones, Father: Richard Jones"</pre> + +<h3 id="Wyciąganie_pól_z_obiektów_przekazanych_jako_parametr_funkcji">Wyciąganie pól z obiektów przekazanych jako parametr funkcji</h3> + +<pre class="brush:js notranslate">function userId({id}) { + return id; +} + +function whois({displayName, fullName: {firstName: name}}){ + console.log(displayName + " is " + name); +} + +var user = { + id: 42, + displayName: "jdoe", + fullName: { + firstName: "John", + lastName: "Doe" + } +}; + +console.log("userId: " + userId(user)); // "userId: 42" +whois(user); // "jdoe is John"</pre> + +<p>To wyciąga <code>id</code>, <code>displayName</code> i <code>firstName</code> z obiektu <em>user </em>i wypisuje je.</p> + +<h3 id="Wyznaczane_nazwy_właściwości_obiektów_i_destrukturyzacja">Wyznaczane nazwy właściwości obiektów i destrukturyzacja</h3> + +<p>Wyznaczane nazwy waściwości, tak samo jak wh <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names">literałach obiektowych</a>, mogą być używane z destrukturyzacją.</p> + +<pre class="brush: js notranslate">let key = "z"; +let { [key]: foo } = { z: "bar" }; + +console.log(foo); // "bar" +</pre> + + + +<h3 id="Reszta_w_destrukturyzacji_obiektów">Reszta w destrukturyzacji obiektów</h3> + +<p><a href="https://github.com/tc39/proposal-object-rest-spread">Własciwości reszty/rozproszenia dla ECMAScript</a> (proponowane, etap 3) dodają składnię <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">reszty</a> do destrukturyzacji. Właściwości reszty zbierają pozostałe klucze, które nie zostały pobrane poprzez wzorzec destrukturyzacji.</p> + +<pre class="brush: js notranslate">let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40} +a; // 10 +b; // 20 +rest; // { c: 30, d: 40 }</pre> + +<h3 id="Nipoprawny_identyfikator_JavaScript_jako_nazwa_własności">Nipoprawny identyfikator JavaScript jako nazwa własności</h3> + +<p>Destrukturyzacja może zostać użyta z nazwami własności, które nie są poprawnymi <a href="https://developer.mozilla.org/en-US/docs/Glossary/Identifier">identyfikatorami</a> JavaScript poprzez zapewnienie alternatywnego, poprawnego identyfikatora.</p> + +<pre class="brush: js notranslate">const foo = { 'fizz-buzz': true }; +const { 'fizz-buzz': fizzBuzz } = foo; + +console.log(fizzBuzz); // "true"</pre> + + + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-destructuring-assignment', 'Destructuring assignment')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja wstępna.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-destructuring-assignment', 'Destructuring assignment')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Edge</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(49.0)}}</td> + <td>{{ CompatGeckoDesktop("1.8.1") }}</td> + <td>14</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>7.1</td> + </tr> + <tr> + <td>Computed property names</td> + <td>{{CompatChrome(49.0)}}</td> + <td>{{ CompatGeckoDesktop("34") }}</td> + <td>14</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Spread operator</td> + <td>{{CompatChrome(49.0)}}</td> + <td>{{ CompatGeckoDesktop("34") }}</td> + <td>12<sup>[1]</sup></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(49.0)}}</td> + <td>{{ CompatGeckoMobile("1.0") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + <td>{{CompatChrome(49.0)}}</td> + </tr> + <tr> + <td>Computed property names</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(49.0)}}</td> + <td>{{ CompatGeckoMobile("34") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(49.0)}}</td> + </tr> + <tr> + <td>Spread operator</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(49.0)}}</td> + <td>{{ CompatGeckoMobile("34") }}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatChrome(49.0)}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Wymaga odblokowanej flagi "Enable experimental Javascript features" w `about:flags`</p> + +<h2 id="Notatki_specyficzne_dla_Firefoxa">Notatki specyficzne dla Firefox'a</h2> + +<ul> + <li>Firefox zapewnił niestandardowe rozszerzenie języka w <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.7">JS1.7</a> dla destrukturyzacji. To rozszerzenie zostało usunięte w Gecko 40 {{geckoRelease(40)}}. Zobacz {{bug(1083498)}}.</li> + <li>Poczynając od Gecko 41 {{geckoRelease(41)}} żeby dostosować się do specyfikacji ES2015, składnia destrukturyzacji używająca nawiasów, takia jak<code>([a, b]) = [1, 2])</code> lub <code>({a, b}) = { a: 1, b: 2 }</code>, jest teraz uważana za niepoprawną i spowoduje {{jsxref("SyntaxError")}}. Zobacz<a class="external external-icon" href="http://whereswalden.com/2015/06/20/new-changes-to-make-spidermonkeys-and-firefoxs-parsing-of-destructuring-patterns-more-spec-compliant/">post Jeffa Waldena </a>oraz {{bug(1146136)}} aby uzyskać więcej informacji.</li> +</ul> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Assignment operators</a></li> + <li><a href="https://hacks.mozilla.org/2015/05/es6-in-depth-destructuring/">"ES6 in Depth: Destructuring" on hacks.mozilla.org</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/domknięcia_wyrażeń/index.html b/files/pl/web/javascript/referencje/operatory/domknięcia_wyrażeń/index.html new file mode 100644 index 0000000000..66cf07b36c --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/domknięcia_wyrażeń/index.html @@ -0,0 +1,78 @@ +--- +title: Domknięcia wyrażeń +slug: Web/JavaScript/Referencje/Operatory/Domknięcia_wyrażeń +tags: + - JavaScript + - Operator + - funkcja + - niestandardowe + - przestarzały +translation_of: Archive/Web/JavaScript/Expression_closures +--- +<div>{{JSSidebar("Operators")}}{{Non-standard_Header}}{{Obsolete_Header("gecko60")}} +<div class="warning"><strong>Niestandardowe. Nie używać!</strong><br> +Składnia domknięcia wyrażeń jest przestarzałą funkcją specyficzną dla Firefoxa i została usunięta od Firefoxa 60. Dla obecnie tworzonych rozwiązań rozważ użycie <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">funkcji strzałkowych</a>.</div> +</div> + +<p>Domknięcia wyrażeń są skróconą składnią dla zapisu prostych funkcji.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">function [nazwa]([<em>param1</em>[, <em>param2[</em>, ..., <em>paramN</em>]]]) + <em>wyrażenie</em> +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>nazwa</code></dt> + <dd>Nazwa funkcji. Może być pominięta w przypadku, gdy funkcja jest <em>anonimowa</em>. Nazwa jest lokalna i ograniczona jedynie do ciała funkcji.</dd> + <dt><code>paramN</code></dt> + <dd>Nazwa argumentu, który ma być przekazany do funkcji. Funkcja może mieć do 255 argumentów.</dd> + <dt><code>wyrażenie</code></dt> + <dd>Wyrażenie, które zawiera ciało funkcji.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Ten dodatek nie jest niczym więcej niż skróconą notacją dla prostych funkcji, która daje językowi coś podobnego do typowej <a class="external" href="http://en.wikipedia.org/wiki/Lambda_calculus#Lambda_calculus_and_programming_languages">notacji lambda</a>.</p> + +<p>JavaScript 1.7 i starsze:</p> + +<pre class="brush: js">function(x) { return x * x; }</pre> + +<p>JavaScript 1.8:</p> + +<pre class="brush: js">function(x) x * x</pre> + +<p>Taka składnia pozwala na pominięcie nawiasów klamrowych i wyrażenia <code>return</code>, czyniąc je niejawnymi. Poza skróceniem zapisu, nie ma innych korzyści z pisania kodu w ten sposób.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Skrócony zapis dla dowiązywania obserwatorów zdarzeń (ang. <em>event listeners</em>):</p> + +<pre class="brush: js"> document.addEventListener('click', function() false, true); +</pre> + +<p>Użycie tej notacji z niektórymi z funkcji strzałkowych z JavaScript 1.6:</p> + +<pre class="brush: js">elems.some(function(elem) elem.type == 'text'); +</pre> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.operators.expression_closures")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("Functions_and_function_scope", "Functions and function scope")}}</li> + <li>{{JSxRef("Function")}}</li> + <li>{{JSxRef("Statements/function", "function statement")}}</li> + <li>{{JSxRef("Operators/function", "function expression")}}</li> + <li>{{JSxRef("Statements/function*", "function* statement")}}</li> + <li>{{JSxRef("Operators/function*", "function* expression")}}</li> + <li>{{JSxRef("GeneratorFunction")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/function_star_/index.html b/files/pl/web/javascript/referencje/operatory/function_star_/index.html new file mode 100644 index 0000000000..52d7a67c98 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/function_star_/index.html @@ -0,0 +1,90 @@ +--- +title: wyrażenie function* +slug: Web/JavaScript/Referencje/Operatory/function* +tags: + - ECMAScript2015 + - Iterator + - JavaScript + - Operator + - funkcja +translation_of: Web/JavaScript/Reference/Operators/function* +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Słowo kluczowe <strong><code>function*</code></strong> może być użyte do zdefiniowania funkcji generatora wewnątrz wyrażenia.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-functionasteriskexpression.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">function* [nazwa]([<em>param1</em>[, <em>param2[</em>, ..., <em>paramN</em>]]]) { + wyrażenia +}</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>nazwa</code></dt> + <dd>Nazw funkcji. Może być pominięta w przyadku funkcji <em>anonimowych</em>. Nazwa jest lokalna i ograniczona do ciała funkcji.</dd> + <dt><code>paramN</code></dt> + <dd>Nazwa argumentu przekazywanego do funkcji. Funkcja może mieć do 255 argumentów.</dd> + <dt><code>wyrażenia</code></dt> + <dd>Wyrażenia, które zawiera ciało funkcji.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Wyrażenie <code>function*</code> jest bardzo podobne i ma niemal taką samą składnię jak {{jsxref('Statements/function*', 'polecenie function*')}}. Zasadnicza różnica między wyrażenem <code>function*</code> a poleceniem <code>function*</code> to <em>nazwa funkcji</em>, która może być pominięta w wyrażeniach <code>function*</code>, co pozwala na tworzenie anonimowych funkcji generatorów. Zobacz również rozdział o <a href="/en-US/docs/Web/JavaScript/Reference/Functions">funkcjach</a>, aby dowiedzieć się więcej.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Następujący przykład definiuje nienazwaną funkcję generatora i przypisuje ją do <code>x</code>. Funkcja zwraca przekazany argument podniesiony do kwadratu.</p> + +<pre class="brush: js">var x = function*(y) { + yield y * y; +}; +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-generator-function-definitions', 'function*')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator-function-definitions', 'function*')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.operators.function_star")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Statements/function*", "function* statement")}}</li> + <li>{{jsxref("GeneratorFunction")}} object</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li> + <li>{{jsxref("Operators/yield", "yield")}}</li> + <li>{{jsxref("Operators/yield*", "yield*")}}</li> + <li>{{jsxref("Function")}} object</li> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/grouping/index.html b/files/pl/web/javascript/referencje/operatory/grouping/index.html new file mode 100644 index 0000000000..5a076c3fb0 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/grouping/index.html @@ -0,0 +1,90 @@ +--- +title: Operator grupowania +slug: Web/JavaScript/Referencje/Operatory/Grouping +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators/Grouping +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Operator grupowania <code>( )</code> pozwala na określenie kolejności wykonywania działań w wyrażeniach.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-groupingoperator.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"> ( )</pre> + +<h2 id="Opis">Opis</h2> + +<p>Operator grupowania składa się z pary nawiasów otaczających wyrażenie lub podwyrażenie. Pozwala na nadpisanie standardowego <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Operatory/Pierwsze%C5%84stwo_operator%C3%B3w">pierwszeństwa operatorów</a>, tak że wyrażenia z niższym piorytetem mogą być wykonane przed wyrażeniami z wyższym priorytetem. Zgodnie z nazwą, operator ten grupuje wyrażenia znajdujące się w nawiasach.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Nadpisanie zasady wykonywania mnożenia i dzielenia przed dodawaniem i odejmowaniem w taki sposób, by dodawanie wykonane było jako pierwsze.</p> + +<pre class="brush:js">var a = 1; +var b = 2; +var c = 3; + +// domyślna kolejność +a + b * c // 7 +// wykonywana domyślnie w taki sposób +a + (b * c) // 7 + +// zmiana kolejności wykonywania działań +// dodawanie przed mnożeniem +(a + b) * c // 9 + +// co odpowiada wyrażeniu +a * c + b * c // 9 +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-grouping-operator', 'The Grouping Operator')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-grouping-operator', 'The Grouping Operator')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.1.6', 'The Grouping Operator')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-11.1.4', 'The Grouping Operator')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.operators.grouping")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Operatory/Pierwsze%C5%84stwo_operator%C3%B3w">Pierwszeństwo operatorów</a></li> + <li>{{jsxref("Operators/delete", "delete")}}</li> + <li>{{jsxref("Operators/typeof", "typeof")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/index.html b/files/pl/web/javascript/referencje/operatory/index.html new file mode 100644 index 0000000000..016c55af35 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/index.html @@ -0,0 +1,282 @@ +--- +title: Operatory +slug: Web/JavaScript/Referencje/Operatory +tags: + - JavaScript + - Operators +translation_of: Web/JavaScript/Reference/Operators +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>This chapter documents all the JavaScript language operators, expressions and keywords.</p> + +<h2 id="Wyrażenia_i_operatory_w_podziale_na_kategorie">Wyrażenia i operatory w podziale na kategorie</h2> + +<h2 id="sect1"> </h2> + +<h2 id="Lista_operatorów_w_kolejności_alfabetycznej_znajduje_sie_w_pasku_bocznym_po_lewej_stronie."><span style="font-size: 14px; font-weight: normal;">Lista operatorów w kolejności alfabetycznej znajduje sie w pasku bocznym po lewej stronie.</span></h2> + +<h3 id="Wyrażenia_podstawowe">Wyrażenia podstawowe</h3> + +<p>Podstawowe słowa kluczowe i wyrażenia w JavaScript.</p> + +<dl> + <dt>{{jsxref("Operator/this", "this")}}</dt> + <dd>Słowo <code>this</code> odnosi się do kontekstu wywołania.</dd> + <dt>{{jsxref("Operator/function", "function")}}</dt> + <dd>Słowo <code>function</code> umożliwia zdefniowanie wyrażenia funkcji .</dd> + <dt>{{experimental_inline}} {{jsxref("Operatory/class", "class")}}</dt> + <dd>Słowo <code>class</code> definiuje wyrażenie klasy.</dd> + <dt>{{experimental_inline}} {{jsxref("Operatory/function*", "function*")}}</dt> + <dd>The <code>function*</code> keyword defines a generator function expression.</dd> + <dt>{{experimental_inline}} {{jsxref("Operatory/yield", "yield")}}</dt> + <dd>Pause and resume a generator function</dd> + <dt>{{experimental_inline}} {{jsxref("Operatory/yield*", "yield*")}}</dt> + <dd>Delegate to another generator function or iterable object.</dd> + <dt>{{jsxref("Global_Objecty/Array", "[]")}}</dt> + <dd>Array initializer/literal syntax.</dd> + <dt>{{jsxref("Operatory/Object_initializer", "{}")}}</dt> + <dd>Object initializer/literal syntax.</dd> + <dt>{{jsxref("RegExp", "/ab+c/i")}}</dt> + <dd>Regular expression literal syntax.</dd> + <dt>{{experimental_inline}} {{jsxref("Operatory/Array_comprehensions", "[for (x of y) x]")}}</dt> + <dd>Array comprehensions.</dd> + <dt>{{experimental_inline}} {{jsxref("Operatory/Generator_comprehensions", "(for (x of y) y)")}}</dt> + <dd>Generator comprehensions.</dd> + <dt>{{jsxref("Operatory/Grouping", "( )")}}</dt> + <dd>Grouping operator.</dd> +</dl> + +<h3 id="Left-hand-side_expressions">Left-hand-side expressions</h3> + +<p>Left values are the destination of an assignment.</p> + +<dl> + <dt>{{jsxref("Operatory/Property_accessors", "Property accessors", "", 1)}}</dt> + <dd>Member operators provide access to a property or method of an object<br> + (<code>object.property</code> and <code>object["property"]</code>).</dd> + <dt>{{jsxref("Operatory/new", "new")}}</dt> + <dd>The <code>new</code> operator creates an instance of a constructor.</dd> + <dt>{{experimental_inline}} {{jsxref("Operatory/super", "super")}}</dt> + <dd>The <code>super</code> keyword calls the parent constructor.</dd> + <dt>{{experimental_inline}} {{jsxref("Operatory/Spread_operator", "...obj")}}</dt> + <dd>The spread operator allows an expression to be expanded in places where multiple arguments (for function calls) or multiple elements (for array literals) are expected.</dd> +</dl> + +<h3 id="Increment_and_decrement">Increment and decrement</h3> + +<p>Postfix/prefix increment and postfix/prefix decrement operators.</p> + +<dl> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "A++", "#Inkrementacja")}}</dt> + <dd>Postfix increment operator.</dd> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "A--", "#Dekrementacja")}}</dt> + <dd>Postfix decrement operator.</dd> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "++A", "#Inkrementacja")}}</dt> + <dd>Prefix increment operator.</dd> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "--A", "#Dekrementacja")}}</dt> + <dd>Prefix decrement operator.</dd> +</dl> + +<h3 id="Unary_operators">Unary operators</h3> + +<p>A unary operation is operation with only one operand.</p> + +<dl> + <dt>{{jsxref("Operatoryy/delete", "delete")}}</dt> + <dd>The <code>delete</code> operator deletes a property from an object.</dd> + <dt>{{jsxref("Operatory/void", "void")}}</dt> + <dd>The <code>void</code> operator discards an expression's return value.</dd> + <dt>{{jsxref("Operatory/typeof", "typeof")}}</dt> + <dd>The <code>typeof</code> operator determines the type of a given object.</dd> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "+", "#Unary_plus")}}</dt> + <dd>The unary plus operator converts its operand to Number type.</dd> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "-", "#Unary_negation")}}</dt> + <dd>The unary negation operator converts its operand to Number type and then negates it.</dd> + <dt>{{jsxref("Operatory/Bitwise_Operators", "~", "#Bitwise_NOT")}}</dt> + <dd>Bitwise NOT operator.</dd> + <dt>{{jsxref("Operatory/Logical_Operators", "!", "#Logical_NOT")}}</dt> + <dd>Logical NOT operator.</dd> +</dl> + +<h3 id="Operatory_arytmetyczne">Operatory arytmetyczne</h3> + +<h3 id="Arithmetic_operators_take_numerical_values_(either_literals_or_variables)_as_their_operands_and_return_a_single_numerical_value."><span style="font-size: 14px;">Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value.</span></h3> + +<dl> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "+", "#Addition")}}</dt> + <dd>Addition operator.</dd> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "-", "#Subtraction")}}</dt> + <dd>Subtraction operator.</dd> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "/", "#Division")}}</dt> + <dd>Division operator.</dd> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "*", "#Multiplication")}}</dt> + <dd>Multiplication operator.</dd> + <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "%", "#Remainder")}}</dt> + <dd>Remainder operator.</dd> +</dl> + +<h3 id="Operatory_porównania">Operatory porównania</h3> + +<p>Operator porównania, jak nazwa wskazuje, porównuje operandy i zwraca wartość logiczną zależną od tego, czy wartość porównania jest prawdziwa. </p> + +<dl> + <dt>{{jsxref("Operatory/in", "in")}}</dt> + <dd>Operator <code>in</code> ustala, czy obiekt posiada daną właściwość.</dd> + <dt>{{jsxref("Operatory/instanceof", "instanceof")}}</dt> + <dd>Operator <code>instanceof</code> ustala czy obiekt jest instancją innego obiektu.</dd> + <dt>{{jsxref("Operatory/Comparison_Operators", "<", "#Less_than_operator")}}</dt> + <dd>Less than operator.</dd> + <dt>{{jsxref("Operatory/Comparison_Operators", ">", "#Greater_than_operator")}}</dt> + <dd>Greater than operator.</dd> + <dt>{{jsxref("Operatory/Comparison_Operators", "<=", "#Less_than_or_equal_operator")}}</dt> + <dd>Less than or equal operator.</dd> + <dt>{{jsxref("Operatory/Comparison_Operators", ">=", "#Greater_than_or_equal_operator")}}</dt> + <dd>Greater than or equal operator.</dd> +</dl> + +<h3 id="Equality_operators">Equality operators</h3> + +<p>The result of evaluating an equality operator is always of type <code>Boolean</code> based on whether the comparison is true.</p> + +<dl> + <dt>{{jsxref("Operatory/Comparison_Operators", "==", "#Equality")}}</dt> + <dd>Equality operator.</dd> + <dt>{{jsxref("Operatory/Comparison_Operators", "!=", "#Inequality")}}</dt> + <dd>Inequality operator.</dd> + <dt>{{jsxref("Operatory/Comparison_Operators", "===", "#Identity")}}</dt> + <dd>Identity operator.</dd> + <dt>{{jsxref("Operatory/Comparison_Operators", "!==", "#Nonidentity")}}</dt> + <dd>Nonidentity operator.</dd> +</dl> + +<h3 id="Bitwise_shift_operators">Bitwise shift operators</h3> + +<p>Operations to shift all bits of the operand.</p> + +<dl> + <dt>{{jsxref("Operatory/Bitwise_Operators", "<<", "#Left_shift")}}</dt> + <dd>Bitwise left shift operator.</dd> + <dt>{{jsxref("Operatory/Bitwise_Operators", ">>", "#Right_shift")}}</dt> + <dd>Bitwise right shift operator.</dd> + <dt>{{jsxref("Operatory/Bitwise_Operators", ">>>", "#Unsigned_right_shift")}}</dt> + <dd>Bitwise unsigned right shift operator.</dd> +</dl> + +<h3 id="Binary_bitwise_operators">Binary bitwise operators</h3> + +<p>Bitwise operators treat their operands as a set of 32 bits (zeros and ones) and return standard JavaScript numerical values.</p> + +<dl> + <dt>{{jsxref("Operatory/Bitwise_Operators", "&", "#Bitwise_AND")}}</dt> + <dd>Bitwise AND.</dd> + <dt>{{jsxref("Operatory/Bitwise_Operators", "|", "#Bitwise_OR")}}</dt> + <dd>Bitwise OR.</dd> + <dt>{{jsxref("Operatory/Bitwise_Operators", "^", "#Bitwise_XOR")}}</dt> + <dd>Bitwise XOR.</dd> +</dl> + +<h3 id="Binary_logical_operators">Binary logical operators</h3> + +<p>Logical operators are typically used with boolean (logical) values, and when they are, they return a boolean value.</p> + +<dl> + <dt>{{jsxref("Operatory/Logical_Operators", "&&", "#Logical_AND")}}</dt> + <dd>Logical AND.</dd> + <dt>{{jsxref("Operatory/Logical_Operators", "||", "#Logical_OR")}}</dt> + <dd>Logical OR.</dd> +</dl> + +<h3 id="Conditional_(ternary)_operator">Conditional (ternary) operator</h3> + +<dl> + <dt>{{jsxref("Operatory/Conditional_Operator", "(condition ? ifTrue : ifFalse)")}}</dt> + <dd> + <p>The conditional operator returns one of two values based on the logical value of the condition.</p> + </dd> +</dl> + +<h3 id="Assignment_operators">Assignment operators</h3> + +<p>An assignment operator assigns a value to its left operand based on the value of its right operand.</p> + +<dl> + <dt>{{jsxref("Operatory/Assignment_Operators", "=", "#Assignment")}}</dt> + <dd>Assignment operator.</dd> + <dt>{{jsxref("Operatory/Assignment_Operators", "*=", "#Multiplication_assignment")}}</dt> + <dd>Multiplication assignment.</dd> + <dt>{{jsxref("Operatory/Assignment_Operators", "/=", "#Division_assignment")}}</dt> + <dd>Division assignment.</dd> + <dt>{{jsxref("Operatory/Assignment_Operators", "%=", "#Remainder_assignment")}}</dt> + <dd>Remainder assignment.</dd> + <dt>{{jsxref("Operatory/Assignment_Operators", "+=", "#Addition_assignment")}}</dt> + <dd>Addition assignment.</dd> + <dt>{{jsxref("Operatory/Assignment_Operators", "-=", "#Subtraction_assignment")}}</dt> + <dd>Subtraction assignment</dd> + <dt>{{jsxref("Operatory/Assignment_Operators", "<<=", "#Left_shift_assignment")}}</dt> + <dd>Left shift assignment.</dd> + <dt>{{jsxref("Operatory/Assignment_Operators", ">>=", "#Right_shift_assignment")}}</dt> + <dd>Right shift assignment.</dd> + <dt>{{jsxref("Operators/Assignment_Operators", ">>>=", "#Unsigned_right_shift_assignment")}}</dt> + <dd>Unsigned right shift assignment.</dd> + <dt>{{jsxref("Operatory/Assignment_Operators", "&=", "#Bitwise_AND_assignment")}}</dt> + <dd>Bitwise AND assignment.</dd> + <dt>{{jsxref("OperatorsyAssignment_Operators", "^=", "#Bitwise_XOR_assignment")}}</dt> + <dd>Bitwise XOR assignment.</dd> + <dt>{{jsxref("Operatory/Assignment_Operators", "|=", "#Bitwise_OR_assignment")}}</dt> + <dd>Bitwise OR assignment.</dd> + <dt>{{experimental_inline}} {{jsxref("Operatory/Destructuring_assignment", "[a, b] = [1, 2]")}}<br> + {{experimental_inline}} {{jsxref("Operatory/Destructuring_assignment", "{a, b} = {a:1, b:2}")}}</dt> + <dd> + <p>Destructuring assignment allows you to assign the properties of an array or object to variables using syntax that looks similar to array or object literals.</p> + </dd> +</dl> + +<h3 id="Comma_operator">Comma operator</h3> + +<dl> + <dt>{{jsxref("Operatory/Comma_Operator", ",")}}</dt> + <dd>The comma operator allows multiple expressions to be evaluated in a single statement and returns the result of the last expression.</dd> +</dl> + +<h3 id="Non-standard_features">Non-standard features</h3> + +<dl> + <dt>{{non-standard_inline}} {{jsxref("Operatory/Legacy_generator_function", "Legacy generator function", "", 1)}}</dt> + <dd>The <code>function</code> keyword can be used to define a legacy generator function inside an expression. To make the function a legacy generator, the function body should contains at least one {{jsxref("Operators/yield", "yield")}} expression.</dd> + <dt>{{non-standard_inline}} {{jsxref("Operatory/Expression_closures", "Expression closures", "", 1)}}</dt> + <dd>The expression closure syntax is a shorthand for writing simple function.</dd> +</dl> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11', 'Expressions')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>New: Spread operator, destructuring assignment, <code>super</code> keyword, Array comprehensions, Generator comprehensions</td> + </tr> + </tbody> +</table> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Operator precedence</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/logical_operators/index.html b/files/pl/web/javascript/referencje/operatory/logical_operators/index.html new file mode 100644 index 0000000000..ce5c7bc211 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/logical_operators/index.html @@ -0,0 +1,253 @@ +--- +title: Operatory logiczne +slug: Web/JavaScript/Referencje/Operatory/Logical_Operators +translation_of: Web/JavaScript/Reference/Operators +--- +<div>{{jsSidebar("Operators")}}</div> + +<div>Operatory logiczne są zazwyczaj używane z wartościami typu {{jsxref("Boolean")}} (logicznymi) – wówczas zwracają również wartość typu logicznego. Jednakże operatory <code>&&</code> i <code>||</code> w istocie zwracają wartość jednego z podanych operandów, więc jeśli operatory te są używane z wartościami nie-boolowskimi, wtedy mogą również zwracać nie-boolowskie wartości.</div> + +<div></div> + +<div>{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}</div> + + + +<h2 id="Opis">Opis</h2> + +<p>Operatory logiczne są opisane w poniższej tabeli:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Operator</th> + <th>Użycie</th> + <th>Opis</th> + </tr> + <tr> + <td>Logiczne AND (<code>&&</code>)</td> + <td><code><em>expr1</em> && <em>expr2</em></code></td> + <td>Zwraca <code>expr1</code> jeśli wartość ta może być przekonwertowana na <code>false</code>, w przeciwnym razie zwraca <code>expr2</code>. Zatem, używany z wartościami typu logicznego, operator <code>&&</code> zwraca <code>true</code> jeśli obydwa operandy mają wartość <code>true</code>, w przeciwnym razie zwraca <code>false</code>.</td> + </tr> + <tr> + <td>Logiczne OR (<code>||</code>)</td> + <td><code><em>expr1</em> || <em>expr2</em></code></td> + <td>Zwraca <code>expr1</code>, jeśli wartość ta może być przekonwertowana na <code>true</code>; w przeciwnym razie zwraca <code>expr2</code>. Tak więc, używany z wartościami typu logicznego, operator <code>||</code> zwraca <code>true</code> którykolwiek z operandów równy jest <code>true</code>.</td> + </tr> + <tr> + <td>Logiczne NOT (<code>!</code>)</td> + <td><code>!<em>expr</em></code></td> + <td>Zwraca <code>false</code> jeśli jego operand można przekonwertować na <code>true</code>; w przeciwnym razie zwraca <code>true</code>.</td> + </tr> + </tbody> +</table> + +<p>Jeśli dana wartość może być przekonwertowana na <code>true</code>, wówczas jest to tzw. wartość {{Glossary("truthy")}}. Jeśli dana wartość może być przekonwertowana na <code>false</code>, jest to tzw. wartość {{Glossary("falsy")}}.</p> + +<p>Przykładami wyrażeń, które mogą być przekonwertowane na <a href="/en-US/docs/Glossary/Falsy">false</a> są:</p> + +<ul> + <li><code>null</code>;</li> + <li><code>NaN;</code></li> + <li><code>0</code>;</li> + <li>pusty łańcuch znaków (string) – <code>""</code> lub <code>''</code>; </li> + <li><code>undefined</code>.</li> +</ul> + +<p>Mimo tego, że operatory <code>&&</code> i <code>||</code> mogą być używane z wartościami nie-boolowskimi, nadal mogą być uznane za operatory boolowskie (logiczne), gdyż zwracane przez nie wartości mogą być zawsze przekonwertowane na wartości logiczne.</p> + +<h3 id="Ewaluacja_short-circuit">Ewaluacja <em>short-circuit</em></h3> + +<p>Ponieważ wyrażenia logiczne są przetwarzane od lewej do prawej, sprawdzana jest najkrótsza możliwa ścieżka, pozwalająca na zwrócenie wyniku całego wyrażenia (tzw. <em>short-circuit evaluation</em>), zgodnie z następującymi zasadami:</p> + +<ul> + <li><code>false && (<em>cokolwiek)</em></code> zostanie przetworzone na false.</li> + <li><code>true || (<em>cokolwiek)</em></code> zostanie przetworzone na true.</li> +</ul> + +<p>Zasady logiki gwarantują, że powyższe ewaluacje są zawsze poprawne. Zauważ, że części wyrażeń oznaczone słowem <code>cokolwiek</code> nie są ewaluowane, więc nie pojawią się żadne efekty uboczne. Zauważ też, że część <code>cokolwiek</code> powyższych wyrażeń może być dowolnym pojedynczym wyrażeniem logicznym (co wskazano przez nawiasy).</p> + +<p>Dla przykładu, poniższe dwie funkcje są równoważne.</p> + +<pre class="brush: js">function shortCircuitEvaluation() { + // logiczne OR (||) + doSomething() || doSomethingElse(); + + // logiczne AND (&&) + doSomething() && doSomethingElse(); +} + +function equivalentEvaluation() { + + // logiczne OR (||) + var orFlag = doSomething(); + if (!orFlag) { + doSomethingElse(); + } + + + // logiczne AND (&&) + var andFlag = doSomething(); + if (andFlag) { + doSomethingElse(); + } +} +</pre> + +<p>Poniższe wyrażenia nie są jednak równoważne ze względu na <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Pierwsze%C5%84stwo_operator%C3%B3w">pierwszeństwo operatorów</a>, co podkreśla, jak ważne jest, by operator po prawej stronie był pojedynczym wyrażeniem (zgrupowanym w razie potrzeby przy pomocy nawiasów).</p> + +<pre class="brush: js">false && true || true // zwraca true +false && (true || true) // zwraca false</pre> + +<h3 id="Logiczne_AND"><a id="Logiczne AND" name="Logiczne AND">Logiczne AND (<code>&&</code>)</a></h3> + +<p>Poniżej pokazane są przykłady użycia operatora <code>&&</code> (logicznego AND).</p> + +<pre class="brush: js">a1 = true && true // t && t zwraca true +a2 = true && false // t && f zwraca false +a3 = false && true // f && t zwraca false +a4 = false && (3 == 4) // f && f zwraca false +a5 = 'Cat' && 'Dog' // t && t zwraca "Dog" +a6 = false && 'Cat' // f && t zwraca false +a7 = 'Cat' && false // t && f zwraca false +a8 = '' && false // f && f zwraca "" +a9 = false && '' // f && f zwraca false +</pre> + +<h3 id="Logiczne_OR"><a id="Logiczne OR" name="Logiczne OR">Logiczne OR (<code>||</code>)</a></h3> + +<p>Poniżej pokazane są przykłady użycia operatora <code>||</code> (logicznego OR).</p> + +<pre class="brush: js">o1 = true || true // t || t zwraca true +o2 = false || true // f || t zwraca true +o3 = true || false // t || f zwraca true +o4 = false || (3 == 4) // f || f zwraca false +o5 = 'Cat' || 'Dog' // t || t zwraca "Cat" +o6 = false || 'Cat' // f || t zwraca "Cat" +o7 = 'Cat' || false // t || f zwraca "Cat" +o8 = '' || false // f || f zwraca false +o9 = false || '' // f || f zwraca "" +</pre> + +<h3 id="Logiczne_NOT_!"><a id="Logiczne NOT" name="Logiczne NOT">Logiczne NOT (<code>!</code>)</a></h3> + +<p>Poniżej pokazane są przykłady użycia operatora <code>!</code> (logicznego NOT).</p> + +<pre class="brush: js">n1 = !true // !t zwraca false +n2 = !false // !f zwraca true +n3 = !'Cat' // !t zwraca false +</pre> + +<h4 id="Podwójne_NOT_!!">Podwójne NOT (<code>!!</code>)</h4> + +<p>Jest możliwe użycie kilku operatorów NOT naraz, by wprost wymusić konwersję dowolnej wartości do odpowiedniej wartości <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type">boolowskiej</a>. Konwersja bazuje na „prawdziwości” lub „fałszywości” wartości (zobacz {{Glossary("truthy")}} i {{Glossary("falsy")}}).</p> + +<p>Taka sama konwersja może być dokonana poprzez funkcję {{jsxref("Boolean")}}.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">n1 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="boolean token">true</span> <span class="comment token">// !!prawda zwraca true</span> +n2 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="punctuation token">{</span><span class="punctuation token">}</span> <span class="comment token">// !!prawda returns true: każdy obiekt jest "prawdą"...</span> +n3 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="punctuation token">(</span><span class="keyword token">new</span> <span class="class-name token">Boolean</span><span class="punctuation token">(</span><span class="boolean token">false</span><span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="comment token">// ...nawet obiekty booloweskie z false jako wartością .valueOf()!</span> +n4 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="boolean token">false</span> <span class="comment token">// !!fałsz zwraca false</span> +n5 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="string token">""</span> <span class="comment token">// !!fałsz zwraca false</span> +n6 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="function token">Boolean</span><span class="punctuation token">(</span><span class="boolean token">false</span><span class="punctuation token">)</span> <span class="comment token">// !!fałsz zwraca false</span></code></pre> + +<h3 id="Zasady_przekształcania_wyrażeń">Zasady przekształcania wyrażeń</h3> + +<h4 id="Przekształcanie_AND_na_OR">Przekształcanie AND na OR</h4> + +<p>Poniższa operacja na wartościach logicznych:</p> + +<pre class="brush: js">bCondition1 && bCondition2</pre> + +<p>jest zawsze równa:</p> + +<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre> + +<h4 id="Przekształcanie_OR_na_AND">Przekształcanie OR na AND</h4> + +<p>Poniższa operacja na wartościach logicznych:</p> + +<pre class="brush: js">bCondition1 || bCondition2</pre> + +<p>jest zawsze równa:</p> + +<pre class="brush: js">!(!bCondition1 && !bCondition2)</pre> + +<h4 id="Przekształcanie_NOT">Przekształcanie NOT</h4> + +<p>Poniższa operacja na wartościach logicznych:</p> + +<pre class="brush: js">!!bCondition</pre> + +<p>jest zawsze równa:</p> + +<pre class="brush: js">bCondition</pre> + +<h3 id="Usuwanie_zagnieżdżonych_wyrażeń_z_nawiasami">Usuwanie zagnieżdżonych wyrażeń z nawiasami</h3> + +<p>Jako że wyrażenia logiczne są ewaluowane od lewej do prawej, jest zawsze możliwe usunięcie nawiasów ze złożonego wyrażenia przy użyciu pewnych, przedstawionych dalej, reguł.</p> + +<h4 id="Usuwanie_zagnieżdżonego_AND">Usuwanie zagnieżdżonego AND</h4> + +<p>Następujące wyrażenie złożone na wartościach logicznych:</p> + +<pre class="brush: js">bCondition1 || (bCondition2 && bCondition3)</pre> + +<p>jest zawsze równe:</p> + +<pre class="brush: js">bCondition1 || bCondition2 && bCondition3</pre> + +<h4 id="Usuwanie_zagnieżdżonego_OR">Usuwanie zagnieżdżonego OR</h4> + +<p>Następujące wyrażenie złożone na wartościach logicznych:</p> + +<pre class="brush: js">bCondition1 && (bCondition2 || bCondition3)</pre> + +<p>jest zawsze równe:</p> + +<pre class="brush: js">!(!bCondition1 || !bCondition2 && !bCondition3)</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Uwagi</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definicja początkowa.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.11')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Zdefiniowane w kilku sekcjach specyfikacji: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.9">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.11">Binary Logical Operators</a></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-binary-logical-operators')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Zdefiniowane w kilku sekcjach specyfikacji: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-logical-operators">Binary Logical Operators</a></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-binary-logical-operators')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Zdefiniowane w kilku sekcjach specyfikacji: <a href="http://tc39.github.io/ecma262/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-logical-operators">Binary Logical Operators</a></td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.operators.logical")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Bitwise operators</a></li> + <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Boolean">Boolean</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/new.target/index.html b/files/pl/web/javascript/referencje/operatory/new.target/index.html new file mode 100644 index 0000000000..8b60074e92 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/new.target/index.html @@ -0,0 +1,134 @@ +--- +title: new.target +slug: Web/JavaScript/Referencje/Operatory/new.target +translation_of: Web/JavaScript/Reference/Operators/new.target +--- +<div>{{JSSidebar("Operators")}}</div> + +<p><strong><code>new.target</code></strong> pozwala sprawdzić czy konstruktor lub funkcja była zainicjalizowana używając operatora <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>. Kiedy w konstruktorze lub funkcji zainicjalizowany jest operatora <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>, <code>new.target</code> zwraca referencje do konstruktora lub funkcji. W normalnym wywołaniu funkcji, <code>new.target</code> jest {{jsxref("undefined")}}.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new.target</pre> + +<h2 id="Opis">Opis</h2> + +<p><code>new.target</code> składa się ze słowa <code>"new</code>", kropki i pola o nazwie <code>"target"</code>. Przeważnie "<code>new."</code> jest kontekstem dostępu do pola, ale w tym przypadku "new." nie jest tak naprawdę obiektem. W wywołaniu konstruktora, <code>new.target</code> nawiązuje do konstruktora wywołanego przez <code>new</code> więc "<code>new.</code>" staje się wirtualnym kontekstem.</p> + +<p><code><font face="Open Sans, Arial, sans-serif">Pole </font>new.target</code> jest meta polem które jest dostępne dla wszystkich funkcji. W <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a>, <code>new.target</code> nawiązuje do <code>new.target</code> otaczającej funkcji.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="new.target_w_wywołaniu_funkcji">new.target w wywołaniu funkcji</h3> + +<p>W normalnym wywołaniu funkcji (w przeciwieństwie do wywołania konstruktora), <code>new.target</code> jest {{jsxref("undefined")}}. Pozwala Ci to stwierdzić, czy funkcja została wywołana wraz z <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a> jako konstruktor.</p> + +<pre class="brush: js">function Foo() { + if (!new.target) throw "Foo() must be called with new"; + console.log("Foo instantiated with new"); +} + +Foo(); // throws "Foo() must be called with new" +new Foo(); // logs "Foo instantiated with new" +</pre> + +<h3 id="new.target_w_konstruktorze">new.target w konstruktorze</h3> + +<p>W konstruktorach klasy, <code>new.target</code> nawiązuje do konstruktora który został bezpośrednio wywołany z <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>. Dzieje się tak również w przypadku kiedy konstruktor znajduje się w klasie rodzica, i został wywołany z konstruktorze dziecka.</p> + +<pre class="brush: js">class A { + constructor() { + console.log(new.target.name); + } +} + +class B extends A { constructor() { super(); } } + +var a = new A(); // logs "A" +var b = new B(); // logs "B" +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-built-in-function-objects', 'Built-in Function Objects')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-built-in-function-objects', 'Built-in Function Objects')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(46.0)}}</td> + <td>{{CompatGeckoDesktop(41)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(46.0)}}</td> + <td>{{CompatGeckoMobile(41)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(46.0)}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions">Functions</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/nullish_coalescing_operator/index.html b/files/pl/web/javascript/referencje/operatory/nullish_coalescing_operator/index.html new file mode 100644 index 0000000000..c8a264e50e --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/nullish_coalescing_operator/index.html @@ -0,0 +1,251 @@ +--- +title: Operator null'owego scalania (??) +slug: Web/JavaScript/Referencje/Operatory/Nullish_coalescing_operator +tags: + - JavaScript + - Language feature + - Operator + - Reference + - nullish coalescing +translation_of: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator +--- +<p>{{JSSidebar("Operators")}}</p> + +<p><strong>Operator null'owego scalania (<code>??</code>)</strong> - to operator logiczny, stosowany w wyrażeniach, który zwraca to co jest po jego lewej stronie, tak długo, jak to nie jest <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code>, albo <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code>, wtedy zwraca to, co jest po prawej.</p> + +<div class="blockIndicator note"> +<p>Początkowo ewaluowane jest tylko wyrażenie z lewej strony.<br> + Dopiero, gdy zachodzi taka potrzeba, ewaluowane jest prawe wyrażenie.</p> +</div> + +<p>Jest podobny do <strong>logicznego operatora LUB (<code>||</code>)</strong> ( <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR">Logical OR (||)</a> ), ale <strong>LUB</strong> decyduje o tym, czy wziąć prawą wartość, na innej podstawie:<br> + <em>Czy lewa wartość jest fałszopodobna</em> (<a href="/en-US/docs/Glossary/Falsy">Falsy</a>)<em>?</em><br> + <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code> i <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code> są fałszopodobne, ale sęk w tym, że nie tylko one, ale również np. <code>0</code>, czy <code>""</code>. Czasem nie chce się podmieniać niczego za <code>0</code> i <code>""</code>, uważając je za dopuszczalne wartości.<br> + Wtedy właśnie przydaje się ten operator.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-nullishcoalescingoperator.html")}}</div> + +<p class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.<br> + See <a href="https://github.com/mdn/interactive-examples/pull/1482#issuecomment-553841750">PR #1482</a> regarding the addition of this example.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><u>LWyr</u> ?? <u>PWyr</u></pre> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Pole</th> + <th scope="col">Opis</th> + </tr> + </thead> + <tbody> + <tr> + <td>LWyr</td> + <td>Wyrażenie główne, ewaluowane na początku.<br> + Jeżeli jego wartość wynikowa jest <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code>, albo <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code>, to nie ona zostanie zwrócona, ale wartość wynikowa wyrażenia <u>PWyr</u>. </td> + </tr> + <tr> + <td>PWyr</td> + <td>Wyrażenie zamienne, ewaluowane, kiedy wartość <u>LWyr</u> jest <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code>, albo <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Przykłady"><span style="">Przykłady</span></h2> + +<h3 id="Użycie_operatora">Użycie operatora</h3> + +<p>W tym przykładzie użyjemy <strong>operatora null'owego scalania</strong> do podania zapasowych wartości, przy inicjowaniu stałych:</p> + +<pre class="brush: js notranslate">const wartoscNull = null; +const warA = wartoscNull ?? "domyślne dla A"; +console.log(warA); + +// konsola: "domyślne dla A" + + + +const pustyTekst = ""; // fałszopodobny +const warB = pustyTekst ?? "domyślne dla B"; +console.log(warB); + +// konsola: "" +// ponieważ "??" reaguje tylko konkretnie na null albo undefined + + + +const jakasLiczba = 42; +const warC = jakasLiczba ?? 0; +console.log(warC); + +// konsola: 42</pre> + +<h3 id="Porównanie_działania_i">Porównanie działania "??" i "||"</h3> + +<p>Wcześniej przed pojawieniem się tego operatora, używano <strong>LUB (<code>||</code>) (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR">Logical OR (||)</a>)</strong>:</p> + +<pre class="notranslate">let liczba; +let zabezpLicz = liczba || 1; +// zmienna "wejscie" nie była nigdy zapełniona żadną wartością, +// więc była "undefined", a undefined jest fałszopodobne, więc +// JavaScript wziął zapasowe '1'. + +console.log(2 * zabezpLicz); +// konsola: 2 +</pre> + +<p>To działa, ale...<br> + przez to jakim operatorem jest <strong>LUB</strong>, nie tylko <code>undefined</code> zostanie tu zamienione, ale też i <code>0</code>, które, w kontekście tego przykładu, powiedzmy, że jest wartością, która powinna być ok:</p> + +<pre class="brush: js notranslate">let liczba = 0; +let zabezpLicz = liczba || 1; +// zmienna "wejscie" została zapełniona zerem, ale jest fałszopodobne, +//więc JavaScript wziął zapasowe '1'. + +console.log(2 * zabezpLicz); +// konsola: 2 +// chcieliśmy: 0 +</pre> + +<p>Operator null'owego scalania rozwiązuje ten problem:</p> + +<pre class="brush: js notranslate">let liczba = 0; +let zabezpLicz = liczba ?? 1; +// zmienna "wejscie" została zapełniona zerem, +//mimo tego, że jest fałszopodobne, "??" akceptuje je, bo to nie null, ani undefined, i +//JavaScript zostawia '0'. + +console.log(2 * zabezpLicz); +// konsola: 0 +</pre> + +<h3 id="Pomijanie_ewaluacji">Pomijanie ewaluacji</h3> + +<p>Podobnie jak inne operatory logiczne <strong>LUB (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR" style="">Logical OR (||)</a>)</strong> i <strong>I (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND">Logical AND (&&)</a>)</strong>, ten operator rozpoczyna od ewaluacji wyrażenia po lewej stronie, i dopiero gdy trzeba, zajmuje się prawą stroną:</p> + +<pre class="brush: js notranslate">function A(){ + console.log("Tu A!"); + return false; +} +function B(){ + console.log("Tu B!"); + return true; +} + +if( A() ?? B() ) console.log("Otrzymano 'true'"); +else console.log("Otrzymano 'false'"); +// konsola: "Otrzymano 'false'" +</pre> + +<p>i :</p> + +<pre class="brush: js notranslate">function A(){ + console.log("Tu A!"); + return null; // teraz tu jest zwracany null, na który reaguje "??" +} +function B(){ + console.log("Tu B!"); + return true; +} + +if( A() ?? B() ) console.log("Otrzymano 'true'"); +else console.log("Otrzymano 'false'"); +// konsola: "Otrzymano 'true'"</pre> + +<h3 id="Nie_działa_seryjnie_ani_z_LUB_ani_z_I">Nie działa seryjnie, ani z LUB, ani z I</h3> + +<p>W wyrażeniach, nie można stawiać zwyczajnie <strong>operatora null'owego scalania</strong> w otoczeniu operatorów <strong>LUB</strong> i <strong>I</strong>, mimo ustalonej kolejności wykonywania działań. Będzie to odbierane jako błąd składniowy:</p> + +<pre class="brush: js example-bad notranslate">null || undefined ?? "yyy..."; // to będzie SyntaxError +true || undefined ?? "aha."; // to też będzie SyntaxError +//bo tu chodzi o to, że jest "||" i "??" razem, nie o wartości. +</pre> + +<p>Trzeba je rozdzielić nawiasami:</p> + +<pre class="brush: js example-good notranslate">(null || undefined) ?? "yyy..."; // zwraca: "yyy..." +null || (undefined ?? "działa!"); // zwraca: "działa!" +</pre> + +<h3 id="Odniesienie_do_Operatora_opcjonalnego_dostępu_.">Odniesienie do Operatora opcjonalnego dostępu "?."</h3> + +<p>Sposób w który <strong>operator null'owego scalania</strong> pracuje z wartościami <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null" style="">null</a></code> i <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code>, jest intuicyjny analogicznie u <strong>operatora opcjonalnego dostępu</strong> (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining">Optional chaining (?.)</a>, i razem pozwalają na ciekawe akcje, np.:</p> + +<pre class="notranslate">class objekt{ + tekst; + + constructor(tekst = null){ + this.tekst = tekst; + } + + odczytTekst(){ + return this.tekst; + } + wpisTekst(w){ + this.tekst = w; + return true; + } +} + +let objekty = [new objekt("cześć!"), null, new objekt()]; + + + +// zadanie kodu: zamień tekst'y w objekt'ach na duże litery, +// używając funkcji dostępu, a pozostawiając puste wartości +// bez zmian + + +// wersja typeof +for(let i = 0; i < objekty.length; i++) + if(typeof(objekty[i]) == "object") + if(typeof(objekty[i].odczytTekst()) == "string") + objekty[i].wpisTekst(objekty[i].odczytTekst().toUpperCase()); + + +// wersja operatorów "??" i "?." +for(let i = 0; i < objekty.length; i++) + objekty[i]?.wpisTekst(objekty[i]?.odczytTekst()?.toUpperCase() ?? null); + +console.log(objekty); +</pre> + +<p>Czasami użycie tych operatorów upraszcza kod.<br> + Poza tym każda funkcja jest wywoływana najwyżej raz i może to być co kolwiek.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#prod-Nulli', 'nullish coalescing expression')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.operators.nullish_coalescing")}}</p> + +<h3 id="Postępy_implementacji">Postępy implementacji</h3> + +<p>Tabelka pod spodem pokazuje codzienny status implementacji tej funkcji. Jest tak, ponieważ nie osiągnięto jeszcze stabilności między przeglądarkami.<br> + Dane są generowane, poprzez przeprowadzanie odpowiednich testów funkcji w <a href="https://github.com/tc39/test262" style="">Test262</a>, standardowym zestawie testów dla JavaScripta, na najnowszych kompilacjach (en: "nightly build"), lub najnowszych wydaniach (en: "latest release") silników JavaScripta przeglądarek.</p> + +<div>{{EmbedTest262ReportResultsTable("coalesce-expression")}}</div> + +<h2 id="Zobacz_też...">Zobacz też...</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining">The optional chaining operator</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR_2">The logical OR (<code>||</code>) operator</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">Default parameters in functions</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/object_initializer/index.html b/files/pl/web/javascript/referencje/operatory/object_initializer/index.html new file mode 100644 index 0000000000..4148cc07d1 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/object_initializer/index.html @@ -0,0 +1,387 @@ +--- +title: Inicjalizator obiektu +slug: Web/JavaScript/Referencje/Operatory/Object_initializer +translation_of: Web/JavaScript/Reference/Operators/Object_initializer +--- +<div>{{JsSidebar("Operators")}}</div> + +<p>Obiekty można tworzyć używając <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>new Object()</code></a>,<code> <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create">Object.create()</a></code>, bądź wykorzystując notację literałową (notację <em>inicializacyjną</em>). Inicjalizator obiektu to lista zera lub więcej par - nazw właściwości oraz ich wartości - otoczonych nawiasami klamrowymi (<code>{}</code>).</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js">var o = {}; +var o = { a: "foo", b: 42, c: {} }; + +var a = "foo", b = 42, c = {}; +var o = { a: a, b: b, c: c }; + +var o = +{ + <var>wlasciwosc: function </var>([<var>parametry</var>]) {}, + get <var>wlasciwosc</var>() {}, + set <var>wlasciwosc</var>(<var>wartosc</var>) {}, +}; +</pre> + +<h3 id="Nowe_notacje_w_ECMAScript_2015">Nowe notacje w ECMAScript 2015</h3> + +<p>Pamiętaj aby zapoznać się z tabelą kompatybilności. Środowiska nie obsługujące tych notacji będą wyrzucać błędy składni.</p> + +<pre class="brush: js">// Skrótowe nazwy właściwości (ES6) +var a = "foo", b = 42, c = {}; +var o = { a, b, c }; + +// Skrótowe nazwy metod (ES6) +var o = { + <var>wlasciwosc</var>([<var>parametry</var>]) {}, + get <var>wlasciwosc</var>() {}, + set <var>wlasciwosc</var>(<var>wartosc</var>) {}, + * <var>generator</var>() {} +}; + +// Obliczone nazwy właściwości (ES6) +var nazwa = "foo"; +var o = { + [nazwa]: "dzien", + ["b" + "ar"]: "dobry", +};</pre> + +<h2 id="Opis">Opis</h2> + +<p>Inicjalizator obiektu to wyrażenie opisujące inicjalizację obiektu {{jsxref("Object")}}. Obiekty składają się z <em>właściwości</em> używanych do opisywania obiektu. Wartości tych właściwości mogą zawierać {{Glossary("primitive")}} typy danych albo inne obiekty.</p> + +<h3 id="Tworzenie_obiektów">Tworzenie obiektów</h3> + +<p>Pusty obiekt możemy stworzyć w taki sposób:</p> + +<pre class="brush: js">var obiekt = {};</pre> + +<p>Jednak prawdziwą przewagą notacji literałowej jest możliwość tworzenia w szybki sposób obiektów ze zdefiniowanymi od razu właściwościami. Wystarczy wypisać listę kluczy: wartości odzdzielonych dwukropkiem. Poniższy przykład tworzy obiekt <code>osoba</code> z trzema właściwościami: "<code>imie</code>", "<code>wiek</code>" i "<code>wyglad</code>". Ich wartościami jest string "<code>Adam</code>", numer <code>42</code> oraz inny obiekt.</p> + +<pre class="brush: js">var osoba = +{ + imie: "Adam", + wiek: 42, + wyglad: { wzrost: 179 }, +}</pre> + +<h3 id="Dostęp_do_właściwości">Dostęp do właściwości</h3> + +<p>Kiedy już stworzyłeś obiekt, możesz chcieć zobaczyć lub zmienić jego właściwości. Można zrobić to używając zapisu z kropką lub nawiasami. Zajrzyj do <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_pamięci">operatorów pamięci</a> po więcej informacji.</p> + +<pre class="brush: js">object.imie; // "Adam" +object["wiek"]; // 42 + +object.imie = "Ewa"; +</pre> + +<h3 id="Definiowanie_właściwości">Definiowanie właściwości</h3> + +<p>Nauczyliśmy się już jak zapisywać właściwości używając notacji literałowej. Czasami jednak mamy w kodzie zmienne, które chcielibyśmy dodać do naszego obiektu. Możemy to zrobić w taki sposób:</p> + +<pre class="brush: js">var a = "foo", + b = 42, + c = {}; + +var o = +{ + a: a, + b: b, + c: c +};</pre> + +<p>Ale ECMAScript 2015 oddaje nam do dyspozycji krótszy zapis, pozwalający uzyskać ten sam efekt:</p> + +<pre class="brush: js">var a = "foo", + b = 42, + c = {}; + +// Skrótowe nazwy właściwości (ES6) +var o = { a, b, c };</pre> + +<h4 id="Duplikowanie_nazw_właściwości">Duplikowanie nazw właściwości</h4> + +<p>W momencie, gdy użyjemy już istniejącej nazwy właściwości jej wartość nadpisze tę poprzednią.</p> + +<pre class="brush: js">var a = {x: 1, x: 2}; +console.log(a); // { x: 2} +</pre> + +<p>W ECMAScript 5 <em>strict mode,</em> duplikowanie nazw właściwości było postrzegane jako {{jsxref("SyntaxError")}}. Zmieniono to jednak po wprowadzeniu obliczanych nazw właściwości. Duplikacja stała się wówczas możliwa podczas wykonywania kodu, dlatego też w ECMAScript 2015 usunięto tę rystrykcję.</p> + +<pre class="brush: js">function czyES6UmozliwiaDuplikowanieWlasciwosci() +{ + "use strict"; + try + { + ({ prop: 1, prop: 2 }); + + // Nie wyrzucono błędu, duplikacja dozwolona w <em>strict mode</em>. + return true; + } + catch (e) + { + // Wyrzucono błąd, duplikacja w <em>strict mode</em> zabroniona. + return false; + } +}</pre> + +<h3 id="Definicje_metod">Definicje metod</h3> + +<p>Właściwość obiektu może również odnosić się do <a href="pl/docs/Web/JavaScript/Reference/Functions">funkcji</a> albo metody <a href="/pl/docs/Web/JavaScript/Reference/Functions/get">getter</a> lub <a href="/pl/docs/Web/JavaScript/Reference/Functions/set">setter</a>.</p> + +<pre class="brush: js">var o = { + <var>wlasciwos: function </var>([<var>parametry</var>]) {}, + get <var>wlasciwos</var>() {}, + set <var>wlasciwos</var>(<var>wartosc</var>) {}, +};</pre> + +<p>w ECMAScript 2015, mamy dostęp do skróconego zapisu, takiego w którym słowo kluczowe "function" nie jest nam już potrzebne.</p> + +<pre class="brush: js">// Shorthand method names (ES6) +var o = { + <var>property</var>([<var>parameters</var>]) {}, + get <var>property</var>() {}, + set <var>property</var>(<var>value</var>) {}, + * <var>generator</var>() {} +};</pre> + +<p>W ECMAScript 2015 możemy również w prostszy sposób zapisać właściwość będącą funkcją generatora:</p> + +<pre class="brush: js">var o = { + * <var>generator</var>() { + ........... + } +};</pre> + +<p>W ECMAScript 5 musielibyśmy zapisać to tak (aczkolwiek pamiętaj że w ES5 nie ma generatorów):</p> + +<pre class="brush: js">var o = { + generator<var>: function *</var>() { + ........... + } +};</pre> + +<p>Po więcej informacji zajrzyj do <a href="/pl/docs/Web/JavaScript/Reference/Functions/Method_definitions">definicji metod</a>.</p> + +<h3 id="Obliczone_nazwy_właściwości">Obliczone nazwy właściwości</h3> + +<p>Od ECMAScript 2015, składnia inicjalizatora obiektu wspiera także obliczone nazwy właściwości. Umożliwia to umieszczenie wyrażenia w nawiasach <code>[]</code>, które potem zostanie przeliczone na nazwę właściwości. Działa to na tej samej zasadzie co zapis klamrowy w <a href="/pl/docs/Web/JavaScript/Reference/Operators/Property_Accessors">operatorach pamięci</a>, z którymi zapewne miałeś już styczność. Teraz możemy użwać tej samej składni w notacji literałowej:</p> + +<pre class="brush: js">// Obliczone nazwy właściwości (ES6) +var i = 0; +var a = { + ["foo" + ++i]: i, + ["foo" + ++i]: i, + ["foo" + ++i]: i +}; + +console.log(a.foo1); // 1 +console.log(a.foo2); // 2 +console.log(a.foo3); // 3 + +var param = 'typ'; +var info = { + [param]: 'strona', + ["pod" + param.charAt(0).toUpperCase() + param.slice(1)]: 'forum' +}; + +console.log(info); // { typ: 'strona', 'podTyp': 'forum' }</pre> + +<h3 id="Zmiana_prototypu">Zmiana prototypu</h3> + +<p>Definicja właściwości w formie <code>__proto__: wartosc</code> albo <code>"__proto__": wartosc</code> nie stworzy właściwości z nazwą <code>__proto__</code>. Zamiast tego, jeżeli podana wartość jest obiektem lub typem <code>null</code>, zamieni ona <code>[[Prototype]]</code> tworzonego obiektu na podaną wartość. (Jeżeli wartość nie jest ani obiektem ani typem <code>null</code> prototyp nie zostanie zmieniony.)</p> + +<pre class="brush: js">var obj1 = {}; +console.log(Object.getPrototypeOf(obj1) === Object.prototype); // true + +var obj2 = { __proto__: null }; +console.log(Object.getPrototypeOf(obj2) === null); // true + +var protoObj = {}; +var obj3 = { "__proto__": protoObj }; +console.log(Object.getPrototypeOf(obj3) === protoObj); // true + +var obj4 = { __proto__: "not an object or null" }; +console.log(Object.getPrototypeOf(obj4) === Object.prototype); // true +console.log(!obj4.hasOwnProperty("__proto__")); // true +</pre> + +<p>Podczas notacji literałowej możemy zmienić prototyp tylko raz, kolejne próby będą skutkować błędami składni.</p> + +<p>Jeżeli użyjemy w defninicji nazwy <code>__proto__</code> bez używania składni z dwukropkiem, nazwa ta będzie się zachowywać jak kazda inna.</p> + +<pre class="brush: js">var __proto__ = "wartosc"; + +var obj1 = { __proto__ }; +console.log(Object.getPrototypeOf(obj1) === Object.prototype); // true +console.log(obj1.hasOwnProperty("__proto__")); // true +console.log(obj1.__proto__ === "wartosc"); // true + +var obj2 = { __proto__() { return "witaj"; } }; +console.log(obj2.__proto__() === "witaj"); // true + +var obj3 = { ["__prot" + "o__"]: 17 }; +console.log(obj3.__proto__ === 17); // true +</pre> + +<h2 id="Notacja_literałowa_vs_JSON">Notacja literałowa vs JSON</h2> + +<p>Notacja literałowa to nie to samo co <strong>J</strong>ava<strong>S</strong>cript <strong>O</strong>bject <strong>N</strong>otation (<a href="/pl/docs/Glossary/JSON">JSON</a>). Pomimo, że wyglądają podobnie, są miedzy nimi poważne różnice:</p> + +<ul> + <li>JSON dopuszcza tylko składnie <code>"wlasnosc": wartosc</code>. Nazwa własności musi być w cudzysłowie, a defnicja nie może być skrócona.</li> + <li>W JSON wartościami moga być tylko string'i, liczby, tablice, <code>true</code>, <code>false</code>, <code>null</code>, lub inny obiekt JSON.</li> + <li>Funkcja nie może być przypisana do wartości w JSON.</li> + <li>Obiekty jak {{jsxref("Date")}} zostaną zamienione na string po użyciu {{jsxref("JSON.parse()")}}.</li> + <li>{{jsxref("JSON.parse()")}} odrzuni obliczone nazwy zmiennych oraz wyrzuci błąd.</li> +</ul> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Dodano metody <a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">getter</a> oraz <a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setter</a>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object-initializer', 'Object Initializer')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Skrócone nazwy właściwości/metod oraz obliczone nazwy właściwości.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object-initializer', 'Object Initializer')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(1.0)}}</td> + <td>{{CompatGeckoDesktop("1.0")}}</td> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>Computed property names</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>7.1</td> + </tr> + <tr> + <td>Shorthand property names</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("33")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Shorthand method names</td> + <td>{{CompatChrome(42.0)}}</td> + <td>{{CompatGeckoDesktop("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.0")}}</td> + <td>1</td> + <td>1</td> + <td>1</td> + <td>{{CompatChrome(1.0)}}</td> + </tr> + <tr> + <td>Computed property names</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Shorthand property names</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("33")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Shorthand method names</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(42.0)}}</td> + <td>{{CompatGeckoMobile("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(42.0)}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Operatory pamięci</a></li> + <li><code><a href="/pl/docs/Web/JavaScript/Reference/Functions/get">get</a></code> / <code><a href="/pl/docs/Web/JavaScript/Reference/Functions/set">set</a></code></li> + <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/Method_definitions">Definicje metod</a></li> + <li><a href="/pl/docs/Web/JavaScript/Reference/Lexical_grammar">Gramatyka leksykalna</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/operator_delete/index.html b/files/pl/web/javascript/referencje/operatory/operator_delete/index.html new file mode 100644 index 0000000000..d2a3679804 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_delete/index.html @@ -0,0 +1,74 @@ +--- +title: Operator delete +slug: Web/JavaScript/Referencje/Operatory/Operator_delete +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Operators/delete +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Operator delete usuwa obiekt, własność obiektu lub element w określonym indeksie w tablicy.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox">delete <em> nazwaObiektu</em> +</pre> + +<pre class="syntaxbox">delete <em>nazwaObiektu.własność</em> +delete <em>nazwaObiektu</em>['<code><em>własność</em>'</code>] +</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>nazwaObiektu</code></dt> + <dd>Nazwa obiektu.</dd> +</dl> + +<dl> + <dt><code>własność</code></dt> + <dd>Własność do usunięcia.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Czwarta forma jest dozwolona tylko wewnątrz instrukcji <code>with</code> w celu usunięcia własności z obiektu.</p> + +<p>Możesz użyć operatora <code>delete</code>, aby usunąć zmienne zadeklarowane bezpośrednio, jednak nie możesz usunąć zmiennych zadeklarowanych za pomocą instrukcji <code>var</code>.</p> + +<p>Jeśli operator <code>delete</code> zadziała prawidłowo, ustawi on własność lub element jako <code>undefined</code> (niezdefiniowany). Operator <code>delete</code> zwraca wartość true (prawda), jeśli operacja jest możliwa, zaś wartość <code>false</code> (fałsz), gdy operacja nie jest możliwa.</p> + +<pre class="brush: js">x = 42; +var y = 43; +myobj = new Number(); +myobj.h = 4; // tworzy własność h +delete x; // zwraca true (można usuwać, jeśli zadeklarowano bezpośrednio) +delete y; // zwraca false (nie można usuwać, jeśli zadeklarowano za pomocą var) +delete Math.PI; // zwraca false (nie można usuwać własności predefiniowanych) +delete myobj.h; // zwraca true (można usuwać własności zdefiniowane przez użytkownika) +delete myobj; // zwraca true (można usuwać obiekty) +</pre> + +<h3 id="Usuwanie_element.C3.B3w_tablicy" name="Usuwanie_element.C3.B3w_tablicy">Usuwanie elementów tablicy</h3> + +<p>Gdy usuwasz element tablicy nie ma to wpływu na jej długość. Na przykład: jeśli usuniesz a{{ mediawiki.external(3) }}, a{{ mediawiki.external(4) }} będzie wciąż a{{ mediawiki.external(4) }}, natomiast a{{ mediawiki.external(3) }} będzie niezdefiniowane.</p> + +<p>Gdy operator <code>delete</code> usuwa element tablicy, element ten przestaje już w niej istnieć. W poniższym przykładzie drzewa{{ mediawiki.external(3) }} jest usunięte za pomocą <code>delete</code>.</p> + +<pre class="brush: js">drzewa = new Array("sekwoja","wawrzyn","cedr","dąb","klon"); +delete drzewa[3]; +if (3 in drzewa) { + // to nie zostanie wykonane +} +</pre> + +<p>Jeśli chcesz, aby element tablicy nadal istniał, ale posiadał wartość niezdefiniowaną, użyj słowa kluczowego <code>undefined</code> zamiast operatora <code>delete</code>. W poniższym przykładzie, drzewa{{ mediawiki.external(3) }} jest przypisana wartość niezdefiniowana, ale element tablicy nadal istnieje:</p> + +<pre class="brush: js">drzewa = new Array("sekwoja","wawrzyn","cedr","dąb","klon"); +drzewa[3] = undefined; +if (3 in drzewa) { + // to zostanie wykonane +} +</pre> + +<div class="noinclude"> </div> diff --git a/files/pl/web/javascript/referencje/operatory/operator_function/index.html b/files/pl/web/javascript/referencje/operatory/operator_function/index.html new file mode 100644 index 0000000000..1d13d1a3c0 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_function/index.html @@ -0,0 +1,144 @@ +--- +title: Operator function +slug: Web/JavaScript/Referencje/Operatory/Operator_function +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Operators/function +--- +<p> </p> + +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> + +<p>Operator <code>function</code> jest używany do definiowania funkcji wewnątrz wyrażenia.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="eval">function [<em>nazwa</em>]([<em>argument1[</em>, <em>argument2[</em>, ..., <em>argumentN</em>]]]) { <em>instrukcje </em>} +</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>nazwa</code></dt> + <dd>Nazwa funkcji. Może zostać pominięta, w takim wypadku funkcja staje się anonimowa. Nazwa jest tylko lokalna i istnieje wewnętrz funkcji.</dd> +</dl> + +<dl> + <dt><code>argumentN</code></dt> + <dd>Nazwa argumentu, który ma zostać przekazany do funkcji. Funkcja może posiadać do 255 argumentów.</dd> +</dl> + +<dl> + <dt><code>instrukcje</code></dt> + <dd>Instrukcje, które stanowią ciało funkcji.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Wyrażenie funkcji jest bardzo podobne do deklaracji funkcji i posiada niemal identyczną składnię (zobacz <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/function">function</a>, aby uzyskać bardziej szczegółowe informacje). Główną różnicą pomiędzy wyrażeniem a definicją jest <em>nazwa funkcji, </em>która może zostać pominięta i utworzyć funkcję<em> anonimową</em>. Zobacz <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje">Funkcje</a>, aby uzyskać informacje o różnicach między instrukcjami funkcji a wyrażeniami funkcji.</p> + +<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2> + +<p>Poniższy przykład definiuje nienazwaną funkcję i przypisują ją do <code>x</code>. Funkcja zwraca kwadrat jej argumentów:</p> + +<pre>var x = function(y) { + return y * y; +}; +</pre> + +<h3 id="Nazwane_wyrażenie">Nazwane wyrażenie</h3> + +<pre><code>var math = { + 'factorial': function factorial(n) { + if (n <= 1) + return 1; + return n * factorial(n - 1); + } +};</code></pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarze</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-13', 'Function definition')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-13', 'Function definition')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Zaimplementowano w JavaScript 1.5.</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<table> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> + +<table> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje">Funkcje</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/function">Polecenie function</a></code></p> diff --git a/files/pl/web/javascript/referencje/operatory/operator_in/index.html b/files/pl/web/javascript/referencje/operatory/operator_in/index.html new file mode 100644 index 0000000000..0a8ef0f068 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_in/index.html @@ -0,0 +1,92 @@ +--- +title: Operator in +slug: Web/JavaScript/Referencje/Operatory/Operator_in +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Operators/in +--- +<p> </p> +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> +<p>Operator <code>in</code> zwraca wartość <code>true</code> (prawda), jeśli określona własność jest w określonym obiekcie.</p> +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header" colspan="2">Operator</td> + </tr> + <tr> + <td>Zaimplementowany w:</td> + <td>JavaScript 1.4</td> + </tr> + </tbody> +</table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3> +<p><code> + <i> + propNameOrNumber</i> + in + <i> + objectName</i> + </code></p> +<h3 id="Parametry" name="Parametry">Parametry</h3> +<dl> + <dt> + <code>propNameOrNumber</code></dt> + <dd> + Łańcuch znaków lub wartość liczbowa reprezentujące nazwę własności lub indeks tablicy.</dd> +</dl> +<dl> + <dt> + <code>objectName</code></dt> + <dd> + Nazwa obiektu.</dd> +</dl> +<h3 id="Opis" name="Opis">Opis</h3> +<p>Poniższe przykłady pokazują wybrane sposoby użycia operatora <code>in</code>.</p> +<pre>// Tablice +trees=new Array("redwood","bay","cedar","oak","maple") +0 in trees // zwraca true +3 in trees // zwraca true +6 in trees // zwraca false +"bay" in trees // zwraca false (musisz określić numer indeksu, + // nie wartość w tym indeksie) +"length" in trees // zwraca true (length jest własnością tablicy Array) + +// Obiekty predefiniowane +"PI" in Math // zwraca true +myString=new String("coral") +"length" in myString // zwraca true + +// Custom objects +mycar = {make:"Honda",model:"Accord",year:1998} +"make" in mycar // zwraca true +"model" in mycar // zwraca true +</pre> +<p>Musisz określić obiekt z prawej strony operatora <code>in</code>. Na przykład: możesz określić łańcuch znaków stworzony za pomocą konstruktora <code>String</code>, ale nie możesz określić łańcucha znaków wprost.</p> +<pre>color1=new String("green") +"length" in color1 // zwraca true +color2="coral" +"length" in color2 // generuje błąd (color nie jest obiektem typu String) +</pre> +<h4 id="Zastosowanie_in_z_usuni.C4.99tymi_lub_niezdefiniowanymi_w.C5.82asno.C5.9Bciami" name="Zastosowanie_in_z_usuni.C4.99tymi_lub_niezdefiniowanymi_w.C5.82asno.C5.9Bciami">Zastosowanie <code>in</code> z usuniętymi lub niezdefiniowanymi własnościami</h4> +<p>Jeśli usuniesz własność za pomocą operatora <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_delete">delete</a></code>, operator <code>in</code> zwróci wartość false (fałsz) dla tej własności.</p> +<pre>mycar = {make:"Honda",model:"Accord",year:1998} +delete mycar.make +"make" in mycar // zwraca false + +trees=new Array("redwood","bay","cedar","oak","maple") +delete trees[3] +3 in trees // zwraca false +</pre> +<p>Jeśli ustalisz własność jako niezdefiniowaną, ale nie usuniesz jej, operator <code>in</code> zwróci wartość true (prawda) dla tej własności.</p> +<pre>mycar = {make:"Honda",model:"Accord",year:1998} +mycar.make=undefined +"make" in mycar // zwraca true + +trees=new Array("redwood","bay","cedar","oak","maple") +trees[3]=undefined +3 in trees // zwraca true +</pre> +<p>Aby uzyskać dodatkowe informacje o zastosowaniu operatora <code>in</code> z usuniętymi elementami tablicy, zobacz <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_delete">delete</a>.</p> diff --git a/files/pl/web/javascript/referencje/operatory/operator_instanceof/index.html b/files/pl/web/javascript/referencje/operatory/operator_instanceof/index.html new file mode 100644 index 0000000000..d9b83cd838 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_instanceof/index.html @@ -0,0 +1,168 @@ +--- +title: Operator instanceof +slug: Web/JavaScript/Referencje/Operatory/Operator_instanceof +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Operators/instanceof +--- +<div>{{jsSidebar("Operators")}}</div> + +<p><strong>Operator</strong> <strong><code>instanceof</code> </strong>sprawdza czy właściwość konstruktora <code>prototype</code> pojawia się gdziekolwiek w łańcuchu prototypowym obiektu.</p> + +<p>{{EmbedInteractiveExample("pages/js/expressions-instanceof.html")}}</p> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><em>object</em> instanceof <em>constructor</em></pre> + +<dl> + <dt> + <h3 id="Parametry">Parametry</h3> + <code>object</code></dt> + <dd>Obiekt do testowania.</dd> +</dl> + +<dl> + <dt><code>constructor</code></dt> + <dd>Funkcja przeciwko której testujemy.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Operator <code>instanceof</code> sprawdza obecność <code>constructor.prototype</code> w łańcuchu prototypowym obiektu <code>object</code></p> + +<pre class="brush: js">// definiowanie konstruktorów +function C() {} +function D() {} + +var o = new C(); + +// true, ponieważ: Object.getPrototypeOf(o) === C.prototype +o instanceof C; + +// false, ponieważ D.prototype nie występuje w łańcuchu prototypowym o. +o instanceof D; + +o instanceof Object; // true, ponieważ: +C.prototype instanceof Object // true + +C.prototype = {}; +var o2 = new C(); + +o2 instanceof C; // true + +// false, ponieważ C.prototype nie ma już w łańcuchu prototypowym o +o instanceof C; + +D.prototype = new C(); // add C to [[Prototype]] linkage of D +var o3 = new D(); +o3 instanceof D; // true +o3 instanceof C; // true since C.prototype is now in o3's prototype chain +</pre> + +<p>Note that the value of an <code>instanceof</code> test can change based on changes to the <code>prototype</code> property of constructors, and it can also be changed by changing an object prototype using <code>Object.setPrototypeOf</code>. It is also possible using the non-standard <code>__proto__</code> pseudo-property.</p> + +<h3 id="instanceof_and_multiple_context_(e.g._frames_or_windows)"><code>instanceof</code> and multiple context (e.g. frames or windows)</h3> + +<p>Different scopes have different execution environments. This means that they have different built-ins (different global object, different constructors, etc.). This may result in unexpected results. For instance, <code>[] instanceof window.frames[0].Array</code> will return <code>false</code>, because <code>Array.prototype !== </code><code>window.frames[0].Array</code> and arrays inherit from the former.</p> + +<p>This may not make sense at first but when you start dealing with multiple frames or windows in your script and pass objects from one context to another via functions, this will be a valid and strong issue. For instance, you can securely check if a given object is, in fact, an Array using <code>Array.isArray(myObj)</code></p> + +<p>For example checking if a <a href="/en-US/docs/Web/API/Node">Nodes</a> is a <a href="/en-US/docs/Web/API/SVGElement">SVGElement</a> in a different context you can use <code>myNode instanceof myNode.ownerDocument.defaultView.SVGElement</code></p> + +<div class="note"><strong>Note for Mozilla developers:</strong><br> +In code using XPCOM <code>instanceof</code> has special effect: <code>obj instanceof </code><em><code>xpcomInterface</code></em> (e.g. <code>Components.interfaces.nsIFile</code>) calls <code>obj.QueryInterface(<em>xpcomInterface</em>)</code> and returns <code>true</code> if QueryInterface succeeded. A side effect of such call is that you can use <em><code>xpcomInterface</code></em>'s properties on <code>obj</code> after a successful <code>instanceof</code> test. Unlike standard JavaScript globals, the test <code>obj instanceof xpcomInterface</code> works as expected even if <code>obj</code> is from a different scope.</div> + +<h2 id="Examples">Examples</h2> + +<h3 id="Demonstrating_that_String_and_Date_are_of_type_Object_and_exceptional_cases">Demonstrating that <code>String</code> and <code>Date</code> are of type <code>Object</code> and exceptional cases</h3> + +<p>The following code uses <code>instanceof</code> to demonstrate that <code>String</code> and <code>Date</code> objects are also of type <code>Object</code> (they are derived from <code>Object</code>).</p> + +<p>However, objects created with the object literal notation are an exception here: Although the prototype is undefined, <code>instanceof Object</code> returns <code>true</code>.</p> + +<pre class="brush: js">var simpleStr = 'This is a simple string'; +var myString = new String(); +var newStr = new String('String created with constructor'); +var myDate = new Date(); +var myObj = {}; + +simpleStr instanceof String; // returns false, checks the prototype chain, finds undefined +myString instanceof String; // returns true +newStr instanceof String; // returns true +myString instanceof Object; // returns true + +myObj instanceof Object; // returns true, despite an undefined prototype +({}) instanceof Object; // returns true, same case as above + +myString instanceof Date; // returns false + +myDate instanceof Date; // returns true +myDate instanceof Object; // returns true +myDate instanceof String; // returns false +</pre> + +<h3 id="Demonstrating_that_mycar_is_of_type_Car_and_type_Object">Demonstrating that <code>mycar</code> is of type <code>Car</code> and type <code>Object</code></h3> + +<p>The following code creates an object type <code>Car</code> and an instance of that object type, <code>mycar</code>. The <code>instanceof</code> operator demonstrates that the <code>mycar</code> object is of type <code>Car</code> and of type <code>Object</code>.</p> + +<pre class="brush: js">function Car(make, model, year) { + this.make = make; + this.model = model; + this.year = year; +} +var mycar = new Car('Honda', 'Accord', 1998); +var a = mycar instanceof Car; // returns true +var b = mycar instanceof Object; // returns true +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-relational-operators', 'Relational Operators')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-relational-operators', 'Relational Operators')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.8.6', 'The instanceof operator')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-11.8.6', 'The instanceof operator')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.4.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("javascript.operators.instanceof")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof" title="/en-US/docs/JavaScript/Reference/Operators/typeof">typeof</a></code></li> + <li>{{jsxref("Symbol.hasInstance")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/operator_new/index.html b/files/pl/web/javascript/referencje/operatory/operator_new/index.html new file mode 100644 index 0000000000..e6153d3a69 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_new/index.html @@ -0,0 +1,183 @@ +--- +title: Operator new +slug: Web/JavaScript/Referencje/Operatory/Operator_new +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Operators/new +--- +<div>{{jsSidebar("Operators")}}</div> + +<p><strong>Operator</strong><strong> <code>new</code> </strong>tworzy nową instancję typu obiektu zdenifiowanego przez użytkownika lub instancję wbudowanego typu obiektu, który posiada konstruktor.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-newoperator.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">new <em>constructor</em>[([<em>arguments</em>])]</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>constructor</code></dt> + <dd>Klasa bądź funkcja, która definiuje typ obiektu instancji.</dd> +</dl> + +<dl> + <dt><code>arguments</code></dt> + <dd>Lista wartości z którymi zostanie wywołany <code>constructor</code>.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Tworzenie obiektu przez zdefiniowanego przez użytkownika przebiega w dwóch krokach:</p> + +<ol> + <li>Zdefiniowanie typu obiektu poprzez napisanie funkcji.</li> + <li>Tworzenie jego instancji przy użyciu słowa kluczowego <code>new</code>.</li> +</ol> + +<p>Aby zdefiniować typ obiektu, stwórz funkcję dla tego typu, która określa jego nazwę i właściwości. Obiekt może mieć właściwość, której wartością jest on sam lub inny obiekt. Spójrz na przykłady poniżej</p> + +<p>Kiedy wykonywaniy jest kod <code>new <em>Foo</em>(...)</code>, dzieją się następujące rzeczy:</p> + +<ol> + <li>Tworzeny jest nowy obiekt, dzidziczący po <code><em>Foo</em>.prototype</code>.</li> + <li>Wywoływany jest konstruktor <em><code>Foo</code></em> z określonymi argumentami, a kontekst <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code> zostaje przypisany do nowo utworzonego obiektu. <code>new <em>Foo</em></code> jest równoznaczne z <code>new </code><em><code>Foo</code></em><code>()</code>, tzn. w przypadku gdy lista argumentów jst nieokreślona, <em><code>Foo</code></em> jest wywoływane bez argumentów.</li> + <li>Obiekt zwrócony przez konstruktor staje się wynikiem całego wyrażenia <code>new</code>. Jeżeli konstruktor nie zwraca obiektu, obiekt stworzony w kroku 1 jest używany zamiast niego. (Zwykle kontruktory nie zwracają żadnej wartości, ale mogą tak czynić jeśli chcą nadpiać normalny proces tworzenia obiektu.)</li> +</ol> + +<p>Zawsze można dodać właściwość do wcześniej stworzonego obiektu. Na przykład, wyrażenie <code>car1.color = "black"</code> dodaje właściwość <code>color</code> do <code>car1</code>, przypisuje mu wartość "<code>black</code>". Jednakże, nie wpływa to w żaden sposób na inne obiekty. Aby dodać właściwość do wszystkich obiektów tego samego typu, trzeba dodać tę właściwość do definicji typu obiektu <code>Car</code>.</p> + +<p>Można dodać wspólną właściwość do wcześniej zdefiniowanego typu obiektu korzystając z właściwości <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype">Function.prototype</a></code>. Definiuje ona wspólną właściwość dla wszystkich obiektów tego typu, a nie charakterystyczną dla instancji typu obiektu. Następujący kod dodaje właściwość <code>color</code> o wartości <code>null</code> do wszystkich obiektów typu <code>Car</code>, a następnie znienia tę wartość tylko w obiekcie <code>car1</code> na łańcuch "<code>black</code>" . Po więcej informacji, zobacz <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype">prototype</a>.</p> + +<pre class="brush: js notranslate">function Car() {} +car1 = new Car(); + +console.log(car1.color); // undefined + +Car.prototype.color = null; +console.log(car1.color); // null + +car1.color = 'black'; +console.log(car1.color); // black +</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Typ_obiektu_i_jego_instancja">Typ obiektu i jego instancja</h3> + +<p>Przypuśćmy, że chcesz stworzyś typ obiektu dla aut. Chcesz, żeby był nazwany <code>car</code> i by miał właściwości <code>make</code>, <code>model</code> i <code>year</code>. Żeby to osiągnąć należy stworzyć następującą funkcję:</p> + +<pre class="brush: js notranslate">function Car(make, model, year) { + this.make = make; + this.model = model; + this.year = year; +} +</pre> + +<p>Teraz można stworzyć obiekt <code>mycar</code>:</p> + +<pre class="brush: js notranslate">var mycar = new Car('Eagle', 'Talon TSi', 1993); +</pre> + +<p>Powyższy kod deklaruje zmienną <code>mycar</code> i przypisuje do niej określone właściwości. Wartość <code>mycar.make</code> to łańcuch "Eagle", <code>mycar.year</code> to liczba 1993 itd.</p> + +<p>Można stworzyć nieograniczoną ilość obiektów <code>Car</code> poprzez słowo kluczowe <code>new</code>. Na przykład:</p> + +<pre class="brush: js notranslate">var kenscar = new Car('Nissan', '300ZX', 1992); +</pre> + +<h3 id="Właściwość_obiektu_będąca_innym_obiektem">Właściwość obiektu, będąca innym obiektem</h3> + +<p>Przypuśćmy, że definiujemy typ obiektu <code>Person</code> jak poniżej:</p> + +<pre class="brush: js notranslate">function Person(name, age, sex) { + this.name = name; + this.age = age; + this.sex = sex; +} +</pre> + +<p>A następnie tworzymy dwa obiekty <code>Person</code>:</p> + +<pre class="brush: js notranslate">var rand = new Person('Rand McNally', 33, 'M'); +var ken = new Person('Ken Jones', 39, 'M'); +</pre> + +<p>Teraz możemy przepisać definicję <code>Car</code> tak, by zawierała właściwość <code>owner</code>, która przyjmuje obiekt:</p> + +<pre class="brush: js notranslate">function Car(make, model, year, owner) { + this.make = make; + this.model = model; + this.year = year; + this.owner = owner; +} +</pre> + +<p>Aby utworzyć nowe obiekty, należy napisać:</p> + +<pre class="brush: js notranslate">var car1 = new Car('Eagle', 'Talon TSi', 1993, rand); +var car2 = new Car('Nissan', '300ZX', 1992, ken); +</pre> + +<p>Zamiast przekazywania wartości liczbowych lub łańcuchów znaków, w powyższym przykładzie przekazywane są obiekty: <code>rand</code> oraz <code>ken</code>. Aby uzyskać imię właściciela samochodu <code>car2</code>, należy napisać:</p> + +<pre class="brush: js notranslate">car2.owner.name +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specifikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-new-operator', 'The new Operator')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-new-operator', 'The new Operator')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.2.2', 'The new Operator')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-11.2.2', 'The new Operator')}}</td> + <td>{{Spec2('ES3')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-11.2.2', 'The new Operator')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Wstępna definicja. Zaimpelementowano w JavaScript 1.0.</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.operators.new")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Reflect.construct()")}}</li> + <li>{{jsxref("Object.prototype")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/operator_potoku/index.html b/files/pl/web/javascript/referencje/operatory/operator_potoku/index.html new file mode 100644 index 0000000000..9bc36390af --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_potoku/index.html @@ -0,0 +1,65 @@ +--- +title: Operator potoku +slug: Web/JavaScript/Referencje/Operatory/Operator_potoku +tags: + - JavaScript + - Operator + - ekxperymentalny +translation_of: Web/JavaScript/Reference/Operators/Pipeline_operator +--- +<div>{{jsSidebar("Operators")}} {{SeeCompatTable}}</div> + +<div>Eskperymentalny operator potoku <code>|></code> (obecnie na pierwszym etapie testów) pozwala na tworzenie łańcuchów wywołań funkcji w czytelny sposób. Dodaje lukier syntaktyczny do wywołania funkcji z pojedynczym argumentem, pozwalając przykładowo na pisanie <code>'%21' |> decodeURI</code> zamiast <code>decodeURI('%21')</code>.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">wyrażenie |> funkcja</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Łańcuchowe_wywołania_funkcji">Łańcuchowe wywołania funkcji</h3> + +<p>Operator potoku może poprawić czytelność kodu przy łańcuchowych wywołaniach wielu funkcji.</p> + +<pre class="brush: js">const double = (n) => n * 2; +const increment = (n) => n + 1; + +// bez operatora potoku +double(increment(double(double(5)))); // 42 + +// z użyciem potoku +5 |> double |> double |> increment |> double; // 42 +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Uwagi</th> + </tr> + </thead> + <tbody> + <tr> + <td><a href="http://tc39.github.io/proposal-pipeline-operator/">Pipeline operator draft</a></td> + <td>Stage 1</td> + <td>Nie jest jeszcze częścią specyfikacji ECMAScript.</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div> + + +<p>{{Compat("javascript.operators.pipeline")}}</p> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="https://github.com/tc39/proposals">TC39 proposals</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/operator_przecinkowy/index.html b/files/pl/web/javascript/referencje/operatory/operator_przecinkowy/index.html new file mode 100644 index 0000000000..b037dcfdc8 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_przecinkowy/index.html @@ -0,0 +1,37 @@ +--- +title: Operator przecinkowy +slug: Web/JavaScript/Referencje/Operatory/Operator_przecinkowy +tags: + - JavaScript + - Operator + - Przecinek + - Przecinkowy +translation_of: Web/JavaScript/Reference/Operators/Comma_Operator +--- +<div>{{jsSidebar("Operators")}}</div> + +<h3 id="Podsumowanie" name="Podsumowanie"></h3> + +<p>Operator przecinkowy wykonuje wszystkie argumenty i zwraca wynik ostatniego argumentu.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox notranslate"><em>wyr1</em>, <em>wyr2, wyr3...</em></pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>wyr1</code>, <code>wyr2, wyr3</code></dt> + <dd>Wyrażenia, z których jedynie ostatnie jest zwracane.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Możemy zastosować operator przecinkowy, kiedy chcemy utworzyć wyrażenie składające się z kilku wyrażeń. Operator przecinkowy jest chyba najczęściej używany w instrukcji pętli for.</p> + +<p>Na przykład, jeśli <code>a</code> jest tablicą dwuwymiarową z 10 elementami w sobie, następujący kod użyje operatora przecinkowego do zwiększenia dwóch zmiennych na raz. Kod wypisze wartości elementów ułożonych po przekątnej w tablicy:</p> + +<pre class="brush: js notranslate">var a = [[]]; +for (var i=0, j=9; i <= 9; i++, j--) + console.log("a["+i+","+j+"]= " + a[i,j]) +</pre> diff --git a/files/pl/web/javascript/referencje/operatory/operator_typeof/index.html b/files/pl/web/javascript/referencje/operatory/operator_typeof/index.html new file mode 100644 index 0000000000..dfb169a9b5 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_typeof/index.html @@ -0,0 +1,91 @@ +--- +title: Operator typeof +slug: Web/JavaScript/Referencje/Operatory/Operator_typeof +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Operators/typeof +--- +<p> </p> + +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> + +<p>Operator <code>typeof</code> używa się na jeden z poniższych sposobów:</p> + +<ol> + <li><code>typeof <em>operand</em> </code></li> + <li><code>typeof (<em>operand</em> )</code></li> +</ol> + +<p>Operator <code>typeof</code> zwraca łańcuch zawierający <span class="comment">type of unevaluated operand: jak przetłumaczyć unevaluated?</span>typ operandu. <code>operand</code> jest łańcuchem znaków, zmienną, słowem kluczowym lub obiektem, którego typ ma zostać zwrócony. Zastosowanie nawiasów jest opcjonalne.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header" colspan="2">Operator</td> + </tr> + <tr> + <td>Zaimplementowany w:</td> + <td>JavaScript 1.1</td> + </tr> + <tr> + <td>Wersja ECMA:</td> + <td>ECMA-262</td> + </tr> + </tbody> +</table> + +<p>Zakładamy, że możemy zdefiniować 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> zwróci następujący rezultat dla tych zmiennych:</p> + +<pre>typeof myFun is object +typeof shape is string +typeof size is number +typeof today is object +typeof dontExist is undefined +</pre> + +<p>Dla słów kluczowych <code>true</code> oraz <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 własności wartości, operator <code>typeof</code> zwraca typ wartości własności, jakie składają się na treść:</p> + +<pre>typeof document.lastModified is string +typeof window.length is number +typeof Math.LN2 is number +</pre> + +<p>Dla metod i 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> diff --git a/files/pl/web/javascript/referencje/operatory/operator_void/index.html b/files/pl/web/javascript/referencje/operatory/operator_void/index.html new file mode 100644 index 0000000000..65b3fe8fa2 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_void/index.html @@ -0,0 +1,51 @@ +--- +title: Operator void +slug: Web/JavaScript/Referencje/Operatory/Operator_void +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Operators/void +--- +<p> </p> + +<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3> + +<p>Operator <code>void</code> może być używany na jeden z dwóch sposobów:</p> + +<ol> + <li><code>void (<em>wyrażenie</em> )</code></li> + <li><code>void <em>wyrażenie</em> </code></li> +</ol> + +<p>Operator <code>void</code> określa wyrażenie, które ma zostać ocenione bez zwracania wartości. <code>wyrażenie</code> jest wyrażeniem JavaScript, które ma zostać ocenione. Nawiasy dookoła wyrażenia są opcjonalne, ale używanie ich jest w dobrym stylu.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header" colspan="2">Operator</td> + </tr> + <tr> + <td>Zaimplementowany w:</td> + <td>JavaScript 1.1</td> + </tr> + <tr> + <td>Wersja ECMA:</td> + <td>ECMA-262</td> + </tr> + </tbody> +</table> + +<p>Możesz użyć operatora <code>void</code>, aby określić wyrażenie jako hipertekstowy odnośnik. Wyrażenie jest oceniane, ale nie jest ładowane w miejsce aktualnego dokumentu.</p> + +<p>Poniższy kod tworzy hipertekstowy odnośnik, który nie wykonuje nic po kliknięciu go przez użytkownika. Gdy użytkownik kliknie odnośnik, void(0) zostanie oceniony jako 0, jednak nie ma to żadnego efektu w JavaScripcie.</p> + +<pre><a href="javascript:void(0)">Kliknij tutaj, żeby nic się nie stało</a> +</pre> + +<p>Poniższy kod tworzy hipertekstowy odnośnik, który wysyła formularz, gdy zostanie kliknięty przez użytkownika.</p> + +<pre><a href="javascript:void(document.form.submit())"> +Kliknij tutaj, aby wysłać.</a> +</pre> diff --git a/files/pl/web/javascript/referencje/operatory/operator_warunkowy/index.html b/files/pl/web/javascript/referencje/operatory/operator_warunkowy/index.html new file mode 100644 index 0000000000..b5b00d0aa1 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operator_warunkowy/index.html @@ -0,0 +1,34 @@ +--- +title: Operator warunkowy +slug: Web/JavaScript/Referencje/Operatory/Operator_warunkowy +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Operators/Conditional_Operator +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Operator warunkowy jest jedynym operatorem w JavaScript, który pobiera trzy argumenty. Operator jest często stosowany jako skrócenie instrukcji <code>if</code>.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<pre class="syntaxbox"><em>warunek</em> ? <em>wyr1</em> : <em>wyr2</em> </pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>warunek</code></dt> + <dd>Wyrażenie, które sprawdza czy warunek jest spełniony (<code>true</code> lub <code>false</code>).</dd> +</dl> + +<dl> + <dt><code>wyr1</code>, <code>wyr2</code></dt> + <dd>Wyrażenia z wartością jakiegoś typu.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Jeśli <code>warunek</code> jest <code>true</code>, operator zwraca wartość <code>wyr1</code>; w przeciwnym razie zwraca wartość <code>wyr2</code>. Na przykład, do wyświetlenia różnych wiadomości opartych na wartości zmiennej <code>isMember</code>, będziesz mógł zastosować poniższą instrukcję:</p> + +<pre>console.log("Opłata wynosi " + (isMember ? "$2.00" : "$10.00")); +console.log("Opłata wynosi " + (zarejestrowany == 1) ? "$2.00" : "$10.00"); +</pre> diff --git a/files/pl/web/javascript/referencje/operatory/operatory_arytmetyczne/index.html b/files/pl/web/javascript/referencje/operatory/operatory_arytmetyczne/index.html new file mode 100644 index 0000000000..8f773f525a --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operatory_arytmetyczne/index.html @@ -0,0 +1,267 @@ +--- +title: Operatory arytmetyczne +slug: Web/JavaScript/Referencje/Operatory/Operatory_arytmetyczne +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators +--- +<div> +<div>{{jsSidebar("Operators")}}</div> +</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Operatory arytmetyczne pobierają wartości liczbowe (w postaci bezpośredniej lub zmiennej) jako ich operandy i zwracają jedna, wynikową wartość liczbową. Typowymi operatorami arytmetycznymi są dodawanie (+), odejmowanie (-), mnożenie (*), i dzielenie (/). Operatory te działają tak samo jak w innych językach programowania, z wyjątkiem operatora dzielenia /, który w JavaScripcie zwraca wynik będący liczbą zmiennoprzecinkową, nie obcinając części ułamkowej, jak to się dzieje w C lub Javie.</p> + +<h2 id="Dodawanie_()">Dodawanie (+)</h2> + +<p>Operator dodawania zwraca sume operandów lub jeśli chociaż jeden operand był łańcuchem znaków, ich konkatenacje.</p> + +<h3 id="Składnia">Składnia</h3> + +<pre class="syntaxbox"><strong>Operator:</strong> x + y</pre> + +<h3 class="syntaxbox" id="Przykłady">Przykłady</h3> + +<pre><code>// Number + Number -> dodawanie +1 + 2 // 3 + +// Boolean + Number -> dodawanie +true + 1 // 2 + +// Boolean + Boolean -> dodawanie +false + false // 0 + +// Number + String -> konkatenacja +5 + "foo" // "5foo" + +// String + Boolean -> konkatenacja +"foo" + false // "foofalse" + +// String + String -> konkatenacja +"foo" + "bar" // "foobar"</code></pre> + +<h2 id="sect1"> </h2> + +<h2 id="Odejmowanie_(-)">Odejmowanie (-)</h2> + +<p>Operator odejmowania zwraca różnicę między pierwszym, a drugim operandem.</p> + +<h3 id="Składnia_2">Składnia</h3> + +<pre><strong>Operator:</strong> x - y +</pre> + +<h3 id="Przykłady_2">Przykłady</h3> + +<pre><code>5 - 3 // 2 +3 - 5 // -2 +5 - true // 4 +"foo" - 3 // NaN</code></pre> + +<p> </p> + +<h2 id="Dzielenie_()">Dzielenie (/)</h2> + +<p>Operator dzielenia zwraca iloraz operandów gdzie ten po lewej stronie jest dzielną, a ten po prawej dzielnikiem.</p> + +<h3 id="Składnia_3">Składnia</h3> + +<pre><strong>Operator:</strong> x / y +</pre> + +<h3 id="Przykłady_3">Przykłady</h3> + +<pre><code>1 / 2 // zwraca 0.5 w JavaScript +1 / 2 // zwraca 0 w Java + +1.0 / 2.0 // zwraca 0.5 zarówno w JavaScript i Java + +2.0 / 0 // zwraca Infinity w JavaScript +2.0 / 0.0 // zwraca także Infinity +2.0 / -0.0 // zwraca -Infinity in JavaScript</code></pre> + +<p> </p> + +<h2 id="Mnożenie_(*)">Mnożenie (*)</h2> + +<p>Operotor mnożenia zwraca wynik mnożenia operandów.</p> + +<h3 id="Składnia_4">Składnia</h3> + +<pre><strong>Operator:</strong> x * y +</pre> + +<h3 id="Przykłady_4">Przykłady</h3> + +<pre><code>2 * 2 // 4 +-2 * 2 // -4 +Infinity * 0 // NaN +Infinity * Infinity // Infinity +"foo" * 2 // NaN</code> +</pre> + +<h2 id="Modulo" name="Modulo"> </h2> + +<h2 id="Modulo" name="Modulo">Dzielenie modulo (%)</h2> + +<p>Operator modulo zwraca resztę z dzielenia pierwszego operandu przez drugi.</p> + +<h3 id="Składnia_5">Składnia</h3> + +<pre><strong>Operator:</strong> var1 % var2 +</pre> + +<h3 id="Przykłady_5">Przykłady</h3> + +<pre><code>12 % 5 // 2 +-1 % 2 // -1 +NaN % 2 // NaN +1 % 2 // 1 +2 % 3 // 2 +-4 % 2 // -0 +5.5 % 2 // 1.5</code></pre> + +<p> </p> + +<h2 id="Potęgowanie_(**)">Potęgowanie (**)</h2> + +<div class="overheadIndicator" style="background: #9CF49C;"> +<p><strong>Ta eksperymentalna własnośc, jest częścią propozycji specyfikacji ECMAScript 2016 (ES7).</strong><br> + Ponieważ specyfikacja tej własność i nie została oficjalnie wdrożona, przed użyciem zapoznaj się z tabelą kompatybilności dla różnych przeglądarek. Warto wspomnieć, że składnia jak i zachowanie eksperymentalnych własności mogą zmieniać się wraz ze zmianami w specyfikacji.</p> +</div> + +<p>Operator ten zwraca wynik gdzie pierwszy operand jest podstawą, a drugi wykładnikiem (<code>var1</code><sup><code>var2</code></sup>). Operator ten jest asocjacyjny co oznacza, że dopuszalne jest użycie w formie <code>a ** b ** c, co jest równe a ** (b ** c)</code>.</p> + +<h3 id="Składnia_6">Składnia</h3> + +<pre><strong>Operator:</strong> var1 ** var2 +</pre> + +<h3 id="Uwagi">Uwagi</h3> + +<p>W większości języków programowania które posiadają operator potęgowania (zwykle jako ^ lub **) jak np. PHP czy Python, ma on wyższy priorytet niż operatory jedno argumentowe (oznaczające liczbę dodatnią lub ujemną) + czy -, ale istnieją wyjątki. Np. w Bash ten operator posiada niższy priorytet niż wspomniane wcześniej + czy -.<br> + W JavaScript niemożliwe jest użycie operatorów jedno argumentowych (<code>+/-/~/!/delete/void/typeof</code>) bezpośrednio przed podstawą.</p> + +<pre><code>-2 ** 2; +// 4 w Bash, -4 w innych językach. +// W JavaScript jest to nieprawidłowa próba użycia operatora potęgowania. + + +-(2 ** 2); // -4 +5 ** -2 // 0.04</code> +</pre> + +<h3 id="Przykłady_6">Przykłady</h3> + +<pre><code>2 ** 3 // 8 +3 ** 2 // 9 +3 ** 2.5 // 15.588457268119896 +10 ** -1 // 0.1 +NaN ** 2 // NaN + +2 ** 3 ** 2 // 512 +2 ** (3 ** 2) // 512 +(2 ** 3) ** 2 // 64</code></pre> + +<p>Aby odwrócić znak zwracanej wartości:</p> + +<pre><code>-(2 ** 2) // -4</code></pre> + +<p>Sposób na wymuszenie potęgowania ujemnej liczby:</p> + +<pre><code>(-2) ** 2 // 4</code></pre> + +<h2 id="Inkrementacja" name="Inkrementacja"> </h2> + +<h2 id="Inkrementacja" name="Inkrementacja">Inkrementacja (++)</h2> + +<p>Operator inkrementacji zwiększa o 1 wartość operandu i zwraca taką wartość. </p> + +<ul> + <li>Jeśli uzyty jako przyrostek (x++), będzie działał jako postinkrementacja, czyli zwracana wartość nie będzie powiększona.</li> + <li>Jeśli użyty jako przedrostek (++x), będzie działał jako preinkrementacja, czyli zwracana wartość będzie już powiększona. </li> +</ul> + +<h3 id="Składnia_7">Składnia</h3> + +<pre><strong>Operator:</strong> x++ lub ++x +</pre> + +<h3 id="Examples">Examples</h3> + +<pre><code>// Przyrostek +var x = 3; +y = x++; // y = 3, x = 4 + +// Przedrostek +var a = 2; +b = ++a; // a = 3, b = 3</code></pre> + +<p> </p> + +<h2 id="Dekrementacja_(--)">Dekrementacja (--)</h2> + +<p>Operator dekrementacji zmniejsza o 1 wartość operandu i zwraca taką wartość.</p> + +<ul> + <li>Jeśli uzyty jako przyrostek (x--), będzie działał jako postdekrementacja, czyli zwracana wartość nie będzie pomniejszona.</li> + <li>Jeśli użyty jako przedrostek (--x), będzie działał jako predekrementacja, czyli zwracana wartość będzie już pomniejszona. </li> +</ul> + +<h3 id="Składnia_8">Składnia</h3> + +<pre><strong>Operator:</strong> x-- lub --x +</pre> + +<h3 id="Przykłady_7">Przykłady</h3> + +<pre><code>// Przyrostek +var x = 3; +y = x--; // y = 3, x = 2 + +// Przedrostek +var a = 2; +b = --a; // a = 1, b = 1</code></pre> + +<p> </p> + +<h2 id="Inkrementacja" name="Inkrementacja">Negacja (-)</h2> + +<p>Jednoargumentowy operator negacji zwraca wartość operandu ze zmienionym znakiem.</p> + +<h3 id="Składnia_9">Składnia</h3> + +<pre><strong>Operator:</strong> -x +</pre> + +<h3 id="Przykłady_8">Przykłady</h3> + +<pre><code>var x = 3; +y = -x; // y = -3, x = 3</code></pre> + +<p> </p> + +<h2 id="Inkrementacja" name="Inkrementacja">Jednoargumentowy plus (+)</h2> + +<p>Jest to jednoargumentowy operator, który transformuje inne typy zmiennych do typu Number. Jeśli dana wartość nie może zostać przetransformowana, zwracany jest typ NaN.</p> + +<h3 id="Składnia_10">Składnia</h3> + +<pre><strong>Operator:</strong> +x +</pre> + +<h3 id="Przykłady_9">Przykłady</h3> + +<pre><code>+3 // 3 ++"3" // 3 ++true // 1 ++false // 0 ++null // 0 + +var x = function(val){ + return val +} +</code>+x // NaN +</pre> diff --git a/files/pl/web/javascript/referencje/operatory/operatory_działające_na_ciągach_znaków/index.html b/files/pl/web/javascript/referencje/operatory/operatory_działające_na_ciągach_znaków/index.html new file mode 100644 index 0000000000..6087023171 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operatory_działające_na_ciągach_znaków/index.html @@ -0,0 +1,34 @@ +--- +title: Operatory działające na ciągach znaków +slug: Web/JavaScript/Referencje/Operatory/Operatory_działające_na_ciągach_znaków +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Oprócz operatorów porównania, których można używać z ciągami znaków, dostępny jest także operator konkatenacji (<code>+</code>), łączący dwie wartości tekstowe w jedną, zwracający nowy ciąg znaków stanowiący połączenie swoich operandów. Na przykład <code>"ciąg " + "znaków"</code> zwróci <code>"ciąg znaków"</code>. +</p><p>Skrócony operator przypisania <code>+=</code> może być również używany do konkatenacji ciągów znaków. Na przykład, jeśli zmienna <code>mojtekst</code> zawiera wartość "<code>alfa</code>", wyrażenie <code>mojtekst += "bet"</code> zostanie wyliczone jako "<code>alfabet</code>", a wartość ta zostanie przypisana do zmiennej <code>mojtekst</code>. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Operator</td> +</tr> +<tr> +<td>Zaimplementowany w:</td> +<td>JavaScript 1.0</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262</td> +</tr> +</tbody></table> +<p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Operators/String_Operators", "es": "es/Referencia_de_JavaScript_1.5/Operadores/String", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Op\u00e9rateurs/Op\u00e9rateurs_de_cha\u00eenes" } ) }} diff --git a/files/pl/web/javascript/referencje/operatory/operatory_pamięci/index.html b/files/pl/web/javascript/referencje/operatory/operatory_pamięci/index.html new file mode 100644 index 0000000000..5db4669011 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operatory_pamięci/index.html @@ -0,0 +1,177 @@ +--- +title: Operatory pamięci +slug: Web/JavaScript/Referencje/Operatory/Operatory_pamięci +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators/Property_Accessors +--- +<div> +<div>{{jsSidebar("Operators")}}</div> +</div> + +<p>Operatory pamięci umożliwiają dostęp do właściwości lub metod obiektu.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">object.property +object['property'] +</pre> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt, w rzeczywistości, jest <em>kojarzeniową tablicą</em> (jak <em>mapa, słownik, hash, poglądowa tabela</em>).<em> Klucze </em>w tablicy są nazwami właściwości i metod (właściwości odnoszących się do funkcji). Istnieją dwa sposoby uzyskania dostępu do właściwości: zapis z kropką lub zapis z nawiasem (operator indeksu dolnego).</p> + +<h3 id="Dot_notation" name="Dot_notation">Zapis z kropką</h3> + +<pre class="brush: js">get = object.property; +object.property = set; +</pre> + +<p><code>property</code> musi być nazwane poprawnie, według zasad JavaScript, innymi słowy: musi być sekwencją znaków alfanumerycznych (włączając w to znak podkreślenia oraz znak dolara), która nie zaczyna się od cyfry. Na przykład: <code>object.$1</code> jest poprawny, natomiast <code>object.1</code> jest nieprawidłowy.</p> + +<p>Przykład:</p> + +<pre class="brush: js">document.createElement('pre'); +</pre> + +<p>Metoda "createElement" jest wywoływana z poziomu <code>document</code>.</p> + +<pre class="brush: js" id="Bracket_notation">Zapis z nawiasem</pre> + +<pre>get = object[property_name]; +object[property_name] = set; +</pre> + +<p><code>property_name</code> jest łańcuchem znaków, nie musi być poprawnym identyfikatorem - może być zupełnie dowolny, przykładowo: "1foo", "!bar!" lub nawet " " (spacja).</p> + +<pre class="brush: js">document['createElement']('pre'); +</pre> + +<p>Mimo różnic, powyższa notacja wykonuje dokładnie to samo co zapis z kropką.</p> + +<h3 id="Nazwy_w.C5.82asno.C5.9Bci" name="Nazwy_w.C5.82asno.C5.9Bci">Nazwy właściwości</h3> + +<p>Nazwy właściwości muszą być łańcuchami. Oznacza to, że nazwy nie będące łańcuchami nie mogą być używane jako klucze w obiekcie. Dowolny obiekt nie będący łańcuchem, wliczając w to liczby, zostanie zrzutowany do obiektu string poprzez metodę {{jsxref("Object.toString", "toString()")}}.</p> + +<pre class="brush: js">var object = {}; +object['1'] = 'value'; +alert(object[1]); +</pre> + +<p>Powyższy kod wyświetla "value", ponieważ 1 został zrzutowany do '1'.</p> + +<pre class="brush: js">var foo = {unique_prop: 1}, bar = {unique_prop: 2}, object = {}; +object[foo] = 'value'; +console.log(object[bar]); +</pre> + +<p>W tym przykładzie także zostanie wypisany "value", ponieważ zarówno foo jak i bar zostały skonwertowane do tego samego łańcucha. W silniku JavaScript <a href="/pl/docs/SpiderMonkey" title="SpiderMonkey">SpiderMonkey</a>, łańcuch będzie wyglądał następująco: "{{ mediawiki.external('object Object') }}".</p> + +<h3 id="Wi.C4.85zanie_metod" name="Wi.C4.85zanie_metod">Wiązanie metod</h3> + +<p>Metoda nie jest powiązana z obiektem, którego jest metodą. Innymi słowy: <code>this</code> w metodzie nie jest ustawiony na sztywno. Nie musi on koniecznie odnosić się do obiektu zawierającego metodę. Zamiast tego <code>this</code> jest przekazywany do funkcji podczas jej wywoływania. Zajrzyj do <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_specjalne/Operator_this#Wi.C4.85zanie_metod" title="Dokumentacja_języka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_this#Wi.C4.85zanie_metod">wiązania metod</a> po więcej informacji.</p> + +<h3 id="Note_on_eval" name="Note_on_eval">Uwaga dotycząca <code>eval</code></h3> + +<p>Początkujący programiści JavaScript popełniają częsty błąd, używając <a href="/pl/docs/Dokumentacja_j%C4%99zyka_JavaScript_1.5/Funkcje/eval" title="Dokumentacja_języka_JavaScript_1.5/Funkcje/eval">eval</a> tam gdzie może być użyty zapis z nawiasem. Poniżej zaprezentowany jest przykład.</p> + +<pre class="brush: js">x = eval('document.form_name.' + strFormControl + '.value'); +</pre> + +<p><code>eval</code> jest wolno-działającą funkcją i powinien być jak najrzadziej używany. Zoptymalizowany fragment kodu brzmi:</p> + +<pre class="brush: js">x = document.form_name[strFormControl].value; +</pre> + + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-property-accessors', 'Property Accessors')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-property-accessors', 'Property Accessors')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.2.1', 'Property Accessors')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-11.2.1', 'Property Accessors')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definicja początkowa. Zaimplementowana w JavaScript 1.0.</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_również">Zobacz również</h2> + +<ul> + <li>{{jsxref("Object")}}</li> + <li>{{jsxref("Object/defineProperty")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/operatory_porównania/index.html b/files/pl/web/javascript/referencje/operatory/operatory_porównania/index.html new file mode 100644 index 0000000000..cf86515544 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operatory_porównania/index.html @@ -0,0 +1,129 @@ +--- +title: Operatory porównania +slug: Web/JavaScript/Referencje/Operatory/Operatory_porównania +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators +--- +<div>{{jsSidebar("Operators")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Operandy posiadają wartość liczbową lub łańcucha znaków. Łańcuchy znaków są porównywane w oparciu o zasady pisowni, używają wartości Unicode.</p> + +<p>Jako rezultat porównania zwracana jest wartość logiczna.</p> + +<ul> + <li>Dwa łańcuchy są równe kiedy kiedy posiadają taką sama sekwencję znaków, taką samą długość, i takie same znaki w zgodnych pozycjach.</li> + <li>Dwie liczby są równe kiedy ich wartości liczbowe (posiadają liczbę o takiej samej wartości). NaN jest różne dla wszystkich, włączając NaN. Dodatnie i ujemne zera są równe.</li> + <li>Dwa obiekty są równe jeżeli odnoszą się do tego samego obiektu .</li> + <li>Dwa operandy Boolean są równe jeżeli oba zwracają <code>true</code> lub <code>false</code>.</li> + <li>Typy Null i Undefined są <code>==</code> (lecz nie <code>===</code>).</li> +</ul> + +<p>Następująca tabela opisuje operatory porównania:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Operator</th> + <th>Opis</th> + <th>Przykłady zwracające prawdę (true)<sup>1</sup></th> + </tr> + <tr> + <td>Równy (<code>==</code>)</td> + <td>Zwraca true jeżeli operandy są równe. Jeżeli operandy nie są tego samego typu, JavaScript próbuje przekształcić operandy na odpowiedni dla porównania typ.</td> + <td> + <p><code>3 == var1<br> + "3" == var1<br> + 3 == '3'</code></p> + </td> + </tr> + <tr> + <td>Różny (<code>!=</code>)</td> + <td>Zwraca true jeżeli operandy są różne. Jeżeli dwa operandy nie są tego samego typu, JavaScript próbuje przekształcić operandy na odpowiedni dla porównania typ.</td> + <td> + <p><code>var1 != 4<br> + var1 != "3"</code></p> + </td> + </tr> + <tr> + <td>Identyczny (<code>===</code>)</td> + <td>Zwraca true jeżeli operandy są równe i tego samego typu.</td> + <td> + <p><code>3 === var1</code></p> + </td> + </tr> + <tr> + <td>Nieidentyczny (<code>!==</code>)</td> + <td>Zwraca true jeżeli operandy nie są równe i/lub nie są tego samego typu.</td> + <td> + <p><code>var1 !== 3<br> + 3 !== '3'</code></p> + </td> + </tr> + <tr> + <td>Większy niż (<code>></code>)</td> + <td>Zwraca true jeżeli lewy operand jest większy od prawego operandu.</td> + <td> + <p><code>var2 > var1</code></p> + </td> + </tr> + <tr> + <td>Większy - równy (<code>>=</code>)</td> + <td>Zwraca true jeżeli lewy operand jest większy lub równy prawemu operandowi.</td> + <td> + <p><code>var2 >= var1<br> + var1 >= 3</code></p> + </td> + </tr> + <tr> + <td>Mniejszy niż (<code><</code>)</td> + <td>Zwraca true, jeśli lewy operand jest mniejszy, niż prawy.</td> + <td> + <p><code>var1 < var2</code></p> + </td> + </tr> + <tr> + <td>Mniejszy - równy (<code><=</code>)</td> + <td>Zwraca true jeżeli lewy operand jest mniejszy lub równy prawemu operandowi.</td> + <td> + <p><code>var1 <= var2<br> + var2 <= 5</code></p> + </td> + </tr> + </tbody> +</table> + +<p><small><sup>1</sup> Te przykłady zakładają, że <code>var1</code> będzie przydzielona wartość 3 i <code>var2</code> będzie miała przydzieloną wartość 4.</small></p> + +<h2 id="U.C5.BCywanie_operator.C3.B3w_por.C3.B3wnania" name="U.C5.BCywanie_operator.C3.B3w_por.C3.B3wnania">Używanie operatorów porównania</h2> + +<p>Standardowe operatory(<code>==</code> i <code>!=</code>) porównują dwa operandy bez względu na ich typ. Operatory porównania identyczności(<code>===</code> i <code>!==</code>) dokonują porównania równości na operandach tego samego typu. Operatorów identyczności używamy jeżeli operandy muszą być określonego typu jak również wartości lub jeśli dokładny typ operandów jest ważny. W przeciwnym razie, używamy standardowych operatorów porównania, które pozwalają na porównać identyczność dwóch operandów nawet jeżeli nie są takiego samego typu.</p> + +<p>Kiedy potrzebna jest konwersja, JavaScript następująco przekształca operand Number, Boolean lub Object.</p> + +<ul> + <li>Kiedy porównujemy liczbę i łańcuch, łańcuch jest zmieniany na wartość liczbową. JavaScript próbuje przekształcić łańcuch literalny cyfr na wartość typu <code>Number</code>. Najpierw, matematyczna wartość jest wyprowadzana z łańcucha cyfrowego literału. Następnie, ta wartość jest zaokrąglana do najbliższej wartości typu <code>Number</code>.</li> + <li>If one of the operands is <code>Boolean</code>, the Boolean operand is converted to 1 if it is <code>true</code> and +0 if it is <code>false</code>.</li> + <li>If an object is compared with a number or string, JavaScript attempts to return the default value for the object. Operators attempt to convert the object to a primitive value, a <code>String</code> or <code>Number</code> value, using the <code>valueOf</code> and <code>toString</code> methods of the objects. If this attempt to convert the object fails, a runtime error is generated.</li> +</ul> + +<p>You cannot use the standard equality operator (<code>==</code>) to compare instances of <code>JSObject</code>. Use the <code>JSObject.equals</code> method for such comparisons.</p> + +<h2 id="Kompatybilno.C5.9B.C4.87_wsteczna" name="Kompatybilno.C5.9B.C4.87_wsteczna">Kompatybilność wsteczna</h2> + +<p>Zachowanie standardowych operatorów porównania (<code>==</code> i <code>!=</code>) zależy od wersji JavaScript.</p> + +<h4 id="JavaScript_1.3_i_wersje_wcze.C5.9Bniejsze" name="JavaScript_1.3_i_wersje_wcze.C5.9Bniejsze">JavaScript 1.3 i wersje wcześniejsze</h4> + +<p>You can use either the standard equality operator (<code>==</code>) or <code>JSObject.equals</code> to compare instances of <code>JSObject</code>.</p> + +<h4 id="JavaScript_1.2" name="JavaScript_1.2">JavaScript 1.2</h4> + +<p>The standard equality operators (<code>==</code> and <code>!=</code>) do not perform a type conversion before the comparison is made. Operatory identyczności (<code>===</code> i <code>!==</code>) są niedostępne.</p> + +<h4 id="JavaScript_1.1_i_wersje_wcze.C5.9Bniejsze" name="JavaScript_1.1_i_wersje_wcze.C5.9Bniejsze">JavaScript 1.1 i wersje wcześniejsze</h4> + +<p>The standard equality operators (<code>==</code> and <code>!=</code>) perform a type conversion before the comparison is made.Operatory identyczności (<code>===</code> i <code>!==</code>) są niedostępne.</p> diff --git a/files/pl/web/javascript/referencje/operatory/operatory_przypisania/index.html b/files/pl/web/javascript/referencje/operatory/operatory_przypisania/index.html new file mode 100644 index 0000000000..c389baa5d6 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/operatory_przypisania/index.html @@ -0,0 +1,74 @@ +--- +title: Operatory przypisania +slug: Web/JavaScript/Referencje/Operatory/Operatory_przypisania +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators#Assignment_operators +--- +<div>{{jsSidebar("Operators")}}</div> + +<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2> + +<p>Operator przypisania przypisuje wartość swego prawego operandu do operandu lewego.</p> + +<p>Podstawowy operator przypisania to znak równości (<code>=</code>), który przypisuje wartość prawego operandu do lewego. To znaczy, że <code>x = y</code> przypisuje wartość zmiennej <code>y</code> do zmiennej <code>x</code>. Pozostałe operatory przypisania to zwykle skróty dla operacji standardowych, jak w poniższej tabeli.</p> + +<table class="standard-table"> + <tbody> + <tr> + <th>Operator skrócony</th> + <th>Znaczenie</th> + </tr> + <tr> + <td><code>x += y</code></td> + <td><code>x = x + y</code></td> + </tr> + <tr> + <td><code>x -= y</code></td> + <td><code>x = x - y</code></td> + </tr> + <tr> + <td><code>x *= y</code></td> + <td><code>x = x * y</code></td> + </tr> + <tr> + <td><code>x /= y</code></td> + <td><code>x = x / y</code></td> + </tr> + <tr> + <td><code>x %= y</code></td> + <td><code>x = x % y</code></td> + </tr> + <tr> + <td><code>x <<= y</code></td> + <td><code>x = x << y</code></td> + </tr> + <tr> + <td><code>x >>= y</code></td> + <td><code>x = x >> y</code></td> + </tr> + <tr> + <td><code>x >>>= y</code></td> + <td><code>x = x >>> y</code></td> + </tr> + <tr> + <td><code>x &= y</code></td> + <td><code>x = x & y</code></td> + </tr> + <tr> + <td><code>x ^= y</code></td> + <td><code>x = x ^ y</code></td> + </tr> + <tr> + <td><code>x |= y</code></td> + <td><code>x = x | y</code></td> + </tr> + </tbody> +</table> + +<p> + </p><div class="noinclude"> </div> +<p></p> + +<p> </p> diff --git a/files/pl/web/javascript/referencje/operatory/pierwszeństwo_operatorów/index.html b/files/pl/web/javascript/referencje/operatory/pierwszeństwo_operatorów/index.html new file mode 100644 index 0000000000..87765f3e1a --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/pierwszeństwo_operatorów/index.html @@ -0,0 +1,336 @@ +--- +title: Pierwszeństwo operatorów +slug: Web/JavaScript/Referencje/Operatory/Pierwszeństwo_operatorów +tags: + - JavaScript + - Operator + - pierwszeństwo +translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence +--- +<div>{{jsSidebar("Operators")}}</div> + +<div></div> + +<div>Pierwszeństwo operatorów ustala kolejność, w jakiej operatory są ewaluowane. Operatory z wyższym pierwszeństwem są ewaluowane jako pierwsze.</div> + +<div></div> + +<p>Prosty przykład:</p> + +<pre class="brush: js notranslate">3 + 4 * 5 // zwraca 23 +</pre> + +<p>Operator mnożenia ("<code>*</code>") ma wyższe pierwszeństwo niż operator dodawania ("<code>+</code>") i dlatego będzie ewaluowany jako pierwszy.</p> + +<h2 id="Associativity" name="Associativity">Łączność</h2> + +<p>Łączność określa kolejność, w jakiej przetwarzane są operatory o takim samym pierwszeństwie. Przykłądowo, rozważny wyrażenie:</p> + +<pre class="syntaxbox notranslate">a OP b OP c +</pre> + +<p>Jeżeli <code>OP<sub>1</sub></code> and <code>OP<sub>2 </sub></code>mają różne poziomy pierwszeństwa operatorów (patrz tabela poniżej), operator z wyższym poziomem pierwszeństwa zostanie wykonany jako pierwszy, a kolejność zapisu nie ma znaczenia. Zwróćmy uwagę na w poniższym przykładzie, że mnożenie ma wyższy poziom pierwszeństwa i tym samym zostanie wykonane jako pierwsze, pomimo tego, że to dodawanie jest zapisane w kodzie jako pierwsze.</p> + +<pre class="notranslate">console.log(3 + 10 * 2); // wynik 23 +console.log(3 + (10 * 2)); // wynik 23 ponieważ nawiasy tutaj nie mają znaczenia +console.log((3 + 10) * 2); // wynik 26 ponieważ nawiasy zmieniają kolejność działań</pre> + +<p>Lewo-łączność (od lewej do prawej) oznacza, iż będzie ono przetworzone jako <code>(a OP b) OP c</code>, podczas gdy prawo-łączność (od prawej do lewej) oznacza, iż będzie ono zinterpretowane jako <code>a OP (b OP c)</code>. Operatory przypisania są prawo-łączne, więc możesz napisać:</p> + +<pre class="brush: js notranslate">a = b = 5; +</pre> + +<p>oczekując, że <code>a</code> i <code>b</code> otrzymają wartość 5. Wynika to z faktu, iż operator przypisania zwraca wartość, która jest przypisana. Najpierw wartość <code>b</code> ustawiana jest na 5, a następnie wartość zmiennej <code>a</code> jest ustawiana na wartość <code>b</code>.</p> + +<h2 id="Tabela" name="Tabela">Tabela</h2> + +<p>Poniższa tabela uporządkowana jest od najwyższego (19) do najniższego (0) pierwszeństwa.</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Pierwszeństwo</th> + <th>Rodzaj operatora</th> + <th>Łączność</th> + <th>Operator</th> + </tr> + <tr> + <td>19</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Grouping">Grouping</a></td> + <td>n/a</td> + <td><code>( … )</code></td> + </tr> + <tr> + <td rowspan="3">18</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors#Dot_notation">Member Access</a></td> + <td>left-to-right</td> + <td><code>… . …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors#Dot_notation">Computed Member Access</a></td> + <td>left-to-right</td> + <td><code>… [ … ]</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Special/new" title="JavaScript/Reference/Operators/Special_Operators/new_Operator">new</a> (z listą argumentów)</td> + <td>n/a</td> + <td><code>new … ( … )</code></td> + </tr> + <tr> + <td rowspan="2">17</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions" title="JavaScript/Reference/Operators/Special_Operators/function_call">Wywołanie funkcji</a></td> + <td>left-to-right</td> + <td><code>… ( <var>… </var>)</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new" title="JavaScript/Reference/Operators/Special_Operators/new_Operator">new</a> (bez listy argumentów)</td> + <td>right-to-left</td> + <td><code>new …</code></td> + </tr> + <tr> + <td rowspan="2">16</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment" title="JavaScript/Reference/Operators/Arithmetic_Operators">Postinkrementacja</a></td> + <td>n/a</td> + <td><code>… ++</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement" title="JavaScript/Reference/Operators/Arithmetic_Operators">Postdekrementacja</a></td> + <td>n/a</td> + <td><code>… --</code></td> + </tr> + <tr> + <td rowspan="9">15</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT" title="JavaScript/Reference/Operators/Logical_Operators">Negacja logiczna (NOT)</a></td> + <td>right-to-left</td> + <td><code>! …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_NOT" title="JavaScript/Reference/Operators/Bitwise_Operators">Negacja bitowa (NOT)</a></td> + <td>right-to-left</td> + <td><code>~ …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_plus" title="JavaScript/Reference/Operators/Arithmetic_Operators">Unary Plus</a></td> + <td>right-to-left</td> + <td><code>+ …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_negation" title="JavaScript/Reference/Operators/Arithmetic_Operators">Unary Negation</a></td> + <td>right-to-left</td> + <td><code>- …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment" title="JavaScript/Reference/Operators/Arithmetic_Operators">Preinkrementacja</a></td> + <td>right-to-left</td> + <td><code>++ …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement" title="JavaScript/Reference/Operators/Arithmetic_Operators">Predekrementacja</a></td> + <td>right-to-left</td> + <td><code>-- …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof" title="JavaScript/Reference/Operators/Special_Operators/typeof_Operator">typeof</a></td> + <td>right-to-left</td> + <td><code>typeof …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void" title="JavaScript/Reference/Operators/Special_Operators/void_Operator">void</a></td> + <td>right-to-left</td> + <td><code>void …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete" title="JavaScript/Reference/Operators/Special_Operators/delete_Operator">delete</a></td> + <td>right-to-left</td> + <td><code>delete …</code></td> + </tr> + <tr> + <td rowspan="3">14</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Multiplication" title="JavaScript/Reference/Operators/Arithmetic_Operators">Mnożenie</a></td> + <td>left-to-right</td> + <td><code>… * …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Division" title="JavaScript/Reference/Operators/Arithmetic_Operators">Dzielenie</a></td> + <td>left-to-right</td> + <td><code>… / …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder" title="JavaScript/Reference/Operators/Arithmetic_Operators">Reszta z dzielenia</a></td> + <td>left-to-right</td> + <td><code>… % …</code></td> + </tr> + <tr> + <td rowspan="2">13</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition" title="JavaScript/Reference/Operators/Arithmetic_Operators">Dodawanie</a></td> + <td>left-to-right</td> + <td><code>… + …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Subtraction" title="JavaScript/Reference/Operators/Arithmetic_Operators">Odejmowanie</a></td> + <td>left-to-right</td> + <td><code>… - …</code></td> + </tr> + <tr> + <td rowspan="3">12</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="JavaScript/Reference/Operators/Bitwise_Operators">Bitowe przesunięcie w lewo</a></td> + <td>left-to-right</td> + <td><code>… << …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="JavaScript/Reference/Operators/Bitwise_Operators">Bitowe przesunięcie w prawo</a></td> + <td>left-to-right</td> + <td><code>… >> …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="JavaScript/Reference/Operators/Bitwise_Operators">Bitowe przesunięcie w prawo bez znaku</a></td> + <td>left-to-right</td> + <td><code>… >>> …</code></td> + </tr> + <tr> + <td rowspan="6">11</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Mniejsze niż</a></td> + <td>left-to-right</td> + <td><code>… < …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than__or_equal_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Mniejsze lub równe</a></td> + <td>left-to-right</td> + <td><code>… <= …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Greater_than_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Większe niż</a></td> + <td>left-to-right</td> + <td><code>… > …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Greater_than_or_equal_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Większe lub równe</a></td> + <td>left-to-right</td> + <td><code>… >= …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/in" title="JavaScript/Reference/Operators/Special_Operators/in_Operator">in</a></td> + <td>left-to-right</td> + <td><code>… in …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof" title="JavaScript/Reference/Operators/Special_Operators/instanceof_Operator">instanceof</a></td> + <td>left-to-right</td> + <td><code>… instanceof …</code></td> + </tr> + <tr> + <td rowspan="4">10</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Equality" title="JavaScript/Reference/Operators/Comparison_Operators">Równość</a></td> + <td>left-to-right</td> + <td><code>… == …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Inequality" title="JavaScript/Reference/Operators/Comparison_Operators">Nierówność</a></td> + <td>left-to-right</td> + <td><code>… != …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Identity" title="JavaScript/Reference/Operators/Comparison_Operators">Ścisła równość</a></td> + <td>left-to-right</td> + <td><code>… === …</code></td> + </tr> + <tr> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Nonidentity" title="JavaScript/Reference/Operators/Comparison_Operators">Ścisła nierówność</a></td> + <td>left-to-right</td> + <td><code>… !== …</code></td> + </tr> + <tr> + <td>9</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_AND" title="JavaScript/Reference/Operators/Bitwise_Operators">Koniunkcja bitowa (AND)</a></td> + <td>left-to-right</td> + <td><code>… & …</code></td> + </tr> + <tr> + <td>8</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR" title="JavaScript/Reference/Operators/Bitwise_Operators">Bitowa alternatywa wykluczająca (XOR)</a></td> + <td>left-to-right</td> + <td><code>… ^ …</code></td> + </tr> + <tr> + <td>7</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_OR" title="JavaScript/Reference/Operators/Bitwise_Operators">Alternatywa bitowa (OR)</a></td> + <td>left-to-right</td> + <td><code>… | …</code></td> + </tr> + <tr> + <td>6</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_AND" title="JavaScript/Reference/Operators/Logical_Operators">Koniunkcja logiczna (AND)</a></td> + <td>left-to-right</td> + <td><code>… && …</code></td> + </tr> + <tr> + <td>5</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR" title="JavaScript/Reference/Operators/Logical_Operators">Alternatywa logiczna (OR)</a></td> + <td>left-to-right</td> + <td><code>… || …</code></td> + </tr> + <tr> + <td>4</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator" title="JavaScript/Reference/Operators/Special_Operators/Conditional_Operator">Warunek</a></td> + <td>right-to-left</td> + <td><code>… ? … : …</code></td> + </tr> + <tr> + <td rowspan="12">3</td> + <td rowspan="12"><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators" title="JavaScript/Reference/Operators/Assignment_Operators">Przypisanie</a></td> + <td rowspan="12">right-to-left</td> + <td><code>… = …</code></td> + </tr> + <tr> + <td><code>… += …</code></td> + </tr> + <tr> + <td><code>… -= …</code></td> + </tr> + <tr> + <td><code>… *= …</code></td> + </tr> + <tr> + <td><code>… /= …</code></td> + </tr> + <tr> + <td><code>… %= …</code></td> + </tr> + <tr> + <td><code>… <<= …</code></td> + </tr> + <tr> + <td><code>… >>= …</code></td> + </tr> + <tr> + <td><code>… >>>= …</code></td> + </tr> + <tr> + <td><code>… &= …</code></td> + </tr> + <tr> + <td><code>… ^= …</code></td> + </tr> + <tr> + <td><code>… |= …</code></td> + </tr> + <tr> + <td>2</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield" title="JavaScript/Reference/Operators/yield">yield</a></td> + <td>right-to-left</td> + <td><code>yield …</code></td> + </tr> + <tr> + <td>1</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator" title="JavaScript/Reference/Operators/Spread_operator">Spread</a></td> + <td>n/a</td> + <td><code>...</code> …</td> + </tr> + <tr> + <td>0</td> + <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator" title="JavaScript/Reference/Operators/Comma_Operator">Comma / Sequence</a></td> + <td>left-to-right</td> + <td><code>… , …</code></td> + </tr> + </tbody> +</table> diff --git a/files/pl/web/javascript/referencje/operatory/składnia_rozwinięcia/index.html b/files/pl/web/javascript/referencje/operatory/składnia_rozwinięcia/index.html new file mode 100644 index 0000000000..a45d730722 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/składnia_rozwinięcia/index.html @@ -0,0 +1,244 @@ +--- +title: Składnia rozwinięcia +slug: Web/JavaScript/Referencje/Operatory/Składnia_rozwinięcia +translation_of: Web/JavaScript/Reference/Operators/Spread_syntax +--- +<div>{{jsSidebar("Operators")}}</div> + +<div><strong>Składnia rozwinięcia</strong> (ang. <em>spread syntax</em>) pozwala na rozwinięcie iterowalnego wyrażenia, takiego jak wyrażenie tablicowe lub ciąg znaków, tam gdzie oczekiwanych jest zero lub więcej argumentów (dla wywołań funkcji) lub elementów (dla literałów tablicowych). Pozwala również na rozwinięcie wyrażeń obiektowych w miejscach, gdzie oczekiwanych jest zero lub więcej par klucz-wartość (dla literałów obiektowych).</div> + +<div> </div> + +<div>{{EmbedInteractiveExample("pages/js/expressions-spreadsyntax.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<p>Dla wywołań funkcji:</p> + +<pre class="syntaxbox">mojaFunkcja(...iterowalnyObiekt); +</pre> + +<p>Dla literałów tablicowych lub łańcuchów znaków:</p> + +<pre class="syntaxbox">[...iterowalnyObiekt, '3', 'cztery', 5];</pre> + +<p>Dla literałów obiektowych (nowe w ECMAScript 2018):</p> + +<pre class="syntaxbox">let klonObiektu = { ...obiekt };</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Rozwinięcie_w_wywołaniach_funkcji">Rozwinięcie w wywołaniach funkcji</h3> + +<h4 id="Zastąpienie_apply">Zastąpienie <code>apply</code></h4> + +<p>Powszechne jest używanie {{jsxref( "Function.prototype.apply")}} w przypadkach, w których chcemy użyć elementów tablicy jako argumentów funkcji.</p> + +<pre class="brush: js">function mojaFunkcja(x, y, z) { } +var argumenty = [0, 1, 2]; +mojaFunkcja.apply(null, argumenty);</pre> + +<p>Przy użyciu operatora rozpakowania można to zapisać jako:</p> + +<pre class="brush: js">function mojaFunkcja(x, y, z) { } +var argumenty = [0, 1, 2]; +mojaFunkcja(...argumenty);</pre> + +<p>Każdy argument na liście argumentów może użyć operatora rozpakowania, można go także używać wielokrotnie.</p> + +<pre class="brush: js">function mojaFunkcja(v, w, x, y, z) { } +var argumenty = [0, 1]; +mojaFunkcja(-1, ...argumenty, 2, ...[3]);</pre> + +<h4 id="Apply_for_new">Apply for new</h4> + +<p>When calling a constructor with <code>new</code>, it's not possible to <strong>directly</strong> use an array and <code>apply</code> (<code>apply</code> does a <code>[[Call]]</code> and not a <code>[[Construct]]</code>). However, an array can be easily used with <code>new</code> thanks to spread syntax:</p> + +<pre class="brush: js">var dateFields = [1970, 0, 1]; // 1 Jan 1970 +var d = new Date(...dateFields); +</pre> + +<p>To use new with an array of parameters without spread syntax, you would have to do it <strong>indirectly</strong> through partial application:</p> + +<pre class="brush: js">function applyAndNew(constructor, args) { + function partial () { + return constructor.apply(this, args); + }; + if (typeof constructor.prototype === "object") { + partial.prototype = Object.create(constructor.prototype); + } + return partial; +} + + +function myConstructor () { + console.log("arguments.length: " + arguments.length); + console.log(arguments); + this.prop1="val1"; + this.prop2="val2"; +}; + +var myArguments = ["hi", "how", "are", "you", "mr", null]; +var myConstructorWithArguments = applyAndNew(myConstructor, myArguments); + +console.log(new myConstructorWithArguments); +// (internal log of myConstructor): arguments.length: 6 +// (internal log of myConstructor): ["hi", "how", "are", "you", "mr", null] +// (log of "new myConstructorWithArguments"): {prop1: "val1", prop2: "val2"}</pre> + +<h3 id="Rozwinięcie_w_literałach_tablicowych">Rozwinięcie w literałach tablicowych</h3> + +<h4 id="Potężniejszy_literał_tablicowy">Potężniejszy literał tablicowy</h4> + +<p>Bez składni rozwinięcia, aby utworzyć nową tablicę, używając tablicy już istniejącej jako jej części, składnia literału tablicowego nie jest już wystarczająca i musimy użyć kodu imperatywnego, używając kombinacji <code>push</code>, <code>splice</code>, <code>concat</code> itd. Z użyciem składni rozwinięcia staje się to o wiele prostsze i bardziej zwięzłe:</p> + +<pre class="brush: js">var czesci = ['kotek', 'na', 'plotek']; +var wierszyk = ['wlazl', ...czesci, 'i', 'mruga']; +// ["wlazl", "kotek", "na", "plotek", "i", "mruga"] +</pre> + +<p>Tak jak dla list argumentów w wywołaniach funkcji, operator <code>...</code> może być użyty wielokrotnie i w każdym miejscu literału tablicowego.</p> + +<h4 id="Kopia_tablicy">Kopia tablicy</h4> + +<pre class="brush: js">var tab = [1, 2, 3]; +var tab2 = [...tab]; // jak tab.slice() +tab2.push(4); + +// tab2 staje się [1, 2, 3, 4] +// tab pozostaje niezmieniona +</pre> + +<p><strong>Uwaga:</strong> Składnia rozwinięcia skutecznie sięga tylko na jeden poziom wgłąb przy kopiowaniu tablicy. W związku z tym takie podejście może być nieodpowiednie przy kopiowaniu tablic wielowymiarowych, jak pokazuje poniższy przykład (tak samo jest z {{jsxref("Object.assign()")}} i kładnią rozwinięcia).</p> + +<pre class="brush: js">var a = [[1], [2], [3]]; +var b = [...a]; +b.shift().shift(); // 1 +// Tablica a została zmodyfikowana: [[], [2], [3]] +</pre> + +<h4 id="Lepszy_sposób_na_łączenie_tablic">Lepszy sposób na łączenie tablic</h4> + +<p>{{jsxref("Array.concat")}} jest często używane do dołączania elementów jednej tablicy na koniec drugiej. Bez składni rozwinięcia wygląda to tak:</p> + +<pre class="brush: js">var tab1 = [0, 1, 2]; +var tab2 = [3, 4, 5]; +// Dołącz wszystkie elementy tab2 na koniec tab1 +tab1 = tab1.concat(tab2);</pre> + +<p>Przy użyciu składni rozwinięcia wygląda to natomiast tak:</p> + +<pre class="brush: js">var tab1 = [0, 1, 2]; +var tab2 = [3, 4, 5]; +tab1 = [...tab1, ...tab2]; +</pre> + +<p>{{jsxref("Array.unshift")}} jest często używane do dołączania elementów jednej tablicy na początek drugiej. Bez składni rozwinięcia wygląda to w następujący sposób:</p> + +<pre class="brush: js">var tab1 = [0, 1, 2]; +var tab2 = [3, 4, 5]; +// Dodaj wszystkie elementy tab2 na początek tab1 +Array.prototype.unshift.apply(tab1, tab2) // tab1 staje się [3, 4, 5, 0, 1, 2]</pre> + +<p>Przy użyciu składni rozwinięcia otrzymuje to następującą postać [jednak zauważ, że w tym przypadku utworzona zostaje nowa tablica <code>tab1</code> – w odróżnieniu od {{jsxref("Array.unshift")}}, <code>tab1</code> nie jest automatycznie modyfikowana):</p> + +<pre class="brush: js">var tab1 = [0, 1, 2]; +var tab2 = [3, 4, 5]; +tab1 = [...tab2, ...tab1]; // tab1 staje się [3, 4, 5, 0, 1, 2] +</pre> + +<h3 id="Rozwinięcie_w_literałach_tablicowych_2">Rozwinięcie w literałach tablicowych</h3> + +<p>The <a href="https://github.com/tc39/proposal-object-rest-spread">Rest/Spread Properties for ECMAScript</a> proposal (stage 4) adds spread properties to <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">object literals</a>. It copies own enumerable properties from a provided object onto a new object.</p> + +<p>Shallow-cloning (excluding prototype) or merging of objects is now possible using a shorter syntax than {{jsxref("Object.assign()")}}.</p> + +<pre class="brush: js">var obj1 = { foo: 'bar', x: 42 }; +var obj2 = { foo: 'baz', y: 13 }; + +var clonedObj = { ...obj1 }; +// Object { foo: "bar", x: 42 } + +var mergedObj = { ...obj1, ...obj2 }; +// Object { foo: "baz", x: 42, y: 13 }</pre> + +<p>Note that {{jsxref("Object.assign()")}} triggers <a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setters</a> whereas spread syntax doesn't.</p> + +<p>Note that you cannot replace nor mimic the {{jsxref("Object.assign()")}} function:</p> + +<pre class="brush: js">var obj1 = { foo: 'bar', x: 42 }; +var obj2 = { foo: 'baz', y: 13 }; +const merge = ( ...objects ) => ( { ...objects } ); + +var mergedObj = merge ( obj1, obj2); +// Object { 0: { foo: 'bar', x: 42 }, 1: { foo: 'baz', y: 13 } } + +var mergedObj = merge ( {}, obj1, obj2); +// Object { 0: {}, 1: { foo: 'bar', x: 42 }, 2: { foo: 'baz', y: 13 } }</pre> + +<p>In the above example, the spread syntax does not work as one might expect: it spreads an <em>array</em> of arguments into the object literal, due to the rest parameter.</p> + +<h3 id="Tylko_dla_obiektów_iterowalnych">Tylko dla obiektów iterowalnych</h3> + +<p>Składnia rozwinięcia może być użyta jedynie dla obiektów<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator"> iterowalnych</a>:</p> + +<pre class="brush: js">var obiekt = {'klucz1': 'wartosc1'}; +var tablica = [...obiekt]; // TypeError: obiekt is not iterable +</pre> + +<h3 id="Rozwinięcie_z_wieloma_wartościami">Rozwinięcie z wieloma wartościami</h3> + +<p>Kiedy używaż składni rozwinięcia do wywołań funkcji, musisz być świadomy możliwości przekroczenia limitu liczby argumentów w silniku JavaScript. Po więcej szczegółów zajrzyj do <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Function/apply" title="The apply() method calls a function with a given this value, and arguments provided as an array (or an array-like object)."><code>apply()</code>.</a></p> + +<h2 id="Składnia_reszty_(parametry)">Składnia reszty (parametry)</h2> + +<p>Składnia reszty ang. <em>rest syntax</em>) wygląda dokładnie jak składnia rozwinięcia, ale jest używana do destrukturyzacji tablic i obiektów. W pewnym sensie składnia reszty jest przeciwieństwem składni rozpakowania: rozwinięcie „rozpakowuje” elementy tablicy, natomiast składnia reszty „zbiera” wiele elementów i „pakuje” je do pojedynczego elementu. Zobacz: <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">rest parameters.</a></p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#sec-array-initializer')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer">Array Initializer</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-argument-lists">Argument Lists</a></td> + </tr> + <tr> + <td>{{SpecName('ES2018', '#sec-object-initializer')}}</td> + <td>{{Spec2('ES2018')}}</td> + <td>Defined in <a href="http://www.ecma-international.org/ecma-262/9.0/#sec-object-initializer">Object Initializer</a></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array-initializer')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>No changes.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object-initializer')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>No changes.</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.operators.spread")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">Rest parameters</a> (również ‘<code>...</code>’)</li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply">fn.apply</a> (również ‘<code>...</code>’)</li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/spread_operator/index.html b/files/pl/web/javascript/referencje/operatory/spread_operator/index.html new file mode 100644 index 0000000000..1479eb441c --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/spread_operator/index.html @@ -0,0 +1,229 @@ +--- +title: Spread syntax +slug: Web/JavaScript/Referencje/Operatory/Spread_operator +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Operator Rozwinięcia +translation_of: Web/JavaScript/Reference/Operators/Spread_syntax +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Operator spread umożliwia rozwinięcie wyrażenia. <strong>Składnia rozwinięcia</strong> pozwala na rozwinięcie wyrażenia w miejscach, w których potrzebne jest wiele argumentów (do wywołań funkcji), wiele elementów (do literałów tablicowych) lub wiele zmiennych ().</p> + +<h2 id="Składnia">Składnia</h2> + +<p>Do wywołań funkcji:</p> + +<pre class="brush: js">mojaFunkcja(...iterowalnyObiekt); +</pre> + +<p>Do literałów tablicowych:</p> + +<pre class="brush: js">[...iterowalnyObiekt, 4, 5, 6]</pre> + +<p> </p> + +<p>Do przypisań destrukturyzujących:</p> + +<pre class="brush: js">var [glowa, ...ogon] = [1, 2, 3, 4]</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Lepsze_zastosowanie">Lepsze zastosowanie</h3> + +<p><strong>Przykład:</strong> powszechne jest użycie {{jsxref( "Function.prototype.apply")}} w przypadkach, gdy chcesz użyć tablic jako argumentów funkcji.</p> + +<pre class="brush: js">function mojaFunkcja(x, y, z) { } +var args = [0, 1, 2]; +mojaFunkcja.apply(null, args);</pre> + +<p>Ze składnią rozwinięcia (spread) ES2015 powyższy kod można zapisać jako:</p> + +<pre class="brush: js">function mojaFunkcja(x, y, z) { } +var args = [0, 1, 2]; +mojaFunkcja(...args);</pre> + +<p>Dowolny argument w liście argumentów może użyć składni rozwinięcia i może być użyty wiele razy.</p> + +<pre class="brush: js">function myFunction(v, w, x, y, z) { } +var args = [0, 1]; +myFunction(-1, ...args, 2, ...[3]);</pre> + +<h3 id="Potężniejszy_literał_tablicowy">Potężniejszy literał tablicowy</h3> + +<p><strong>Przykład:</strong> Jeżeli masz tablicę i chcesz utworzyć nową tablicę z tą tablicą jako jej częścią, składnia literału tablicowego nie jest już wystarczająca i należy cofnąć się do programowania imperatywnego, użyć kombinacji <code>push</code>, <code>splice</code>, <code>concat</code>, itp. Z użyciem składni rozwinięcia wygląda to dużo prościej:</p> + +<pre class="brush: js">var czesci = ['ramiona', 'kolana']; +var rymowanka = ['glowa', ...czesci, 'i', 'palce']; // <span class="objectBox objectBox-array"><a class="objectLink "><span class="arrayLeftBracket">[</span></a><span class="objectBox objectBox-string">"glowa"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"</span></span>ramiona<span class="objectBox objectBox-array"><span class="objectBox objectBox-string">"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"kolana"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"i"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"palce"</span></span>] +</pre> + +<p>Tak samo jak rozwinięcie może być użyte do list argumentów, <code>...</code> mogą być użyte wszędzie w literale tablicowym, także wiele razy.</p> + +<h3 id="Zastosowanie_z_new">Zastosowanie z new</h3> + +<p><strong>Przykład:</strong> W ES5 nie jest możliwa kompozycja <code>new</code> z <code>apply.</code> (W ES5, <code>apply</code> wykonuje <code>[[Call]]<font face="Open Sans, arial, x-locale-body, sans-serif"><span style="background-color: #ffffff;">, a nie </span></font></code><code>[[Construct]].</code>) W ES2015 składnia rozwinięcia wygląda następująco:</p> + +<pre class="brush: js">var daty = czytajDaty(bazaDanych); +var d = new Date(...daty);</pre> + +<h3 id="Kopiowanie_tablicy">Kopiowanie tablicy</h3> + +<pre class="brush: js">var tablica = [1,2,3]; +var tablica2 = [...tablica]; // jak tablica.slice() +tablica2.push(4); // tablica2 staje się [1,2,3,4], tablica pozostaje niezmieniona + +</pre> + +<h3 id="Ulepszone_push">Ulepszone push</h3> + +<p><strong>Przykład:</strong> {{jsxref("Global_Objects/Array/push", "push")}} jest często używany, by dodać tablicę na koniec innej tablicy. W ES5 jest to często osiągane przez:</p> + +<pre class="brush: js">var tablica1 = [0, 1, 2]; +var tablica2 = [3, 4, 5]; +// Dodaj wszystkie elementy z tablica2 do tablica1 +Array.prototype.push.apply(tablica1, tablica2);</pre> + +<p>W ES2015 z rozwinięciem wygląda to następująco:</p> + +<pre class="brush: js">var tablica1 = [0, 1, 2]; +var tablica2 = [3, 4, 5]; +tablica1.push(...tablica2);</pre> + +<h3 id="Użycie_jedynie_dla_obiektów_iterowalnych">Użycie jedynie dla obiektów iterowalnych</h3> + +<pre class="brush: js">var obiekt = {"klucz1":"wartosc1"}; +function mojaFunkcja(x) { + /* ... */ +} +// proba rozwinięcia nieiterowalnego elementu +// spowoduje błąd +mojaFunkcja(...obiekt); +var args = [...obiekt]; +// TypeError: obiekt is not iterable</pre> + +<h2 id="Operator_reszty">Operator reszty</h2> + +<p>Operator reszty, który wygląda dokładnie jak składnia rozwinięcia (spread), jest używany do destrukturyzacji obiektów i tablic. W pewnym stopniu, elementy reszty są przeciwieństwem elementów rozwinięcia: rozwinięcie 'rozbija' tablicę na elementy, natomiast reszta zbiera wiele elementów i 'zwija' je w jeden element.</p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Stan</th> + <th scope="col">Komentasz</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#sec-array-initializer')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Zdefiniowany w kilku sekcjach specyfikacji: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer">Array Initializer</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-argument-lists">Argument Lists</a></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array-initializer')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funkcja</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Operacja rozwinięcia w literałach tablicowych</td> + <td>{{CompatChrome("46")}}</td> + <td>{{ CompatGeckoDesktop("16") }}</td> + <td>{{CompatIE("Edge")}}</td> + <td>{{CompatNo}}</td> + <td>7.1</td> + </tr> + <tr> + <td>Operacja rozwinięcia w wywołaniach funkcji</td> + <td>{{CompatChrome("46")}}</td> + <td>{{ CompatGeckoDesktop("27") }}</td> + <td>{{CompatIE("Edge")}}</td> + <td>{{CompatNo}}</td> + <td>7.1</td> + </tr> + <tr> + <td>Operacja rozwinięcia w destrukturyzacji</td> + <td>{{CompatChrome("49")}}</td> + <td>{{ CompatGeckoDesktop("34") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funkcja</th> + <th>Android</th> + <th>Android Webview</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Operacja rozwinięcia w literałach tablicowych</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("46")}}</td> + <td>{{ CompatGeckoMobile("16") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + <td>{{CompatChrome("46")}}</td> + </tr> + <tr> + <td>Operacja rozwinięcia w wywołaniach funkcji</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("46")}}</td> + <td>{{ CompatGeckoMobile("27") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + <td>{{CompatChrome("46")}}</td> + </tr> + <tr> + <td>Operacja rozwinięcia w destrukturyzacji</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoDesktop("34") }}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">Parametry reszty</a></li> + <li><a href="http://exploringjs.com/es6/ch_destructuring.html#sec_rest-operator">Operator reszty</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/super/index.html b/files/pl/web/javascript/referencje/operatory/super/index.html new file mode 100644 index 0000000000..c217af33e9 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/super/index.html @@ -0,0 +1,171 @@ +--- +title: super +slug: Web/JavaScript/Referencje/Operatory/super +translation_of: Web/JavaScript/Reference/Operators/super +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Słowo kluczowe <strong>super </strong>jest wykorzystywane do udostępniania i korzystania z funkcji klasy po której nasz obiekt dziedziczy.</p> + +<p>Wyrażenia <code>super.prop</code> i <code>super[expr]</code> są poprawne w każdej definicji metody zarówno w <a href="/pl/docs/Web/JavaScript/Reference/Classes">klasach</a> i <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">literałach obiektowych</a>.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">super([arguments]); // wywołuje konstruktor klasy rodzica +super.functionOnParent([arguments]); +</pre> + +<h2 id="Opis">Opis</h2> + +<p>W przypadku użycia w konstruktorze, słowo kluczowe <code>super</code> pojawia się samodzielnie i musi zostać użyte przed użyciem słowa kluczowego <code>this</code> . Słowo kluczowe <code>super</code> można również wykorzystać do wywoływania funkcji które nasz obiekt odziedziczył po swoim rodzicu.</p> + +<h2 id="Przykład">Przykład</h2> + +<h3 id="Użycie_super_w_klasach">Użycie <code>super</code> w klasach</h3> + +<p>Poniższy snippet został pobrany z <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">próbki klasy</a> (live demo). W tym przykładzie, super() jest wywoływane w celu uniknięcia powielania tych części konstruktora, które są wspólne zarówno dla <code>Rectangle</code> (trójkąta) jak i <code>Square</code> (kwadratu).</p> + +<pre class="brush: js notranslate">class Rectangle { + constructor(height, width) { + this.name = 'Rectangle'; + this.height = height; + this.width = width; + } + sayName() { + console.log('Hi, I am a ', this.name + '.'); + } + get area() { + return this.height * this.width; + } + set area(value) { + this._area = value; + } +} + +class Square extends Rectangle { + constructor(length) { + this.height; // ReferenceError, super needs to be called first! + + // Wywołanie konstruktora klasy nadrzędnej + // określenie szerokości i wysokości prostokąta + super(length, length); + // Uwaga: W pochodnych klasach, super() musi być wywołane wcześniej niż + // pierwsze użycie 'this'. W przeciwnym wypadku pojawi się błąd odniesienia. + this.name = 'Square'; + } +}</pre> + +<h3 id="Super-wywołanie_metod_statycznych">Super-wywołanie metod statycznych</h3> + +<p>Za pomocą <code>super</code> jesteś w stanie także wywołać metody statyczne.</p> + +<pre class="brush: js notranslate">class Rectangle { + constructor() {} + static logNbSides() { + return 'I have 4 sides'; + } +} + +class Square extends Rectangle { + constructor() {} + static logDescription() { + return super.logNbSides() + ' which are all equal'; + } +} +Square.logDescription(); // 'I have 4 sides which are all equal' +</pre> + +<h3 id="Usuwanie_właściwości_z_super_wyrzuci_błąd">Usuwanie właściwości z super wyrzuci błąd</h3> + +<p>Nie możesz użyć <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operator_delete">operatora usuwania</a> oraz <code>super.prop</code> bądź <code>super[expr]</code> w celu usunięcia właściwości klasy rodzica ponieważ zostanie zwrócony błąd {{jsxref("ReferenceError")}}.</p> + +<pre class="brush: js notranslate">class Base { + constructor() {} + foo() {} +} +class Derived extends Base { + constructor() {} + delete() { + delete super.foo; // to jest niepoprawnie + } +} + +new Derived().delete(); // ReferenceError: invalid delete involving 'super'. </pre> + +<h3 id="super.prop_nie_może_nadpisać_właściwości_typu_non-writable"><code>super.prop</code> nie może nadpisać właściwości typu non-writable </h3> + +<p>Definiując właściwości non-writable (niezapisywalne) np. {{jsxref("Object.defineProperty")}}, pamiętaj, że <code>super</code> nie może nadpisać takiej wartości.</p> + +<pre class="brush: js notranslate">class X { + constructor() { + Object.defineProperty(this, 'prop', { + configurable: true, + writable: false, + value: 1 + }); + } +} + +class Y extends X { + constructor() { + super(); + } + foo() { + super.prop = 2; // Nie można nadpisać wartości + } +} + +var y = new Y(); +y.foo(); // TypeError: "prop" is read-only +console.log(y.prop); // 1 +</pre> + +<h3 id="Używanie_super.prop_w_literałach_obiektowych">Używanie <code>super.prop</code> w literałach obiektowych</h3> + +<p><code>super</code> może być także wykorzystane <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">inicjalizatorze / literale obiektu</a>.</p> + +<p>W tym przykładzie dwa obiekty definiują swoją metodę. W drugim obiekcie, <code>super</code> wywołuje metodę obiektu pierwszego. To działa dzięki {{jsxref("Object.setPrototypeOf()")}} z czym jesteśmy w stanie ustawić prototyp obiektu <code>obj2</code> na <code>obj1</code>, tak aby <code>super</code><span> było w stanie znaleźć metodę </span><code>method1</code><span> </span>w obiekcie <code>obj1</code><span>. </span></p> + +<pre class="brush: js notranslate">var obj1 = { + method1() { + console.log('method 1'); + } +} + +var obj2 = { + method2() { + super.method1(); + } +} + +Object.setPrototypeOf(obj2, obj1); +obj2.method2(); // wypisze "method 1" +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-super-keyword', 'super')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność">Kompatybilność</h2> + + + +<p>{{Compat("javascript.operators.super")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Reference/Classes">Classes</a></li> + <li><a href="https://medium.com/beginners-guide-to-mobile-web-development/super-and-extends-in-javascript-es6-understanding-the-tough-parts-6120372d3420">Anurag Majumdar - Super & Extends in JavaScript</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/this/index.html b/files/pl/web/javascript/referencje/operatory/this/index.html new file mode 100644 index 0000000000..523e210cb6 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/this/index.html @@ -0,0 +1,346 @@ +--- +title: this +slug: Web/JavaScript/Referencje/Operatory/this +translation_of: Web/JavaScript/Reference/Operators/this +--- +<div> +<div>{{jsSidebar("Operators")}}</div> +</div> + +<h2 id="Summary">Summary</h2> + +<p>W JavaScript słówko kluczowe <code>this</code> zachowuje się nieco inaczej w porównaniu do innych języków programowania. Istnieje również kilka różnic między trybem <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">strict mode</a> oraz non-strict mode.</p> + +<p>W większości przypadków wartość <code>this</code> jest ustalana na podstawie tego, jak wywołana została dana funkcja. Wartość ta nie może być przypisana podczas wykonywania się funkcji i może być inna za każdym wywołaniem. ES5 wprowadziło metodę <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">bind</a></code> dzięki której <a href="#The_bind_method">możemy przypisać wartość <code>this</code> w funkcji, niezależnie od tego jak została ona wywołana.</a></p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">this</pre> + +<h2 id="Global_context">Global context</h2> + +<p>In the global execution context (outside of any function), <code>this</code> refers to the global object, whether in strict mode or not.</p> + +<pre class="brush:js">console.log(this.document === document); // true + +// In web browsers, the window object is also the global object: +console.log(this === window); // true + +this.a = 37; +console.log(window.a); // 37 +</pre> + +<h2 id="Function_context">Function context</h2> + +<p>Inside a function, the value of <code>this</code> depends on how the function is called.</p> + +<h3 id="Simple_call">Simple call</h3> + +<pre class="brush:js">function f1(){ + return this; +} + +f1() === window; // global object +</pre> + +<p>In this case, the value of <code>this</code> is not set by the call. Since the code is not in strict mode, the value of <code>this</code> must always be an object so it defaults to the global object.</p> + +<pre class="brush:js">function f2(){ + "use strict"; // see strict mode + return this; +} + +f2() === undefined; +</pre> + +<p>In strict mode, the value of <code>this</code> remains at whatever it's set to when entering the execution context. If it's not defined, it remains undefined. It can also be set to any value, such as <code>null</code> or <code>42</code> or <code>"I am not this"</code>.</p> + +<div class="note"><strong>Note:</strong> In the second example, <code>this</code> should be <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a>, because <code>f2</code> was called without providing any base (e.g. <code>window.f2()</code>). This feature wasn't implemented in some browsers when they first started to support <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode" title="Strict mode">strict mode</a>. As a result, they incorrectly returned the <code>window</code> object.</div> + +<h3 id="As_an_object_method">As an object method</h3> + +<p>When a function is called as a method of an object, its <code>this</code> is set to the object the method is called on.</p> + +<p>In the following example, when <code>o.f()</code> is invoked, inside the function <code>this</code> is bound to the <code>o</code> object.</p> + +<pre class="brush:js">var o = { + prop: 37, + f: function() { + return this.prop; + } +}; + +console.log(o.f()); // logs 37 +</pre> + +<p>Note that this behavior is not at all affected by how or where the function was defined. In the previous example, we defined the function inline as the <code>f</code> member during the definition of <code>o</code>. However, we could have just as easily defined the function first and later attached it to <code>o.f</code>. Doing so results in the same behavior:</p> + +<pre class="brush:js">var o = {prop: 37}; + +function independent() { + return this.prop; +} + +o.f = independent; + +console.log(o.f()); // logs 37 +</pre> + +<p>This demonstrates that it matters only that the function was invoked from the <code>f</code> member of <code>o</code>.</p> + +<p>Similarly, the <code>this</code> binding is only affected by the most immediate member reference. In the following example, when we invoke the function, we call it as a method <code>g</code> of the object <code>o.b</code>. This time during execution, <code>this</code> inside the function will refer to <code>o.b</code>. The fact that the object is itself a member of <code>o</code> has no consequence; the most immediate reference is all that matters.</p> + +<pre class="brush:js">o.b = {g: independent, prop: 42}; +console.log(o.b.g()); // logs 42 +</pre> + +<h4 id="this_on_the_objects_prototype_chain"><code>this</code> on the object's prototype chain</h4> + +<p>The same notion holds true for methods defined somewhere on the object's prototype chain. If the method is on an object's prototype chain, <code>this</code> refers to the object the method was called on, as if the method was on the object.</p> + +<pre class="brush:js">var o = {f:function(){ return this.a + this.b; }}; +var p = Object.create(o); +p.a = 1; +p.b = 4; + +console.log(p.f()); // 5 +</pre> + +<p>In this example, the object assigned to the variable <code>p</code> doesn't have its own <code>f</code> property, it inherits it from its prototype. But it doesn't matter that the lookup for <code>f</code> eventually finds a member with that name on <code>o</code>; the lookup began as a reference to <code>p.f</code>, so <code>this</code> inside the function takes the value of the object referred to as <code>p</code>. That is, since <code>f</code> is called as a method of <code>p</code>, its <code>this</code> refers to <code>p</code>. This is an interesting feature of JavaScript's prototype inheritance.</p> + +<h4 id="this_with_a_getter_or_setter"><code>this</code> with a getter or setter</h4> + +<p>Again, the same notion holds true when a function is invoked from a getter or a setter. A function used as getter or setter has its <code>this</code> bound to the object from which the property is being set or gotten.</p> + +<pre class="brush:js">function modulus(){ + return Math.sqrt(this.re * this.re + this.im * this.im); +} + +var o = { + re: 1, + im: -1, + get phase(){ + return Math.atan2(this.im, this.re); + } +}; + +Object.defineProperty(o, 'modulus', { + get: modulus, enumerable:true, configurable:true}); + +console.log(o.phase, o.modulus); // logs -0.78 1.4142 +</pre> + +<h3 id="As_a_constructor">As a constructor</h3> + +<p>When a function is used as a constructor (with the <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code> keyword), its <code>this</code> is bound to new object being constructed.</p> + +<p>Note: while the default for a constructor is to return the object referenced by <code>this</code>, it can instead return some other object (if the return value isn't an object, then the <code>this</code> object is returned).</p> + +<pre class="brush:js">/* + * Constructors work like this: + * + * function MyConstructor(){ + * // Actual function body code goes here. + * // Create properties on |this| as + * // desired by assigning to them. E.g., + * this.fum = "nom"; + * // et cetera... + * + * // If the function has a return statement that + * // returns an object, that object will be the + * // result of the |new| expression. Otherwise, + * // the result of the expression is the object + * // currently bound to |this| + * // (i.e., the common case most usually seen). + * } + */ + +function C(){ + this.a = 37; +} + +var o = new C(); +console.log(o.a); // logs 37 + + +function C2(){ + this.a = 37; + return {a:38}; +} + +o = new C2(); +console.log(o.a); // logs 38 +</pre> + +<p>In the last example (<code>C2</code>), because an object was returned during construction, the new object that <code>this</code> was bound to simply gets discarded. (This essentially makes the statement "<code>this.a = 37;</code>" dead code. It's not exactly dead, because it gets executed, but it can be eliminated with no outside effects.)</p> + +<h3 id="call_and_apply"><code>call</code> and <code>apply</code></h3> + +<p>Where a function uses the <code>this</code> keyword in its body, its value can be bound to a particular object in the call using the <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call">call</a></code> or <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply">apply</a></code> methods that all functions inherit from <code>Function.prototype</code>.</p> + +<pre class="brush:js">function add(c, d){ + return this.a + this.b + c + d; +} + +var o = {a:1, b:3}; + +// The first parameter is the object to use as +// 'this', subsequent parameters are passed as +// arguments in the function call +add.call(o, 5, 7); // 1 + 3 + 5 + 7 = 16 + +// The first parameter is the object to use as +// 'this', the second is an array whose +// members are used as the arguments in the function call +add.apply(o, [10, 20]); // 1 + 3 + 10 + 20 = 34 +</pre> + +<p>Note that with <code>call</code> and <code>apply</code>, if the value passed as <code>this</code> is not an object, an attempt will be made to convert it to an object using the internal <code>ToObject</code> operation. So if the value passed is a primitive like <code>7</code> or <code>'foo'</code>, it will be converted to an Object using the related constructor, so the primitive number <code>7</code> is converted to an object as if by <code>new Number(7)</code> and the string <code>'foo'</code> to an object as if by <code>new String('foo'), e.g.</code></p> + +<pre class="brush:js">function bar() { + console.log(Object.prototype.toString.call(this)); +} + +bar.call(7); // [object Number] +</pre> + +<h3 id="The_bind_method">The <code>bind</code> method</h3> + +<p>ECMAScript 5 introduced <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">Function.prototype.bind</a></code>. Calling <code>f.bind(someObject)</code> creates a new function with the same body and scope as <code>f</code>, but where <code>this</code> occurs in the original function, in the new function it is permanently bound to the first argument of <code>bind</code>, regardless of how the function is being used.</p> + +<pre class="brush:js">function f(){ + return this.a; +} + +var g = f.bind({a:"azerty"}); +console.log(g()); // azerty + +var o = {a:37, f:f, g:g}; +console.log(o.f(), o.g()); // 37, azerty +</pre> + +<h3 id="As_a_DOM_event_handler">As a DOM event handler</h3> + +<p>When a function is used as an event handler, its <code>this</code> is set to the element the event fired from (some browsers do not follow this convention for listeners added dynamically with methods other than <code>addEventListener</code>).</p> + +<pre class="brush:js">// When called as a listener, turns the related element blue +function bluify(e){ + // Always true + console.log(this === e.currentTarget); + // true when currentTarget and target are the same object + console.log(this === e.target); + this.style.backgroundColor = '#A5D9F3'; +} + +// Get a list of every element in the document +var elements = document.getElementsByTagName('*'); + +// Add bluify as a click listener so when the +// element is clicked on, it turns blue +for(var i=0 ; i<elements.length ; i++){ + elements[i].addEventListener('click', bluify, false); +}</pre> + +<h3 id="In_an_in–line_event_handler">In an in–line event handler</h3> + +<p>When code is called from an in–line handler, its <code>this</code> is set to the DOM element on which the listener is placed:</p> + +<pre class="brush:js"><button onclick="alert(this.tagName.toLowerCase());"> + Show this +</button> +</pre> + +<p>The above alert shows <code>button</code>. Note however that only the outer code has its <code>this</code> set this way:</p> + +<pre class="brush:js"><button onclick="alert((function(){return this}()));"> + Show inner this +</button> +</pre> + +<p>In this case, the inner function's <code>this</code> isn't set so it returns the global/window object (i.e. the default object in non–strict mode where <code>this</code> isn't set by the call).</p> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initial definition. Implemented in JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.1.1', 'The this keyword')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-this-keyword', 'The this keyword')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">Strict mode</a></li> + <li><a href="http://bjorn.tipling.com/all-this">All this</a>, an article about <code>this</code> in different contexts</li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/yield/index.html b/files/pl/web/javascript/referencje/operatory/yield/index.html new file mode 100644 index 0000000000..8d814a5aa8 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/yield/index.html @@ -0,0 +1,168 @@ +--- +title: yield +slug: Web/JavaScript/Referencje/Operatory/yield +translation_of: Web/JavaScript/Reference/Operators/yield +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Słowo kluczowe <code>yield</code> jest używane do zatrzymania i powrotu funkcji generatora ({{jsxref("Statements/function*", "function*")}} lub <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Legacy_generator_function">legacy generator function</a>).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">[<em>rv</em>] = <strong>yield</strong> [<em>expression</em>];</pre> + +<dl> + <dt><code>expression</code></dt> + <dd>Definiuje wartość która ma być zwrócona przez funkcję generatora przez <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol">the iterator protocol</a>, jeżeli pominięte, zostanie zwrócone <code>undefined</code>.</dd> + <dt><code>rv</code></dt> + <dd> + <p>Zwraca opcjonalną wartość przekazaną do metody next() generatora, do powrotu do jej wykonania.</p> + </dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>The <code>yield</code> keyword causes generator function execution to pause and the value of the expression following the <code>yield</code> keyword is returned to the generator's caller. It can be thought of as a generator-based version of the <code>return</code> keyword.</p> + +<p>The <code>yield</code> keyword actually returns an <code>IteratorResult</code> object with two properties, <code>value</code> and <code>done</code>. The <code>value</code> property is the result of evaluating the <code>yield</code> expression, and <code>done</code> is <code>false</code>, indicating that the generator function has not fully completed.</p> + +<p>Once paused on a <code>yield</code> expression, the generator's code execution remains paused until the generator's <code>next()</code> method is called. Each time the generator's <code>next()</code> method is called, the generator resumes execution and runs until it reaches one of the following:</p> + +<ul> + <li> A <code>yield</code>, which causes the generator to once again pause and return the generator's new value. The next time <code>next()</code> is called, execution resumes with the statement immediately after the <code>yield</code>.</li> + <li>{{jsxref("Statements/throw", "throw")}} is used to throw an exception from the generator. This halts execution of the generator entirely, and execution resumes in the caller as is normally the case when an exception is thrown.</li> + <li>The end of the generator function is reached; in this case, execution of the generator ends and an <code>IteratorResult</code> is returned to the caller in which the <code>value</code> is {{jsxref("undefined")}} and <code>done</code> is <code>true</code>.</li> + <li>A {{jsxref("Statements/return", "return")}} statement is reached. In this case, execution of the generator ends and an <code>IteratorResult</code> is returned to the caller in which the <code>value</code> is the value specified by the <code>return</code> statement and <code>done</code> is <code>true</code>.</li> +</ul> + +<p>If an optional value is passed to the generator's <code>next()</code> method, that value becomes the value returned by the generator's current <code>yield</code> operation.</p> + +<p>Between the generator's code path, its <code>yield</code> operators, and the ability to specify a new starting value by passing it to {{jsxref("Generator.prototype.next()")}}, generators offer enormous power and control.</p> + +<h2 id="Examples">Examples</h2> + +<p>The following code is the declaration of an example generator function.</p> + +<pre class="brush: js">function* foo() { + var index = 0; + while (index <= 2) + yield index++; +}</pre> + +<p>Once a generator function is defined, it can be used by constructing an iterator as shown.</p> + +<pre class="brush: js">var iterator = foo(); +console.log(iterator.next()); // { value: 0, done: false } +console.log(iterator.next()); // { value: 1, done: false } +console.log(iterator.next()); // { value: 2, done: false } +console.log(iterator.next()); // { value: undefined, done: true }</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#', 'Yield')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#', 'Yield')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>39</td> + <td>{{CompatGeckoDesktop("26.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatSafari("10")}}</td> + </tr> + <tr> + <td><code>IteratorResult</code> object instead of throwing</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("29.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatSafari("10")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("26.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{ CompatUnknown}}</td> + <td>{{CompatSafari("10")}}</td> + </tr> + <tr> + <td><code>IteratorResult</code> object instead of throwing</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("29.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatSafari("10")}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Firefox-specific_notes">Firefox-specific notes</h2> + +<ul> + <li>Starting with Gecko 29 {{geckoRelease(29)}}, the completed generator function no longer throws a {{jsxref("TypeError")}} "generator has already finished". Instead, it returns an <code>IteratorResult</code> object like <code>{ value: undefined, done: true }</code> ({{bug(958951)}}).</li> + <li>Starting with Gecko 33 {{geckoRelease(33)}}, the parsing of the <code>yield</code> expression has been updated to conform with the ES2015 specification ({{bug(981599)}}): + <ul> + <li>The expression after the <code>yield</code> keyword is optional and omitting it no longer throws a {{jsxref("SyntaxError")}}: <code>function* foo() { yield; }</code></li> + </ul> + </li> +</ul> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li> + <li>{{jsxref("Statements/function*", "function*")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("Operators/yield*", "yield*")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/operatory/yield_star_/index.html b/files/pl/web/javascript/referencje/operatory/yield_star_/index.html new file mode 100644 index 0000000000..ddef530622 --- /dev/null +++ b/files/pl/web/javascript/referencje/operatory/yield_star_/index.html @@ -0,0 +1,200 @@ +--- +title: yield* +slug: Web/JavaScript/Referencje/Operatory/yield* +translation_of: Web/JavaScript/Reference/Operators/yield* +--- +<div>{{jsSidebar("Operators")}}</div> + +<p><strong><code>Wyrażenie yield*</code> </strong> służy do wydelegowania działania generatora do innego {{jsxref("Statements/function*", "generatora")}} lub obiektu iterowalnego.</p> + +<div>{{EmbedInteractiveExample("pages/js/expressions-yieldasterisk.html")}}</div> + +<p class="hidden">Źródło poniższego interaktywnego przykładu przechowywane jest w repozytorium na GitHub. Jeśli chcesz współtworzyć projekt interaktywnych przykładów, sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij nam pull request.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"> yield* [[expression]];</pre> + +<dl> + <dt><code>expression</code></dt> + <dd>Wyrażenie, które zwraca iterowalny obiekt lub generator.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p><code>yield*</code> iteruje po iterowalnym obiekcie i wywołuje <code>yield</code> z każdą kolejną zwracaną przez niego wartością.</p> + +<p>Wartość samego <code>yield*</code> jest wartością zwróconą przez iterator w momencie jego zakończenia (tzn. kiedy <code>done</code> ma wartość <code>true</code>).</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Delegowanie_logiki_do_osobnego_generatora">Delegowanie logiki do osobnego generatora</h3> + +<p>W poniższym kodzie wartości <code>yeld</code> dla <code>g1()</code> zwracane są przy wywołaniu <code>next()</code> dokładnie tak samo jak te, które zwraca <code>yeld</code> generatora <code>g2()</code>.</p> + +<pre class="brush: js">function* g1() { + yield 2; + yield 3; + yield 4; +} + +function* g2() { + yield 1; + yield* g1(); + yield 5; +} + +var iterator = g2(); + +console.log(iterator.next()); // {value: 1, done: false} +console.log(iterator.next()); // {value: 2, done: false} +console.log(iterator.next()); // {value: 3, done: false} +console.log(iterator.next()); // {value: 4, done: false} +console.log(iterator.next()); // {value: 5, done: false} +console.log(iterator.next()); // {value: undefined, done: true} +</pre> + +<h3 id="Inne_obiekty_iterowalne">Inne obiekty iterowalne</h3> + +<p><code>yield*</code> może wywoływać <code>yield</code> z wartościami dostarczanymi przez inne rodzje obiektów iterowalnych , np. tablice, stringi lub obiekt <code>arguments</code>.</p> + +<pre class="brush: js">function* g3() { + yield* [1, 2]; + yield* '34'; + yield* Array.from(arguments); +} + +var iterator = g3(5, 6); + +console.log(iterator.next()); // {value: 1, done: false} +console.log(iterator.next()); // {value: 2, done: false} +console.log(iterator.next()); // {value: "3", done: false} +console.log(iterator.next()); // {value: "4", done: false} +console.log(iterator.next()); // {value: 5, done: false} +console.log(iterator.next()); // {value: 6, done: false} +console.log(iterator.next()); // {value: undefined, done: true} +</pre> + +<h3 id="Wartość_samego_wyrażenia_yield*">Wartość samego wyrażenia <code>yield*</code></h3> + +<p><code>yield*</code> jest wyrażeniem (expression) a nie statement, więc rozwiązuje się do konkretnej wartości.</p> + +<pre class="brush: js">function* g4() { + yield* [1, 2, 3]; + return 'foo'; +} + +var result; + +function* g5() { + result = yield* g4(); +} + +var iterator = g5(); + +console.log(iterator.next()); // {value: 1, done: false} +console.log(iterator.next()); // {value: 2, done: false} +console.log(iterator.next()); // {value: 3, done: false} +console.log(iterator.next()); // {value: undefined, done: true}, + // g4() zwrócił w tym momencie {value: 'foo', done: true} + +console.log(result); // "foo" +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#', 'Yield')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#', 'Yield')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("27.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatSafari("10")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("27.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatSafari("10")}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Firefox-specific_notes">Firefox-specific notes</h2> + +<ul> + <li>Starting with Gecko 33 {{geckoRelease(33)}}, the parsing of the yield expression has been updated to conform with the ES2015 specification ({{bug(981599)}}): + <ul> + <li>The line terminator restriction is now implemented. No line terminator between "yield" and "*" is allowed. Code like the following will throw a {{jsxref("SyntaxError")}}: + <pre class="brush: js">function* foo() { + yield + *[]; +}</pre> + </li> + </ul> + </li> +</ul> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li> + <li>{{jsxref("Statements/function*", "function*")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("Operators/yield", "yield")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/block/index.html b/files/pl/web/javascript/referencje/polecenia/block/index.html new file mode 100644 index 0000000000..bbc5c7e4fb --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/block/index.html @@ -0,0 +1,160 @@ +--- +title: block +slug: Web/JavaScript/Referencje/Polecenia/block +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/block +--- +<p><strong>Blok instrukcji</strong> jest stosowany do zgrupowania zero lub więcej instrukcji. Blok jest ograniczony parą nawiasów klamrowych i opcjonalnie może posiadać etykietę.</p> + +<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2> + +<h3 id="Blok">Blok</h3> + +<pre class="eval">{ ListaInstrukcji } +</pre> + +<h3 id="Blok_z_etykietą">Blok z etykietą</h3> + +<pre>EtykietaBloku: { ListaInstrukcji }</pre> + +<h3 id="Parametry" name="Parametry">Parametry</h3> + +<dl> + <dt><code>ListaInstrukcji</code></dt> + <dd>Instrukcje zgrupowane w bloku.</dd> + <dt><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.498039);">EtykietaBloku</span></font></dt> + <dd>Opcjonalna <a href="/pl/docs/Web/JavaScript/Referencje/Polecenia/etykieta">etykieta</a> dla wizualnej identyfikacji lub jako cel dla <a href="/pl/docs/Web/JavaScript/Referencje/Polecenia/break">break</a>.</dd> +</dl> + +<h2 id="Opis" name="Opis">Opis</h2> + +<p>Blok instrukcji nazywany jest również w innych językach <strong>instrukcjami złożonymi</strong>. Pozwala użyć wielu instrukcji tam, gdzie JavaScript pozwala użyć tylko jednej. Składanie instrukcji w bloki jest powszechną praktyką w JavaScript. Za pomocą bloku można uzyskać też efekt przeciwny - brak instrukcji tam, gdzie jest wymagana.</p> + +<h3 id="Reguły_zasięgu_bloku">Reguły zasięgu bloku</h3> + +<h4 id="Zasięg_var">Zasięg <code>var</code></h4> + +<p>Zmienne tworzone poprzez <code>var</code> <strong>nie mają </strong>zasięgu bloku. Zmienne zadeklarowane w bloku są ograniczone do funkcji lub skryptu zawierającego, a efektyoperacji na nich utrzymują się poza samym blokiem. Innymi słowy, instrukcje blokowe nie wprowadzają zakresu. Chociaż "samodzielne" bloki są poprawną składnią, nie chcesz używać niezależnych bloków w JavaScript, ponieważ nie robią tego, co myślisz, że robią, jeśli myślisz, że robią coś takiego jak w C lub Java. Na przykład:</p> + +<pre><code>var x = 1; +{ + var x = 2; +} +console.log(x); // zwraca 2</code> +</pre> + +<p>Otrzymujesz 2, ponieważ instrukcja <code>var x = 2</code>, która jest w bloku jest w tym samym zasięgu co instrukcja przed blokiem. W C lub Javie podobny kod zwróciłby 1.</p> + +<h4 id="Zasięg_let_i_const">Zasięg <code>let</code> i <code>const</code></h4> + +<p>Dla odmiany identyfikatory stworzone z użyciem <a href="en-US/docs/Web/JavaScript/Reference/Statements/let">let</a> i <a href="/pl/docs/Web/JavaScript/Referencje/Polecenia/const">const</a> <strong>posiadają</strong> zakres blokowy:</p> + +<pre><code>let x = 1; +{ + let x = 2; +} +console.log(x); // zwraca 1</code> +</pre> + +<p><code><font face="Arial, x-locale-body, sans-serif"><span style="background-color: #ffffff;">Instrukcja </span></font>x = 2</code> jest ograniczona w zakresie bloku, w którym została zdefiniowana.</p> + +<p>To samo odnosi się do <code>const</code>:</p> + +<pre><code>const c = 1; +{ + const c = 2; +} +console.log(c); // zwraca 1 i nie rzuca wyjątkiem SyntaxError.</code> +</pre> + +<p>Zauważ, że <code>const c = 2</code> nie rzuca wyjątku <code>SyntaxError: Identifier 'c' has already been declared</code>, ponieważ może być zadeklarowane unikalnie w ramach bloku.</p> + +<h4 id="Zasięg_funkcji">Zasięg <code>funkcji</code></h4> + +<p>Funkcja zadeklarowana w bloku również widzialna jest w zakresie tego bloku:</p> + +<pre><code>foo('outside'); // TypeError: foo is not a function +{ + function foo(location) { + console.log('foo is called ' + location); + } + foo('inside'); // wykonuje się poprawnie i zwraca 'foo is called inside' +}</code> +</pre> + +<p>Bardziej precyzyjnie mówiąc blok instrukcji zapobiega <a href="/pl/docs/Glossary/Hoisting">Hoisting</a>owi deklaracji funkcji na początek zakresu. Funkcja zachowuje się tak, jakby była zdefiniowana jako wyrażenie funkcji i jako taka jest tylko deklaracją zmiennej, która zostaje podniesiona do góry, na początek zakresu:</p> + +<pre><code>foo; // zwraca undefined +{ + function foo(location) { + console.log('foo is called ' + location); + } + foo('inside'); // wykonuje się poprawnie i zwraca 'foo is called inside' +}</code></pre> + +<p>Konsekwentnie to znaczy, że gdy przeniesiemy wywołanie funkcji poniżej jej deklaracji - nie otrzymamy błędu:</p> + +<pre><code>{ + function foo(location) { + console.log('foo is called ' + location); + } + foo('inside'); // works correctly and logs 'foo is called inside' +} +foo('outside'); // works correctly and logs 'foo is called outside'</code> +</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-block', 'Block statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-block', 'Block statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.1', 'Block statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-12.1', 'Block statement')}}</td> + <td>{{Spec2('ES3')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-12.1', 'Block statement')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2> + +<div class="hidden"> +<p>Tabela zgodności na tej stronie jest generowana na podstawie danych strukturalnych. Jeśli chcesz przyczynić się do danych, sprawdź https://github.com/mdn/browser-compat-data i wyślij nam prośbę o wycofanie.</p> +</div> + +<p>{{Compat("javascript.statements.block")}}</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li><a href="/pl/docs/Web/JavaScript/Referencje/Polecenia/while">while</a></li> + <li><a href="/pl/docs/Web/JavaScript/Referencje/Polecenia/if...else">if...else</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/break/index.html b/files/pl/web/javascript/referencje/polecenia/break/index.html new file mode 100644 index 0000000000..661b130d71 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/break/index.html @@ -0,0 +1,67 @@ +--- +title: break +slug: Web/JavaScript/Referencje/Polecenia/break +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/break +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Przerywa aktualnie wykonywaną pętlę, konstrukcję <code>switch</code> i przekazuje sterowanie programu do polecenia za pętlą lub za wskazaną etykietą. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Polecenie</td> +</tr> +<tr> +<td>Zaimplementowane w:</td> +<td>JavaScript 1.0, NES 2.0</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262 (wersja bez etykiety) +<p>ECMA-262, Edycja 3 (wersja z etykietą) +</p> +</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<p><code> +break {{ mediawiki.external('<i>etykieta</i>') }} +</code> +</p> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>etykieta</code> </dt><dd> Identyfikator przypisany etykiecie polecenia. +</dd></dl> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Polecenie <code>break</code> może zawierać opcjonalną etykietę, która pozwala programowi na wyjście z bloku poleceń oznaczonego etykietą. Polecenia w bloku oznaczonym etykietą mogą być dowolnego rodzaju. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_break" name="Przyk.C5.82ad:_Zastosowanie_break"> Przykład: Zastosowanie <code>break</code> </h4> +<p>Poniższa funkcja zawiera polecenie <code>break</code>, które przerywa pętlę +<code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/while">while</a></code>, kiedy <code>e</code> jest równe 3, a następnie zwraca wartość 3 * <code>x</code>. +</p> +<pre>function testBreak(x) { + var i = 0; + while (i < 6) { + if (i == 3) + break; + i++; + } + return i*x; +} +</pre> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/continue">continue</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/etykieta">etykieta</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/switch">switch</a></code> +</p><p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/break", "es": "es/Referencia_de_JavaScript_1.5/Sentencias/break", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/break", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/break" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/class/index.html b/files/pl/web/javascript/referencje/polecenia/class/index.html new file mode 100644 index 0000000000..05cdb7b2d4 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/class/index.html @@ -0,0 +1,113 @@ +--- +title: class +slug: Web/JavaScript/Referencje/Polecenia/class +translation_of: Web/JavaScript/Reference/Statements/class +--- +<div>{{jsSidebar("Statements")}}</div> + +<div><strong>Deklaracja klasy</strong> tworzy nową klasę z daną nazwą, używając dziedziczenia opartego na prototypach.</div> + +<div>{{EmbedInteractiveExample("pages/js/statement-class.html")}}</div> + + + +<div class="noinclude"> +<p>Możesz także zdefiniować klasę, używając {{jsxref("Operators/class", "wyrażenia class", "", 1)}}. W odróżnieniu jednak od wyrażenia class, deklaracja klasy nie pozwala na ponowne zadeklarowanie istniejącej klasy i w takim przypadku zwróci błąd.</p> +</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="brush: js">class nazwa [extends] { + // ciało klasy +} +</pre> + +<h2 id="Opis">Opis</h2> + +<p>Ciało klasy w deklaracji klasy jest wykonywane w <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode">trybie ścisłym</a>. Konstruktor jest opcjonalny.</p> + +<p>Deklaracje klas nie są {{Glossary("Hoisting", "hoisted")}} (w odróżnieniu od <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">deklaracji funkcji</a>).</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Prosta_deklaracja_klasy">Prosta deklaracja klasy</h3> + +<p>W poniższym przykładzie, najpierw definiujemy klasę o nazwie Polygon, a następnie rozszerzamy ją do klasy Square. Zwróć uwagę na to, że <code>super()</code>, użyte w konstruktorze, może byc użyte jedynie w konstruktorach i musi być wywołane przed użyciem słowa kluczowego <code>this</code>.</p> + +<pre class="brush: js">class Polygon { + constructor(height, width) { + this.name = 'Polygon'; + this.height = height; + this.width = width; + } +} + +class Square extends Polygon { + constructor(length) { + super(length, length); + this.name = 'Square'; + } +}</pre> + +<div class="warning"> +<h3 id="Próba_podwójnej_deklaracji_klasy">Próba podwójnej deklaracji klasy</h3> + +<p>Próba ponownego zadeklarowania klasy, przy użyciu deklaracji klasy, spowoduje wystąpienie błędu.</p> + +<pre class="brush: js">class Foo {}; +class Foo {}; // Uncaught SyntaxError: Identifier 'Foo' has already been declared +</pre> + +<p>Taki sam błąd jest zwracany, gdy klasa jest zdefiniowana przed użyciem wyrażenia klasy.</p> + +<pre class="brush: js">var Foo = class {}; +class Foo {}; // Uncaught TypeError: Identifier 'Foo' has already been declared + +</pre> +</div> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Początkowa definicja.</td> + </tr> + <tr> + <td>{{SpecName('ES2016', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ES2016')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES2017', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ES2017')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.statements.class")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/function"><code>function</code> declaration</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> expression</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/const/index.html b/files/pl/web/javascript/referencje/polecenia/const/index.html new file mode 100644 index 0000000000..ead1ca32fb --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/const/index.html @@ -0,0 +1,53 @@ +--- +title: const +slug: Web/JavaScript/Referencje/Polecenia/const +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/const +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Deklaruje nazwaną stałą tylko do odczytu. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Wyrażenie</td> +</tr> +<tr> +<td>Zaimplementowane w:</td> +<td>JavaScript 1.5, NES 6.0 (rozszerzenie Netscape, tylko w silniku C)</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<p><code> +const <i>nazwaStałej</i> {{ mediawiki.external('= <i>wartość</i>') }} [..., <i>nazwaStałej</i> {{ mediawiki.external('= <i>wartość</i>') }} ] +</code> +</p> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>nazwaStałej</code> </dt><dd> Nazwa stałej. Może być dowolnym dozwolonym identyfikatorem. +</dd></dl> +<dl><dt> <code>wartość</code> </dt><dd> Wartość stałej. Może być dowolną dozwoloną wartością lub wynikiem wyrażenia. +</dd></dl> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Tworzy stałą, która może być globalna lub lokalna dla funkcji, która ją zadeklarowała. Zasady zasięgu dla stałych są takie same jak dla zmiennych. +</p><p>Wartość stałej nie może zostać zmieniona poprzez ponowne przypisanie; stała nie może także być ponownie zadeklarowana. +</p><p>Stała nie może mieć takiej samej nazwy jak funkcja lub zmienna o tym samym zasięgu. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_const" name="Przyk.C5.82ad:_Zastosowanie_const"> Przykład: Zastosowanie <code>const</code> </h4> +<p>Poniższy skrypt wypisuje "<code>a jest równe 7</code>". +</p> +<pre>const a = 7; +document.writeln("a jest równe " + a); +</pre> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/var">var</a></code> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/const", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/const", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/const" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/continue/index.html b/files/pl/web/javascript/referencje/polecenia/continue/index.html new file mode 100644 index 0000000000..b6c2a05d94 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/continue/index.html @@ -0,0 +1,166 @@ +--- +title: continue +slug: Web/JavaScript/Referencje/Polecenia/continue +tags: + - JavaScript + - instrukcja + - polecenie +translation_of: Web/JavaScript/Reference/Statements/continue +--- +<div>{{jsSidebar("Statements")}}</div> + +<p><strong>Polecenie continue</strong> zatrzymuje wykonanie pętli w obecnej iteracji, w obecnej lub wskazanej pętli i kontynuuje wykonanie pętli w kolejnej jej iteracji.</p> + +<div>{{EmbedInteractiveExample("pages/js/statement-continue.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">continue [etykieta];</pre> + +<dl> + <dt><code>etykieta</code></dt> + <dd>Identyfikator powiązany z etykietą instrukcji.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>W przeciwieństwie do instrukcji {{jsxref("Statements/break", "break")}}, <code>continue</code> nie zatrzymuje całkowicie wykonania pętli, natomiast:</p> + +<ul> + <li>w pętli {{jsxref("Statements/while", "while")}} powoduje przejście do warunku pętli,</li> +</ul> + +<ul> + <li>w pętli {{jsxref("Statements/for", "for")}}, powoduje przejście do wyrażenia aktualizującego pętlę.</li> +</ul> + +<p>Instrukcja <code>continue</code> może opcjonalnie zawierać etykietę, która pozwala programowi przejść do kolejnej iteracji pętli, której tę etykietę przypisano, zamiast kolejnej iteracji obecnej pętli. W tym przypadku, polecenie <code>continue</code> musi być zawarte wewnątrz instrukcji z etykietą.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_continue_z_while">Użycie continue z while</h3> + +<p>Poniższy przykład pokazuje pętlę {{jsxref("Statements/while", "while")}}, zawierającą polecenie <code>continue</code>, które jest wykonywane, gdy wartość zmiennej <code>i</code> równa jest 3 – zatem <code>n</code> przyjmuje kolejno wartości 1, 3, 7 i 12.</p> + +<pre class="brush: js notranslate">var i = 0; +var n = 0; + +while (i < 5) { + i++; + + if (i === 3) { + continue; + } + + n += i; +} +</pre> + +<h3 id="Użycie_continue_z_etykietą">Użycie continue z etykietą</h3> + +<p>W poniższym przykładzie, instrukcja z etykietą <code>checkiandj</code> zawiera instrukcję z etykietą <code>checkj</code>. Jeśli zostanie napotkane polecenie <code>continue</code>, wykonanie programu jest kontynuowane od góry instukcji <code>checkj</code>. Za każdym razem, gdy napotkane jest <code>continue</code>, <code>chekckj</code> jest przeiterowywane dopóki jego warunek nie zwróci wartości false. Kiedy zwracane jest false, wykonywana jest pozostała część <code>checkiandj</code>.</p> + +<p>Gdyby <code>continue</code> miało etykietę <code>checkiandj</code>, wówczas program powinien przejść na początek instrukcji <code>checkiandj</code>.</p> + +<p>Zobacz też {{jsxref("Statements/label", "label")}}.</p> + +<pre class="brush: js notranslate">var i = 0; +var j = 8; + +checkiandj: while (i < 4) { + console.log('i: ' + i); + i += 1; + + checkj: while (j > 4) { + console.log('j: ' + j); + j -= 1; + + if ((j % 2) == 0) + continue checkj; + console.log('Liczba' + j + ' jest nieparzysta.'); + } + console.log('i = ' + i); + console.log('j = ' + j); +} +</pre> + +<p>Wyjście:</p> + +<pre class="brush: js notranslate">i: 0 + +// początek checkj +j: 8 +Liczba 7 jest nieparzysta. +j: 7 +j: 6 +Liczba 5 jest nieparzysta. +j: 5 +// koniec checkj + +i = 1 +j = 4 + +i: 1 +i = 2 +j = 4 + +i: 2 +i = 3 +j = 4 + +i: 3 +i = 4 +j = 4 +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Uwagi</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Wstępna definicja. Wersja bez etykiety.</td> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Dodano wersję z etykietą.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.7', 'Continue statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-continue-statement', 'Continue statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-continue-statement', 'Continue statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.statements.continue")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Statements/break", "break")}}</li> + <li>{{jsxref("Statements/label", "label")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/debugger/index.html b/files/pl/web/javascript/referencje/polecenia/debugger/index.html new file mode 100644 index 0000000000..b4fe9548a7 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/debugger/index.html @@ -0,0 +1,126 @@ +--- +title: debugger +slug: Web/JavaScript/Referencje/Polecenia/debugger +translation_of: Web/JavaScript/Reference/Statements/debugger +--- +<div>{{jsSidebar("Statements")}}</div> + +<div>Wyrażenie <strong>debugger </strong>uruchamia dowolną dostępną funkcjonalność umożliwiającą debuggowanie, przykładowo poprzez ustawienie <em>breakpointa</em> w miejscu użycia wyrażenia. Jeżeli żadna tego typu funkcjonalność nie jest dostępna, użycie wyrażenia nie ma wpływu na działanie programu.</div> + +<div> +<h2 id="Składnia">Składnia</h2> +</div> + +<pre class="syntaxbox"><code>debugger;</code></pre> + +<h2 id="Przykłady">Przykłady</h2> + +<p>Poniższy przykład pokazuje użycie wyrażenia <strong>debugger</strong> w celu uruchomienia debuggera w momencie wywołania funkcji (jeżeli jest dostępny).</p> + +<pre class="brush:js">function potentiallyBuggyCode() { + debugger; + // przeprowadź analizę działania programu zawierających bugi, przejdź do kolejnych wywołań, itp. +}</pre> + +<p>Kiedy następuje wywołanie instrukcji debugger, uruchomienie programu zatrzymywane jest na wyrażeniu <strong>debugger</strong>. Działa to tak jak ustawienie <em>breakpointu</em> w kodzie źródłowym skryptu.</p> + +<p><a href="https://mdn.mozillademos.org/files/6963/Screen Shot 2014-02-07 at 9.14.35 AM.png"><img alt="Paused at a debugger statement." src="https://mdn.mozillademos.org/files/6963/Screen%20Shot%202014-02-07%20at%209.14.35%20AM.png" style="height: 371px; width: 700px;"></a></p> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-debugger-statement', 'Debugger statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-debugger-statement', 'Debugger statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.15', 'Debugger statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Wstępna definicja</td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-7.5.3', 'Debugger statement')}}</td> + <td>{{Spec2('ES3')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-7.4.3', 'Debugger statement')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Jedynie wspomniane jako zarezerwowane słowo kluczowe</td> + </tr> + </tbody> +</table> + +<h3 id="CompatibilityTable"><br> + {{CompatibilityTable}}</h3> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Cecha</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Podstawowe wsparcia</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Cecha</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Podstawowe wsparcie</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><a href="/en-US/docs/Debugging_JavaScript">Debugging JavaScript</a></li> + <li><a href="/en-US/docs/Tools/Debugger">The Debugger in the Firefox Developer Tools</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/default/index.html b/files/pl/web/javascript/referencje/polecenia/default/index.html new file mode 100644 index 0000000000..3e28e480e8 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/default/index.html @@ -0,0 +1,120 @@ +--- +title: default +slug: Web/JavaScript/Referencje/Polecenia/default +tags: + - JavaScript + - słowo kluczowe +translation_of: Web/JavaScript/Reference/Statements/switch +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>Słowo kluczowe <strong>default </strong>może być użyte w języku JavaScript w dwóch sytuacjach: w instrukcji {{jsxref("Statements/switch", "switch")}} lub instrukcji {{jsxref("Statements/export", "export")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/statement-default.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<p>W instrukcji {{jsxref("Statements/switch", "switch")}}:</p> + +<pre class="syntaxbox">switch (wyrażenie) { + case wartość1: + //Instrukcje wykonywane kiedy wartość1 zgadza się z wartością wyrażenia + [break;] + default: + //Instrukcje wykonywane kiedy żadna z wartości nie zgadza się z wartością wyrażenia + [break;] +}</pre> + +<p>Z instrukcją {{jsxref("Statements/export", "export")}}:</p> + +<pre class="syntaxbox">export default <em>nazwaN</em> </pre> + +<h2 id="Opis">Opis</h2> + +<p>Po więcej szczegółów zobacz strony instrukcji</p> + +<ul> + <li>{{jsxref("Statements/switch", "switch")}}</li> + <li>i {{jsxref("Statements/export", "export")}}.</li> +</ul> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_default_w_instrukcji_switch">Użycie <code>default</code> w instrukcji <code>switch</code></h3> + +<p>W poniższym przykładzie, jeśli <code>expr</code> przyjmie wartość "Pomarańcze" lub "Jabłka", program dopasuje tę wartość odpowiednio do przypadków (case) "Pomarańcze" i "Jabłka" oraz wykona odpowiednie instrukcje. Słowo kluczowe <code>default</code> zostanie użyte w każdym innym przypadku i pozwoli na wykonanie odpowiedających mu instrukcji.</p> + +<pre class="brush: js">switch (expr) { + case 'Pomarańcze': + console.log('Pomarańcze kosztują 3.29 zł za kilogram.'); + break; + case 'Jabłka': + console.log('Jabłka kosztują 1.59 zł za kilogram.'); + break; + default: + console.log('Przepraszamy, ' + expr + ' niestety się skończyły.'); +}</pre> + +<h3 id="Użycie_default_z_export">Użycie <code>default</code> z <code>export</code></h3> + +<p>Jeśli chcesz wyeksportować pojednynczą wartość lub potrzebujesz tzw. <em>fallback value</em> dla modułu, może szostać zastosowany domyślny eksport (<code>default export</code>)</p> + +<pre class="brush: js">// module "my-module.js" +let cube = function cube(x) { + return x * x * x; +}; +export default cube;</pre> + +<p>Wtedy, w innym skrypcie, domyślnie wyeksportowana wartość będzie bezpośrednio zaimportowana:</p> + +<pre class="brush: js">// module "another-module.js" +import cube from 'my-module'; //"default export" pozwala na napisanie "import cube", zamiast "import cube from 'my-module'" +console.log(cube(3)); // 27 +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-exports', 'Exports')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-exports', 'Exports')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.statements.default")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Statements/export", "export")}}</li> + <li>{{jsxref("Statements/switch", "switch")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/do...while/index.html b/files/pl/web/javascript/referencje/polecenia/do...while/index.html new file mode 100644 index 0000000000..a57caf17ee --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/do...while/index.html @@ -0,0 +1,54 @@ +--- +title: do...while +slug: Web/JavaScript/Referencje/Polecenia/do...while +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/do...while +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Wykonuje zadane polecenia dopóki warunek jest spełniony. Polecenia wykonywane są przynajmniej raz. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Polecenie</td> +</tr> +<tr> +<td>Zaimplementowane w:</td> +<td>JavaScript 1.2, NES 3.0</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262, Edycja 3 +</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<pre class="eval">do + <i>polecenia</i> +while (<i>warunek</i>); +</pre> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>polecenia</code> </dt><dd> Blok poleceń, który jest wykonywany przynajmniej raz. i jest wykonywany ponownie tak długo, jak <code>warunek</code> jest spełniony. +</dd></dl> +<dl><dt> <code>warunek</code> </dt><dd> Obliczany przy każdym przejściu pętli. Jeśli <code>warunek</code> ma wartość <i>prawda</i>, polecenia w bloku go poprzedzającym są wykonywane ponownie. Kiedy <code>warunek</code> osiągnie wartość <i>fałsz</i>, sterowanie przepływa do następnego polecenia po pętli <code>do...while</code> +</dd></dl> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_do...while" name="Przyk.C5.82ad:_Zastosowanie_do...while"> Przykład: Zastosowanie <code>do...while</code> </h4> +<p>W poniższym przykładzie pętla <code>do...while</code> wykonywana jest przynajmniej raz, a następnie jej wykonywanie jest powtarzane tak długo, aż <code>i</code> będzie większe lub równe 5. +</p> +<pre>do { + i+=1; + document.write(i); +} while (i<5); +</pre> +<p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/do...while", "es": "es/Referencia_de_JavaScript_1.5/Sentencias/do...while", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/do...while", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/do...while" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/empty/index.html b/files/pl/web/javascript/referencje/polecenia/empty/index.html new file mode 100644 index 0000000000..4c55c3f4dd --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/empty/index.html @@ -0,0 +1,92 @@ +--- +title: empty +slug: Web/JavaScript/Referencje/Polecenia/Empty +tags: + - JavaScript + - funkcja języka + - wyrażenie +translation_of: Web/JavaScript/Reference/Statements/Empty +--- +<div>{{jsSidebar("Statements")}}</div> + +<p><strong>Puste wyrażenie</strong> jest używane do podania braku wyrażenia tam, gdzie składnia JavaScript wymaga jakiejkolwiek instrukcji.</p> + +<div>{{EmbedInteractiveExample("pages/js/statement-empty.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">; +</pre> + +<h2 id="Opis">Opis</h2> + +<p>Puste wyrażenie jest zapisywane jako średnik, wskazujący na to, że żadna instrukcja nie będzie wykonana, nawet jeśli składnia JavaScript wymaga jakiejkolwiek operacji.</p> + +<p>Przeciwna zachowanie, kiedy potrzebne jest użycie kilku wyrażeń tam, gdzie JavaScript pozwala tylko na jedno, jest możliwe dzięki <a href="/en-US/docs/Web/JavaScript/Reference/Statements/block">blokom instrukcji</a>, które łączą kilka wyrażeń w jedno.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Pusta_pętla">Pusta pętla</h3> + +<p>Puste wyrażenie jest czasem używane w pętlach. Poniższy przykład prrzedstawia ciało pustej pętli:</p> + +<pre class="brush: js notranslate">let arr = [1, 2, 3]; + +// Nadaj wszystkim elementom tablicy wartość 0 +for (let i = 0; i < arr.length; arr[i++] = 0) /* puste wyrażenie */ ; + +console.log(arr); +// [0, 0, 0] +</pre> + +<h3 id="Nieumyślne_użycie">Nieumyślne użycie</h3> + +<p>Dobrym pomysłem jest dodanie komentarza do <em>umyślnego</em> użycia pustego wyrażenia, ponieważ nieoczywistym może się okazać rozróżnienie takiej instrukcji od zwykłego średnika.</p> + +<p>W poniższym przykładzie użycie pustego wyrażenia prawdopodobnie nie jest umyślne:</p> + +<pre class="brush: js example-bad notranslate">if (condition); // Uwaga, ten "if" nic nie robi! + killTheUniverse() // To polecenie będzie zawsze wykonane!!! +</pre> + +<p>W kolejnym przykładzie użyta jest instrukcja warunkowa {{jsxref("Statements/if...else", "if...else")}} bez nawiasów klamrowych (<code>{}</code>).</p> + +<p>Jeśli wartość zmiennej <code>trzy</code> jest równa <code>true</code>, nic się nie stanie, zmienna <code>cztery</code> nie ma znaczenia, również funkcja <code>odpalRakietę</code> w przypadku <code>else</code> nie będzie wykonana.</p> + +<pre class="brush: js example-bad notranslate">if (jeden) + wykonajJeden(); +else if (dwa) + wykonajDwa(); +else if (trzy) + ; // puste wyrażenie +else if (cztery) + wykonajCztery(); +else + odpalRakietę();</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-empty-statement', 'Empty statement')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.statements.empty")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Statements/block", "Block statement")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/etykieta/index.html b/files/pl/web/javascript/referencje/polecenia/etykieta/index.html new file mode 100644 index 0000000000..7ff42b3940 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/etykieta/index.html @@ -0,0 +1,51 @@ +--- +title: etykieta +slug: Web/JavaScript/Referencje/Polecenia/etykieta +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/label +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Pozwala na oznaczenie punktu w kodzie, do którego będzie można przejść za pomocą poleceń <code>break</code> lub <code>continue</code>. +</p><p>Przykładowo, można zastosować etykietę do oznaczenia pętli, a następnie użyć poleceń <code>break</code> lub <code>continue</code>, by zaznaczyć, czy program powinien przerwać pętlę czy kontynuować jej wykonywanie. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Polecenie</td> +</tr> +<tr> +<td>Zaimplementowane w:</td> +<td>JavaScript 1.2, NES 3.0</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262, Edycja 3</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<pre class="eval"><i>etykieta</i> : + <i>polecenie</i> +</pre> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>etykieta</code> </dt><dd> Dowolny identyfikator języka JavaScript, który nie jest słowem zarezerwowanym. +</dd></dl> +<dl><dt> <code>polecenie</code> </dt><dd> Polecenia. Polecenie <code>break</code> może być użyte z dowolnym poleceniem oznaczonym etykietą, a <code>continue</code> można użyć z zapętlonymi poleceniami oznaczonymi etykietami. +</dd></dl> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<p>Przykład użycia etykiety z poleceniem <code>break</code> +znajduje się w rodziale <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/break">break</a></code>. Przykład użycia etykiety z poleceniem <code>continue</code> znajduje się w rozdziale <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/continue">continue</a></code>. +</p> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/break">break</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/continue">continue</a></code> +</p><p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/label", "es": "es/Referencia_de_JavaScript_1.5/Sentencias/label", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/label", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/label" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/export/index.html b/files/pl/web/javascript/referencje/polecenia/export/index.html new file mode 100644 index 0000000000..3b29f1987b --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/export/index.html @@ -0,0 +1,47 @@ +--- +title: export +slug: Web/JavaScript/Referencje/Polecenia/export +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/export +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Pozwala podpisanemu skryptowi na dostarczanie własności, funkcji i obiektów do innych podpisanych lub niepodpisanych skryptów. Tej opcji nie ma w 3 edycji ECMA-262. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Instrukcja</td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.2, NES 3.0</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<p><code> +export <i>nazwa1</i>, <i>nazwa2</i>, ..., <i>nazwaN</i>; +</code> +</p><p><code> +export *; +</code> +</p> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code><i>nazwaN</i></code> </dt><dd> Własność, funkcja, lub obiekt do wyeksportowania. +</dd></dl> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Zazwyczaj informacja w podpisanym skrypcie jest dostępna tylko dla skryptów podpisanych przez tych samych wykonawców. Poprzez wyeksportowanie własności, funkcji i obiektów podpisany skrypt udostępnia tę informację dla każdego skryptu (podpisanego lub niepodpisanego). Skrypt otrzymujący używa instrukcji <code>import</code>, by uzyskać dostęp do tej informacji. +</p><p>Pierwsza składnia eksportuje określone własności, funkcje i obiekty. +</p><p>Druga składnia eksportuje wszystkie własności, funkcje i obiekty ze skryptu. +</p> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/import">import</a></code> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/export", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/export", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/export" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/for...in/index.html b/files/pl/web/javascript/referencje/polecenia/for...in/index.html new file mode 100644 index 0000000000..d8c17d3b3e --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/for...in/index.html @@ -0,0 +1,173 @@ +--- +title: for...in +slug: Web/JavaScript/Referencje/Polecenia/for...in +tags: + - JavaScript + - wyrażenie +translation_of: Web/JavaScript/Reference/Statements/for...in +--- +<div>{{jsSidebar("Statements")}}</div> + +<p><strong>Wyrażenie</strong> <strong><code>for...in</code> </strong>iteruje po nazwach wszystkich <a href="/pl/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">wyliczalnych</a> własnościach obiektu, włączając w to odziedziczone wyliczalne właściwości. <strong><code>for...in</code></strong> pomija te właściwości, które są indeksowane <a href="/pl/docs/Web/JavaScript/Referencje/Obiekty/Symbol">Symbol</a>ami.</p> + +<div>{{EmbedInteractiveExample("pages/js/statement-forin.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox notranslate">for (<em>zmienna</em> in <var>obiekt</var>) + polecenie</pre> + +<dl> + <dt><code>zmienna</code></dt> + <dd>W każdej iteracji, <em>zmiennej</em> przypisywana jest inna nazwa własności.</dd> + <dt><code>obiekt</code></dt> + <dd>Obiekt, po którego niesymbolicznych wyliczalnych własnościach iterujemy.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p><code>for...in</code> iteruje jedynie po wyliczalnych i jednocześnie niesymbolicznych właściwościach. Obiekty utworzone za pomocą wbudowanych konstruktorów (np. <code>Array</code> czy <code>Object</code>) dziedziczą niewyliczalne właściwości z m.in. <code>Object.protoype</code> oraz <code>String.prototype</code>, takie jak metoda {{jsxref("String.indexOf", "indexOf()")}} ze {{jsxref("String")}} albo {{jsxref("Object.toString", "toString()")}} z {{jsxref("Object")}}. Pętla przejdzie przez wszystkie wyliczalne właściwości – zarówno własne, jak i odziedziczone z prototypu konstruktora.</p> + +<h3 id="Usunięte_dodane_lub_zmodyfikowane_własności">Usunięte, dodane lub zmodyfikowane własności</h3> + +<p>Pętla <code>for...in</code> iteruje po właściwościach w arbitralnej kolejności (zobacz więcej w opisie operatora {{jsxref("Operators/delete", "delete")}}, dlaczego nie można liczyć na konkretną kolejność właściwości – szczególnie w różnych przeglądarkach).</p> + +<p>Jeśli właściwość zostanie zmodyfikowana w danej iteracji, a dopiero następnie odwiedzona przez <code>for...in</code>, przyjmuje tę późniejszą wartość. Usunięcie właściwości przed jej odwiedzeniem przez pętlę, spowoduje, że nie wystąpi w żadnej z późniejszych iteracji. Natomiast właściwość dodana do obiektu w trakcie iterowania może (ale nie musi) zostać odwiedzona przez pętlę.</p> + +<p>Ogólnie, w trakcie iterowania z użyciem <code>for...in</code> najlepiej jest nie modyfikować innych właściwości obiektu niż ta, która jest aktualnie odwiedzona. Nie ma żadnej gwarancji, że dodana właściwość zostanie odwiedzona, ani że właściwość usuwana zostanie odwiedzona przed skasowaniem. Podobnie, nie ma gwarancji, czy właściwość zmodyfikowana zostanie odwiedzona przed, czy po modyfikacji.</p> + +<h3 id="Iterowanie_po_tablicy_i_for...in">Iterowanie po tablicy i for...in</h3> + +<div class="note"> +<p><strong>Uwaga:</strong> wyrażenie <code>for...in</code> nie powinno być używane na obiektach klasy{{jsxref("Array")}}, gdzie kolejność elementów jest ważna.</p> +</div> + +<p>Indeksy tablic są niczym innym jak właściwościami obiektu – z tym, że ich nazwy są liczbowe, a nie słowne. Dlatego nie ma gwarancji, że <code>for...in</code> odwiedzi je w jakiejkolwiek konkretnej kolejności. Ponadto, pętla zwróci także nieliczbowe właściwości oraz te odziedziczone.</p> + +<p>Kiedy kolejność odwiedzania elementów ma znaczenie, iterowanie po elementach tablicy powinno odbywać się z użyciem pętli {{jsxref("Statements/for", "for")}} (albo {{jsxref("Array.prototype.forEach()")}} albo pętli {{jsxref("Statements/for...of", "for...of")}}), ze względu na to, że kolejność iterowania po właściwościach jest zależna od implementacji.</p> + +<h3 id="Iterowanie_jedynie_po_własnych_właściwościach">Iterowanie jedynie po własnych właściwościach</h3> + +<p>Jeżeli potrzebujesz iterować tylko po własnych właściwościach obiektu, użyj {{jsxref("Object.getOwnPropertyNames", "getOwnPropertyNames()")}}, albo sprawdzaj za każdym razem, czy właściwość jest właściwością własną za pomocą {{jsxref("Object.prototype.hasOwnProperty", "hasOwnProperty()")}}({{jsxref("Object.prototype.propertyIsEnumerable", "propertyIsEnumerable()")}} również moży zostać użyte). Alternatywnie, jeśli jesteś pewien, że nie spowoduje to problemów w kodzie, możesz rozszerzyć wbudowane prototypy o metodę sprawdzającą, czy właściwość jest własna.</p> + +<h2 id="Dlaczego_używać_for...in">Dlaczego używać for...in?</h2> + +<p>Skoro pętla <code>for...in</code> została stworzona do iterowania po właściwościach obiektu i nie jest zalecana do pracy z tablicami, to jaki może bć z niej pożytek?</p> + +<p>Najbardziej praktyczna jest w sytuacjach związanych z debugowaniem, zapewniając łatwy sposób na sprawdzenie właściwości obiektu (wypisując je do konsoli lub gdziekolwiek indziej). Oprócz tego, są sytuacje, kiedy pary klucz-wartość są indeksowane innym typem niż liczba. Wtedy po takim "słowniku" można przeiterować za pomocą <code>for...in</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_for...in">Użycie for...in</h3> + +<p>Pętla <code>for...in</code> poniżej iteruje po wszystkich wyliczalnych właściwościach obiektu <code>obj</code> i wypisuje je do konsoli.</p> + +<pre class="brush: js notranslate">var obj = {a: 1, b: 2, c: 3}; + +for (const prop in obj) { + console.log(`obj.${prop} = ${obj[prop]}`); +} + +// Wyjście: +// "obj.a = 1" +// "obj.b = 2" +// "obj.c = 3"</pre> + +<h3 id="Iterowanie_po_własnych_właściwościach">Iterowanie po własnych właściwościach</h3> + +<p>Następny przykład pokazuje użycie {{jsxref("Object.prototype.hasOwnProperty", "hasOwnProperty()")}}, aby nie wyświetlać właściwości odziedziczonych przez <code>ColoredTriangle</code>.</p> + +<pre class="brush: js notranslate">var triangle = {a: 1, b: 2, c: 3}; + +function ColoredTriangle() { + this.color = 'red'; +} + +ColoredTriangle.prototype = triangle; + +var obj = new ColoredTriangle(); + +for (const prop in obj) { + if (obj.hasOwnProperty(prop)) { + console.log(`obj.${prop} = ${obj[prop]}`); + } +} + +// Wyjście: +// "obj.color = red" +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + <th scope="col">Status</th> + <th scope="col">Komentarz</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...in statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...in statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.6.4', 'for...in statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-12.6.4', 'for...in statement')}}</td> + <td>{{Spec2('ES3')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-12.6.3', 'for...in statement')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definicja początkowa.</td> + </tr> + </tbody> +</table> + +<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2> + + + +<p>{{Compat("javascript.statements.for_in")}}</p> + +<h3 id="Zgodność_Wyrażenie_incjalizujące_w_trybie_ścisłym">Zgodność: Wyrażenie incjalizujące w trybie ścisłym</h3> + +<p>Przed Firefoksem 40, było możliwe używanie wyrażenia incjalizującego (<code>i=0</code>) w pętli <code>for...in</code>:</p> + +<pre class="brush: js example-bad notranslate">var obj = {a: 1, b: 2, c: 3}; +for (var i = 0 in obj) { + console.log(obj[i]); +} +// 1 +// 2 +// 3 +</pre> + +<p>To niestandardowe zachowanie jest ignorowane począwszy od wersji 40 i powoduje zgłoszenie błędu {{jsxref("SyntaxError")}} ("<a href="/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_for-in_initializer">for-in loop head declarations may not have initializers</a>") w <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">trybie ścisłym</a> ({{bug(748550)}} i {{bug(1164741)}}).</p> + +<p>Inne silniki, takie jak v8 (Chrome), Chakra (IE/Edge), i JSC (WebKit/Safari) również mogą przestać obsługiwać taką konstrukcję.</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("Statements/for...of", "for...of")}} – podobna konstrukcja, która iteruje po <em>wartościach </em>właściwości</li> + <li>{{jsxref("Statements/for_each...in", "for each...in")}} {{deprecated_inline}} – wyrażenie analogiczne do <code>for...of</code>, ale zdeprecjonowane</li> + <li>{{jsxref("Statements/for", "for")}}</li> + <li><a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Wyrażenia generatora</a> (używają składni <code>for...in</code>)</li> + <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Reguły wyliczalności i własności właściwości</a></li> + <li>{{jsxref("Object.getOwnPropertyNames()")}}</li> + <li>{{jsxref("Object.prototype.hasOwnProperty()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/for/index.html b/files/pl/web/javascript/referencje/polecenia/for/index.html new file mode 100644 index 0000000000..1178c277ef --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/for/index.html @@ -0,0 +1,58 @@ +--- +title: for +slug: Web/JavaScript/Referencje/Polecenia/for +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/for +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Tworzy pętlę, która składa się z trzech opcjonalnych wyrażeń, załączonych w nawiasach i oddzielonych średnikami, po których występuje instrukcja wykonywana w pętli. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Instrukcja</td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.0, NES 2.0</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<pre class="eval">for ([<i>wyrażenie-wstępne</i>]; [<i>warunek</i>]; [<i>wyrażenie-inkrementacji</i>]) + <i>instrukcja</i> +</pre> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>wyrażenie-wstępne</code> </dt><dd> Wyrażenie (włącznie z wyrażeniami przypisania) lub deklaracja zmiennej. Zazwyczaj używane do zainicjalizowania zmiennej licznika. Wyrażenie to może opcjonalnie deklarować nowe zmienne za pomocą słowa kluczowego <code>var</code>. Zmienne te nie są lokalne dla pętli, inaczej mówiąc, mają one taki sam zasięg jak pętla <code>for</code>. +</dd></dl> +<dl><dt> <code>warunek</code> </dt><dd> Wyrażenie sprawdzane podczas każdego przejścia przez pętlę. Jeśli warunek jest prawdziwy, wykonywana jest <code>instrukcja</code>. Sprawdzenie warunku jest opcjonalne. Jeśli zostanie pominięte, warunek jest zawsze uznawany jako prawdziwy. </dd></dl> +<dl><dt> <code>wyrażenie-inkrementacji</code> </dt><dd> Ogólnie używane do aktualizacji lub inkrementacji wartości zmiennej licznika. +</dd></dl> +<dl><dt> <code>instrukcja</code> </dt><dd> Instrukcja, wykonywana dopóki warunek oceniany jest jako prawdziwy. Aby wykonać większą ilość instrukcji wewnątrz pętli, użyj instrukcji <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/block">block</a> (<code>{ ... }</code>), aby pogrupować te instrukcje. +</dd></dl> +<h3 id="Przyk.C5.82ad" name="Przyk.C5.82ad"> Przykład </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_for" name="Przyk.C5.82ad:_Zastosowanie_for"> Przykład: Zastosowanie <code>for</code> </h4> +<p>Następująca instrukcja <code>for</code> rozpoczyna się deklaracją zmiennej <code>i</code> oraz zainicjalizowaniem jej wartości początkowej <code>0</code>. Instrukcja sprawdza kolejno czy wartość zmiennej <code>i</code> jest mniejsza od dziewięciu, wykonuje dwie następujące po sobie instrukcje oraz zwiększa o 1 wartość zmiennej <code>i</code> podczas każdego kolejnego przejścia przez pętlę. +</p> +<pre class="eval">for (var i = 0; i < 9; i++) { + n += i; + myfunc(n); +} +</pre> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/while">while</a>, +<a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/do...while">do...while</a></code> +</p><p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/for", "es": "es/Referencia_de_JavaScript_1.5/Sentencias/for", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/for", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/for" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/for_each...in/index.html b/files/pl/web/javascript/referencje/polecenia/for_each...in/index.html new file mode 100644 index 0000000000..52f1bb9a79 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/for_each...in/index.html @@ -0,0 +1,80 @@ +--- +title: for each...in +slug: Web/JavaScript/Referencje/Polecenia/for_each...in +tags: + - E4X + - JavaScript + - przestarzałe + - wyrażenie +translation_of: Archive/Web/JavaScript/for_each...in +--- +<div>{{jsSidebar("Statements")}}</div> + +<div class="warning"> +<p>Wyrażenie <code>for each...in</code> jest przestarzałe jako część standardu ECMA-357 (<a href="/en-US/docs/Archive/Web/E4X" title="/en-US/docs/E4X">E4X</a>), gdyż E4X nie jest już wspierany. Zamiast tego, rozważ użycie wyrażenia <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a>.<br> + <br> + <strong>Firefox obecnie ostrzega przed użyciem <code>for each...in</code> i wyrażenie to nie będzie działało od wersji Firefox 57.<br> + Zobacz <a href="/en-US/docs/Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated">Warning: JavaScript 1.6's for-each-in loops are deprecated</a> dla pomocy przy migracji do nowego standardu.</strong></p> +</div> + +<p><strong>Wyrażenie</strong><code> <strong>for each...in</strong></code><strong> </strong>iteruje daną zmienną po wszystkich wartościach własności obiektu (ang. <em>object's properties</em>). Podane wyrażenie jest wykonywane dla każdej oddzielnej własności.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">for each (<em>zmienna</em> in <em>obiekt</em>) { + <em>polecenie</em> +}</pre> + +<dl> + <dt><code>zmienna</code></dt> + <dd>Zmienna do iteracji po wartościach własnośic, opcjonalnie deklarowana ze słowem kluczowym <code>var</code>. Zmienna jest lokalna dla funkcji, a nie pętli.</dd> +</dl> + +<dl> + <dt><code>obiekt</code></dt> + <dd>Obiekt, po którego własnościach iterujemy.</dd> +</dl> + +<dl> + <dt><code>polecenie</code></dt> + <dd>Polecenie do wykonania dla każdej własności. Do wykonania wielu poleceń należy użyć wyrażenia <a href="/en-US/docs/Web/JavaScript/Reference/Statements/block">block</a> (<code>{ ... }</code>), w celu zgrupowania tychże poleceń.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Niektóre z wbudowanych własności nie są iterowalne – do tej grupy zaliczają się wszystkie wbudowane metody obiektów, jak na przykład metoda <code>indexOf</code> obiektów klasy <code>String</code>. Możliwe jest jednakże iterowanie po wszystkich własnościach zdefiniowanych przez użytkownika.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_for_each...in">Użycie <code>for each...in</code></h3> + +<p><strong>Ostrzeżenie:</strong> Nigdy nie używaj takich pętli na tablicach. Wykorzystuj to tylko na obiektach. Po więcej szczegółów, przeczytaj opis wyrażenia <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a>.</p> + +<p>Następujący fragment kodu iteruje po własnościach obiektu, obliczając ich sumę:</p> + +<pre class="brush:js">var sum = 0; +var obj = {prop1: 5, prop2: 13, prop3: 8}; + +for each (var item in obj) { + sum += item; +} + +console.log(sum); // logs "26", which is 5+13+8</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<p>To wyrażenie nie jest częścią aktualnej specyfikacji ECMA-262 specification. Zaimlementowane w JavaScript 1.6 i obecnie przestarzałe.</p> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.statements.for_each_in")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></code> – podobne wyrażenie, iterujące po <em>nazwach</em> własności;</li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code> – podobne wyrażenie, iterujące po <em>wartościach</em> własności, którego można jednak używać dla typów iterowalnych, a więc nie dla obiektówgenerycznych;</li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Statements/for">for</a></code><a href="/en-US/docs/JavaScript/Reference/Statements/for">.</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/function/index.html b/files/pl/web/javascript/referencje/polecenia/function/index.html new file mode 100644 index 0000000000..6b9eba95dd --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/function/index.html @@ -0,0 +1,68 @@ +--- +title: function +slug: Web/JavaScript/Referencje/Polecenia/function +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/function +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Deklaruje funkcję z określonymi parametrami. +</p><p>Możesz również zdefiniować funkcję używając konstruktora <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a></code> oraz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_function">operator function</a></code> (wyrażenie funkcji). +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Instrukcja</td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.0, NES 2.0 +<p>JavaScript 1.5, NES 6.0: Dodano deklaracje funkcji warunkowych (rozszerzenie Netscape). +</p> +</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262 +</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<pre class="eval">function <i>nazwa</i>([<i>argument</i>] [, <i>argument</i>] [..., <i>argument</i>]) { + <i>instrukcje</i> +} +</pre> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>nazwa</code> </dt><dd> Nazwa funkcji. +</dd></dl> +<dl><dt> <code>argument</code> </dt><dd> Nazwa argumentu, który ma zostać przekazany do funkcji. Funkcja może posiadać do 255 argumentów. +</dd></dl> +<dl><dt> <code>instrukcje</code> </dt><dd> Instrukcje, które stanowią ciało funkcji. +</dd></dl> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Aby zwrócić wartość, funkcja musi zawierać instrukcję <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/return">return</a></code> określającą wartość, która ma zostać zwrócona. +</p><p>Funkcja utworzona za pomocą instrukcji <code>function</code> jest obiektem <code>Function</code> i posiada wszystkie własności, metody i zachowania obiektów <code>Function</code>. Zobacz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a></code>, aby uzyskać szczegółowe informacje o funkcjach. +</p><p>Funkcja może zostać zadeklarowana również wewnątrz wyrażenia. W takim przypadku funkcja jest zazwyczaj anonimowa. Zobacz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_function">operator function</a></code>, aby uzyskać więcej informacji o <code>function</code> (wyrażenie funkcji). +</p><p>Funkcje mogą być deklarowane warunkowo. To znaczy, definicja funkcji może zostać zagnieżdżona wewnątrz instrukcji <code>if</code>. Technicznie rzecz biorąc, takie deklaracje nie są właściwie deklaracjami funkcji; są one wyrażeniami funkcji. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_function" name="Przyk.C5.82ad:_Zastosowanie_function"> Przykład: Zastosowanie <code>function</code> </h4> +<p>Poniższy kod deklaruje funkcję, która zwraca całkowitą kwotę sprzedaży, gdy podano liczbę sprzedanych produktów <code>a</code>, <code>b</code> i <code>c</code>. +</p> +<pre class="eval">function calc_sales(units_a, units_b, units_c) { + return units_a*79 + units_b * 129 + units_c * 699; +} +</pre> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje">Funkcje</a></code>, +<code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a></code>, +<code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_function">function operator</a></code> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/function", "es": "es/Referencia_de_JavaScript_1.5/Sentencias/function", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/function", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/function" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/function_star_/index.html b/files/pl/web/javascript/referencje/polecenia/function_star_/index.html new file mode 100644 index 0000000000..5962e0c286 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/function_star_/index.html @@ -0,0 +1,309 @@ +--- +title: function* +slug: Web/JavaScript/Referencje/Polecenia/function* +translation_of: Web/JavaScript/Reference/Statements/function* +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>Deklaracja <code><strong>function*</strong></code> (Słowo kluczowe <code>function</code> przed gwiazdką) definiuje <em>funkcję generatora</em>, która zwraca obiekt {{jsxref("Obiekty/Generator","Generator")}}.</p> + +<div class="noinclude"> +<p>Możesz także zdefinować funkcje generatora używając konstruktora {{jsxref("GeneratorFunction")}} oraz {{jsxref("Operators/function*", "function* expression")}}.</p> +</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">function* <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>Nazwa funkcji.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>Nazwa argumentu przekazywanego do funkcji. Funkcja może posiadać maksymalnie 255 argumentów.</dd> +</dl> + +<dl> + <dt><code>statements</code></dt> + <dd>Polecenia wypełniające ciało funkcji.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Generatory są specyficznym rodzajem funkcji, która może być zatrzymywana i wznawiana. Pomiędzy kolejnymi wznowieniami zachowany jest kontekst (variable bindings).</p> + +<p>Wywołanie funkcji generatora nie wykonuje poleceń w niej zawartych od razu; Zamiast tego, zwracany jest obiekt <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator">iteratora</a>. Dopiero kiedy na iteratorze wywoływana jest metoda <code>next()</code> wykonywane jest ciało funkcji, do momentu wystąpienia pierwszego wyrażenia {{jsxref("Operators/yield", "yield")}}. {{jsxref("Operators/yield", "yield")}} Określa jaka wartość zostanie zwrócona z generatora lub, jeśli użyto {{jsxref("Operators/yield*", "yield*")}}, wskazuje na kolejny do wywołania generator. Metoda <code>next()</code> zwraca obiekt z właściwością <code>value</code> zawierającą zwróconą przez {{jsxref("Operators/yield", "yield")}} wartość oraz właściowść <code>done</code> , która wskazuje czy generator zwórcił już wartość ostatniego {{jsxref("Operators/yield", "yield")}}. Wywołanie metody <code>next()</code> z argumentem, będzie wznawiało wykonywanie generatora za miejscem gdzie występował {{jsxref("Operators/yield", "yield")}} wstrzymujący generator.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Prosty_przykład">Prosty przykład</h3> + +<pre class="brush: js">function* idMaker() { + var index = 0; + while (index < 3) + yield index++; +} + +var gen = idMaker(); + +console.log(gen.next().value); // 0 +console.log(gen.next().value); // 1 +console.log(gen.next().value); // 2 +console.log(gen.next().value); // undefined +// ...</pre> + +<h3 id="Przykład_z_yield*">Przykład z yield*</h3> + +<pre class="brush: js">function* anotherGenerator(i) { + yield i + 1; + yield i + 2; + yield i + 3; +} + +function* generator(i) { + yield i; + yield* anotherGenerator(i); + yield i + 10; +} + +var gen = generator(10); + +console.log(gen.next().value); // 10 +console.log(gen.next().value); // 11 +console.log(gen.next().value); // 12 +console.log(gen.next().value); // 13 +console.log(gen.next().value); // 20 +</pre> + +<h3 id="Przekazywanie_parametrów_do_generatora">Przekazywanie parametrów do generatora</h3> + +<pre class="brush: js">function* logGenerator() { + console.log(yield); + console.log(yield); + console.log(yield); +} + +var gen = logGenerator(); + +// the first call of next executes from the start of the function +// until the first yield statement +gen.next(); +gen.next('pretzel'); // pretzel +gen.next('california'); // california +gen.next('mayonnaise'); // mayonnaise +</pre> + +<h3 id="Wyrażenie_return_wewnątrz_generatora">Wyrażenie return wewnątrz generatora</h3> + +<pre class="brush: js">function* yieldAndReturn() { + yield "Y"; + return "R"; + yield "unreachable"; +} + +var gen = yieldAndReturn() +console.log(gen.next()); // { value: "Y", done: false } +console.log(gen.next()); // { value: "R", done: true } +console.log(gen.next()); // { value: undefined, done: true }</pre> + +<h3 id="Generator_nie_jest_typowym_konstruktorem">Generator nie jest typowym konstruktorem</h3> + +<pre class="brush: js example-bad">function* f() {} +var obj = new f; // throws "TypeError: f is not a constructor"</pre> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#', 'function*')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES2016', '#', 'function*')}}</td> + <td>{{Spec2('ES2016')}}</td> + <td>Changed that generators should not have [[Construct]] trap and will throw when used with <code>new</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#', 'function*')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th> Edge</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(39.0)}}</td> + <td>{{CompatGeckoDesktop("26.0")}}</td> + <td>{{CompatNo}}</td> + <td>13</td> + <td>26</td> + <td>{{CompatSafari("10")}}</td> + </tr> + <tr> + <td><code>yield*</code></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("27.0")}}</td> + <td>{{CompatNo}}</td> + <td>13</td> + <td>26</td> + <td>{{CompatSafari("10")}}</td> + </tr> + <tr> + <td><code>IteratorResult</code> object instead of throwing</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("29.0")}}</td> + <td>{{CompatNo}}</td> + <td>13</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Not constructable with <code>new</code> as per ES2016</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("43.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Trailing comma in parameters</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("52.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("26.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("10")}}</td> + <td>{{CompatChrome(39.0)}}</td> + </tr> + <tr> + <td><code>yield*</code></td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("27.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("10")}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><code>IteratorResult</code> object instead of throwing</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("29.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Not constructable with <code>new</code> as per ES2016</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("43.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Trailing comma in parameters</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("52.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Firefox-specific_notes">Firefox-specific notes</h2> + +<h4 id="Generatory_i_iteratory_w_Firefox_przed_wersją_26">Generatory i iteratory w Firefox przed wersją 26</h4> + +<p>Starsze wersje Firefox implementują nieco inną, bardziej archaiczną propozycje specyfikacji. W starszych wersjach definiowanie generatorów odbywało się za pomocą wyłącznie słowa kluczowego <code>function</code> (bez dodatkowej gwiazdki). Tą i wiele innych drobnych różnic można sprawdzić na <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Legacy_generator_function">Legacy generator function</a>.</p> + +<h4 id="IteratorResult_zwraca_obiekt_zamiast_rzucać_wyjątek"><code>IteratorResult</code> zwraca obiekt zamiast rzucać wyjątek</h4> + +<p>Począwszy od silnika Gecko 29 {{geckoRelease(29)}}, zakończony generator nie rzuca już więcej wyjątkami {{jsxref("TypeError")}} "generator has already finished". W zamian za to zwraca obiekt <code>IteratorResult</code> w postaci <code>{ value: undefined, done: true }</code> ({{bug(958951)}}).</p> + +<h2 id="Zobacz_także">Zobacz także</h2> + +<ul> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("GeneratorFunction")}} object</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li> + <li>{{jsxref("Operators/yield", "yield")}}</li> + <li>{{jsxref("Operators/yield*", "yield*")}}</li> + <li>{{jsxref("Function")}} object</li> + <li>{{jsxref("Statements/function", "function declaration")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li> + <li>Other web resources: + <ul> + <li><a href="http://facebook.github.io/regenerator/">Regenerator</a> an ES2015 generator compiler to ES5</li> + <li><a href="http://www.youtube.com/watch?v=qbKWsbJ76-s">Forbes Lindesay: Promises and Generators: control flow utopia -- JSConf EU 2013</a></li> + <li><a href="https://www.youtube.com/watch?v=ZrgEZykBHVo&list=PLuoyIZT5fPlG44bPq50Wgh0INxykdrYX7&index=1">Hemanth.HM: The New gen of *gen(){}</a></li> + <li><a href="http://taskjs.org/">Task.js</a></li> + </ul> + </li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/funkcja_async/index.html b/files/pl/web/javascript/referencje/polecenia/funkcja_async/index.html new file mode 100644 index 0000000000..95b488405e --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/funkcja_async/index.html @@ -0,0 +1,264 @@ +--- +title: funkcja async +slug: Web/JavaScript/Referencje/Polecenia/funkcja_async +translation_of: Web/JavaScript/Reference/Statements/async_function +--- +<div> +<div>{{jsSidebar("Statements")}}</div> + +<p><span class="seoSummary">Deklaracja funkcji <code><strong>async</strong></code> definiuje <strong>funkcję asynchroniczną</strong>, która zwraca obiekt {{jsxref("Global_Objects/AsyncFunction","AsyncFunction")}}.</span> Funkcja asynchroniczna to funkcja, która działa asynchroniczne poprzez zdarzenie pętli używając bezwarunkowego {{jsxref("Promise")}} do zwrócenia wyniku. Składnia i struktura kodu używanego przy funkcjach asynchronicznych jest jednakże bardziej podobna do znanych ze standardowych funkcji synchronicznych.</p> + +<div class="noinclude"> +<p>Możesz zdefiniować funkcje asynchroniczne również poprzez użycie {{jsxref("Operators/async_function", "async function expression", "", 1)}}.</p> +</div> +</div> + +<div>{{EmbedInteractiveExample("pages/js/statement-async.html", "taller")}}</div> + +<p class="hidden">Źródło niniejszego interaktywnego demo znajduje się na repozytorium GitHuba. Jeśli chcesz mieć wkład w ten interaktywny projekt demo po prostu sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij nam żądanie pull.</p> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">async function <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { + <em>statements</em> +} +</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>name</code></dt> + <dd>Nazwa funkcji.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>Nazwa argumentu, który zostanie podany do funkcji.</dd> +</dl> + +<dl> + <dt><code>statements</code></dt> + <dd>Wyrażenia stanowiące ciało funkcji.</dd> +</dl> + +<h3 id="Wartość_zwrotna_return">Wartość zwrotna (return)</h3> + +<p><code><a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise">Promise</a></code>, które zostanie rozwiązane z wartością zwróconą przez funkcję asynchroniczną lub odrzucone z nieprzechwyconym wyjątkiem wyrzuconym z funkcji asynchronicznej.</p> + +<h2 id="Opis">Opis</h2> + +<p>Funkcja <code>async</code> może zawierać wyrażenie {{jsxref("Operators/await", "await")}}, które wstrzymuje wywołanie funkcji asynchronicznej i czeka na przekazaną deklarację <code>Promise</code>i wtedy wznawia wywołanie funkcji <code>async</code> oraz interpretuje jako wartość rozwiązaną.<br> + <br> + Pamiętaj, że polecenie <code>await</code> działa wyłącznie wewnątrz funkcji <code>async</code>. Jeśli użyjesz go poza ciałem funkcji <code>async</code> otrzymasz <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">SyntaxError</a></code>.</p> + +<p>Zauważ, że kiedy funkcja <code>async</code> jest wstrzymana, funkcja wywołująca kontynuuje działanie (otrzymując domyślny Promise zwracany przez funkcję <code>async</code>).</p> + +<div class="note"> +<p>Celem funkcji <code>async</code>/<code>await</code> jest uproszczenie działania używając obietnic (promises) synchronicznie oraz by wykonać pewne działania w grupie <code>Promises</code>. Tak, jak <code>Promises</code> są podobne do strukturalnych callbacków, tak <code>async</code>/<code>await</code> jest podobne do kombinacji generatorów i obietnic.</p> +</div> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Prosty_przykład">Prosty przykład</h3> + +<pre class="brush: js">var resolveAfter2Seconds = function() { + console.log("starting slow promise"); + return new Promise(resolve => { + setTimeout(function() { + resolve("slow"); + console.log("wolna obietnica została wykonana"); + }, 2000); + }); +}; + +var resolveAfter1Second = function() { + console.log("starting fast promise"); + return new Promise(resolve => { + setTimeout(function() { + resolve("fast"); + console.log("szybka obietnica została wykonana"); + }, 1000); + }); +}; + +var sequentialStart = async function() { + console.log('==START SEKWENCYJNY=='); + + // 1. Niemalże natychmiast dochodzi do wywołania + const slow = await resolveAfter2Seconds(); + console.log(slow); // 2. to zostaje wywołanie 2s po 1. + + const fast = await resolveAfter1Second(); + console.log(fast); // 3. to zostaje wykonane 3s po 1. +} + +var concurrentStart = async function() { + console.log('==RÓWNOCZESNY START z await=='); + const slow = resolveAfter2Seconds(); // licznik startuje od razu + const fast = resolveAfter1Second(); // licznik startuje od razu + + // 1. Niemalże natychmiast dochodzi do wywołania + console.log(await slow); // 2. jest wywołane 2s po 1. + console.log(await fast); // 3. jest wywołane 2s po 1., natychmiast po 2., podczas gdy szybka jest już wykonana +} + +var concurrentPromise = function() { + console.log('==RÓWNOCZESNY START z Promise.all=='); + return Promise.all([resolveAfter2Seconds(), resolveAfter1Second()]).then((messages) => { + console.log(messages[0]); // wolne + console.log(messages[1]); // szybkie + }); +} + +var parallel = async function() { + console.log('==RÓWNOLEGLE z await Promise.all=='); + + // Równolegle startują dwa zadania i czekamy na zakończenie działania obu + await Promise.all([ + (async()=>console.log(await resolveAfter2Seconds()))(), + (async()=>console.log(await resolveAfter1Second()))() + ]); +} + +// This function does not handle errors. See warning below! +var parallelPromise = function() { + console.log('==PARALLEL with Promise.then=='); + resolveAfter2Seconds().then((message)=>console.log(message)); + resolveAfter1Second().then((message)=>console.log(message)); +} + +sequentialStart(); // after 2 seconds, logs "slow", then after 1 more second, "fast" + +// wait above to finish +setTimeout(concurrentStart, 4000); // after 2 seconds, logs "slow" and then "fast" + +// wait again +setTimeout(concurrentPromise, 7000); // same as concurrentStart + +// wait again +setTimeout(parallel, 10000); // truly parallel: after 1 second, logs "fast", then after 1 more second, "slow" + +// wait again +setTimeout(parallelPromise, 13000); // same as parallel +</pre> + +<div class="note"> +<h4 id="await_and_parallelism"><code>await</code> and parallelism</h4> + +<p>In <code>sequentialStart</code>, execution suspends 2 seconds for the first <code>await</code>, and then again another 1 second for the second <code>await</code>. The second timer is not created until the first has already fired. The code finishes after 3 seconds.</p> + +<p>In <code>concurrentStart</code>, both timers are created and then <code>await</code>ed. The timers are running concurrently, which means the code finishes in 2 rather than 3 seconds, i.e. the slowest timer.<br> + However the <code>await</code> calls are still running in series, which means the second <code>await</code> will wait for the first one to finish. In this case, this leads to the processing of the result of the fastest timer to be performed after the slowest.</p> + +<p>If you wish to fully perform two or more jobs in parallel, you must use <code>await Promise.all([job1(), job2()])</code> as shown in the <code>parallel</code> example.</p> +</div> + +<div class="warning"> +<h4 id="asyncawait_vs_Promisethen_and_error_handling"><code>async</code>/<code>await</code> vs Promise#then and error handling</h4> + +<p>Most async functions can also be written as regular functions using Promises. However <code>async</code> functions are a little bit less error-prone when it comes to error handling.</p> + +<p>Both <code>concurrentStart</code> and <code>concurrentPromise</code> are functionally equivalent.<br> + In <code>concurrentStart</code>, if either of the <code>await</code>ed calls fail, the exception will be automatically caught, the async function execution interrupted, and the Error propagated to the caller through the implicit return Promise.<br> + For the same to happen in the Promise case, the function must take care of returning a <code>Promise</code> which captures the completion of the function. In <code>concurrentPromise</code> that means <code>return</code>ing the promise from <code>Promise.all([]).then()</code>. As a matter of fact, a previous version of this example forgot to do this!</p> + +<p>It is however still possible for <code>async</code> functions to mistakenly swallow errors.<br> + Take for example the <code>parallel</code> async function. If it didn't <code>await</code> (or <code>return</code>) the result of the <code>Promise.all([])</code> call, any Error would not have been propagated.<br> + While the <code>parallelPromise</code> example seem simple, it does not handle errors at all! Doing so would require a similar <code>return </code><code>Promise.all([])</code>.</p> +</div> + +<h3 id="Rewriting_a_promise_chain_with_an_async_function">Rewriting a promise chain with an <code>async</code> function</h3> + +<p>An API that returns a {{jsxref("Promise")}} will result in a promise chain, and it splits the function into many parts. Consider the following code:</p> + +<pre class="brush: js">function getProcessedData(url) { + return downloadData(url) // returns a promise + .catch(e => { + return downloadFallbackData(url); // returns a promise + }) + .then(v => { + return processDataInWorker(v); // returns a promise + }); +} +</pre> + +<p>it can be rewritten with a single <code>async</code> function as follows:</p> + +<pre class="brush: js">async function getProcessedData(url) { + let v; + try { + v = await downloadData(url); + } catch(e) { + v = await downloadFallbackData(url); + } + return processDataInWorker(v); +} +</pre> + +<p>Note that in the above example, there is no <code>await</code> statement on the <code>return</code> statement, because the return value of an <code>async function</code> is implicitly wrapped in {{jsxref("Promise.resolve")}}.</p> + +<div class="blockIndicator note"> +<h4 id="return_await_promiseValue_vs._return_promiseValue"><code>return await promiseValue;</code> vs. <code>return promiseValue;</code></h4> + +<p>The implicit wrapping of return values in {{jsxref("Promise.resolve")}} does not imply that <code>return await promiseValue;</code> is functionally equivalent to <code>return promiseValue;</code></p> + +<p>Consider the following rewrite of the above code that returns null if <code>processDataInWorker</code> were to reject with an error:</p> + +<pre class="brush: js">async function getProcessedData(url) { + let v; + try { + v = await downloadData(url); + } catch(e) { + v = await downloadFallbackData(url); + } + try { + return await processDataInWorker(v); // Note the `return await` vs. just `return` + } catch (e) { + return null; + } +} +</pre> + +<p>Having simply written <code>return processDataInWorker(v);</code> would have caused the {{jsxref("Promise")}} returned by the function to reject instead of resolving to <code>null</code> in the case where <code>processDataInWorker(v)</code> rejects. This highlights the subtle difference between <code>return foo;</code> and <code>return await foo;</code> which is that <code>return foo;</code> will immediately return <code>foo</code> and never throw even if <code>foo</code> is a promise and rejects whereas <code>return await foo;</code> will wait for <code>foo</code> to resolve or reject if it's a promise and will throw <strong>before returning</strong> if it rejects.</p> +</div> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-async-function-definitions', 'async function')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initial definition in ES2017.</td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-async-function-definitions', 'async function')}}</td> + <td>{{Spec2('ES8')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.statements.async_function")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Operators/async_function", "async function expression")}}</li> + <li>{{jsxref("AsyncFunction")}} object</li> + <li>{{jsxref("Operators/await", "await")}}</li> + <li><a href="http://innolitics.com/10x/javascript-decorators-for-promise-returning-functions/">"Decorating Async Javascript Functions" on "innolitics.com"</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/if...else/index.html b/files/pl/web/javascript/referencje/polecenia/if...else/index.html new file mode 100644 index 0000000000..38dd3c8f8a --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/if...else/index.html @@ -0,0 +1,65 @@ +--- +title: if...else +slug: Web/JavaScript/Referencje/Polecenia/if...else +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/if...else +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Wykonuje blok poleceń, jeśli dany warunek jest spełniony. Jeśli warunek nie jest spełniony, może zostać wykonany inny blok poleceń. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Polecenie</td> +</tr> +<tr> +<td>Zaimplementowane w:</td> +<td>JavaScript 1.0, NES 2.0</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<pre class="eval">if (warunek) { + <i>polecenia1</i> +} +[else { + <i>polecenia2</i> +}] +</pre> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>warunek</code> </dt><dd> może być dowolnym wyrażeniem JavaScriptu przyjmującym wartości logiczne (true, false) lub mogącym być na wartości logiczne przekonwertowane. Warunek musi być ujęty w nawiasach. Jeśli warunek jest spełniony (ma wartość true), wykonywane są polecenia w bloku <code>polecenia1</code>. +</dd></dl> +<dl><dt> <code>polecenia1</code>, <code>polecenia2</code> </dt><dd> mogą być dowolnymi poleceniami JavaScriptu, w tym zagnieżdżonymi poleceniami <code>if...else</code>. Bloki wielu poleceń muszą być ujęte w nawiasy klamrowe. +</dd></dl> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Nie powinno się używać prostych operatorów przypisania w wyrażeniu warunkowym. Przykładowo, nie należy używać kodu podobnego do poniższego: +</p> +<pre>if(x = y) +{ + /* zrób coś */ +} +</pre> +<p>Jeśli potrzebujesz użyć przypisania w wyrażeniu warunkowym, użyj dodatkowej pary nawiasów. Na przykład: <code>if( (x = y) )</code>. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_if...else" name="Przyk.C5.82ad:_Zastosowanie_if...else"> Przykład: Zastosowanie <code>if...else</code> </h4> +<pre>if (cipher_char == from_char) { + result = result + to_char + x++} +else + result = result + clear_char +</pre> +<p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/if...else", "es": "es/Referencia_de_JavaScript_1.5/Sentencias/if...else", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/if...else", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/if...else" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/import/index.html b/files/pl/web/javascript/referencje/polecenia/import/index.html new file mode 100644 index 0000000000..406050c420 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/import/index.html @@ -0,0 +1,55 @@ +--- +title: import +slug: Web/JavaScript/Referencje/Polecenia/import +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/import +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Pozwala zaimportować własności, funkcje i obiekty z podpisanego skryptu, który wyeksportował informację. +</p><p>Tej cechy nie ma w 3 edycji ECMA 262. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Instrukcja</td> +</tr> +<tr> +<td>Zaimplementowane w:</td> +<td>JavaScript 1.2, NES 3.0</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<p><code> +import <i>objectName</i>.<i>name1</i>, <i>objectName</i>.<i>name2</i>, ..., <i>objectName</i>.<i>nameN</i>; +</code> +</p><p><code> +import <i>objectName</i>.<i>*</i>; +</code> +</p> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>objectName</code> </dt><dd> Nazwa obiektu, który przyjmie zaimportowane nazwy. +</dd></dl> +<dl><dt> <code>nameN</code> </dt><dd> Własność, funkcja lub obiekt do zaimportowania. +</dd></dl> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Parametr <code>objectName</code> jest nazwą obiektu, który przyjmie zaimportowane nazwy. Na przykład jeśli <code>f</code> i <code>p</code> zostały wyeksportowane i <code>obj</code> jest obiektem z importującego skryptu, to poniższy kod zrobi <code>f</code> i <code>p</code> dostępnymi jako własności <code>obj</code> wewnątrz skryptu importującego. +</p> +<pre class="eval">import obj.f, obj.p; +</pre> +<p>Pierwsza składnia importuje określone własności, funkcje i obiekty z wyeksportowanego skryptu. +</p><p>Druga składnia importuje wszystkie własności, funkcje i obiekty z wyeksportowanego skryptu. +</p><p>Zazwyczaj informacja w podpisanym skrypcie jest dostępna tylko dla skryptów podpisanych przez tych samych wykonawców. Poprzez wyeksportowanie (używając instrukcji <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/export">export</a></code>) własności, funkcji i obiektów podpisany skrypt robi tę informację dostępną dla każdego skryptu (podpisanego lub niepodpisanego). Skrypt otrzymujący używa instrukcji <code>import</code>, by uzyskać dostęp do tej informacji. +</p><p>Skrypt musi załadować skrypt eksportowy do okna, ramki lub warstwy zanim będzie on mógł zaimportować i użyć którejkolwiek z wyeksportowanych własności, funkcji lub obiektów. +</p> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/export">export</a></code> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/import", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/import", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/import" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/index.html b/files/pl/web/javascript/referencje/polecenia/index.html new file mode 100644 index 0000000000..b6f58b783c --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/index.html @@ -0,0 +1,149 @@ +--- +title: Polecenia +slug: Web/JavaScript/Referencje/Polecenia +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>JavaScript applications consist of statements with an appropriate syntax. A single statement may span multiple lines. Multiple statements may occur on a single line if each statement is separated by a semicolon. This isn't a keyword, but a group of keywords.</p> + +<h2 id="Statements_and_declarations_by_category">Statements and declarations by category</h2> + +<p>For an alphabetical listing see the sidebar on the left.</p> + +<h3 id="Control_flow">Control flow</h3> + +<dl> + <dt>{{jsxref("Statements/block", "Block")}}</dt> + <dd>A block statement is used to group zero or more statements. The block is delimited by a pair of curly brackets.</dd> + <dt>{{jsxref("Statements/break", "break")}}</dt> + <dd>Terminates the current loop, switch, or label statement and transfers program control to the statement following the terminated statement.</dd> + <dt>{{jsxref("Statements/continue", "continue")}}</dt> + <dd>Terminates execution of the statements in the current iteration of the current or labeled loop, and continues execution of the loop with the next iteration.</dd> + <dt>{{jsxref("Statements/Empty", "Empty")}}</dt> + <dd>An empty statement is used to provide no statement, although the JavaScript syntax would expect one.</dd> + <dt>{{jsxref("Statements/if...else", "if...else")}}</dt> + <dd>Executes a statement if a specified condition is true. If the condition is false, another statement can be executed.</dd> + <dt>{{jsxref("Statements/switch", "switch")}}</dt> + <dd>Evaluates an expression, matching the expression's value to a case clause, and executes statements associated with that case.</dd> + <dt>{{jsxref("Statements/throw", "throw")}}</dt> + <dd>Throws a user-defined exception.</dd> + <dt>{{jsxref("Statements/try...catch", "try...catch")}}</dt> + <dd>Marks a block of statements to try, and specifies a response, should an exception be thrown.</dd> +</dl> + +<h3 id="Declarations">Declarations</h3> + +<dl> + <dt>{{jsxref("Statements/var", "var")}}</dt> + <dd>Declares a variable, optionally initializing it to a value.</dd> + <dt>{{jsxref("Statements/let", "let")}}</dt> + <dd>Declares a block scope local variable, optionally initializing it to a value.</dd> + <dt>{{jsxref("Statements/const", "const")}}</dt> + <dd>Declares a read-only named constant.</dd> +</dl> + +<h3 id="Functions_and_classes">Functions and classes</h3> + +<dl> + <dt>{{jsxref("Statements/function", "function")}}</dt> + <dd>Declares a function with the specified parameters.</dd> + <dt>{{jsxref("Statements/function*", "function*")}}</dt> + <dd>Generator Functions enable writing <a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">iterators</a> more easily.</dd> + <dt>{{jsxref("Statements/async_function", "async function")}}</dt> + <dd>Declares an async function with the specified parameters.</dd> + <dt>{{jsxref("Statements/return", "return")}}</dt> + <dd>Specifies the value to be returned by a function.</dd> + <dt>{{jsxref("Statements/class", "class")}}</dt> + <dd>Declares a class.</dd> +</dl> + +<h3 id="Iterations">Iterations</h3> + +<dl> + <dt>{{jsxref("Statements/do...while", "do...while")}}</dt> + <dd>Creates a loop that executes a specified statement until the test condition evaluates to false. The condition is evaluated after executing the statement, resulting in the specified statement executing at least once.</dd> + <dt>{{jsxref("Statements/for", "for")}}</dt> + <dd>Creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a statement executed in the loop.</dd> + <dt>{{deprecated_inline}} {{non-standard_inline()}} {{jsxref("Statements/for_each...in", "for each...in")}}</dt> + <dd>Iterates a specified variable over all values of object's properties. For each distinct property, a specified statement is executed.</dd> + <dt>{{jsxref("Statements/for...in", "for...in")}}</dt> + <dd>Iterates over the enumerable properties of an object, in arbitrary order. For each distinct property, statements can be executed.</dd> + <dt>{{jsxref("Statements/for...of", "for...of")}}</dt> + <dd>Iterates over iterable objects (including {{jsxref("Global_Objects/Array","arrays","","true")}}, array-like objects, <a href="/en-US/docs/JavaScript/Guide/Iterators_and_Generators">iterators and generators</a>), invoking a custom iteration hook with statements to be executed for the value of each distinct property.</dd> + <dt>{{jsxref("Statements/while", "while")}}</dt> + <dd>Creates a loop that executes a specified statement as long as the test condition evaluates to true. The condition is evaluated before executing the statement.</dd> +</dl> + +<h3 id="Others">Others</h3> + +<dl> + <dt>{{jsxref("Statements/debugger", "debugger")}}</dt> + <dd>Invokes any available debugging functionality. If no debugging functionality is available, this statement has no effect.</dd> + <dt>{{jsxref("Statements/export", "export")}}</dt> + <dd>Used to export functions to make them available for imports in external modules, another scripts.</dd> + <dt>{{jsxref("Statements/import", "import")}}</dt> + <dd>Used to import functions exported from an external module, another script.</dd> + <dt>{{jsxref("Statements/label", "label")}}</dt> + <dd>Provides a statement with an identifier that you can refer to using a <code>break</code> or <code>continue</code> statement.</dd> +</dl> + +<dl> + <dt>{{deprecated_inline}} {{jsxref("Statements/with", "with")}}</dt> + <dd>Extends the scope chain for a statement.</dd> +</dl> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-12', 'Statements')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition</td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-12', 'Statements')}}</td> + <td>{{Spec2('ES3')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12', 'Statements')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>New: function*, let, for...of, yield, class</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("javascript.statements")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators">Operators</a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/return/index.html b/files/pl/web/javascript/referencje/polecenia/return/index.html new file mode 100644 index 0000000000..ed7849ed65 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/return/index.html @@ -0,0 +1,48 @@ +--- +title: return +slug: Web/JavaScript/Referencje/Polecenia/return +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/return +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Określa wartość, która ma być zwrócona przez funkcję. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Polecenie</td> +</tr> +<tr> +<td>Zaimplementowane w:</td> +<td>JavaScript 1.0, NES 2.0</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<p><code> +return <i>wyrażenie</i>; +</code> +</p> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>wyrażenie</code> </dt><dd> wyrażenie, którego wynik ma być zwrócony. +</dd></dl> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_return" name="Przyk.C5.82ad:_Zastosowanie_return"> Przykład: Zastosowanie <code>return</code> </h4> +<p>Poniższa funkcja zwraca kwadrat swojego argumentu <code>x</code> (gdzie <code>x</code> jest liczbą). +</p> +<pre>function kwadrat(x) { + return x * x; +} +</pre> +<p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/return", "es": "es/Referencia_de_JavaScript_1.5/Sentencias/return", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/return", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/return" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/switch/index.html b/files/pl/web/javascript/referencje/polecenia/switch/index.html new file mode 100644 index 0000000000..d131e042ca --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/switch/index.html @@ -0,0 +1,285 @@ +--- +title: switch +slug: Web/JavaScript/Referencje/Polecenia/switch +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/switch +--- +<div>{{jsSidebar("Statements")}}</div> + +<p><span class="seoSummary">Instrukcja switch ocenia wyrażenie, dopasowując wartość wyrażenia do klauzuli case, i wykonuje instrukcje powiązane z tym case, a także instrukcje w przypadkach następujących po dopasowanym przypadku.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/statement-switch.html")}}</div> + +<p class="hidden">Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do projektu interaktywnych przykładów, sklonuj https://github.com/mdn/interactive-examples i wyślij nam prośbę o pobranie.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">switch (expression) { + case value1: + //Statements executed when the + //result of expression matches value1 + [break;] + case value2: + //Statements executed when the + //result of expression matches value2 + [break;] + ... + case valueN: + //Statements executed when the + //result of expression matches valueN + [break;] + [default: + //Statements executed when none of + //the values match the value of the expression + [break;]] +}</pre> + +<dl> + <dt><code>expression</code></dt> + <dd>Wyrażenie, którego wynik jest dopasowany do każdej klauzuli przypadku.</dd> + <dt><code>case valueN</code> {{optional_inline}}</dt> + <dd>Klauzula przypadku używana do dopasowania do wyrażenia. Jeśli wyrażenie pasuje do podanej wartościN, instrukcje wewnątrz klauzuli case są wykonywane do końca instrukcji switch lub break.</dd> + <dt><code>default</code> {{optional_inline}}</dt> + <dd>A <code>default</code> clause; if provided, this clause is executed if the value of <code>expression</code> doesn't match any of the <code>case</code> clauses.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>A switch statement first evaluates its expression. It then looks for the first <code>case</code> clause whose expression evaluates to the same value as the result of the input expression (using the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">strict comparison</a>, <code>===</code>) and transfers control to that clause, executing the associated statements. (If multiple cases match the provided value, the first case that matches is selected, even if the cases are not equal to each other.)</p> + +<p>If no matching <code>case</code> clause is found, the program looks for the optional <code>default</code> clause, and if found, transfers control to that clause, executing the associated statements. If no <code>default</code> clause is found, the program continues execution at the statement following the end of <code>switch</code>. By convention, the <code>default</code> clause is the last clause, but it does not need to be so.</p> + +<p>The optional <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/break" title="JavaScript/Reference/Statements/break">break</a></code> statement associated with each case label ensures that the program breaks out of switch once the matched statement is executed and continues execution at the statement following switch. If <code>break</code> is omitted, the program continues execution at the next statement in the <code>switch</code> statement.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_switch">Using <code>switch</code></h3> + +<p>In the following example, if <code>expr</code> evaluates to "Bananas", the program matches the value with case "Bananas" and executes the associated statement. When <code>break</code> is encountered, the program breaks out of <code>switch</code> and executes the statement following <code>switch</code>. If <code>break</code> were omitted, the statement for case "Cherries" would also be executed.</p> + +<pre class="brush: js">switch (expr) { + 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': + case 'Papayas': + console.log('Mangoes and papayas are $2.79 a pound.'); + break; + default: + console.log('Sorry, we are out of ' + expr + '.'); +} + +console.log("Is there anything else you'd like?"); +</pre> + +<h3 id="What_happens_if_I_forgot_a_break">What happens if I forgot a break?</h3> + +<p>If you forget a break then the script will run from the case where the criterion is met and will run the case after that regardless if criterion was met. See example here:</p> + +<pre class="brush: js">var foo = 0; +switch (foo) { + case -1: + console.log('negative 1'); + break; + case 0: // foo is 0 so criteria met here so this block will run + console.log(0); + // NOTE: the forgotten break would have been here + case 1: // no break statement in 'case 0:' so this case will run as well + console.log(1); + break; // it encounters this break so will not continue into 'case 2:' + case 2: + console.log(2); + break; + default: + console.log('default'); +}</pre> + +<h3 id="Can_I_put_a_default_between_cases">Can I put a default between cases?</h3> + +<p>Yes, you can! JavaScript will drop you back to the default if it can't find a match:</p> + +<pre class="brush: js">var foo = 5; +switch (foo) { + case 2: + console.log(2); + break; // it encounters this break so will not continue into 'default:' + default: + console.log('default') + // fall-through + case 1: + console.log('1'); +} +</pre> + +<p>It also works when you put default before all other cases.</p> + +<h3 id="Rewriting_multiple_If_statements_with_Switch">Rewriting multiple If statements with Switch</h3> + +<p>Shown below as a possibility.</p> + +<pre class="brush: js">var a = 100; +var b = NaN; +switch (true) { + case isNaN(a) || isNaN(b): + console.log('NaNNaN'); + break; + case a === b: + console.log(0); + break; + case a < b: + console.log(-1); + break; + default: + console.log(1); +} +</pre> + +<h3 id="Methods_for_multi-criteria_case">Methods for multi-criteria case</h3> + +<p>Source for this technique is here:</p> + +<p><a href="http://stackoverflow.com/questions/13207927/switch-statement-multiple-cases-in-javascript">Switch statement multiple cases in JavaScript (Stack Overflow)</a></p> + +<h4 id="Multi-case_-_single_operation">Multi-case - single operation</h4> + +<p>This method takes advantage of the fact that if there is no break below a case statement it will continue to execute the next case statement regardless if the case meets the criteria. See the section titled "What happens if I forgot a break?"</p> + +<p>This is an example of a single operation sequential switch statement, where four different values perform exactly the same.</p> + +<pre class="brush: js">var Animal = 'Giraffe'; +switch (Animal) { + case 'Cow': + case 'Giraffe': + case 'Dog': + case 'Pig': + console.log('This animal will go on Noah\'s Ark.'); + break; + case 'Dinosaur': + default: + console.log('This animal will not.'); +}</pre> + +<h4 id="Multi-case_-_chained_operations">Multi-case - chained operations</h4> + +<p>This is an example of a multiple-operation sequential switch statement, where, depending on the provided integer, you can receive different output. This shows you that it will traverse in the order that you put the case statements, and it does not have to be numerically sequential. In JavaScript, you can even mix in definitions of strings into these case statements as well.</p> + +<pre class="brush: js">var foo = 1; +var output = 'Output: '; +switch (foo) { + case 10: + output += 'So '; + case 1: + output += 'What '; + output += 'Is '; + case 2: + output += 'Your '; + case 3: + output += 'Name'; + case 4: + output += '?'; + console.log(output); + break; + case 5: + output += '!'; + console.log(output); + break; + default: + console.log('Please pick a number from 0 to 6!'); +}</pre> + +<p>The output from this example:</p> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Value</th> + <th scope="col">Log text</th> + </tr> + <tr> + <td>foo is NaN or not 1, 2, 3, 4, 5 or 10</td> + <td>Please pick a number from 0 to 6!</td> + </tr> + <tr> + <td>10</td> + <td>Output: So What Is Your Name?</td> + </tr> + <tr> + <td>1</td> + <td>Output: What Is Your Name?</td> + </tr> + <tr> + <td>2</td> + <td>Output: Your Name?</td> + </tr> + <tr> + <td>3</td> + <td>Output: Name?</td> + </tr> + <tr> + <td>4</td> + <td>Output: ?</td> + </tr> + <tr> + <td>5</td> + <td>Output: !</td> + </tr> + </tbody> +</table> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.11', 'switch statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("javascript.statements.switch")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else"><code>if...else</code></a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/throw/index.html b/files/pl/web/javascript/referencje/polecenia/throw/index.html new file mode 100644 index 0000000000..a8d57064f5 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/throw/index.html @@ -0,0 +1,197 @@ +--- +title: throw +slug: Web/JavaScript/Referencje/Polecenia/throw +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/throw +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>The <strong><code>throw</code> statement</strong> throws a user-defined exception. Execution of the current function will stop (the statements after <code>throw</code> won't be executed), and control will be passed to the first <a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch"><code>catch</code></a> block in the call stack. If no <code>catch</code> block exists among caller functions, the program will terminate.</p> + +<div>{{EmbedInteractiveExample("pages/js/statement-throw.html")}}</div> + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">throw <em>expression</em>; </pre> + +<dl> + <dt><code>expression</code></dt> + <dd>The expression to throw.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>Use the <code>throw</code> statement to throw an exception. When you throw an exception, <code>expression</code> specifies the value of the exception. Each of the following throws an exception:</p> + +<pre class="brush: js">throw 'Error2'; // generates an exception with a string value +throw 42; // generates an exception with the value 42 +throw true; // generates an exception with the value true</pre> + +<p>Also note that the <code>throw</code> statement is affected by <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">automatic semicolon insertion (ASI)</a> as no line terminator between the <code>throw</code> keyword and the expression is allowed.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Throw_an_object">Throw an object</h3> + +<p>You can specify an object when you throw an exception. You can then reference the object's properties in the <code>catch</code> block. The following example creates an object of type <code>UserException</code> and uses it in a <code>throw</code> statement.</p> + +<pre class="brush: js">function UserException(message) { + this.message = message; + this.name = 'UserException'; +} +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] !== undefined) { + return months[mo]; + } else { + throw new UserException('InvalidMonthNo'); + } +} + +try { + // statements to try + var myMonth = 15; // 15 is out of bound to raise the exception + var monthName = getMonthName(myMonth); +} catch (e) { + monthName = 'unknown'; + console.log(e.message, e.name); // pass exception object to err handler +} +</pre> + +<h3 id="Another_example_of_throwing_an_object">Another example of throwing an object</h3> + +<p>The following example tests an input string for a U.S. zip code. If the zip code uses an invalid format, the throw statement throws an exception by creating an object of type <code>ZipCodeFormatException</code>.</p> + +<pre class="brush: js">/* + * Creates a ZipCode object. + * + * Accepted formats for a zip code are: + * 12345 + * 12345-6789 + * 123456789 + * 12345 6789 + * + * If the argument passed to the ZipCode constructor does not + * conform to one of these patterns, an exception is thrown. + */ + +function ZipCode(zip) { + zip = new String(zip); + pattern = /[0-9]{5}([- ]?[0-9]{4})?/; + if (pattern.test(zip)) { + // zip code value will be the first match in the string + this.value = zip.match(pattern)[0]; + this.valueOf = function() { + return this.value + }; + this.toString = function() { + return String(this.value) + }; + } else { + throw new ZipCodeFormatException(zip); + } +} + +function ZipCodeFormatException(value) { + this.value = value; + this.message = 'does not conform to the expected format for a zip code'; + this.toString = function() { + return this.value + this.message; + }; +} + +/* + * This could be in a script that validates address data + * for US addresses. + */ + +const ZIPCODE_INVALID = -1; +const ZIPCODE_UNKNOWN_ERROR = -2; + +function verifyZipCode(z) { + try { + z = new ZipCode(z); + } catch (e) { + if (e instanceof ZipCodeFormatException) { + return ZIPCODE_INVALID; + } else { + return ZIPCODE_UNKNOWN_ERROR; + } + } + return z; +} + +a = verifyZipCode(95060); // returns 95060 +b = verifyZipCode(9560); // returns -1 +c = verifyZipCode('a'); // returns -1 +d = verifyZipCode('95060'); // returns 95060 +e = verifyZipCode('95060 1234'); // returns 95060 1234 +</pre> + +<h3 id="Rethrow_an_exception">Rethrow an exception</h3> + +<p>You can use <code>throw</code> to rethrow an exception after you catch it. The following example catches an exception with a numeric value and rethrows it if the value is over 50. The rethrown exception propagates up to the enclosing function or to the top level so that the user sees it.</p> + +<pre class="brush: js">try { + throw n; // throws an exception with a numeric value +} catch (e) { + if (e <= 50) { + // statements to handle exceptions 1-50 + } else { + // cannot handle this exception, so rethrow + throw e; + } +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.4</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.13', 'throw statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-throw-statement', 'throw statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-throw-statement', 'throw statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("javascript.statements.throw")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch"><code>try...catch</code></a></li> +</ul> diff --git a/files/pl/web/javascript/referencje/polecenia/var/index.html b/files/pl/web/javascript/referencje/polecenia/var/index.html new file mode 100644 index 0000000000..aff42bcdac --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/var/index.html @@ -0,0 +1,61 @@ +--- +title: var +slug: Web/JavaScript/Referencje/Polecenia/var +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/var +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Deklaruje zmienną oraz opcjonalnie przypisuje jej wartość początkową. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td class="header" colspan="2">Instrukcja</td> +</tr> +<tr> +<td>Zaimplementowana w:</td> +<td>JavaScript 1.0, NES 2.0</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<p><code> +var <i>varname1</i> {{ mediawiki.external('= <i>value1</i>') }}, <i>varname2</i> {{ mediawiki.external('= <i>value2</i>') }}, ..., <i>varnameN</i> {{ mediawiki.external('= <i>valueN</i>') }}; +</code> +</p> +<h3 id="Parametry" name="Parametry"> Parametry </h3> +<dl><dt> <code>varnameN</code> </dt><dd> Nazwa zmiennej. Może być dowolnym, dozwolonym identyfikatorem. +</dd></dl> +<dl><dt> <code>valueN</code> </dt><dd> Zainicjalizowanie wartości zmiennej. Może być dowolnym, dozwolonym wyrażeniem. +</dd></dl> +<h3 id="Opis" name="Opis"> Opis </h3> +<p>Zasięgiem zmiennej jest aktualna funkcja lub, jeśli zmienna została zadeklarowana poza funkcją, aktualna aplikacja. +</p><p>Użycie <code>var</code> poza funkcją jest opcjonalne; przypisanie wartości do niezadeklarowanej zmiennej domyślnie deklaruje ją jako zmienna globalną. Zalecane jest jednak, aby zawsze używać <code>var</code>, ponadto jest to konieczne wewnątrz funkcji w następujących przypadkach: +</p> +<ul><li> Jeśli zmienna w zasięgu obejmującym funkcję (łącznie z zasięgiem globalnym) posiada tę samą nazwę. +</li><li> Jeśli funkcje rekurencyjne lub złożone używają zmiennych o tych samych nazwach, które mają być lokalne. +</li></ul> +<p>Niepowodzenie zadeklarowania zmiennej w tych przypadkach będzie najprawdopodobniej prowadzić do niespodziewanych wyników. +</p> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<h4 id="Przyk.C5.82ad:_Zastosowanie_var" name="Przyk.C5.82ad:_Zastosowanie_var"> Przykład: Zastosowanie <code>var</code> </h4> +<p>Poniższy przykład deklaruje dwie zmienne, <code>num_hits</code> i <code>cust_no</code> i przypisuje im obu początkową wartość 0. +</p> +<pre class="eval">var num_hits = 0, cust_no = 0; +</pre> +<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3> +<p><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/const">const</a> +</p><p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/var", "es": "es/Referencia_de_JavaScript_1.5/Sentencias/var", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/var", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/var" } ) }} diff --git a/files/pl/web/javascript/referencje/polecenia/while/index.html b/files/pl/web/javascript/referencje/polecenia/while/index.html new file mode 100644 index 0000000000..103762fd01 --- /dev/null +++ b/files/pl/web/javascript/referencje/polecenia/while/index.html @@ -0,0 +1,61 @@ +--- +title: while +slug: Web/JavaScript/Referencje/Polecenia/while +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Statements/while +--- +<p> +</p> +<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3> +<p>Tworzy pętlę, która wylicza wyrażenie <code>i</code>, jeśli jest ono prawdą, wykonuje blok poleceń. Wykonywanie pętli powtarza się, póki warunek jest prawdziwy. +</p> +<table class="fullwidth-table"> +<tbody><tr> +<td colspan="2">Polecenie</td> +</tr> +<tr> +<td>Zaimplementowane w:</td> +<td>JavaScript 1.0, NES 2.0</td> +</tr> +<tr> +<td>Wersja ECMA:</td> +<td>ECMA-262</td> +</tr> +</tbody></table> +<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia"> Składnia </h3> +<pre class="eval">while (<i>warunek</i>) { + <i>polecenia</i> +} +</pre> +<h3 id="Parametery" name="Parametery"> Parametery </h3> +<dl><dt> <code>warunek</code> </dt><dd> Wyliczany przed każdym wejściem w blok poleceń. Jeśli warunek jest prawdą, polecenia w bloku są wykonywane. Jeśli nie jest, sterowanie przepływa do pierwszego polecenia za pętlą. +</dd></dl> +<dl><dt> <code>polecenia</code> </dt><dd> Blok poleceń wykonywanych póki warunek jest spełniony. Dobrą praktyką jest stosowanie w tym miejscu wcięć (indentacji), zwiększających czytelność kodu. +</dd></dl> +<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3> +<p>Poniższa pętla <code>while</code> wykonuje się dopóki n jest mniejsze niż trzy. +</p> +<pre class="eval">n = 0; +x = 0; +while(n < 3) { + n ++; + x += n; +} +</pre> +<p>Po każdej iteracji pętla zwiększa n i dodaje je do x. Dlatego też x i n przyjmują następujące wartości: +</p> +<ul><li> Po pierwszym przejściu: n = 1, x = 1 +</li><li> Po drugim przejściu: n = 2, x = 3 +</li><li> Po trzecim przejściu: n = 3, x = 6 +</li></ul> +<p>Po ukończeniu trzeciego przejścia warunek n < 3 nie jest już spełniony, zatem wykonywanie pętli kończy się. +</p><p><br> +</p><p><br> +</p> +<div class="noinclude"> +</div> +{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Statements/while", "es": "es/Referencia_de_JavaScript_1.5/Sentencias/while", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Instructions/while", "ja": "ja/Core_JavaScript_1.5_Reference/Statements/while" } ) }} diff --git a/files/pl/web/javascript/referencje/przestarzałe_własności_i_metody/index.html b/files/pl/web/javascript/referencje/przestarzałe_własności_i_metody/index.html new file mode 100644 index 0000000000..92c805ac17 --- /dev/null +++ b/files/pl/web/javascript/referencje/przestarzałe_własności_i_metody/index.html @@ -0,0 +1,292 @@ +--- +title: Przestarzałe własności i metody +slug: Web/JavaScript/Referencje/Przestarzałe_własności_i_metody +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Strony_wymagające_dopracowania + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Deprecated_and_obsolete_features +--- +<div>{{JsSidebar("More")}}</div> + +<p>This page lists features of JavaScript that are deprecated (that is, still available but planned for removal) and obsolete (that is, no longer usable).</p> + +<h2 id="Deprecated_features">Deprecated features</h2> + +<p>These deprecated features can still be used, but should be used with caution because they are expected to be removed entirely sometime in the future. You should work to remove their use from your code.</p> + +<h3 id="RegExp_properties">RegExp properties</h3> + +<p>The following properties are deprecated. This does not affect their use in {{jsxref("String.replace", "replacement strings", "", 1)}}:</p> + +<table class="standard-table"> + <tbody> + <tr> + <th>Property</th> + <th>Description</th> + </tr> + <tr> + <td>{{jsxref("RegExp.n", "$1-$9")}}</td> + <td> + <p>Parenthesized substring matches, if any.<br> + <strong>Warning:</strong> Using these properties can result in problems, since browser extensions can modify them. Avoid them!</p> + </td> + </tr> + <tr> + <td>{{jsxref("RegExp.input", "$_")}}</td> + <td>See <code>input</code>.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.multiline", "$*")}}</td> + <td>See <code>multiline</code>.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.lastMatch", "$&")}}</td> + <td>See <code>lastMatch</code>.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.lastParen", "$+")}}</td> + <td>See <code>lastParen</code>.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.leftContext", "$`")}}</td> + <td>See <code>leftContext</code>.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.rightContext", "$'")}}</td> + <td>See <code>rightContext</code>.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.input", "input")}}</td> + <td>The string against which a regular expression is matched.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.lastMatch", "lastMatch")}}</td> + <td>The last matched characters.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.lastParen", "lastParen")}}</td> + <td>The last parenthesized substring match, if any.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.leftContext", "leftContext")}}</td> + <td>The substring preceding the most recent match.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.rightContext", "rightContext")}}</td> + <td>The substring following the most recent match.</td> + </tr> + </tbody> +</table> + +<p>The following are now properties of <code>RegExp</code> instances, no longer of the <code>RegExp</code> object:</p> + +<table class="standard-table"> + <tbody> + <tr> + <th>Property</th> + <th>Description</th> + </tr> + <tr> + <td>{{jsxref("RegExp.global", "global")}}</td> + <td>Whether or not to test the regular expression against all possible matches in a string, or only against the first.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.ignoreCase", "ignoreCase")}}</td> + <td>Whether or not to ignore case while attempting a match in a string.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.lastIndex", "lastIndex")}}</td> + <td>The index at which to start the next match.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.multiline", "multiline")}}</td> + <td>Whether or not to search in strings across multiple lines.</td> + </tr> + <tr> + <td>{{jsxref("RegExp.source", "source")}}</td> + <td>The text of the pattern.</td> + </tr> + </tbody> +</table> + +<h3 id="RegExp_methods">RegExp methods</h3> + +<ul> + <li>The {{jsxref("RegExp.compile", "compile()")}} method is deprecated.</li> + <li>The <code>valueOf</code> method is no longer specialized for <code>RegExp</code>. Use {{jsxref("Object.valueOf()")}}.</li> +</ul> + +<h3 id="Function_properties">Function properties</h3> + +<ul> + <li>The {{jsxref("Global_Objects/Function/caller", "caller")}} and {{jsxref("Global_Objects/Function/arguments", "arguments")}} properties are deprecated, because they leak the function caller. Instead of the arguments property, you should use the {{jsxref("Functions/arguments", "arguments")}} object inside function closures.</li> +</ul> + +<h3 id="Legacy_generator">Legacy generator</h3> + +<ul> + <li>{{jsxref("Statements/Legacy_generator_function", "Legacy generator function statement")}} and {{jsxref("Operators/Legacy_generator_function", "Legacy generator function expression")}} are deprecated. Use {{jsxref("Statements/function*", "function* statement")}} and {{jsxref("Operators/function*", "function* expression")}} instead.</li> + <li>{{jsxref("Operators/Array_comprehensions", "JS1.7/JS1.8 Array comprehension", "#Differences_to_the_older_JS1.7.2FJS1.8_comprehensions")}} and {{jsxref("Operators/Generator_comprehensions", "JS1.7/JS1.8 Generator comprehension", "#Differences_to_the_older_JS1.7.2FJS1.8_comprehensions")}} are deprecated.</li> +</ul> + +<h3 id="Iterator">Iterator</h3> + +<ul> + <li>{{jsxref("Global_Objects/StopIteration", "StopIteration")}} is deprecated.</li> + <li>{{jsxref("Global_Objects/Iterator", "Iterator")}} is deprecated.</li> +</ul> + +<h3 id="Object_methods">Object methods</h3> + +<ul> + <li>{{jsxref("Object.watch", "watch")}} and {{jsxref("Object.unwatch", "unwatch")}} are deprecated. Use {{jsxref("Proxy")}} instead.</li> + <li><code>__iterator__</code> is deprecated.</li> + <li>{{jsxref("Object.noSuchMethod", "__noSuchMethod__")}} is deprecated. Use {{jsxref("Proxy")}} instead.</li> +</ul> + +<h3 id="Date_methods">Date methods</h3> + +<ul> + <li>{{jsxref("Global_Objects/Date/getYear", "getYear")}} and {{jsxref("Global_Objects/Date/setYear", "setYear")}} are affected by the Year-2000-Problem and have been subsumed by {{jsxref("Global_Objects/Date/getFullYear", "getFullYear")}} and {{jsxref("Global_Objects/Date/setFullYear", "setFullYear")}}.</li> + <li>You should use {{jsxref("Global_Objects/Date/toISOString", "toISOString")}} instead of the deprecated {{jsxref("Global_Objects/Date/toGMTString", "toGMTString")}} method in new code.</li> + <li>{{jsxref("Global_Objects/Date/toLocaleFormat", "toLocaleFormat")}} is deprecated.</li> +</ul> + +<h3 id="Functions">Functions</h3> + +<ul> + <li>{{jsxref("Operators/Expression_closures", "Expression closures", "", 1)}} are deprecated. Use regular {{jsxref("Operators/function", "functions")}} or {{jsxref("Functions/Arrow_functions", "arrow functions", "", 1)}} instead.</li> +</ul> + +<h3 id="Proxy">Proxy</h3> + +<ul> + <li><a href="/en-US/docs/Archive/Web/Old_Proxy_API">Proxy.create</a> and <a href="/en-US/docs/Archive/Web/Old_Proxy_API">Proxy.createFunction</a> are deprecated. Use {{jsxref("Proxy")}} instead.</li> + <li>The following traps are obsolete: + <ul> + <li><code>hasOwn</code> ({{bug(980565)}}, Firefox 33).</li> + <li><code>getEnumerablePropertyKeys</code> ({{bug(783829)}}, Firefox 37)</li> + <li><code>getOwnPropertyNames</code> ({{bug(1007334)}}, Firefox 33)</li> + <li><code>keys</code> ({{bug(1007334)}}, Firefox 33)</li> + </ul> + </li> +</ul> + +<h3 id="Escape_sequences">Escape sequences</h3> + +<ul> + <li>Octal escape sequences (\ followed by one, two, or three octal digits) are deprecated in string and regular expression literals.</li> + <li>The {{jsxref("Global_Objects/escape", "escape")}} and {{jsxref("Global_Objects/unescape", "unescape")}} functions are deprecated. Use {{jsxref("Global_Objects/encodeURI", "encodeURI")}}, {{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent")}}, {{jsxref("Global_Objects/decodeURI", "decodeURI")}} or {{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent")}} to encode and decode escape sequences for special characters.</li> +</ul> + +<h3 id="String_methods">String methods</h3> + +<ul> + <li><a href="https://developer.mozilla.org/en-US/docs/tag/HTML%20wrapper%20methods">HTML wrapper methods</a> like {{jsxref("String.prototype.fontsize")}} and {{jsxref("String.prototype.big")}}.</li> + <li>{{jsxref("String.prototype.quote")}} is removed from Firefox 37.</li> + <li>non standard <code>flags</code> parameter in {{jsxref("String.prototype.search")}}, {{jsxref("String.prototype.match")}}, and {{jsxref("String.prototype.replace")}} are deprecated.</li> +</ul> + +<h2 id="Obsolete_features">Obsolete features</h2> + +<p>These obsolete features have been entirely removed from JavaScript and can no longer be used as of the indicated version of JavaScript.</p> + +<h3 id="Object">Object</h3> + +<table class="standard-table"> + <tbody> + <tr> + <th>Property</th> + <th>Description</th> + </tr> + <tr> + <td>{{jsxref("Global_Objects/Object/count", "__count__")}}</td> + <td>Returns the number of enumerable properties directly on a user-defined object.</td> + </tr> + <tr> + <td>{{jsxref("Global_Objects/Object/Parent", "__parent__")}}</td> + <td>Points to an object's context.</td> + </tr> + <tr> + <td>{{jsxref("Global_Objects/Object/eval", "Object.prototype.eval()")}}</td> + <td>Evaluates a string of JavaScript code in the context of the specified object.</td> + </tr> + <tr> + <td>{{jsxref("Object.observe()")}}</td> + <td>Asynchronously observing the changes to an object.</td> + </tr> + <tr> + <td>{{jsxref("Object.unobserve()")}}</td> + <td>Remove observers.</td> + </tr> + <tr> + <td>{{jsxref("Object.getNotifier()")}}</td> + <td>Creates an object that allows to synthetically trigger a change.</td> + </tr> + </tbody> +</table> + +<h3 id="Function">Function</h3> + +<table class="standard-table"> + <tbody> + <tr> + <th>Property</th> + <th>Description</th> + </tr> + <tr> + <td>{{jsxref("Global_Objects/Function/arity", "arity")}}</td> + <td>Number of formal arguments.</td> + </tr> + </tbody> +</table> + +<h3 id="Array">Array</h3> + +<table class="standard-table"> + <tbody> + <tr> + <td>Property</td> + <td>Description</td> + </tr> + <tr> + <td>{{jsxref("Array.observe()")}}</td> + <td>Asynchronously observing changes to Arrays.</td> + </tr> + <tr> + <td>{{jsxref("Array.unobserve()")}}</td> + <td>Remove observers.</td> + </tr> + </tbody> +</table> + +<h3 id="Number">Number</h3> + +<ul> + <li>{{jsxref("Number.toInteger()")}}</li> +</ul> + +<h3 id="ParallelArray">ParallelArray</h3> + +<ul> + <li>{{jsxref("ParallelArray")}}</li> +</ul> + +<h3 id="Statements">Statements</h3> + +<ul> + <li>{{jsxref("Statements/for_each...in", "for each...in")}} is deprecated. Use {{jsxref("Statements/for...of", "for...of")}} instead.</li> + <li>Destructuring {{jsxref("Statements/for...in", "for...in")}} is deprecated. Use {{jsxref("Statements/for...of", "for...of")}} instead.</li> + <li>let blocks and let expressions are obsolete.</li> +</ul> + +<h3 id="E4X">E4X</h3> + +<p>See <a href="/en-US/docs/Archive/Web/E4X">E4X</a> for more information.</p> + +<h3 id="Sharp_variables">Sharp variables</h3> + +<p>See <a href="/en-US/docs/Archive/Web/Sharp_variables_in_JavaScript">Sharp variables in JavaScript</a> for more information.</p> diff --git a/files/pl/web/javascript/referencje/słowa_zarezerwowane/index.html b/files/pl/web/javascript/referencje/słowa_zarezerwowane/index.html new file mode 100644 index 0000000000..b190262a84 --- /dev/null +++ b/files/pl/web/javascript/referencje/słowa_zarezerwowane/index.html @@ -0,0 +1,17 @@ +--- +title: Słowa zarezerwowane +slug: Web/JavaScript/Referencje/Słowa_zarezerwowane +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Lexical_grammar#Keywords +--- +<p> </p> +<p>Słowa zarezerwowane nie mogą być używane jako nazwy zmiennych, funkcji, metod ani obiektów języka JavaScript. Niektóre z nich są słowami kluczowymi języka JavaScript, inne zarezerwowano do przyszłych zastosowań.</p> +<ul> <li><code>abstract</code></li> <li><code>boolean</code></li> <li><code>break</code></li> <li><code>byte</code></li> <li><code>case</code></li> <li><code>catch</code></li> <li><code>char</code></li> <li><code>class</code></li> <li><code>const</code></li> <li><code>continue</code></li> <li><code>debugger</code></li> <li><code>default</code></li> <li><code>delete</code></li> <li><code>do</code></li> <li><code>double</code></li> <li><code>else</code> <code>enum</code> <code>export</code> <code>extends</code> <code>false</code> <code>final</code> <code>finally</code> <code>float</code> <code>for</code> <code>function</code> <code>goto</code> <code>if</code> <code>implements</code> <code>import</code> <code>in</code></li> <li><code>instanceof</code> <code>int</code> <code>interface</code> <code>long</code> <code>native</code> <code>new</code> <code>null</code> <code>package</code> <code>private</code> <code>protected</code> <code>public</code> <code>return</code> <code>short</code> <code>static</code> <code>super</code></li> <li><code>switch</code> <code>synchronized</code> <code>this</code> <code>throw</code> <code>throws</code> <code>transient</code> <code>true</code> <code>try</code> <code>typeof</code> <code>var</code> <code>void</code> <code>volatile</code> <code>while</code> <code>with</code></li> +</ul> +<p> </p> + +<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Reserved_Words", "es": "es/Referencia_de_JavaScript_1.5/Palabras_Reservadas", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Mots_r\u00e9serv\u00e9s", "ja": "ja/Core_JavaScript_1.5_Reference/Reserved_Words" } ) }}</p> diff --git a/files/pl/web/javascript/shells/index.html b/files/pl/web/javascript/shells/index.html new file mode 100644 index 0000000000..67356169f7 --- /dev/null +++ b/files/pl/web/javascript/shells/index.html @@ -0,0 +1,42 @@ +--- +title: Powłoki JavaScript +slug: Web/JavaScript/Shells +translation_of: Web/JavaScript/Shells +--- +<div>{{JsSidebar}}</div> + +<p> </p> + +<p>Powłoki JavaScript pozwalają szybko przetestować fragmenty kodu <a href="/en-US/docs/Web/JavaScript">JavaScript</a> bez konieczności ponownego ładowania strony internetowej. Są niezwykle przydatne przy tworzeniu i debugowaniu kodu.</p> + +<h2 id="Samodzielne_powłoki_JavaScript">Samodzielne powłoki JavaScript</h2> + +<p>Następujące powłoki JavaScript są samodzielnymi środowiskami, takimi jak Perl lub Python.</p> + +<ul> + <li><a href="http://nodejs.org/">Node.js</a> - Node.js to platforma do łatwego budowania szybkich, skalowalnych aplikacji sieciowych.</li> + <li><a class="external" href="http://www.jsdb.org/">JSDB</a> - samodzielna powłoka JavaScript z kompilowanymi binariami dla systemów Windows, Mac i Linux.</li> + <li><a class="external" href="http://javalikescript.free.fr/">JavaLikeScript</a> - samodzielna, rozszerzalna powłoka JavaScript, zawierająca zarówno biblioteki natywne, jak i JavaScript.</li> + <li><a class="external" href="http://gluescript.sourceforge.net/">GLUEscript</a> - samodzielna powłoka JavaScript do pisania międzyplatformowych aplikacji JavaScript. Może używać wxWidgets dla aplikacji GUI i był wcześniej nazywany wxJavaScript.</li> + <li><a class="external" href="http://jspl.msg.mx/">jspl</a> - samodzielna powłoka JavaScript rozszerzona przez Perl. Może korzystać z modułów Perla bezpośrednio z JavaScript: DBI do integracji z bazą danych, GTK2 do aplikacji GUI, POSIX do programowania systemów itp. Obecnie najlepsze z CPAN dla programistów JavaScript.</li> + <li><a class="external" href="http://shelljs.org">ShellJS</a> - Przenośne polecenia powłoki Unix dla Node.js</li> +</ul> + +<h2 id="Lista_powłok_JavaScript">Lista powłok JavaScript</h2> + +<p>Następujące powłoki JavaScript działają z Mozillą.</p> + +<ul> + <li>Firefox ma wbudowaną konsolę JavaScript o nazwie <a href="/en-US/docs/Tools/Scratchpad">Scratchpad</a>, począwszy od wersji 6.</li> + <li><a href="/en-US/docs/Mozilla/Projects/SpiderMonkey/Introduction_to_the_JavaScript_shell">JavaScript Shell</a> (<code>js</code>) - interpreter wiersza poleceń dla JavaScript</li> + <li><a href="/en-US/docs/Mozilla/XPConnect/xpcshell">xpcshell</a> to powłoka z obsługą <a href="/en-US/docs/Mozilla/Tech/XPCOM/Language_bindings/XPConnect">XPConnect</a>, przydatna czasem przy rozwoju Mozilli.</li> + <li><a class="external" href="http://babeljs.io/repl">Babel REPL</a> - <a href="https://en.wikipedia.org/wiki/REPL">REPL</a> oparty na przeglądarce do eksperymentowania z <u>przyszłym</u> JavaScript.</li> + <li><a class="external" href="http://es6console.com">ES6Console.com</a> - konsola JavaScript o otwartym kodzie źródłowym do testowania kodu ECMAScript 2015 w przeglądarce.</li> + <li><a class="external" href="http://jsconsole.com/">jsconsole.com</a> - konsola JavaScript o otwartym kodzie źródłowym z możliwością łatwego łączenia się do określonych wyrażeń</li> + <li><a class="external" href="http://www.squarefree.com/shell/">JavaScript Shell (strona internetowa)</a> - dostępna również w ramach rozszerzenia<a class="link-https" href="https://addons.mozilla.org/en-US/firefox/addon/7434"> Developer's Extension</a></li> + <li><a class="external" href="http://www.billyreisinger.com/jash/">Jash: JavaScript Shell</a> - powłoka oparta na DHTML, która zapewnia dostęp do strony internetowej z linii poleceń.</li> + <li><a class="external" href="http://hyperstruct.net/projects/mozrepl">MozRepl</a> - połącz się z Firefoksem i innymi aplikacjami Mozilli, przeglądaj i modyfikuj je od środka, gdy są uruchomione.</li> + <li><a class="external link-https" href="https://addons.mozilla.org/en-US/firefox/addon/execute-js/">Execute JS</a> - (nie jest już wspierane) - rozszerzenie Firefox, które dostarcza rozszerzoną konsolę JavaScript, w której możesz wygodnie wprowadzać i uruchamiać dowolny kod JavaScript i modyfikować funkcje.</li> + <li><a class="external link-https" href="https://addons.mozilla.org/addon/159546">xqjs</a> - prosta konsola dla Firefoksa.</li> + <li><a class="external link-https" href="https://addons.mozilla.org/en-US/firefox/addon/firebug/">Firebug</a> - narzędzia dla programistów dla Firefoksa, w tym konsola.</li> +</ul> diff --git a/files/pl/web/javascript/typed_arrays/index.html b/files/pl/web/javascript/typed_arrays/index.html new file mode 100644 index 0000000000..a9ede19c94 --- /dev/null +++ b/files/pl/web/javascript/typed_arrays/index.html @@ -0,0 +1,277 @@ +--- +title: Tablice reprezentujące typy JavaScript +slug: Web/JavaScript/Typed_arrays +translation_of: Web/JavaScript/Typed_arrays +--- +<div> +<div>{{JsSidebar("Advanced")}}</div> +</div> + +<p>Jako, że aplikacje internetowe stają się coraz bardziej potężne, zapewniając takie możliwości jak chociażby manipulacja audio i wideo, dostęp do surowych danych używając WebSocket, i tak dalej, stało się jasne, że są sytuacje, w których przydałoby się, żeby kod JavaScript był w stanie szybko i łatwo manipulować surowymi danymi binarnymi. W przeszłości, musiało być to symulowane przez traktowanie surowych danych jako <a href="/en-US/docs/JavaScript/Reference/Global_Objects/String" title="JavaScript/Reference/Global Objects/String">string</a> i używanie metody <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/String/charCodeAt" title="JavaScript/Reference/Global Objects/String/charCodeAt">charCodeAt()</a>,</code> aby przeczytać bajty z buforu danych.</p> + +<p>Jakkolwiek, jest to wolne i podatne na błędy, ze względu na potrzebę wielu konwersji (szczególnie jeśli dane binarne nie są tak naprawdę danymi w formacie bajtów, ale, na przykład, 32-bitowymi liczbami całkowitymi lub zmiennoprzecinkowymi).</p> + +<p>Tablice zawierające typy JavaScript zapewniają mechanizm dostępu do danych binarnych dużo bardziej wydajnie.</p> + +<table class="topicpage-table"> + <tbody> + <tr> + <td> + <h2 class="Documentation" id="Documentation" name="Documentation">Dokumentacja</h2> + + <dl> + <dt><a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBuffer" title="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBuffer"><code>ArrayBuffer</code></a></dt> + <dd>The <code>ArrayBuffer</code> is a data type that is used to represent a generic, fixed-length binary data buffer. You can't directly manipulate the contents of an <code>ArrayBuffer</code>; instead, you create an <a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBufferView" title="en/JavaScript typed arrays/ArrayBufferView"><code>ArrayBufferView</code></a> object which represents the buffer in a specific format, and use that to read and write the contents of the buffer.</dd> + <dt><a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBufferView" title="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBufferView"><code>ArrayBufferView</code></a></dt> + <dd>The <code>ArrayBufferView</code> type describes a particular view on the contents of an <a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBuffer" title="en/JavaScript typed arrays/ArrayBuffer">ArrayBuffer</a>'s data. Of note is that you may create multiple views into the same buffer, each looking at the buffer's contents starting at a particular offset. This makes it possible to set up views of different data types to read the contents of a buffer based on the types of data at specific offsets into the buffer</dd> + <dt><a href="/en-US/docs/Web/JavaScript/Typed_arrays/DataView" title="/en-US/docs/Web/JavaScript/Typed_arrays/DataView"><code>DataView</code></a></dt> + <dd> + <p>The <code>DataView</code> view provides a low-level interface for reading data from and writing it to an <code><a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBuffer" title="en/JavaScript_typed_arrays/ArrayBuffer">ArrayBuffer</a></code>.</p> + </dd> + <dt><a href="/en-US/docs/Web/JavaScript/Typed_arrays/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code></a> <span class="inlineIndicator" style="font-weight: normal;" title="This API is not native.">Non native</span></dt> + <dd>In this article is published a library of ours whose aims are: + <ul> + <li>creating a <strong><a href="http://en.wikipedia.org/wiki/C_%28programming_language%29">C</a>-like interface for strings</strong> (i.e. array of characters codes — an<a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBufferView"> <code>ArrayBufferView</code></a> in JavaScript) based upon the JavaScript <a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBuffer"><code>ArrayBuffer</code></a> interface,</li> + <li>creating an <strong>highly scalable</strong> library, that anyone can extend by adding methods to the object <code>StringView.prototype</code>,</li> + <li>creating a collection of methods for such string-like objects (since now: <code>stringView</code>s) which <strong>work strictly on arrays of numbers</strong> rather than on creating new immutable JavaScript strings,</li> + <li><strong>working with other Unicode encodings</strong> different from default JavaScript's UTF-16 {{domxref("DOMString")}}s,</li> + </ul> + </dd> + <dt><a href="/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer" title="/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">Getting <code>ArrayBuffer</code>s or typed arrays from <em>Base64</em>-encoded strings</a></dt> + <dd>Code snippets to get <code>ArrayBuffer</code>s or typed arrays from <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding" title="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding"><em>Base64</em>-encoded</a> strings.</dd> + <dt><a href="/en-US/docs/Web/API/FileReader#readAsArrayBuffer()" title="/en-US/docs/Web/API/FileReader#readAsArrayBuffer()"><code>FileReader.prototype.readAsArrayBuffer()</code></a></dt> + <dd>The <code>FileReader.prototype.readAsArrayBuffer()</code> method starts reading the contents of the specified <a href="/en-US/docs/Web/API/Blob" title="/en-US/docs/DOM/Blob"><code>Blob</code></a> or <a href="/en-US/docs/Web/API/File" title="/en-US/docs/DOM/File"><code>File</code></a>.</dd> + <dt><a href="/en-US/docs/Web/API/XMLHttpRequest#send()" title="/en-US/docs/Web/API/XMLHttpRequest#send()"><code>XMLHttpRequest.prototype.send()</code></a></dt> + <dd><code>XMLHttpRequest</code> instances' <code>send()</code> method now supports typed arrays and <a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBuffer" title="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBuffer"><code>ArrayBuffer</code></a>s as argument.</dd> + </dl> + + <p><span class="alllinks"><a href="/en-US/docs/tag/JavaScript%20typed%20arrays" title="tag/JavaScript%20typed%20arrays">View All...</a></span></p> + </td> + <td> + <h2 class="Community" id="Community" name="Community">Społeczność</h2> + + <ul> + <li>Zobacz forum Mozilla... {{ DiscussionList("dev-web-development", "mozilla.dev.web.development") }}</li> + </ul> + + <h2 class="Tools" id="Tools" name="Tools">Narzędzia</h2> + + <ul> + <li><a href="/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer" title="/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">Getting <code>ArrayBuffer</code>s or typed arrays from <em>Base64</em>-encoded strings</a></li> + <li><a href="/en-US/docs/Code_snippets/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code> – a C-like representation of strings based on typed arrays</a></li> + </ul> + + <p><span class="alllinks"><a href="/en-US/docs/tag/JavaScript%20typed%20arrays:Tools" title="tag/JavaScript%20typed%20arrays:Tools">View All...</a></span></p> + + <h2 class="Related_Topics" id="Related_Topics" name="Related_Topics">Powiązane tematy</h2> + + <ul> + <li><a href="/en-US/docs/Web/API/File" title="/en-US/docs/DOM/File"><code>File</code></a></li> + <li><code><a href="/en-US/docs/Web/API/Blob" title="/en-US/docs/DOM/Blob">Blob</a></code></li> + </ul> + </td> + </tr> + </tbody> +</table> + +<h2 id="Bufory_i_widoki_struktura_tablic_reprezentujących_typy">Bufory i widoki: struktura tablic reprezentujących typy</h2> + +<p>To achieve maximum flexibility and efficiency, JavaScript typed arrays split the implementation into a <strong>buffer</strong> and a <strong>view</strong>. A buffer (implemented by the <a href="/en-US/docs/JavaScript_typed_arrays/ArrayBuffer" title="JavaScript typed arrays/ArrayBuffer"><code>ArrayBuffer</code></a> class) is an object representing a chunk of data; it has no format to speak of, and offers no mechanism for accessing its contents. In order to access the memory contained in a buffer, you need to use a view. A view provides a context—that is, a data type, starting offset, and number of elements—that turns the data into an actual typed array. Views are implemented by the <a href="/en-US/docs/JavaScript_typed_arrays/ArrayBufferView" title="JavaScript typed arrays/ArrayBufferView"><code>ArrayBufferView</code></a> class and its subclasses.</p> + +<h2 id="Podklasy_tablic_reprezentujących_typy">Podklasy tablic reprezentujących typy</h2> + +<p>The following subclasses provide buffer views allowing access to the data in specific data types. Note that the classes that work with more than one byte (e.g. Int16Array) use the platform byte order. If control over byte order is needed, use DataView instead.</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">Typ</td> + <td class="header">Rozmiar</td> + <td class="header">Opis</td> + <td class="header">Odpowiednik C</td> + </tr> + <tr> + <td><a href="/en/JavaScript_typed_arrays/Int8Array" title="en/JavaScript typed arrays/Int8Array"><code>Int8Array</code></a></td> + <td>1</td> + <td>8-bitowa liczba całkowita ze znakiem w zapisie dopełnienia do dwóch</td> + <td><code>signed char</code></td> + </tr> + <tr> + <td><code><a href="/en/JavaScript_typed_arrays/Uint8Array" title="en/JavaScript typed arrays/Uint8Array">Uint8Array</a></code></td> + <td>1</td> + <td>8-bitowa liczba całkowita bez znaku</td> + <td><code>unsigned char</code></td> + </tr> + <tr> + <td><a href="/en-US/docs/JavaScript/Typed_arrays/Uint8ClampedArray" title="/en-US/docs/JavaScript/Typed_arrays/Uint8ClampedArray"><code>Uint8ClampedArray</code></a></td> + <td>1</td> + <td>8-bitowa liczba całkowita bez znaku</td> + <td><code>unsigned char</code></td> + </tr> + <tr> + <td><code><a href="/en/JavaScript_typed_arrays/Int16Array" title="en/JavaScript typed arrays/Int16Array">Int16Array</a></code></td> + <td>2</td> + <td>16-bitowa liczba całkowita ze znakiem w zapisie dopełnienia do dwóch</td> + <td><code>short</code></td> + </tr> + <tr> + <td><code><a href="/en/JavaScript_typed_arrays/Uint16Array" title="en/JavaScript typed arrays/Uint16Array">Uint16Array</a></code></td> + <td>2</td> + <td>16-bitowa liczba całkowita bez znaku</td> + <td><code>unsigned short</code></td> + </tr> + <tr> + <td><code><a href="/en/JavaScript_typed_arrays/Int32Array" title="en/JavaScript typed arrays/Int32Array">Int32Array</a></code></td> + <td>4</td> + <td>32-bitowa liczba całkowita ze znakiem w zapisie dopełnienia do dwóch</td> + <td><code>int</code></td> + </tr> + <tr> + <td><code><a href="/en/JavaScript_typed_arrays/Uint32Array" title="en/JavaScript typed arrays/Uint32Array">Uint32Array</a></code></td> + <td>4</td> + <td>32-bitowa liczba całkowita bez znaku</td> + <td><code>unsigned int</code></td> + </tr> + <tr> + <td><code><a href="/en/JavaScript_typed_arrays/Float32Array" title="en/JavaScript typed arrays/Float32Array">Float32Array</a></code></td> + <td>4</td> + <td>32-bitowa liczba zmiennoprzecinkowa IEEE</td> + <td><code>float</code></td> + </tr> + <tr> + <td><code><a href="/en/JavaScript_typed_arrays/Float64Array" title="en/JavaScript typed arrays/Float64Array">Float64Array</a></code></td> + <td>8</td> + <td>64-bitowa liczba zmiennoprzecinkowa IEEE</td> + <td><code>double</code></td> + </tr> + </tbody> +</table> + +<h2 id="Superklasy_tablic_reprezentujących_typy">Superklasy tablic reprezentujących typy</h2> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">Typ</td> + <td class="header">Opis</td> + </tr> + <tr> + <td><a href="/en-US/docs/Web/JavaScript/Typed_arrays/DataView" title="/en-US/docs/Web/JavaScript/Typed_arrays/DataView"><code>DataView</code></a></td> + <td>The <code>DataView</code> view provides a low-level interface for reading data from and writing it to an <code><a href="https://developer.mozilla.org/en/JavaScript_typed_arrays/ArrayBuffer" title="en/JavaScript_typed_arrays/ArrayBuffer">ArrayBuffer</a></code>.</td> + </tr> + <tr> + <td><a href="/en-US/docs/Web/JavaScript/Typed_arrays/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code></a> <span class="inlineIndicator" title="This API is not native.">Non native</span></td> + <td>The <code>StringView</code> view provides a <strong><a class="external" href="http://en.wikipedia.org/wiki/C_%28programming_language%29">C</a>-like interface for strings</strong> (i.e. array of characters codes — an<a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBufferView"> <code>ArrayBufferView</code></a> in JavaScript) based upon the JavaScript <a href="/en-US/docs/Web/JavaScript/Typed_arrays/ArrayBuffer"><code>ArrayBuffer</code></a> interface,</td> + </tr> + </tbody> +</table> + +<h2 id="Używanie_widoków_z_buforami">Używanie widoków z buforami</h2> + +<p>Stwórzmy 16-bajtowy bufor:</p> + +<pre class="brush:js">var buffer = new ArrayBuffer(16); +</pre> + +<p>At this point, we have a chunk of memory whose bytes are all pre-initialized to 0. There's not a lot we can do with it, though. We can confirm that it is indeed 16 bytes long, and that's about it:</p> + +<pre class="brush:js">if (buffer.byteLength == 16) { + alert("Yes, it's 16 bytes."); +} else { + alert("Oh no, it's the wrong size!"); +} +</pre> + +<p>Before we can really work with this buffer, we need to create a view. Let's create a view that treats the data in the buffer as an array of 32-bit signed integers:</p> + +<pre class="brush:js">var int32View = new Int32Array(buffer); +</pre> + +<p>Now we can access the fields in the array just like a normal array:</p> + +<pre class="brush:js">for (var i=0; i<int32View.length; i++) { + int32View[i] = i*2; +} +</pre> + +<p>This fills out the 4 entries in the array (4 entries at 4 bytes each makes 16 total bytes) with the values 0, 2, 4, and 6.</p> + +<h3 id="Wiele_widoków_tych_samych_danych">Wiele widoków tych samych danych</h3> + +<p>Things start to get really interesting when you consider that you can create multiple views onto the same data. For example, given the code above, we can continue like this:</p> + +<pre class="brush:js">var int16View = new Int16Array(buffer); + +for (var i=0; i<int16View.length; i++) { + console.log("Entry " + i + ": " + int16View[i]); +} +</pre> + +<p>Here we create a 16-bit integer view that shares the same buffer as the existing 32-bit view and we output all the values in the buffer as 16-bit integers. Now we get the output 0, 0, 2, 0, 4, 0, 6, 0.</p> + +<p>You can go a step farther, though. Consider this:</p> + +<pre class="brush:js">int16View[0] = 32; +console.log("Entry 0 in the 32-bit array is now " + int32View[0]); +</pre> + +<p>The output from this is "Entry 0 in the 32-bit array is now 32". In other words, the two arrays are indeed simply views on the same data buffer, treating it as different formats. You can do this with any <a href="/en-US/docs/JavaScript_typed_arrays/ArrayBufferView#Typed_array_subclasses" title="JavaScript typed arrays/ArrayBufferView#Typed array subclasses">view types</a>.</p> + +<h2 id="Praca_ze_złożonymi_strukturami_danych">Praca ze złożonymi strukturami danych</h2> + +<p>By combining a single buffer with multiple views of different types, starting at different offsets into the buffer, you can interact with data objects containing multiple data types. This lets you, for example, interact with complex data structures from <a href="/en-US/docs/WebGL" title="WebGL">WebGL</a>, data files, or C structures you need to use while using <a href="/en-US/docs/js-ctypes" title="js-ctypes">js-ctypes</a>.</p> + +<p>Rozważ tą strukturę C:</p> + +<pre class="brush:cpp">struct someStruct { + unsigned long id; + char username[16]; + float amountDue; +};</pre> + +<p>Możesz uzyskać dostęp do bufora zawierającego dane w tych formacie w ten sposób:</p> + +<pre class="brush:js">var buffer = new ArrayBuffer(24); + +// ... zczytaj dane do bufora ... + +var idView = new Uint32Array(buffer, 0, 1); +var usernameView = new Uint8Array(buffer, 4, 16); +var amountDueView = new Float32Array(buffer, 20, 1);</pre> + +<p>Potem możesz uzyskać dostęp, na przykład, do kwoty należnej używając <code>amountDueView[0]</code>.</p> + +<div class="note"><strong>Note:</strong> The <a href="http://en.wikipedia.org/wiki/Data_structure_alignment" title="http://en.wikipedia.org/wiki/Data_structure_alignment">data structure alignment</a> in a C structure is platform-dependent. Take precautions and considerations for these padding differences.</div> + +<h2 id="Konwersja_do_zwykłych_tablic">Konwersja do zwykłych tablic</h2> + +<p>After processing a typed array, it is sometimes useful to convert it back to a normal array in order to benefit from the <code>Array</code> prototype. Following is a way to do that.</p> + +<pre>var typedArray = new Uint8Array( [ 1, 2, 3, 4 ] ), + normalArray = Array.apply( [], typedArray ); +normalArray.length === 4; +normalArray.constructor === Array; +</pre> + +<h2 id="Kompatybilność">Kompatybilność</h2> + +<p>Typed arrays are available in WebKit as well. Chrome 7 includes support for <code>ArrayBuffer</code>, <code>Float32Array</code>, <code>Int16Array</code>, and <code>Uint8Array</code>. Chrome 9 and Firefox 15 add support for <code>DataView</code> objects. Internet Explorer 10 supports all types except <code>Uint8ClampedArray</code> and <code>ArrayBuffer.prototype.slice</code>.</p> + +<h2 id="Specyfikacja">Specyfikacja</h2> + +<ul> + <li><a class="link-https" href="http://www.khronos.org/registry/typedarray/specs/latest/">Typed Array Specification</a></li> +</ul> + +<h2 id="See_also" name="See_also">Zobacz także</h2> + +<ul> + <li><a href="/en-US/docs/JavaScript/Typed_arrays/Int8Array" title="Int8Array"><code>Int8Array</code></a>, <a href="/en-US/docs/JavaScript/Typed_arrays/Int16Array" title="Int8Array"><code>Int16Array</code></a>, <a href="/en-US/docs/JavaScript/Typed_arrays/Int32Array" title="Int8Array"><code>Int32Array</code></a></li> + <li><a href="/en-US/docs/JavaScript/Typed_arrays/Uint8Array" title="Uint8Array"><code>Uint8Array</code></a>, <a href="/en-US/docs/JavaScript/Typed_arrays/Uint16Array" title="Uint8Array"><code>Uint16Array</code></a>, <a href="/en-US/docs/JavaScript/Typed_arrays/Uint32Array" title="Uint8Array"><code>Uint32Array</code></a>, <a href="/en-US/docs/JavaScript/Typed_arrays/Uint8ClampedArray" title="/en-US/docs/JavaScript/Typed_arrays/Uint8ClampedArray"><code>Uint8ClampedArray</code></a></li> + <li><a href="/en-US/docs/JavaScript/Typed_arrays/Float32Array" title="Float32Array"><code>Float32Array</code></a>, <a href="/en-US/docs/JavaScript/Typed_arrays/Float64Array" title="Float64Array"><code>Float64Array</code></a></li> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays/DataView" title="/en-US/docs/Web/JavaScript/Typed_arrays/DataView"><code>DataView</code></a></li> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code></a></li> + <li><a href="/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer" title="/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">Getting <code>ArrayBuffer</code>s or typed arrays from <em>Base64</em>-encoded strings</a></li> +</ul> + +<div id="cke_pastebin" style="position: absolute; top: 617.817px; width: 1px; height: 1px; overflow: hidden; left: -1000px;"> </div> diff --git a/files/pl/web/javascript/typy_oraz_struktury_danych/index.html b/files/pl/web/javascript/typy_oraz_struktury_danych/index.html new file mode 100644 index 0000000000..d6a2808105 --- /dev/null +++ b/files/pl/web/javascript/typy_oraz_struktury_danych/index.html @@ -0,0 +1,443 @@ +--- +title: Typy oraz struktury danych w JavaScript +slug: Web/JavaScript/typy_oraz_struktury_danych +tags: + - JavaScript + - Początkujący + - Typy danych +translation_of: Web/JavaScript/Data_structures +--- +<div>{{jsSidebar("More")}}</div> + +<div>Wszystkie języki programowania posiadają wbudowane struktury danych, mogą one jednak różnic się między poszczególnymi językami. Poniższy artykuł jest próbą stworzenia listy wbudowanych typów oraz struktur danych w JavaScript oraz ich właściwości. Mogą być one użyte do tworzenia innych struktur danych. Tam gdzie jest to możliwe dokonano porównania z innymi językami programowania.</div> + +<h2 id="Dynamiczne_typowanie">Dynamiczne typowanie</h2> + +<p>JavaScript jest językiem typowanym dynamicznie. Zmienne w Javascript nie są bezpośrednio powiązane z konkretnym typem wartości i możemy im przypisywać wartości dowolnego typu:</p> + +<pre class="brush: js notranslate">let foo = 42; // foo jest teraz liczbą (number) +foo = 'bar'; // foo jest teraz ciągiem znaków (string) +foo = true; // foo jest teraz type logicznym (boolean) +</pre> + +<h2 id="Data_and_Structure_types">Data and Structure types</h2> + +<p>Najnowsza wersja standardu ECMAScript definiuje dziewięć typów danych:</p> + +<ul> + <li>Six <strong>Data Types</strong> that are <a href="/en-US/docs/Glossary/Primitive">primitives</a>, checked by <a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a> operator: + + <ul> + <li><a href="/en-US/docs/Glossary/Undefined">undefined</a> : <code>typeof instance === "undefined"</code></li> + <li><a href="/en-US/docs/Glossary/Boolean">Boolean</a> : <code>typeof instance === "boolean"</code></li> + <li><a href="/en-US/docs/Glossary/Number">Number</a> : <code>typeof instance === "number"</code></li> + <li><a href="/en-US/docs/Glossary/String">String</a> : <code>typeof instance === "string"</code></li> + <li><a href="/en-US/docs/Glossary/BigInt">BigInt</a><span> : </span><code>typeof instance === "bigint"</code></li> + <li><a href="/en-US/docs/Glossary/Symbol">Symbol</a><span> : </span><code>typeof instance === "symbol"</code></li> + </ul> + </li> + <li><a href="/en-US/docs/Glossary/Null">null</a><span> : </span><code>typeof instance === "object"</code>. Special <a href="/en-US/docs/Glossary/Primitive">primitive</a> type having additional usage for it's value: if object is not inherited, then <code>null</code> is shown;</li> + <li><a href="/en-US/docs/Glossary/Object">Object</a><span> : </span><code>typeof instance === "object"</code>. Special non-data but structural type for any <a href="/en-US/docs/Learn/JavaScript/Objects#The_Constructor">constructed</a> object instance also used as data structures: new <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object">Object</a>, new <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array">Array</a>, new <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map">Map</a>, new <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set">Set</a>, new <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap">WeakMap</a>, new <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet">WeakSet</a>, new <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date">Date</a> and almost everything made with <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new keyword</a>;</li> + <li><a href="/en-US/docs/Glossary/Function">Function</a><span> non data structure, though it also answers for typeof operator: </span><code>typeof instance === "function"</code>. This answer is done as a special shorthand for Functions, though every Function constructor is derived from Object constructor.</li> +</ul> + +<p>Keep in mind the only valuable purpose of <code>typeof</code> operator usage is checking the Data Type. If we wish to check any Structural Type derived from Object it is pointless to use <code>typeof</code> for that, as we will always receive <code>"object"</code>. The indeed proper way to check what sort of Object we are using an <a href="/en-US/docs/Web/JavaScript/Reference/Operators/instanceof">instanceof</a> keyword. But even in that case there might be misconceptions.</p> + +<h2 id="Wartości_prymitywne">Wartości prymitywne</h2> + +<p>All types except objects define immutable values (that is, values which can't be changed). For example (and unlike in C), Strings are immutable. We refer to values of these types as "<em>primitive values</em>".</p> + +<h3 id="Boolean_type">Boolean type</h3> + +<p>Boolean represents a logical entity and can have two values: <code>true</code> and <code>false</code>. See <a href="/en-US/docs/Glossary/Boolean">Boolean</a> and {{jsxref("Boolean")}} for more details.</p> + +<h3 id="Null_type">Null type</h3> + +<p>The Null type has exactly one value: <code>null</code>. See {{jsxref("null")}} and <a href="/en-US/docs/Glossary/Null">Null</a> for more details.</p> + +<h3 id="Undefined_type">Undefined type</h3> + +<p>A variable that has not been assigned a value has the value <code>undefined</code>. See {{jsxref("undefined")}} and <a href="/en-US/docs/Glossary/Undefined">Undefined</a> for more details.</p> + +<h3 id="Number_type">Number type</h3> + +<p>ECMAScript has two built-in numeric types: <strong>Number</strong> and <strong>BigInt</strong> (see below).</p> + +<p>The Number type is a <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">double-precision 64-bit binary format IEEE 754 value</a> (numbers between -(2<sup>53</sup> − 1) and 2<sup>53</sup> − 1). In addition to representing floating-point numbers, the number type has three symbolic values: <code>+Infinity</code>, <code>-Infinity</code>, and {{jsxref("NaN")}} ("<strong>N</strong>ot a <strong>N</strong>umber").</p> + +<p>To check for the largest available value or smallest available value within {{jsxref("Infinity", "±Infinity")}}, you can use the constants {{jsxref("Number.MAX_VALUE")}} or {{jsxref("Number.MIN_VALUE")}}.</p> + +<p>Starting with ECMAScript 2015, you are also able to check if a number is in the double-precision floating-point number range using {{jsxref("Number.isSafeInteger()")}} as well as {{jsxref("Number.MAX_SAFE_INTEGER")}} and {{jsxref("Number.MIN_SAFE_INTEGER")}}. Beyond this range, integers in JavaScript are not safe anymore and will be a double-precision floating point approximation of the value.</p> + +<p>The number type has only one integer with two representations: <code>0</code> is represented as both <code>-0</code> and <code>+0</code>. (<code>0</code> is an alias for <code>+0</code>.) </p> + +<p>In the praxis, this has almost no impact. For example, <code>+0 === -0</code> is <code>true</code>. However, you are able to notice this when you divide by zero:</p> + +<pre class="brush: js notranslate">> 42 / +0 +Infinity +> 42 / -0 +-Infinity +</pre> + +<p>Although a number often represents only its value, JavaScript provides {{jsxref("Operators/Bitwise_Operators", "binary (bitwise) operators")}}.</p> + +<p>These bitwise operators can be used to represent several Boolean values within a single number using <a class="external" href="http://en.wikipedia.org/wiki/Mask_%28computing%29">bit masking</a>. However, this is usually considered a bad practice, since JavaScript offers other means to represent a set of Booleans (like an array of Booleans, or an object with Boolean values assigned to named properties). Bit masking also tends to make the code more difficult to read, understand, and maintain.</p> + +<p>It may be necessary to use such techniques in very constrained environments, like when trying to cope with the limitations of local storage, or in extreme cases (such as when each bit over the network counts). This technique should only be considered when it is the last measure that can be taken to optimize size.</p> + +<h3 id="BigInt_type">BigInt type</h3> + +<p>The {{jsxref("BigInt")}} type is a numeric primitive in JavaScript that can represent integers with arbitrary precision. With <code>BigInt</code>s, you can safely store and operate on large integers even beyond the safe integer limit for <code>Number</code>s.</p> + +<p>A <code>BigInt</code> is created by appending <code>n</code> to the end of an integer or by calling the constructor.</p> + +<p>You can obtain the safest value that can be incremented with <code>Number</code>s by using the constant {{jsxref("Number.MAX_SAFE_INTEGER")}}. With the introduction of <code>BigInt</code>s, you can operate with numbers beyond the {{jsxref("Number.MAX_SAFE_INTEGER")}}.</p> + +<p>This example demonstrates, where incrementing the {{jsxref("Number.MAX_SAFE_INTEGER")}} returns the expected result:</p> + +<pre class="brush: js notranslate">> const x = 2n ** 53n; +9007199254740992n +> const y = x + 1n; +9007199254740993n +</pre> + +<p>You can use the operators <code>+</code>, <code>*</code>, <code>-</code>, <code>**</code>, and <code>%</code> with <code>BigInt</code>s—just like with <code>Number</code>s. A <code>BigInt</code> is not strictly equal to a <code>Number</code>, but it is loosely so.</p> + +<p>A <code>BigInt</code> behaves like a <code>Number</code> in cases where it is converted to <code>Boolean</code>: <code>if</code>, <code>||</code>, <code>&&</code>, <code>Boolean</code>, <code>!</code>.</p> + +<p><code>BigInt</code>s cannot be operated on interchangeably with <code>Number</code>s. Instead a {{jsxref("TypeError")}} will be thrown.</p> + +<h3 id="String_type">String type</h3> + +<p>JavaScript's {{jsxref("String")}} type is used to represent textual data. It is a set of "elements" of 16-bit unsigned integer values. Each element in the String occupies a position in the String. The first element is at index <code>0</code>, the next at index <code>1</code>, and so on. The length of a String is the number of elements in it.</p> + +<p>Unlike some programming languages (such as C), JavaScript strings are immutable. This means that once a string is created, it is not possible to modify it.</p> + +<p>However, it is still possible to create another string based on an operation on the original string. For example:</p> + +<ul> + <li>A substring of the original by picking individual letters or using {{jsxref("String.substr()")}}.</li> + <li>A concatenation of two strings using the concatenation operator (<code>+</code>) or {{jsxref("String.concat()")}}.</li> +</ul> + +<h4 id="Beware_of_stringly-typing_your_code!">Beware of "stringly-typing" your code!</h4> + +<p>It can be tempting to use strings to represent complex data. Doing this comes with short-term benefits:</p> + +<ul> + <li>It is easy to build complex strings with concatenation.</li> + <li>Strings are easy to debug (what you see printed is always what is in the string).</li> + <li>Strings are the common denominator of a lot of APIs (<a href="/en-US/docs/Web/API/HTMLInputElement" title="HTMLInputElement">input fields</a>, <a href="/en-US/docs/Storage" title="Storage">local storage</a> values, <a href="/en-US/docs/Web/API/XMLHttpRequest" title="Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing."><code>XMLHttpRequest</code></a> responses when using <code>responseText</code>, etc.) and it can be tempting to only work with strings.</li> +</ul> + +<p>With conventions, it is possible to represent any data structure in a string. This does not make it a good idea. For instance, with a separator, one could emulate a list (while a JavaScript array would be more suitable). Unfortunately, when the separator is used in one of the "list" elements, then, the list is broken. An escape character can be chosen, etc. All of this requires conventions and creates an unnecessary maintenance burden.</p> + +<p>Use strings for textual data. When representing complex data, parse strings and use the appropriate abstraction.</p> + +<h3 id="Symbol_type">Symbol type</h3> + +<p>Symbols are new to JavaScript in ECMAScript 2015. A Symbol is a <strong>unique</strong> and <strong>immutable</strong> primitive value and may be used as the key of an Object property (see below). In some programming languages, Symbols are called "atoms".</p> + +<p>For more details see <a href="/en-US/docs/Glossary/Symbol">Symbol</a> and the {{jsxref("Symbol")}} object wrapper in JavaScript.</p> + +<h2 id="Obiekty">Obiekty</h2> + +<p>In computer science, an object is a value in memory which is possibly referenced by an <a href="/en-US/docs/Glossary/Identifier">identifier</a>.</p> + +<h3 id="Properties">Properties</h3> + +<p>In JavaScript, objects can be seen as a collection of properties. With the <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Object_literals">object literal syntax</a>, a limited set of properties are initialized; then properties can be added and removed. Property values can be values of any type, including other objects, which enables building complex data structures. Properties are identified using <em>key</em> values. A <em>key</em> value is either a String or a Symbol value.</p> + +<p>There are two types of object properties which have certain attributes: The <em>data</em> property and the <em>accessor</em> property.</p> + +<h4 id="Data_property">Data property</h4> + +<p>Associates a key with a value, and has the following attributes:</p> + +<table class="standard-table"> + <caption>Attributes of a data property</caption> + <thead> + <tr> + <th scope="col">Attribute</th> + <th scope="col">Type</th> + <th scope="col">Description</th> + <th scope="col">Default value</th> + </tr> + </thead> + <tbody> + <tr> + <td>[[Value]]</td> + <td>Any JavaScript type</td> + <td>The value retrieved by a get access of the property.</td> + <td><code>undefined</code></td> + </tr> + <tr> + <td>[[Writable]]</td> + <td>Boolean</td> + <td>If <code>false</code>, the property's [[Value]] cannot be changed.</td> + <td><code>false</code></td> + </tr> + <tr> + <td>[[Enumerable]]</td> + <td>Boolean</td> + <td> + <p>If <code>true</code>, the property will be enumerated in <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a> loops.<br> + See also <a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a>.</p> + </td> + <td><code>false</code></td> + </tr> + <tr> + <td>[[Configurable]]</td> + <td>Boolean</td> + <td>If <code>false</code>, the property cannot be deleted, cannot be changed to an accessor property, and attributes other than [[Value]] and [[Writable]] cannot be changed.</td> + <td><code>false</code></td> + </tr> + </tbody> +</table> + +<table class="standard-table"> + <caption>Obsolete attributes (as of ECMAScript 3, renamed in ECMAScript 5)</caption> + <thead> + <tr> + <th scope="col">Attribute</th> + <th scope="col">Type</th> + <th scope="col">Description</th> + </tr> + </thead> + <tbody> + <tr> + <td>Read-only</td> + <td>Boolean</td> + <td>Reversed state of the ES5 [[Writable]] attribute.</td> + </tr> + <tr> + <td>DontEnum</td> + <td>Boolean</td> + <td>Reversed state of the ES5 [[Enumerable]] attribute.</td> + </tr> + <tr> + <td>DontDelete</td> + <td>Boolean</td> + <td>Reversed state of the ES5 [[Configurable]] attribute.</td> + </tr> + </tbody> +</table> + +<h4 id="Accessor_property">Accessor property</h4> + +<p>Associates a key with one of two accessor functions (<code>get</code> and <code>set</code>) to retrieve or store a value, and has the following attributes:</p> + +<table class="standard-table"> + <caption>Attributes of an accessor property</caption> + <thead> + <tr> + <th scope="col">Attribute</th> + <th scope="col">Type</th> + <th scope="col">Description</th> + <th scope="col">Default value</th> + </tr> + </thead> + <tbody> + <tr> + <td>[[Get]]</td> + <td>Function object or <code>undefined</code></td> + <td>The function is called with an empty argument list and retrieves the property value whenever a get access to the value is performed.<br> + See also <a href="/en-US/docs/Web/JavaScript/Reference/Operators/get"><code>get</code></a>.</td> + <td><code>undefined</code></td> + </tr> + <tr> + <td>[[Set]]</td> + <td>Function object or <code>undefined</code></td> + <td>The function is called with an argument that contains the assigned value and is executed whenever a specified property is attempted to be changed.<br> + See also <a href="/en-US/docs/Web/JavaScript/Reference/Operators/set"><code>set</code></a>.</td> + <td><code>undefined</code></td> + </tr> + <tr> + <td>[[Enumerable]]</td> + <td>Boolean</td> + <td>If <code>true</code>, the property will be enumerated in <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a> loops.</td> + <td><code>false</code></td> + </tr> + <tr> + <td>[[Configurable]]</td> + <td>Boolean</td> + <td>If <code>false</code>, the property can't be deleted and can't be changed to a data property.</td> + <td><code>false</code></td> + </tr> + </tbody> +</table> + +<div class="note"> +<p><strong>Note: </strong>Attribute is usually used by JavaScript engine, so you can't directly access it (see more about {{jsxref("Object.defineProperty()")}}). That's why the attribute is put in double square brackets instead of single.</p> +</div> + +<h3 id="Normal_objects_and_functions">"Normal" objects, and functions</h3> + +<p>A JavaScript object is a mapping between <em>keys</em> and <em>values</em>. Keys are strings (or {{jsxref("Symbol")}}s), and <em>values</em> can be anything. This makes objects a natural fit for <a class="external" href="http://en.wikipedia.org/wiki/Hash_table">hashmaps</a>.</p> + +<p>Functions are regular objects with the additional capability of being <em>callable</em>.</p> + +<h3 id="Dates">Dates</h3> + +<p>When representing dates, the best choice is to use the built-in <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code> utility</a> in JavaScript.</p> + +<h3 id="Indexed_collections_Arrays_and_typed_Arrays">Indexed collections: Arrays and typed Arrays</h3> + +<p><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array" title="Array">Arrays</a> are regular objects for which there is a particular relationship between integer-key-ed properties and the <code>length</code> property.</p> + +<p>Additionally, arrays inherit from <code>Array.prototype</code>, which provides to them a handful of convenient methods to manipulate arrays. For example, <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf" title="en/JavaScript/Reference/Global_Objects/Array/indexOf">indexOf</a></code> (searching a value in the array) or <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/push" title="en/JavaScript/Reference/Global_Objects/Array/push">push</a></code> (adding an element to the array), and so on. This makes Arrays a perfect candidate to represent lists or sets.</p> + +<p><a href="/en-US/docs/Web/JavaScript/Typed_arrays">Typed Arrays</a> are new to JavaScript with ECMAScript 2015, and present an array-like view of an underlying binary data buffer. The following table helps determine the equivalent C data types:</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">Type</th> + <th class="header" scope="col">Value Range</th> + <th class="header" scope="col">Size in bytes</th> + <th class="header" scope="col">Description</th> + <th class="header" scope="col">Web IDL type</th> + <th class="header" scope="col">Equivalent C type</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{jsxref("Int8Array")}}</td> + <td><code>-128</code> to <code>127</code></td> + <td>1</td> + <td>8-bit two's complement signed integer</td> + <td><code>byte</code></td> + <td><code>int8_t</code></td> + </tr> + <tr> + <td>{{jsxref("Uint8Array")}}</td> + <td><code>0</code> to <code>255</code></td> + <td>1</td> + <td>8-bit unsigned integer</td> + <td><code>octet</code></td> + <td><code>uint8_t</code></td> + </tr> + <tr> + <td>{{jsxref("Uint8ClampedArray")}}</td> + <td><code>0</code> to <code>255</code></td> + <td>1</td> + <td>8-bit unsigned integer (clamped)</td> + <td><code>octet</code></td> + <td><code>uint8_t</code></td> + </tr> + <tr> + <td>{{jsxref("Int16Array")}}</td> + <td><code>-32768</code> to <code>32767</code></td> + <td>2</td> + <td>16-bit two's complement signed integer</td> + <td><code>short</code></td> + <td><code>int16_t</code></td> + </tr> + <tr> + <td>{{jsxref("Uint16Array")}}</td> + <td><code>0</code> to <code>65535</code></td> + <td>2</td> + <td>16-bit unsigned integer</td> + <td><code>unsigned short</code></td> + <td><code>uint16_t</code></td> + </tr> + <tr> + <td>{{jsxref("Int32Array")}}</td> + <td><code>-2147483648</code> to <code>2147483647</code></td> + <td>4</td> + <td>32-bit two's complement signed integer</td> + <td><code>long</code></td> + <td><code>int32_t</code></td> + </tr> + <tr> + <td>{{jsxref("Uint32Array")}}</td> + <td><code>0</code> to <code>4294967295</code></td> + <td>4</td> + <td>32-bit unsigned integer</td> + <td><code>unsigned long</code></td> + <td><code>uint32_t</code></td> + </tr> + <tr> + <td>{{jsxref("Float32Array")}}</td> + <td><code>1.2</code><span>×</span><code>10<sup>-38</sup></code> to <code>3.4</code><span>×</span><code>10<sup>38</sup></code></td> + <td>4</td> + <td>32-bit IEEE floating point number (7 significant digits e.g., <code>1.1234567</code>)</td> + <td><code>unrestricted float</code></td> + <td><code>float</code></td> + </tr> + <tr> + <td>{{jsxref("Float64Array")}}</td> + <td><code>5.0</code><span>×</span><code>10<sup>-324</sup></code> to <code>1.8</code><span>×</span><code>10<sup>308</sup></code></td> + <td>8</td> + <td>64-bit IEEE floating point number (16 significant digits e.g., <code>1.123...15</code>)</td> + <td><code>unrestricted double</code></td> + <td><code>double</code></td> + </tr> + <tr> + <td>{{jsxref("BigInt64Array")}}</td> + <td><code>-2<sup>63</sup></code> to <code>2<sup>63</sup>-1</code></td> + <td>8</td> + <td>64-bit two's complement signed integer</td> + <td><code>bigint</code></td> + <td><code>int64_t (signed long long)</code></td> + </tr> + <tr> + <td>{{jsxref("BigUint64Array")}}</td> + <td><code>0</code> to <code>2<sup>64</sup>-1</code></td> + <td>8</td> + <td>64-bit unsigned integer</td> + <td><code>bigint</code></td> + <td><code>uint64_t (unsigned long long)</code></td> + </tr> + </tbody> +</table> + +<h3 id="Keyed_collections_Maps_Sets_WeakMaps_WeakSets">Keyed collections: Maps, Sets, WeakMaps, WeakSets</h3> + +<p>These data structures, introduced in ECMAScript Edition 6, take object references as keys. {{jsxref("Set")}} and {{jsxref("WeakSet")}} represent a set of objects, while {{jsxref("Map")}} and {{jsxref("WeakMap")}} associate a value to an object.</p> + +<p>The difference between <code>Map</code>s and <code>WeakMap</code>s is that in the former, object keys can be enumerated over. This allows garbage collection optimizations in the latter case.</p> + +<p>One could implement <code>Map</code>s and <code>Set</code>s in pure ECMAScript 5. However, since objects cannot be compared (in the sense of <code><</code> "less than", for instance), look-up performance would necessarily be linear. Native implementations of them (including <code>WeakMap</code>s) can have look-up performance that is approximately logarithmic to constant time.</p> + +<p>Usually, to bind data to a DOM node, one could set properties directly on the object, or use <code>data-*</code> attributes. This has the downside that the data is available to any script running in the same context. <code>Map</code>s and <code>WeakMap</code>s make it easy to <em>privately</em> bind data to an object.</p> + +<h3 id="Structured_data_JSON">Structured data: JSON</h3> + +<p>JSON (<strong>J</strong>ava<strong>S</strong>cript <strong>O</strong>bject <strong>N</strong>otation) is a lightweight data-interchange format, derived from JavaScript, but used by many programming languages. JSON builds universal data structures.</p> + +<p>See <a href="/en-US/docs/Glossary/JSON">JSON</a> and {{jsxref("JSON")}} for more details.</p> + +<h3 id="More_objects_in_the_standard_library">More objects in the standard library</h3> + +<p>JavaScript has a standard library of built-in objects.</p> + +<p>Please have a look at the <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects">reference</a> to find out about more objects.</p> + +<h2 id="Określanie_typu_za_pomocą_operatora_typeof">Określanie typu za pomocą operatora <code>typeof</code></h2> + +<p>Operator <code>typeof</code> może być pomocny przy określeniu typu twojej zmiennej.</p> + +<p>Więcej szczegółów znajdziecie na stronie poświęconej operatorowi <code>typeof</code>.</p> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}</td> + </tr> + </tbody> +</table> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a class="link-https" href="https://github.com/nzakas/computer-science-in-javascript/">Nicholas Zakas collection of common data structure and common algorithms in JavaScript.</a></li> + <li><a href="https://github.com/monmohan/DataStructures_In_Javascript" title="https://github.com/monmohan/DataStructures_In_Javascript">Search Tre(i)es implemented in JavaScript</a></li> +</ul> diff --git a/files/pl/web/javascript/wprowadzenie_do_programowania_obiektowego_w_jezyku_javascript/index.html b/files/pl/web/javascript/wprowadzenie_do_programowania_obiektowego_w_jezyku_javascript/index.html new file mode 100644 index 0000000000..7de2f98142 --- /dev/null +++ b/files/pl/web/javascript/wprowadzenie_do_programowania_obiektowego_w_jezyku_javascript/index.html @@ -0,0 +1,341 @@ +--- +title: Wprowadzenie do programowania obiektowego w języku JavaScript +slug: Web/JavaScript/Wprowadzenie_do_programowania_obiektowego_w_jezyku_JavaScript +translation_of: Learn/JavaScript/Objects +--- +<p>JavaScript jest zorientowany obiektowo do szpiku kości dzięki potężnym, elastycznym możliwościom realizacji OOP. <span style="line-height: 1.5;">Ten artykuł zawiera wprowadzenie do programowania obiektowego (ogółem), analizuje model obiektowy w JavaScript i w końcu demonstruje aspekty programowania obiektowego w JavaScript.</span></p> + +<h2 id="JavaScript_Review" name="JavaScript_Review">Przegląd JavaScript</h2> + +<p>Jeśli nie czujesz się pewnie w zagadnieniach dotyczących JavaScript takich, jak zmienne, typy, funkcje oraz zasięg, możesz przeczytać o nich w <a href="/en/JavaScript/A_re-introduction_to_JavaScript" title="en/JavaScript/A_re-introduction_to_JavaScript">Ponownym wprowadzeniu do JavaScript (angielski)</a>. Możesz także zasięgnąć wiedzy zawartej w <a href="/en/JavaScript/Guide" title="en/JavaScript/Guide">Core JavaScript 1.5 Guide</a>.</p> + +<h2 id="Object-oriented_programming" name="Object-oriented_programming">Programowanie zorientowane obiektowo</h2> + +<p>Programowanie zorientowane obiektowo jest paradygmatem programowania, który korzysta z abstrakcji do tworzenia modeli opartych na świecie rzeczywistym. Stosuje on kilka technik z poprzednio ustanowionych paradygmatów, np. modułowość, polimorfizm czy enkapsulację. Obecnie wiele popularnych języków programowania (takich, jak Java, JavaScript, C#, C++, Python, PHP, Ruby i Objective-C) wspierają programowanie zorientowane obiektowo (OOP - z ang. "object-oriented programming").</p> + +<p>Programowanie zorientowane obiektowo może być rozumiane jako sposób projektowania oprogramowania stosujący kolekcję powiązanych ze sobą obiektów, w przeciwieństwie do tradycyjnego punktu widzenia, gdzie program może być rozumiany jako zestaw funkcji lub, po prostu, jako lista instrukcji przekazywanych do komputera. W OOP każdy obiekt jest zdolny odbierać wiadomości, przetwarzać dane i wysyłać wiadomości do innych obiektów. Każdy obiekt może być rozumiany jako niezależna mała maszyna pełniąca odrębną rolę lub odpowiedzialność.</p> + +<p><span style="line-height: 1.5;">Programowanie obiektowe ma na celu promować większą elastyczność i łatwość rozwoju w programowaniu. Jest ono bardzo popularne przy tworzeniu oprogramowania na dużą skalę. Dzięki silnemu naciskowi na modułowość, kod programu zorientowany obiektowo jest łatwiejszy do napisania i późniejszego zrozumienia, stając się łatwiejszym do bezpośredniej analizy, kodowania i rozumienia złożonych sytuacji i procedur niż mniej modułowe metody programowania.</span><sup><a href="#References">2</a></sup></p> + +<h2 id="Terminology" name="Terminology">Terminologia</h2> + +<dl> + <dt>Przestrzeń nazw (ang. "namespace")</dt> + <dd>Przestrzeń pozwalająca programiście na zawarcie wszystkich funkcjonalności pod unikalną nazwą, właściwą dla danej aplikacji.</dd> + <dt>Klasa (ang. "class")</dt> + <dd>Definiuje własności obiektu.</dd> + <dt>Obiekt (ang. "object")</dt> + <dd>Instancja (byt, twór) klasy.</dd> + <dt>Właściwość (ang. "property")</dt> + <dd>Własność obiektu, np. kolor.</dd> + <dt>Metoda (ang. "method")</dt> + <dd>Zdolność (czynność) obiektu, np. chodzenie (idź).</dd> + <dt>Konstruktor (ang. "constructor")</dt> + <dd>Metoda wywoływana w momencie inicjalizacji obiektu.</dd> + <dt>Dziedziczenie (ang. "inheritance")</dt> + <dd>Klasa może dziedziczyć własności od innej klasy.</dd> + <dt>Hermetyzacja (lub enkapsulacja - ang. "encapsulation")</dt> + <dd>Klasa definiuje tylko własności obiektu, podczas gdy metoda definiuje tylko sposób realizacji.</dd> + <dt>Abstrakcja (ang. "abstraction")</dt> + <dd>Koniunkcja złożonego dziedziczenia, metod, właściwości obiektu musi dobrze oddawać model rzeczywistości.</dd> + <dt>Polimorfizm (ang. "polymorphism")</dt> + <dd><em>Poli </em>znaczy "wiele", a <em>morfizm</em> oznacza "formy". Różne klasy mogą definiować takie same metody albo właściwości.</dd> +</dl> + +<p>Bardziej obszerną definicję programowania obiektowego można znaleźć w <a href="http://pl.wikipedia.org/wiki/Programowanie_obiektowe">Programowaniu obiektowym</a> na Wikipedii.</p> + +<h2 id="Programowanie_oparte_na_prototypie">Programowanie oparte na prototypie</h2> + +<p>Programowanie prototypowe jest stylem programowania obiektowego, w którym klasy nie są obecne, a ponowne wykorzystanie zachowań (w językach opartych na klasach znane jako dziedziczenie) jest realizowane przez proces dekoracji istniejących obiektów, które służą jako prototypy. Ten model jest znany również jako programowanie "bezklasowe", "zorientowane prototypowo" lub "oparte na instancji".</p> + +<p>Oryginalnym (i najbardziej kanonicznym) przykładem języka opartego na prototypie jest język programowaina Self stworzony przez Davida Ungara i Randalla Smitha. Niemniej jednak, programowanie w stylu bezklasowym stało się ostatnimi czasy bardzo popularne i zostało zaimplementowane w takich językach, jak Javascript, Cecil, NewtonScript, Io, MOO, REBOL, Kevo, Squeak (podczas używania frameworka Viewer do manipulacji komponentami Morphic) i kilku innych.<sup><a href="#Reference">2</a></sup></p> + +<h2 id="JavaScript_Object_Oriented_Programming" name="JavaScript_Object_Oriented_Programming">OOP w języku JavaScript</h2> + +<h3 id="Przestrzeń_nazw">Przestrzeń nazw</h3> + +<p>Przestrzeń nazw jest pojemnikiem pozwalającym programiście na zawarcie wszystkich funkcjonalności pod unikalną nazwą, właściwą dla danej aplikacji. W JavaScript przestrzeń nazw jest po prostu obiektem przechowującym metody, właściwości i inne obiekty. Cel przyświecający przestrzeniom nazw w JavaScript jest prosty: utworzony zostaje jeden globalny obiekt, a wszystkie zmienne, metody i funkcje stają się właściwościami tego obiektu. Użycie przestrzeni nazw zmniejsza również ryzyko kolizji nazw w aplikacji.</p> + +<p>Obiekt jest przestrzenią nazw:<br> + <br> + Stwórzmy globalny obiekt o nazwie MYAPP</p> + +<pre class="brush: js">// globalna przestrzeń nazw +var MYAPP = MYAPP || {};</pre> + +<p><span style="background-color: #ffffff; color: #4d4e53; font-style: normal; line-height: 1.5;">W powyższym przykładzie najpierw sprawdzamy czy MYAPP jest już zdefiniowany w tym samym lub innym pliku. Jeśli tak, używamy istniejącego globalnego obiektu MYAPP. W przeciwnym razie tworzymy pusty obiekt MYAPP, który zenkapsuluje metody, funkcje, zmienne i obiekty.</span></p> + +<p>Możemy również utworzyć podrzędną przestrzeń nazw:</p> + +<pre class="brush: js">// pod-przestrzeń nazw +MYAPP.event = {};</pre> + +<p>Poniżej znajduje się kod tworzący przestrzeń nazw i dodający zmienne, funkcje i metody:</p> + +<pre class="brush: js">// Utwórz pojemnik MYAPP.commonMethod na typowe metody i właściwości +MYAPP.commonMethod = { + regExForName: "", // zdefiniuj wyrażenie regularne do walidacji nazwiska + regExForPhone: "", // <span style="font-size: 1rem;">zdefiniuj wyrażenie regularne do walidacji numeru telefonu</span> + validateName: function(name){ + // Zrób coś z nazwiskiem. Możesz użyć zmiennej regExForName + // użycie "this.regExForName" + }, + + validatePhoneNo: function(phoneNo){ + // zrób coś z numerem telefonu + } +} + +// Obiekt razem z deklaracją metod +MYAPP.event = { + addListener: function(el, type, fn) { + // jakiś kod + }, + removeListener: function(el, type, fn) { + // jakiś kod + }, + getEvent: function(e) { + // jakiś kod + } + + // Można dodać kolejne metody i właściwości +} + +// Składnia do użycia metody AddListener: +MYAPP.event.addListener("yourel", "type", callback);</pre> + +<h3 id="Core_Objects" name="Core_Objects">Obiekty wbudowane</h3> + +<p>JavaScript posiada kilka obiektów wbudowanych, na przykład Math, Object, Array, i String. Poniższy przykład pokazuje, jak użyć obiektu Math do pobrania pseudo-losowej liczby używając metody <span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">random()</span><span style="line-height: 1.5;">.</span></p> + +<pre class="brush: js">alert(Math.random()); +</pre> + +<div class="note"><strong>Notka:</strong> Ten i wszystkie dalsze przykłady zakładają, że istnieje funkcja globalna <span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">alert</span><span style="line-height: 1.5;"> (taka, jak ta zaimplementowana w przeglądarkach internetowych). Tak naprawdę funkcja </span><span style="font-family: 'Courier New','Andale Mono',monospace;">alert</span><span style="line-height: 1.5;"> nie jest częścią języka JavaScript.</span></div> + +<p>Artykuł <a href="/En/Core_JavaScript_1.5_Reference/Global_Objects" title="En/Core_JavaScript_1.5_Reference/Global_Objects">Core JavaScript 1.5 Reference:Global Objects</a> zawiera listę wszystkich obiektów wbudowanych w JavaScript.</p> + +<p>Każdy obiekt w JavaScript jest instancją obiektu <span style="font-family: 'Courier New','Andale Mono',monospace;">Object</span> i tym samym dziedziczy jego wszystkie właściwości i metody.</p> + +<h3 id="Custom_Objects" name="Custom_Objects">Własne obiekty</h3> + +<h4 id="The_Class" name="The_Class">Klasa</h4> + +<p>JavaScript jest językiem opartym na prototypie, w którym nie występuje pojęcie klasy, w przeciwieństwie do języków takich, jak C++ czy Java. Fakt ten bywa dezorientujący dla programistów przyzwyczajonych do języków z pojęciem klasy. Zamiast klas, JavaScript stosuje funkcje. Zdefiniowanie klasy ogranicza się do prostej czynności, jaką jest zdefiniowanie funkcji. W poniższym przykładzie definiujemy nową klasę Person.</p> + +<pre class="brush: js">function Person() { } +or +var Person = function(){ } +</pre> + +<h4 id="The_Object_.28Class_Instance.29" name="The_Object_.28Class_Instance.29">Obiekt (instancja klasy)</h4> + +<p>Żeby utworzyć nową instancję obiektu <em>obj</em>, używamy wyrażenia <span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">new </span><em>obj</em><span style="line-height: 1.5;">, przypisując jego wynik (który jest typu </span><em>obj</em><span style="line-height: 1.5;">) do zmiennej, żeby później mieć do niego dostęp.</span></p> + +<p>W poniższym przykładzie definiujemy klasę Person i tworzymy dwie instancje (person1 i person2).</p> + +<pre class="brush: js">function Person() { } +var person1 = new Person(); +var person2 = new Person(); +</pre> + +<div class="note">Zobacz również <a href="/en/JavaScript/Reference/Global_Objects/Object/create" title="Object.create">Object.create</a>, który jest nową metodą instancjalizacji.</div> + +<h4 id="The_Constructor" name="The_Constructor">Konstruktor</h4> + +<p>Konstruktor jest wywoływany w momencie instancjalizacji (moment, w którym instancja obiektu zostaje utworzona). Konstruktor jest metodą klasy. W JavaScript, funkcja służy za konstruktor obiektu. Nie ma jednak wyraźnej potrzeby definiowania konstruktora. Każda akcja zadeklarowana w konstruktorze zostanie wykonana w momencie utworzenia obiektu.</p> + +<p>Konstruktor jest używany do ustawienia właściwości obiektu lub do wywołania metod przygotowujących obiekt do użytku.</p> + +<p>W poniższym przykładzie konstruktor klasy Person wyświetla ostrzeżenie w momencie kiedy Person zostaje utworzony.</p> + +<pre class="brush: js">function Person() { + alert('Person został utworzony'); +} + +var person1 = new Person(); +var person2 = new Person(); +</pre> + +<h4 id="The_Property_.28object_attribute.29" name="The_Property_.28object_attribute.29">Właściwość (atrybut obiektu)</h4> + +<p>Właściwości są zmiennymi zawartymi wewnątrz klasy. Każda instancja obiektu posiada te właściwości. Właściwości powinny być ustawiane we właściwości prototype klasy (funkcji), dzięki czemu dziedziczenie zadziała prawidłowo.</p> + +<p>Dostęp do właściwości z wnętrza klasy odbywa się za pomocą słowa kluczowego <span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">this</span><span style="line-height: 1.5;">, które odnosi się do aktualnego obiektu. Dostęp (odczyt lub zapis) do właściwości poza klasą odbywa się za pomocą składni: NazwaInstancji.Wlasciwosc; jest to taka sama składnia, jak w językach C++, Java i szeregu innych języków.</span></p> + +<p>W poniższym przykładzie definiujemy właściwość <span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">firstName</span><span style="line-height: 1.5;"> dla klasy </span><span style="font-family: 'Courier New','Andale Mono',monospace;">Person</span><span style="line-height: 1.5;"> i robimy to w momencie utworzenia obiektu.</span></p> + +<pre class="brush: js">function Person(firstName) { + this.firstName = firstName; + alert('Person instantiated'); +} + +var person1 = new Person('Alice'); +var person2 = new Person('Bob'); + +// Pokaż właściwości firstName obiektów +alert('person1 nazywa się ' + person1.firstName); // komunikat "person1 nazywa się Alice" +alert('person2 nazywa się ' + person2.firstName); // komunikat "person2 nazywa się Bob" +</pre> + +<h4 id="The_methods" name="The_methods">Metody</h4> + +<p>Metody opierają się na tej samej logice, co właściwości; różnica polega na tym, że są one funkcjami i definiuje się je jak funkcje. Wywołanie metody wygląda podobnie do wywołania właściwości, z tym, że dodajemy ( ) na końcu nazwy metody, czasami z argumentami. Żeby zdefiniować metodę, przypisujemy funkcję do jakiejś właściwości obiektu <span style="font-family: 'Courier New','Andale Mono',monospace;">prototype</span> klasy; nazwa właściwości staje się nazwą metody, po jakiej wywołamy ją na obiekcie.</p> + +<p>W poniższym przykładzie definiujemy i używamy metodę <span style="font-family: 'Courier New','Andale Mono',monospace;">sayHello()</span> dla klasy Person.</p> + +<pre class="brush: js">function Person(firstName) { + this.firstName = firstName; +} + +Person.prototype.sayHello = function() { + alert("Hello, I'm " + this.firstName); +}; + +var person1 = new Person("Alice"); +var person2 = new Person("Bob"); + +// wywołanie metody sayHello klasy Person +person1.sayHello(); // komunikat "Hello, I'm Alice" +person2.sayHello(); // komunikat "Hello, I'm Bob" +</pre> + +<p>W JavaScript metody to zwykłe funkcje, które są przypisane do obiektu jako jego właściwości, dzięki czemu mogą być wywoływane w jego kontekście. Przyjrzyj się natępującemu przykładowi kodu:</p> + +<pre class="brush: js">function Person(firstName) { + this.firstName = firstName; +} + +Person.prototype.sayHello = function() { + alert("Hello, I'm " + this.firstName); +}; + +var person1 = new Person("Alice"); +var person2 = new Person("Bob"); +var helloFunction = person1.sayHello; + +person1.sayHello(); // komunikat "Hello, I'm Alice" +person2.sayHello(); // <span style="font-size: 1rem;">komunikat</span><span style="font-size: 1rem;"> "Hello, I'm Bob"</span> +helloFunction(); // <span style="font-size: 1rem;">komunikat</span><span style="font-size: 1rem;"> "Hello, I'm undefined" (lub niepowodzenie</span> + // wyświetlające TypeError w trybie strict) +alert(helloFunction === person1.sayHello); // <span style="font-size: 1rem;">komunikat</span><span style="font-size: 1rem;"> true</span> +alert(helloFunction === Person.prototype.sayHello); // <span style="font-size: 1rem;">komunikat</span><span style="font-size: 1rem;"> true</span> +helloFunction.call(person1); // <span style="font-size: 1rem;">komunikat</span><span style="font-size: 1rem;"> "Hello, I'm Alice"</span> +</pre> + +<p>Jak pokazuje powyższy przykład, wszystkie odniesienia do funkcji <span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">sayHello </span><span style="line-height: 1.5;">—</span><span style="line-height: 1.5;"> to w obiekcie person1, w </span><code style="font-style: normal; line-height: 1.5;">Person.prototype</code><span style="line-height: 1.5;">, w </span><code style="font-style: normal; line-height: 1.5;">helloFunction</code><span style="line-height: 1.5;">variable, itd. — dotyczą tej <em>samej funkcji</em>. W trakcie wywołania funkcji, wartość </span><span style="font-family: 'Courier New','Andale Mono',monospace;">this</span><span style="line-height: 1.5;"> zależy od tego, jak ją wywołamy. W typowym przypadku, gdzie wywołujemy funkcję jako metodę obiektu </span><span style="line-height: 1.5;">— </span><code style="font-style: normal; line-height: 1.5;">person1.sayHello()</code><span style="line-height: 1.5;"> — </span><code style="font-style: normal; line-height: 1.5;">this</code><span style="line-height: 1.5;"> odnosi się do obiektu, z którego funkcja pochodzi (person1), stąd </span><span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">person1.sayHello()</span><span style="line-height: 1.5;"> używa nazwy "Alice", a </span><span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">person2.sayHello() </span><span style="line-height: 1.5;">używa nazwy "Bob". Natomiast wywołanie funkcji ze zmiennej </span><span style="line-height: 1.5;">— </span><code style="font-style: normal; line-height: 1.5;">helloFunction()</code><span style="line-height: 1.5;"> —</span><span style="line-height: 1.5;"> ustawia </span><span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">this</span><span style="line-height: 1.5;"> na obiekt globalny (</span><span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">window</span><span style="line-height: 1.5;"> w przypadku przeglądarek). Ponieważ ten obiekt najprawdopodobniej nie posiada właściwości </span><span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">firstName</span><span style="line-height: 1.5;">, ostatecznie otrzymujemy komunikat "Hello, I'm undefined". (Tak będzie w trybie loose; byłoby inaczej [błąd] w <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">trybie strict</a>, ale nie będziemy go tutaj opisywać, żeby nie wprowadzać zamieszania). Możemy też ustawić </span><span style="font-family: 'Courier New','Andale Mono',monospace;">this</span><span style="line-height: 1.5;"> wedle uznania, używając funkcji </span><span style="font-family: 'Courier New','Andale Mono',monospace;">call</span><span style="line-height: 1.5;"> (lub </span><span style="font-family: 'Courier New','Andale Mono',monospace;">apply</span><span style="line-height: 1.5;">), tak jak pokazuje ostatni przykład.</span></p> + +<div class="note">Więcej na temat <span style="font-family: 'Courier New','Andale Mono',monospace;">this</span> w <a href="/en/JavaScript/Reference/Global_Objects/Function/call" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/call">Function#call</a> oraz <a href="/en/JavaScript/Reference/Global_Objects/Function/apply" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/apply">Function#apply</a></div> + +<h4 id="Inheritance" name="Inheritance">Dziedziczenie</h4> + +<p>Dziedziczenie jest sposobem na stworzenie klasy jako specjalistycznej wersji jednej lub większej ilości klas (<em>JavaScript wspiera tylko dziedziczenie pojedyncze</em>). Taka wyspecjalizowana klasa jest często nazywana <em>dzieckiem</em>, natomiast ta druga — <em>rodzicem</em>. W JavaScript osiąga się to poprzez przypisanie klasy rodzica do klasy dziecka, a następnie wyspecjalizowaniu jej. W nowoczesnych przeglądarkach można również użyć <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/create#Classical_inheritance_with_Object.create" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/create#Classical_inheritance_with_Object.create">Object.create</a> do implementacji dziedziczenia.</p> + +<div class="note"> +<p>JavaScript nie wykrywa właściwości klasy dziecka <code>prototype.constructor</code> (zobacz <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/prototype">Core JavaScript 1.5 Reference:Global Objects:Object:prototype</a>), więc musimy tego dokonać ręcznie.</p> +</div> + +<p>W poniższym przykładzie definiujemy klasę <code>Student</code> jako dziecko klasy <code>Person</code>. Następnie definiujemy ponownie metodę <code>sayHello()</code> oraz dodajemy metodę <code>sayGoodBye()</code>.</p> + +<pre class="brush: js">// Definicja konstruktora Person +function Person(firstName) { + this.firstName = firstName; +} + +// Dodajemy kilka metod do Person.prototype +Person.prototype.walk = function(){ + alert("I am walking!"); +}; +Person.prototype.sayHello = function(){ + alert("Hello, I'm " + this.firstName); +}; + +// Definiujemy konstruktor +function Student(firstName, subject) { + // Wywołujemy konstruktor rodzica (używając Function#call) upewniając się, że "this" + // <span style="font-size: 1rem;">zostanie ustawione poprawnie podczas wywołania</span> + Person.call(this, firstName); + + // inicjalizujemy właściwości odpowiednie dla studenta + this.subject = subject; +}; + +// Tworzymy obiekt Student.prototype, który dziedziczy po Person +// Uwaga: Typowym błędem w takich przypadkach jest użycie "new Person()" do utworzenia Student.prototype. +// Jest to niepoprawne z kilku powodów, nie wspominając o tym, +// Nie mielibyśmy jakiej wartości podać jako argument "firstName". +// Prawidłowym miejscem na wywołanie konstruktora Person jest to powyżej, w konstruktorze Student +Student.prototype = Object.create(Person.prototype); + +// Ustawiamy właściwość "constructor" na obiekt Student +Student.prototype.constructor = Student; + +// Zmieniamy metodę "sayHello" +Student.prototype.sayHello = function(){ + alert("Hello, I'm " + this.firstName + ". I'm studying " + this.subject + "."); +}; + +// Dodajemy metodę "sayGoodBye" +Student.prototype.sayGoodBye = function(){ + alert("Goodbye!"); +}; + +// Przykład użycia: +var student1 = new Student("Janet", "Applied Physics"); +student1.sayHello(); // "Hello, I'm Janet. I'm studying Applied Physics." +student1.walk(); // "I am walking!" +student1.sayGoodBye(); // "Goodbye!" + +// sprawdzamy poprawność działania "instanceof" +alert(student1 instanceof Person); // true +alert(student1 instanceof Student); // true +</pre> + +<p>Jeśli chodzi o linię <code>Student.prototype = Object.create(Person.prototype);</code> w starszych silnikach JavaScript, nie posiadających metody <a href="/en/JavaScript/Reference/Global_Objects/Object/create" title="Object.create"><code>Object.create</code></a>, można użyć tzw. "polyfill" (aka "shim", patrz artykuł powyżej), czyli funkcję, która stanowi swego rodzaju łatkę zapewniającą kompatybilność wsteczną danej funkcjonalności. Można też samemu napisać funkcję dającą taki sam efekt:</p> + +<pre class="brush: js">function createObject(proto) { + function ctor() { } + ctor.prototype = proto; + return new ctor(); +} + +// Przykład użycia: +Student.prototype = createObject(Person.prototype); +</pre> + +<div class="note">Zobacz <a href="/en/JavaScript/Reference/Global_Objects/Object/create" title="Object.create">Object.create</a>, żeby poznać wszystkie jego możliwości oraz znaleźć łatkę dla starszych silników JavaScript.</div> + +<h4 id="Encapsulation" name="Encapsulation">Enkapsulacja (hermetyzacja)</h4> + +<p>W poprzednim przykładzie klasa <code>Student</code> nie musiała wiedzieć, w jaki sposób metoda <span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">walk()</span><span style="line-height: 1.5;"> klasy </span><code style="font-style: normal; line-height: 1.5;">Person</code><span style="line-height: 1.5;"> została zaimplementowana</span><span style="line-height: 1.5;">, ale wciąż mogła jej używać; klasa </span><code style="font-style: normal; line-height: 1.5;">Student</code><span style="line-height: 1.5;"> nie musi ponownie definiować tej metody, dopóki nie chcemy jej zmienić. To zjawisko nazywamy </span><strong style="line-height: 1.5;">enkapsulacją</strong><span style="line-height: 1.5;">, czyli każda klasa dziedziczy metody swojego rodzica i definiuje własne tylko wtedy, gdy chce coś zmienić.</span></p> + +<h4 id="Abstraction" name="Abstraction">Abstrakcja</h4> + +<p>Abstrakcja jest mechanizmem, który pozwala modelować aktualnie rozpatrywany problem. Może to być osiągane przez dziedziczenie (specjalizację) lub kompozycję. JavaScript osiąga specjalizację dzięki dziedziczeniu, a kompozycję dzięki umożliwieniu instancjom klas bycie wartościami atrybutów innych obiektów.</p> + +<p>Klasa Function w JavaScript dziedziczy po klasie Object (jest to przykład specjalizacji modelu), natomiast właściwość Function.prototype jest instancją Object (co z kolei jest przykładem kompozycji).</p> + +<pre class="brush: js">var foo = function(){}; +alert( 'foo is a Function: ' + (foo instanceof Function) ); +alert( 'foo.prototype is an Object: ' + (foo.prototype instanceof Object) ); +</pre> + +<h4 id="Polymorphism" name="Polymorphism">Polimorfizm</h4> + +<p>Tak, jak wszystkie metody i właściwości są zdefiniowane wewnątrz właściwości <code>prototype</code>, tak różne klasy mogą definiować metody z tą samą nazwą; metody mają zasięg ograniczony do klasy, w której zostały zdefiniowane. Ma to rację bytu tylko w przypadku, gdy dwie klasy nie są w relacji rodzic-dziecko (kiedy jedna nie dziedziczy po drugiej w łańcuchu dziedziczenia).</p> + +<h2 id="Notes" name="Notes">Uwagi</h2> + +<p>Techniki implementacji programowania zorientowanego obiektowo zaprezentowane w tym artykule nie są jedynymi, jakie umożliwia JavaScript, dzięki czemu sposób osiągnięcia programowania obiektowego jest w tym języku bardzo elastyczny.</p> + +<p>Techniki tutaj przedstawione nie zawierają żadnych sztuczek językowych, ani nie próbują naśladować implementacji teorii obiektowości z innych języków.</p> + +<p>Istnieją inne techniki, które czynią programowanie obiektowe w JavaScript jeszcze bardziej zaawansowanym, jednak są one poza zasięgiem tego artykułu wprowadzającego.</p> + +<h2 id="References" name="References">Przypisy</h2> + +<ol> + <li>Mozilla. "<a href="/docs/Web/JavaScript/Guide" title="/docs/Web/JavaScript/Guide">Core JavaScript 1.5 Guide</a>", https://developer.mozilla.org/docs/Web/JavaScript/Guide</li> + <li>Wikipedia. "Object-oriented programming", <a class="external" href="http://en.wikipedia.org/wiki/Object-oriented_programming" rel="freelink">http://en.wikipedia.org/wiki/Object-...ed_programming</a></li> + <li><a href="http://davidwalsh.name/javascript-objects">OOP JavaScript Overview</a> series by Kyle Simpson</li> +</ol> diff --git a/files/pl/web/javascript/zasoby_języka_javascript/index.html b/files/pl/web/javascript/zasoby_języka_javascript/index.html new file mode 100644 index 0000000000..c53fd0fd2a --- /dev/null +++ b/files/pl/web/javascript/zasoby_języka_javascript/index.html @@ -0,0 +1,48 @@ +--- +title: Zasoby języka JavaScript +slug: Web/JavaScript/Zasoby_języka_JavaScript +tags: + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Language_Resources +--- +<p> +</p> +<h3 id="JavaScript_1.x" name="JavaScript_1.x">JavaScript 1.x</h3> +<p>ECMAScript jest nazwą używaną dla JavaScriptu ustandaryzowanego przez komitet TC39 <a class="external" href="http://www.ecma-international.org/">organizacji standardów ECMA</a>. Poniższe standardy ECMAScript zostały zatwierdzone: +</p> +<table class="standard-table"> <tbody><tr> <th>Nazwa</th> <th>Odnośniki</th> <th>Data</th> <th>Opis</th> </tr> <tr> <td>ECMA-262</td> <td><a class="external" href="http://www.mozilla.org/js/language/E262.pdf">PDF</a></td> <td>Czerwiec 1997</td> <td>Oryginalny standard ECMAScript.</td> </tr> <tr> <td>2 Edycja ECMA-262</td> <td><a class="external" href="http://www.mozilla.org/js/language/E262-2.pdf">PDF</a></td> <td>Sierpień 1998</td> <td>Druga wersja standardu ECMAScript; również standard ISO 16262.</td> </tr> <tr> <td>3 Edycja ECMA-262</td> <td><a class="external" href="http://www.mozilla.org/js/language/E262-3.pdf">PDF</a> <a class="external" href="http://www.mozilla.org/js/language/E262-3.doc">Word</a></td> <td>Grudzień 1999</td> <td>Trzecia i najbardziej aktualna wersja standardu ECMAScript; nawiązuje do JavaScript 1.5.<br> Zobacz także <a class="external" href="http://www.mozilla.org/js/language/E262-3-errata.html">erratę</a>.</td> </tr> <tr> <td>ECMA-357</td> <td><a class="external" href="http://www.mozilla.org/js/language/ECMA-357.pdf">PDF</a></td> <td>Czerwiec 2004</td> <td>ECMAScript dla XML (E4X).<br> Zobacz także <a class="link-https" href="https://bugzilla.mozilla.org/attachment.cgi?id=169406">erratę E4X</a>.</td> </tr> +</tbody></table> +<h3 id="JavaScript_2.0_i_4_edycja_ECMAScript" name="JavaScript_2.0_i_4_edycja_ECMAScript">JavaScript 2.0 i 4 edycja ECMAScript</h3> +<h4 id="Bie.C5.BC.C4.85ce_informacje" name="Bie.C5.BC.C4.85ce_informacje"> Bieżące informacje</h4> +<p>Nowe: myśl przewodnia Brendana <a class="external" href="http://www.mozilla.org/js/language/ICFP-Keynote.ppt">JavaScript at Ten Years</a> <small>(Powerpoint)</small> na konferencję <a class="external" href="http://www.brics.dk/~danvy/icfp05/">ACM ICFP 2005</a>. +</p><p>Obecne prace nad czwartą edycją ECMAScript są okresowe wysyłane na <a class=" external" href="http://developer.mozilla.org/es4/" rel="freelink">http://developer.mozilla.org/es4/</a> +</p> +<h4 id="Informacje_historyczne" name="Informacje_historyczne"> Informacje historyczne </h4> +<div class="warning"> +<p>Informacje w tym fragmencie są przestarzałe. +</p> +</div> +<p>Zobacz <a class="external" href="http://www.mozilla.org/js/language/js20/index.html">stronę JavaScript 2.0</a>, aby obejrzeć propozycję Netscapa dotyczącą kolejnej wersji języka JavaScript. Wszystkie informacje tam zawarte są w zasadzie jedynie wstępem i niekoniecznie wskazują konkretne funkcje, które zostaną zaimplementowane w przyszłości. Pracujemy w ramach ECMA TC39, aby koordynować i ustandaryzować proponowane zmiany. +</p><p>Zobacz stronę <a class="external" href="http://www.mozilla.org/js/language/es4/index.html">4 edycji ECMAScript</a>, aby dowiedzieć się o pokrewnej Netscapowi propozycji kolejnej wersji standardu ECMAScript. +</p><p>Waldemar jest twórcą 4 edycji standardu ECMA-262 zaproponowanej na rok 2002. Niekompletny szkic ECMA TC39, będący w trakcie konstrukcji, jest dostępny tutaj w formacie PDF. +</p><p>Waldemar zaprezentował wykład na temat JavaScriptu 2.0 na <a class="external" href="http://ll1.ai.mit.edu/">konferencji LL1</a> na MIT. Sprawdź odnośnik agendy, aby uzyskać slajdy z wykładu. +</p><p>Waldemar zaprezentował druk <a class="external" href="http://www.mozilla.org/js/language/evolvingJS.pdf">"JavaScript 2.0: Evolving a Language for Evolving Systems?"</a><small> (PDF)</small> oraz wykład na temat JavaScriptu 2.0 (<a class="external" href="http://www.mozilla.org/js/language/evolvingJSTalk.ppt">slajdy PowerPoint</a>) na <a class="external" href="http://www.machack.com/">MacHack 2002</a>. Opisują one niektóre z cech języka JavaScript 2.0 i uzasadnienie ich wyboru i konkretnego użycia. +</p><p>Dostępna jest wczesna implementacja JavaScriptu 2.0 o nazwie kodowej <a class="external" href="http://www.mozilla.org/js/language/Epimetheus.html">Epimetheus</a>. +</p> +<h3 id="LiveConnect" name="LiveConnect">LiveConnect</h3> +<p>LiveConnect jest mostem pomiędzy JavaScriptem a Javą. <a class="external" href="http://www.mozilla.org/js/liveconnect/">3 wersja LiveConnect</a> jest zaimplementowana w <a href="pl/SpiderMonkey">SpiderMonkey</a> od wersji 1.4 i w <a href="pl/Rhino">Rhino</a> od wersji 1.5. +</p> +<h3 id="R.C3.B3.C5.BCne" name="R.C3.B3.C5.BCne">Różne</h3> +<p>Poniższe zasoby mogą również okazać się pomocne: +</p> +<ul><li> <a class="external" href="http://www.mozilla.org/js/language/grammar14.html">Gramatyka LR(1)</a> dla JavaScriptu 1.5 <small><a class="external" href="http://www.mozilla.org/js/language/grammar14.rtf">(wersja rtf)</a></small> +</li><li> <a class="external" href="http://www.mozilla.org/js/language/bibliography.html">Bibliografia Waldemara</a> +</li></ul> +<div class="originaldocinfo"> +<h2 id="Informacje_o_pochodzeniu_dokumentu" name="Informacje_o_pochodzeniu_dokumentu"> Informacje o pochodzeniu dokumentu </h2> +<ul><li> Autorzy: <a class="link-mailto" href="mailto:brendan@mozilla.org">Brendan Eich</a>, <a class="link-mailto" href="mailto:bob@bclary.org">Bob Clary</a> +</li><li> Data ostatniej aktualizacji: Friday, January 24, 2003 +</li></ul> +</div> +{{ languages( { "en": "en/JavaScript_Language_Resources", "ja": "ja/JavaScript_Language_Resources" } ) }} |