diff options
Diffstat (limited to 'files/pl/web/javascript/reference/statements')
23 files changed, 2722 insertions, 0 deletions
diff --git a/files/pl/web/javascript/reference/statements/async_function/index.html b/files/pl/web/javascript/reference/statements/async_function/index.html new file mode 100644 index 0000000000..95b488405e --- /dev/null +++ b/files/pl/web/javascript/reference/statements/async_function/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/reference/statements/block/index.html b/files/pl/web/javascript/reference/statements/block/index.html new file mode 100644 index 0000000000..bbc5c7e4fb --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/break/index.html b/files/pl/web/javascript/reference/statements/break/index.html new file mode 100644 index 0000000000..661b130d71 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/class/index.html b/files/pl/web/javascript/reference/statements/class/index.html new file mode 100644 index 0000000000..05cdb7b2d4 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/const/index.html b/files/pl/web/javascript/reference/statements/const/index.html new file mode 100644 index 0000000000..ead1ca32fb --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/continue/index.html b/files/pl/web/javascript/reference/statements/continue/index.html new file mode 100644 index 0000000000..b6c2a05d94 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/debugger/index.html b/files/pl/web/javascript/reference/statements/debugger/index.html new file mode 100644 index 0000000000..b4fe9548a7 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/do...while/index.html b/files/pl/web/javascript/reference/statements/do...while/index.html new file mode 100644 index 0000000000..a57caf17ee --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/empty/index.html b/files/pl/web/javascript/reference/statements/empty/index.html new file mode 100644 index 0000000000..4c55c3f4dd --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/export/index.html b/files/pl/web/javascript/reference/statements/export/index.html new file mode 100644 index 0000000000..3b29f1987b --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/for...in/index.html b/files/pl/web/javascript/reference/statements/for...in/index.html new file mode 100644 index 0000000000..d8c17d3b3e --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/for/index.html b/files/pl/web/javascript/reference/statements/for/index.html new file mode 100644 index 0000000000..1178c277ef --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/function/index.html b/files/pl/web/javascript/reference/statements/function/index.html new file mode 100644 index 0000000000..6b9eba95dd --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/function_star_/index.html b/files/pl/web/javascript/reference/statements/function_star_/index.html new file mode 100644 index 0000000000..5962e0c286 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/if...else/index.html b/files/pl/web/javascript/reference/statements/if...else/index.html new file mode 100644 index 0000000000..38dd3c8f8a --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/import/index.html b/files/pl/web/javascript/reference/statements/import/index.html new file mode 100644 index 0000000000..406050c420 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/index.html b/files/pl/web/javascript/reference/statements/index.html new file mode 100644 index 0000000000..b6f58b783c --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/label/index.html b/files/pl/web/javascript/reference/statements/label/index.html new file mode 100644 index 0000000000..7ff42b3940 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/label/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/reference/statements/return/index.html b/files/pl/web/javascript/reference/statements/return/index.html new file mode 100644 index 0000000000..ed7849ed65 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/switch/index.html b/files/pl/web/javascript/reference/statements/switch/index.html new file mode 100644 index 0000000000..d131e042ca --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/throw/index.html b/files/pl/web/javascript/reference/statements/throw/index.html new file mode 100644 index 0000000000..a8d57064f5 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/var/index.html b/files/pl/web/javascript/reference/statements/var/index.html new file mode 100644 index 0000000000..aff42bcdac --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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/reference/statements/while/index.html b/files/pl/web/javascript/reference/statements/while/index.html new file mode 100644 index 0000000000..103762fd01 --- /dev/null +++ b/files/pl/web/javascript/reference/statements/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" } ) }} |