Merge pull request #38 from fiji-flo/unslugging-pl

Unslugging pl

301 files changed, 30475 insertions, 4 deletions

diff --git a/files/pl/web/javascript/reference/about/index.html b/files/pl/web/javascript/reference/about/index.html
new file mode 100644
index 0000000000..b574d1e042
--- /dev/null
+++ b/files/pl/web/javascript/reference/about/index.html
@@ -0,0 +1,59 @@
+---
+title: O dokumentacji referencyjnej
+slug: Web/JavaScript/Reference/About
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - Informator
+  - JavaScript
+  - Referencje
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/About
+original_slug: Web/JavaScript/Referencje/O_tym_dokumencie
+---
+<p>{{JsSidebar}}</p>
+
+<p>Dokumentacja referencyjna JavaScript służy jako repozytorium faktów w zakresie języka JavaScript. Tutaj opisany jest szczegółowo cały język. Podczas pisania kodu JavaScript, będziesz często zaglądać na te strony, stąd nazwa tej części dokumentacji (dokumentacja referencyjna). Jeśli uczysz się dopiero JavaScript lub potrzebujesz wyjaśnień na temat jakichś możliwości lub funkcjonalności, sprawdz nasz <a href="/pl/docs/Web/JavaScript/Guide">podręcznik JavaScript</a>.</p>
+
+<p>Język JavaScript jest przeznaczony do użycia w szerokim środowisku, zarówno w przeglądarce internetowej, aplikacjach na urządzenia mobilne jak i skryptach działających po stronie serwera. Przeważająca część informacji, zawarta w naszym dokumentacji referencyjnej, ma charakters agnostyczny i nie dotyczy środowiska przeglądarki.</p>
+
+<h2 id="Gdzie_znaleźć_informacje_o_JavaScript">Gdzie znaleźć informacje o JavaScript</h2>
+
+<p>Nasza dokumentacja rdzennych funkcjonalności JavaScript (w przeważającej części czysty <a href="/pl/docs/Web/JavaScript/Zasoby_języka_JavaScript">ECMAScript</a>) obejmuje</p>
+
+<ul>
+ <li><a href="/pl/docs/Web/JavaScript/Guide">Podręcznik JavaScript</a></li>
+ <li><a href="/pl/docs/Web/JavaScript/Referencje">Dokumentację referencyjną JavaScript</a></li>
+</ul>
+
+<p>Jeśli jesteś początkującym w JavaScript, rozpocznij od lektury <a href="/pl/docs/Web/JavaScript/Guide">podręcznika</a>. Gdy już będziesz zrozumiesz podstawy, możesz zająć się <a href="/pl/docs/Web/JavaScript/Referencje">referencjami</a>, aby uzyskać wiedzę na temat poszczególnych obiektów i konstrukcji językowych.</p>
+
+<h2 id="Struktura_dokumentacji_referencyjnej">Struktura dokumentacji referencyjnej</h2>
+
+<p>W dokumentacji referencyjnej znajdują się następujące rozdziały:</p>
+
+<dl>
+ <dt><a href="/pl/docs/Web/JavaScript/Referencje/Obiekty">Obiekty</a></dt>
+ <dd>W tym rozdziale opisano wszystkie standardowe obiekty wbudowane JavaScript, w tym ich metody i właściwości.</dd>
+ <dt><a href="/pl/docs/Web/JavaScript/Referencje/Polecenia">Polecenia i deklaracje</a></dt>
+ <dd>JavaScript applications consist of statements with an appropriate syntax. A single statement may span multiple lines. Multiple statements may occur on a single line if each statement is separated by a semicolon. This isn't a keyword, but a group of keywords.</dd>
+ <dt><a href="/pl/docs/Web/JavaScript/Referencje/Operatory">Operatory i wyrażenia</a></dt>
+ <dd>This chapter documents all the JavaScript language operators, expressions and keywords.</dd>
+ <dt><a href="/pl/docs/Web/JavaScript/Reference/Functions">Funkcje</a></dt>
+ <dd>Chapter about JavaScript functions.</dd>
+ <dt><a href="/pl/docs/Web/JavaScript/Reference/Classes">Klasy</a></dt>
+ <dd>Chapter about JavaScript classes introduced in ECMAScript 2015.</dd>
+ <dt><a href="/pl/docs/Web/JavaScript/Reference/Errors">Błędy</a></dt>
+ <dd>Chapter about specific errors, exceptions and warnings thrown by JavaScript.</dd>
+ <dt><a href="/pl/docs/Web/JavaScript/New_in_JavaScript">Nowości w JavaScript</a></dt>
+ <dd>Chapter about JavaScript version history.</dd>
+</dl>
+
+<h3 id="Więcej_odnośnych_stron">Więcej odnośnych stron</h3>
+
+<ul>
+ <li><a href="/pl/docs/Web/JavaScript/Referencje/Przestarzałe_własności_i_metody">Przestarzałe własności i metody</a></li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">Gramatyka leksykalna</a></li>
+ <li><a href="/pl/docs/Web/JavaScript/typy_oraz_struktury_danych">Typy oraz struktury danych w JavaScript</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/classes/konstruktor/index.html b/files/pl/web/javascript/reference/classes/constructor/index.html
index 353adecd19..8d11cce8f0 100644
--- a/files/pl/web/javascript/reference/classes/konstruktor/index.html
+++ b/files/pl/web/javascript/reference/classes/constructor/index.html
@@ -1,11 +1,12 @@
 ---
 title: Konstruktor
-slug: Web/JavaScript/Reference/Classes/Konstruktor
+slug: Web/JavaScript/Reference/Classes/constructor
 tags:
   - Classes
   - JavaScript
   - Language feature
 translation_of: Web/JavaScript/Reference/Classes/constructor
+original_slug: Web/JavaScript/Reference/Classes/Konstruktor
 ---
 <div>{{jsSidebar("Classes")}}</div>
 
diff --git a/files/pl/web/javascript/reference/deprecated_and_obsolete_features/index.html b/files/pl/web/javascript/reference/deprecated_and_obsolete_features/index.html
new file mode 100644
index 0000000000..e937d7c66d
--- /dev/null
+++ b/files/pl/web/javascript/reference/deprecated_and_obsolete_features/index.html
@@ -0,0 +1,293 @@
+---
+title: Przestarzałe własności i metody
+slug: Web/JavaScript/Reference/Deprecated_and_obsolete_features
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Deprecated_and_obsolete_features
+original_slug: Web/JavaScript/Referencje/Przestarzałe_własności_i_metody
+---
+<div>{{JsSidebar("More")}}</div>
+
+<p>This page lists features of JavaScript that are deprecated (that is, still available but planned for removal) and obsolete (that is, no longer usable).</p>
+
+<h2 id="Deprecated_features">Deprecated features</h2>
+
+<p>These deprecated features can still be used, but should be used with caution because they are expected to be removed entirely sometime in the future. You should work to remove their use from your code.</p>
+
+<h3 id="RegExp_properties">RegExp properties</h3>
+
+<p>The following properties are deprecated. This does not affect their use in {{jsxref("String.replace", "replacement strings", "", 1)}}:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Property</th>
+   <th>Description</th>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.n", "$1-$9")}}</td>
+   <td>
+    <p>Parenthesized substring matches, if any.<br>
+     <strong>Warning:</strong> Using these properties can result in problems, since browser extensions can modify them. Avoid them!</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.input", "$_")}}</td>
+   <td>See <code>input</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.multiline", "$*")}}</td>
+   <td>See <code>multiline</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastMatch", "$&amp;")}}</td>
+   <td>See <code>lastMatch</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastParen", "$+")}}</td>
+   <td>See <code>lastParen</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.leftContext", "$`")}}</td>
+   <td>See <code>leftContext</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.rightContext", "$'")}}</td>
+   <td>See <code>rightContext</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.input", "input")}}</td>
+   <td>The string against which a regular expression is matched.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastMatch", "lastMatch")}}</td>
+   <td>The last matched characters.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastParen", "lastParen")}}</td>
+   <td>The last parenthesized substring match, if any.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.leftContext", "leftContext")}}</td>
+   <td>The substring preceding the most recent match.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.rightContext", "rightContext")}}</td>
+   <td>The substring following the most recent match.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>The following are now properties of <code>RegExp</code> instances, no longer of the <code>RegExp</code> object:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Property</th>
+   <th>Description</th>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.global", "global")}}</td>
+   <td>Whether or not to test the regular expression against all possible matches in a string, or only against the first.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.ignoreCase", "ignoreCase")}}</td>
+   <td>Whether or not to ignore case while attempting a match in a string.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastIndex", "lastIndex")}}</td>
+   <td>The index at which to start the next match.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.multiline", "multiline")}}</td>
+   <td>Whether or not to search in strings across multiple lines.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.source", "source")}}</td>
+   <td>The text of the pattern.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="RegExp_methods">RegExp methods</h3>
+
+<ul>
+ <li>The {{jsxref("RegExp.compile", "compile()")}} method is deprecated.</li>
+ <li>The <code>valueOf</code> method is no longer specialized for <code>RegExp</code>. Use {{jsxref("Object.valueOf()")}}.</li>
+</ul>
+
+<h3 id="Function_properties">Function properties</h3>
+
+<ul>
+ <li>The {{jsxref("Global_Objects/Function/caller", "caller")}} and {{jsxref("Global_Objects/Function/arguments", "arguments")}} properties are deprecated, because they leak the function caller. Instead of the arguments property, you should use the {{jsxref("Functions/arguments", "arguments")}} object inside function closures.</li>
+</ul>
+
+<h3 id="Legacy_generator">Legacy generator</h3>
+
+<ul>
+ <li>{{jsxref("Statements/Legacy_generator_function", "Legacy generator function statement")}} and {{jsxref("Operators/Legacy_generator_function", "Legacy generator function expression")}} are deprecated. Use {{jsxref("Statements/function*", "function* statement")}} and {{jsxref("Operators/function*", "function* expression")}} instead.</li>
+ <li>{{jsxref("Operators/Array_comprehensions", "JS1.7/JS1.8 Array comprehension", "#Differences_to_the_older_JS1.7.2FJS1.8_comprehensions")}} and {{jsxref("Operators/Generator_comprehensions", "JS1.7/JS1.8 Generator comprehension", "#Differences_to_the_older_JS1.7.2FJS1.8_comprehensions")}} are deprecated.</li>
+</ul>
+
+<h3 id="Iterator">Iterator</h3>
+
+<ul>
+ <li>{{jsxref("Global_Objects/StopIteration", "StopIteration")}} is deprecated.</li>
+ <li>{{jsxref("Global_Objects/Iterator", "Iterator")}} is deprecated.</li>
+</ul>
+
+<h3 id="Object_methods">Object methods</h3>
+
+<ul>
+ <li>{{jsxref("Object.watch", "watch")}} and {{jsxref("Object.unwatch", "unwatch")}} are deprecated. Use {{jsxref("Proxy")}} instead.</li>
+ <li><code>__iterator__</code> is deprecated.</li>
+ <li>{{jsxref("Object.noSuchMethod", "__noSuchMethod__")}} is deprecated. Use {{jsxref("Proxy")}} instead.</li>
+</ul>
+
+<h3 id="Date_methods">Date methods</h3>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Date/getYear", "getYear")}} and {{jsxref("Global_Objects/Date/setYear", "setYear")}} are affected by the Year-2000-Problem and have been subsumed by {{jsxref("Global_Objects/Date/getFullYear", "getFullYear")}} and {{jsxref("Global_Objects/Date/setFullYear", "setFullYear")}}.</li>
+ <li>You should use {{jsxref("Global_Objects/Date/toISOString", "toISOString")}} instead of the deprecated {{jsxref("Global_Objects/Date/toGMTString", "toGMTString")}} method in new code.</li>
+ <li>{{jsxref("Global_Objects/Date/toLocaleFormat", "toLocaleFormat")}} is deprecated.</li>
+</ul>
+
+<h3 id="Functions">Functions</h3>
+
+<ul>
+ <li>{{jsxref("Operators/Expression_closures", "Expression closures", "", 1)}} are deprecated. Use regular {{jsxref("Operators/function", "functions")}} or {{jsxref("Functions/Arrow_functions", "arrow functions", "", 1)}} instead.</li>
+</ul>
+
+<h3 id="Proxy">Proxy</h3>
+
+<ul>
+ <li><a href="/en-US/docs/Archive/Web/Old_Proxy_API">Proxy.create</a> and <a href="/en-US/docs/Archive/Web/Old_Proxy_API">Proxy.createFunction</a> are deprecated. Use {{jsxref("Proxy")}} instead.</li>
+ <li>The following traps are obsolete:
+  <ul>
+   <li><code>hasOwn</code> ({{bug(980565)}}, Firefox 33).</li>
+   <li><code>getEnumerablePropertyKeys</code> ({{bug(783829)}}, Firefox 37)</li>
+   <li><code>getOwnPropertyNames</code> ({{bug(1007334)}}, Firefox 33)</li>
+   <li><code>keys</code> ({{bug(1007334)}}, Firefox 33)</li>
+  </ul>
+ </li>
+</ul>
+
+<h3 id="Escape_sequences">Escape sequences</h3>
+
+<ul>
+ <li>Octal escape sequences (\ followed by one, two, or three octal digits) are deprecated in string and regular expression literals.</li>
+ <li>The {{jsxref("Global_Objects/escape", "escape")}} and {{jsxref("Global_Objects/unescape", "unescape")}} functions are deprecated. Use {{jsxref("Global_Objects/encodeURI", "encodeURI")}}, {{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent")}}, {{jsxref("Global_Objects/decodeURI", "decodeURI")}} or {{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent")}} to encode and decode escape sequences for special characters.</li>
+</ul>
+
+<h3 id="String_methods">String methods</h3>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/en-US/docs/tag/HTML%20wrapper%20methods">HTML wrapper methods</a> like {{jsxref("String.prototype.fontsize")}} and {{jsxref("String.prototype.big")}}.</li>
+ <li>{{jsxref("String.prototype.quote")}} is removed from Firefox 37.</li>
+ <li>non standard <code>flags</code> parameter in {{jsxref("String.prototype.search")}}, {{jsxref("String.prototype.match")}}, and {{jsxref("String.prototype.replace")}} are deprecated.</li>
+</ul>
+
+<h2 id="Obsolete_features">Obsolete features</h2>
+
+<p>These obsolete features have been entirely removed from JavaScript and can no longer be used as of the indicated version of JavaScript.</p>
+
+<h3 id="Object">Object</h3>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Property</th>
+   <th>Description</th>
+  </tr>
+  <tr>
+   <td>{{jsxref("Global_Objects/Object/count", "__count__")}}</td>
+   <td>Returns the number of enumerable properties directly on a user-defined object.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Global_Objects/Object/Parent", "__parent__")}}</td>
+   <td>Points to an object's context.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Global_Objects/Object/eval", "Object.prototype.eval()")}}</td>
+   <td>Evaluates a string of JavaScript code in the context of the specified object.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Object.observe()")}}</td>
+   <td>Asynchronously observing the changes to an object.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Object.unobserve()")}}</td>
+   <td>Remove observers.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Object.getNotifier()")}}</td>
+   <td>Creates an object that allows to synthetically trigger a change.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="Function">Function</h3>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Property</th>
+   <th>Description</th>
+  </tr>
+  <tr>
+   <td>{{jsxref("Global_Objects/Function/arity", "arity")}}</td>
+   <td>Number of formal arguments.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="Array">Array</h3>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td>Property</td>
+   <td>Description</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Array.observe()")}}</td>
+   <td>Asynchronously observing changes to Arrays.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Array.unobserve()")}}</td>
+   <td>Remove observers.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="Number">Number</h3>
+
+<ul>
+ <li>{{jsxref("Number.toInteger()")}}</li>
+</ul>
+
+<h3 id="ParallelArray">ParallelArray</h3>
+
+<ul>
+ <li>{{jsxref("ParallelArray")}}</li>
+</ul>
+
+<h3 id="Statements">Statements</h3>
+
+<ul>
+ <li>{{jsxref("Statements/for_each...in", "for each...in")}} is deprecated. Use {{jsxref("Statements/for...of", "for...of")}} instead.</li>
+ <li>Destructuring {{jsxref("Statements/for...in", "for...in")}} is deprecated. Use {{jsxref("Statements/for...of", "for...of")}} instead.</li>
+ <li>let blocks and let expressions are obsolete.</li>
+</ul>
+
+<h3 id="E4X">E4X</h3>
+
+<p>See <a href="/en-US/docs/Archive/Web/E4X">E4X</a> for more information.</p>
+
+<h3 id="Sharp_variables">Sharp variables</h3>
+
+<p>See <a href="/en-US/docs/Archive/Web/Sharp_variables_in_JavaScript">Sharp variables in JavaScript</a> for more information.</p>
diff --git a/files/pl/web/javascript/reference/errors/brakujący_średnik_po_własności_id/index.html b/files/pl/web/javascript/reference/errors/missing_colon_after_property_id/index.html
index ecdb783335..c100d384ac 100644
--- a/files/pl/web/javascript/reference/errors/brakujący_średnik_po_własności_id/index.html
+++ b/files/pl/web/javascript/reference/errors/missing_colon_after_property_id/index.html
@@ -1,12 +1,13 @@
 ---
 title: 'Błąd składni: brakująca własność po identyfikatorze.'
-slug: Web/JavaScript/Reference/Errors/Brakujący_średnik_po_własności_id
+slug: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id
 tags:
   - Błąd
   - Błąd składniowy
   - Błędy
   - JavaScript
 translation_of: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id
+original_slug: Web/JavaScript/Reference/Errors/Brakujący_średnik_po_własności_id
 ---
 <div>{{jsSidebar("Errors")}}</div>
 
diff --git a/files/pl/web/javascript/reference/functions/arguments/callee/index.html b/files/pl/web/javascript/reference/functions/arguments/callee/index.html
new file mode 100644
index 0000000000..04c4c87538
--- /dev/null
+++ b/files/pl/web/javascript/reference/functions/arguments/callee/index.html
@@ -0,0 +1,61 @@
+---
+title: callee
+slug: Web/JavaScript/Reference/Functions/arguments/callee
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Functions/arguments/callee
+original_slug: Web/JavaScript/Referencje/Funkcje/arguments/callee
+---
+<p>
+</p>
+<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3>
+<p>Określa aktualnie wykonywaną funkcję.
+</p>
+<table class="fullwidth-table">
+<tbody><tr>
+<td class="header" colspan="2">Własność obiektów <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments">arguments</a> i <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/arguments">Function.arguments</a> (Wycofywany)</td>
+</tr>
+<tr>
+<td>Zaimplementowano w:</td>
+<td>JavaScript 1.2
+<p>JavaScript 1.4: <code>callee</code> wycofywany jako własność <code>Function.arguments</code>, zachowany jako własność zmiennej lokalnej <code>arguments</code> funkcji.
+</p>
+</td>
+</tr>
+<tr>
+<td>Wersja ECMA:</td>
+<td>ECMA-262</td>
+</tr>
+</tbody></table>
+<h3 id="Opis" name="Opis"> Opis </h3>
+<p><code>callee</code> jest własnością zmiennej lokalnej <code>arguments</code> dostępnej wewnątrz wszystkich obiektów funkcji; <code>callee</code> jako własność <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/arguments">Function.arguments</a></code> nie jest już używana (również sam obiekt <code>Function.arguments</code> jest wycofywany).
+</p><p><code>arguments.callee</code> pozwala anonimowym funkcjom odwoływać się do siebie samych, co jest potrzebne w przypadku rekursywnych anonimowych funkcji.
+</p><p>Słowo kluczowe <code>this</code> nie odwołuje się do aktualnie wykonywanej funkcji. Użyj własności <code>callee</code>, aby odwołać się do funkcji z poziomu jej ciała.
+</p>
+<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3>
+<h4 id="Przyk.C5.82ad:_Zastosowanie_arguments.callee_w_anonimowych_funkcjach_rekursywnych" name="Przyk.C5.82ad:_Zastosowanie_arguments.callee_w_anonimowych_funkcjach_rekursywnych"> Przykład: Zastosowanie <code>arguments.callee</code> w anonimowych funkcjach rekursywnych </h4>
+<p>Funkcja rekursywna musi mieć możliwość odwołania się do siebie samej. Zazwyczaj funkcja odwołuje się do samej siebie wykorzystując swoją nazwę. Jednakże anonimowa funkcja nie posiada nazwy i jeśli w łańcuchu zasięgu nie istnieje zmienna odwołująca się do tej funkcji, tj. funkcja nie jest przypisana do żadnej zmiennej, to funkcja ta nie ma możliwości odwołania się do siebie samej (anonimowe funkcje można tworzyć przy użyciu <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_function">wyrażenia function</a> lub <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">konstruktora <code>Function</code></a>). W tym miejscu wkracza <code>arguments.callee</code>.
+</p><p>Poniższy przykład definiuje funkcję, która z kolei definiuje i zwraca funkcję obliczającą silnię.
+</p>
+<pre class="eval">function makeFactorialFunc() {
+   alert('tworzenie funkcji obliczającej silnię!');
+   return function(x) {
+      if (x &lt;= 1)
+         return 1;
+      return x * arguments.callee(x - 1);
+   };
+}
+
+var result = makeFactorialFunc()(5); // zwraca 120 (5 * 4 * 3 * 2 * 1)
+</pre>
+<p><span class="comment">this example isn't very practical, but then again, there are few practical cases where arguments.callee is necessary, and most of the those cases involve closures</span>
+</p><p><br>
+</p><p><br>
+</p><p><br>
+</p>
+<div class="noinclude">
+</div>
+{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments/callee", "es": "es/Referencia_de_JavaScript_1.5/Funciones/arguments/callee", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments/callee", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments/callee" } ) }}
diff --git a/files/pl/web/javascript/reference/functions/arguments/index.html b/files/pl/web/javascript/reference/functions/arguments/index.html
new file mode 100644
index 0000000000..66091708d9
--- /dev/null
+++ b/files/pl/web/javascript/reference/functions/arguments/index.html
@@ -0,0 +1,130 @@
+---
+title: arguments
+slug: Web/JavaScript/Reference/Functions/arguments
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Functions/arguments
+original_slug: Web/JavaScript/Referencje/Funkcje/arguments
+---
+<p>
+</p>
+<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3>
+<p>Tablicopodobny obiekt odpowiadający argumentom przekazanym do funkcji.
+</p>
+<table class="fullwidth-table">
+<tbody><tr>
+<td class="header" colspan="2">
+Zmienna lokalna we wszystkich funkcjach oraz wycofywana własność obiektu <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a></td>
+</tr>
+<tr>
+<td>Zaimplementowana w:</td>
+<td>JavaScript 1.1, NES 2.0
+<p>JavaScript 1.2: dodano własność <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/callee">arguments.callee</a></code>.
+</p><p>JavaScript 1.3: wycofywana własność <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/caller">arguments.caller</a></code>; usunięto obsługę nazw argumentów oraz zmiennych lokalnych jako własności obiektu <code>arguments</code>.
+</p><p>JavaScript 1.4: wycofywane <code>arguments</code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/callee">arguments.callee</a></code> oraz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">arguments.length</a></code> jako własności <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a></code>; zachowanie <code>arguments</code> jako lokalnej zmiennej funkcji oraz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/callee">arguments.callee</a></code> oraz <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">arguments.length</a></code> jako własności tej zmiennej.
+</p>
+</td>
+</tr>
+<tr>
+<td>Wersja ECMA:</td>
+<td>ECMA-262</td>
+</tr>
+</tbody></table>
+<h3 id="Opis" name="Opis"> Opis </h3>
+<p>Obiekt <code>arguments</code> jest zmienną lokalną dostępną wewnątrz każdej funkcji; <code>arguments</code> jako własność <code>Function</code> nie może być już używana.
+</p><p>Do argumentów wewnątrz funkcji możesz odwołać się używając obiektu <code>arguments</code>. Obiekt ten zawiera pozycję dla każdego argumentu przekazanego funkcji, przy czym indeks pierwszego z nich ma wartość 0. Na przykład, jeśli do funkcji przekazane są trzy argumenty, można się do nich odwołać w następujący sposób:
+</p>
+<pre class="eval">arguments[0]
+arguments[1]
+arguments[2]
+</pre>
+<p>Argumentom mogą być również przypisywane wartości:
+</p>
+<pre class="eval">arguments[1] = 'nowa wartosc';
+</pre>
+<div class="note"><b>Uwaga:</b> silnik JavaScript <a href="pl/SpiderMonkey">SpiderMonkey</a> posiada <a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=292215">bug</a>, w którym nie można do <code>arguments{{ mediawiki.external('n') }}</code> przypisać wartości, jeśli <code>n</code> jest większe niż liczba formalnych lub rzeczywistych parametrów.
+Błąd ten został usunięty w silniku JavaScript 1.6.</div>
+<p>Obiekt <code>arguments</code> nie jest tablicą. Jest do niej podobny, lecz nie posiada żadnej z własności tablicy poza <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">length</a></code>. Przykładowo nie posiada on metody <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/pop">pop</a></code>. Może być on jednak skonwertowany do prawdziwej tablicy:
+</p>
+<pre class="eval"> var args = Array.prototype.slice.call(arguments);
+</pre>
+<p>Obiekt <code>arguments</code> dostępny jest wyłącznie wewnątrz ciała funkcji. Próba dostępu do obiektu <code>arguments</code> spoza części deklaracyjnej funkcji zakończy się błędem.
+</p><p>Możesz użyć obiektu <code>arguments</code>, jeśli funkcja wywołana jest z większą liczbą argumentów niż zostało to zadeklarowane. Jest to użyteczne dla funkcji, które wywoływać można ze zmienną liczbą argumentów.
+Aby określić liczbę argumentów przekazywanych do funkcji można użyć własności
+<code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">arguments.length</a></code>, a następnie skorzystać z każdego z argumentów używając obiektu <code>arguments</code> (aby określić liczbę argumentów zadeklarowanych podczas definiowania funkcji, skorzystać można z własności <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/length">Function.length</a></code>).
+</p>
+<h3 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci"> Własności </h3>
+<dl><dt> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/callee">arguments.callee</a></code></dt><dd> Określa ciało funkcji aktualnie wykonywanej funkcji.
+</dd></dl>
+<dl><dt> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/caller">arguments.caller</a></code> {{ Deprecated_inline() }}</dt><dd> Określa nazwę funkcji, która wywołała aktualnie wykonywaną funkcję.
+</dd></dl>
+<dl><dt> <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments/length">arguments.length</a></code></dt><dd> Określa liczbę argumentów przekazywanych do funkcji.
+</dd></dl>
+<h3 id="Zgodno.C5.9B.C4.87_wsteczna" name="Zgodno.C5.9B.C4.87_wsteczna"> Zgodność wsteczna </h3>
+<h4 id="JavaScript_1.3_i_wcze.C5.9Bniejsze_wersje" name="JavaScript_1.3_i_wcze.C5.9Bniejsze_wersje"> JavaScript 1.3 i wcześniejsze wersje </h4>
+<p>Oprócz dostępności jako zmienna lokalna, obiekt <code>arguments</code> jest również własnością obiektu <code>Function</code> i może być poprzedzony nazwą funkcji. Na przykład, jeżeli do funkcji <code>myFunc</code> są przekazywane trzy argumenty o nazwie <code>arg1</code>, <code>arg2</code>, i <code>arg3</code>, można odwołać się do tych argumentów następująco:
+</p>
+<pre class="eval">myFunc.arguments[0]
+myFunc.arguments[1]
+myFunc.arguments[2]
+</pre>
+<h4 id="JavaScript_1.1_i_1.2" name="JavaScript_1.1_i_1.2"> JavaScript 1.1 i 1.2 </h4>
+<p>Następujące cechy dostępne w JavaScripcie 1.1 i JavaScripcie 1.2 zostały usunięte:
+</p>
+<ul><li> Każda zmienna lokalna funkcji jest własnością obiektu <code>arguments</code>. Na przykład, jeśli funkcja <code>myFunc</code> posiada zmienną lokalną nazwaną <code>myLocalVar</code>, możesz odwołać się do zmiennej jako <code>arguments.myLocalVar</code>.
+</li></ul>
+<ul><li> Każdy argument formalny funkcji jest własnością obiektu <code>arguments</code>. Na przykład, jeżeli funkcja <code>myFunc</code> posiada dwa argumenty o nazwie <code>arg1</code> i <code>arg2</code>, możesz odwołać się do nich jako <code>arguments.arg1</code> i <code>arguments.arg2</code> (możesz także odwołać się do tych argumentów poprzez <code>arguments{{ mediawiki.external(0) }}</code> i <code>arguments{{ mediawiki.external(1) }}</code>).
+</li></ul>
+<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3>
+<h4 id="Przyk.C5.82ad:_Definiowanie_funkcji_.C5.82.C4.85cz.C4.85cej_.C5.82a.C5.84cuchy_znak.C3.B3w" name="Przyk.C5.82ad:_Definiowanie_funkcji_.C5.82.C4.85cz.C4.85cej_.C5.82a.C5.84cuchy_znak.C3.B3w"> Przykład: Definiowanie funkcji łączącej łańcuchy znaków </h4>
+<p>Ten przykład definiuje funkcję łączącą kilka łańcuchów znaków. Jedynym formalnym argumentem tej funkcji jest łańcuch znaków, który określa znaki oddzielające poszczególne łączone elementy. Funkcja jest zdefiniowana następująco:
+</p>
+<pre class="eval">function myConcat(separator) {
+   result = ""; // inicjalizacja listy
+   // iteracja pomiędzy argumentami
+   for (var i = 1; i &lt; arguments.length; i++) {
+      result += arguments[i] + separator;
+   }
+   return result;
+}
+</pre>
+<p>Możesz przesłać dowolną liczbę argumentów do tej funkcji, tworząc na ich bazie listę.
+</p>
+<pre class="eval">// zwraca "czerwony, pomaranczowy, niebieski, "
+myConcat(", ", "czerwony", "pomaranczowy", "niebieski");
+
+// zwraca "slon; zyrafa; lew; gepard; "
+myConcat("; ", "slon", "zyrafa", "lew", "gepard");
+
+// zwraca "szalwia. bazylia. oregano. pieprz. pietruszka. "
+myConcat(". ", "szalwia", "bazylia", "oregano", "pieprz", "pietruszka");
+</pre>
+<h4 id="Przyk.C5.82ad:_Definiowanie_funkcji.2C_kt.C3.B3ra_tworzy_list.C4.99_HTML" name="Przyk.C5.82ad:_Definiowanie_funkcji.2C_kt.C3.B3ra_tworzy_list.C4.99_HTML"> Przykład: Definiowanie funkcji, która tworzy listę HTML </h4>
+<p>Ten przykład definiuje funkcję, która tworzy łańcuch znaków reprezentujący kod HTML listy. Jedynym argumentem formalnym tej funkcji jest ciąg znaków, który przyjmuje wartość "<code>u</code>" dla listy nieuporządkowanej, lub "<code>o</code>" w przypadku listy uporządkowanej. Funkcja ta jest zdefiniowana następująco:
+</p>
+<pre>function list(type) {
+  var result = "&lt;" + type + "l&gt;";
+
+  // iteracja pomiędzy argumentami
+  for (var i = 1; i &lt; arguments.length; i++)
+    result += "&lt;li&gt;" + arguments[i] + "&lt;/li&gt;";
+
+  result += "&lt;/" + type + "l&gt;"; // koniec listy
+
+  return result;
+}
+</pre>
+<p>Możesz przekazać funkcji dowolną liczbę argumentów, a ona doda każdy z nich jako kolejną pozycję na liście o wskazanym typie. Przykładowo następujące wywołanie funkcji:
+</p>
+<pre>var listHTML = list("u", "Raz", "Dwa", "Trzy");
+// listHTML zawiera łańcuch "&lt;ul&gt;&lt;li&gt;Raz&lt;/li&gt;&lt;li&gt;Dwa&lt;/li&gt;&lt;li&gt;Trzy&lt;/li&gt;&lt;/ul&gt;"
+</pre>
+<p><br>
+</p><p><br>
+</p>
+<div class="noinclude">
+</div>
+{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments", "es": "es/Referencia_de_JavaScript_1.5/Funciones/arguments", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments" } ) }}
diff --git a/files/pl/web/javascript/reference/functions/arguments/length/index.html b/files/pl/web/javascript/reference/functions/arguments/length/index.html
new file mode 100644
index 0000000000..fe871fa77e
--- /dev/null
+++ b/files/pl/web/javascript/reference/functions/arguments/length/index.html
@@ -0,0 +1,60 @@
+---
+title: length
+slug: Web/JavaScript/Reference/Functions/arguments/length
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Functions/arguments/length
+original_slug: Web/JavaScript/Referencje/Funkcje/arguments/length
+---
+<p>
+</p>
+<h3 id="Podsumowanie" name="Podsumowanie"> Podsumowanie </h3>
+<p>Określa liczbę argumentów przekazywanych do funkcji.
+</p>
+<table class="fullwidth-table">
+<tbody><tr>
+<td class="header" colspan="2">Własność obiektów <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments">arguments</a> i <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/arguments">Function.arguments</a> (wycofywana)</td>
+</tr>
+<tr>
+<td>Zaimplementowana w:</td>
+<td>JavaScript 1.1
+<p>JavaScript 1.4: Przenaczono do wycofania <code>length</code> jako własność <code>Function.arguments</code>, zachowano ją natomiast jako własność zmiennej lokalnej <code>arguments</code> funkcji.
+</p>
+</td>
+</tr>
+<tr>
+<td>Wersja ECMA:</td>
+<td>ECMA-262</td>
+</tr>
+</tbody></table>
+<h3 id="Opis" name="Opis"> Opis </h3>
+<p><code>length</code> jest własnością zmiennej lokalnej <code>arguments</code> dostępnej wewnątrz wszystkich obiektów funkcji; <code>length</code> jako własność <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/arguments">Function.arguments</a></code> nie jest już używana (również sam obiekt <code>Function.arguments</code> jest wycofywany).
+</p><p><code>arguments.length</code> dostarcza liczbę argumentów przekazywanych obecnie funkcji. Dla porównania, własność <code>Function.length</code> wskazuje ilość argumentów oczekiwanych przez funkcję.
+</p>
+<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady"> Przykłady </h3>
+<h4 id="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length" name="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length"> Przykład: Zastosowanie <code>Function.length</code> i <code>arguments.length</code> </h4>
+<p>Następujący przykład przedstawia zastosowanie <code>Function.length</code> i <code>arguments.length</code>.
+</p>
+<pre>function addNumbers(x,y){
+   if (arguments.length == addNumbers.length) {
+      return (x+y)
+   }
+   else return 0
+}
+</pre>
+<p>Jeśli podano więcej niż dwa argumenty funkcji, zostanie zwrócona wartość 0:
+</p>
+<pre>result=addNumbers(3,4,5)   // zwraca 0
+result=addNumbers(3,4)     // zwraca 7
+result=addNumbers(103,104) // zwraca 207
+</pre>
+<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe"> Zobacz także </h3>
+<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function/length">Function.length</a></code>
+</p><p><br>
+</p>
+<div class="noinclude">
+</div>
+{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments/length", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments/length", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments/length" } ) }}
diff --git a/files/pl/web/javascript/reference/functions/funkcje_strzalkowe/index.html b/files/pl/web/javascript/reference/functions/arrow_functions/index.html
index d1b9d6010f..da3259ac37 100644
--- a/files/pl/web/javascript/reference/functions/funkcje_strzalkowe/index.html
+++ b/files/pl/web/javascript/reference/functions/arrow_functions/index.html
@@ -1,7 +1,8 @@
 ---
 title: Funkcje strzałkowe
-slug: Web/JavaScript/Reference/Functions/Funkcje_strzalkowe
+slug: Web/JavaScript/Reference/Functions/Arrow_functions
 translation_of: Web/JavaScript/Reference/Functions/Arrow_functions
+original_slug: Web/JavaScript/Reference/Functions/Funkcje_strzalkowe
 ---
 <div>{{jsSidebar("Functions")}}</div>
 
diff --git a/files/pl/web/javascript/reference/functions/parametry_domyślne/index.html b/files/pl/web/javascript/reference/functions/default_parameters/index.html
index b192456adf..a0bc76eb74 100644
--- a/files/pl/web/javascript/reference/functions/parametry_domyślne/index.html
+++ b/files/pl/web/javascript/reference/functions/default_parameters/index.html
@@ -1,11 +1,12 @@
 ---
 title: Parametry domyślne
-slug: Web/JavaScript/Reference/Functions/Parametry_domyślne
+slug: Web/JavaScript/Reference/Functions/Default_parameters
 tags:
   - ECMAScript2015
   - Funkcje
   - JavaScript
 translation_of: Web/JavaScript/Reference/Functions/Default_parameters
+original_slug: Web/JavaScript/Reference/Functions/Parametry_domyślne
 ---
 <div>{{jsSidebar("Functions")}}</div>
 
diff --git a/files/pl/web/javascript/reference/global_objects/array/concat/index.html b/files/pl/web/javascript/reference/global_objects/array/concat/index.html
new file mode 100644
index 0000000000..f740400903
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/concat/index.html
@@ -0,0 +1,72 @@
+---
+title: Array.prototype.concat()
+slug: Web/JavaScript/Reference/Global_Objects/Array/concat
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/concat
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca nową tablicę złożoną z tablicy, na której wywołano tę metodę, połączonej z innymi podanymi tablicami lub wartościami.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>var <var>new_array</var> = <var>old_array</var>.concat(wartość1[, wartość2[, ...[, wartośćN]]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>wartość
+ <i>N</i>
+ </code> </dt>
+ <dd>Tablice lub wartości do dołączenia do tablicy, na której wywołana została metoda <code>concat</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>concat</code> nie zmienia oryginalnej tablicy, lecz zwraca jej kopię "o jednym poziomie głębokości" zawierającą te same elementy wspólne co pierwotna tablica. Elementy oryginalnej tablicy są kopiowane do nowej tablicy następująco:</p>
+
+<ul>
+ <li>referencje do obiektów (a nie faktyczne obiekty): <code>concat</code> kopiuje referencje do obiektów do nowej tablicy. Zarówno pierwotna, jak i nowa tablica odnoszą się więc do tych samych obiektów. Oznacza to, że jeżeli wskazany obiekt jest modyfikowany, zmiany są widoczne w obydwu tablicach (nowej i starej).</li>
+</ul>
+
+<ul>
+ <li>Łańcuchy znaków i liczby (ale nie obiekty {{jsxref("String")}} i {{jsxref("Number")}} ): <code>concat</code> kopiuje wartości łańcuchów znaków i liczb do nowej tablicy.</li>
+</ul>
+
+<p>Operacje wykonywane na nowej tablicy nie wpłyną w żaden sposób na oryginalną tablicę i na odwrót.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_dw.C3.B3ch_tablic" name="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_dw.C3.B3ch_tablic">Przykład: Połączenie dwóch tablic</h3>
+
+<p>Następujący kod łączy dwie tablice:</p>
+
+<pre class="brush: js">alpha = new Array("a", "b", "c");
+numeric = new Array(1, 2, 3);
+alphaNumeric = alpha.concat(numeric); // tworzy tablicę ["a", "b", "c", 1, 2, 3]
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_trzech_tablic" name="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_trzech_tablic">Przykład: Połączenie trzech tablic</h3>
+
+<p>Następujący kod łączy trzy tablice:</p>
+
+<pre class="brush: js">num1 = [1, 2, 3];
+num2 = [4, 5, 6];
+num3 = [7, 8, 9];
+nums = num1.concat(num2,num3) // tworzy tablicę [1, 2, 3, 4, 5, 6, 7, 8, 9]
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_warto.C5.9Bci_z_tablic.C4.85" name="Przyk.C5.82ad:_Po.C5.82.C4.85czenie_warto.C5.9Bci_z_tablic.C4.85">Przykład: Połączenie wartości z tablicą</h3>
+
+<p>Następujący kod łączy trzy wartości z tablicą:</p>
+
+<pre class="brush: js">alpha = ['a', 'b', 'c'];
+alphaNumeric = alpha.concat(1, 2, 3); // tworzy tablicę ["a", "b", "c", 1, 2, 3]
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/array/copywithin/index.html b/files/pl/web/javascript/reference/global_objects/array/copywithin/index.html
new file mode 100644
index 0000000000..af9f1b91f7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/copywithin/index.html
@@ -0,0 +1,182 @@
+---
+title: Array.prototype.copyWithin()
+slug: Web/JavaScript/Reference/Global_Objects/Array/copyWithin
+tags:
+  - Array
+  - ECMAScript 2015
+  - JavaScript
+  - Metodă
+  - Peototyp
+  - Prototype
+  - Reference
+  - Referencja
+  - Tablica
+  - polyfill
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/copyWithin
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>copyWithin()</strong></code> tworzy kopie płytkie części tablicy w innej części tej samej tablicy i zwraca tę tablicę bez modyfikowania jej długości.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/array-copywithin.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate"><var>arr</var>.copyWithin(<var>cel[, start[, koniec]]</var>)
+</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>cel</code></dt>
+ <dd>Indeks (liczony od zera), do którego ma zostać skopiowana sekwencja. Jeśli wartość <code>target</code> będzie ujemna, pozycja będzie liczona od końca tablicy.</dd>
+ <dd>Jeśli <code>cel</code> jest większy lub równy <code>arr.length</code>, nic nie zostanie skopiowane. Jeśli wartość <code>cel</code> będzie większa niż <code>start</code>, kopiowana sekwencja zostanie przycięta tak, aby pasować do <code>arr.length</code>.</dd>
+ <dt><code>start</code> {{optional_inline}}</dt>
+ <dd>Indeks (liczony od zera), określający pozycję początkową sekwencji, która ma zostać skopiowana. Jeśli wartość ta będzie ujemna, <code>start</code> będzie liczony od końca tablicy.</dd>
+ <dd>Jeśli wartość <code>start</code> nie jest podana, <code>copyWithin</code> skopiuje sekwencję zaczynając od indeksu <code>0</code>. </dd>
+ <dt><code>koniec</code> {{optional_inline}}</dt>
+ <dd>Indeks (liczony od zera), określający pozycję końcową sekwencji, która ma zostać skopiowana, z wyłączeniem wartości pod indeksem <code>koniec</code>. Jeśli wartość ta będzie ujemna, <code>koniec</code> będzie liczony od końca tablicy.</dd>
+ <dd>Jeśli wartość <code>koniec</code> nie jest podana, <code>copyWithin</code> skopiuje sekwencję do ostatniego indeksu (domyślnie do <code>arr.length</code>).</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Zmodyfikowana tablica.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Metoda <code>copyWithin</code> działa jak <code>memmove</code> w C/C++ i jest wysokowydajną metodą przesuwania wartości w obiektach {{jsxref("Array")}}. Dotyczy to szczególnie metody o tej samej nazwie {{jsxref("TypedArray/copyWithin", "TypedArray")}}. Sekwencja jest kopiowana i wklejana w jednej operacji, a wklejona sekwencja będzie zawierać skopiowane wartości nawet wtedy, gdy zakres żródłowy (kopiowania) i docelowy (wklejania) nakładają się na siebie.</p>
+
+<p>Funkcja <code>copyWithin</code> jest celowo <em>ogólna</em>, nie wymaga, by jej wartość <code>this</code> była obiektem typu {{jsxref("Array")}}.</p>
+
+<p>Metoda <code>copyWithin</code> jest modyfikowalna. Nie zmienia długości <code>this</code>, ale zmienia zawartość <code>this</code> i tworzy nowe własności, jeśli jest to konieczne.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js notranslate">if (!Array.prototype.copyWithin) {
+  Object.defineProperty(Array.prototype, 'copyWithin', {
+    value: function(target, start/*, end*/) {
+    // Kroki 1-2.
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+
+    var O = Object(this);
+
+    // Kroki 3-5.
+    var len = O.length &gt;&gt;&gt; 0;
+
+    // Kroki 6-8.
+    var relativeTarget = target &gt;&gt; 0;
+
+    var to = relativeTarget &lt; 0 ?
+      Math.max(len + relativeTarget, 0) :
+      Math.min(relativeTarget, len);
+
+    // Kroki 9-11.
+    var relativeStart = start &gt;&gt; 0;
+
+    var from = relativeStart &lt; 0 ?
+      Math.max(len + relativeStart, 0) :
+      Math.min(relativeStart, len);
+
+    // Kroki 12-14.
+    var end = arguments[2];
+    var relativeEnd = end === undefined ? len : end &gt;&gt; 0;
+
+    var final = relativeEnd &lt; 0 ?
+      Math.max(len + relativeEnd, 0) :
+      Math.min(relativeEnd, len);
+
+    // Krok 15.
+    var count = Math.min(final - from, len - to);
+
+    // Kroki 16-17.
+    var direction = 1;
+
+    if (from &lt; to &amp;&amp; to &lt; (from + count)) {
+      direction = -1;
+      from += count - 1;
+      to += count - 1;
+    }
+
+    // Krok 18.
+    while (count &gt; 0) {
+      if (from in O) {
+        O[to] = O[from];
+      } else {
+        delete O[to];
+      }
+
+      from += direction;
+      to += direction;
+      count--;
+    }
+
+    // Krok 19.
+    return O;
+  },
+  configurable: true,
+  writable: true
+  });
+}</pre>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_copyWithin">Użycie copyWithin</h3>
+
+<pre class="brush: js notranslate">[1, 2, 3, 4, 5].copyWithin(-2)
+// [1, 2, 3, 1, 2]
+
+[1, 2, 3, 4, 5].copyWithin(0, 3)
+// [4, 5, 3, 4, 5]
+
+[1, 2, 3, 4, 5].copyWithin(0, 3, 4)
+// [4, 2, 3, 4, 5]
+
+[1, 2, 3, 4, 5].copyWithin(-2, -3, -1)
+// [1, 2, 3, 3, 4]
+
+[].copyWithin.call({długość: 5, 3: 1}, 0, 3)
+// {0: 1, 3: 1, długość: 5}
+
+// ES2015 Typowane tablice są podklasami zwykłej tablicy (Array)
+var i32a = new Int32Array([1, 2, 3, 4, 5])
+
+i32a.copyWithin(0, 2)
+// Int32Array [3, 4, 5, 4, 5]
+
+// Na platformach niewspierających jeszcze ES 2015:
+[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
+// Int32Array [4, 2, 3, 4, 5]
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Array.copyWithin")}}</p>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/entries/index.html b/files/pl/web/javascript/reference/global_objects/array/entries/index.html
new file mode 100644
index 0000000000..f5c7a6d596
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/entries/index.html
@@ -0,0 +1,78 @@
+---
+title: Array.prototype.entries()
+slug: Web/JavaScript/Reference/Global_Objects/Array/entries
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/entries
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>entries()</strong></code> zwraca obiekt <code><strong>Iteratora</strong></code> który zawiera parę klucz/wartość dla każdej pozycji w tablicy.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/array-entries.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><var>a</var>.entries()</pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Nowy iterator {{jsxref("Tablicy")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_w_pętli_for…of">Użycie w pętli <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for…of</a></h3>
+
+<pre class="brush:js">var a = ['a', 'b', 'c'];
+var iterator = a.entries();
+
+for (let e of iterator) {
+  console.log(e);
+}
+// [0, 'a']
+// [1, 'b']
+// [2, 'c']
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_w_przeglądarkach">Kompatybilność w przeglądarkach</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Array.entries")}}</p>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.keys()")}}</li>
+ <li>{{jsxref("Array.prototype.values()")}}</li>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+ <li>{{jsxref("Array.prototype.some()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/every/index.html b/files/pl/web/javascript/reference/global_objects/array/every/index.html
new file mode 100644
index 0000000000..707e7bda84
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/every/index.html
@@ -0,0 +1,90 @@
+---
+title: Array.prototype.every()
+slug: Web/JavaScript/Reference/Global_Objects/Array/every
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/every
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Metoda <span style="line-height: 23.3333339691162px;"> </span><code style="font-style: normal; line-height: 23.3333339691162px;"><strong>every() </strong></code>sprawdza, czy wszystkie elementy w tablicy przechodzą test zrealizowany w postaci dostarczonej funkcji.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.every(<var>callback</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Funkcja sprawdzająca dla każdego elementu. Zawiera trzy argumenty.<br>
+ <strong style="font-family: consolas,monaco,andale mono,monospace; font-weight: bold; line-height: 23.3333339691162px;">currentValue<br>
+   </strong>Bieżący element przetwarzany w tablicy</dd>
+ <dt>       <strong style="font-family: consolas,monaco,andale mono,monospace; font-weight: bold; line-height: 23.3333339691162px;">index</strong></dt>
+ <dd>
+ <p>     Indeks bieżacego elementu przetwarzanego w tablicy</p>
+
+ <p> <strong>array</strong><br>
+      Tablica na której została wywołana funkcja</p>
+ </dd>
+ <dt><code>thisObject</code></dt>
+ <dd>Opcjonalnie. Obiekt, na który będzie wskazywał <code>this</code>, gdy wykonana zostanie funkcja zwrotna <code>callback</code>. </dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>every</code> wykonuje dostarczoną funkcję <code>callback</code> raz dla każdego elementu tablicy do momentu, kiedy znajdzie taki element, dla którego funkcja <code>callback</code> zwróci wartość <code>false</code>. Jeżeli taki element zostanie znaleziony, test zostanie przerwany, a metoda <code>every</code> zwróci wartość <code>false</code>. W przeciwnym wypadku (<code>callback</code> zwraca wartość <code>true</code> dla wszystkich elementów) <code>every</code> zwróci <code>true</code>. Funkcja <code>callback</code> wywoływana jest jedynie dla indeksów tablicy, którym została przypisana wartość; nie jest wywoływana dla indeksów, które zostały usunięte i tych, którym nigdy nie została przypisana żadna wartość.</p>
+
+<p>Funkcja <code>callback</code> jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.</p>
+
+<p>Jeśli parametr <code>thisObject</code> został dostarczony do metody <code>every</code>, będzie on wskazywany przez <code>this</code> dla każdego wywołania funkcji <code>callback</code>. W przypadku, gdy nie został on przekazany lub jego wartość jest równa <code>null</code>, <code>this</code> będzie się odnosić do obiektu globalnego połączonego z funkcją <code>callback</code>.</p>
+
+<p>Metoda <code>every</code> nie modyfikuje tablicy, na której jest wywoływana.</p>
+
+<p>Zakres elementów przetwarzanych przez <code>every</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy dołączone do tablicy po momencie wywołania <code>every</code> są testowane przez <code>callback</code>. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji <code>callback</code> odpowiada wartości w momencie, w którym <code>every</code> się o nie zwróci; metoda <code>every</code> nie upomina się o elementy usunięte.</p>
+
+<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3>
+
+<p><code>every</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>every</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p>
+
+<pre class="brush: js">if (!Array.prototype.every)
+{
+  Array.prototype.every = function(fun /*, thisp*/)
+  {
+    var len = this.length;
+    if (typeof fun != "function")
+      throw new TypeError();
+
+    var thisp = arguments[1];
+    for (var i = 0; i &lt; len; i++)
+    {
+      if (i in this &amp;&amp;
+          !fun.call(thisp, this[i], i, this))
+        return false;
+    }
+
+    return true;
+  };
+}
+</pre>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy">Przykład: Sprawdzanie rozmiaru wszystkich elementów tablicy</h3>
+
+<p>Następujący przykład sprawdza, czy wszystkie elementy w tablicy są większe niż 10.</p>
+
+<pre class="brush: js">function isBigEnough(element, index, array) {
+  return (element &gt;= 10);
+}
+passed = [12, 5, 8, 130, 44].every(isBigEnough);
+// fałsz
+passed = [12, 54, 18, 130, 44].every(isBigEnough);
+// prawda
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/array/fill/index.html b/files/pl/web/javascript/reference/global_objects/array/fill/index.html
new file mode 100644
index 0000000000..1251451837
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/fill/index.html
@@ -0,0 +1,186 @@
+---
+title: Array.prototype.fill()
+slug: Web/JavaScript/Reference/Global_Objects/Array/fill
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/fill
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>fill() </strong>uzupełnia wszystkie elementy tablicy, zaczynając od indeksu początkowego</code>  <strong>(start)</strong> aż po indeks końcowy <strong>(end)</strong> statyczną wartością <strong>(value)</strong>.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/array-fill.html")}}<br>
+ Źródło tego przykładu jest przechowywane w repozytorium na GitHub. Jeśli chciałbyś dodać coś od siebie do projektu interaktywnych przykładów, sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a>  i wyślij pull request.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.fill(<var>value</var>[, <var>start<var> = 0[, <var>end</var> = this.length]])</var></var></code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>Wartość, którą wypełniana będzie tablica.</dd>
+ <dt><code>start</code></dt>
+ <dd>Opcjonalnie. Indeks początkowy.</dd>
+ <dt><code>end</code></dt>
+ <dd>Opcjonalnie. Indeks końcowy.</dd>
+ <dt>
+ <h3 id="Wartość_zwracana">Wartość zwracana</h3>
+
+ <p>Zmodyfikowana tablica.</p>
+ </dt>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Przedział elementów do wypełnienia to: [<code>start</code>, <code>end</code>).</p>
+
+<p><code>Metoda</code><strong><code> fill</code></strong> przyjmuje do trzech parametrów <code>value</code>, <code>start</code> i <code>end</code>. Argumenty <code>start i</code> <code>end</code> są opcjonalne i przyjmują, odpowiednio,  <code>0</code> i długość (<code>length)</code> obiektu <code>this</code>.</p>
+
+<p>Jeżeli parametr <code>start</code> jest ujemny, jest to traktowane jako <code>length+start</code> gdzie <code>length</code> jest liczbą elementów tablicy. Jeżeli parametr <code>end</code> jest negatywny, jest to traktowane jako <code>length+end</code>. </p>
+
+<p>Funkcja<strong> fill</strong> została świdomie zaprojektowana jako generyczna, przez co nie wymaga, by wartość <font face="Consolas, Liberation Mono, Courier, monospace">this</font> była obiektem typu Array.</p>
+
+<p>Metoda<strong> fill </strong>jest zmienna (ang. mutalbe), metoda ta nie zwraca kopii this, a oryginalny obiekt po modyfikacjach.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<pre class="brush: js">[1, 2, 3].fill(4);               // [4, 4, 4]
+[1, 2, 3].fill(4, 1);            // [1, 4, 4]
+[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
+[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
+[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
+[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
+[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}
+//Obiekty przez referencję
+var arr = Array(3).fill({}) // [{}, {}, {}];
+arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
+</pre>
+
+<p> </p>
+
+<p> </p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">if (!Array.prototype.fill) {
+  Array.prototype.fill = function(value) {
+
+    // Steps 1-2.
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+
+    var O = Object(this);
+
+    // Steps 3-5.
+    var len = O.length &gt;&gt;&gt; 0;
+
+    // Steps 6-7.
+    var start = arguments[1];
+    var relativeStart = start &gt;&gt; 0;
+
+    // Step 8.
+    var k = relativeStart &lt; 0 ?
+      Math.max(len + relativeStart, 0) :
+      Math.min(relativeStart, len);
+
+    // Steps 9-10.
+    var end = arguments[2];
+    var relativeEnd = end === undefined ?
+      len : end &gt;&gt; 0;
+
+    // Step 11.
+    var final = relativeEnd &lt; 0 ?
+      Math.max(len + relativeEnd, 0) :
+      Math.min(relativeEnd, len);
+
+    // Step 12.
+    while (k &lt; final) {
+      O[k] = value;
+      k++;
+    }
+
+    // Step 13.
+    return O;
+  };
+}
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.fill', 'Array.prototype.fill')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definicja początkowa</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funckjonalność</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Wsparcie podstawowe</td>
+   <td>{{CompatChrome("36")}} [1]</td>
+   <td>{{CompatGeckoDesktop("31")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatSafari("7.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Wsparcie podstawowe</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("31")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8.0</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] The feature is available behind a preference. In chrome://flags, activate the entry “Enable Experimental JavaScript”.</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+ <li>{{jsxref("TypedArray.prototype.fill()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/filter/index.html b/files/pl/web/javascript/reference/global_objects/array/filter/index.html
new file mode 100644
index 0000000000..6ec5d0cdc5
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/filter/index.html
@@ -0,0 +1,151 @@
+---
+title: Array.prototype.filter()
+slug: Web/JavaScript/Reference/Global_Objects/Array/filter
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/filter
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong>filter()</strong> tworzy nową tablicę z wszystkimi elementami, które przechodzą test określony w postaci funkcji.</p>
+
+<pre class="brush: js">function isBigEnough(value) {
+  return value &gt;= 10;
+}
+
+var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+// filtered is [12, 130, 44]
+</pre>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre><var>var newArray = arr</var>.filter(<var>callback(element[, index[, array]])</var>[, <var>thisArg</var>])</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Funkcja sprawdzająca każdy element tablicy. Funkcja powinna zwrócić <code>true,</code> aby zatrzymać element lub <code>false,</code> aby odrzucić element. Funkcja przyjmuje trzy argumenty:</dd>
+ <dd>
+ <dl>
+  <dt><code>element</code></dt>
+  <dd>Element tablicy do przetworzenia.</dd>
+  <dt><code>index</code></dt>
+  <dd>Numer indeksu procesowanego elementu tablicy.</dd>
+  <dt><code>array</code></dt>
+  <dd>Tablica na której <code>filter</code> został wywołany.</dd>
+ </dl>
+ </dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Obiekt na który będzie wskazywał <code>this</code>, przy wywoływaniu funkcji <code>callback</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>filter</code> wykonuje dostarczoną funkcję <code>callback</code> dla każdego elementu tablicy, tworząc nową tablicę z wszystkich tych elementów, dla których funkcja <code>callback</code> zwróciła wartość <code>true</code>. Wynikowa tablica jest zwarta; wartości, które nie przechodzą testu funkcji <code>callback,</code> są zwyczajnie pomijane i nie są przypisywane do indeksów nowej tablicy.</p>
+
+<p>Funkcja <code>callback</code> jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.</p>
+
+<p>Jeśli parametr <code>thisObject</code> został dostarczony do metody <code>filter</code>, będzie on wskazywany przez <code>this</code> dla każdego wywołania funkcji<code>callback</code>. W przypadku gdy nie został on przekazany lub jego wartość jest równa <code>null</code>, <code>this</code> będzie się odnosić do obiektu globalnego połączonego z funkcją <code>callback</code>.</p>
+
+<p>Metoda <code>filter</code> nie modyfikuje tablicy, na której jest wywoływana.</p>
+
+<p>Zakres elementów przetwarzanych przez <code>filter</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy dołączone do tablicy po momencie wywołania <code>filter</code> są testowane przez <code>callback</code>. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji <code>callback</code> odpowiada wartości w momencie, w którym <code>filter</code> się o nie zwróci; metoda <code>filter</code> nie upomina się o elementy usunięte.</p>
+
+<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3>
+
+<p><code>filter</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>filter</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p>
+
+<pre class="brush: js">if (!Array.prototype.filter)
+{
+  Array.prototype.filter = function(fun /*, thisp*/)
+  {
+    var len = this.length;
+    if (typeof fun != "function")
+      throw new TypeError();
+
+    var res = new Array();
+    var thisp = arguments[1];
+    for (var i = 0; i &lt; len; i++)
+    {
+      if (i in this)
+      {
+        var val = this[i]; // in case fun mutates this
+        if (fun.call(thisp, val, i, this))
+          res.push(val);
+      }
+    }
+
+    return res;
+  };
+}
+</pre>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Odfiltrowanie_wszystkich_ma.C5.82ych_warto.C5.9Bci" name="Przyk.C5.82ad:_Odfiltrowanie_wszystkich_ma.C5.82ych_warto.C5.9Bci">Przykład: Odfiltrowanie wszystkich małych wartości</h3>
+
+<p>Poniższy przykład używa <code>filter</code> by utworzyć przefiltrowaną tablicę, z której usunięto wszystkie elementy których wartość wynosi mniej niż 10.</p>
+
+<pre class="brush: js">function isBigEnough(element, index, array) {
+  return (element &gt;= 10);
+}
+filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+</pre>
+
+<h2 id="Kompatybilność_z_przeglądarkami" style="margin-bottom: 20px; font-size: 2.14285714285714rem;">Kompatybilność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table" style="border-color: transparent;">
+ <tbody>
+  <tr>
+   <th style="line-height: 16px;">Feature</th>
+   <th style="line-height: 16px;">Chrome</th>
+   <th style="line-height: 16px;">Firefox (Gecko)</th>
+   <th style="line-height: 16px;">Internet Explorer</th>
+   <th style="line-height: 16px;">Opera</th>
+   <th style="line-height: 16px;">Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("1.8")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table" style="border-color: transparent;">
+ <tbody>
+  <tr>
+   <th style="line-height: 16px;">Feature</th>
+   <th style="line-height: 16px;">Android</th>
+   <th style="line-height: 16px;">Chrome for Android</th>
+   <th style="line-height: 16px;">Firefox Mobile (Gecko)</th>
+   <th style="line-height: 16px;">IE Mobile</th>
+   <th style="line-height: 16px;">Opera Mobile</th>
+   <th style="line-height: 16px;">Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("1.8")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
diff --git a/files/pl/web/javascript/reference/global_objects/array/find/index.html b/files/pl/web/javascript/reference/global_objects/array/find/index.html
new file mode 100644
index 0000000000..520be8939f
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/find/index.html
@@ -0,0 +1,279 @@
+---
+title: Array.prototype.find()
+slug: Web/JavaScript/Reference/Global_Objects/Array/find
+tags:
+  - Array
+  - ECMAScript 2015
+  - JavaScript
+  - Metodă
+  - Prototype
+  - Referencja
+  - Tablica
+  - polyfill
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/find
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/find
+---
+<p>{{JSRef}}<br>
+ Metoda <strong>find()</strong> zwraca pierwszy element tablicy, który spełnia warunek podanej funkcji testującej.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/array-find.html","shorter")}}</div>
+
+
+
+<ul>
+ <li>Jeśli potrzebujesz <strong>indeksu</strong> znalezionego elementu w tablicy, użyj {{jsxref("Array.findIndex", "findIndex()")}}.</li>
+ <li>Jesli potrzebujesz <strong>indeksu wartości</strong>, użyj {{jsxref("Array.prototype.indexOf()")}}. (Jest to podobne do {{jsxref("Array.findIndex", "findIndex()")}}, ale sprawdza każdy element tablicy pod kątem równości z zadaną wartością, zamiast używać funkcji testującej.)</li>
+ <li>Jeśli chcesz sprawdzić, czy wartość <strong>istnieje</strong> w tablicy, użyj {{jsxref("Array.prototype.includes()")}}. Tutaj także sprawdzana jest równość elementu z zadaną wartością zamiast używania funkcji testującej.</li>
+ <li>Jeśli chcesz znaleźć dowolny element, który spełnia warunek funkcji testującej, użyj {{jsxref("Array.prototype.some()")}}.</li>
+</ul>
+
+<h2 id="Syntax" name="Syntax">Składnia</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.find(<var>callback</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parametry</h3>
+
+<dl>
+ <dt><em><code>callback</code></em></dt>
+ <dd>Funkcja do wykonania przy każdym elemencie tablicy, przyjmująca trzy wartości:
+ <dl>
+  <dt><em><code>element</code></em></dt>
+  <dd>Element obecnie przetwarzany przez funkcję.</dd>
+  <dt><em><code>index</code></em></dt>
+  <dd>Indeks obecnie przetwarzanego elementu.</dd>
+  <dt><em><code>array</code></em></dt>
+  <dd>Tablica, na której wywołano funkcję <code>find</code>.</dd>
+ </dl>
+ </dd>
+ <dt><em><code>thisArg</code></em></dt>
+ <dd>Opcjonalny. Obiekt, który będzie się znajdował pod <code>this</code> w czasie wykonywania funkcji <code>callback</code>.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p><strong>Wartość pierwszego elementu</strong> w tablicy, spełniającego warunek funkcji testującej.<br>
+ W przeciwnym wypadku: {{jsxref("undefined")}}.</p>
+
+<h2 id="Description" name="Description">Opis</h2>
+
+<p>Metoda <code>find</code> wywołuje funkcję <code><var>callback</var></code> raz dla każdego indeksu tablicy, dopóki nie znajdzie takiego elementu, dla którego <em><code>callback</code></em> zwraca wartość <code>true</code>. Wówczas <code>find</code> natychmiast zwraca wartość tego elementu. W przeciwnym razie, gdy żaden z elementów nie spełni warunków funkcji testującej, <code>find</code> zwraca {{jsxref("undefined")}}.</p>
+
+<p><code><var>callback</var></code> jest wywoływany dla każdego indeksu tablicy, nie tylko tych z przypisanymi wartościami. Oznacza to, że może to być mniej efektywne w przypadku tablic rzadkich, w porównaniu z metodami, które odwiedzają jedynie indeksy z przypisanymi wartościami.</p>
+
+<p>Jeśli parametr <code><var>thisArg</var></code>jest przekazany do <code>find</code>, będzie użyty jako wartość <code>this</code> w każdym wywołaniu <code><var>callback</var></code>. Jeśli parametr ten nie jest przekazany, używana jest wartość {{jsxref("undefined")}}.</p>
+
+<p>Metoda <code>find</code> nie modyfikuje tablicy, na której jest wywoływana, ale może to robić funkcja przekazana do <code><var>callback</var></code>. Jeśli tak się stanie, elementy przetwarzane przez <code>find</code> są ustawiane <em>przed</em> pierwszym wywołaniem funkcji <code><em>callback</em></code>. Zatem:</p>
+
+<ul>
+ <li><code><var>callback</var></code> nie odwiedzi żadnych elementów dodanych do tablicy po rozpoczęciu wywowłania <code>find</code>.</li>
+ <li>Jeśli istniejący, jeszcze nieodwiedzony element tablicy jest zmieniony przez <code><em>callback</em></code>, jego wartość przekazana do <code><em>callback</em></code> będzie wartością w momencie, w którym <code>find</code> odwiedza indeks tego elementu.</li>
+ <li>Elementy {{jsxref("delete", "usunięte")}} dalej są odwiedzane.</li>
+</ul>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Metoda ta została dodana do specyfikacji ECMAScript 2015 i może nie być jeszcze dostępna we wszystkich implementacjach języka JavaScript.  Niemniej jednak, możesz użyć <em>polyfill</em> z  <code>Array.prototype.find</code> z poniższym fragmentem kodu:</p>
+
+<pre class="brush: js notranslate">// https://tc39.github.io/ecma262/#sec-array.prototype.find
+if (!Array.prototype.find) {
+  Object.defineProperty(Array.prototype, 'find', {
+    value: function(predicate) {
+      // 1. Let O be ? ToObject(this value).
+      if (this == null) {
+        throw TypeError('"this" is null or not defined');
+      }
+
+      var o = Object(this);
+
+      // 2. Let len be ? ToLength(? Get(O, "length")).
+      var len = o.length &gt;&gt;&gt; 0;
+
+      // 3. If IsCallable(predicate) is false, throw a TypeError exception.
+      if (typeof predicate !== 'function') {
+        throw TypeError('predicate must be a function');
+      }
+
+      // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
+      var thisArg = arguments[1];
+
+      // 5. Let k be 0.
+      var k = 0;
+
+      // 6. Repeat, while k &lt; len
+      while (k &lt; len) {
+        // a. Let Pk be ! ToString(k).
+        // b. Let kValue be ? Get(O, Pk).
+        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
+        // d. If testResult is true, return kValue.
+        var kValue = o[k];
+        if (predicate.call(thisArg, kValue, k, o)) {
+          return kValue;
+        }
+        // e. Increase k by 1.
+        k++;
+      }
+
+      // 7. Return undefined.
+      return undefined;
+    },
+    configurable: true,
+    writable: true
+  });
+}
+</pre>
+
+<p>Jeśli potrzebujesz wspierać naprawdę przestarzałe silniki JavaScript, które nie wspierająt <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code>, najlepiej w ogóle nie używać <em>polyfill</em> z <code>Array.prototype</code>, gdyż nie da się go uczynić niewyliczeniowym.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Wyszukiwanie_obiektu_w_tablicy_na_podstawie_jednej_z_jego_własności">Wyszukiwanie obiektu w tablicy na podstawie jednej z jego własności</h3>
+
+<pre class="brush: js notranslate">const inventory = [
+  {name: 'apples', quantity: 2},
+  {name: 'bananas', quantity: 0},
+  {name: 'cherries', quantity: 5}
+];
+
+function isCherries(fruit) {
+  return fruit.name === 'cherries';
+}
+
+console.log(inventory.find(isCherries));
+// { name: 'cherries', quantity: 5 }</pre>
+
+<h4 id="Użycie_funkcji_strzałkowej_i_destrukturyzacja">Użycie funkcji strzałkowej i destrukturyzacja</h4>
+
+<pre class="brush: js notranslate">const inventory = [
+  {name: 'apples', quantity: 2},
+  {name: 'bananas', quantity: 0},
+  {name: 'cherries', quantity: 5}
+];
+
+const result = inventory.find( ({ name }) =&gt; name === 'cherries' );
+
+console.log(result) // { name: 'cherries', quantity: 5 }</pre>
+
+<h3 id="Wyszukiwanie_liczby_pierwszej_w_tablicy">Wyszukiwanie liczby pierwszej w tablicy</h3>
+
+<p>Poniższy przykładowy kod znajduje element tablicy będący liczbą pierwszą (lub zwraca {{jsxref("undefined")}} jeśli w tablicy nie ma liczby pierwszej):</p>
+
+<pre class="brush: js notranslate">function czyPierwsza(element, indeks, tablica) {
+  let start = 2;
+  while (start &lt;= Math.sqrt(element)) {
+    if (element % start++ &lt; 1) {
+      return false;
+    }
+  }
+  return element &gt; 1;
+}
+
+console.log([4, 6, 8, 12].find(czyPierwsza)); // undefined, nie znaleziono
+console.log([4, 5, 8, 12].find(czyPierwsza)); // 5
+</pre>
+
+<p>Poniższy przykład pokazuje, że nieistniejące i usunięte elementy <em>są</em> odwiedzane, oraz że wartość przekazana do <code><em>callback</em></code> jest ich wartością, kiedy są odwiedzane:</p>
+
+<pre class="brush: js notranslate">// Zadeklaruj tablicę bez elementów przy indeksach 2, 3 i 4
+const array = [0,1,,,,5,6];
+
+// Pokazuje wszystkie indeksy, nie tylko te z przypisanymi wartościami
+array.find(function(value, index) {
+  console.log('Odwiedzono indeks ', index, ' z wartością ', value);
+});
+
+// Pokazuje wszystkie indeksy, włączając usunięte
+array.find(function(value, index) {
+  // Usuń element 5 w pierwszej iteracji
+  if (index === 0) {
+    console.log('Usuwanie array[5] z wartością ', array[5]);
+    delete array[5];
+  }
+  // Element 5 jest wciąż odwiedzany, choć został usunięty
+  console.log('Odwiedzono indeks ', index, ' z wartością ', value);
+});
+// Oczekiwane wyjście:
+// Usuwanie array[5] z wartością 5
+// Odwiedzono indeks 0 z wartością 0
+// Odwiedzono indeks 1 z wartością 1
+// Odwiedzono indeks 2 z wartością undefined
+// Odwiedzono indeks 3 z wartością undefined
+// Odwiedzono indeks 4 z wartością undefined
+// Odwiedzono indeks 5 z wartością undefined
+// Odwiedzono indeks 6 z wartością 6
+</pre>
+
+<h2 id="Specifications" name="Specifications">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array.prototype.find', 'Array.prototype.find')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Pierwotna definicja.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Wsparcie przeglądarek</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("45.0")}}</td>
+   <td>{{CompatGeckoDesktop("25.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatSafari("7.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("25.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>iOS 8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/findindex/index.html b/files/pl/web/javascript/reference/global_objects/array/findindex/index.html
new file mode 100644
index 0000000000..46d8e2a087
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/findindex/index.html
@@ -0,0 +1,215 @@
+---
+title: Array.prototype.findIndex()
+slug: Web/JavaScript/Reference/Global_Objects/Array/findIndex
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/findIndex
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>findIndex()</strong></code> zwraca <strong>indeks</strong> pierwszego elementu tablicy, który spełnia kryteria postawione w funkcji testującej. W przeciwnym wypadku zwraca -1.</p>
+
+<pre class="brush: js">function isBigEnough(element) {
+  return element &gt;= 15;
+}
+
+[12, 5, 8, 130, 44].findIndex(isBigEnough);
+// zostanie zwrócony indeks czwartego elementu tablicy,
+// który wynosi 3</pre>
+
+<p>Zobacz także metodę {{jsxref("Array.find", "find()")}}, która zwraca <strong>wartość</strong> znalezionego elementu, zamiast jego indeksu.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><var>arr</var>.findIndex(<var>callback</var>[, <var>thisArg</var>])</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Funkcja wywoływana dla każdej wartości w tablicy, bierze trzy argumenty:</dd>
+ <dd>
+ <dl>
+  <dt><code>element</code></dt>
+  <dd>Obecnie przetwarzany element z tablicy.</dd>
+  <dt><code>index</code></dt>
+  <dd>Indeks obecnie przetwarzanego elementu z tablicy.</dd>
+  <dt><code>array</code></dt>
+  <dd>Tablica, na której została wywołana funkcja <code>findIndex</code>.</dd>
+ </dl>
+ </dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Opcjonalny.  Obiekt do użycia jako <code>this </code>w czasie wykonywania <code>callback.</code></dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Indeks elementu tablicy, który pomyślnie przeszedł test, jeśli taki nie zostanie znaleziony, zwraca <strong>-1</strong>.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Metoda <code>findIndex</code> wykonuje funkcję <code>callback</code> dla każdego indeksu tablicy 0..długość - 1 (włącznie) w tablicy dopóki nie znajdzie tego, na którym funkcja <code>callback</code> zwróci prawdę. Jeśli taki element zostanie znaleziony, <code>findIndex</code> natychmiast zwraca indeks dla tej iteracji. Jeśli callback nigdy nie zwróci prawdy lub wielkość tablicy wynosi 0, <code>findIndex</code> zwróci -1. W przeciwieństwie do innych metod tablicowych takich jak Array#some, w tablicach rzadkich <code>callback </code><strong>jest</strong> wywoływany nawet dla indeksów niewystępujących w tablicy.</p>
+
+<p><code>callback </code>jest wywoływany z trzema argumentami: wartością elementu, indeksem elementu i przetwarzaną tablicą.</p>
+
+<p>Jeśli <code>thisArg</code> jest dołączony do <code>findIndex</code>, zostanie użyty jako <code>this</code> dla każdego wywołania . Jeśli nie, zostanie użyte {{jsxref("undefined")}}.</p>
+
+<p><code>findIndex </code>nie zmienia tablicy na której jest wywoływany.</p>
+
+<p>Zakres elementów przetwarzanych przez <code>findIndex</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy, które są dodane po rozpoczęciu wywołania funkcji <code>findIndex </code>nie będą przetworzone przez <code>callback</code>. Jeśli istniejący, nieodwiedzony element tablicy zostanie zmieniony przez <code>callback</code>, jego wartość przekazana do odwiedzającego <code>callback</code> będzie tą wartością z momentu, w którym <code>findIndex</code> odwiedzi indeks tego elementu, elementy usunięte, nie będą odwiedzone.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Znajdź_indeks_liczby_pierwszej_w_tablicy">Znajdź indeks liczby pierwszej w tablicy</h3>
+
+<p>Poniższy przykład znajduje indeks elementu w tablicy, który jest liczbą pierwszą (lub zwraca -1 jeśli nie w tablicy nie ma liczby pierwszej).</p>
+
+<pre class="brush: js">function isPrime(element, index, array) {
+  var start = 2;
+  while (start &lt;= Math.sqrt(element)) {
+    if (element % start++ &lt; 1) {
+      return false;
+    }
+  }
+  return element &gt; 1;
+}
+
+console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, nie znaleziono
+console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.findIndex
+if (!Array.prototype.findIndex) {
+  Object.defineProperty(Array.prototype, 'findIndex', {
+    value: function(predicate) {
+     // 1. Let O be ? ToObject(this value).
+      if (this == null) {
+        throw new TypeError('"this" ma wartość null lub undefined');
+      }
+
+      var o = Object(this);
+
+      // 2. Niech len będzie ? ToLength(? Get(O, "length")).
+      var len = o.length &gt;&gt;&gt; 0;
+
+      // 3. Jeśli IsCallable(predicate) jest fałszem, rzuć wyjątek TypeError.
+      if (typeof predicate !== 'function') {
+        throw new TypeError('predykat musi być funkcją');
+      }
+
+      // 4. Jeśli thisArg został podany, niech T będzie thisArg; w przeciwnym wypadku, niech T będzie undefined.
+      var thisArg = arguments[1];
+
+      // 5. Let k be 0.
+      var k = 0;
+
+      // 6. Powtarzaj, dopóki k &lt; len
+      while (k &lt; len) {
+        // a. Niech Pk będzie ! ToString(k).
+        // b. Niech kValue będzie ? Get(O, Pk).
+        // c. Niech testResult będzie ToBoolean(? Call(predicate, T, « kValue, k, O »)).
+        // d. Jeśli testResult jest prawdą, zwróć k.
+        var kValue = o[k];
+        if (predicate.call(thisArg, kValue, k, o)) {
+          return k;
+        }
+        // e. Zwiększ wartość k o 1.
+        k++;
+      }
+
+      // 7. Return -1.
+      return -1;
+    }
+  });
+}
+</pre>
+
+<p>Jeśli musisz wspierać naprawdę przestarzałe silniki JavaScript, które nie wspierają <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code>, najlepiej nie korzystać z metod <code>Array.prototype</code>  w ogóle, ponieważ nie można sprawić by były niepoliczalne.</p>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array.prototype.findindex', 'Array.prototype.findIndex')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Podstawowa definicja.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Edge</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(45.0)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("25.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>Tak</td>
+   <td>Tak</td>
+   <td>{{CompatSafari("7.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>45.0</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("25.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8.0</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.find()")}}</li>
+ <li>{{jsxref("Array.prototype.indexOf()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/flat/index.html b/files/pl/web/javascript/reference/global_objects/array/flat/index.html
new file mode 100644
index 0000000000..063a4f1084
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/flat/index.html
@@ -0,0 +1,174 @@
+---
+title: Array.prototype.flat()
+slug: Web/JavaScript/Reference/Global_Objects/Array/flat
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/flat
+---
+<div>{{JSRef}}</div>
+
+<div></div>
+
+<p>Metoda <code><strong>flat()</strong></code> tworzy nową tablicę ze wszystkich elementów, które są podtablicami, łącząc je rekursyjnie z podanym parametrem jak głęboko powinno nastąpić spłaszczenie.</p>
+
+<p class="hidden">\{{EmbedInteractiveExample("pages/js/array-flatten.html")}}</p>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><var>var newArray = arr</var>.flat(<em>[depth]</em>);</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>depth</code> {{optional_inline}}</dt>
+ <dd>Parametr ten określa jak głęboko zagnieżdżona tablica powinna być spłaszczona. Wartość domyślna to 1.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Nowa tablica składająca się z połączonych elementów podtablic.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Spłaszczanie_zagnieżdżonych_tablic">Spłaszczanie zagnieżdżonych tablic</h3>
+
+<pre class="brush: js">var arr1 = [1, 2, [3, 4]];
+arr1.flat();
+// [1, 2, 3, 4]
+
+var arr2 = [1, 2, [3, 4, [5, 6]]];
+arr2.flat();
+// [1, 2, 3, 4, [5, 6]]
+
+var arr3 = [1, 2, [3, 4, [5, 6]]];
+arr3.flat(2);
+// [1, 2, 3, 4, 5, 6]
+</pre>
+
+<h3 id="Spłaszczanie_i_puste_miejsca_tablicy">Spłaszczanie i puste miejsca tablicy</h3>
+
+<p>Metoda flat() usuwa puste miejsca w tablicy:</p>
+
+<pre class="brush: js">var arr4 = [1, 2, , 4, 5];
+arr4.flat();
+// [1, 2, 4, 5]
+</pre>
+
+<h2 id="Alternatywa">Alternatywa</h2>
+
+<h3 id="reduce_i_concat"><code>reduce</code> i <code>concat</code></h3>
+
+<pre class="brush: js">var arr1 = [1, 2, [3, 4]];
+arr1.flat();
+
+//to flat single level array
+arr1.reduce((acc, val) =&gt; acc.concat(val), []);// [1, 2, 3, 4]
+
+//or
+const flatSingle = arr =&gt; [].concat(...arr);
+</pre>
+
+
+
+<pre class="brush: js">//to enable deep level flatten use recursion with reduce and concat
+var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];
+
+function flattenDeep(arr1) {
+   return arr1.reduce((acc, val) =&gt; Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);
+}
+flattenDeep(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
+</pre>
+
+
+
+<pre class="brush: js">//non recursive flatten deep using a stack
+var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];
+function flatten(input) {
+  const stack = [...input];
+  const res = [];
+  while (stack.length) {
+    // pop value from stack
+    const next = stack.pop();
+    if (Array.isArray(next)) {
+      // push back array items, won't modify the original input
+      stack.push(...next);
+    } else {
+      res.push(next);
+    }
+  }
+  //reverse to restore input order
+  return res.reverse();
+}
+flatten(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
+</pre>
+
+
+
+<pre class="brush: js">//recursive flatten deep
+function flatten(array) {
+  var flattend = [];
+  !(function flat(array) {
+    array.forEach(function(el) {
+      if (Array.isArray(el)) flat(el);
+      else flattend.push(el);
+    });
+  })(array);
+  return flattend;
+}
+</pre>
+
+
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">if (!Array.prototype.flat) {
+  Array.prototype.flat = function(depth) {
+    var flattend = [];
+    (function flat(array, depth) {
+      for (let el of array) {
+        if (Array.isArray(el) &amp;&amp; depth &gt; 0) {
+          flat(el, depth - 1);
+        } else {
+          flattend.push(el);
+        }
+      }
+    })(this, Math.floor(depth) || 1);
+    return flattend;
+  };
+}
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td><a href="https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flat"><code>Array.prototype.flat</code> proposal</a></td>
+   <td>Finished (4)</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Array.flat")}}</p>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.flatMap()")}}</li>
+ <li>{{jsxref("Array.prototype.map()")}}</li>
+ <li>{{jsxref("Array.prototype.reduce()")}}</li>
+ <li>{{jsxref("Array.prototype.concat()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/foreach/index.html b/files/pl/web/javascript/reference/global_objects/array/foreach/index.html
new file mode 100644
index 0000000000..612be4d2fb
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/foreach/index.html
@@ -0,0 +1,105 @@
+---
+title: Array.prototype.forEach()
+slug: Web/JavaScript/Reference/Global_Objects/Array/forEach
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/forEach
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wykonuje dostarczoną funkcję jeden raz na każdy element tablicy.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.forEach(<var>callback</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Funkcja wykonywana dla każdego elementu.</dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Obiekt na który będzie wskazywał <code>this</code>, gdy wykonana zostanie funkcja zwrotna <code>callback</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>forEach</code> wykonuje dostarczoną funkcje <code>callback</code> raz dla każdego elementu tablicy. Funkcja <code>callback</code> wywoływana jest jedynie dla indeksów tablicy, którym została przypisana wartość; nie jest wywoływana dla indeksów, które zostały usunięte i tych, którym nigdy nie została przypisana żadna wartość.</p>
+
+<p>Funkcja <code>callback</code> jest wywoływana z trzema argumentami: wartością elementu, jego indeksem i obiektem tablicy, w którym się ten element zawiera.</p>
+
+<p>Jeśli parametr <code>thisArg</code> został dostarczony do metody <code>forEach</code>, będzie on wskazywany przez <code>this</code> dla każdego wywołania funkcji <code>callback</code>. W przypadku, gdy nie został on przekazany lub jego wartość jest równa <code>null</code>, <code>this</code> będzie się odnosić do obiektu globalnego połączonego z funkcją <code>callback</code>.</p>
+
+<p>Metoda <code>forEach</code> nie modyfikuje tablicy na której jest wywołana.</p>
+
+<p>Zakres elementów przetwarzanych przez <code>forEach</code> jest ustawiany przed pierwszym wywołaniem funkcji <code>callback</code>. Elementy dołączone do końca tablicy po momencie wywołania <code>forEach</code> nie są przesyłane do funkcji <code>callback</code>. Jeśli istniejące elementy tablicy są zmieniane lub usuwane, to wartość przesyłana do funkcji <code>callback</code> odpowiada wartości w momencie, w którym <code>forEach</code> się o nie zwróci; elementy usunięte zanim zostaną odwiedzone nie zostaną odwiedzone. Jeżeli element już odwiedzony zostanie usunięty (nastąpi skrócenie tablicy), element tablicy w kolejności po obecnie odwiedzanym zostanie pominięty.</p>
+
+<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3>
+
+<p><code>forEach</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>forEach</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p>
+
+<pre class="brush: js">if (!Array.prototype.forEach)
+{
+  Array.prototype.forEach = function(fun /*, thisp*/)
+  {
+    var len = this.length;
+    if (typeof fun != "function")
+      throw new TypeError();
+
+    var thisp = arguments[1];
+    for (var i = 0; i &lt; len; i++)
+    {
+      if (i in this)
+        fun.call(thisp, this[i], i, this);
+    }
+  };
+}
+</pre>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy" name="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy">Przykład: Drukowanie zawartości tablicy</h3>
+
+<p>Następujący kod drukuje linie dla każdego elementu w tablicy (i przyjmuje obecność funkcji <code>print</code> do wywołania!):</p>
+
+<pre class="brush: js">function printElt(element, index, array) {
+    print("[" + index + "] jest " + element);
+}
+[2, 5, 9].forEach(printElt);
+// Wydrukuje:
+// [0] jest 2
+// [1] jest 5
+// [2] jest 9
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy_z_metod.C4.85_obiektu" name="Przyk.C5.82ad:_Drukowanie_zawarto.C5.9Bci_tablicy_z_metod.C4.85_obiektu">Przykład: Drukowanie zawartości tablicy z metodą obiektu</h3>
+
+<p>Następujący kod tworzy prosty obiekt wypisujący i następnie stosuje metodę <code>writeln</code> do wypisania jednej linii na element w tablicy (przyjmuje obecność funkcji <code>print</code> do wywołania!):</p>
+
+<pre class="brush: js">var writer = {
+    sb:       [],
+    write:    function (s) {
+        this.sb.push(s);
+    },
+    writeln:  function (s) {
+        this.write(s + "\n");
+    },
+    toString: function () {
+        return this.sb.join("");
+    }
+};
+
+[2, 5, 9].forEach(writer.writeln, writer);
+print(writer.toString());
+
+// Wydrukuje:
+// 2
+// 5
+// 9
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/array/from/index.html b/files/pl/web/javascript/reference/global_objects/array/from/index.html
new file mode 100644
index 0000000000..049d4477d1
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/from/index.html
@@ -0,0 +1,249 @@
+---
+title: Array.from()
+slug: Web/JavaScript/Reference/Global_Objects/Array/from
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/from
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/from
+---
+<div>{{JSRef}}</div>
+
+<p><code><strong>Array.from() </strong></code> metoda tworzy nową instację tablicy z obiektu podobnego do tablicy lub obiektu iterowalnego.</p>
+
+<p>W ES2015, składania klas dopuszcza dziedziczenie obu rodzajów klas: wbudowanych oraz zdefiniowanych przez programistę; w rezultacie, statyczne metody jak <code><strong>Array.from</strong></code> są "dziedziczone" przez klasę pochodną i tworzą nową instancję klasy pochodnej, a nie klasy <code><strong>Array</strong></code>.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Array.from(arrayLike[, mapFn[, thisArg]])
+</code></pre>
+
+<h3 id="Argumenty">Argumenty</h3>
+
+<dl>
+ <dt><code>arrayLike</code></dt>
+ <dd>Obiekt podobny do tablicy lub iterowalny.</dd>
+ <dt><code>mapFn</code></dt>
+ <dd>Opcjonalny. Funkcja mapująca wywoływany z każdym elementem tablicy.</dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Opcjonalny. Wartość używana jako <code>this</code> podczas wykonywania <code>mapFn</code>.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p><code>Array.from()</code> pozwala tworzyć tablicę z:</p>
+
+<ul>
+ <li>obiektu podobnego do tablicy (obiekt z właściwością <code>length</code> property oraz liczbowymi elementami)</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterable objects</a> (objects where you can get its elements, such as {{jsxref("Map")}} and {{jsxref("Set")}}).</li>
+</ul>
+
+<p><code>Array.from()</code> has an optional parameter <code>mapFn</code>, which allows you to execute a {{jsxref("Array.prototype.map", "map")}} function on each element of the array (or subclass object) that is being created. More clearly,<code> Array.from(obj, mapFn, thisArg)</code> is the same as <code>Array.from(obj).map(mapFn, thisArg)</code>, except that it does not create an intermediate array. This is especially important for certain array subclasses, like <a href="/en-US/docs/Web/JavaScript/Typed_arrays">typed arrays</a>, since the intermediate array would necessarily have values truncated to fit into the appropriate type.</p>
+
+<p>The <code>length</code> property of the <code>from()</code> method is 1.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<pre class="brush: js">// Array-like object (arguments) to Array
+function f() {
+  return Array.from(arguments);
+}
+
+f(1, 2, 3);
+// [1, 2, 3]
+
+
+// Any iterable object...
+// Set
+var s = new Set(["foo", window]);
+Array.from(s);
+// ["foo", window]
+
+
+// Map
+var m = new Map([[1, 2], [2, 4], [4, 8]]);
+Array.from(m);
+// [[1, 2], [2, 4], [4, 8]]
+
+
+// String
+Array.from("foo");
+// ["f", "o", "o"]
+
+
+// Using an arrow function as the map function to
+// manipulate the elements
+Array.from([1, 2, 3], x =&gt; x + x);
+// [2, 4, 6]
+
+
+// Generate a sequence of numbers
+Array.from({length: 5}, (v, k) =&gt; k);
+// [0, 1, 2, 3, 4]
+
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p><code>Array.from</code> was added to the ECMA-262 standard in the 6th edition; as such it may not be present in other implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of <code>Array.from</code> in implementations that don't natively support it.  This algorithm is exactly the one specified in ECMA-262, 6th edition, assuming <code>Object</code> and <code>TypeError</code> have their original values and that <code>callback.call</code> evaluates to the original value of {{jsxref("Function.prototype.call")}}. In addition, since true iterables can not be polyfilled, this implementation does not support generic iterables as defined in the 6th edition of ECMA-262.</p>
+
+<pre class="brush: js">// Production steps of ECMA-262, Edition 6, 22.1.2.1
+// Reference: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from
+if (!Array.from) {
+  Array.from = (function () {
+    var toStr = Object.prototype.toString;
+    var isCallable = function (fn) {
+      return typeof fn === 'function' || toStr.call(fn) === '[object Function]';
+    };
+    var toInteger = function (value) {
+      var number = Number(value);
+      if (isNaN(number)) { return 0; }
+      if (number === 0 || !isFinite(number)) { return number; }
+      return (number &gt; 0 ? 1 : -1) * Math.floor(Math.abs(number));
+    };
+    var maxSafeInteger = Math.pow(2, 53) - 1;
+    var toLength = function (value) {
+      var len = toInteger(value);
+      return Math.min(Math.max(len, 0), maxSafeInteger);
+    };
+
+    // The length property of the from method is 1.
+    return function from(arrayLike/*, mapFn, thisArg */) {
+      // 1. Let C be the this value.
+      var C = this;
+
+      // 2. Let items be ToObject(arrayLike).
+      var items = Object(arrayLike);
+
+      // 3. ReturnIfAbrupt(items).
+      if (arrayLike == null) {
+        throw new TypeError("Array.from requires an array-like object - not null or undefined");
+      }
+
+      // 4. If mapfn is undefined, then let mapping be false.
+      var mapFn = arguments.length &gt; 1 ? arguments[1] : void undefined;
+      var T;
+      if (typeof mapFn !== 'undefined') {
+        // 5. else
+        // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
+        if (!isCallable(mapFn)) {
+          throw new TypeError('Array.from: when provided, the second argument must be a function');
+        }
+
+        // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
+        if (arguments.length &gt; 2) {
+          T = arguments[2];
+        }
+      }
+
+      // 10. Let lenValue be Get(items, "length").
+      // 11. Let len be ToLength(lenValue).
+      var len = toLength(items.length);
+
+      // 13. If IsConstructor(C) is true, then
+      // 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len.
+      // 14. a. Else, Let A be ArrayCreate(len).
+      var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+
+      // 16. Let k be 0.
+      var k = 0;
+      // 17. Repeat, while k &lt; len… (also steps a - h)
+      var kValue;
+      while (k &lt; len) {
+        kValue = items[k];
+        if (mapFn) {
+          A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);
+        } else {
+          A[k] = kValue;
+        }
+        k += 1;
+      }
+      // 18. Let putStatus be Put(A, "length", len, true).
+      A.length = len;
+      // 20. Return A.
+      return A;
+    };
+  }());
+}
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array.from', 'Array.from')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.from', 'Array.from')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Edge</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("45")}}</td>
+   <td>{{CompatGeckoDesktop("32")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>9.0</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("32")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+ <li>{{jsxref("Array.prototype.map()")}}</li>
+ <li>{{jsxref("TypedArray.from()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/includes/index.html b/files/pl/web/javascript/reference/global_objects/array/includes/index.html
new file mode 100644
index 0000000000..ead60760a3
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/includes/index.html
@@ -0,0 +1,111 @@
+---
+title: Array.prototype.includes()
+slug: Web/JavaScript/Reference/Global_Objects/Array/includes
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/includes
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>includes()</strong></code> ustala czy dana tablica posiada szukany element, zwracając <code>true</code> lub <code>false.</code></p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">var<code><var> boolean = array</var>.includes(<var>searchElement</var>[, <var>fromIndex</var>])</code></pre>
+
+<h3 id="Zwraca">Zwraca</h3>
+
+<p>{{jsxref("Boolean")}}.</p>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>searchElement</code></dt>
+ <dd>Szukany element.</dd>
+ <dt><code>fromIndex</code></dt>
+ <dd>Opcjonalne. Jest to pozycja w tablicy, od której rozpoczyna się szukanie elementu <code>searchElement</code>. Ujemna wartość przeszukuje tablicę od końca tablicy. Domyślna wartość wynosi 0.</dd>
+</dl>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<pre class="brush: js">[1, 2, 3].includes(2);     // true
+[1, 2, 3].includes(4);     // false
+[1, 2, 3].includes(3, 3);  // false
+[1, 2, 3].includes(3, -1); // true
+[1, 2, NaN].includes(NaN); // true
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">if (!Array.prototype.includes) {
+  Array.prototype.includes = function(searchElement /*, fromIndex*/ ) {
+    'use strict';
+    var O = Object(this);
+    var len = parseInt(O.length) || 0;
+    if (len === 0) {
+      return false;
+    }
+    var n = parseInt(arguments[1]) || 0;
+    var k;
+    if (n &gt;= 0) {
+      k = n;
+    } else {
+      k = len + n;
+      if (k &lt; 0) {k = 0;}
+    }
+    var currentElement;
+    while (k &lt; len) {
+      currentElement = O[k];
+      if (searchElement === currentElement ||
+         (searchElement !== searchElement &amp;&amp; currentElement !== currentElement)) { // NaN !== NaN
+        return true;
+      }
+      k++;
+    }
+    return false;
+  };
+}
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td>
+   <td>{{Spec2('ES7')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>
+    <p> </p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.Array.includes")}}</p>
+</div>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("TypedArray.prototype.includes()")}}</li>
+ <li>{{jsxref("String.prototype.includes()")}}</li>
+ <li>{{jsxref("Array.prototype.indexOf()")}}</li>
+ <li>{{jsxref("Array.prototype.find()")}}</li>
+ <li>{{jsxref("Array.prototype.findIndex()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/index.html b/files/pl/web/javascript/reference/global_objects/array/index.html
new file mode 100644
index 0000000000..7592e1696b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/index.html
@@ -0,0 +1,280 @@
+---
+title: Array
+slug: Web/JavaScript/Reference/Global_Objects/Array
+tags:
+  - Array
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/Array
+original_slug: Web/JavaScript/Referencje/Obiekty/Array
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<p><code>Array</code>  w języku JavaScript jest globalnym obiektem, który jest używany podczas tworzenia tablic – listo-podobnych obieków wysokiego poziomu.</p>
+
+<div class="boxed translate-rendered">
+<p><strong>Stwórz tablicę</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> owoce <span class="operator token">=</span> <span class="punctuation token">[</span><span class="string token">'Jabłko'</span><span class="punctuation token">,</span> <span class="string token">'Banan'</span><span class="punctuation token">]</span><span class="punctuation token">;</span>
+
+console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>owoce<span class="punctuation token">.</span>length<span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// 2</span></code></pre>
+</div>
+
+<p><strong>Dostawanie się do elementu tablicy</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> pierwszy <span class="operator token">=</span> owoce<span class="punctuation token">[</span><span class="number token">0</span><span class="punctuation token">]</span><span class="punctuation token">;</span>
+<span class="comment token">// Jablko</span>
+
+<span class="keyword token">var</span> ostatni <span class="operator token">=</span> owoce<span class="punctuation token">[</span>owoce<span class="punctuation token">.</span>length <span class="operator token">-</span> <span class="number token">1</span><span class="punctuation token">]</span><span class="punctuation token">;</span>
+<span class="comment token">// Banan</span></code></pre>
+
+<p><strong>Pętla przechodząca przez zawartość tablicy</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js">owoce<span class="punctuation token">.</span><span class="function token">forEach</span><span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span>item<span class="punctuation token">,</span> index<span class="punctuation token">,</span> array<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>item<span class="punctuation token">,</span> index<span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// Jablko 0</span>
+<span class="comment token">// Banan 1</span></code></pre>
+
+<p><strong>Dodawanie elementu na końcu tablicy</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> nowaDługosc <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">push</span><span class="punctuation token">(</span><span class="string token">'Pomarańcz'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// ["Jabłko", "Banan", "Pomarańcz"]</span></code></pre>
+
+<p><strong>Usuwanie elemetu z końca tablicy</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> ostatni <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">pop</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// usuwa pomarańczę z końca</span>
+<span class="comment token">// ["Jabłko", "Banan"];</span></code></pre>
+
+<p><strong>Usuwanie elementu z przodu tablicy</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> pierwszy <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">shift</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// usuwa jabłko z początku</span>
+<span class="comment token">// ["Banan"];</span></code></pre>
+
+<p><strong>Dodawanie elementu z przodu tablicy</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> nowaDługość <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">unshift</span><span class="punctuation token">(</span><span class="string token">'Truskawki'</span><span class="punctuation token">)</span> <span class="comment token">// dodaje na początku</span>
+<span class="comment token">// ["Truskawkę", "Banan"];</span></code></pre>
+
+<p><strong>Znajdowanie indeksu (numeru porządkowego) elementu t tablicy</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js">owoce<span class="punctuation token">.</span><span class="function token">push</span><span class="punctuation token">(</span><span class="string token">'Mango'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// ["Truskawka", "Banan", "Mango"]</span>
+
+<span class="keyword token">var</span> pos <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">'Banan'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// 1</span></code></pre>
+
+<p><strong>Usuwanie obiektu przy użyciu indeksu </strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> usunElement <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">splice</span><span class="punctuation token">(</span>pos<span class="punctuation token">,</span> <span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// tak się usuwa element</span>
+
+<span class="comment token">// ["Truskawka", "Mango"]</span></code></pre>
+
+<p><strong>Usuwanie elementów przy użyciu pozycji w indeksie</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> warzywa <span class="operator token">=</span> <span class="punctuation token">["</span><span class="string token">Kapusta"</span><span class="punctuation token">,</span> "<span class="string token">Rzepa</span><span class="punctuation token">",</span> "<span class="string token">Rzodkiew"</span><span class="punctuation token">,</span> "<span class="string token">Marchew"</span><span class="punctuation token">]</span><span class="punctuation token">;</span>
+console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(warzywa</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// </span><span class="punctuation token">[</span><span class="string token">"Kapusta"</span><span class="punctuation token">,</span> "<span class="string token">Rzepa"</span><span class="punctuation token">,</span> "<span class="string token">Rzodkiew"</span><span class="punctuation token">,</span> "<span class="string token">Marchew"</span><span class="punctuation token">]</span>
+
+<span class="keyword token">var</span> pos <span class="operator token">=</span> <span class="number token">1</span><span class="punctuation token">,</span> n <span class="operator token">=</span> <span class="number token">2</span><span class="punctuation token">;</span>
+
+<span class="keyword token">var</span> usunieteElementy <span class="operator token">=</span> warzywa<span class="punctuation token">.</span><span class="function token">splice</span><span class="punctuation token">(</span>pos<span class="punctuation token">,</span> n<span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// n oznacza liczbę elementów do usunięcia</span>
+<span class="comment token">// zaczynając od elementu na określonej pozycji(pos)</span>
+
+console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>warzywa<span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// ["Kapusta", "Marchew"] (początkowa tablica została zmieniona)</span>
+
+console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>usunieteElementy<span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// ["Rzepa", "Rzodkiew"]</span></code>
+</pre>
+
+<p><strong>Kopiowanie tablicy</strong></p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> płytkaKopia <span class="operator token">=</span> owoce<span class="punctuation token">.</span><span class="function token">slice</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// tak się tworzy kopię</span>
+<span class="comment token">// ["Truskawka", "Mango"]</span></code>
+</pre>
+
+<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia:</h2>
+
+<pre class="syntaxbox"><code>[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>]
+new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]])
+new Array(długoscTablicy)</code></pre>
+
+<dl>
+ <dt><code>elementN </code></dt>
+ <dd>Lista wartości elementów tablicy. Tablica jest inicjowana z określonymi wartościami jako jej elementami. Długość tablicy (<code>length</code>) odpowiada liczbie jej elementów.</dd>
+ <dt><code>długośćTablicy</code></dt>
+ <dd>Początkowa długość tablicy. Aby móc przetwarzać wartości używamy własności długości tablicy <code>length</code>. Jeśli określona wartość nie jest liczbą, zostanie utworzona tablica jednoelementowa, a jej pierwszy element będzie posiadał ową wartość. Maksymalna długość tablicy wynosi 4,294,967,295 elementów.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Tablica jest uporządkowanym zbiorem wartości przyporządkowanych ustalonej pojedynczej zmiennej.</p>
+
+<p>Poniższy przykład tworzy obiekt <code>Array</code> przy użyciu literału tablicy. Tablica <code>kawa</code> zawiera trzy elementy i ma długość (<code>length</code>) równą 3:</p>
+
+<pre class="brush: js">kawa = ["mocca", "cappucino", "zbożowa"]
+</pre>
+
+<p>Można utworzyć tzw. zwartą tablicę składającą się z dwóch lub więcej elementów, o początkowym indeksie 0, jeśli poda się początkowe wartości wszystkich elementów. Zwarta tablica to taka, w której każdy element posiada wartość. Poniższy kod tworzy zwartą tablicę o trzech elementach:</p>
+
+<pre class="brush: js">myArray = new Array("Hello", myVar, 3.14159)
+</pre>
+
+<h3 id="Dost.C4.99p_do_element.C3.B3w_tablicy" name="Dost.C4.99p_do_element.C3.B3w_tablicy">Dostęp do elementów tablicy</h3>
+
+<p>Do elementów tablicy odwołujemy się po ich liczbie porządkowej (zaczynając od zera). Przykładowo, jeśli mamy zdefiniowaną tablicę:</p>
+
+<pre class="brush: js">mojaTablica = new Array("Wiatr","Deszcz","Ogień")
+</pre>
+
+<p>Do pierwszego elementu odwołujemy się poprzez <code>mojaTablica[0]</code>, a do drugiego poprzez <code>mojaTablica[1]</code>.</p>
+
+<h3 id="Podawanie_pojedynczego_parametru" name="Podawanie_pojedynczego_parametru">Podawanie pojedynczego parametru</h3>
+
+<p>Jeśli konstruktor <code>Array</code> zostanie wywołany z pojedynczym parametrem liczbowym, parametr ten zostanie uznany za początkową długość tablicy. Poniższy kod tworzy tablicę pięciu elementów:</p>
+
+<pre class="brush: js">rodzajPlatnosci = new Array(5)
+</pre>
+
+<p>Zachowanie konstruktora <code>Array</code> zależy od tego, czy jedyny parametr jest liczbą.</p>
+
+<ul>
+ <li>Jeśli jedyny parametr jest liczbą, konstruktor konwertuje tę liczbą do 32-bitowej liczby całkowitej bez znaku i tworzy tablicę o długości (liczbie elementów, <code>length</code>) równej tej liczbie. Tablica początkowo nie zawiera żadnych elementów, mimo że ma niezerową długość.</li>
+ <li>Jeśli parametr ten nie jest liczbą, tworzona jest tablica o długości 1, a parametr ten staje się jej pierwszym elementem.</li>
+</ul>
+
+<p>Poniższy kod tworzy tablicę o długości 25, a następnie przypisuje wartości pierwszym trzem elementom:</p>
+
+<pre class="brush: js">rodzajeMuzyki = new Array(25)
+rodzajeMuzyki[0] = "R&amp;B"
+rodzajeMuzyki[1] = "Blues"
+rodzajeMuzyki[2] = "Jazz"
+</pre>
+
+<h3 id="Po.C5.9Brednie_zwi.C4.99kszanie_d.C5.82ugo.C5.9Bci_tablicy" name="Po.C5.9Brednie_zwi.C4.99kszanie_d.C5.82ugo.C5.9Bci_tablicy">Pośrednie zwiększanie długości tablicy</h3>
+
+<p>Długość tablicy wzrasta samoczynnie, jeśli elementowi o indeksie wyższym niż obecna długość zostanie przypisana wartość. Poniższy kod tworzy tablicę o zerowej długości, a następnie przypisuje do niej 99. element. W wyniku długość tablicy zostaje zmieniona na 100.</p>
+
+<pre class="brush: js">kolory = new Array();
+kolory[99] = "ciemnoniebieski";
+</pre>
+
+<h3 id="Tworzenie_tablicy_z_wynik.C3.B3w_wyra.C5.BCenia_regularnego" name="Tworzenie_tablicy_z_wynik.C3.B3w_wyra.C5.BCenia_regularnego">Tworzenie tablicy z wyników wyrażenia regularnego</h3>
+
+<p>Wynik porównania pomiędzy regularnym wyrażeniem a łańcuchem znaków może utworzyć tablicę. Ta tablica ma własności i elementy, które przekazują informacje dotyczące porównania. Tablica jest wartością zwracaną przez <code>RegExp.exec</code>, <code>String.match</code> i <code>String.replace</code>. Aby zrozumieć te własności spójrz na poniższy przykład odwołując się do poniższej tabeli:</p>
+
+<pre class="brush: js">//Porównuje łańcuch znaków złożony z jednego 'd' następnie kilku 'b' a następnie jednego 'd'
+//Zapamiętuje porównane 'b' i następujące 'd'
+//Ignoruje wielkość liter
+
+mojRe=/d(b+)(d)/i;
+mojaTablica = mojRe.exec("cdbBdbsbz");
+</pre>
+
+<p>Własności i elementy zwracają wartości z poniższej tabeli:</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header">Własność/Element</td>
+   <td class="header">Opis</td>
+   <td class="header">Przykład</td>
+  </tr>
+  <tr>
+   <td><code>input</code></td>
+   <td>Wartość tylko-do-odczytu, opisująca oryginalny łańcuch znaków, do którego porównano wyrażenie regularne.</td>
+   <td>cdbBdbsbz</td>
+  </tr>
+  <tr>
+   <td><code>index</code></td>
+   <td>Własność tylko-do-odczytu, będąca indeksem (zaczynając od 0) porównanego znaku w łańcuchu znaków.</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td><code>[0]</code></td>
+   <td>Element tylko-do-odczytu, zawierający ostatnio porównane znaki.</td>
+   <td>dbBd</td>
+  </tr>
+  <tr>
+   <td><code>[1], ... [n]</code></td>
+   <td>Elementy tylko-do-odczytu, zawierające podobne podłańcuchy znaków, zawarte w wyrażeniu regularnym. Liczba możliwych podłańcuchów jest nieskończona.</td>
+   <td>[1]: bB<br>
+    [2]: d</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Własności">Własności</h2>
+
+<dl>
+ <dd>
+ <dl>
+  <dt>{{jsxref("Array.length")}}</dt>
+  <dd>Odzwierciedla ilość elementów tablicy.</dd>
+  <dt>{{jsxref("Array.prototype")}}</dt>
+  <dd>Pozwala na dodawanie własności do wszystkich obiektów.</dd>
+ </dl>
+ </dd>
+</dl>
+
+<h2 id="Metody" name="Metody">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("Array.from()")}} {{experimental_inline}}</dt>
+ <dd>Tworzy nową instancję <code>Array</code> z obiektu podobnego do tablicy lub iterowalnego.</dd>
+ <dt>{{jsxref("Array.isArray()")}}</dt>
+ <dd>Zwraca true, jeśli zmienna jest tablicą, jeśli nie false.</dd>
+ <dt>{{jsxref("Array.observe()")}} {{experimental_inline}}</dt>
+ <dd>Asynchronicznie obserwuje zmiany w tablicach, podobnie jak {{jsxref ("Object.observe ()")}} dla obiektów. Zapewnia strumień zmian w kolejności występowania.</dd>
+ <dt>{{jsxref("Array.of()")}} {{experimental_inline}}</dt>
+ <dd>Tworzy nową instancję Array ze zmienną liczbą argumentów, niezależnie od liczby lub rodzaju argumentów.</dd>
+</dl>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad_Tworzenie_tablicy" name="Przyk.C5.82ad:_Tworzenie_tablicy">Przykład: Tworzenie tablicy</h3>
+
+<p>Poniższy kod tworzy tablicę <code>msgArray</code> o długości 0, a następnie przypisuje wartości do <code>msgArray[0]</code> i <code>msgArray[99]</code>, zwiększając długość tablicy do 100.</p>
+
+<pre class="brush: js">msgArray = new Array()
+msgArray[0] = "Witaj,"
+msgArray[99] = "świecie"
+// Poniższy warunek jest spełniony,
+// ponieważ zdefiniowano element msgArray[99].
+if (msgArray.length == 100)
+   myVar="Długość tablicy jest równa 100."
+</pre>
+
+<h3 id="Przyk.C5.82ad_Tworzenie_tablicy_dwuwymiarowej" name="Przyk.C5.82ad:_Tworzenie_tablicy_dwuwymiarowej">Przykład: Tworzenie tablicy dwuwymiarowej</h3>
+
+<p>Poniższy kod tworzy tablicę dwuwymiarową i przypisuje wyniki do zmiennej <code>myVar</code>.</p>
+
+<pre class="brush: js">myVar="Test tablicy wielowymiarowej; "
+a = new Array(4)
+for (i=0; i &lt; 4; i++) {
+   a[i] = new Array(4)
+   for (j=0; j &lt; 4; j++) {
+      a[i][j] = "["+i+","+j+"]"
+   }
+}
+for (i=0; i &lt; 4; i++) {
+   str = "Wiersz "+i+":"
+   for (j=0; j &lt; 4; j++) {
+      str += a[i][j]
+   }
+   myVar += str +"; "
+}
+</pre>
+
+<p>Poniższy łańcuch znaków będzie przypisany do zmiennej <code>myVar</code> (linie zostały przełamane dla zwiększenia czytelności):</p>
+
+<pre>Test tablicy wielowymiarowej;
+Wiersz 0:[0,0][0,1][0,2][0,3];
+Wiersz 1:[1,0][1,1][1,2][1,3];
+Wiersz 2:[2,0][2,1][2,2][2,3];
+Wiersz 3:[3,0][3,1][3,2][3,3];
+</pre>
+
+<div class="noinclude"></div>
diff --git a/files/pl/web/javascript/reference/global_objects/array/indexof/index.html b/files/pl/web/javascript/reference/global_objects/array/indexof/index.html
new file mode 100644
index 0000000000..512e3de6ab
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/indexof/index.html
@@ -0,0 +1,96 @@
+---
+title: Array.prototype.indexOf()
+slug: Web/JavaScript/Reference/Global_Objects/Array/indexOf
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/indexOf
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca pierwszy (najmniejszy) indeks elementu w tablicy równego podanej wartości lub -1, gdy nie znaleziono takiego elementu.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><em>array</em>.indexOf(<em>searchElement</em>[,<em> fromIndex</em> = 0]);
+</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>searchElement</code></dt>
+ <dd>Element do znalezienia w tablicy.</dd>
+ <dt><code>fromIndex</code></dt>
+ <dd>Indeks od którego ma zacząć się wyszukiwanie. Domyślnie 0 - przeszukana zostanie cała tablica. Jeżeli indeks będzie większy lub równy ilości elementów tablica nie zostanie przeszukana - funkcja zwróci -1. Jeżeli podana zostanie liczba ujemna zostanie dodany do niej rozmiar tablicy (np. podanie -5 oznacza przeszukiwanie od 5 elementu od końca). Jeżeli tak obliczony indeks jest mniejszy od zera przeszukana zostanie cała tablica. Uwaga, wyszukiwanie dalej będzie się odbywać w kierunku rosnących indeksów.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>indexOf</code> porównuje <code>searchElement</code> z elementami tablicy używając <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_por%c3%b3wnania#.22U.C5.BCywanie_operator.C3.B3w_por.C3.B3wnania">ścisłego porównania</a> (podobnie jak w przypadku operatora ===).</p>
+
+<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3>
+
+<p><code>indexOf</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>indexOf</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p>
+
+<pre class="brush: js">if (!Array.prototype.indexOf)
+{
+  Array.prototype.indexOf = function(elt /*, from*/)
+  {
+    var len = this.length;
+
+    var from = Number(arguments[1]) || 0;
+    from = (from &lt; 0)
+         ? Math.ceil(from)
+         : Math.floor(from);
+    if (from &lt; 0)
+      from += len;
+
+    for (; from &lt; len; from++)
+    {
+      if (from in this &amp;&amp;
+          this[from] === elt)
+        return from;
+    }
+    return -1;
+  };
+}
+</pre>
+
+<p>Należy zwrócić uwagę, że ta implementacja ma na celu całkowitą zgodność z <code>indexOf</code> występującą w Firefoksie i silniku JavaScript SpiderMonkey, włączając w to przypadki w których przesyłany do <code>indexOf</code> indeks nie jest wartością liczbową. Jeśli masz zamiar wykorzystać przytoczone rozwiązanie w rzeczywistych aplikacjach, możesz nie potrzebować całego powyższego kodu (części odpowiedzialnej za obliczenie wartości <code>from</code>).</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_indexOf" name="Przyk.C5.82ad:_Zastosowanie_indexOf">Przykład: Zastosowanie <code>indexOf</code></h3>
+
+<p>Następujący przykład stosuje <code>indexOf</code> do znalezienia pierwszego wystąpienia elementów.</p>
+
+<pre class="brush: js">array = [2, 5, 9];
+index = array.indexOf(2);
+// index jest 0
+index = array.indexOf(7);
+// index jest -1
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_w_tablicy" name="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_w_tablicy">Przykład: Wyszukiwanie wszystkich wystąpień w tablicy</h3>
+
+<p>Poniższy przykład używa <code>indexOf</code> do znalezienia wszystkich wystąpień elementu w tablicy oraz dodaje ich indeksy do drugiej tablicy używając metody {{jsxref("Array.prototype.push()")}}.</p>
+
+<pre class="brush: js">indices = [];
+idx = array.indexOf(element)
+while (idx != -1) {
+   indices.push(idx);
+   idx = array.indexOf(element, idx + 1);
+}
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.indexOf()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/isarray/index.html b/files/pl/web/javascript/reference/global_objects/array/isarray/index.html
new file mode 100644
index 0000000000..2abef7d8b6
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/isarray/index.html
@@ -0,0 +1,140 @@
+---
+title: Array.isArray()
+slug: Web/JavaScript/Reference/Global_Objects/Array/isArray
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/isArray
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Podsumowanie</h2>
+
+<p><strong>Array.isArray()</strong> to metoda, która zwraca <code style="font-style: normal; line-height: 23.3333339691162px;">true</code><span style="line-height: 23.3333339691162px;"> </span> jeśli obiekt jest tablicą, fałsz jeśli nie jest.</p>
+
+<h2 id="Syntax" name="Syntax">Składnia</h2>
+
+<pre class="syntaxbox"><code>Array.isArray(<var>obj</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parametry</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>Obiekt do sprawdzenia</dd>
+</dl>
+
+<h2 id="Description" name="Description">Opis</h2>
+
+<p>Zobacz artykuł  <a href="http://web.mit.edu/jwalden/www/isArray.html">“Determining with absolute accuracy whether or not a JavaScript object is an array”</a> , aby poznać więcej szczegółów.</p>
+
+<h2 id="Examples" name="Examples">Przykłady</h2>
+
+<pre class="brush: js">// poniższe przykłady zwrócą true
+Array.isArray([]);
+Array.isArray([1]);
+Array.isArray(new Array());
+// Mało znany fakt: Array.prototype sam w sobie jest tablicą:
+Array.isArray(Array.prototype);
+
+// poniższe przykłady zwrócą false
+Array.isArray();
+Array.isArray({});
+Array.isArray(null);
+Array.isArray(undefined);
+Array.isArray(17);
+Array.isArray('Array');
+Array.isArray(true);
+Array.isArray(false);
+Array.isArray({ __proto__: Array.prototype });
+</pre>
+
+<h2 id="Polyfill" name="Polyfill">Dostępność wsteczna</h2>
+
+<p>Jeśli metody <span style="font-family: consolas,monaco,andale mono,monospace; line-height: 23.3333339691162px;">Array.isArray() nie jest natywnie dostępna, poniższy kod ją utworzy.</span></p>
+
+<pre class="brush: js">if (!Array.isArray) {
+  Array.isArray = function(arg) {
+    return Object.prototype.toString.call(arg) === '[object Array]';
+  };
+}
+</pre>
+
+<h2 id="Specifications" name="Specifications">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Wstępna definicja. Implementacja od  JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Zgodność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("10.5")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("2.0")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>Based on <a href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p>
+
+<h2 id="See_also" name="See_also">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Array", "Array")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/join/index.html b/files/pl/web/javascript/reference/global_objects/array/join/index.html
new file mode 100644
index 0000000000..cd1d7f8a7b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/join/index.html
@@ -0,0 +1,51 @@
+---
+title: Array.prototype.join()
+slug: Web/JavaScript/Reference/Global_Objects/Array/join
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/join
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/join
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Łączy wszystkie elementy tablicy w jeden łańcuch znaków.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var> = <var>arr</var>.join([<var>separator</var> = ','])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>separator</code> </dt>
+ <dd>Określa łańcuch znaków użyty do oddzielenia każdego z elementów tablicy. W razie konieczności separator jest konwertowany do łańcucha znaków. Jeśli parametr zostanie pominięty, elementy tablicy będą rozdzielone za pomocą przecinka.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>join</code> zmienia w łańcuchy znaków wszystkie elementy tablicy i łączy je w jeden łańcuch znaków.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_.C5.81.C4.85czenie_tablicy_na_trzy_r.C3.B3.C5.BCne_sposoby" name="Przyk.C5.82ad:_.C5.81.C4.85czenie_tablicy_na_trzy_r.C3.B3.C5.BCne_sposoby">Przykład: Łączenie tablicy na trzy różne sposoby</h3>
+
+<p>Poniższy przykład tworzy trzyelementową tablicę <code>a</code> zawierającą trzy elementy, następnie trzykrotnie łączy ją: używając domyślnego separatora, przecinka i spacji oraz znaku plus.</p>
+
+<pre class="brush: js">var a = new Array("Wiatr","Deszcz","Ogień");
+var myVar1 = a.join()      // przypisuje "Wiatr,Deszcz,Ogień" do myVar1
+var myVar2 = a.join(", ")  // przypisuje "Wiatr, Deszcz, Ogień" do myVar2
+var myVar3 = a.join(" + ") // przypisuje "Wiatr + Deszcz + Ogień" do myVar3
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.split()")}}</li>
+ <li>{{jsxref("Array.prototype.toString()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.join()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/keys/index.html b/files/pl/web/javascript/reference/global_objects/array/keys/index.html
new file mode 100644
index 0000000000..a284253ed6
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/keys/index.html
@@ -0,0 +1,121 @@
+---
+title: Array.prototype.keys()
+slug: Web/JavaScript/Reference/Global_Objects/Array/keys
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/keys
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>keys()</strong></code> zwraca nowy obiekt typu <code><strong>Array Iterator</strong></code> zawierający indeksy kolejnych elementów tablicy.</p>
+
+<pre class="brush: js">var arr = ['a', 'b', 'c'];
+var iterator = arr.keys();
+
+console.log(iterator.next()); // { value: 0, done: false }
+console.log(iterator.next()); // { value: 1, done: false }
+console.log(iterator.next()); // { value: 2, done: false }
+console.log(iterator.next()); // { value: undefined, done: true }
+</pre>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><var>arr</var>.keys()</pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Nowy iterator dla typu {{jsxref("Array")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Iterator_nie_ignoruje_dziur">Iterator nie ignoruje dziur</h3>
+
+<pre class="brush: js">var arr = ['a', , 'c'];
+var sparseKeys = Object.keys(arr);
+var denseKeys = [...arr.keys()];
+console.log(sparseKeys); // ['0', '2']
+console.log(denseKeys);  // [0, 1, 2]
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Pierwsze wystąpienie.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Edge</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("38")}}</td>
+   <td>{{CompatGeckoDesktop("28")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("25")}}</td>
+   <td>{{CompatSafari("7.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("28")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8.0</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.values()")}}</li>
+ <li>{{jsxref("Array.prototype.entries()")}}</li>
+ <li>{{jsxref("Iteration_protocols", "Iteratory")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/pl/web/javascript/reference/global_objects/array/lastindexof/index.html
new file mode 100644
index 0000000000..ca02035c96
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/lastindexof/index.html
@@ -0,0 +1,115 @@
+---
+title: Array.prototype.lastIndexOf()
+slug: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/lastIndexOf
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca ostatni indeks, pod którym podany element może być znaleziony w tablicy, lub -1 jeśli nie jest obecny. Tablica jest przeszukiwana od końca, zaczynając od indeksu <code>fromIndex</code></p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.lastIndexOf(<var>searchElement</var>[, <var>fromIndex</var> = arr.length])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>searchElement</code></dt>
+ <dd>Element do znalezienia w tablicy.</dd>
+ <dt><code>fromIndex</code></dt>
+ <dd>Indeks od którego ma zostać rozpoczęte wyszukiwanie od tyłu. Domyślnie jest to długość tablicy, tzn. przeszukana zostanie cała tablica. Jeśli indeks jest większy od lub równy długości tablicy, przeszukana zostanie cała tablica. Jeśli jest ujemny, traktowany będzie jako przesunięcie od końca tablicy. Należy pamiętać, że nawet jeśli indeks jest ujemny, to i tak tablica przeszukiwana jest od końca do początku. Jeśli obliczony indeks jest mniejszy od 0, zwracana jest wartość -1, innymi słowy, tablica nie zostanie przeszukana.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>lastIndexOf</code> porównuje <code>searchElement</code> z elementami tablicy używając <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_por%c3%b3wnania#.22U.C5.BCywanie_operator.C3.B3w_por.C3.B3wnania">ścisłego porównania</a> (podobnie jak w przypadku operatora ===).</p>
+
+<h3 id="Kompatybilno.C5.9B.C4.87" name="Kompatybilno.C5.9B.C4.87">Kompatybilność</h3>
+
+<p><code>lastIndexOf</code> jest rozszerzeniem JavaScript dla standardu ECMA-262, więc może nie być obecny w innych implementacjach tego standardu. Można to obejść, dopisując poniższy kod na początku skryptu, zezwalający na użycie <code>lastIndexOf</code> w implementacji ECMA-262, które nie wspierają tego natywnie.</p>
+
+<pre class="brush: js">if (!Array.prototype.lastIndexOf)
+{
+  Array.prototype.lastIndexOf = function(elt /*, from*/)
+  {
+    var len = this.length;
+
+    var from = Number(arguments[1]);
+    if (isNaN(from))
+    {
+      from = len - 1;
+    }
+    else
+    {
+      from = (from &lt; 0)
+           ? Math.ceil(from)
+           : Math.floor(from);
+      if (from &lt; 0)
+        from += len;
+      else if (from &gt;= len)
+        from = len - 1;
+    }
+
+    for (; from &gt; -1; from--)
+    {
+      if (from in this &amp;&amp;
+          this[from] === elt)
+        return from;
+    }
+    return -1;
+  };
+}
+</pre>
+
+<p>Należy zwrócić uwagę, że ta implementacja ma na celu całkowitą zgodność z <code>lastIndexOf</code> występującą w Firefoksie i silniku JavaScript SpiderMonkey, włączając w to przypadki skrajne. Jeśli masz zamiar wykorzystać przytoczone rozwiązanie w rzeczywistych aplikacjach, możesz obliczyć <code>from</code> za pomocą mniej skomplikowanego kodu (z pominięciem części instrukcji warunkowych).</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_lastIndexOf" name="Przyk.C5.82ad:_Zastosowanie_lastIndexOf">Przykład: Zastosowanie <code>lastIndexOf</code></h3>
+
+<p>Poniższy przykład używa <code>lastIndexOf</code> do znalezienia określonych wartości w tablicy.</p>
+
+<pre class="brush: js">array = [2, 5, 9, 2];
+index = array.lastIndexOf(2);
+// index is 3
+index = array.lastIndexOf(7);
+// index is -1
+index = array.lastIndexOf(2, 3);
+// index is 3
+index = array.lastIndexOf(2, 2);
+// index is 0
+index = array.lastIndexOf(2, -2);
+// index is 0
+index = array.lastIndexOf(2, -1);
+// index is 3
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_danego_elementu" name="Przyk.C5.82ad:_Wyszukiwanie_wszystkich_wyst.C4.85pie.C5.84_danego_elementu">Przykład: Wyszukiwanie wszystkich wystąpień danego elementu</h3>
+
+<p>Poniższy przykład używa <code>lastIndexOf</code> do znalezienia wszystkich wystąpień elementu w tablicy oraz dodaje ich indeksy do drugiej tablicy używając metody <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Array/push">push</a></code>.</p>
+
+<pre class="brush: js">indices = [];
+idx = array.lastIndexOf(element)
+while (idx != -1) {
+   indices.push(idx);
+   idx = (idx &gt; 0 ? array.lastIndexOf(element, idx - 1) : -1);
+}
+</pre>
+
+<p>Warto zauważyć, że obsłużyliśmy warunek <code>idx == 0</code> oddzielnie, ponieważ element ten zostanie zawsze odnaleziony - bez względu na wartość parametru <code>fromIndex</code> - w przypadku gdy jest on pierwszym elementem tablicy. To różni tę metodę od metody {{jsxref("Array.prototype.indexOf()")}}.</p>
+
+<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3>
+
+<ul>
+ <li>{{jsxref("Array.prototype.indexOf()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.lastIndexOf()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/length/index.html b/files/pl/web/javascript/reference/global_objects/array/length/index.html
new file mode 100644
index 0000000000..520bff2ab7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/length/index.html
@@ -0,0 +1,54 @@
+---
+title: Array.prototype.length
+slug: Web/JavaScript/Reference/Global_Objects/Array/length
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/length
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/length
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>32-bitowa liczba całkowita bez znaku określająca liczbę elementów w tablicy.</p>
+
+<div>{{js_property_attributes(1, 0, 0)}}</div>
+
+<div>
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.length</code></pre>
+</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartością własności <code>length</code> jest dodatnia liczba całkowita mniejsza niż 2 do potęgi 32 (2<sup>32</sup>).</p>
+
+<p>W dowolnej chwili możesz ustalić wartość <code>length</code> w celu zmniejszenia rozmiaru tablicy. Ustawienie wartości <code>length</code> na większą niż rozmiar tablicy nie zwiększy liczby elementów, np. jeżeli ustawisz <code>length</code> na 3, podczas gdy obecną wartością jest liczba 2, tablica nadal będzie zawierać tylko 2 elementy.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Iteracja_przez_wszystkie_elementy_tablicy" name="Przyk.C5.82ad:_Iteracja_przez_wszystkie_elementy_tablicy">Przykład: Iteracja przez wszystkie elementy tablicy</h3>
+
+<p>W poniższym przykładzie ilość elementów w tablicy <code>numbers</code> jest określana w instrukcji iteracyjnej na podstawie wartości <code>length</code>, następnie wartość każdego elementu jest podwajana.</p>
+
+<pre class="brush: js">var numbers = [1,2,3,4,5];
+for (var i = 0; i &lt; numbers.length; i++) {
+  numbers[i] *= 2;
+}
+// zawartość tablicy to teraz [2,4,6,8,10];
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Skracanie_tablicy" name="Przyk.C5.82ad:_Skracanie_tablicy">Przykład: Skracanie tablicy</h3>
+
+<p>Poniższy przykład zmniejsza rozmiar tablicy <code>statesUS</code> do 50, jeżeli przekracza on tę wartość.</p>
+
+<pre class="brush: js">if (statesUS.length &gt; 50) {
+   statesUS.length=50
+}
+</pre>
+
+<div class="noinclude"> </div>
diff --git a/files/pl/web/javascript/reference/global_objects/array/map/index.html b/files/pl/web/javascript/reference/global_objects/array/map/index.html
new file mode 100644
index 0000000000..41e1f41bbd
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/map/index.html
@@ -0,0 +1,94 @@
+---
+title: Array.prototype.map()
+slug: Web/JavaScript/Reference/Global_Objects/Array/map
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/map
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>map()</strong></code> tworzy nową tablicę zawierającą wyniki wywoływania podanej funkcji dla każdego elementu wywołującej tablicy.</p>
+
+<pre class="brush: js">var liczby = [1, 5, 10, 15];
+var podwojenia = liczby.map(function(x) {
+    return x * 2;
+});
+// podwojenia to teraz [2, 10, 20, 30]
+// liczby to dalej [1, 5, 10, 15]
+
+var liczby = [1, 4, 9];
+var pierwiastki = liczby.map(Math.sqrt);
+// pierwiastki to teraz [1, 2, 3]
+// liczby to dalej [1, 4, 9]
+</pre>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>var new_array = arr</var>.map(<var>function callback(currentValue, index, array){ // Zwróć element nowej tablicy }</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code><strong>callback</strong></code></dt>
+ <dd>Funkcja tworząca element nowej tablicy, przyjmująca trzy argumenty:</dd>
+ <dd>
+ <dl>
+  <dt><code><strong>currentValue</strong></code></dt>
+  <dd>Element tablicy nad którym obecnie pracujemy</dd>
+  <dt><code><strong>index</strong></code></dt>
+  <dd>Indeks elementu tablicy nad którym obecnie pracujemy</dd>
+  <dt><code><strong>array</strong></code></dt>
+  <dd>Oryginalna tablica na rzecz której wywołano metodę <code>map</code></dd>
+ </dl>
+ </dd>
+ <dt><code><strong>thisArg</strong></code></dt>
+ <dd>Opcjonalny. Wartość jaką użyć jako <code>this</code> podczas wywołania <code>callback</code></dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Nowa tablica zawierająca elementy będące wynikami wywoływani funkcji <code>callback</code>.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p><code>map</code> wykonuje funkcję (<code>callback</code>) raz na każdym z elementów tablicy w kolejności i tworzy nową tablicę na podstawie wyników. <code>callback</code> wywoływany jest tylko dla indeksów tablicy które mają przypisane wartości, włącznie z <a href="/pl/docs/Web/JavaScript/Referencje/Obiekty/undefined">undefined</a>. Nie jest wywoływany dla brakujących elementów tablicy (indeksów które nigdy nie były ustawione, usunięte lub nie miały nigdy przypisanych wartości).</p>
+
+<p><code>callback</code> wywoływana jest z trzema argumentami: wartością elementu, jego indeksem i tablicą która jest trawersowana.</p>
+
+<p>W przypadku podania argumentu <code>thisObject</code>, zostanie on przekazany jako <code>this</code> przy każdym wywołaniu <code>callback</code>. Gdy go brak, lub ma wartość <code>null</code>, użyty zostanie obiekt globalny przyporządkowany do <code>callback</code>.</p>
+
+<p><code>map</code> nie modyfikuje tablicy, na której jest wywołany.</p>
+
+<p>Zakres elementów przetwarzanych przez <code>map</code> ustalany jest przed pierwszym wywołaniem <code>callback</code>. Elementy dodane do tablicy po wywołaniu <code>map</code> nie zostaną odwiedzone przez <code>callback</code>. Jeśli istniejący, element tablicy zostanie zmieniony lub usunięty, wartością przekazaną do <code>callback</code> będzie wartość z momentu w którym <code>map</code> odwiedza dany element; elementy usunięte przed sprawdzeniem będą przekazane jako <code>undefined</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Wielkie_litery_.C5.82a.C5.84cuch.C3.B3w_w_tablicy" name="Przyk.C5.82ad:_Wielkie_litery_.C5.82a.C5.84cuch.C3.B3w_w_tablicy">Wielkie litery łańcuchów w tablicy</h3>
+
+<p>Poniższy kod tworzy nową tablicę zawierającą pisaną wielkimi literami wersję wszystkich oryginalnych łańcuchów.</p>
+
+<pre class="brush: js">var strings = ["hello", "Array", "WORLD"];
+function makeUpperCase(v)
+{
+    return v.toUpperCase();
+}
+var uppers = strings.map(makeUpperCase);
+// uppers są teraz pisane wielkimi literami ["HELLO", "ARRAY", "WORLD"]
+// strings są niezmienione
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Mapowanie_tablicy_liczb_do_tablicy_pierwiastk.C3.B3w_kwadratowych" name="Przyk.C5.82ad:_Mapowanie_tablicy_liczb_do_tablicy_pierwiastk.C3.B3w_kwadratowych">Mapowanie tablicy liczb do tablicy pierwiastków kwadratowych</h3>
+
+<p>Poniższy kod pobiera tablicę liczb i tworzy nową tablicę z pierwiastkami kwadratowymi liczb z pierwszej tablicy.</p>
+
+<pre class="brush: js">var liczby = [1, 4, 9];
+var pierwiastki = liczby.map(Math.sqrt);
+// otrzymane pierwiastki [1, 2, 3]
+// pozostające nadal liczby [1, 4, 9]
+</pre>
+
+<p> </p>
diff --git a/files/pl/web/javascript/reference/global_objects/array/of/index.html b/files/pl/web/javascript/reference/global_objects/array/of/index.html
new file mode 100644
index 0000000000..8a7273148c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/of/index.html
@@ -0,0 +1,93 @@
+---
+title: Array.of()
+slug: Web/JavaScript/Reference/Global_Objects/Array/of
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/of
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/of
+---
+<div>{{JSRef}}</div>
+
+<p><code><font face="Verdana, arial, x-locale-body, sans-serif"><span style="background-color: #ffffff;">Metoda </span></font><strong>Array.of()</strong></code> tworzy nową instancję obiektu <code>Array</code>, która zawiera w sobie wszystkie argumenty przekazane do funkcji, niezależnie od ich liczby i typu.</p>
+
+<p>Różnica pomiędzy <code><strong>Array.of()</strong></code> i konstruktorem <code><strong>Array</strong></code> polega na różnej interpretacji argumentów - <code><strong>Array.of(7)</strong></code> tworzy nową tablicę z jednym elementem(<code>7</code>), gdzie <code><strong>Array(7)</strong></code> tworzy nową tablicę z właściwością <code>length</code> ustawioną na 7 (<strong>Notatka:</strong> Oznacza to tablicę z <code>7</code> wolnymi miejscami, nie miejscami z wartościami <code>undefined</code>).</p>
+
+<pre class="brush: js">Array.of(7);       // [7]
+Array.of(1, 2, 3); // [1, 2, 3]
+
+Array(7);          // [ , , , , , , ]
+Array(1, 2, 3);    // [1, 2, 3]
+</pre>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">Array.of(<var>element0</var>[, <var>element1</var>[, ...[, <var>elementN</var>]]])</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>element<em>N</em></code></dt>
+ <dd>Elementy, które tworzą tablicę.</dd>
+</dl>
+
+<h3 id="Wartość_zwracana">Wartość zwracana</h3>
+
+<p>Nowa instancja obiektu {{jsxref("Array")}}.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Ta funkcja jest częścią standardu ECMAScript 2015. Po więcej informacji zobacz <a href="https://gist.github.com/rwaldron/1074126"><code>Array.of</code> and <code>Array.from</code> proposal</a> i <a href="https://gist.github.com/rwaldron/3186576"><code>Array.of</code> polyfill</a>.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<pre class="brush: js">Array.of(1);         // [1]
+Array.of(1, 2, 3);   // [1, 2, 3]
+Array.of(undefined); // [undefined]
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Uruchomienie tego kodu przed innym stworzy <code>Array.of()</code> nawet jeśli nie jest ona dostępna natywnie.</p>
+
+<pre class="brush: js">if (!Array.of) {
+  Array.of = function() {
+    return Array.prototype.slice.call(arguments);
+  };
+}
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array.of', 'Array.of')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Początkowa definicja.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.of', 'Array.of')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Array.of")}}</p>
+</div>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+ <li>{{jsxref("Array.from()")}}</li>
+ <li>{{jsxref("TypedArray.of()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/pop/index.html b/files/pl/web/javascript/reference/global_objects/array/pop/index.html
new file mode 100644
index 0000000000..32c6f2d6dd
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/pop/index.html
@@ -0,0 +1,139 @@
+---
+title: Array.prototype.pop()
+slug: Web/JavaScript/Reference/Global_Objects/Array/pop
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Metodă
+  - Prototype
+  - Tablica
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/pop
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Usuwa ostatni element z tablicy zwracając go. Metoda ta zmienia długość tablicy.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.pop()</code></pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Ostatni element tablicy;<br>
+ Jeśli tablica jest pusta zwraca {{jsxref("undefined")}}</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Metoda pop usuwa ostatni element tablicy i zwraca tę wartość.</p>
+
+<p><code>pop</code> is intentionally generic. Metoda ta może być {{jsxref("Function.call", "called", "", 1)}} lub {{jsxref("Function.apply", "applied", "", 1)}} do obiektu przypominającego tablice. Obiekty, które nie posiadają właściwości <code>length</code> odzwierciedlającej ostani element w serii, przy właściwościach liczonych od zera nie mogą zachowywać się w żaden znaczący sposób.</p>
+
+<p>Jeśli zawołasz  <code>pop()</code> na pustej tablicy, zwróci ona {{jsxref("undefined")}}.</p>
+
+<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2>
+
+<h3 id="Przyk.C5.82ad:_Usuwanie_ostatniego_elementu_tablicy" name="Przyk.C5.82ad:_Usuwanie_ostatniego_elementu_tablicy">Przykład: Usuwanie ostatniego elementu tablicy</h3>
+
+<p>Następujący kod tworzy tablicę <code>myFish</code> zawierającą cztery elementy, a następnie usuwa ostatni jej element.</p>
+
+<pre><code>var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+
+console.log(myFish); // ['angel', 'clown', 'mandarin', 'sturgeon']
+
+var popped = myFish.pop();
+
+console.log(myFish); // ['angel', 'clown', 'mandarin' ]
+
+console.log(popped); // 'sturgeon'</code></pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table>
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<table>
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("1.0")}}</td>
+   <td>{{CompatGeckoDesktop("1.7")}}</td>
+   <td>{{CompatIE("5.5")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<table>
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.push()")}}</li>
+ <li>{{jsxref("Array.prototype.shift()")}}</li>
+ <li>{{jsxref("Array.prototype.unshift()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/push/index.html b/files/pl/web/javascript/reference/global_objects/array/push/index.html
new file mode 100644
index 0000000000..ad55ffe255
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/push/index.html
@@ -0,0 +1,52 @@
+---
+title: Array.prototype.push()
+slug: Web/JavaScript/Reference/Global_Objects/Array/push
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/push
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/push
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Dodaje jeden lub więcej elementów na koniec tablicy i zwraca jej nową długość. Metoda ta zmienia długość tablicy.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.push(<var>element1</var>, ..., <var>elementN</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>element
+ <i>N</i>
+ </code> </dt>
+ <dd>Elementy dodawane na końcu tablicy.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Zachowanie metody <code>push</code> jest analogiczne do funkcji <code>push</code> w języku Perl 4. Uwaga: jej zachowanie różni się w języku Perl 5.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy" name="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy">Przykład: Dodawanie elementów do tablicy</h3>
+
+<p>Następujący kod tworzy tablicę <code>myFish</code> zawierającą dwa elementy, następnie dodaje do niej dwa kolejne. Po wykonaniu kodu, <code>pushed</code> zawiera wartość 4 (w JavaScript 1.2 po wykonaniu kodu zmienna <code>pushed</code> zawiera wartość "lew").</p>
+
+<pre class="brush: js">myFish = ["anioł", "klaun"];
+pushed = myFish.push("bęben", "lew");
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.pop()")}}</li>
+ <li>{{jsxref("Array.prototype.shift()")}}</li>
+ <li>{{jsxref("Array.prototype.unshift()")}}</li>
+ <li>{{jsxref("Array.prototype.concat()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/reduce/index.html b/files/pl/web/javascript/reference/global_objects/array/reduce/index.html
new file mode 100644
index 0000000000..f98d5375c3
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/reduce/index.html
@@ -0,0 +1,301 @@
+---
+title: Array.prototype.reduce()
+slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/Reduce
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Podsumowanie</h2>
+
+<p><code><font face="Open Sans, Arial, sans-serif">Metoda </font><strong>reduce()</strong></code> wywołuje funkcję względem wartości przyrostowej z każdego wywołania i kolejnego elementu tablicy (od lewej do prawej) w celu sprowadzenia tej tablicy do pojedynczej wartości.</p>
+
+<h2 id="Syntax" name="Syntax">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])</var></code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Funkcja wykonywana na każdej wartości w tablicy, przyjmuje cztery argumenty:
+ <dl>
+  <dt><code>previousValue</code></dt>
+  <dt></dt>
+  <dd>Wartość zwróconą w ostatnim wywołaniu funkcji <code>callback</code>, lub <code>initialValue</code>, jeśli ta została dostarczona. (Patrz niżej.)</dd>
+  <dt><code>currentValue</code></dt>
+  <dd>Obecnie przetwarzany element w tablicy.</dd>
+  <dt><code>index</code></dt>
+  <dd>Indeks w tablicy obecnie przetwarzanego elementu.</dd>
+  <dt><code>array</code></dt>
+  <dd>Tablica, na której została wykonana funkcja <code>reduce</code> .</dd>
+ </dl>
+ </dd>
+ <dt><code>initialValue</code></dt>
+ <dd>Opcjonalne. Obiekt który będzie użyty jako pierwszy argument pierwszego wywołania funkcji <code>callback</code>.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Opis</h2>
+
+<p><code>reduce</code> wykonuje funkcję <code>callback</code> raz dla każdego elementu występującego w tablicy, wyłączając dziury. Funkcja <code>callback</code> przyjmuje cztery argumenty: wartość początkową (lub wartość poprzedniego wywołania <code>callback)</code>, wartość obecnego elementu, jego indeks, oraz tablicę na której zachodzi proces iteracji.</p>
+
+<p>Przy pierwszym wywołaniu funkcji <code>callback, previousValue</code> oraz <code>currentValue</code> mogą przyjąć jedną z dwóch wartości. Jeżeli <code>initialValue</code> było dostarczone w wywołaniu, wtedy <code>previousValue</code> przyjmie wartość podaną jako <code>initialValue</code>, natomiast <code>currentValue</code> przyjmie wartość pierwszego elementu tablicy. Jeśli <code>initialValue</code> nie było podane, wtedy <code>previousValue</code> będzie miało wartość pierwszego elementu tablicy, natomiast <code>currentValue</code> będzie równe elementowi drugiemu.</p>
+
+<p>Jeżeli tablica jest pusta oraz <code>initialValue</code> nie zostało dostarczone, będzie rzucony błąd {{jsxref("Global_Objects/TypeError", "TypeError")}}. Jeśli natomiast tablica ma jeden tylko element (bez względu na jego pozycję) i <code>initialValue</code> nie zostało podane, lub dostarczono <code>initialValue</code>, ale tablica jest pusta, wtedy ta jedyna wartość zostanie zwrócona, bez wywoływania funkcji <code>callback</code>.</p>
+
+<p>Przyjmijmy, że wystąpiło następujące wywolanie funkcji <code>reduce</code>:</p>
+
+<pre class="brush: js">[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+});
+</pre>
+
+<p>Funkcja callback będzie wywołana cztery razy, z argumentami i wartościami zwrotnymi przy każdym wołaniu jak następuje:</p>
+
+<table style="width: 100%;">
+ <thead>
+  <tr>
+   <th scope="col"></th>
+   <th scope="col"><code>previousValue</code></th>
+   <th scope="col"><code>currentValue</code></th>
+   <th scope="col"><code>index</code></th>
+   <th scope="col"><code>array</code></th>
+   <th scope="col">wartość zwracana</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <th scope="row">pierwsze wywołanie</th>
+   <td><code>0</code></td>
+   <td><code>1</code></td>
+   <td><code>1</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>1</code></td>
+  </tr>
+  <tr>
+   <th scope="row">drugie wywołanie</th>
+   <td><code>1</code></td>
+   <td><code>2</code></td>
+   <td><code>2</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>3</code></td>
+  </tr>
+  <tr>
+   <th scope="row">trzecie wywołanie</th>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>6</code></td>
+  </tr>
+  <tr>
+   <th scope="row">czwarte wywołanie</th>
+   <td><code>6</code></td>
+   <td><code>4</code></td>
+   <td><code>4</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>10</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Wartość zwrócona ostatecznie przez <code>reduce</code> będzie tą z ostatniego wywołania funcji callback (<code>10</code>).</p>
+
+<p>Natomiast, jeśli dostarczylibyśmy wartość początkową jako drugi argument funkcji przekazanej do <code>reduce</code>, wynik wyglądałby jak poniżej:</p>
+
+<pre class="brush: js">[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+}, 10);
+</pre>
+
+<table style="width: 100%;">
+ <thead>
+  <tr>
+   <th scope="col"></th>
+   <th scope="col"><code>previousValue</code></th>
+   <th scope="col"><code>currentValue</code></th>
+   <th scope="col"><code>index</code></th>
+   <th scope="col"><code>array</code></th>
+   <th scope="col">wartość zwracana</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <th scope="row">pierwsze wywołanie</th>
+   <td><code>10</code></td>
+   <td><code>0</code></td>
+   <td><code>0</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>10</code></td>
+  </tr>
+  <tr>
+   <th scope="row">drugie wywołanie</th>
+   <td><code>10</code></td>
+   <td><code>1</code></td>
+   <td><code>1</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>11</code></td>
+  </tr>
+  <tr>
+   <th scope="row">trzecie wywołanie</th>
+   <td><code>11</code></td>
+   <td><code>2</code></td>
+   <td><code>2</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>13</code></td>
+  </tr>
+  <tr>
+   <th scope="row">czwarte wywołanie</th>
+   <td><code>13</code></td>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>16</code></td>
+  </tr>
+  <tr>
+   <th scope="row">piąte wywołanie</th>
+   <td><code>16</code></td>
+   <td><code>4</code></td>
+   <td><code>4</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>20</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Tym razem wartość zwrócona przez <code>reduce</code> będzie wynosiła <code>20</code>.</p>
+
+<h2 id="Examples" name="Examples">Przykłady</h2>
+
+<h3 id="Example_Sum_up_all_values_within_an_array" name="Example:_Sum_up_all_values_within_an_array">Przykład: Zsumowanie wszystkich wartości w tablicy.</h3>
+
+<pre class="brush: js">var total = [0, 1, 2, 3].reduce(function(a, b) {
+  return a + b;
+});
+// total == 6
+</pre>
+
+<h3 id="Example_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Przykład: Spłaszczenie tablicy tablic</h3>
+
+<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
+  return a.concat(b);
+});
+// flattened is [0, 1, 2, 3, 4, 5]
+</pre>
+
+<h2 id="Polyfill" name="Polyfill">Polyfill</h2>
+
+<p><code>Array.prototype.reduce</code> zostało dodane do standardu ECMA-262 w edycji piątej i jako takie może nie występować we wszystkich implementacji standardu. Można obejśc ten brak poprzez wstawienie poniższego kodu na początku skryptu, co pozwala na użycie <code>reduce</code> z implementacjami, które nie wspierają tej funkcji.</p>
+
+<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.21
+// Reference: http://es5.github.io/#x15.4.4.21
+if (!Array.prototype.reduce) {
+  Array.prototype.reduce = function(callback /*, initialValue*/) {
+    'use strict';
+    if (this == null) {
+      throw new TypeError('Array.prototype.reduce called on null or undefined');
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' is not a function');
+    }
+    var t = Object(this), len = t.length &gt;&gt;&gt; 0, k = 0, value;
+    if (arguments.length == 2) {
+      value = arguments[1];
+    } else {
+      while (k &lt; len &amp;&amp; !(k in t)) {
+        k++;
+      }
+      if (k &gt;= len) {
+        throw new TypeError('Reduce of empty array with no initial value');
+      }
+      value = t[k++];
+    }
+    for (; k &lt; len; k++) {
+      if (k in t) {
+        value = callback(value, t[k], k, t);
+      }
+    }
+    return value;
+  };
+}
+</pre>
+
+<h2 id="Specifications" name="Specifications">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Stan</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definicja początkowa. Wprowadzon w JavaScript 1.8.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Wspierane przeglądarki</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("1.9")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("10.5")}}</td>
+   <td>{{CompatSafari("4.0")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.reduceRight()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/reduceright/index.html b/files/pl/web/javascript/reference/global_objects/array/reduceright/index.html
new file mode 100644
index 0000000000..53e9a3d6b9
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/reduceright/index.html
@@ -0,0 +1,345 @@
+---
+title: Array.prototype.reduceRight()
+slug: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/ReduceRight
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>reduceRight()</strong></code> przekazuje do funkcji wartość przyrostową dla każdego elementu w tablicy zaczynając od prawej do lewej (od najwyższego indexu do najniższego) w celu sprowadzenia tablicy do pojedynczej wartości.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/array-reduce-right.html","shorter")}}</div>
+
+
+
+<p>Sprawdź również {{jsxref("Array.prototype.reduce()")}} dla redukowania tablicy od lewej do prawej (od najniższego indexu do najwyższego).</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><var>arr.reduceRight(callback(akumulator, obecnaWartość[, index[, tablica]])[, wartośćPoczątkowa])</var></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Funkcja która będzie wołana dla każdego elementu w tablicy, przyjmuje 4 argumenty:
+ <dl>
+  <dt><code>akumulator</code></dt>
+  <dd>Wartość zwrócona z poprzedniego wywołania funkcji <code>callback</code> lub <code>wartośćPoczątkowa</code>, jeśli została zdefiniowana. (Sprawdź poniżej.)</dd>
+  <dt><code>obecnaWartość</code></dt>
+  <dd>Element z tablicy, który aktualnie jest przetwarzany</dd>
+  <dt><code>index</code>{{optional_inline}}</dt>
+  <dd>Index aktualnie przetwarzanego elementu z tablicy.</dd>
+  <dt><code>tablica</code>{{optional_inline}}</dt>
+  <dd>Tablica, na której <code>reduceRight()</code> zostało zawołane.</dd>
+ </dl>
+ </dd>
+ <dt><code>wartośćPoczątkowa</code>{{optional_inline}}</dt>
+ <dd>Wartość, która zostanie użyta do pierwszego wykonania funkcji <code>callback</code>. Jeśli wartość ta nie zostanie zdefiniowana, ostatni element tablicy zostanie użyty i pominięty. Wołanie reduce lub reduceRight na pustej tablicy bez zdefiniowanej wartości początkowej spowoduje błąd <code>TypeError</code>.</dd>
+</dl>
+
+<h3 id="Wartość_zwracana">Wartość zwracana</h3>
+
+<p>Wartość wynikowa redukcji.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p><code>reduceRight</code> wykonuje funkcję <code>callback</code> dla każdego elementu z tablicy, z wyłączeniem miejsc niezdefiniowanych w tablicy, przekazując cztery argumenty: wartość początkową (lub wartość z poprzedniego wywołania funkcji <code>callback</code>), wartość obecnie przetwarzanego elementu, obecny index oraz tablicę na której wykonywane są iteracje.</p>
+
+<p>Użycie funkcji <code>callback</code> w metodzie reduceRight może wyglądac następująco:</p>
+
+<pre class="brush: js">array.reduceRight(function(akumulator, obecnaWartość, index, tablica) {
+  // ...
+});
+</pre>
+
+<p>Przy pierwszym wywołaniu funkcji, <code>akumulator</code> i <code>obecnaWartość</code> mogą mieć jedną z 2 wartości. Jeśli <code>wartośćPoczątkowa</code> została przekazana do <code>reduceRight</code>, to <code>akumulator</code> będzie równy <code>wartośćPoczątkowa</code> a <code>obecnaWartość</code> będzie równa ostatniej wartości z tablicy. Jeśli <code>wartośćPoczątkowa</code> nie została zdefiniowana, wtedy <code>akumulator</code> będzie równy ostatniej wartości z tablicy a <code>obecnaWartość</code> będzie równa przedostatniej wartości z tablicy.</p>
+
+<p>Jeśli tablica jest pusta i <code>wartośćPoczątkowa</code> nie została zdefiniowana, spowoduje to błąd: {{jsxref("TypeError")}}. Jeśli tablica ma tylko jeden element (niezależnie od jego pozycji) i <code>wartośćPoczątkowa</code> nie została zdefiniowana lub <code>wartośćPoczątkowa</code> została zdefiniowana ale tablica jest pusta, to ta pojedyncza wartość zostanie zwrócona bez wołania funkcji <code>callback</code>.</p>
+
+<p>Przykład pokazujący, jak przepływają dane do funkcji <code>callback</code>:</p>
+
+<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(akumulator, obecnaWartość, index, tablica) {
+  return akumulator + obecnaWartość;
+});
+</pre>
+
+<p>Funkcja <code>callback</code> wykona się 4 razy a argumenty wywołań oraz wartości zwracane będą zgodne z poniższą tabelą:</p>
+
+<table>
+ <thead>
+  <tr>
+   <th scope="col"><code>callback</code></th>
+   <th scope="col"><code>akumulator</code></th>
+   <th scope="col"><code>obecnaWartość</code></th>
+   <th scope="col"><code>index</code></th>
+   <th scope="col"><code>tablica</code></th>
+   <th scope="col">zwrócona wartość</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <th scope="row">first call</th>
+   <td><code>4</code></td>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>7</code></td>
+  </tr>
+  <tr>
+   <th scope="row">second call</th>
+   <td><code>7</code></td>
+   <td><code>2</code></td>
+   <td><code>2</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>9</code></td>
+  </tr>
+  <tr>
+   <th scope="row">third call</th>
+   <td><code>9</code></td>
+   <td><code>1</code></td>
+   <td><code>1</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>10</code></td>
+  </tr>
+  <tr>
+   <th scope="row">fourth call</th>
+   <td><code>10</code></td>
+   <td><code>0</code></td>
+   <td><code>0</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>10</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Wartość zwrócona przez <code>reduceRight</code> będzie tym, co zostało zwrócone przez ostatnie wywołanie funkcji <code>callback</code> (<code>10</code>).</p>
+
+<p>Jeśli <code>wartośćPoczątkowa</code> zostałaby zdefiniowana wyniki wyglądałyby następująco:</p>
+
+<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(akumulator, obecnaWartość, index, tablica) {
+  return akumulator + obecnaWartość;
+}, 10);
+</pre>
+
+<table>
+ <thead>
+  <tr>
+   <th scope="col"><code>callback</code></th>
+   <th scope="col"><code>akumulator</code></th>
+   <th scope="col"><code>obecnaWartość</code></th>
+   <th scope="col"><code>index</code></th>
+   <th scope="col"><code>tablica</code></th>
+   <th scope="col">zwrócona wartość</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <th scope="row">first call</th>
+   <td><code>10</code></td>
+   <td><code>4</code></td>
+   <td><code>4</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>14</code></td>
+  </tr>
+  <tr>
+   <th scope="row">second call</th>
+   <td><code>14</code></td>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>17</code></td>
+  </tr>
+  <tr>
+   <th scope="row">third call</th>
+   <td><code>17</code></td>
+   <td><code>2</code></td>
+   <td><code>2</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>19</code></td>
+  </tr>
+  <tr>
+   <th scope="row">fourth call</th>
+   <td><code>19</code></td>
+   <td><code>1</code></td>
+   <td><code>1</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>20</code></td>
+  </tr>
+  <tr>
+   <th scope="row">fifth call</th>
+   <td><code>20</code></td>
+   <td><code>0</code></td>
+   <td><code>0</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>20</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Wartość zwrócona przez <code>reduceRight</code> w tym przypadku, będzie, oczywiście, <code>20</code>.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Zsumuj_wszystkie_wartości_z_tablicy">Zsumuj wszystkie wartości z tablicy</h3>
+
+<pre class="brush: js">var sum = [0, 1, 2, 3].reduceRight(function(a, b) {
+  return a + b;
+});
+// sum is 6
+</pre>
+
+<h3 id="Spłaszcz_tablicę_tablic">Spłaszcz tablicę tablic</h3>
+
+<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
+    return a.concat(b);
+}, []);
+// flattened is [4, 5, 2, 3, 0, 1]
+
+</pre>
+
+<h3 id="Uruchom_asynchroniczne_funkcje_z_callbackami_z_listy_w_taki_sposób_aby_każda_przekazywała_wynik_wykonania_do_następnej">Uruchom asynchroniczne funkcje z callbackami z listy w taki sposób aby każda przekazywała wynik wykonania do następnej</h3>
+
+<pre class="brush: js">const waterfall = (...functions) =&gt; (callback, ...args) =&gt;
+  functions.reduceRight(
+    (composition, fn) =&gt; (...results) =&gt; fn(composition, ...results),
+    callback
+  )(...args);
+
+const randInt = max =&gt; Math.floor(Math.random() * max)
+
+const add5 = (callback, x) =&gt; {
+  setTimeout(callback, randInt(1000), x + 5);
+};
+const mult3 = (callback, x) =&gt; {
+  setTimeout(callback, randInt(1000), x * 3);
+};
+const sub2 = (callback, x) =&gt; {
+  setTimeout(callback, randInt(1000), x - 2);
+};
+const split = (callback, x) =&gt; {
+  setTimeout(callback, randInt(1000), x, x);
+};
+const add = (callback, x, y) =&gt; {
+  setTimeout(callback, randInt(1000), x + y);
+};
+const div4 = (callback, x) =&gt; {
+  setTimeout(callback, randInt(1000), x / 4);
+};
+
+const computation = waterfall(add5, mult3, sub2, split, add, div4);
+computation(console.log, 5) // -&gt; 14
+
+// same as:
+
+const computation2 = (input, callback) =&gt; {
+  const f6 = x=&gt; div4(callback, x);
+  const f5 = (x, y) =&gt; add(f6, x, y);
+  const f4 = x =&gt; split(f5, x);
+  const f3 = x =&gt; sub2(f4, x);
+  const f2 = x =&gt; mult3(f3, x);
+  add5(f2, input);
+}</pre>
+
+<h3 id="​​​​​​Różnica_pomiędzy_reduce_i_reduceRight">​​​​​​Różnica pomiędzy <code>reduce</code> i <code>reduceRight</code></h3>
+
+<pre class="brush: js">var a = ['1', '2', '3', '4', '5'];
+var left  = a.reduce(function(prev, cur)      { return prev + cur; });
+var right = a.reduceRight(function(prev, cur) { return prev + cur; });
+
+console.log(left);  // "12345"
+console.log(right); // "54321"</pre>
+
+<h3 id="Przykład_na_rozwijanie_funkcji">Przykład na rozwijanie funkcji</h3>
+
+<p>W rozwijaniu funkcji chodzi o to, że w wywołaniu jednej funkcji możemy użyć wielu funkcji. Odbywa się to od prawej do lewej, wołając każdą funkcję z wynikiem zwróconym przez poprzednią.</p>
+
+<pre class="brush: js">/**
+ * Function Composition is way in which result of one function can
+ * be passed to another and so on.
+ *
+ * h(x) = f(g(x))
+ *
+ * Function execution happens right to left
+ *
+ * https://en.wikipedia.org/wiki/Function_composition
+ */
+
+const compose = (...args) =&gt; (value) =&gt; args.reduceRight((acc, fn) =&gt; fn(acc), value)
+
+// Increment passed number
+const inc = (n) =&gt; n + 1
+
+// Doubles the passed value
+const double = (n) =&gt; n * 2
+
+// using composition function
+console.log(compose(double, inc)(2)); // 6
+
+// using composition function
+console.log(compose(inc, double)(2)); // 5
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p><code>reduceRight</code> zostało dodane dostandardu ECMA-262 w piątej edycji, w związku z czym może jeszcze nie być dodane do wszystkich implementacji standardu. Można to rozwiązać poprzez użycie poniższego kodu na początku aplikacji, pozwoli to na używanie <code>reduceRight</code> w środowiskach, które tego nie implementują.</p>
+
+<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.22
+// Reference: http://es5.github.io/#x15.4.4.22
+if ('function' !== typeof Array.prototype.reduceRight) {
+  Array.prototype.reduceRight = function(callback /*, initialValue*/) {
+    'use strict';
+    if (null === this || 'undefined' === typeof this) {
+      throw new TypeError('Array.prototype.reduce called on null or undefined');
+    }
+    if ('function' !== typeof callback) {
+      throw new TypeError(callback + ' is not a function');
+    }
+    var t = Object(this), len = t.length &gt;&gt;&gt; 0, k = len - 1, value;
+    if (arguments.length &gt;= 2) {
+      value = arguments[1];
+    } else {
+      while (k &gt;= 0 &amp;&amp; !(k in t)) {
+        k--;
+      }
+      if (k &lt; 0) {
+        throw new TypeError('Reduce of empty array with no initial value');
+      }
+      value = t[k--];
+    }
+    for (; k &gt;= 0; k--) {
+      if (k in t) {
+        value = callback(value, t[k], k, t);
+      }
+    }
+    return value;
+  };
+}
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Zgodność_w_przeglądarkach">Zgodność w przeglądarkach</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Array.reduceRight")}}</p>
+</div>
+
+<h2 id="Sprawdź_również">Sprawdź również</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.reduce()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/reverse/index.html b/files/pl/web/javascript/reference/global_objects/array/reverse/index.html
new file mode 100644
index 0000000000..6a18aa625c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/reverse/index.html
@@ -0,0 +1,56 @@
+---
+title: Array.prototype.reverse()
+slug: Web/JavaScript/Reference/Global_Objects/Array/reverse
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/reverse
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Odwraca kolejność elementów w tablicy: pierwszy staje się ostatnim, ostatni pierwszym.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.reverse()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>reverse</code> zmienia zawartość tablicy, odwracając kolejność jej elementów.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Odwracanie_kolejno.C5.9Bci_element.C3.B3w_w_tablicy" name="Przyk.C5.82ad:_Odwracanie_kolejno.C5.9Bci_element.C3.B3w_w_tablicy">Przykład: Odwracanie kolejności elementów w tablicy</h3>
+
+<p>Poniższy przykład tworzy tablicę mojaTablica, posiadającą trzy elementy, następnie odwraca ich kolejność.</p>
+
+<pre class="brush: js">mojaTablica = new Array("jeden", "dwa", "trzy")
+mojaTablica.reverse()
+</pre>
+
+<p>W wyniku działania powyższego kodu:</p>
+
+<ul>
+ <li><code>mojaTablica[0]</code> ma wartość "trzy"</li>
+ <li><code>mojaTablica[1]</code> ma wartość "dwa"</li>
+ <li><code>mojaTablica[2]</code> ma wartość "jeden"</li>
+</ul>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.join()")}}</li>
+ <li>{{jsxref("Array.prototype.sort()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.reverse()")}}</li>
+</ul>
+
+<div class="noinclude"> </div>
diff --git a/files/pl/web/javascript/reference/global_objects/array/shift/index.html b/files/pl/web/javascript/reference/global_objects/array/shift/index.html
new file mode 100644
index 0000000000..a83215d6c5
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/shift/index.html
@@ -0,0 +1,49 @@
+---
+title: Array.prototype.shift()
+slug: Web/JavaScript/Reference/Global_Objects/Array/shift
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/shift
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Usuwa pierwszy element z tablicy i zwraca go. Metoda ta zmienia długość tablicy.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.shift()</code></pre>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Usuwanie_pierwszego_elementu_tablicy" name="Przyk.C5.82ad:_Usuwanie_pierwszego_elementu_tablicy">Przykład: Usuwanie pierwszego elementu tablicy</h3>
+
+<p>Następujący kod wyświetli tablicę <code>myFish</code>, przed i po usunięciu jej pierwszego elementu. Wyświetli również usunięty element:</p>
+
+<pre class="brush: js">// przyjmując że funkcja print jest zdefiniowana
+var myFish = ["anioł", "klaun", "mandarynka", "chirurg"];
+console.log("myFish przed: " + myFish);
+var shifted = myFish.shift();
+console.log("myFish po: " + myFish);
+console.log("Usunięto element: " + shifted);
+</pre>
+
+<p>Przykład wyświetli następujący rezultat:</p>
+
+<pre class="brush: js">myFish przed: ["anioł", "klaun", "mandarynka", "chirurg"]
+myFish po: ["klaun", "mandarynka", "chirurg"]
+//Usunięto element: anioł
+</pre>
+
+<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3>
+
+<ul>
+ <li>{{jsxref("Array.prototype.push()")}}</li>
+ <li>{{jsxref("Array.prototype.pop()")}}</li>
+ <li>{{jsxref("Array.prototype.unshift()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/slice/index.html b/files/pl/web/javascript/reference/global_objects/array/slice/index.html
new file mode 100644
index 0000000000..5de5456984
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/slice/index.html
@@ -0,0 +1,100 @@
+---
+title: Array.prototype.slice()
+slug: Web/JavaScript/Reference/Global_Objects/Array/slice
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/slice
+---
+<p>{{ JSRef }}</p>
+
+<p>{{EmbedInteractiveExample("pages/js/array-slice.html")}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wydobywa fragment tablicy i zwraca go jako nową tablicę.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.slice([<var>begin</var>[, <var>end</var>]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>begin</code></dt>
+ <dd>Indeks (liczony od zera) od którego zaczyna się wydobywanie.</dd>
+ <dd>Jeżeli indeks jest ujemny, <code>begin</code> wskazuje przesunięcie w kolejności od końca. <code>slice(-2)</code> wydobywa kolejno drugi od końca i ostatni element tablicy.</dd>
+</dl>
+
+<dl>
+ <dt><code>end</code></dt>
+ <dd>Indeks (liczony od zera) przed którym kończy się wydobywanie. <code>slice</code> wydobywa elementy jednakże nie zawiera <code>end</code>.</dd>
+</dl>
+
+<dl>
+ <dd><code>slice(1,4)</code> wydobywa elementy od drugiego do czwartego (o indeksach 1, 2 i 3).</dd>
+</dl>
+
+<dl>
+ <dd>Jeżeli parametr ten ma wartość ujemną to <code>end</code> określa odległość od końca tablicy. <code>slice(2,-1)</code> wydobywa kolejne elementy od trzeciego do przedostatniego.</dd>
+</dl>
+
+<dl>
+ <dd>Jeżeli <code>end</code> jest pominięty, <code>slice</code> wydobywa wszystkie elementy do końca tablicy.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>slice</code> nie zmienia zawartości oryginalnej tablicy, tylko zwraca nową kopię "o jednym poziomie głębokości" zawierającą elementy wyciągnięte z oryginalnej tablicy. Elementy oryginalnej tablicy są kopiowane do nowej tablicy następująco:</p>
+
+<ul>
+ <li>W przypadku referencji do obiektów (nie obiektów właściwych), <code>slice</code> kopiuje referencje do nowej tablicy. Obydwie - oryginalna i nowa tablica - odnoszą się do tego samego obiektu. Jeżeli zmienimy obiekt odniesienia, zmiany są widoczne dla obydwu tablic, nowej i oryginalnej.</li>
+</ul>
+
+<ul>
+ <li>Dla łańcuchów znaków i liczb (nie będących obiektami {{jsxref("String")}} i {{jsxref("Number")}}, <code>slice</code> kopiuje łańcuchy znaków i liczby do nowej tablicy. Zmiana łańcucha znaków lub liczby w jednej z tablic nie wpływa na wartość w drugiej.</li>
+</ul>
+
+<p>Jeżeli nowy element jest dodany do jednej z tablic, to nie wpływa to w żaden sposób na drugą.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_slice" name="Przyk.C5.82ad:_Zastosowanie_slice">Przykład: Zastosowanie <code>slice</code></h3>
+
+<p>W następującym przykładzie <code>slice</code> tworzy nową tablicę <code>newCar</code> z <code>myCar</code>. Obydwie zawierają odniesienie do obiektu <code>myHonda</code>. Kiedy kolor <code>myHonda</code> jest zmieniany na purpurowy, to obie tablice odzwierciedlają zmianę.</p>
+
+<pre class="brush: js">//Użycie slice, tworzenie newCar z myCar.
+var myHonda = { color: "red", wheels: 4, engine: { cylinders: 4, size: 2.2 } };
+var myCar = [myHonda, 2, "cherry condition", "purchased 1997"];
+var newCar = myCar.slice(0, 2);
+
+//Wpisz wartości myCar, newCar i color myHonda
+//  referenced from both arrays.
+console.log("myCar = " + myCar.toSource());
+console.log("newCar = " + newCar.toSource());
+console.log("myCar[0].color = " + myCar[0].color);
+console.log("newCar[0].color = " + newCar[0].color);
+
+//zmienia kolor myHonda.
+myHonda.color = "purple";
+console.log("Nowy kolor mojej Honda to " + myHonda.color);
+
+//Wpisz color myHonda odnoszący się do oby tablic
+console.log("myCar[0].color = " + myCar[0].color);
+console.log("newCar[0].color = " + newCar[0].color);
+</pre>
+
+<p>Ten skrypt wypisze:</p>
+
+<pre class="brush: js">myCar = [{color:"red", wheels:4, engine:{cylinders:4, size:2.2}}, 2, "cherry condition", "purchased 1997"]
+newCar = [{color:"red", wheels:4, engine:{cylinders:4, size:2.2}}, 2]
+myCar[0].color = red
+newCar[0].color = red
+Nowym kolorem mojej Honda jest purpurowy
+myCar[0].color = purple
+newCar[0].color = purple
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/array/some/index.html b/files/pl/web/javascript/reference/global_objects/array/some/index.html
new file mode 100644
index 0000000000..c05147d8ae
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/some/index.html
@@ -0,0 +1,111 @@
+---
+title: Array.prototype.some()
+slug: Web/JavaScript/Reference/Global_Objects/Array/some
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/some
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/some
+---
+<p>{{ JSRef }}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Sprawdza, czy jakikolwiek element tablicy zalicza test zaimplementowany przez dostarczoną funkcję .</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.some(<var>callback</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>callback</code> </dt>
+ <dd>Funkcja sprawdzająca dla każdego elementu.</dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Obiekt do użycia jako <code>this</code> gdy wykonujemy funkcję <code>callback</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>some</code> wykonuje funkcję <code>callback</code>) na każdym elemencie tablicy, aż znajdzie taki, dla którego <code>callback</code> zwróci prawdę (<code>true</code>). Jeżeli taki element zostanie znaleziony, <code>some</code> zakończy swoje działanie i zwróci prawdę (<code>true</code>), w przeciwnym przypadku (gdy <code>callback</code> zwróci fałsz dla każdego z elementów) <code>some</code> zwróci <code>false</code>. Tablice nie są traktowane jako "zwarte" - czyli <code>callback</code> zostanie wywołany dla każdego indeksu tablicy dla którego wartość została przypisana. Nie zostanie wywołany dla indeksów, które zostały usunięte, bądź dla których nigdy nie została przypisana wartość.</p>
+
+<p><code>callback</code> wywoływana jest z trzema argumentami: wartością elementu, jego indeksem i przemierzaną tablicą.</p>
+
+<p>W przypadku podania argumentu <code>thisObject</code>, zostanie on przekazany jako <code>this</code> przy każdym wywołaniu <code>callback</code>. Gdy go brak, lub ma wartość <code>null</code>, użyty zostanie obiekt globalny przyporządkowany do <code>callback</code>.</p>
+
+<p><code>some</code> nie modyfikuje tablicy, na której jest wywołany.</p>
+
+<p>Zakres elementów przetwarzanych przez <code>some</code> ustalany jest przed pierwszym wywołaniem <code>callback</code>. Elementy dodane do tablicy po wywołaniu <code>some</code> nie zostaną sprawdzone przez <code>callback</code>. Jeśli istniejący, niesprawdzony jeszcze element tablicy zostanie zmieniony lub usunięty przez <code>callback</code>, wartością przekazaną do <code>callback</code> będzie wartość z momentu, w którym <code>some</code> sprawdza dany element; elementy usunięte przed sprawdzeniem będą przekazane jako <code>undefined</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy">Sprawdzanie rozmiaru wszystkich elementów tablicy</h3>
+
+<p>Następujący przykład sprawdza czy jakiś element tablicy jest większy, bądź równy 10.</p>
+
+<pre class="brush: js">function czyWiekszyNiz10(element, index, array) {
+  return element &gt; 10;
+}
+[2, 5, 8, 1, 4].some(czyWiekszyNiz10); // false
+[12, 5, 8, 1, 44].some(czyWiekszyNiz10); // true
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_rozmiaru_wszystkich_element.C3.B3w_tablicy">Sprawdzanie elementów używając funkcji strzałkowych</h3>
+
+<p>Funkcje strzałkowe dają krótszą składnię dla tego samego testu.</p>
+
+<pre class="brush: js">[2, 5, 8, 1, 4].some(x =&gt; x &gt; 10); // false
+[12, 5, 8, 1, 44].some(x =&gt; x &gt; 10); // true
+</pre>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<table>
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("1.8")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<table>
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("1.8")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
diff --git a/files/pl/web/javascript/reference/global_objects/array/sort/index.html b/files/pl/web/javascript/reference/global_objects/array/sort/index.html
new file mode 100644
index 0000000000..f179b3c45b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/sort/index.html
@@ -0,0 +1,123 @@
+---
+title: Array.prototype.sort()
+slug: Web/JavaScript/Reference/Global_Objects/Array/sort
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/sort
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Sortuje elementy tablicy.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.sort([<var>compareFunction</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>compareFunction</code> </dt>
+ <dd>jest nazwą funkcji porównującej elementy. Jeżeli parametr zostanie pominięty, tablica będzie posortowana w porządku leksykograficznym (alfabetycznie).</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeżeli <code>compareFunction</code> nie zostanie podana, elementy zostaną posortowane leksykograficznie (alfabetycznie - słownikowo) według porównania ich reprezentacji znakowej (łańcucha znaków). Przykładowo "80" znajdzie się przed "9" w porządku leksykograficznym, pomimo że numerycznie 9 poprzedza 80.</p>
+
+<p>Jeżeli <code>compareFunction</code> zostanie podana, elementy tablicy zostaną posortowane odpowiednio do wartości zwracanej przez funkcję porównującą. Jeżeli <code>a</code> oraz <code>b</code> są dwoma porównywanymi elementami tablicy to:</p>
+
+<ul>
+ <li><code>compareFunction(a, b)</code> zwróci wartość mniejszą od 0 - indeks elementu <code>a</code> będzie mniejszy niż indeks <code>b</code> (logicznie <code>a</code> &lt; <code>b</code>).</li>
+</ul>
+
+<ul>
+ <li><code>compareFunction(a, b)</code> zwróci 0 - pozostawia <code>a</code> oraz <code>b</code> w niezmienionej kolejności względem siebie, jednak w dalszym ciągu oba będą porównywane z innymi elementami (logicznie <code>b</code> = <code>a</code>). Uwaga: Standard ECMAscript nie gwarantuje niezmienionej kolejności (np. Mozilla wszystkie wersje do 2003 roku).</li>
+</ul>
+
+<ul>
+ <li><code>compareFunction(a, b)</code> zwraca wartość większą od 0 - indeks elementu <code>a</code> będzie większy niż indeks <code>b</code> (logicznie <code>a</code> &gt; <code>b</code>).</li>
+</ul>
+
+<p>Ogólna postać funkcji porównującej wygląda następująco:</p>
+
+<pre class="brush: js">function compare(a, b) {
+   if (a mniejsze niż b według kryteriów sortowania)
+      return -1
+   if (a większe od b według kryteriów sortowania)
+      return 1
+   // a równe b
+   return 0
+}
+</pre>
+
+<p>W celu porównania liczb, zamiast napisów, funkcja porównująca może odejmować <code>b</code> od <code>a</code>:</p>
+
+<pre class="brush: js">function compareNumbers(a, b) {
+   return a - b
+}
+</pre>
+
+<p>Niektóre implementacje JavaScript wykonują sortowanie stabilne: kolejność elementów <code>a</code> i <code>b</code> nie jest zmieniana jeśli <code>a</code> i <code>b</code> są sobie równe. Jeżeli przed sortowaniem <code>a</code> jest w tablicy wcześniej niż <code>b</code> oraz <code>a</code> i <code>b</code> są sobie równe, to po sortowaniu ich kolejność będzie taka sama (niezależnie od tego, jak zmienią się pozycje elementów <code>a</code> i <code>b</code>).</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Tworzenie.2C_wy.C5.9Bwietlanie_i_sortowanie_tablic" name="Przyk.C5.82ad:_Tworzenie.2C_wy.C5.9Bwietlanie_i_sortowanie_tablic">Przykład: Tworzenie, wyświetlanie i sortowanie tablic</h3>
+
+<p>Następujący przykład tworzy cztery tablice i wyświetla oryginalną tablicę, potem posortowane tablice. Tablice liczbowe są sortowane najpierw bez podania funkcji porównującej, następnie z taką funkcją.</p>
+
+<pre class="brush: js">stringArray = new Array("Blue","Humpback","Beluga")
+numericStringArray = new Array("80","9","700")
+numberArray = new Array(40,1,5,200)
+mixedNumericArray = new Array("80","9","700",40,1,5,200)
+
+function compareNumbers(a, b) {
+   return a - b
+}
+
+console.log("tablicaNapisów: " + stringArray.join())
+console.log("Posortowana: " + stringArray.sort())
+
+console.log("tablicaLiczbowa: " + numberArray.join())
+console.log("Posortowana bez funkcji porównującej: " + numberArray.sort())
+console.log("Posortowana z funkcją porównującą: " + numberArray.sort(compareNumbers))
+
+console.log("tablicaNapisówLiczbowych: " + numericStringArray.join())
+console.log("Posortowana bez funkcji porównującej: " + numericStringArray.sort())
+console.log("Posortowana z funkcją porównującą: " + numericStringArray.sort(compareNumbers))
+
+console.log("tablicaLiczbowaMieszna: " + mixedNumericArray.join())
+console.log("Posortowana bez funkcji porównującej: " + mixedNumericArray.sort())
+console.log("Posortowana z funkcją porównującą: " + mixedNumericArray.sort(compareNumbers))
+</pre>
+
+<p>Ten przykład wyświetla następujące dane. Jak widać, przy zastosowaniu funkcji porównującej, liczby są sortowane prawidłowo niezależnie od tego czy są przedstawiane jako wartości liczbowe bądź też napisy.</p>
+
+<pre>tablicaNapisów: Blue,Humpback,Beluga
+Posortowana: Beluga,Blue,Humpback
+
+tablicaLiczbowa: 40,1,5,200
+Posortowana bez funkcji porównującej: 1,200,40,5
+Posortowana z funkcją porównującą: 1,5,40,200
+
+tablicaNapisówLiczbowych: 80,9,700
+Posortowana bez funkcji porównującej: 700,80,9
+Posortowana z funkcją porównującą: 9,80,700
+
+tablicaLiczbowaMieszna: 80,9,700,40,1,5,200
+Posortowana bez funkcji porównującej: 1,200,40,5,700,80,9
+Posortowana z funkcją porównującą: 1,5,9,40,80,200,700
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.reverse()")}}</li>
+ <li>{{jsxref("String.prototype.localeCompare()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/splice/index.html b/files/pl/web/javascript/reference/global_objects/array/splice/index.html
new file mode 100644
index 0000000000..bbe9d2b474
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/splice/index.html
@@ -0,0 +1,87 @@
+---
+title: Array.prototype.splice()
+slug: Web/JavaScript/Reference/Global_Objects/Array/splice
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/splice
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zmienia zawartość tablicy, dodając nowe elementy podczas usuwania starych elementów.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>array</var>.splice(<var>start</var>, <var>deleteCount</var>[, <var>item1</var>[, <var>item2</var>[, ...]]])
+</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>start</code></dt>
+ <dd>Indeks od którego rozpoczynamy modyfikację tablicy.</dd>
+</dl>
+
+<dl>
+ <dt><code>deleteCount</code></dt>
+ <dd>Liczba całkowita określająca liczbę starych elementów tablicy do usunięcia. Jeżeli <font face="Consolas, Monaco, Andale Mono, monospace">deleteCount</font> wynosi 0, nic nie zostanie usunięte. W tym przypadku należy podać co najmniej jeden nowy element. W przypadku gdy parametr <font face="Consolas, Monaco, Andale Mono, monospace">deleteCount</font> nie został podany (druga forma składni podana powyżej, która jest rozszerzeniem SpiderMonkey), wszystkie elementy o indeksach wyższych <code>lub równych index</code> są usuwane.</dd>
+</dl>
+
+<dl>
+ <dt><code>itemN</code></dt>
+ <dd>Elementy dodawane do tablicy. Jeżeli nie określimy żadnych elementów, <code>splice</code> usunie tylko podaną liczbę elementów.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeżeli podamy różną liczbę wstawianych elementów od liczby usuwanych elementów, tablica będzie posiadała inną długość po wywołaniu metody <code>splice</code>.</p>
+
+<p>Metoda <code>splice</code> zwraca tablicę zawierającą usunięte elementy. Jeżeli usunięty został tylko jeden element, zwracana jest tablica jednoelementowa.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_splice" name="Przyk.C5.82ad:_Zastosowanie_splice">Przykład: Zastosowanie <code>splice</code></h3>
+
+<p>Następujący skrypt ilustruje użycie splice:</p>
+
+<pre class="brush: js">myFish = ["anioł", "klaun", "mandarynka", "jesiotr"];
+console.log("myFish: " + myFish);
+
+removed = myFish.splice(2, 0, "bęben");
+console.log("Po dodaniu 1: " + myFish);
+console.log("Usunięty jest: " + removed);
+
+removed = myFish.splice(3, 1)
+console.log("Po usunięciu 1: " + myFish);
+console.log("Usunięty jest: " + removed);
+
+removed = myFish.splice(2, 1, "trąba")
+console.log("Po zastąpieniu 1: " + myFish);
+console.log("Usunięty jest: " + removed);
+
+removed = myFish.splice(0, 2, "papuga", "zawilec", "niebieski")
+console.log("Po zastąpieniu 2: " + myFish);
+console.log("Usunięty jest: " + removed);
+</pre>
+
+<p>Ten skrypt wyświetli:</p>
+
+<pre>myFish: ["anioł", "klaun", "mandarynka", "jesiotr"]
+
+Po dodaniu 1: ["anioł", "klaun", "bęben", "mandarynka", "jesiotr"]
+Usunięty jest: undefined
+
+Po usunięciu 1: ["anioł", "klaun", "bęben, "jesiotr"]
+Usunięty jest: mandarynka
+
+Po zastąpieniu 1: ["anioł", "klaun", "trąba", "jesiotr"]
+Usunięty jest: bęben
+
+Po zastąpieniu 2: ["papuga", "zawilec", "niebieski", "trąba", "jesiotr"]
+Usunięty jest: ["anioł", "klaun"]
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/array/tolocalestring/index.html b/files/pl/web/javascript/reference/global_objects/array/tolocalestring/index.html
new file mode 100644
index 0000000000..45c7ec7864
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/tolocalestring/index.html
@@ -0,0 +1,129 @@
+---
+title: Array.prototype.toLocaleString()
+slug: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/toLocaleString
+---
+<div>{{JSRef}}</div>
+
+<div>Metoda <code><strong>toLocaleString()</strong></code> zwraca łańcuch znaków reprezentujący wszystkie elementy w tablicy. Każdy element jest konwerterowany do  łańcucha znaku za pomocą lokalnych wywołań <code>toLocaleString. Elementy </code>łaczone są separatorem zdefiniowanym dla lokalnego języka (np. przecinek).</div>
+
+<div></div>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.toLocaleString();</code></pre>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Poniższe elementy tablic są konwertowane na łańcuchy znaków za pomocą wbudowanych metod <code>toLocaleString</code></p>
+
+<ul>
+ <li><code>Object</code>: {{jsxref("Object.prototype.toLocaleString()")}}</li>
+ <li><code>Number</code>: {{jsxref("Number.prototype.toLocaleString()")}}</li>
+ <li><code>Date</code>: {{jsxref("Date.prototype.toLocaleString()")}}</li>
+</ul>
+
+<h2 id="Przykład">Przykład</h2>
+
+<h3 id="Użycie_toLocaleString">Użycie <code>toLocaleString</code></h3>
+
+<pre class="notranslate">let numer = 1337;
+let data = new Date();
+let tablica = [numer , data, 'foo'];
+
+let str = tablica.toLocaleString();
+
+console.log(str);
+// logs '1337,19.11.2020, 17:21:06,foo'
+// if run in a Polish (pl-PL) locale with timezone Europe/Warsaw
+
+
+let strEn = tablica.toLocaleString("en-US");  // "1,337,11/19/2020, 5:21:06 PM,foo"</pre>
+
+
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarze</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Inicjalna definicja</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.3', 'Array.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/tosource/index.html b/files/pl/web/javascript/reference/global_objects/array/tosource/index.html
new file mode 100644
index 0000000000..4a3fa7d355
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/tosource/index.html
@@ -0,0 +1,63 @@
+---
+title: Array.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Array/toSource
+tags:
+  - Array
+  - JavaScript
+  - Method
+  - Non-standard
+  - Prototype
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący kod źródłowy tablicy.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.toSource()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>toSource</code> zwraca następujące wartości:</p>
+
+<p><span class="comment">This shouldn't be here, but until reorganization where pages are moved to their proper places, the title of this article is ambiguous, so it can stay. After reorganization, this should be removed.</span></p>
+
+<ul>
+ <li>Dla wbudowanego obiektu <code>Array</code>, <code>toSource</code> zwraca następujący łańcuch znaków sygnalizując, że kod źródłowy jest niedostępny:
+
+  <pre class="brush: js">function Array() {
+    [natywny kod]
+}
+</pre>
+ </li>
+ <li>Dla instancji {{jsxref("Array")}}, <code>toSource</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li>
+</ul>
+
+<p>Metoda ta jest zazwyczaj wywoływana wewnętrznie przez JavaScript, a nie bezpośrednio w kodzie. Możliwe jest wywołanie <code>toSource</code> podczas debugowania, aby zbadać zawartość tablicy.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Sprawdzanie_kodu_.C5.BAr.C3.B3d.C5.82owego_tablicy" name="Przyk.C5.82ad:_Sprawdzanie_kodu_.C5.BAr.C3.B3d.C5.82owego_tablicy">Przykład: Sprawdzanie kodu źródłowego tablicy</h3>
+
+<p>Do sprawdzania kodu źródłowego tablicy:</p>
+
+<pre class="brush: js">var alpha = new Array("a", "b", "c");
+
+alpha.toSource() //zwraca ["a", "b", "c"]
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+ <li>{{jsxref("Array.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/tostring/index.html b/files/pl/web/javascript/reference/global_objects/array/tostring/index.html
new file mode 100644
index 0000000000..ffc994aeae
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/tostring/index.html
@@ -0,0 +1,43 @@
+---
+title: Array.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Array/toString
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/toString
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>toString()</strong></code> zwraca łańcuch znaków reprezentujący daną tablicę wraz z jej elementami.</p>
+
+<pre class="brush: js">var months = ['Styczeń', 'Luty', 'Marzec', 'Kwiecień'];
+months.toString(); // "Styczeń,Luty,Marzec,Kwiecień"
+</pre>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.toString()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Obiekt {{jsxref("Array")}} przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}. Dla obiektów Array, metoda <code>toString</code> łączy tablicę i zwraca jeden łańcuch znaków zawierający wszystkie elementy tablicy oddzielone przecinkami. Przykładowo poniższy kod tworzy tablicę i stosuje metodę <code>toString</code>, aby przekształcić tablicę do łańcucha znaków.</p>
+
+<pre class="brush: js">var monthNames = new Array("Jan","Feb","Mar","Apr")
+var myVar = monthNames.toString() // przypisuje "Jan,Feb,Mar,Apr" do zmiennej myVar
+</pre>
+
+<p>JavaScript wywołuje metodę <code>toString</code> automatycznie, gdy tablica jest traktowana jako wartość tekstowa lub kiedy istnieje odniesienie do tej tablicy wewnątrz połączonego łańcucha znaków.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+ <li>{{jsxref("Array.prototype.join()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/unshift/index.html b/files/pl/web/javascript/reference/global_objects/array/unshift/index.html
new file mode 100644
index 0000000000..3d249e3ec8
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/unshift/index.html
@@ -0,0 +1,57 @@
+---
+title: Array.prototype.unshift()
+slug: Web/JavaScript/Reference/Global_Objects/Array/unshift
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/unshift
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Dodaje jeden lub więcej elementów na początek tablicy i zwraca jej nową długość.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.unshift([<var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>element
+ <i>N</i>
+ </code> </dt>
+ <dd>Elementy do dodania na początek tablicy.</dd>
+</dl>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy" name="Przyk.C5.82ad:_Dodawanie_element.C3.B3w_do_tablicy">Przykład: Dodawanie elementów do tablicy</h3>
+
+<p>Następujący kod wyświetli tablicę <code>myFish</code> przed i po dodaniu do niej elementów.</p>
+
+<pre class="brush: js">myFish = ["anioł", "klaun"];
+console.log("myFish przed: " + myFish);
+unshifted = myFish.unshift("bęben", "lew");
+console.log("myFish po: " + myFish);
+console.log("Nowa długość tablicy: " + unshifted);
+</pre>
+
+<p>Powyższy przykład wyświetli:</p>
+
+<pre>myFish przed: ["anioł", "klaun"]
+myFish po: ["bęben", "lew", "anioł", "klaun"]
+Nowa długość tablicy: 4
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.push()")}}</li>
+ <li>{{jsxref("Array.prototype.pop()")}}</li>
+ <li>{{jsxref("Array.prototype.shift()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/array/values/index.html b/files/pl/web/javascript/reference/global_objects/array/values/index.html
new file mode 100644
index 0000000000..1a2df94435
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/array/values/index.html
@@ -0,0 +1,85 @@
+---
+title: Array.prototype.values()
+slug: Web/JavaScript/Reference/Global_Objects/Array/values
+tags:
+  - ECMAScript 2015
+  - Iterator
+  - JavaScript
+  - Metodă
+  - Prototype
+  - Tablica
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/values
+original_slug: Web/JavaScript/Referencje/Obiekty/Array/values
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong><code>values()</code></strong> zwraca nowy obiekt <strong><code>Array Iterator</code></strong> , który zawiera wartości dla każdego indeksu w tablicy.</p>
+
+<pre class="brush: js">var a = ['w', 'y', 'k', 'o', 'p'];
+var iterator = a.values();
+
+console.log(iterator.next().value); // w
+console.log(iterator.next().value); // y
+console.log(iterator.next().value); // k
+console.log(iterator.next().value); // o
+console.log(iterator.next().value); // p</pre>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><var>arr</var>.values()</pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Nowy obiekt {{jsxref("Array")}} iterator.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Iteracja_używająca_pętli_for...of">Iteracja używająca pętli <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code></h3>
+
+<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
+var iterator = arr.values();
+
+for (let letter of iterator) {
+  console.log(letter);
+}
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array.prototype.values', 'Array.prototype.values')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.values', 'Array.prototype.values')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Array.values")}}</p>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.keys()")}}</li>
+ <li>{{jsxref("Array.prototype.entries()")}}</li>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+ <li>{{jsxref("Array.prototype.some()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/arraybuffer/index.html b/files/pl/web/javascript/reference/global_objects/arraybuffer/index.html
new file mode 100644
index 0000000000..a1ac4a5da1
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/arraybuffer/index.html
@@ -0,0 +1,223 @@
+---
+title: ArrayBuffer
+slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+tags:
+  - ArrayBuffer
+  - JavaScript
+  - Konstruktor
+  - TypedArrays
+translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+original_slug: Web/JavaScript/Referencje/Obiekty/ArrayBuffer
+---
+<div>{{JSRef}}</div>
+
+<p>Objekt<strong> <code>ArrayBuffer</code></strong> reprezentuje buffer z surowymi danymi binarnymi o niezmiennej długości. Nie możesz bezpośrednio wpływać na zawartość obiektu <code><strong>ArrayBuffer</strong></code>, możesz natomiast stworzyć jeden z obiektów<code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">typedArray</a></code> lub obiekt {{jsxref("DataView")}} reprezentujący buffer w specjalnym formacie i używać tego obiektu do odczytu oraz zapisu treści buffera.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">new ArrayBuffer(length)
+</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt>długość<code>(length)</code></dt>
+ <dd>Rozmiar, w bajtach, tworzony z bufferu tablicy (array buffer).</dd>
+</dl>
+
+<h3 id="Wartość_zwrócona">Wartość zwrócona</h3>
+
+<p>Nowy obiekt <code>ArrayBuffer</code> o określonym rozmiarze. Jego wartości początkowe wynoszą 0.</p>
+
+<h3 id="Wyjątki">Wyjątki</h3>
+
+<p>{{jsxref("RangeError")}} pojawi się, jeśli długość (<code>length</code>) jest większa niż {{jsxref("Number.MAX_SAFE_INTEGER")}} (&gt;= 2 ** 53) lub ujemna.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Konstruktor <code>ArrayBuffer</code> tworzy nowy <code>ArrayBuffer </code>z podanej długości (<code>length</code>) w bajtach.</p>
+
+<h3 id="Otrzymywanie_bufferu_tablicy_z_istniejących_danych">Otrzymywanie bufferu tablicy z istniejących danych</h3>
+
+<ul>
+ <li><a href="/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">ze stringa Base64</a></li>
+ <li><a href="/en-US/docs/Web/API/FileReader#readAsArrayBuffer()">z lokalnego pliku</a></li>
+</ul>
+
+<h2 id="Właściwości">Właściwości</h2>
+
+<dl>
+ <dt><code>ArrayBuffer.length</code></dt>
+ <dd>Właściwość długości konstruktura <code>ArrayBuffer</code>, której wartość wynosi 1.</dd>
+ <dt>{{jsxref("ArrayBuffer.@@species", "get ArrayBuffer[@@species]")}}</dt>
+ <dd>Funkcja konstruktora jest używana do tworzenia dostarczanych obiektów.</dd>
+ <dt>{{jsxref("ArrayBuffer.prototype")}}</dt>
+ <dd>Pozwala dodać właściwości do wszystkich obiektów <code>ArrayBuffer</code>.</dd>
+</dl>
+
+<h2 id="Metody">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("ArrayBuffer.isView", "ArrayBuffer.isView(arg)")}}</dt>
+ <dd>Zwraca <code>true</code>, jeśli <code>arg</code> jest jednym z widoków <code>ArrayBuffer</code>, jak obiekty <code>typedArray</code> lub {{jsxref("DataView")}}. W innych przypadkach zwraca <code>false</code>.</dd>
+ <dt>{{jsxref("ArrayBuffer.transfer", "ArrayBuffer.transfer(oldBuffer [, newByteLength])")}} {{experimental_inline}}</dt>
+ <dd>
+ <div class="line" id="file-arraybuffer-transfer-LC6">Zwraca nowy <code>ArrayBuffer</code>, którego zawartości są pobrane z danych <code>oldBuffer</code>. Następnie zostaje skrócony lub przedłużony od 0 przez <code>newByteLength</code>.</div>
+ </dd>
+</dl>
+
+<h2 id="Instancje_ArrayBuffer"><code>Instancje ArrayBuffer</code></h2>
+
+<p>Wszystkie instancje <code>ArrayBuffer </code>dziedziczą z {{jsxref("ArrayBuffer.prototype")}}.</p>
+
+<h3 id="Właściwości_2">Właściwości</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Properties')}}</p>
+
+<h3 id="Metody_2">Metody</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Methods')}}</p>
+
+<dl>
+ <dt>{{jsxref("ArrayBuffer.slice()")}} {{non-standard_inline}}</dt>
+ <dd>Posiada tę samą funkcjonalność, jak {{jsxref("ArrayBuffer.prototype.slice()")}}.</dd>
+</dl>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<p>W niniejszym przykładzie tworzymy 8-bajtowy buffer z widokiem {{jsxref("Global_Objects/Int32Array", "Int32Array")}} odnoszącym się do buffera:</p>
+
+<pre class="brush: js">var buffer = new ArrayBuffer(8);
+var view   = new Int32Array(buffer);</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('Typed Array')}}</td>
+   <td>{{Spec2('Typed Array')}}</td>
+   <td>Zastępiony przez ECMAScript 6.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definicja początkowa w standardzie ECMA. Zgłasza, że wymagany jest <code>new</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Cecha</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Wsparcie podstawowe</td>
+   <td>7.0</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>10</td>
+   <td>11.6</td>
+   <td>5.1</td>
+  </tr>
+  <tr>
+   <td><code>ArrayBuffer()</code> bez odsyłacza <code>new</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("44")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td><code>ArrayBuffer.slice()</code> {{non-standard_inline}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}<br>
+    {{CompatNo}} {{CompatGeckoDesktop("53")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Cecha</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Wsparcie podstawowe</td>
+   <td>4.0</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("2")}}</td>
+   <td>10</td>
+   <td>11.6</td>
+   <td>4.2</td>
+  </tr>
+  <tr>
+   <td><code>ArrayBuffer()</code> bez odsyłacza <code>new</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("44")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td><code>ArrayBuffer.slice()</code> {{non-standard_inline}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}<br>
+    {{CompatNo}} {{CompatGeckoMobile("53")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zapis_kompatybilny">Zapis kompatybilny</h2>
+
+<p>Od ECMAScript 2015 kontruktory <code>ArrayBuffer</code> muszą być tworzone poprzez operator {{jsxref("Operators/new", "new")}}. Wywoływanie kontruktora ArrayBuffer jako funkcji bez <code>new</code> zaskutkuje od teraz pojawieniem się {{jsxref("TypeError")}}.</p>
+
+<pre class="brush: js example-bad">var dv = ArrayBuffer(10);
+// TypeError: calling a builtin ArrayBuffer constructor
+// without new is forbidden</pre>
+
+<pre class="brush: js example-good">var dv = new ArrayBuffer(10);</pre>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typed arrays</a></li>
+ <li>{{jsxref("SharedArrayBuffer")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/bigint/asintn/index.html b/files/pl/web/javascript/reference/global_objects/bigint/asintn/index.html
new file mode 100644
index 0000000000..fca69d7e9c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/bigint/asintn/index.html
@@ -0,0 +1,80 @@
+---
+title: BigInt.asIntN()
+slug: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN
+tags:
+  - BigInt
+  - JavaScript
+  - Metodă
+  - Referencja
+  - asIntN
+translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN
+original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/asIntN
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda statyczna <strong><code>BigInt.asIntN</code></strong> jest używana do opakowywania wartości BigInt w wartości całkowite ze znakiem w zakresie od -2<sup>szerokość-1</sup> do 2<sup>szerokość-1</sup>-1.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/bigint-asintn.html", "taller")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">BigInt.asIntN(<em>szerokość</em>, <var>bigint</var>);</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code><var>szerokość</var></code></dt>
+ <dd>Liczba bitów dostępnych dla rozmiaru wartości całkowitej (integer).</dd>
+ <dt><code><var>bigint</var></code></dt>
+ <dd>Wartość całkowita, którą chcemy wpasować w daną liczbę bitów.</dd>
+</dl>
+
+<h3 id="Wynik">Wynik</h3>
+
+<p>Wartość <code><var>bigint</var></code> modulo 2<sup><code><var>szerokość</var></code></sup> jako liczba całkowita ze znakiem.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Pozostawanie_w_zakresie_arytmetyki_64-bitowej">Pozostawanie w zakresie arytmetyki 64-bitowej</h3>
+
+<p>Metoda <code>BigInt.asIntN()</code> może być użyteczna do tego, by pozostać w zakresie obliczeń arytmetyki 64-bitowej.</p>
+
+<pre class="brush: js">const max = 2n ** (64n - 1n) - 1n;
+
+BigInt.asIntN(64, max);
+// ↪ 9223372036854775807n
+
+BigInt.asIntN(64, max + 1n);
+// ↪ -9223372036854775807n
+// wartość ujemna ze względu na przepełnienie
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-bigint.asintn', 'BigInt.asIntN()')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.builtins.BigInt.asIntN")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{JSxRef("BigInt")}}</li>
+ <li>{{JSxRef("BigInt.asUintN()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/bigint/asuintn/index.html b/files/pl/web/javascript/reference/global_objects/bigint/asuintn/index.html
new file mode 100644
index 0000000000..63ed40473a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/bigint/asuintn/index.html
@@ -0,0 +1,79 @@
+---
+title: BigInt.asUintN()
+slug: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN
+tags:
+  - BigInt
+  - JavaScript
+  - Metodă
+  - Referencja
+  - asUintN
+translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN
+original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/asUintN
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda statyczna <strong><code>BigInt.asUintN</code></strong> jest używana do opakowywania wartości BigInt w wartości całkowite bez znaku w zakresie od 0 do 2<sup>szerokość</sup>-1.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/bigint-asuintn.html", "taller")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">BigInt.asUintN(<em>szerokość</em>, <var>bigint</var>);</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code><var>szerokość</var></code></dt>
+ <dd>Liczba bitów dostępnych dla rozmiaru wartości całkowitej (integer).</dd>
+ <dt><code><var>bigint</var></code></dt>
+ <dd>Wartość całkowita, którą chcemy wpasować w daną liczbę bitów.</dd>
+</dl>
+
+<h3 id="Wynik">Wynik</h3>
+
+<p>Wartość <code><var>bigint</var></code> modulo 2<sup><code><var>szerokość</var></code></sup> jako wartość całkowita bez znaku.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Pozostawanie_w_zakresie_arytmetyki_64-bitowej">Pozostawanie w zakresie arytmetyki 64-bitowej</h3>
+
+<p>Metoda <code>BigInt.asUintN()</code> może być użyteczna do tego, by pozostać w zakresie obliczeń arytmetyki 64-bitowej.</p>
+
+<pre class="brush: js">const max = 2n ** 64n - 1n;
+
+BigInt.asUintN(64, max);
+// ↪ 18446744073709551615n
+
+BigInt.asUintN(64, max + 1n);
+// ↪ 0n
+// zero z powodu przepełnienia</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-bigint.asuintn', 'BigInt.asUintN()')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.builtins.BigInt.asUintN")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{JSxRef("BigInt")}}</li>
+ <li>{{JSxRef("BigInt.asIntN()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/bigint/index.html b/files/pl/web/javascript/reference/global_objects/bigint/index.html
new file mode 100644
index 0000000000..4f66412f67
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/bigint/index.html
@@ -0,0 +1,294 @@
+---
+title: BigInt
+slug: Web/JavaScript/Reference/Global_Objects/BigInt
+tags:
+  - BigInt
+  - JavaScript
+  - Referencja
+translation_of: Web/JavaScript/Reference/Global_Objects/BigInt
+original_slug: Web/JavaScript/Referencje/Obiekty/BigInt
+---
+<div>{{JSRef}}</div>
+
+<p><strong><code>BigInt</code></strong> jest wbudowanym obiektem umożliwiającym reprezentowanie całych liczb większch niż 2<sup>53</sup> - 1, ile wynosi największa liczba, którą JavaScript może faktycznie reprezentować przez prymityw {{JSxRef("Number")}}, co jest też reprezentowane przez stałą {{JSxRef("Number.MAX_SAFE_INTEGER")}}. <strong><code>BigInt</code></strong> może być używany do dowolnie dużych liczb całkowitych.</p>
+
+<dl>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p><code>BigInt</code> jest tworzony przez dodanie <code>n</code> na końcu literału liczby — <code>10n</code> — lub przez wywołanie funkcji <code>BigInt()</code>.</p>
+
+<pre class="brush: js">const najwiekszyInt = 9007199254740991n
+
+const tezDuzaLiczba = BigInt(9007199254740991)
+// ↪ 9007199254740991n
+
+const duzyString = BigInt("9007199254740991")
+// ↪ 9007199254740991n
+
+const duzyHex = BigInt("0x1fffffffffffff")
+// ↪ 9007199254740991n
+
+const duzyBin = BigInt("0b11111111111111111111111111111111111111111111111111111")
+// ↪ 9007199254740991n
+</pre>
+
+<p><code>BigInt</code> jest w pewnym sensie podobny do {{JSxRef("Number")}} ale też różni się od niego w kilku kluczowych sprawach — nie może być używany z metodami wbudowanego obiektu {{JSxRef("Math")}}, a także nie może być mieszany z instancjami <code>Number</code> w żadnych operacjach; konieczne jest wymuszenie tego samego typu operandów. Należy uważać z wymuszaniem typów w jedną i drugą stronę, w szczególności precyzja <code>BigInt</code> może być utracona przy wymuszonej konwersji do typu <code>Number</code>.</p>
+
+<h3 id="Informacje_o_typie">Informacje o typie</h3>
+
+<p>Przy sprawdzeniu za pomocą <code>typeof</code>, <code>BigInt</code> zwróci "bigint":</p>
+
+<pre class="brush: js">typeof 1n === 'bigint'           // true
+typeof BigInt('1') === 'bigint'  // true
+</pre>
+
+<p>Obudowany w <code>Object</code>, <code>BigInt</code> będzie rozważany jako zwykły "obiekt":</p>
+
+<pre class="brush: js">typeof Object(1n) === 'object'  // true
+</pre>
+
+<h3 id="Operatory">Operatory</h3>
+
+<p>Z <code>BigInt</code>ami (lub <code>BigInt</code>ami obudowanymi w obiekty) mogą być używane następujące operatory: : <code>+</code>, <code>*</code>, <code>-</code>, <code>**</code>, <code>%</code>.</p>
+
+<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Operatory bitowe</a> także są wspierane, z wyjątkiem <code>&gt;&gt;&gt;</code> (przesunięcie w prawo z dopełnieniem zerami), gdyż wszystkie <code>BigInt</code>y mają znak.</p>
+
+<p>Niewspierany jest także operator jednoargumentowy (<code>+</code>), <a href="https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs">aby nie złamać zasad asm.js</a>.</p>
+
+<pre class="brush: js">const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
+// ↪ 9007199254740991n
+
+const maxPlusOne = previousMaxSafe + 1n
+// ↪ 9007199254740992n
+
+const theFuture = previousMaxSafe + 2n
+// ↪ 9007199254740993n, this works now!
+
+const multi = previousMaxSafe * 2n
+// ↪ 18014398509481982n
+
+const subtr = multi – 10n
+// ↪ 18014398509481972n
+
+const mod = multi % 10n
+// ↪ 2n
+
+const bigN = 2n ** 54n
+// ↪ 18014398509481984n
+
+bigN * -1n
+// ↪ –18014398509481984n
+</pre>
+
+<p>Operator <code>/</code> także działa zgodnie z założeniami z całymi liczbami.</p>
+
+<p>Jako że są to <code>BigInt</code>y, a nie <code>BigDecimal</code>, operacja dzielenia będzie zaokroąglała wynik do <code>0</code> (zatem można prościej powiedzieć, że nie zwraca ułamkowej części wyniku).</p>
+
+<div class="blockIndicator warning">
+<p>Ułamkowy wynik operacji będzie przycięty, kiedy używany jest  <code>BigInt</code>.</p>
+</div>
+
+<pre class="brush: js">const expected = 4n / 2n
+// ↪ 2n
+
+const rounded = 5n / 2n
+// ↪ 2n, not 2.5n
+
+</pre>
+
+<h3 id="Porównania">Porównania</h3>
+
+<p><code>BigInt</code> nie jest ściśle równy {{JSxRef("Number")}}, ale jest równy w luźnym sensie, zatem:</p>
+
+<pre class="brush: js">0n === 0
+// ↪ false
+
+0n == 0
+// ↪ true</pre>
+
+<p>{{JSxRef("Global_Objects/Number", "Number")}} i <code>BigInt</code> mogą być porównywane w zwyczajny sposób:</p>
+
+<pre class="brush: js">1n &lt; 2
+// ↪ true
+
+2n &gt; 1
+// ↪ true
+
+2 &gt; 2
+// ↪ false
+
+2n &gt; 2
+// ↪ false
+
+2n &gt;= 2
+// ↪ true</pre>
+
+<p>Mogą być też mieszane w tablicach i sortowane:</p>
+
+<pre class="brush: js">const mixed = [4n, 6, -12n, 10, 4, 0, 0n]
+// ↪  [4n, 6, -12n, 10, 4, 0, 0n]
+
+mixed.sort()
+// ↪ [-12n, 0, 0n, 4n, 4, 6, 10]
+</pre>
+
+<p>Zauważ, że porównania z <code>BigInt</code>ami opakowanymi w obiekty działają jak z innymi obiektami, wskazując równość tylko wtedy, kiedy ta sama instancja obiektu znajduje się po obu stronach porównania:</p>
+
+<pre class="brush: js">0n === Object(0n)          // false
+Object(0n) === Object(0n)  // false
+
+const o = Object(0n)
+o === o                    // true
+</pre>
+
+<h3 id="Instrukcje_warunkowe">Instrukcje warunkowe</h3>
+
+<p><code>BigInt</code> zachowuje się jak {{JSxRef("Global_Objects/Number", "Number")}} w przypadkach, gdy:</p>
+
+<ul>
+ <li>jest konwertowany na {{JSxRef("Global_Objects/Boolean", "Boolean")}} za pomocą funkcji {{JSxRef("Global_Objects/Boolean", "Boolean")}};</li>
+ <li>jest używany z <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Logical_Operators">operatorami logicznymi</a> <code>||</code>, <code>&amp;&amp;</code> lub <code>!</code>;</li>
+ <li>w instrukcjach warunkowych {{JSxRef("Statements/if...else", "if")}}.</li>
+</ul>
+
+<pre class="brush: js">if (0n) {
+  console.log('Hello from the if!')
+} else {
+  console.log('Hello from the else!')
+}
+
+// ↪ "Hello from the else!"
+
+0n || 12n
+// ↪ 12n
+
+0n &amp;&amp; 12n
+// ↪ 0n
+
+Boolean(0n)
+// ↪ false
+
+Boolean(12n)
+// ↪ true
+
+!12n
+// ↪ false
+
+!0n
+// ↪ true
+</pre>
+
+<h2 id="Konstruktor">Konstruktor</h2>
+
+<dl>
+ <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/BigInt">BigInt()</a></code></dt>
+ <dd>Tworzy obiekty {{jsxref("BigInt")}}.</dd>
+</dl>
+
+<h2 id="Metody_statyczne">Metody statyczne</h2>
+
+<dl>
+ <dt>{{JSxRef("BigInt.asIntN()")}}</dt>
+ <dd>Opakowuje wartość <code>BigInt</code> w liczbę całkowitą ze znakiem o wartości między <code>-2<var><sup>width</sup></var><sup>-1</sup></code> a <code>2<var><sup>width</sup></var><sup>-1</sup> - 1</code>.</dd>
+ <dt>{{JSxRef("BigInt.asUintN()")}}</dt>
+ <dd>Opakowuje wartość <code>BigInt</code> w liczbę całkowitą bez znaku o wartości między <code>0</code> a <code>2<var><sup>width</sup></var> - 1</code>.</dd>
+</dl>
+
+<h2 id="Metody_instancyjne">Metody instancyjne</h2>
+
+<dl>
+ <dt>{{JSxRef("BigInt.prototype.toLocaleString()")}}</dt>
+ <dd>Zwraca string z zależną od języka reprezentacją danej liczby. Nadpisuje metodę {{JSxRef("Object.prototype.toLocaleString()")}}.</dd>
+ <dt>{{JSxRef("BigInt.prototype.toString()")}}</dt>
+ <dd>Zwraca string reprezentujący dany obiekt w określonym źródle. Nadpisuje metodę {{JSxRef("Object.prototype.toString()")}}.</dd>
+ <dt>{{JSxRef("BigInt.prototype.valueOf()")}}</dt>
+ <dd>Zwraca prymitywną wartość danego obiektu. Nadpisuje metodę {{JSxRef("Object.prototype.valueOf()")}}.</dd>
+</dl>
+
+<h2 id="Zalecenia_w_użyciu">Zalecenia w użyciu</h2>
+
+<h3 id="Wymuszanie_typów">Wymuszanie typów</h3>
+
+<p>Ponieważ wymuszanie tupów między {{JSxRef("Number")}} a <code>BigInt</code> może prowadzić do utraty precyzji, zaleca się używanie jedynie typu <code>BigInt</code>, gdy można się spodziewać, że pojawią się wartości przekraczające 2<sup>53</sup> i nie należy wówczas przeprowadzać konwersji między tymi typami.</p>
+
+<h3 id="Kryptografia">Kryptografia</h3>
+
+<p>Operacje wspierane dla <code>BigInt</code>ów nie są stałe czasowo, dlatego też typ <code>BigInt</code> <a href="https://www.chosenplaintext.ca/articles/beginners-guide-constant-time-cryptography.html">nie nadaje się do użycia w kryptografii</a>.</p>
+
+<h3 id="Użycie_w_JSON">Użycie w JSON</h3>
+
+<p>Użycie {{jsxref("JSON.stringify()")}} z dowolną wartością typu <code>BigInt</code> spowoduje błąd <code>TypeError</code>, ponieważ wartości <code>BigInt</code> nie są domyślnie serialozowane w JSONie. Jednakże, jeśli taka operacja jest potrzebna, możesz zaimplemntować własną metodę <code>toJSON</code>:</p>
+
+<pre class="brush: js">BigInt.prototype.toJSON = function() { return this.toString()  }</pre>
+
+<p>Zamiast wyrzucania wyjątku, <code>JSON.stringify</code> będzie teraz zwracać string:</p>
+
+<pre class="brush: js">JSON.stringify(BigInt(1))
+// '"1"'</pre>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Obliczanie_liczb_pierwszych">Obliczanie liczb pierwszych</h3>
+
+<pre class="brush: js">// Zwraca true jeśl dany BigInt jest liczbą pierwszą
+function isPrime(p) {
+  for (let i = 2n; i * i &lt;= p; i++) {
+    if (p % i === 0n) return false;
+  }
+  return true
+}
+
+// Przyjmuje BigInt n jako argument, zwraca n-tą liczbę pierwszą jako BigInt
+function nthPrime(nth) {
+  let maybePrime = 2n
+  let prime = 0n
+
+  while (nth &gt;= 0n) {
+    if (isPrime(maybePrime)) {
+      nth--
+      prime = maybePrime
+    }
+    maybePrime++
+  }
+
+  return prime
+}
+
+nthPrime(20n)
+// ↪ 73n</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName("ESDraft", "#sec-bigint-objects", "<code>BigInt</code> objects")}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div class="hidden">The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a class="external" href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</div>
+
+<p>{{Compat("javascript.builtins.BigInt")}}</p>
+
+<h3 id="Postęp_implementacji">Postęp implementacji</h3>
+
+<p>Poniższa tabela przedstawia postęp implementacji tej funkcji języka JavaScript, gdyż nie osiągnęła ona jeszcze pełnej stabilności między przeglądarkami. Dane są generowane przez uruchamianie odpowiednich testów tej funkcji w <a href="https://github.com/tc39/test262">Test262</a>,standrardowym zestawie testów JavaScript, „nocnych wersji” (ang. <em>nightly build</em>) lub ostatnich wydań silnika JavaScript w każdej przeglądarce.</p>
+
+<div>{{EmbedTest262ReportResultsTable("BigInt")}}</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{JSxRef("Number")}}</li>
+ <li>{{JSxRef("Number.MAX_SAFE_INTEGER")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/bigint/tostring/index.html b/files/pl/web/javascript/reference/global_objects/bigint/tostring/index.html
new file mode 100644
index 0000000000..8c3cc98381
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/bigint/tostring/index.html
@@ -0,0 +1,96 @@
+---
+title: BigInt.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/BigInt/toString
+tags:
+  - BigInt
+  - JavaScript
+  - Metodă
+  - Prototyp
+  - toString()
+translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/toString
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong><code>toString()</code></strong> zwraca ciąg znaków (<em>string</em>), reprezentujący dany obiekt {{jsxref("BigInt")}}. Końcowy znak "n" nie jest częścią wynikowego ciągu znaków.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/bigint-tostring.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>bigIntObj</var>.toString([podstawa])</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>podstawa</code>{{optional_inline}}</dt>
+ <dd>Argument opcjonalny. Liczba całkowita w zakresie od 2 do 36, reprezentująca bazę systemu liczbowego, w którym ma być przedstawiona dana wartość {{jsxref("BigInt")}}.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Ciąg znaków reprezentujący dany obiekt {{jsxref("BigInt")}}.</p>
+
+<h3 id="Wyjątki">Wyjątki</h3>
+
+<dl>
+ <dt>{{jsxref("RangeError")}}</dt>
+ <dd>Jeśli do metody <code>toString()</code> przekazana jest podstawa systemu mniejsza niż 2 lub większa niż 36, wyrzucany jest błąd {{jsxref("RangeError")}}.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Obiekt {{jsxref("BigInt")}} nadpisuje metodę <code>toString()</code> obiektu {{jsxref("Object")}}; nie dziedziczy metody {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref( "BigInt")}}, metoda <code>toString()</code> zwraca ciąg znaków reprezentujący daną wartość w systemie pozycyjnym o zadanej bazie.</p>
+
+<p>Metoda <code>toString()</code> parsuje pierwszy argument i próbuje zwrócić ciąg znaków reprezentujący daną wartość w systemie o zadanej podstawie (bazie). Dla systemów o podstawie większej niż 10, do reprezentacji cyfr większych niż 9 używane są kolejne litery alfabetu łacińskiego. Przykładowo, dla wartości w systemie szesnastkowym (o podstawie równej 16), używane są litery od <code>a</code> do <code>f</code>.</p>
+
+<p>Jeśli <code>podstawa</code> nie jest podana, zakłada się, że preferowaną bazą systemu jest 10.</p>
+
+<p>Jeśli wartość <code>bigIntObj</code> jest ujemna, znak jest zachowywany. Dzieje się tak nawet wtedy, gdy podstawą jest 2; zwracany ciąg cyfr jest dodatnią reprezentacją <code>bigIntObj</code>, poprzedzoną znakiem <code>-</code>, <strong>nie</strong> dopełnieniem dwójkowym <code>bigIntObj</code>.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_toString">Użycie <code>toString</code></h3>
+
+<pre class="brush: js">17n.toString();      // '17'
+66n.toString(2);     // '1000010'
+254n.toString(16);   // 'fe'
+-10n.toString(2);    // -1010'
+-0xffn.toString(2);  // '-11111111'
+</pre>
+
+<h3 id="BigInt_z_ujemnym_zerem"><code>BigInt</code> z ujemnym zerem</h3>
+
+<p>Nie ma obiektów <code>BigInt</code> reprezentujących ujemne zero, tak jak nie ma ujemnych zer wśród liczb całkowitych.. <code>-0.0</code> jest zmiennoprzecinkową koncepcją zmiennoprzecinkową IEEE, która pojawia się w języku JavaScript jedynie w typie {{jsxref("Number")}}.</p>
+
+<pre class="brush: js">(-0n).toString();      // '0'
+BigInt(-0).toString(); // '0'</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-bigint.prototype.tostring', 'BigInt.prototype.toString()')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.BigInt.toString")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("BigInt.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("BigInt.prototype.valueOf()")}}</li>
+ <li>{{jsxref("Number.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/bigint/valueof/index.html b/files/pl/web/javascript/reference/global_objects/bigint/valueof/index.html
new file mode 100644
index 0000000000..e1ed582948
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/bigint/valueof/index.html
@@ -0,0 +1,60 @@
+---
+title: BigInt.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf
+tags:
+  - BigInt
+  - JavaScript
+  - Metodă
+  - Prototype
+  - valueOf()
+translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf
+original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/valueOf
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong><code>valueOf()</code></strong> zwraca opakowaną wartość prymitywną obiektu {{jsxref("BigInt")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/bigint-valueof.html","shorter")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><var>bigIntObj</var>.valueOf()</pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>BigInt reprezentujący wartość prymitywną danego obiektu {{jsxref("BigInt")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_valueOf">Użycie <code>valueOf</code></h3>
+
+<pre class="brush: js">typeof Object(1n); // object
+typeof Object(1n).valueOf(); // bigint
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-bigint.prototype.valueof', 'BigInt.prototype.valueOf()')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.BigInt.valueOf")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("BigInt.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/boolean/index.html b/files/pl/web/javascript/reference/global_objects/boolean/index.html
new file mode 100644
index 0000000000..29719a9605
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/boolean/index.html
@@ -0,0 +1,112 @@
+---
+title: Boolean
+slug: Web/JavaScript/Reference/Global_Objects/Boolean
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean
+original_slug: Web/JavaScript/Referencje/Obiekty/Boolean
+---
+<p>{{JSRef("Global_Objects", "Boolean")}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Obiekt <code>Boolean</code> jest obiektem opakowującym (ang.<em>wrapper</em> ) dla wartości logicznych.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>new Boolean([wartosc])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>wartosc</code> </dt>
+ <dd>Początkowa wartość obiektu <code>Boolean</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość przekazana jako pierwszy parametr jest w razie konieczności konwertowana do wartości logicznej. Jeśli wartość zostanie pominięta lub będzie równa 0, -0, null, false, <code>NaN</code>, będzie pustym łańcuchem znaków ("") lub będzie niezdefiniowana, obiekt przyjmie początkową wartość false. Dowolna inna wartość, włączając łańcuch znaków <code>"false"</code>, spowoduje utworzenie obiektu z początkową wartością true.</p>
+
+<p>Nie należy mylić prostych wartości logicznych true i false z wartościami <code>true</code> i <code>false</code> obiektu Boolean.</p>
+
+<p>Każdy obiekt, którego wartością nie jest wartość <code>undefined</code> lub <code>null</code>, w tym obiekt Boolean posiadający wartość <code>false</code>, traktowany jest w instrukcjach warunkowych jako <code>true</code>. Przykładowo warunek w poniższej instrukcji if będzie miał wartość <code>true</code>:</p>
+
+<pre class="eval">x = new Boolean(false);
+if (x) {
+  // . . . ten kod zostanie wykonany
+}
+</pre>
+
+<p>Taka sytuacja nie zachodzi przy prostych wartościach logicznych. Przykładowo warunek w poniższej instrukcji if będzie miał wartość <code>false</code>::</p>
+
+<pre class="eval">x = false;
+if (x) {
+  // . . . ten kod nie zostanie wykonany
+}
+</pre>
+
+<p>Nie należy zatem używać obiektu <code>Boolean</code> do konwersji wartości nie będącej wartością logiczną na wartość typu Boolean. Zamiast tego należy skorzystać z funkcji <code>Boolean()</code>:</p>
+
+<pre class="eval">x = Boolean(wyrazenie);     // zalecane
+x = new Boolean(wyrazenie); // nie należy używać
+</pre>
+
+<p>Jeśli jako wartość początkową określony zostanie dowolny obiekt, w tym obiekt Boolean o wartości <code>false</code>, nowy obiekt Boolean będzie miał wartość <code>true</code>.</p>
+
+<pre class="eval">myFalse = new Boolean(false);   // wartość początkowa: false
+g = new Boolean(myFalse);       // wartość początkowa: true
+myString = new String("Hello"); // obiekt String (łańcuch znaków)
+s = new Boolean(myString);      // wartość początkowa: true
+</pre>
+
+<p><strong>Nie należy</strong> używać obiektu Boolean zamiast prostej wartości logicznej.</p>
+
+<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2>
+
+<dl>
+ <dt><code>Boolean.length</code></dt>
+ <dd>Length property whose value is 1.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Boolean.prototype")}}</dt>
+ <dd>Definiuje własność współdzieloną przez wszystkie obiekty Boolean.</dd>
+</dl>
+
+<h2 id="Metody" name="Metody">Metody</h2>
+
+<p>Globalny obiekt <code>Boolean</code> sam w sobie nie zawiera żadnych metod, jednak dziedziczy on niektóre metody poprzez łańcuch prototypu.</p>
+
+<div>{{jsOverrides("Function", "Methods")}}</div>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Efa.C5.82sz.E2.80.9D" name="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Efa.C5.82sz.E2.80.9D">Tworzenie obiektów <code>Boolean</code> z początkową wartością „fałsz”</h3>
+
+<pre class="brush: js">bNoParam = new Boolean();
+bZero = new Boolean(0);
+bNull = new Boolean(null);
+bEmptyString = new Boolean("");
+bfalse = new Boolean(false);
+</pre>
+
+<h3 id="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Eprawda.E2.80.9D" name="Tworzenie_obiekt.C3.B3w_Boolean_z_pocz.C4.85tkow.C4.85_warto.C5.9Bci.C4.85_.E2.80.9Eprawda.E2.80.9D">Tworzenie obiektów <code>Boolean</code> z początkową wartością „prawda”</h3>
+
+<pre class="brush: js">btrue = new Boolean(true);
+btrueString = new Boolean("true");
+bfalseString = new Boolean("false");
+bSuLin = new Boolean("Su Lin");
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Boolean.prototype")}}</li>
+ <li>{{Glossary("Boolean")}}</li>
+ <li><a href="http://en.wikipedia.org/wiki/Boolean_data_type">Boolean data type (Wikipedia)</a></li>
+</ul>
+
+<div class="noinclude"> </div>
diff --git a/files/pl/web/javascript/reference/global_objects/boolean/tosource/index.html b/files/pl/web/javascript/reference/global_objects/boolean/tosource/index.html
new file mode 100644
index 0000000000..532bffc87c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/boolean/tosource/index.html
@@ -0,0 +1,52 @@
+---
+title: Boolean.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Boolean/toSource
+tags:
+  - Boolean
+  - JavaScript
+  - Method
+  - Non-standard
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toSource
+original_slug: Web/JavaScript/Referencje/Obiekty/Boolean/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków z kodem źródłowym obiektu.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>booleanObj</var>.toSource()
+Boolean.toSource()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>toSource</code> zwraca następujące wartości:</p>
+
+<ul>
+ <li>dla wbudowanego obiektu <code>Boolean</code> metoda <code>toSource</code> zwraca następujący łańcuch znaków, oznaczający, że kod źródłowy nie jest dostępny:
+
+  <pre class="brush: js">function Boolean() {
+   [native code]
+}
+</pre>
+ </li>
+</ul>
+
+<ul>
+ <li>dla instancji obiektu <code>Boolean</code> metoda <code>toSource</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li>
+</ul>
+
+<p>Metoda ta jest zwykle stosowana wewnętrznie przez interpreter JavaScriptu, a nie bezpośrednio w kodzie programów.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/boolean/tostring/index.html b/files/pl/web/javascript/reference/global_objects/boolean/tostring/index.html
new file mode 100644
index 0000000000..708dae8151
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/boolean/tostring/index.html
@@ -0,0 +1,42 @@
+---
+title: Boolean.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Boolean/toString
+tags:
+  - Boolean
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/Boolean/toString
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca ciąg znaków reprezentujący dany obiekt Boolean</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>bool</var>.toString()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Obiekt {{jsxref("Boolean")}} przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}, nie dziedziczy metody {{jsxref("Object.prototype.toString()")}}. Dla obiektów <code>Boolean</code> metoda <code>toString</code> zwraca ich tekstową reprezentację.</p>
+
+<p>JavaScript wywołuje metodę <code>toString</code> samoczynnie, kiedy instancja obiektu {{jsxref("Boolean")}} ma być reprezentowana jako wartość tekstowa lub kiedy instancja obiektu {{jsxref("Boolean")}} jest składnikiem konkatenacji ciągu(-ów) znaków.</p>
+
+<p>Dla obiektów i wartości {{jsxref("Boolean")}} wbudowana metoda <code>toString</code> zwraca ciąg znaków "<code>true</code>" lub "<code>false</code>" w zależności od wartości obiektu boolowskiego. W poniższym przykładzie <code>flaga.toString</code> zwraca "<code>true</code>".</p>
+
+<pre class="brush: js">var flaga = new Boolean(true)
+var mojaZmienna=flaga.toString()
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/boolean/valueof/index.html b/files/pl/web/javascript/reference/global_objects/boolean/valueof/index.html
new file mode 100644
index 0000000000..005bde3e87
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/boolean/valueof/index.html
@@ -0,0 +1,44 @@
+---
+title: Boolean.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf
+tags:
+  - Boolean
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf
+original_slug: Web/JavaScript/Referencje/Obiekty/Boolean/valueOf
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca wartość prostą obiektu {{jsxref("Boolean")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>bool</var>.valueOf()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>valueOf</code> obiektu {{jsxref("Boolean")}} zwraca wartość prostą obiektu {{jsxref("Boolean")}} lub literału {{jsxref("Boolean")}} jako typ Boolean.</p>
+
+<p>Metoda ta jest zwykle wywoływana wewnętrznie przez interpreter JavaScriptu, a nie w typowym kodzie w JavaScripcie.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_valueOf" name="Przyk.C5.82ad:_Zastosowanie_valueOf">Przykład: Zastosowanie <code>valueOf</code></h3>
+
+<pre class="brush: js">var x = new Boolean();
+myVar = x.valueOf()      // przypisuje myVar wartość false
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/dataview/index.html b/files/pl/web/javascript/reference/global_objects/dataview/index.html
new file mode 100644
index 0000000000..0df48f7f98
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/dataview/index.html
@@ -0,0 +1,119 @@
+---
+title: DataView
+slug: Web/JavaScript/Reference/Global_Objects/DataView
+translation_of: Web/JavaScript/Reference/Global_Objects/DataView
+original_slug: Web/JavaScript/Referencje/Obiekty/DataView
+---
+<div>{{JSRef}}</div>
+
+<p><strong><code>DataView</code></strong>  udostępnia niskopoziowy interfejs do zapisu i odczytu typów numerycznych w formie {{jsxref("ArrayBuffer")}} niezależnie od kodowania platformy.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">new DataView(buffer [, byteOffset [, byteLength]])</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>buffer</code></dt>
+ <dd>Istniejący {{jsxref("ArrayBuffer")}} lub {{jsxref("SharedArrayBuffer")}} {{experimental_inline}} używany jako pamięć dla  obiektu  <code>DataView</code> .</dd>
+ <dt><code>byteOffset</code> {{optional_inline}}</dt>
+ <dd>The offset, in bytes, to the first byte in the specified buffer for the new view to reference. If not specified, the view of the buffer will start with the first byte.</dd>
+ <dt><code>byteLength</code> {{optional_inline}}</dt>
+ <dd>The number of elements in the byte array. If unspecified, length of the view will match the buffer's length.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>A new <code>DataView</code> object representing the specified data buffer.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<dl>
+ <dt><code>{{jsxref("RangeError")}}</code></dt>
+ <dd>Thrown if the <code>byteOffset</code> and <code>byteLength</code> result in the specified view extending past the end of the buffer.</dd>
+</dl>
+
+<h2 id="Description">Description</h2>
+
+<h3 id="Endianness">Endianness</h3>
+
+<p>Multi-byte number formats are represented in memory differently depending on machine architecture, see {{Glossary("Endianness")}} for an explanation. DataView accessors provide explicit control of how data will be accessed irrespective of the platform architecture's endianness.</p>
+
+<pre class="brush: js">var littleEndian = (function() {
+  var buffer = new ArrayBuffer(2);
+  new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
+  // Int16Array uses the platform's endianness.
+  return new Int16Array(buffer)[0] === 256;
+})();
+console.log(littleEndian); // true or false
+</pre>
+
+<h2 id="Properties">Properties</h2>
+
+<p>All <code>DataView</code> instances inherit from {{jsxref("DataView.prototype")}} and allows the addition of properties to all DataView objects.</p>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Properties')}}</p>
+
+<h2 id="Methods">Methods</h2>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Methods')}}</p>
+
+<h2 id="Example">Example</h2>
+
+<pre class="brush: js">var buffer = new ArrayBuffer(16);
+var dv = new DataView(buffer, 0);
+
+dv.setInt16(1, 42);
+dv.getInt16(1); //42
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('Typed Array')}}</td>
+   <td>{{Spec2('Typed Array')}}</td>
+   <td>Superseded by ECMAScript 6</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition in an ECMA standard</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-dataview-constructor', 'DataView')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+
+
+<p>{{Compat("javascript.builtins.DataView")}}</p>
+
+<h2 id="Compatibility_notes">Compatibility notes</h2>
+
+<p>Starting with Firefox 40, <code>DataView</code> requires to be constructed with a {{jsxref("Operators/new", "new")}} operator. Calling <code>DataView()</code> as a function without <code>new</code>, will throw a {{jsxref("TypeError")}} from now on.</p>
+
+<pre class="brush: js example-bad">var dv = DataView(buffer, 0);
+// TypeError: calling a builtin DataView constructor without new is forbidden</pre>
+
+<pre class="brush: js example-good">var dv = new DataView(buffer, 0);</pre>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a class="link-https" href="https://github.com/jDataView/jDataView">jDataView</a>: JavaScript library that polyfills and extends the <code>DataView</code> API to all browsers and Node.js.</li>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li>{{jsxref("SharedArrayBuffer")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getdate/index.html b/files/pl/web/javascript/reference/global_objects/date/getdate/index.html
new file mode 100644
index 0000000000..5828087a48
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getdate/index.html
@@ -0,0 +1,48 @@
+---
+title: Date.prototype.getDate()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getDate
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getDate
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca dzień miesiąca dla określonej daty stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getDate()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getDate</code> to liczby całkowite z przedziału liczb pomiędzy 1 a 31.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getDate" name="Przyk.C5.82ad:_Zastosowanie_getDate">Przykład: Zastosowanie <code>getDate()</code></h3>
+
+<p>Druga instrukcja poniżej przydziela wartość 25 do zmiennej <code>dzien</code>, wartość oparta na <code>Date</code>, obiektu <code>Xmas95</code>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00");
+var dzien = Xmas95.getDate();
+
+console.log(dzien), // 25
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
+ <li>{{jsxref("Date.prototype.setDate()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getday/index.html b/files/pl/web/javascript/reference/global_objects/date/getday/index.html
new file mode 100644
index 0000000000..021381df42
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getday/index.html
@@ -0,0 +1,48 @@
+---
+title: Date.prototype.getDay()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getDay
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getDay
+---
+<div>{{JSRef("Global_Objects", "Date")}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca dzień tygodnia określonej daty, stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getDay()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartością zwracaną przez <code>getDay</code> jest liczba całkowita, odnosząca się do dnia tygodnia: 0 dla niedzieli, 1 dla poniedziałku, 2 dla wtorku, i tak dalej.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getDay" name="Przyk.C5.82ad:_Zastosowanie_getDay">Przykład: Zastosowanie <code>getDay()</code></h3>
+
+<p>Druga instrukcja poniżej przydziela wartość 1 do <code>dzienTyg</code>, opierając się o wartość <code>Date</code>, obiektu <code>Xmas95</code>. 25 grudnia 1995 roku wypadał w poniedziałek.</p>
+
+<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00");
+var weekday = Xmas95.getDay();
+
+console.log(weekday); // 1
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
+ <li>{{jsxref("Date.prototype.setDate()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getfullyear/index.html b/files/pl/web/javascript/reference/global_objects/date/getfullyear/index.html
new file mode 100644
index 0000000000..bca657a324
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getfullyear/index.html
@@ -0,0 +1,48 @@
+---
+title: Date.prototype.getFullYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getFullYear
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getFullYear
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca rok określonej daty, stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getFullYear()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość <code>getFullYear</code> zwracana jest jako pełna liczba. Dla dat liczba lat zawiera się pomiędzy 1000 i 9999, <code>getFullYear</code> zwraca czterocyfrową liczbę, na przykład: 1995. Użyj tej funkcji, aby być pewnym, że wyświetlona będzie pełna data po roku 2000.</p>
+
+<p>Użyj tej metody zamiast metody <code>getYear</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getFullYear" name="Przyk.C5.82ad:_Zastosowanie_getFullYear">Przykład: Zastosowanie <code>getFullYear</code></h3>
+
+<p>Następujący przykład przydziela czterocyfrową wartość aktualnego roku do zmiennej <code>yr</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var yr = today.getFullYear();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.getYear()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/gethours/index.html b/files/pl/web/javascript/reference/global_objects/date/gethours/index.html
new file mode 100644
index 0000000000..2caecf0633
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/gethours/index.html
@@ -0,0 +1,47 @@
+---
+title: Date.prototype.getHours()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getHours
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getHours
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca godzinę określonej daty, stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getHours()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getHours</code> jest liczbą całkowitą z przedziału od 0 do 23.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getHours" name="Przyk.C5.82ad:_Zastosowanie_getHours">Przykład: Zastosowanie <code>getHours()</code></h3>
+
+<p>Druga instrukcja poniżej przydziela wartość liczby 23 zmiennej <code>hours</code>, opartej o wartość <code>Date</code> obiektu <code>Xmas95</code>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00");
+var hours = Xmas95.getHours();
+
+console.log(hours); // 23
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCHours()")}}</li>
+ <li>{{jsxref("Date.prototype.setHours()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getmilliseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/getmilliseconds/index.html
new file mode 100644
index 0000000000..12762689c8
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getmilliseconds/index.html
@@ -0,0 +1,45 @@
+---
+title: Date.prototype.getMilliseconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getMilliseconds
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca milisekundy określonej daty, stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getMilliseconds()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getMilliseconds</code> jest liczbą pomiędzy 0 a 999.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_getMilliseconds">Przykład: Zastosowanie <code>getMilliseconds()</code></h3>
+
+<p>Następujący przykład przydziela liczbę milisekund aktualnego czasu do zmiennej <code>ms</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var ms = today.getMilliseconds();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getminutes/index.html b/files/pl/web/javascript/reference/global_objects/date/getminutes/index.html
new file mode 100644
index 0000000000..d12e7ab7d7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getminutes/index.html
@@ -0,0 +1,49 @@
+---
+title: Date.prototype.getMinutes()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getMinutes
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getMinutes
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca minuty dla określonej daty w zależności od czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getMinutes()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getMinutes</code> jest liczbą całkowitą z przedziału od 0 do 59.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getMinutes" name="Przyk.C5.82ad:_Zastosowanie_getMinutes">Przykład: Zastosowanie <code>getMinutes</code></h3>
+
+<p>Druga instrukcja poniżej przypisuje wartość 15 do zmiennej <code>minutes</code>, bazując na wartości obiektu <code>Xmas95</code> typu <code>Date</code>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00");
+var minutes = Xmas95.getMinutes();
+
+console.log(minutes); // 15
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<div class="noinclude">
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li>
+ <li>{{jsxref("Date.prototype.setMinutes()")}}</li>
+</ul>
+</div>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getmonth/index.html b/files/pl/web/javascript/reference/global_objects/date/getmonth/index.html
new file mode 100644
index 0000000000..2ed9843375
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getmonth/index.html
@@ -0,0 +1,47 @@
+---
+title: Date.prototype.getMonth()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getMonth
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getMonth
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca miesiąc dla określonej daty w zależności od czasu lokalnego.</p>
+
+<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getMonth()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getMonth</code> jest liczbą całkowitą z przedziału od 0 do 11. 0 reprezentuje styczeń, 1 luty, i tak dalej.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getMonth" name="Przyk.C5.82ad:_Zastosowanie_getMonth">Przykład: Zastosowanie <code>getMonth()</code></h3>
+
+<p>Druga instrukcja z przykładu poniżej przypisuje wartość 11 zmiennej <code>month</code>, bazując na wartości obiektu <code>Xmas95</code> typu <code>Date</code>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:00");
+var month = Xmas95.getMonth();
+
+console.log(month); // 11
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li>
+ <li>{{jsxref("Date.prototype.setMonth()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/getseconds/index.html
new file mode 100644
index 0000000000..228fe5355e
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getseconds/index.html
@@ -0,0 +1,47 @@
+---
+title: Date.prototype.getSeconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getSeconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getSeconds
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca sekundy dla określonej daty w zależności od czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getSeconds()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getSeconds</code> jest liczbą całkowitą z przedziału od 0 do 59.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getSeconds" name="Przyk.C5.82ad:_Zastosowanie_getSeconds">Przykład: Zastosowanie <code>getSeconds()</code></h3>
+
+<p>Druga instrukcja poniżej przypisuje wartość 30 do zmiennej <code>secs</code>, bazując na wartości obiektu <code>Xmas95</code> typu <code>Date</code>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date("December 25, 1995 23:15:30");
+var seconds = Xmas95.getSeconds();
+
+console.log(seconds); // 30
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setSeconds()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/gettime/index.html b/files/pl/web/javascript/reference/global_objects/date/gettime/index.html
new file mode 100644
index 0000000000..9371ea3350
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/gettime/index.html
@@ -0,0 +1,48 @@
+---
+title: Date.prototype.getTime()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getTime
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getTime
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca liczbę reprezentującą czas dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<p>Może być wykorzystana do przypisania daty i czasu do innego obiektu {{jsxref("Date")}}. Ta metoda jest funkcjonalnie równoważna metodzie {{jsxref("Date.valueof", "valueOf()")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getTime()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez metodę <code>getTime</code> jest liczbą milisekund liczoną od 1 stycznia 1970 00:00:00.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getTime" name="Przyk.C5.82ad:_Zastosowanie_getTime">Przykład: Zastosowanie <code>getTime()</code></h3>
+
+<p>Następująca instrukcja przypisuje wartość daty <code>theBigDay</code> do <code>sameAsBigDay</code>:</p>
+
+<pre class="brush: js">var theBigDay = new Date("July 1, 1999");
+var sameAsBigDay = new Date();
+sameAsBigDay.setTime(theBigDay.getTime());
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.setTime()")}}</li>
+ <li>{{jsxref("Date.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html b/files/pl/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html
new file mode 100644
index 0000000000..bf73ff0ea4
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html
@@ -0,0 +1,36 @@
+---
+title: Date.prototype.getTimezoneOffset()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getTimezoneOffset
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca przesunięcie strefy czasowej w minutach dla bieżącej lokalizacji.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getTimezoneOffset()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Przesunięcie strefy czasowej jest to różnica, wyrażona w minutach, pomiędzy <strong>Greenwich Mean Time</strong> (<strong>GMT</strong>) a bieżącym czasem lokalnym. Na przykład, jeśli aktualna strefa to GMT+10, wynikiem jest -600. Wartość nie jest liczbą stałą ze względu na zmiany czasu na letni i zimowy.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h4 id="Przyk.C5.82ad:_Zastosowanie_getTimezoneOffset" name="Przyk.C5.82ad:_Zastosowanie_getTimezoneOffset">Przykład: Zastosowanie <code>getTimezoneOffset()</code></h4>
+
+<pre class="brush: js">var x = new Date();
+var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60;
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcdate/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcdate/index.html
new file mode 100644
index 0000000000..c8dca866f1
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getutcdate/index.html
@@ -0,0 +1,46 @@
+---
+title: Date.prototype.getUTCDate()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCDate
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca dzień (datę) miesiąca dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDate()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartością zwracaną przez <code>getUTCDate</code> jest liczba całkowita z przedziału od 1 do 31.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCDate" name="Przyk.C5.82ad:_Zastosowanie_getUTCDate">Przykład: Zastosowanie <code>getUTCDate()</code></h3>
+
+<p>Następujący przykład przypisuje aktualny dzień miesiąca do zmiennej <code>d</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var d = today.getUTCDate();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getDate()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCDate()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcday/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcday/index.html
new file mode 100644
index 0000000000..89a9b1c090
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getutcday/index.html
@@ -0,0 +1,46 @@
+---
+title: Date.prototype.getUTCDay()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCDay
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca dzień tygodnia dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDay()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getUTCDay</code> jest liczbą całkowitą określającą dzień tygodnia: 0 dla niedzieli, 1 dla poniedziałku, 2 dla wtorku itd.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCDay" name="Przyk.C5.82ad:_Zastosowanie_getUTCDay">Przykład: Zastosowanie <code>getUTCDay()</code></h3>
+
+<p>Następujący przykład przypisuje aktualny dzień tygodnia do zmiennej <code>weekday</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var weekday = today.getUTCDay();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
+ <li>{{jsxref("Date.prototype.getDay()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCDate()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcfullyear/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcfullyear/index.html
new file mode 100644
index 0000000000..f815b1c921
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getutcfullyear/index.html
@@ -0,0 +1,45 @@
+---
+title: Date.prototype.getUTCFullYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCFullYear
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca rok dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCFullYear()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartością zwracaną przez <code>getUTCFullYear</code> jest dodatnia liczba całkowita, zgodna z rokiem 2000, na przykład 1995.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCFullYear" name="Przyk.C5.82ad:_Zastosowanie_getUTCFullYear">Przykład: Zastosowanie <code>getUTCFullYear()</code></h3>
+
+<p>Następujący przykład przypisuje czterocyfrową liczbę aktualnego roku do zmiennej <code>yr</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var year = today.getUTCFullYear();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getutchours/index.html b/files/pl/web/javascript/reference/global_objects/date/getutchours/index.html
new file mode 100644
index 0000000000..0ff3ff5fc5
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getutchours/index.html
@@ -0,0 +1,45 @@
+---
+title: Date.prototype.getUTCHours()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCHours
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca godziny dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCHours()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getUTCHours</code> jest liczbą całkowitą z przedziału od 0 do 23.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCHours" name="Przyk.C5.82ad:_Zastosowanie_getUTCHours">Przykład: Zastosowanie <code>getUTCHours()</code></h3>
+
+<p>Następujący przykład przypisuje część aktualnej daty określającą godzinę do zmiennej <code>hrs</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var hours = today.getUTCHours();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getHours()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html
new file mode 100644
index 0000000000..8c3603a46d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html
@@ -0,0 +1,45 @@
+---
+title: Date.prototype.getUTCMilliseconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCMilliseconds
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca milisekundy dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMilliseconds()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana <code>getUTCMilliseconds</code> jest liczbą całkowitą z przedziału od 0 do 999.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_getUTCMilliseconds">Przykład: Zastosowanie <code>getUTCMilliseconds()</code></h3>
+
+<p>Następujący przykład przypisuje część aktualnej daty określającą liczbę milisekund do zmiennej <code>ms</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var ms = today.getUTCMilliseconds();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcminutes/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcminutes/index.html
new file mode 100644
index 0000000000..d83258052f
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getutcminutes/index.html
@@ -0,0 +1,45 @@
+---
+title: Date.prototype.getUTCMinutes()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCMinutes
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca minuty dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMinutes()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getUTCMinutes()</code> jest liczbą całkowitą z przedziału od 0 do 59.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCMinutes" name="Przyk.C5.82ad:_Zastosowanie_getUTCMinutes">Przykład: Zastosowanie <code>getUTCMinutes()</code></h3>
+
+<p>Następujący przykład przypisuje część aktualnej daty określającą minuty do zmiennej <code>min</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var min = today.getUTCMinutes();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMinutes()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcmonth/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcmonth/index.html
new file mode 100644
index 0000000000..9bb65f2552
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getutcmonth/index.html
@@ -0,0 +1,45 @@
+---
+title: Date.prototype.getUTCMonth()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCMonth
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca miesiąc dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMonth()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getUTCMonth()</code> jest liczbą całkowitą z przedziału od 0 do 11 odpowiadającą miesiącowi: 0 dla stycznia, 1 dla lutego, 2 dla marca, i tak dalej.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCMonth" name="Przyk.C5.82ad:_Zastosowanie_getUTCMonth">Przykład: Zastosowanie <code>getUTCMonth()</code></h3>
+
+<p>Następujący przykład przypisuje aktualny miesiąc do zmiennej <code>mon</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var mon = today.getUTCMonth();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMonth()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getutcseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/getutcseconds/index.html
new file mode 100644
index 0000000000..b20f50a93d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getutcseconds/index.html
@@ -0,0 +1,45 @@
+---
+title: Date.prototype.getUTCSeconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getUTCSeconds
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca sekundy dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCSeconds()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>getUTCSeconds()</code> jest liczbą całkowitą z przedziału od 0 do 59.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_getUTCSeconds" name="Przyk.C5.82ad:_Zastosowanie_getUTCSeconds">Przykład: Zastosowanie <code>getUTCSeconds()</code></h3>
+
+<p>Następujący przykład przypisuje część aktualnej daty określającą liczbę sekund do zmiennej <code>sec</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var sec = today.getUTCSeconds();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getSeconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/getyear/index.html b/files/pl/web/javascript/reference/global_objects/date/getyear/index.html
new file mode 100644
index 0000000000..b8186a6e7e
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/getyear/index.html
@@ -0,0 +1,98 @@
+---
+title: Date.prototype.getYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getYear
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/getYear
+---
+<p>{{JSRef}}{{ Deprecated_header() }}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca rok dla określonej daty w zależności od czasu lokalnego. Metoda <code>getYear</code> nie jest dłużej wykorzystywana i została zastąpiona metodą {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getYear()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>getYear</code> zwraca rok minus 1900; tak więc:</p>
+
+<ul>
+ <li>Dla lat późniejszych lub równych 2000, wartość zwracana przez <code>getYear</code> wynosi 100 lub więcej. Przykładowo, dla roku 2026, <code>getYear</code> zwraca 126.</li>
+</ul>
+
+<ul>
+ <li>Dla lat pomiędzy i włącznie z latami 1900 i 1999, wartość zwracana przez <code>getYear</code> zawiera się w przedziale od 0 do 99. Na przykład, jeśli mamy rok 1976, <code>getYear</code> zwraca 76.</li>
+</ul>
+
+<ul>
+ <li>Dla lat wcześniejszych niż 1900, wartość zwracana przez <code>getYear</code> jest mniejsza niż 0. Na przykład, dla roku 1800, <code>getYear</code> zwraca -100.</li>
+</ul>
+
+<p>Aby obsłużyć lata zarówno przed jak i po roku 2000, należy zamiast <code>getYear</code> użyć metody {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}, która zwraca pełną liczbę określającą rok.</p>
+
+<h2 id="Kompatybilno.C5.9B.C4.87_wsteczna" name="Kompatybilno.C5.9B.C4.87_wsteczna">Kompatybilność wstecz</h2>
+
+<h3 id="JavaScript_1.2_i_wersje_wcze.C5.9Bniejsze" name="JavaScript_1.2_i_wersje_wcze.C5.9Bniejsze">JavaScript 1.2 i wersje wcześniejsze</h3>
+
+<p>Metoda <code>getYear()</code> zwraca rok w formacie 2-cyfrowym lub 4-cyfrowym:</p>
+
+<ul>
+ <li>Dla roczników pomiędzy i włącznie z latami 1900 i 1999, wartość zwracana przez <code>getYear</code> jest to rok minus 1900. Na przykład, dla roku 1976 będzie to liczba 76.</li>
+</ul>
+
+<ul>
+ <li>Dla roczników niższych niż 1900 lub wyższych niż 1999, wartość zwracana przez <code>getYear</code> jest cztero-cyfrowa. Na przykład, dla roku 1856, wartość jest równa 1856. Dla roku 2026, wartość wynosi 2026.</li>
+</ul>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Lata_pomi.C4.99dzy_1900_i_1999" name="Przyk.C5.82ad:_Lata_pomi.C4.99dzy_1900_i_1999">Przykład: Lata pomiędzy 1900 i 1999</h3>
+
+<p>Druga instrukcja przypisuje wartość 95 do zmiennej <code>year</code>.</p>
+
+<pre class="brush: js">var Xmas = new Date("December 25, 1995 23:15:00");
+var year = Xmas.getYear(); // zwraca 95
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Lata_powy.C5.BCej_1999" name="Przyk.C5.82ad:_Lata_powy.C5.BCej_1999">Przykład: Lata powyżej 1999</h3>
+
+<p>Druga instrukcja przypisuje wartość 100 do zmiennej <code>year</code>.</p>
+
+<pre class="brush: js">var Xmas = new Date("December 25, 2000 23:15:00");
+var year = Xmas.getYear(); // zwraca 100
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Lata_powy.C5.BCej_1900" name="Przyk.C5.82ad:_Lata_powy.C5.BCej_1900">Przykład: Lata poniżej 1900</h3>
+
+<p>Druga instrukcja przypisuje wartość -100 do zmiennej <code>year</code>.</p>
+
+<pre class="brush: js">var Xmas = new Date("December 25, 1800 23:15:00");
+var year = Xmas.getYear(); // zwraca -100
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Ustawienie_i_pobieranie_lat_pomi.C4.99dzy_1900_i_1999" name="Przyk.C5.82ad:_Ustawienie_i_pobieranie_lat_pomi.C4.99dzy_1900_i_1999">Przykład: Ustawianie i pobieranie roku pomiędzy 1900 i 1999</h3>
+
+<p>Druga instrukcja przypisuje wartość 95 do zmiennej <code>year</code>, reprezentując rok 1995.</p>
+
+<pre class="brush: js">var Xmas.setYear(95);
+var year = Xmas.getYear(); // zwraca 95
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setYear()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/index.html b/files/pl/web/javascript/reference/global_objects/date/index.html
new file mode 100644
index 0000000000..2b74956882
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/index.html
@@ -0,0 +1,139 @@
+---
+title: Date
+slug: Web/JavaScript/Reference/Global_Objects/Date
+tags:
+  - Date
+  - JavaScript
+  - data
+translation_of: Web/JavaScript/Reference/Global_Objects/Date
+original_slug: Web/JavaScript/Referencje/Obiekty/Date
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Tworzy instancje <code>Date</code>, które pozwalają na pracę z danymi opisującymi datę i czas.</p>
+
+<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia</h2>
+
+<pre class="syntaxbox"><code>new Date();
+new Date(<em>milisekundy</em>);
+new Date(<em>dateString</em>);
+new Date(<em>rok</em>, <em>indeksMiesiąca </em>[, <em>dzień </em>[, <em>godzina </em>[, <em>minuta </em>[, <em>sekunda </em>[, <em>milisekunda</em>]]]]]);
+</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>milisekundy</code> </dt>
+ <dd>Wartość całkowita reprezentująca liczbę milisekund od 1 stycznia 1970, godz. 00:00:00 UTC.</dd>
+</dl>
+
+<dl>
+ <dt><code>dateString</code> </dt>
+ <dd>Łańcuch znaków reprezentujący datę. Łańcuch znaków powinien być w formacie rozpoznawalnym przez metodę <a href="/pl/Dokumentacja_j%C4%99zyka_JavaScript_1.5/Obiekty/Date/parse" title="pl/Dokumentacja_języka_JavaScript_1.5/Obiekty/Date/parse">parse</a>.</dd>
+</dl>
+
+<dl>
+ <dt><code>rok</code></dt>
+ <dd>Wartość całkowita reprezentująca rok. Dla zgodności (w celu uniknięcia problemu roku 2000) należy zawsze określać rok w pełnej formie, używając raczej <code>1998</code> niż <code>98</code>.</dd>
+</dl>
+
+<dl>
+ <dt><code>indeksMiesiąca</code></dt>
+ <dd>Wartość całkowita reprezentująca miesiąc, począwszy od 0 dla stycznia, kończąc na 11 dla grudnia.</dd>
+</dl>
+
+<dl>
+ <dt><code>dzień</code></dt>
+ <dd>Wartość całkowita reprezentująca dzień miesiąca.</dd>
+</dl>
+
+<dl>
+ <dt><code>godzina</code></dt>
+ <dd>Wartość całkowita reprezentująca godzinę (w formacie 24-godzinnym).</dd>
+</dl>
+
+<dl>
+ <dt><code>minuta</code></dt>
+ <dd>Wartość całkowita reprezentująca część minutową odczytywanego czasu.</dd>
+</dl>
+
+<dl>
+ <dt><code>second</code></dt>
+ <dd>Wartość całkowita reprezentująca część sekundową odczytywanego czasu.</dd>
+</dl>
+
+<dl>
+ <dt><code>millisecond</code></dt>
+ <dd>Wartość całkowita reprezentująca część milisekundową odczytywanego czasu.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie dostarczasz żadnych argumentów, konstruktor tworzy obiekt <code>Date</code> dla dzisiejszej daty i czasu stosownie do czasu lokalnego. Jeśli dostarczasz jakieś argumenty, lecz nie wszystkie, brakujące argumenty mają ustawioną wartość 0. Jeśli jednak dostarczasz jakieś argumenty, musisz dostarczyć co najmniej rok, miesiąc i dzień. Pominąć możesz godzinę, minuty, sekundy i milisekundy.</p>
+
+<p>Data jest mierzona w milisekundach od północy 1 stycznia 1970 UTC. W jednym dniu jest 86,400,000 milisekund. Zakres wartości obiektu <code>Date</code> wynosi od -100,000,000 dni do 100,000,000 dni w stosunku do 01 stycznia 1970 UTC.</p>
+
+<p>Obiekt <code>Date</code> zapewnia jednolite działanie bez względu na platformę.</p>
+
+<p>Obiekt <code>Date</code> wspiera wiele metod UTC (uniwersalny czas światowy) i metody czasu lokalnego. UTC, także znany jako <em>Greenwich Mean Time</em> (GMT), odnosi się do czasu ustanowionego przez "światowy standard czasu" (ang. World Time Standard). Czas lokalny jest czasem, który zna komputer, na jakim jest wykonywany JavaScript.</p>
+
+<p>Dla kompatybilności z obliczeniami milenijnymi (inaczej, syndromem roku 2000), powinieneś zawsze określić pełen rok, czyli na przykład, używa 1998, nie 98. Aby pomóc Ci w określeniu całego roku, JavaScript zawiera metody {{jsxref("Date.prototype.getFullYear()")}}, {{jsxref("Date.prototype.setFullYear()")}}, {{jsxref("Date.getUTCFullYear()")}} i {{jsxref("Date.setUTCFullYear()")}}.</p>
+
+<p>Odwoływanie się do <code>Date </code>w kontekście innym niż konstruktor (np. bez operatora {{jsxref("new")}}) będzie zwracało ciąg reprezentujący aktualny czas.</p>
+
+<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2>
+
+<dl>
+ <dt>{{jsxref("Date.prototype")}}</dt>
+ <dd>Pozwala dodać własności do obiektu <code>Date</code>.</dd>
+ <dt><code>Date.length</code></dt>
+ <dd>The value of <code>Date.length</code> is 7. This is the number of arguments handled by the constructor.</dd>
+ <dt>
+ <div>{{jsOverrides("Function", "properties", "prototype")}}</div>
+ </dt>
+</dl>
+
+<h2 id="Metody_statyczne" name="Metody_statyczne">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("Date.now()")}}</dt>
+ <dd>Zwraca wartość liczbową odnoszącą się do aktualnego czasu.</dd>
+ <dt>{{jsxref("Date.parse()")}}</dt>
+ <dd>Zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 czasu lokalnego do daty podanej jako argument string.</dd>
+ <dt>{{jsxref("Date.UTC()")}}</dt>
+ <dd>Zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 czasu uniwersalnego do daty podanej jako zestaw liczb (parametry jak w najdłuższej formie konstruktora).</dd>
+</dl>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Kilka_sposob.C3.B3w_na_przypisywanie_dat" name="Przyk.C5.82ad:_Kilka_sposob.C3.B3w_na_przypisywanie_dat">Przykład: Kilka sposobów na przypisywanie dat</h3>
+
+<p>Poniżej przedstawiono kilka przykładowych przypisań dat:</p>
+
+<pre class="brush: js">var dzisiaj = new Date();
+var urodziny = new Date("December 17, 1995 03:24:00");
+var urodziny = new Date(1995,11,17);
+var urodziny = new Date(1995,11,17,3,24,0);
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Obliczanie_czasu_trwania" name="Przyk.C5.82ad:_Obliczanie_czasu_trwania">Przykład: Obliczanie czasu trwania</h3>
+
+<p>Poniższy przykład pokazuje, jak określić czas, jaki minął pomiędzy dwoma datami:</p>
+
+<pre class="brush: js">// używając metod statycznych
+var start = Date.now();
+// zdarzenie, dla którego chciałbyś zmierzyć czas trwania:
+zrobCosPrzezDlugiCzas();
+var stop = Date.now();
+var roznica_czasow = stop - start; // czas w milisekundach
+</pre>
+
+<pre class="brush: js">// wykorzystując obiekty Date
+var start = new Date();
+// zdarzenie, dla którego chciałbyś zmierzyć czas trwania:
+zrobCosPrzezDlugiCzas();
+var stop = new Date();
+var roznica_czasow = stop.getTime() - start.getTime(); // czas w milisekundach
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/date/now/index.html b/files/pl/web/javascript/reference/global_objects/date/now/index.html
new file mode 100644
index 0000000000..4bffd676df
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/now/index.html
@@ -0,0 +1,44 @@
+---
+title: Date.now()
+slug: Web/JavaScript/Reference/Global_Objects/Date/now
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/now
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/now
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca liczbę milisekund, która upłynęła od 1 stycznia 1970 00:00:00 UTC.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>var timeInMs = Date.now();</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda now zwraca milisekundy, które upłynęły od 1 stycznia 1970 00:00:00 UTC do teraz w postaci obiektu {{jsxref("Number")}}.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_now" name="Przyk.C5.82ad:_Zastosowanie_now">Przykład: Zastosowanie <code>now</code></h3>
+
+<p>Poniższy przykład używa <code>now</code> do stworzenia znacznika czasu.</p>
+
+<pre class="brush: js">var timestamp = Date.now();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{domxref("Performance.now()")}}</li>
+ <li>{{domxref("Console.time()")}} / {{domxref("Console.timeEnd()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/parse/index.html b/files/pl/web/javascript/reference/global_objects/date/parse/index.html
new file mode 100644
index 0000000000..49cd5c9441
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/parse/index.html
@@ -0,0 +1,75 @@
+---
+title: Date.parse()
+slug: Web/JavaScript/Reference/Global_Objects/Date/parse
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/parse
+---
+<div> {{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Analizuje łańcuch znaków reprezentujący datę i zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 UTC.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Date.parse(<var>dateString</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>dateString</code> </dt>
+ <dd>Łańcuch znaków reprezentujący datę.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>parse</code> pobiera łańcuch znaków daty (na przykład: "<code>Dec 25, 1995</code>") i zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970, 00:00:00 UTC. Gdy parametr nie zawiera informacji na temat strefy czasowej, domyślnie używana jest lokalna strefa czasowa. Ta funkcja jest przydatna do ustawiania wartości daty w oparciu o wartość łańcucha znaków, przykładowo w połączeniu z metodą {{jsxref("Date.prototype.setTime()", "setTime()")}} oraz obiektem {{jsxref("Date")}}.</p>
+
+<p>Dla podanego łańcucha znaków reprezentującego czas, <code>parse</code> zwraca wartość czasu. Akceptuje składnię standardu daty - IETF: "<code>Mon, 25 Dec 1995 13:30:00 GMT</code>". Rozpoznaje skróty kontynentalnej strefy czasowej US, lecz w ogólnym zastosowaniu używa się przesunięć dla strefy czasowej, na przykład: "<code>Mon, 25 Dec 1995 13:30:00 GMT+0430</code>" (4 godziny i 30 minut na zachód od południka Greenwich). Jeśli nie określono strefy czasowej, domyślna jest strefa lokalna. GMT i UTC są rozpatrywane jako równoważne.</p>
+
+<p>Mimo iż specyfikatory strefy czasowej są brane pod uwagę podczas analizy łańcucha znaków do prawidłowej interpretacji argumentu, nie wpływają one jednak na zwracaną wartość, którą zawsze jest ilość milisekund pomiędzy 1 stycznia 1970 roku, 00:00:00 UTC a punktem w czasie reprezentowanym przez argument.</p>
+
+<p>Ponieważ <code>parse</code> jest metodą statyczną obiektu <code>Date</code>, używamy jej jako <code>Date.parse()</code>, raczej niż jako wywołanie metody utworzonego przez nas obiektu <code>Date</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_parse" name="Przyk.C5.82ad:_Zastosowanie_parse">Przykład: Zastosowanie <code>parse</code></h3>
+
+<p>Jeśli <code>IPOdate</code> jest istniejącym obiektem <code>Date</code>, możemy przypisać mu wartość 9 sierpnia 1995 (czasu lokalnego) w następujący sposób:</p>
+
+<pre class="brush: js">IPOdate.setTime(Date.parse("Aug 9, 1995")) ;
+</pre>
+
+<p>Kilka innych przykładów:</p>
+
+<pre class="brush: js">// Zwraca 807937200000 w strefie czasowej GMT-0300, i inne wartości dla innych stref
+// czasowych, ponieważ argument nie specyfikuje strefy czasowej.
+Date.parse("Aug 9, 1995");</pre>
+
+<pre class="brush: js">// Zwraca 807926400000 niezależnie od lokalnej strefy czasowej.
+Date.parse("Wed, 09 Aug 1995 00:00:00 GMT");</pre>
+
+<pre class="brush: js">// Zwraca 807937200000 w strefie czasowej GMT-0300, a inne wartości w innych
+// strefach czasowych, ponieważ strefa nie jest wyspecyfikowana w argumencie.
+Date.parse("Wed, 09 Aug 1995 00:00:00");</pre>
+
+<pre class="brush: js">// Zwraca 0 niezależnie od lokalnej strefy czasowej.
+Date.parse("Thu, 01 Jan 1970 00:00:00 GMT");</pre>
+
+<pre class="brush: js">// Zwraca 14400000 w strefie czasowej GMT-0400, a inne wartości w innych
+// strefach czasowych, ponieważ strefa nie jest podana w argumencie.
+Date.parse("Thu, 01 Jan 1970 00:00:00");</pre>
+
+<pre class="brush: js">// Zwraca 14400000 niezależnie od lokalnej strefy czasowej.
+Date.parse("Thu, 01 Jan 1970 00:00:00 GMT-0400");</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.UTC()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setdate/index.html b/files/pl/web/javascript/reference/global_objects/date/setdate/index.html
new file mode 100644
index 0000000000..f0569b5eac
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setdate/index.html
@@ -0,0 +1,44 @@
+---
+title: Date.prototype.setDate()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setDate
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setDate
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia dzień miesiąca dla określonej daty stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setDate(<var>dayValue</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>dayValue</code> </dt>
+ <dd>Liczba całkowita z przedziału od 1 do 31, reprezentująca dzień miesiąca.</dd>
+</dl>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setDate" name="Przyk.C5.82ad:_Zastosowanie_setDate">Przykład: Zastosowanie <code>setDate()</code></h3>
+
+<p>Druga instrukcja poniżej zmienia dzień miesiąca dla zmiennej <code>theBigDay</code> z jego oryginalnej wartości na 24 lipca.</p>
+
+<pre class="brush: js">var theBigDay = new Date("July 27, 1962 23:30:00");
+var theBigDay.setDate(24);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getDate()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCDate()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setfullyear/index.html b/files/pl/web/javascript/reference/global_objects/date/setfullyear/index.html
new file mode 100644
index 0000000000..c119547e86
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setfullyear/index.html
@@ -0,0 +1,59 @@
+---
+title: Date.prototype.setFullYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setFullYear
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setFullYear
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia kompletny rok dla określonej daty stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>yearValue</code> </dt>
+ <dd>Liczba całkowita określająca wartość numeryczną roku, na przykład; 1995.</dd>
+</dl>
+
+<dl>
+ <dt><code>monthValue</code> </dt>
+ <dd>Liczba całkowita z przedziału od 0 do 11 (reprezentująca miesiące od stycznia do grudnia).</dd>
+</dl>
+
+<dl>
+ <dt><code>dayValue</code> </dt>
+ <dd>Liczba całkowita z przedziału od 1 do 31 reprezentująca dzień miesiąca. Jeśli zostaje podany parametr <code>dayValue</code>, należzy również podać <code>monthValue</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie zostały podane parametry <code>monthValue</code> i <code>dayValue</code>, biblioteka pobierze te dane z metod {{jsxref("Date.prototype.getMonth()", "getMonth()")}} i {{jsxref("Date.prototype.getDate()", "getDate()")}}.</p>
+
+<p>Jeżeli określony parametr jest poza oczekiwanym zakresem, <code>setFullYear()</code> spróbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Przykładowo, jeśli zostanie podana wartość 15 dla <code>monthValue</code> to rok zostanie zwiększony o 1 (rok+1), a miesiąc zostanie ustawiony na wartość 3.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setFullYear" name="Przyk.C5.82ad:_Zastosowanie_setFullYear">Przykład: Zastosowanie <code>setFullYear()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setFullYear(1997);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setYear()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/sethours/index.html b/files/pl/web/javascript/reference/global_objects/date/sethours/index.html
new file mode 100644
index 0000000000..c621fd575a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/sethours/index.html
@@ -0,0 +1,67 @@
+---
+title: Date.prototype.setHours()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setHours
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setHours
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia godziny dla określonej daty stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre>
+
+<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>)</code></pre>
+
+<h2 id="Parametry" name="Parametry">Parametry</h2>
+
+<dl>
+ <dt><code>hoursValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 23, reprezentująca godziny.</dd>
+</dl>
+
+<dl>
+ <dt><code>minutesValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca minuty.</dd>
+</dl>
+
+<dl>
+ <dt><code>secondsValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, musisz także określić <code>minutesValue</code>.</dd>
+</dl>
+
+<dl>
+ <dt><code>msValue</code> </dt>
+ <dd>A Liczba pomiędzy 0 i 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, musisz także określić <code>minutesValue</code> i <code>secondsValue</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie określisz parametrów <code>minutesValue</code>, <code>secondsValue</code> i <code>msValue</code>, wartość zwracana użytych metod {{jsxref("Date.prototype.getMinutes()", "getMinutes()")}}, {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} i {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setHours</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty będą wzrastać o 1 (min + 1), i wartość 40 będzie użyta dla sekund.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad_Zastosowanie_setHours" name="Przyk.C5.82ad:_Zastosowanie_setHours">Przykład: Zastosowanie <code>setHours()</code></h3>
+
+<pre class="brush: js">var the BigDay = new Date();
+theBigDay.setHours(7);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getHours()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setmilliseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/setmilliseconds/index.html
new file mode 100644
index 0000000000..1e33e8f97a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setmilliseconds/index.html
@@ -0,0 +1,46 @@
+---
+title: Date.prototype.setMilliseconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setMilliseconds
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia milisekundy dla określonej daty stosownie do czasu lokalnego.</p>
+
+<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setMilliseconds(<var>millisecondsValue</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>millisecondsValue</code> </dt>
+ <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli sprecyzujesz liczbę z poza oczekiwanego szeregu, informacje zawarte w obiekcie <code>Date</code> będą aktualizowane. Na przykład, jeśli określisz 1005, liczba sekund rośnie o 1, i 5 jest użyte dla milisekund.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_setMilliseconds">Przykład: Zastosowanie <code>setMilliseconds()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setMilliseconds(100);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setminutes/index.html b/files/pl/web/javascript/reference/global_objects/date/setminutes/index.html
new file mode 100644
index 0000000000..737598c146
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setminutes/index.html
@@ -0,0 +1,61 @@
+---
+title: Date.prototype.setMinutes()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setMinutes
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setMinutes
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia minuty dla określonej daty stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre>
+
+<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>minutesValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca minuty.</dd>
+</dl>
+
+<dl>
+ <dt><code>secondsValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, musisz także określić <code>minutesValue</code>.</dd>
+</dl>
+
+<dl>
+ <dt><code>msValue</code> </dt>
+ <dd>Liczba pomiędzy 0 i 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, musisz także określić <code>minutesValue</code> i <code>secondsValue</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie określono parametrów <code>secondsValue</code> i <code>msValue</code>, są użyte wartości zwracanych metod <code>getSeconds</code> i <code>getMilliseconds</code>.</p>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setMinutes</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty (<code>minutesValue</code>) będą wzrastać o 1 (<code>minutesValue</code> + 1) i wartość 40 będzie użyta dla sekund.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setMinutes" name="Przyk.C5.82ad:_Zastosowanie_setMinutes">Przykład: Zastosowanie <code>setMinutes()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setMinutes(45);</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMinutes()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setmonth/index.html b/files/pl/web/javascript/reference/global_objects/date/setmonth/index.html
new file mode 100644
index 0000000000..c9dcbbea7f
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setmonth/index.html
@@ -0,0 +1,57 @@
+---
+title: Date.prototype.setMonth()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setMonth
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setMonth
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia nazwę miesiąca dla określonej daty stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre>
+
+<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>)</code></pre>
+
+<h3 id="Parameter" name="Parameter">Parametry</h3>
+
+<dl>
+ <dt><code>monthValue</code> </dt>
+ <dd>Liczba całkowita z przedziału 0 i 11 (reprezentuje miesiące od stycznia do grudnia).</dd>
+</dl>
+
+<dl>
+ <dt><code>dayValue</code> </dt>
+ <dd>Liczba całkowita z przedziału 1 i 31, reprezentuje dzień miesiąca.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie określisz parametru <code>dayValue</code>, zostanie zwrócona wartość użytej metody <code>getDate</code>.</p>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setMonth()</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 15 dla <code>monthValue</code>, rok wzrośnie o 1 (year + 1) i 3 będzie użyte dla miesiąca.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setMonth" name="Przyk.C5.82ad:_Zastosowanie_setMonth">Przykład: Zastosowanie <code>setMonth()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date;
+theBigDay.setMonth(6);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMonth()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/setseconds/index.html
new file mode 100644
index 0000000000..e2af3ab2b7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setseconds/index.html
@@ -0,0 +1,57 @@
+---
+title: Date.prototype.setSeconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setSeconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setSeconds
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia sekundy dla określonej daty stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre>
+
+<h3 id="Do_wersji_JavaScript_1.3" name="Do_wersji_JavaScript_1.3">Do wersji JavaScript 1.3</h3>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>)</code></pre>
+
+<h2 id="Parametry" name="Parametry">Parametry</h2>
+
+<dl>
+ <dt><code>secondsValue</code> </dt>
+ <dd>Liczba całkowita z przedziału 0 i 59.</dd>
+</dl>
+
+<dl>
+ <dt><code>msValue</code> </dt>
+ <dd>Liczba z przedziału 0 i 999, reprezentująca milisekundy.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie określisz parametru <code>msValue</code>, wartość zwracana użytej metody {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setSeconds()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty zawarte w obiekcie {{jsxref("Date")}} będą wzrastać o 1 i wartość 40 będzie użyta dla sekund.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setSeconds" name="Przyk.C5.82ad:_Zastosowanie_setSeconds">Przykład: Zastosowanie <code>setSeconds()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setSeconds(30);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getSeconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/settime/index.html b/files/pl/web/javascript/reference/global_objects/date/settime/index.html
new file mode 100644
index 0000000000..c2f6c15564
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/settime/index.html
@@ -0,0 +1,47 @@
+---
+title: Date.prototype.setTime()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setTime
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setTime
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setTime
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia wartość obiektu {{jsxref("Date")}} stosownie do czasu lokalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setTime(<var>timeValue</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>timeValue</code> </dt>
+ <dd>Liczba całkowita reprezentująca liczbę milisekund liczonych od 1 stycznia 1970, 00:00:00.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Użyj metody <code>setTime()</code>, aby pomóc przydzielić dacie czas następnego obiektu {{jsxref("Date")}}.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setTime" name="Przyk.C5.82ad:_Zastosowanie_setTime">Przykład: Zastosowanie <code>setTime()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date("July 1, 1999");
+var sameAsBigDay = new Date();
+sameAsBigDay.setTime(theBigDay.getTime())
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getTime()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcdate/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcdate/index.html
new file mode 100644
index 0000000000..efae5bb77b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setutcdate/index.html
@@ -0,0 +1,46 @@
+---
+title: Date.prototype.setUTCDate()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCDate
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia dzień miesiąca dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setUTCDate(<var>dayValue</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>dayValue</code> </dt>
+ <dd>Liczba całkowita od 1 do 31, reprezentująca dni miesiąca.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCDate()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 40 dla <code>dayValue</code>, i nazwa miesiąca jaki jest w danym momencie przechowywany w obiekcie {{jsxref("Date")}} będzie czerwcem, to do dni przypiszemy wartość 10, ale wyświetlaną nazwą miesiąca będzie już lipiec.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCDate" name="Przyk.C5.82ad:_Zastosowanie_setUTCDate">Przykład: Zastosowanie <code>setUTCDate()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setUTCDate(20);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
+ <li>{{jsxref("Date.prototype.setDate()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcfullyear/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcfullyear/index.html
new file mode 100644
index 0000000000..f87b25b50d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setutcfullyear/index.html
@@ -0,0 +1,58 @@
+---
+title: Date.prototype.setUTCFullYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCFullYear
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia pełen rok dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setUTCFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>yearValue</code> </dt>
+ <dd>Liczba całkowita określająca numerycznie wartość roku, na przykład: 1995.</dd>
+</dl>
+
+<dl>
+ <dt><code>monthValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 a 11, reprezentuje nazwy miesięcy, od stycznia do grudnia.</dd>
+</dl>
+
+<dl>
+ <dt><code>dayValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 1 a 31, reprezentuje dzień miesiąca. Jeśli określimy parametr <code>dayValue</code>, to musimy także sprecyzować <code>monthValue</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie określisz parametrów <code>monthValue</code> i <code>dayValue</code>, wartość zwracana metod {{jsxref("Date.prototype.getUTCMonth()", "getUTCMonth()")}} i {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}} jest w użyciu.</p>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCFullYear()</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 15 dla <code>monthValue</code>, lata będą wzrastać o 1 (rok + 1), i 3 jest użyta jako miesiąc.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCFullYear" name="Przyk.C5.82ad:_Zastosowanie_setUTCFullYear">Przykład: Zastosowanie <code>setUTCFullYear()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setUTCFullYear(1997);
+</pre>
+
+<h3 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h3>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setutchours/index.html b/files/pl/web/javascript/reference/global_objects/date/setutchours/index.html
new file mode 100644
index 0000000000..66b51f50e5
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setutchours/index.html
@@ -0,0 +1,63 @@
+---
+title: Date.prototype.setUTCHours()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCHours
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia godzinę dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setUTCHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>hoursValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 a 23, reprezentująca godzinę.</dd>
+</dl>
+
+<dl>
+ <dt><code>minutesValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 a 59, reprezentująca minutami.</dd>
+</dl>
+
+<dl>
+ <dt><code>secondsValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 a 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, to musisz także określić parametr <code>minutesValue</code>.</dd>
+</dl>
+
+<dl>
+ <dt><code>msValue</code> </dt>
+ <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, to musisz także określić parametry <code>minutesValue</code> i <code>secondsValue</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie określisz parametrów <code>minutesValue</code>, <code>secondsValue</code> i <code>msValue</code>, wartość zwracana będzie użytych metod {{jsxref("Date.prototype.getUTCMinutes()", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} i {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCHours()</code> próbuje zaktualizować informacje o dacie w obiekcie <code>Date</code>. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty zawarte w obiekcie <code>Date</code> będą wzrastać o 1 i wartość 40 będzie użyta dla sekund.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCHours" name="Przyk.C5.82ad:_Zastosowanie_setUTCHours">Przykład: Zastosowanie <code>setUTCHours()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setUTCHours(8);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCHours()")}}</li>
+ <li>{{jsxref("Date.prototype.setHours()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html
new file mode 100644
index 0000000000..e9360b2e0f
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html
@@ -0,0 +1,46 @@
+---
+title: Date.prototype.UTCMilliseconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCMilliseconds
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia milisekundy dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMilliseconds(<var>millisecondsValue</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>millisecondsValue</code> </dt>
+ <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli parametr, który określiłeś jest z poza szeregu, <code>setUTCMilliseconds()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz 1100 dla <code>millisecondsValue</code>, sekunda przechowana w obiekcie {{jsxref("Date")}} wzrośnie o 1 i wartość 100 będzie użyta dla milisekund.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h4 id="Przyk.C5.82ad:_Zastosowanie_setUTCMilliseconds" name="Przyk.C5.82ad:_Zastosowanie_setUTCMilliseconds">Przykład: Zastosowanie <code>setUTCMilliseconds()</code></h4>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setUTCMilliseconds(500);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcminutes/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcminutes/index.html
new file mode 100644
index 0000000000..c99dadaa2b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setutcminutes/index.html
@@ -0,0 +1,58 @@
+---
+title: Date.prototype.setUTCMinutes()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCMinutes
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia minuty dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>minutesValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca minuty.</dd>
+</dl>
+
+<dl>
+ <dt><code>secondsValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 59, reprezentująca sekundy. Jeśli określisz parametr <code>secondsValue</code>, musisz także określić <code>minutesValue</code>.</dd>
+</dl>
+
+<dl>
+ <dt><code>msValue</code> </dt>
+ <dd>Liczba pomiędzy 0 i 999, reprezentująca milisekundy. Jeśli określisz parametr <code>msValue</code>, musisz także określić <code>minutesValue</code> i <code>secondsValue</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie określono parametrów <code>secondsValue</code> i <code>msValue</code>, są użyte wartości zwracanych metod {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} i {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCMinutes()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty (<code>minutesValue</code>) będą wzrastać o 1 (<code>minutesValue</code> + 1) i wartość 40 będzie użyta dla sekund.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCMinutes" name="Przyk.C5.82ad:_Zastosowanie_setUTCMinutes">Przykład: Zastosowanie <code>setUTCMinutes()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setUTCMinutes(43);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li>
+ <li>{{jsxref("Date.prototype.setMinutes()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcmonth/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcmonth/index.html
new file mode 100644
index 0000000000..3d8947802e
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setutcmonth/index.html
@@ -0,0 +1,53 @@
+---
+title: Date.prototype.setUTCMonth()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCMonth
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia miesiąc dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>monthValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 a 11, reprezentująca nazwy miesięcy od stycznia do grudnia.</dd>
+</dl>
+
+<dl>
+ <dt><code>dayValue</code> </dt>
+ <dd>Liczba całkowita od 1 do 31, reprezentująca dzień miesiąca.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie określisz parametru <code>dayValue</code>, zostanie zwrócona wartość użytej metody {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}}.</p>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCMonth()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 15 dla <code>monthValue</code>, rok wzrośnie o 1 (rok + 1) i 3, które pozostało będzie użyte dla miesiąca.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCMonth" name="Przyk.C5.82ad:_Zastosowanie_setUTCMonth">Przykład: Zastosowanie <code>setUTCMonth()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setUTCMonth(11);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li>
+ <li>{{jsxref("Date.prototype.setMonth()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setutcseconds/index.html b/files/pl/web/javascript/reference/global_objects/date/setutcseconds/index.html
new file mode 100644
index 0000000000..adf4079334
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setutcseconds/index.html
@@ -0,0 +1,53 @@
+---
+title: Date.prototype.setUTCSeconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setUTCSeconds
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia sekundy dla określonej daty stosownie do czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setUTCSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>secondsValue</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 a 59.</dd>
+</dl>
+
+<dl>
+ <dt><code>msValue</code> </dt>
+ <dd>Liczba pomiędzy 0 a 999, reprezentująca milisekundy.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli nie określisz parametru <code>msValue</code>, wartość zwracana jest z użytej metody {jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p>
+
+<p>Jeśli Twój parametr jest określony z poza szeregu, <code>setUTCSeconds()</code> próbuje zaktualizować informacje o dacie w obiekcie {{jsxref("Date")}}. Na przykład, jeśli użyjesz wartości 100 dla <code>secondsValue</code>, minuty zawarte w obiekcie {{jsxref("Date")}} będą wzrastać o 1 i wartość 40 będzie użyta dla sekund.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setUTCSeconds" name="Przyk.C5.82ad:_Zastosowanie_setUTCSeconds">Przykład: Zastosowanie <code>setUTCSeconds()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date();
+theBigDay.setUTCSeconds(20);
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setSeconds()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/setyear/index.html b/files/pl/web/javascript/reference/global_objects/date/setyear/index.html
new file mode 100644
index 0000000000..932dda7f51
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/setyear/index.html
@@ -0,0 +1,53 @@
+---
+title: Date.prototype.setYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setYear
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setYear
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/setYear
+---
+<p>{{jSRef}}{{ Deprecated_header() }}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Ustawia rok dla określonej daty stosownie do czasu lokalnego. Aby móc korzystać z roczników przed i po roku 2000, powinieneś użyć metody {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} zawierającej <code>setYear()</code>, która rok potrafi określić w pełni.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setYear(<var>yearValue</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>yearValue</code> </dt>
+ <dd>Liczba całkowita.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli <code>yearValue</code> jest liczbą pomiędzy 0 a 99 (inclusive), to rok dla <code>dateObjectName</code> jest ustawiany - 1900 + <code>yearValue</code>. W innym przypadku, rok dla <code>dateObjectName</code> jest ustawiany w postaci wyświetlenia <code>yearValue</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_setYear" name="Przyk.C5.82ad:_Zastosowanie_setYear">Przykład: Zastosowanie <code>setYear()</code></h3>
+
+<p>Dwie pierwsze linie ustawiają rok w dacie na 1996. Trzecia ustawia rok na 2000.</p>
+
+<pre class="brush: js">var theBigDay = new Date();
+
+theBigDay.setYear(96)
+theBigDay.setYear(1996)
+theBigDay.setYear(2000)
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/togmtstring/index.html b/files/pl/web/javascript/reference/global_objects/date/togmtstring/index.html
new file mode 100644
index 0000000000..8b82e892a3
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/togmtstring/index.html
@@ -0,0 +1,45 @@
+---
+title: Date.prototype.toGMTString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toGMTString
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toGMTString
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/toGMTString
+---
+<p>{{JSRef}}{{ Deprecated_header() }}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Konwertuje datę na łańcuch znaków używając konwersji czasu GMT. Dokładny format zwracanych wartości <code>toGMTString()</code> różni się w zależności platformy.</p>
+
+<div class="note">
+<p>Metoda <code>toGMTString</code> jest nie długo używana i została ona zastąpiona metodą {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}. Powinieneś używać {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}} zamiast <code>toGMTSTring</code>().</p>
+</div>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toGMTString()</code></pre>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_toGMTString" name="Przyk.C5.82ad:_Zastosowanie_toGMTString">Przykład: Zastosowanie <code>toGMTString()</code></h3>
+
+<p>W następującym przykładzie jest dzisiejsza data obiektu <code>Date</code>:</p>
+
+<pre class="brush: js">var today = new Date();
+var str = today.toGMTString();
+
+console.log(str); // Mon, 18 Dec 1995 17:28:35 GMT</pre>
+
+<p>W tym przykładzie metoda <code>toGMTString</code> konwertuje datę w czasie GMT (UTC) używanego przez system operacyjny w odpowiedniej strefie czasowej i zwraca wartość łańcucha znaków, która jest podobna do następującej formy. Format jest w pełni zależny od platformy.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toUTCString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/tojson/index.html b/files/pl/web/javascript/reference/global_objects/date/tojson/index.html
new file mode 100644
index 0000000000..b5b3110291
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/tojson/index.html
@@ -0,0 +1,71 @@
+---
+title: Date.prototype.toJSON()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toJSON
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toJSON
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/toJSON
+---
+<div>{{JSRef}}</div>
+
+<div>Zwraca objekt {{jsxref("Date")}} w postaci tekstu.</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toJSON()</code>
+</pre>
+
+<h2 id="Opis">Opis</h2>
+
+<p><code>toJSON()</code> zwraca ciąg znaków (using {{jsxref("Date.prototype.toISOString()", "toISOString()")}}) reprezentujący wartość obiektu {{jsxref("Date")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_toJSON()">Użycie <code>toJSON()</code></h3>
+
+<pre class="brush:js">var jsonDate = (new Date()).toJSON();
+var backToDate = new Date(jsonDate);
+
+console.log(jsonDate); //2015-10-26T07:46:36.611Z
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.44', 'Date.prototype.toJSON')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Początkowa definicja zaimplementowana w JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność">Kompatybilność</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toJSON")}}</p>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toUTCString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/tolocaledatestring/index.html b/files/pl/web/javascript/reference/global_objects/date/tolocaledatestring/index.html
new file mode 100644
index 0000000000..103db5d284
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/tolocaledatestring/index.html
@@ -0,0 +1,56 @@
+---
+title: Date.prototype.toLocaleDateString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/toLocaleDateString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca "date", porcje daty jako łańcuch znaków, używając aktualnych lokalnych konwersji.</p>
+
+<p>Metoda <code>toLocaleDateString</code> polega na znalezieniu formatu daty w systemie operacyjnym. Konwertuje datę do łańcucha znakowego używając konwencji formatowania systemu operacyjnego, gdzie skrypt jest uruchomiony. Na przykład, w USA, miesiąc pojawia się przed dniem (04/15/98), gdzie w Niemczech data wyświetla miesiąc po dniu (15.04.98). Jeśli system operacyjny nie używa, nie spełnia roku 2000 i nie używa pełnego roku dla lat przed 1900 lub po 2000, <code>toLocaleDateString</code> zwraca łańcuch znakowy, który nie jest uległy wobec roku 2000. <code>toLocaleDateString</code> postępuje podobnie do <code>toString</code>, kiedy konwertuje rok, który system operacyjny ma w niewłaściwym formacie.</p>
+
+<p>Metody takie jak <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getHours">getHours</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getMinutes">getMinutes</a></code> i <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getSeconds">getSeconds</a></code> dają więcej przenośnych rezultatów niż <code>toLocaleDateString</code>.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleDateString([<var>locales</var> [, <var>options</var>]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Check the {{anch("Browser compatibility")}} section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleDateString$edit#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div>
+
+<p>The default value for each date-time component property is {{jsxref("Global_Objects/undefined", "undefined")}}, but if the <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code> properties are all {{jsxref("Global_Objects/undefined", "undefined")}}, then <code>year</code>, <code>month</code>, and <code>day</code> are assumed to be <code>"numeric"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_toLocaleDateString" name="Przyk.C5.82ad:_Zastosowanie_toLocaleDateString">Przykład: Zastosowanie <code>toLocaleDateString()</code></h3>
+
+<p>Następujący przykład <code>today</code> jest obiektem <code>Date</code>:</p>
+
+<pre class="brush: js">var today = new Date(95,11,18,17,28,35) //miesiąc jest reprezentowany przez liczby od 0 do 11
+today.toLocaleDateString()
+</pre>
+
+<p>W tym przykładzie, <code>toLocaleDateString</code> zwraca łańcuch znakowy, który jest podobny do poniższej formy. Dokładny format, jaki znajduje się na platformie.</p>
+
+<pre>12/18/95
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/tolocalestring/index.html b/files/pl/web/javascript/reference/global_objects/date/tolocalestring/index.html
new file mode 100644
index 0000000000..3735e6885b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/tolocalestring/index.html
@@ -0,0 +1,52 @@
+---
+title: Date.prototype.toLocaleString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/toLocaleString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Konwertuje datę na łańcuch znakowy, używając aktualnej lokalnej konwersji.</p>
+
+<p>Metoda <code>toLocaleString</code> polega na znalezieniu formatu daty w systemie operacyjnym. Konwertuje datę do łańcucha znakowego używając konwencji formatowania systemu operacyjnego, gdzie skrypt jest uruchomiony. Na przykład, w USA, miesiąc pojawia się przed dniem (<b>04</b>/15/98), gdzie w Niemczech data wyświetla miesiąc, zaraz po dniu (15.<b>04</b>.98). Jeśli system operacyjny nie używa, nie spełnia roku 2000 i nie używa pełnego roku dla lat przed 1900 lub po 2000, <code>toLocaleString</code> zwraca łańcuch znakowy, który nie jest uległy wobec roku 2000. <code>toLocaleString</code> postępuje podobnie do <code>toString</code>, kiedy konwertuje rok, który system operacyjny ma w niewłaściwym formacie.</p>
+
+<p>Metody, takie jak <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getHours">getHours</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getMinutes">getMinutes</a></code> i <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getSeconds">getSeconds</a></code> dają więcej przenośnych rezultatów niż <code>toLocaleString</code></p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleString([<var>locales</var>[, <var>options</var>]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Check the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleString$edit#Browser_Compatibility">Browser compatibility</a> section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleString$edit#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div>
+
+<p>The default value for each date-time component property is {{jsxref("Global_Objects/undefined", "undefined")}}, but if the <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, <code>second</code> properties are all {{jsxref("Global_Objects/undefined", "undefined")}}, then <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, and <code>second</code> are assumed to be <code>"numeric"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Zastosowanie_toLocaleString" name="Zastosowanie_toLocaleString">Zastosowanie <code>toLocaleString()</code></h3>
+
+<p>W następującym przykładzie, obiekt <code>today</code> jest <code>Date</code>:</p>
+
+<pre class="brush: js">var today = new Date(95,11,18,17,28,35); //miesiące są reprezentowane poprzez liczby od 0 do 11
+today.toLocaleString(); // 12/18/95 17:28:35</pre>
+
+<p>W tym przykładzie, <code>toLocaleString</code> zwraca łańcuch znaków, który jest podobny do następującej formy. Dokładnie to taki format, jaki jest w systemie.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/tolocaletimestring/index.html b/files/pl/web/javascript/reference/global_objects/date/tolocaletimestring/index.html
new file mode 100644
index 0000000000..4e87a02b41
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/tolocaletimestring/index.html
@@ -0,0 +1,53 @@
+---
+title: Date.prototype.toLocaleTimeString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/toLocaleTimeString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca "czas", porcje daty jako łańcuch znaków, używając aktualnych lokalnych konwersji.</p>
+
+<p>Metoda <code>toLocaleTimeString</code> polega na znalezieniu formatu daty w systemie operacyjnym. Konwertuje datę do łańcucha znakowego używając konwencji formatowania systemu operacyjnego, gdzie skrypt jest uruchomiony. Na przykład, w USA, miesiąc pojawia się przed dniem (04/15/98), gdzie w Niemczech data wyświetla miesiąc po dniu (15.04.98). Jeśli system operacyjny nie używa, nie spełnia roku 2000 i nie używa pełnego roku dla lat przed 1900 lub po 2000, <code>toLocaleTimeString</code> zwraca łańcuch znakowy, który nie jest uległy wobec roku 2000. <code>toLocaleTimeString</code> postępuje podobnie do <code>toString</code>, kiedy konwertuje rok, który system operacyjny ma w nie właściwym formacie.</p>
+
+<p>Metody takie jak <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getHours">getHours</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getMinutes">getMinutes</a></code> i <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Date/getSeconds">getSeconds</a></code> dają więcej podobnych rezultatów niż <code>toLocaleTimeString</code>.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleTimeString([<var>locales</var>[, <var>options</var>]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Check the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleTimeString$edit#Browser_Compatibility">Browser compatibility</a> section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Date/toLocaleTimeString$edit#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div>
+
+<p>The default value for each date-time component property is {{jsxref("Global_Objects/undefined", "undefined")}}, but if the <code>hour</code>, <code>minute</code>, <code>second</code> properties are all {{jsxref("Global_Objects/undefined", "undefined")}}, then <code>hour</code>, <code>minute</code>, and <code>second</code> are assumed to be <code>"numeric"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h4 id="Zastosowanie_toLocaleTimeString" name="Zastosowanie_toLocaleTimeString">Zastosowanie <code>toLocaleTimeString()</code></h4>
+
+<p>W następującym przykładzie, <code>today</code> jest obiektem <code>Date</code> object:</p>
+
+<pre class="brush: js">var today = new Date(95,11,18,17,28,35); //miesiące są reprezentowane przez liczby od 0 do 11
+today.toLocaleTimeString(); // 17:28:35</pre>
+
+<p>W tym przykładzie, <code>toLocaleTimeString</code> zwraca wartość łańcucha znakowego, która jest podobna do następującej formy. Dokładny format, jaki znajduje się na platformie.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/tosource/index.html b/files/pl/web/javascript/reference/global_objects/date/tosource/index.html
new file mode 100644
index 0000000000..6019f0d46b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/tosource/index.html
@@ -0,0 +1,50 @@
+---
+title: Date.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toSource
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toSource
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący kod źródłowy obiektu.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toSource()
+Date.toSource()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h3 id="Opis" name="Opis">Opis</h3>
+
+<p>Metoda <code>toSource()</code> zwraca następującą wartość:</p>
+
+<ul>
+ <li>Dla wewnętrznej budowy obiekt {{jsxref("Date")}}, <code>toSource()</code> zwraca następujący łańcuch znaków sygnalizując, który kod źródłowy jest nieosiągalny:</li>
+</ul>
+
+<pre class="brush: js">function Date() {
+   [native code]
+}
+</pre>
+
+<ul>
+ <li>Dla instancji {{jsxref("Date")}}, <code>toSource()</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li>
+</ul>
+
+<p>Ta metoda jest często nazywana wewnętrzną metodą JavaScript i jest nie wyraźna w kodzie.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/tostring/index.html b/files/pl/web/javascript/reference/global_objects/date/tostring/index.html
new file mode 100644
index 0000000000..d19870e9b2
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/tostring/index.html
@@ -0,0 +1,50 @@
+---
+title: Date.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toString
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/toString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków, reprezentujący określony obiekt <code>Date</code>.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toString()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Obiekt {{jsxref("Date")}} przesłania metodę <code>toString</code> z obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref("Date")}}, metoda <code>toString()</code> zwraca łańcuch znaków, które reprezentują obiekt.</p>
+
+<p>JavaScript wywołuje metodę <code>toString()</code> automatycznie wtedy, gdy data jest reprezentowana jako wartość tekstowa lub kieruje powiązanym łańcuchem znaków.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_toString" name="Przyk.C5.82ad:_Zastosowanie_toString">Przykład: Zastosowanie <code>toString()</code></h3>
+
+<p>Następujący przykład przydziela <code>toString</code> wartość obiektu <code>Date</code> do <code>myVar</code>:</p>
+
+<pre class="brush: js">var x = new Date();
+myVar=x.toString();   //przydziela wartość myVar, podobnie do:
+// Mon Sep 28 14:36:22 GMT-0700 (Pacific Daylight Time) 1998
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+ <li>{{jsxref("Date.prototype.toDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/toutcstring/index.html b/files/pl/web/javascript/reference/global_objects/date/toutcstring/index.html
new file mode 100644
index 0000000000..c185e5b46d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/toutcstring/index.html
@@ -0,0 +1,44 @@
+---
+title: Date.prototype.toUTCString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toUTCString
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toUTCString
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/toUTCString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Konwertuje datę na łańcuch znaków, używając do konwersji czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toUTCString()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość zwracana przez <code>toUTCString()</code> jest sformatowanym i tylko do odczytu łańcuchem znaków, stosowanym do konwersji UTC. Wartość zwracanego formatu może być określona stosownie do platformy.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_toUTCString" name="Przyk.C5.82ad:_Zastosowanie_toUTCString">Przykład: Zastosowanie <code>toUTCString()</code></h3>
+
+<pre class="brush: js  language-js">var today = new Date();
+var UTCstring = today.toUTCString();
+<code class="language-js"><span class="token comment">// Mon, 03 Jul 2006 21:44:38 GMT</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date.prototype.toDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toISOString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/utc/index.html b/files/pl/web/javascript/reference/global_objects/date/utc/index.html
new file mode 100644
index 0000000000..21cbba9e24
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/utc/index.html
@@ -0,0 +1,70 @@
+---
+title: Date.UTC()
+slug: Web/JavaScript/Reference/Global_Objects/Date/UTC
+tags:
+  - Date
+  - JavaScript
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/UTC
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Akceptuje te same parametry co najdłuższa forma konstruktora i zwraca liczbę milisekund w obiekcie {{jsxref("Date")}}, które upłynęły od 1 stycznia, 1970, 00:00:00, czasu uniwersalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Date.UTC(<em>rok</em>,<em> miesiąc</em>[,<em> dzień</em>[,<em> godz</em>[,<em> min</em>[,<em> sek</em>[, ms]]]]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>rok</code> </dt>
+ <dd>Rok po 1900.</dd>
+ <dt><code>miesiąc</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 11 reprezentująca miesiąc.</dd>
+ <dt><code>dzień</code> </dt>
+ <dd>Liczba całkowita pomiędzy 1 i 31 reprezentująca dzień miesiąca.</dd>
+ <dt><code>godz</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 23 reprezentująca godziny.</dd>
+ <dt><code>min</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 59 reprezentująca minuty.</dd>
+ <dt><code>sek</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 59 reprezentująca sekundy.</dd>
+ <dt><code>ms</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0 i 999 reprezentująca milisekundy.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>UTC</code> pobiera parametry daty oddzielone za pomocą przecinków i zwraca liczbę milisekund między 1 stycznia, 1970, 00:00:00, czasu uniwersalnego a określoną datą.</p>
+
+<p>Powinno używać się pełnego zapisu roku, na przykład 1998. Jeśli określony jest rok z przedziału pomiędzy 0 a 99, metoda konwertuje go do roku w 20 wieku (1900 + rok); na przykład, jeśli określiłeś go jako 95, zostanie użyty rok 1995.</p>
+
+<p>Metoda <code>UTC</code> różni się od konstruktora {{jsxref("Date")}} na dwa sposoby.</p>
+
+<ul>
+ <li><code>Date.UTC</code> używa czasu uniwersalnego zamiast lokalnego.</li>
+ <li><code>Date.UTC</code> zwraca wartość czasu jako liczbę zamiast tworzenia obiektu typu {{jsxref("Date")}}.</li>
+</ul>
+
+<p>Jeśli parametr określony jest poza spodziewanym zasięgiem, metoda <code>UTC</code> zaktualizuje pozostałe parametry. Na przykład, jeśli użyjesz liczby 15 do określenia miesiąca, wartość parametru <code>rok</code> zostanie powiększona o 1 (rok + 1), a 3 zostanie użyte w parametrze <code>miesiąc</code>.</p>
+
+<p>Ponieważ <code>UTC</code> jest statyczną metodą obiektu {{jsxref("Date")}}, zawsze powinno używać się jej jako <code>Date.UTC()</code>, niż jako metodę utworzonego obiektu {{jsxref("Date")}}.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Date.UTC" name="Przyk.C5.82ad:_Zastosowanie_Date.UTC">Przykład: Zastosowanie <code>Date.UTC()</code></h3>
+
+<p>Następująca instrukcja tworzy obiekt <code>Date</code> używający GMT (czasu uniwersalnego) zamiast czasu lokalnego:</p>
+
+<pre class="brush: js">var utcDate = new Date(Date.UTC(96, 11, 1, 0, 0, 0));
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.parse()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/date/valueof/index.html b/files/pl/web/javascript/reference/global_objects/date/valueof/index.html
new file mode 100644
index 0000000000..7cf5d666fc
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/date/valueof/index.html
@@ -0,0 +1,47 @@
+---
+title: Date.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/Date/valueOf
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/valueOf
+original_slug: Web/JavaScript/Referencje/Obiekty/Date/valueOf
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca prymitywną wartość obiektu <code>Date</code>.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.valueOf()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h3 id="Opis" name="Opis">Opis</h3>
+
+<p>Metoda <code>valueOf</code> zwraca wartość prymitywną obiektu {{jsxref("Date")}} jako typ danych liczbowych, czyli liczbę milisekund od północy 1 stycznia 1970 UTC.</p>
+
+<p>Ta metoda jest funkcyjnie równoważna do metody {{jsxref("Date.prototype.getTime()")}}.</p>
+
+<p>Ta metoda często jest nazywana wewnętrzną metodą JavaScriptu i nie jest wyraźna w kodzie.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_valueOf" name="Przyk.C5.82ad:_Zastosowanie_valueOf">Przykład: Zastosowanie <code>valueOf()</code></h3>
+
+<pre class="brush: js">var x = new Date(56, 6, 17);
+var myVar = x.valueOf();      // przydziela -424713600000 do myVar
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+ <li>{{jsxref("Date.prototype.getTime()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/decodeuri/index.html b/files/pl/web/javascript/reference/global_objects/decodeuri/index.html
new file mode 100644
index 0000000000..5563376592
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/decodeuri/index.html
@@ -0,0 +1,40 @@
+---
+title: decodeURI()
+slug: Web/JavaScript/Reference/Global_Objects/decodeURI
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/decodeURI
+original_slug: Web/JavaScript/Referencje/Obiekty/decodeURI
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Dekoduje Jednolity Identyfikator Zasobu (URI) utworzony wcześniej przez funkcję {{jsxref("encodeURI", "encodeURI()")}} lub podobną.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>decodeURI(<i>encodedURI</i>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>encodedURI</code> </dt>
+ <dd>Kompletny, odkodowany Jednolity Identyfikator Zasobu.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Podmienia każdą sekwencję ucieczki (ang.
+ <i>escape sequence</i>
+ ) w zakodowanym URI znakiem, który reprezentuje.</p>
+
+<p>Nie dekoduje sekwencji, które nie mogłyby być wprowadzone przez {{jsxref("encodeURI", "encodeURI()")}}.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li>
+ <li>{{jsxref("encodeURI", "encodeURI()")}}</li>
+ <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/decodeuricomponent/index.html b/files/pl/web/javascript/reference/global_objects/decodeuricomponent/index.html
new file mode 100644
index 0000000000..b14a436859
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/decodeuricomponent/index.html
@@ -0,0 +1,42 @@
+---
+title: decodeURIComponent()
+slug: Web/JavaScript/Reference/Global_Objects/decodeURIComponent
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent
+original_slug: Web/JavaScript/Referencje/Obiekty/decodeURIComponent
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Dekoduje komponent Jednolitego Identyfikatora Zasobu (URI) stworzonego przez {{jsxref("encodeURIComponent", "encodeURIComponent()")}} lub podobną.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>decodeURIComponent(<em>encodedURI</em>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>encodedURI</code> </dt>
+ <dd>Odkodowany komponent Jednolitego Identyfikatora Zasobu.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Podmienia każdą sekwencję ucieczki (ang.
+ <i>escape sequence</i>
+ ) w zakodowanym komponencie URI znakiem, który ona reprezentuje.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("decodeURI", "decodeURI()")}}</li>
+ <li>{{jsxref("encodeURI", "encodeURI()")}}</li>
+ <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/encodeuri/index.html b/files/pl/web/javascript/reference/global_objects/encodeuri/index.html
new file mode 100644
index 0000000000..52229240b8
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/encodeuri/index.html
@@ -0,0 +1,73 @@
+---
+title: encodeURI()
+slug: Web/JavaScript/Reference/Global_Objects/encodeURI
+tags:
+  - JavaScript
+  - URI
+translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI
+original_slug: Web/JavaScript/Referencje/Obiekty/encodeURI
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Koduje Jednolity Identyfikator Zasobu (URI) poprzez zamianę każdego z wystąpień pewnych znaków na jedną, dwie lub trzy sekwencje ucieczki (ang.
+ <i>escape sequences</i>
+ ) kodowania UTF-8 danego znaku.</p>
+
+<h2 id="Syntax" name="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><code>encodeURI(<em>URI</em>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>URI</code> </dt>
+ <dd>Kompletny Jednolity Identyfikator Zasobu.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Zakłada się, iż URI jest kompletnym URI, więc nie koduje znaków zarezerwowanych, mających specjalne znaczenie w URI.</p>
+
+<p><code>encodeURI</code> zamienia wszystkie znaki, poza podanymi poniżej, odpowiednimi sekwencjami ucieczki.</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header">Typ</td>
+   <td class="header">Zawiera</td>
+  </tr>
+  <tr>
+   <td>Znaki zarezerwowane</td>
+   <td><code>; , / ? : @ &amp; = + $</code></td>
+  </tr>
+  <tr>
+   <td>Znaki nie podlegające ucieczce</td>
+   <td>Litery, cyfry, <code>- _ . ! ~ * ' ( )</code></td>
+  </tr>
+  <tr>
+   <td>
+    <i>Score</i>
+   </td>
+   <td><code>#</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Zauważ, że <code>encodeURI</code> samo z siebie
+
+ <i>nie</i>
+ potrafi utworzyć poprawnych żądań HTTP GET i POST, jak na przykład XMLHTTPRequest, ponieważ "&amp;", "+", i "=" nie są kodowane, a są traktowane jako znaki specjalne w żądaniach GET i POST. Jednakże, {{jsxref("encodeURIComponent", "encodeURIComponent()")}}, koduje te znaki. Zachowania te są konsekwentnie wspomagane przez różne przeglądarki.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("decodeURI", "decodeURI()")}}</li>
+ <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li>
+ <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/encodeuricomponent/index.html b/files/pl/web/javascript/reference/global_objects/encodeuricomponent/index.html
new file mode 100644
index 0000000000..2c694bc5ba
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/encodeuricomponent/index.html
@@ -0,0 +1,39 @@
+---
+title: encodeURIComponent()
+slug: Web/JavaScript/Reference/Global_Objects/encodeURIComponent
+tags:
+  - JavaScript
+  - URI
+translation_of: Web/JavaScript/Reference/Global_Objects/encodeURIComponent
+original_slug: Web/JavaScript/Referencje/Obiekty/encodeURIComponent
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Koduje każdy komponent Jednolitego Identyfikatora Zasobu (URI) poprzez zamianę, każdego wystąpienia pewnych znaków jedną, dwoma lub trzema sekwencjami ucieczki reprezentujące kodowanie UTF-8 znaku.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox">encodeURIComponent(str);</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>str</code></dt>
+ <dd>Komponent Jednolitego Identyfikatora Zasobu.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>encodeURIComponent()</code> zamienia wszystkie znaki na sekwencje ucieczki poza znakami: alfabetycznymi, cyframi, <code>- _ . ! ~ * ' ( )</code></p>
+
+<p>Ze względów bezpieczeństwa, powinieneś wywoływać <code>encodeURIComponent</code> na każdym parametrze podanym przez użytkownika, który będzie podany jako część URI. Na przykład, użytkownik mógł wpisać "<code>Thyme &amp;time=again</code>" dla zmiennej <code>comment</code>. Nie użycie <code>encodeURIComponent</code> na tej zmiennej da <code>comment=Thyme%20&amp;time=again</code>. Zauważ, że znak ampersand (<em>&amp;</em>) i znak równości (<em>=</em> ) oznaczają nową parę kluczy i wartość. Więc, zamiast wysyłać klucz <code>comment</code> równy <code>Thyme &amp;time=again</code>, dostaniesz dwa klucze POST, jeden równy "Thyme" , a drugi (<code>time</code>) równy again.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("decodeURI", "decodeURI()")}}</li>
+ <li>{{jsxref("encodeURI", "encodeURI()")}}</li>
+ <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/error/columnnumber/index.html b/files/pl/web/javascript/reference/global_objects/error/columnnumber/index.html
new file mode 100644
index 0000000000..ac83ab1f07
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/error/columnnumber/index.html
@@ -0,0 +1,82 @@
+---
+title: Error.prototype.columnNumber
+slug: Web/JavaScript/Reference/Global_Objects/Error/columnNumber
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/columnNumber
+original_slug: Web/JavaScript/Referencje/Obiekty/Error/columnNumber
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>The <code><strong>columnNumber</strong></code> property contains the column number in the line of the file that raised this error.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_columnNumber">Using <code>columnNumber</code></h3>
+
+<pre class="brush: js">var e = new Error('Could not parse input');
+throw e;
+console.log(e.columnNumber) // 0
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<p>Not part of any specification. Non-standard.</p>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/error/filename/index.html b/files/pl/web/javascript/reference/global_objects/error/filename/index.html
new file mode 100644
index 0000000000..b6533ba106
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/error/filename/index.html
@@ -0,0 +1,50 @@
+---
+title: Error.prototype.fileName
+slug: Web/JavaScript/Reference/Global_Objects/Error/fileName
+tags:
+  - JavaScript
+  - Prototyp
+  - Prototype
+  - Właściwość
+  - niestandardowe
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/fileName
+original_slug: Web/JavaScript/Referencje/Obiekty/Error/fileName
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Właściwość <code><strong>fileName</strong></code> zawiera ścieżkę do pliku, który spowodował błąd.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Ta nieopisana w żadnym standardzie właściwość zawiera ścieżkę do pliku, który spowodował błąd. Jeśli jest wywoływana z kontekstu debuggera, jak na przykład Firefox Developer Tools, zwracana jest wartość "debugger eval code".</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_fileName">Użycie <code>fileName</code></h3>
+
+<pre class="brush: js">var e = new Error('Błąd przy parsowaniu wejścia');
+throw e;
+// wartość e.fileName powinna być czymś podobnym do "file:///C:/example.html"
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<p><span class="pl-s">Nie jest częścią żadnego standardu.</span></p>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.fileName")}}</p>
+</div>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.stack")}}</li>
+ <li>{{jsxref("Error.prototype.columnNumber")}}</li>
+ <li>{{jsxref("Error.prototype.lineNumber")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/error/index.html b/files/pl/web/javascript/reference/global_objects/error/index.html
new file mode 100644
index 0000000000..2d61bfdb38
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/error/index.html
@@ -0,0 +1,247 @@
+---
+title: Error
+slug: Web/JavaScript/Reference/Global_Objects/Error
+tags:
+  - Błąd
+  - CustomError
+  - Error
+  - JavaScript
+  - Obsługa błędów
+translation_of: Web/JavaScript/Reference/Global_Objects/Error
+original_slug: Web/JavaScript/Referencje/Obiekty/Error
+---
+<div>{{JSRef}}</div>
+
+<div>Kontruktor klasy <strong><code>Error</code></strong> tworzy obiekt błędu. Instancja klasy <code>Error</code> jest rzucana w momencie napotkania błędu w trakcie wykonywania programu. Klasa <code>Error</code> może być także używana do tworzenia własnych wyjątków. Poniżej przestawione zostaną wbudowane standardowe typy błędów.</div>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate">new Error([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>message</code></dt>
+ <dd>Opcjonalny. Opis błędu zrozumiały dla użytkownika.</dd>
+ <dt><code>fileName</code> {{non-standard_inline}}</dt>
+ <dd>Opcjonalny. Wartość dla parametru <code>fileName</code> przy tworzeniu obiektu <code>Error</code>. Domyślnie to nazwa pliku zawierającego kod, który wywołał konstruktor.</dd>
+ <dt><code>lineNumber</code> {{non-standard_inline}}</dt>
+ <dd>Opcjonalny. Wartość dla paramteru <code>lineNumber</code> przy tworzeniu obiektu <code>Error</code>. Domyślnie zawiera numer linijki zawirającej wywołanie konstruktora klasy <code>Error</code>.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Błędy w trakcie wykonywania programu skutkują utworzeniem i rzuceniem nowego obiektu <code>Error</code>.</p>
+
+<p>This page documents the use of the <code>Error</code> object itself and its use as a constructor function. For a list of properties and methods inherited by <code>Error</code> instances, see {{jsxref("Error.prototype")}}.</p>
+
+
+
+<h3 id="Używanie_jako_funkcja">Używanie jako funkcja</h3>
+
+<p>Gdy <code>Error</code> jest używany jako funkcja -- bez słowa kluczowego <code>new</code>, zwraca on obiekt <code>Error</code>. Możemy więc zauważyć, że zwykłe wywołanie <code>Error</code> zwróci nam to samo co stworznie nowego obiektu <code>Error</code> przy pomocy słowa kluczowego <code>new</code>.</p>
+
+<pre class="notranslate"><code>// to:
+const x = Error('Jestem stworzony przy pomocy wyowałania funkcji!');
+​​​​// działa tak samo jak to:
+const y = new Error('Jestem stworzony przy pomocy słowa kluczowego "new"!');</code></pre>
+
+
+
+<h3 id="Typy_błędów">Typy błędów</h3>
+
+<p>Oprócz konstruktora generycznego <code>Error</code>, mamy jeszcze siedem innych podstawowych konstruktorów błędów w JavaScript. Dla wyjątów po stronie klienta zobacz <a href="/en-US/docs/Web/JavaScript/Guide/Statements#Exception_Handling_Statements">Exception Handling Statements</a>.</p>
+
+<dl>
+ <dt>{{jsxref("EvalError")}}</dt>
+ <dd>Tworzy instancje reprezentującą błąd dotyczący globalnej funkcji {{jsxref("Global_Objects/eval", "eval()")}}.</dd>
+ <dt>{{jsxref("InternalError")}} {{non-standard_inline}}</dt>
+ <dd>Tworzy instancje reprezentującą błąd, który występuje w momencie wyrzucenia wewnętrznego błędu silnika JavaScript np. "too much recursion".</dd>
+ <dt>{{jsxref("RangeError")}}</dt>
+ <dd>Tworzy instancje reprezentującą błąd, który występuje w momencie gdy zmienna numeryczna lub parametr wyjdzie poza zakres. </dd>
+ <dt>{{jsxref("ReferenceError")}}</dt>
+ <dd>Tworzy instancje reprezentującą błąd, który występuje przy próbie odwołania do nieistniejącego zasobu.</dd>
+ <dt>{{jsxref("SyntaxError")}}</dt>
+ <dd>Tworzy instancje reprezentującą błąd składni, który występuje przy parsowaniu kodu przy pomocy {{jsxref("Global_Objects/eval", "eval()")}}.</dd>
+ <dt>{{jsxref("TypeError")}}</dt>
+ <dd>Tworzy instancję reprezentującą błąd, który występuje gdy zmienna lub parametr mają niepoprawny typ.</dd>
+ <dt>{{jsxref("URIError")}}</dt>
+ <dd>Tworzy instancję reprezentującą błąd, który występuje gdy {{jsxref("Global_Objects/encodeURI", "encodeURI()")}} i {{jsxref("Global_Objects/decodeURI", "decodeURI()")}} mają przekazane nieprawidłowe parametry.</dd>
+</dl>
+
+<h2 id="Właściwości">Właściwości</h2>
+
+<dl>
+ <dt>{{jsxref("Error.prototype")}}</dt>
+ <dd>Pozwala na dodawanie właściwości do instancji klasy <code>Error</code>.</dd>
+</dl>
+
+<h2 id="Metody">Metody</h2>
+
+<p>Globalny obiekt <code>Error</code> sam w sobie nie zawiera metod, niemniej, dziedziczy on niektóre metody z łańcucha prototypów.</p>
+
+<h2 id="Error_instancje"><code>Error</code> instancje</h2>
+
+<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/Error/prototype', 'Description')}}</div>
+
+<h3 id="Właściwości_2">Właściwości</h3>
+
+<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/Error/prototype', 'Properties')}}</div>
+
+<h3 id="Metody_2">Metody</h3>
+
+<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/Error/prototype', 'Methods')}}</div>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Rzucanie_ogólnego_błędu">Rzucanie ogólnego błędu</h3>
+
+<p>Zazwyczaj tworzysz obiekt <code>Error</code> w celu wywołania go przy użyciu słowa kluczowego {{jsxref("Statements/throw", "throw")}}. Możesz obsłużyć tak rzucony błąd przy pomocy konstrukcji {{jsxref("Statements/try...catch", "try...catch")}}:</p>
+
+<pre class="brush: js notranslate">try {
+  throw new Error('Whoops!');
+} catch (e) {
+  alert(e.name + ': ' + e.message);
+}
+</pre>
+
+<h3 id="Obsługa_specyficznych_błędów">Obsługa specyficznych błędów</h3>
+
+<p>Jeżeli chcesz możesz obsługiwać tylko specyficzny rodzaj błędu poprzez użycie właściwości jego {{jsxref("Object.prototype.constructor", "constructor")}} lub, jeżeli używasz nowoczesnego silnika JavaScript, poprzez słowo kluczowe {{jsxref("Operators/instanceof", "instanceof")}}:</p>
+
+<pre class="brush: js notranslate">try {
+  foo.bar();
+} catch (e) {
+  if (e instanceof EvalError) {
+    alert(e.name + ': ' + e.message);
+  } else if (e instanceof RangeError) {
+    alert(e.name + ': ' + e.message);
+  }
+  // ... etc
+}
+</pre>
+
+<h3 id="Niestandardowe_typy_błędów">Niestandardowe typy błędów</h3>
+
+<p>Możesz chcieć zdefiniować własny typ błędu pochodzący z klasy <code>Error</code> z możliwością rzucenia błędu <code>throw new MyError()</code> i użycia <code>instanceof MyError</code> w celu sprawdzenia jego rodzaju. Skutkuje to czystszym i spójniejszym kodem obsługi błędów. Zobacz <a href="http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript">"What's a good way to extend Error in JavaScript?"</a> na StackOverflow dla dogłębniejszej analizy.</p>
+
+<h4 id="ES6_Custom_Error_Class">ES6 Custom Error Class</h4>
+
+<div class="warning">
+<p>Babel i inne transpilatory nie potrafią poprawnie obsłużyć podanego kodu bez <a href="https://github.com/loganfsmyth/babel-plugin-transform-builtin-extend">dodatkowej konfiguracji</a>.</p>
+</div>
+
+<div class="note">
+<p>Nie które przeglądarki dodają constructor <code>CustomError</code> w stosie błędu kiedy używamy klas ES2015</p>
+</div>
+
+<pre class="brush: js notranslate">class CustomError extends Error {
+  constructor(foo = 'bar', ...params) {
+    // Pass remaining arguments (including vendor specific ones) to parent constructor
+    super(...params);
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, CustomError);
+    }
+
+    // Custom debugging information
+    this.foo = foo;
+    this.date = new Date();
+  }
+}
+
+try {
+  throw new CustomError('baz', 'bazMessage');
+} catch(e){
+  console.log(e.foo); //baz
+  console.log(e.message); //bazMessage
+  console.log(e.stack); //stacktrace
+}</pre>
+
+<h4 id="ES5_Custom_Error_Object">ES5 Custom Error Object</h4>
+
+<div class="warning">
+<p><strong>Wszystkie</strong> przeględarki dodają konstruktor <code>CustomError </code>kiedy używasz konstruktora z wykorzystaniem prototype</p>
+</div>
+
+<pre class="brush: js notranslate">function CustomError(foo, message, fileName, lineNumber) {
+  var instance = new Error(message, fileName, lineNumber);
+  instance.foo = foo;
+  Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(instance, CustomError);
+  }
+  return instance;
+}
+
+CustomError.prototype = Object.create(Error.prototype, {
+  constructor: {
+    value: Error,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  }
+});
+
+if (Object.setPrototypeOf){
+  Object.setPrototypeOf(CustomError, Error);
+} else {
+  CustomError.__proto__ = Error;
+}
+
+
+try {
+  throw new CustomError('baz', 'bazMessage');
+} catch(e){
+  console.log(e.foo); //baz
+  console.log(e.message) ;//bazMessage
+}</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Początkowa definicja. Zaimplementowana w JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11', 'Error')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-error-objects', 'Error')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-error-objects', 'Error')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność">Kompatybilność</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error")}}</p>
+</div>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Statements/throw", "throw")}}</li>
+ <li>{{jsxref("Statements/try...catch", "try...catch")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/error/linenumber/index.html b/files/pl/web/javascript/reference/global_objects/error/linenumber/index.html
new file mode 100644
index 0000000000..955f768c0b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/error/linenumber/index.html
@@ -0,0 +1,58 @@
+---
+title: Error.prototype.lineNumber
+slug: Web/JavaScript/Reference/Global_Objects/Error/lineNumber
+tags:
+  - JavaScript
+  - Prototyp
+  - Prototype
+  - Referencja
+  - Własność
+  - niestandardowe
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/lineNumber
+original_slug: Web/JavaScript/Referencje/Obiekty/Error/lineNumber
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Właściwość <code><strong>lineNumber</strong></code> zawiera numer linii w pliku, gdzie pojawił się błąd.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_lineNumber">Użycie <code>lineNumber</code></h3>
+
+<pre class="brush: js">var e = new Error('Błąd przy parsowaniu wejścia');
+throw e;
+console.log(e.lineNumber) // 2
+</pre>
+
+<h3 id="Alternatywny_przykład_użycia_zdarzenia_error">Alternatywny przykład użycia zdarzenia <code>error</code></h3>
+
+<pre class="brush: js">window.addEventListener('error', function(e) {
+  console.log(e.lineNumber); // 5
+});
+var e = new Error('Błąd przy parsowaniu wejścia');
+throw e;
+</pre>
+
+<p>Własność <code>lineNumber</code> jest niestandardowa i nie posiada szerokiego wsparcia – zobacz tabelę opisującą wsparcie przeglądarek dla tej własności.</p>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<p><span class="pl-s">Nie jest częścią żadnego standardu.</span></p>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.lineNumber")}}</p>
+</div>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.stack")}}</li>
+ <li>{{jsxref("Error.prototype.columnNumber")}}</li>
+ <li>{{jsxref("Error.prototype.fileName")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/error/message/index.html b/files/pl/web/javascript/reference/global_objects/error/message/index.html
new file mode 100644
index 0000000000..3cfdd45e92
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/error/message/index.html
@@ -0,0 +1,109 @@
+---
+title: Error.prototype.message
+slug: Web/JavaScript/Reference/Global_Objects/Error/message
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/message
+original_slug: Web/JavaScript/Referencje/Obiekty/Error/message
+---
+<div>{{JSRef}}</div>
+
+<p>Właściwość <code><strong>message</strong></code> jest komunikatem błędu zapisanym w sposób czytelny dla czlowieka.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Właściwość zawiera krótki opis błędu, jeśli jest dostępny, lub został ustawiony. <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> szeroko wykorzystuje właściwość <code>message</code> w wyjątkach. Właściwość <code>message</code> jest używany, wraz z właściwością {{jsxref("Error.prototype.name", "name")}} przez metodę {{jsxref("Error.prototype.toString()")}} do tworzenia tekstowej reprezentacji obiektu Error.</p>
+
+<p>Domyślnie właściwość <code>message </code>jest pustym stringiem, ale to zachowanie może zostać nadpisane w instancji, poprzez przekazanie komunikatu jako pierwszy parametr do {{jsxref("Error", "Error constructor")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Rzucanie_ustawionego_błędu">Rzucanie ustawionego błędu</h3>
+
+<pre class="brush: js">var e = new Error('Could not parse input'); // e.message is 'Could not parse input'
+throw e;
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.4.3', 'Error.prototype.message')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-error.prototype.message', 'Error.prototype.message')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.name")}}</li>
+ <li>{{jsxref("Error.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/error/name/index.html b/files/pl/web/javascript/reference/global_objects/error/name/index.html
new file mode 100644
index 0000000000..e797299222
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/error/name/index.html
@@ -0,0 +1,110 @@
+---
+title: Error.prototype.name
+slug: Web/JavaScript/Reference/Global_Objects/Error/name
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/name
+original_slug: Web/JavaScript/Referencje/Obiekty/Error/name
+---
+<div>{{JSRef}}</div>
+
+<p>Właściwość <code><strong>name</strong></code> reprezentuję nazwę danego typu błędu. Początkową wartością jest "Error".</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Domyślnie, instancje {{jsxref("Error")}} mają ustawioną nazwę "Error". Właściwość <code>name</code>, razem z właściwością {{jsxref("Error.prototype.message", "message")}}, jest używana przez metodę  {{jsxref("Error.prototype.toString()")}} do tworzenia tekstowej reprezentacji obiektu Error.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Rzucanie_ustawionego_błędu">Rzucanie ustawionego błędu</h3>
+
+<pre class="brush: js">var e = new Error('Malformed input'); // e.name is 'Error'
+
+e.name = 'ParseError';
+throw e;
+// e.toString() would return 'ParseError: Malformed input'
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.4.2', 'Error.prototype.name')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-error.prototype.name', 'Error.prototype.name')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.message")}}</li>
+ <li>{{jsxref("Error.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/error/stack/index.html b/files/pl/web/javascript/reference/global_objects/error/stack/index.html
new file mode 100644
index 0000000000..ab989c4b8d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/error/stack/index.html
@@ -0,0 +1,128 @@
+---
+title: Error.prototype.stack
+slug: Web/JavaScript/Reference/Global_Objects/Error/Stack
+tags:
+  - JavaScript
+  - Prototyp
+  - Referencja
+  - Własność
+  - niestandardowe
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/Stack
+original_slug: Web/JavaScript/Referencje/Obiekty/Error/Stack
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Niestandardowa własność <strong><code>stack</code></strong> obiektów {{jsxref("Error")}} podaje ścieżkę wywołań funkcji – które z nich były wywołane, w jakiej kolejności, z której linii i pliku, z jakimi argumentami. Stos wywołań zaczyna się od ostatnich wywołań, przez wcześniejsze, prowadząc do pierwotnego wywołania z zakresu globalnego.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Każdy krok będzie znajdował się w oddzielnej linii, zawierając w pierwszej części nazwę funkcji (jeśli nie jest to wywołanie z zakresu globalnego), następnie znak <em>at</em> (<code>@</code>), lokalizację pliku (z wyjątkiem sytuacji, w których funkcja jest konstruktorem zgłaszanego błędu), dwukropek oraz numer linii (jeśli zdefiniowana jest lokalizacja pliku). (Zauważ, że obiekt {{jsxref("Error")}} także posiada własności <code>fileName</code>, <code>lineNumber</code> i <code>columnNumber</code>, które można odczytać z danego błędu, jednak jedynie błędu, a nie jego stosu wywołań).</p>
+
+<p>Należy podkreślić, że opisany wyżej format jest formatem przeglądarki Firefox – nie ma standardu formatowania, jednakże Safari 6+ i Opera 12- używają bardzo podobnego formatu. Przeglądarki używające silnika JavaScript V8 (takie jak Chrome, Opera 15+, Android Browser) oraz IE10+, używają natomiast innego formatu (zobacz <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">archiwalną dokumentację MSDN dla error.stack</a>).</p>
+
+<p><strong>Wartości argumentów w stosie:</strong> w wersjach wcześniejszych niż Firefox 14, po nazwie funkcji następowały wartości argumentów przekonwertowane do łańcucha znaków (<em>string</em>) w nawiasach, przed znakiem <em>at</em> (<code>@</code>). Podczas gdy obiekt (lub tablica itp.) pojawia się w przekonwertowanej formie <code>"[object Object]"</code> i nie może być przekonwertowany z powrotem do właściwych obiektów, wartości skalarne mogą być odzyskane (choć być może — w Firefoksie 14 nadal jest to możliwe — łatwiej będzie użyć <code>arguments.callee.caller.arguments</code>, tak jak nazwa funkcji może być uzyskana przez  <code>arguments.callee.caller.name</code>). <code>"undefined"</code> jest wylistowany jako <code>"(void 0)"</code>. Zauważ, że jeśli argumenty typu <em>string</em> były przekazane z wartościami takimi jak <code>"@"</code>, <code>"("</code>, <code>")"</code> (lub znaki te występują w nazwach plików), nie możesz polegać po prostu na podzieleniu linii na części składowe – <span class="tlid-translation translation" lang="pl"><span title="">dlatego w Firefoksie 14 i nowszych jest to mniejszy problem<strong>.</strong></span></span></p>
+
+<p>Różne przeglądarki ustawiają tę wartość w różnych momentach. Przykładowo, Firefox ustawia ją podczas tworzenia obiektu {{jsxref("Error")}}, natomiast PhantomJS ustawia ją jedynie podczas wyrzucania {{jsxref("Error")}} – i <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">archiwalna dokumentacja MSDN</a> również wydaje się zgadzać z implementacją PhantomJS.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_własności_stack">Użycie własności <code>stack</code></h3>
+
+<p>Poniższy dokument HTML prezentuje użycie własności <code>stack</code>.</p>
+
+<pre class="brush: html notranslate">&lt;!DOCTYPE HTML&gt;
+&lt;meta charset="UTF-8"&gt;
+&lt;title&gt;Stack Trace Example&lt;/title&gt;
+&lt;body&gt;
+&lt;script&gt;
+function trace() {
+  try {
+    throw new Error('myError');
+  }
+  catch(e) {
+    alert(e.stack);
+  }
+}
+function b() {
+  trace();
+}
+function a() {
+  b(3, 4, '\n\n', undefined, {});
+}
+a('first call, firstarg');
+&lt;/script&gt;
+</pre>
+
+<p>Zakładając, że powyższy dokument zapisany jest pod adresem <code>C:\example.html</code> w systemie plików Windows, kod utworzy okno typu <em>alert</em> z następującą treścią:</p>
+
+<p>W przeglądarce Firefox 30 i późniejszych wersjach, wraz z numerem kolumny:</p>
+
+<pre class="notranslate"><samp>trace@file:///C:/example.html:9:17
+b@file:///C:/example.html:16:13
+a@file:///C:/example.html:19:13
+@file:///C:/example.html:21:9</samp></pre>
+
+<p>Od Firefoxa 14 do Firefoxa 29:</p>
+
+<pre class="notranslate"><samp>trace@file:///C:/example.html:9
+b@file:///C:/example.html:16
+a@file:///C:/example.html:19
+@file:///C:/example.html:21</samp></pre>
+
+<p>Firefox 13 i wcześniejsze zwróci zamiast tego następujący tekst:</p>
+
+<pre class="notranslate"><samp>Error("myError")@:0
+trace()@file:///C:/example.html:9
+b(3,4,"\n\n",(void 0),[object Object])@file:///C:/example.html:16
+a("first call, firstarg")@file:///C:/example.html:19
+@file:///C:/example.html:21</samp></pre>
+
+<h3 id="Stos_ewaluowanego_kodu">Stos ewaluowanego kodu</h3>
+
+<p>Od Firefoxa 30, stos błędu w wywołaniach <code>Function()</code> i <code>eval()</code> tworzy stos z bardziej szczegółową informacją o linii i kolumnie wewnątrz tych wywołań. Wywołania funkcji są wskazywane przez <code>"&gt; Function"</code>, a eval przez <code>"&gt; eval"</code>.</p>
+
+<pre class="brush: js notranslate">try {
+  new Function('throw new Error()')();
+} catch (e) {
+  console.log(e.stack);
+}
+
+// anonymous@file:///C:/example.html line 7 &gt; Function:1:1
+// @file:///C:/example.html:7:6
+
+
+try {
+  eval("eval('FAIL')");
+} catch (x) {
+  console.log(x.stack);
+}
+
+// @file:///C:/example.html line 7 &gt; eval line 1 &gt; eval:1:1
+// @file:///C:/example.html line 7 &gt; eval:1:1
+// @file:///C:/example.html:7:6
+</pre>
+
+<p>Możesz także użyć dyrektywy <code>//# sourceURL</code> do nazwania źródła <code>eval</code>. Zobacz też źródła <a href="/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources">Debug eval</a> w dokumentacji <a href="/en-US/docs/Tools/Debugger">Debuggera</a> oraz w <a href="http://fitzgeraldnick.com/weblog/59/">tym artykule</a>.</p>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<p><span class="pl-s">Nie jest częścią żadnego standardu.</span></p>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.stack")}}</p>
+</div>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Components.stack">Components.stack</a></li>
+ <li>Projekty zewnetrzne: <a class="link-https" href="https://github.com/csnover/TraceKit/">TraceKit</a> i <a class="link-https" href="https://github.com/eriwen/javascript-stacktrace">javascript-stacktrace</a></li>
+ <li>MSDN: <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">archiwalna dokumentacja error.stack</a></li>
+ <li><a href="https://github.com/v8/v8/wiki/Stack%20Trace%20API">Przegląd API stosu wywołań w JavaScript V8</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/error/tosource/index.html b/files/pl/web/javascript/reference/global_objects/error/tosource/index.html
new file mode 100644
index 0000000000..1a6c5b4e2f
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/error/tosource/index.html
@@ -0,0 +1,61 @@
+---
+title: Error.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Error/toSource
+tags:
+  - JavaScript
+  - Metodă
+  - Niestandardowy
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource
+original_slug: Web/JavaScript/Referencje/Obiekty/Error/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Metoda <code><strong>toSource()</strong></code> zwraca kod, który możemethod returns code that could eval to the same error.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate"><var>e</var>.toSource()</pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Łańcuch znaków (<em>string</em>) zawierający kod źródłowy błędu.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_toSource">Użycie toSource</h3>
+
+<p>Wywołanie metody <code>toSource</code> instancji {{jsxref("Error")}} (w tym <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types">NativeErrors</a></em>) zwróci łańcuch znaków zawierający kod źródłowy błędu. Zwrócony <em>string</em> może być ewaluowany do utworzenia (w przybliżeniu) takiego samego obiektu. Oczywiście ciąg znaków zawierający kod źródłowy jest zgodny ze strukturą konstruktora {{jsxref("Error")}}. Przykładowo:</p>
+
+<pre class="brush: js notranslate">(<em>newname</em>(<em>message</em>, <em>nazwaPliku</em>, <em>numerLinii</em>))
+</pre>
+
+<p>gdzie wymienione atrybuty odpowiadają właściwym własnościom instancji błędu.</p>
+
+<div class="note">
+<p><strong>Uwaga:</strong> należy pamiętać, że własności używanen przez metodę <code>toSource</code> podczas tworzenia tego ciągu znaków są modyfikowalne i mogą nie odzwierciedlać dokładnie funkcji użytej do stworzenia instancji błędu lub nazwy pliku czy numeru linii gdzie wystąpił dany błąd.</p>
+</div>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<p>Nie należy do żadnego standardu.</p>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.toSource")}}</p>
+</div>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.fileName")}}</li>
+ <li>{{jsxref("Error.prototype.lineNumber")}}</li>
+ <li>{{jsxref("Error.prototype.message")}}</li>
+ <li>{{jsxref("Error.prototype.name")}}</li>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/error/tostring/index.html b/files/pl/web/javascript/reference/global_objects/error/tostring/index.html
new file mode 100644
index 0000000000..34c420487e
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/error/tostring/index.html
@@ -0,0 +1,99 @@
+---
+title: Error.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Error/toString
+tags:
+  - JavaScript
+  - Metodă
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/Error/toString
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>toString()</strong></code> zwraca iąg znaków reprezentujący dany obiekt {{jsxref("Error")}}.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate"><code><var>e</var>.toString()</code></pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Ciąg znaków reprezentujący dany obiekt {{jsxref("Error")}}.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Obiekt {{jsxref("Error")}} nadpisuje metodę {{jsxref("Object.prototype.toString()")}} dziedziczoną przez wszystkie obiekty. Jego semantyka jest następująca (przy założeniu, że {{jsxref("Object")}} i {{jsxref("String")}} mają swoje oryginalne wartości):</p>
+
+<pre class="brush: js notranslate">Error.prototype.toString = function() {
+  'use strict';
+
+  var obj = Object(this);
+  if (obj !== this) {
+    throw new TypeError();
+  }
+
+  var name = this.name;
+  name = (name === undefined) ? 'Error' : String(name);
+
+  var msg = this.message;
+  msg = (msg === undefined) ? '' : String(msg);
+
+  if (name === '') {
+    return msg;
+  }
+  if (msg === '') {
+    return name;
+  }
+
+  return name + ': ' + msg;
+};
+</pre>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_toString">Użycie toString()</h3>
+
+<pre class="brush: js notranslate">var e = new Error('fatal error');
+console.log(e.toString()); // 'Error: fatal error'
+
+e.name = undefined;
+console.log(e.toString()); // 'Error: fatal error'
+
+e.name = '';
+console.log(e.toString()); // 'fatal error'
+
+e.message = undefined;
+console.log(e.toString()); // ''
+
+e.name = 'hello';
+console.log(e.toString()); // 'hello'
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.toString")}}</p>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/escape/index.html b/files/pl/web/javascript/reference/global_objects/escape/index.html
new file mode 100644
index 0000000000..2fcf67431d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/escape/index.html
@@ -0,0 +1,121 @@
+---
+title: escape()
+slug: Web/JavaScript/Reference/Global_Objects/escape
+translation_of: Web/JavaScript/Reference/Global_Objects/escape
+original_slug: Web/JavaScript/Referencje/Obiekty/escape
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p>The deprecated <code><strong>escape()</strong></code> function computes a new string in which certain characters have been replaced by a hexadecimal escape sequence. Use {{jsxref("encodeURI")}} or {{jsxref("encodeURIComponent")}} instead.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>escape(str)</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>str</code></dt>
+ <dd>A string to be encoded.</dd>
+</dl>
+
+<h2 id="Description">Description</h2>
+
+<p>The <code>escape</code> function is a property of the <em>global object</em>. Special characters are encoded with the exception of: @*_+-./</p>
+
+<p>The hexadecimal form for characters, whose code unit value is 0xFF or less, is a two-digit escape sequence: %xx. For characters with a greater code unit, the four-digit format %<strong>u</strong>xxxx is used.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<pre class="brush: js">escape("abc123");     // "abc123"
+escape("äöü");        // "%E4%F6%FC"
+escape("ć");          // "%u0107"
+
+// znaki specjalne
+escape("@*_+-./");    // "@*_+-./"</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-B.2.1', 'escape')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Defined in the (informative) Compatibility Annex B</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-escape-string', 'escape')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("encodeURI")}}</li>
+ <li>{{jsxref("encodeURIComponent")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/evalerror/index.html b/files/pl/web/javascript/reference/global_objects/evalerror/index.html
new file mode 100644
index 0000000000..15b2ee1c40
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/evalerror/index.html
@@ -0,0 +1,88 @@
+---
+title: EvalError
+slug: Web/JavaScript/Reference/Global_Objects/EvalError
+tags:
+  - EvalError
+  - JavaScript
+  - Klasa
+  - Obiekt
+  - Referencja
+translation_of: Web/JavaScript/Reference/Global_Objects/EvalError
+original_slug: Web/JavaScript/Referencje/Obiekty/EvalError
+---
+<div>{{JSRef}}</div>
+
+<p>Obiekt <strong><code>EvalError</code></strong> wskazuje na błąd dotyczący globalnej funkcji {{jsxref("Global_Objects/eval", "eval()")}}. Ten wyjątek nie jest już wywoływany przez JavaScript, jednak obiekt <code>EvalError</code> został zachowany ze względu na kompatybilność wsteczną.</p>
+
+<h2 id="Konstruktor">Konstruktor</h2>
+
+<dl>
+ <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/EvalError"><code>EvalError()</code></a></dt>
+ <dd>Tworzy nowy obiekt <code>EvalError</code>.</dd>
+</dl>
+
+<h2 id="Własności_instancji">Własności instancji</h2>
+
+<dl>
+ <dt>{{jsxref("Error.prototype.message", "EvalError.prototype.message")}}</dt>
+ <dd>Treść błędu. Choć ECMA-262 określa, że {{jsxref("EvalError")}} powinien mieć swoją własną wartość <code>message</code>, w <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> jest ona dziedziczona z {{jsxref("Error.prototype.message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "EvalError.prototype.name")}}</dt>
+ <dd>Nazwa błędu. Dziedziczone z {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "EvalError.prototype.fileName")}}</dt>
+ <dd>Ścieżka do pliku, w którym został wywołany błąd. Dziedziczone z {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "EvalError.prototype.lineNumber")}}</dt>
+ <dd>Numer linii w pliku, gdzie został wywołany błąd. Dziedziczone z {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "EvalError.prototype.columnNumber")}}</dt>
+ <dd>Kolumna w linii, gdzie został wywołany błąd. Dziedziczone z {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "EvalError.prototype.stack")}}</dt>
+ <dd>Stos wywołań. Dziedziczone z {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<p><code>EvalError</code> nie jest używany w obecnej specyfikacji ECMAScript, zatem nie będzie wywoływany podczas wykonania programu – jednakże sam obiekt został zachowany ze względu na wsteczną kompatybilność z wcześniejszymi wersjami specyfikacji.</p>
+
+<h3 id="Tworzenie_EvalError">Tworzenie EvalError</h3>
+
+<pre class="brush: js notranslate">try {
+  throw new EvalError('Hello', 'someFile.js', 10);
+} catch (e) {
+  console.log(e instanceof EvalError); // true
+  console.log(e.message);              // "Hello"
+  console.log(e.name);                 // "EvalError"
+  console.log(e.fileName);             // "someFile.js"
+  console.log(e.lineNumber);           // 10
+  console.log(e.columnNumber);         // 0
+  console.log(e.stack);                // "@Scratchpad/2:2:9\n"
+}
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.EvalError")}}</p>
+</div>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Error")}}</li>
+ <li>{{jsxref("Global_Objects/eval", "eval()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/function/apply/index.html b/files/pl/web/javascript/reference/global_objects/function/apply/index.html
new file mode 100644
index 0000000000..1114e51167
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/function/apply/index.html
@@ -0,0 +1,290 @@
+---
+title: Function.prototype.apply()
+slug: Web/JavaScript/Reference/Global_Objects/Function/apply
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
+original_slug: Web/JavaScript/Referencje/Obiekty/Function/apply
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code>apply()</code> wywołuje daną funkcję podstawiając daną wartość <code>this</code> i argumenty <span id="result_box" lang="pl"><span>przedstawione</span> <span>w postaci tablicy</span></span> (lub obiektu tablicopodobnego (<a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">array-like object</a>)).</p>
+
+<div class="note">
+<p><strong>Notka:</strong> <span id="result_box" lang="pl"><span>Składnia</span> <span>tej funkcji jest</span> <span>niemal identyczna </span><span>do</span></span> {{jsxref("Function.call", "call()")}}, podstawową różnicą jest to, iż <code>call()</code> przyjmuje <strong>listę argumentów</strong>, podczas gdy <code>apply()</code> akceptuje <strong>pojedynczą tablicę argumentów</strong>.</p>
+</div>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><em><var>fun</var>ction</em>.apply(<var>thisArg, </var>[<var>argsArray</var>])</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>thisArg</code></dt>
+ <dd>Optional. The value of <code>this</code> provided for the call to <em><code>func</code></em>. Note that <code>this</code> may not be the actual value seen by the method: if the method is a function in {{jsxref("Strict_mode", "non-strict mode", "", 1)}} code, {{jsxref("null")}} and {{jsxref("undefined")}} will be replaced with the global object, and primitive values will be boxed.</dd>
+ <dt><code>argsArray</code></dt>
+ <dd>Optional. An array-like object, specifying the arguments with which <em><code>fun</code></em> should be called, or {{jsxref("null")}} or {{jsxref("undefined")}} if no arguments should be provided to the function. Starting with ECMAScript 5 these arguments can be a generic array-like object instead of an array. See below for {{anch("Browser_compatibility", "browser compatibility")}} information.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Wynik wywoływanej funkcji z określoną wartością <code>this</code> i argumentami.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p><span id="result_box" lang="pl"><span>Można</span> <span>przypisać inny</span> <span>obiekt</span> <code>this</code> <span>podczas wywoływania</span> <span>istniejącej</span> <span>funkcji.</span></span> <code>this</code> <span id="result_box" lang="pl"><span>odnosi się do</span> <span>bieżącego obiektu</span><span>,</span> <span>obiektu</span> <span>wywołującego. </span></span><span lang="pl"><span>Z</span> <span>apply</span><span> można</span> <span>napisać metodę</span> <span>raz, a następnie</span> <span>dziedziczyć</span> <span>ją</span> <span>w innym</span> <span>obiekcie,</span> <span>bez konieczności</span> <span>przepisywania</span> <span>metody</span> <span>dla nowego</span> <span>obiektu.</span></span></p>
+
+<p><code>apply</code> jest bardzo podobne do {{jsxref("Function.call", "call()")}}, <span class="short_text" id="result_box" lang="pl"><span>z wyjątkiem typu danych</span> <span>argumentów</span><span>, które wspiera</span><span>. </span></span><span id="result_box" lang="pl"><span>Można</span> <span>używać tablicy</span> <span>argumentów</span> <span>zamiast</span> <span>zestawu argumentów (parametrów</span><span>).</span></span> Z metodą <code>apply</code>, możesz używać tablic w sensie dosłownym, na przykład <code><em>fun</em>c.apply(this, ['eat', 'bananas'])</code>, lub obiektów typu {{jsxref("Array")}}, na przykład, <code><em>func</em>.apply(this, new Array('eat', 'bananas'))</code>.</p>
+
+<p>Można używać również {{jsxref("Funkcje/arguments", "arguments")}} dla parametru <code>argsArray</code>. <code>arguments</code> jest zmienną lokalną dostępną wewnątrz każdej funkcji. Można to zastosować<span id="result_box" lang="pl"><span> do wszystkich</span> <span>nieokreślonych</span> <span>argumentów</span> wywoływanego <span>obiektu</span><span>.</span></span> <span id="result_box" lang="pl"><span>Tak więc</span> <span>nie trzeba</span> <span>znać</span> <span>argumentów</span> <span>wywoływanego obiektu</span> <span>przy</span> <span>użyciu</span> <span>metody</span> <span><code>apply</code>. </span></span> Możesz użyć <code>arguments</code>, aby <span class="short_text" id="result_box" lang="pl"><span>przekazać</span> <span>wszystkie argumenty do wywoływanego obiektu. </span></span><span id="result_box" lang="pl"><span>Wywołany</span> <span>obiekt</span> <span>jest</span> <span>odpowiedzialny za obsługę</span> <span>otrzymanych argumentów</span><span>.</span></span></p>
+
+<p><span lang="pl"><span>Od </span></span>ECMAScript 5th Edition możliwe jest również używanie wszelkiego rodzaju obiektów „tablicopodobnych” (array-like), co w praktyce oznacza, że obiekt taki musi mieć własność <code>length</code> i całkowite własności (indeksy) w zakresie <code>(0..length-1)</code>. Przykładowo możesz użyć {{domxref("NodeList")}} lub własnego oiektu jak np. <code>{ 'length': 2, '0': 'eat', '1': 'bananas' }</code>.</p>
+
+<div class="note">
+<p>Większość przeglądarek, w tym Chrome 14 i Internet Explorer 9, w dalszym ciągu nie akceptuje obiektów tablicopodobnych i będzie wyrzucać wyjątek.</p>
+</div>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_apply_do_dodania_tablicy_do_innej_tablicy">Użycie <code>apply</code> do dodania tablicy do innej tablicy</h3>
+
+<p>Możemy użyć metody <code>push</code> do dodania elementu do tablicy. I, jako że <code>push</code> przyjmuje zmienną liczbę argumentów, możemy również dodać wiele elementów naraz – ale jeśli faktycznie przekażemy tablicę do funkcji <code>push</code>, wówczas rzeczywiście doda ona tablicę jako pojedynczy element, zamiast dodać jej elementy, więc skończymy z tablicą wewnątrz tablicy. Co jeśli to nie jest to, co chcieliśmy osiągnąć? <code>concat</code> ma zachowanie takie, jakiego oczekiwalibyśmy w tym przypadku, jednak funkcja ta nie dodaje w rzeczywistości tablicy do istniejącej tablicy, ale tworzy i zwraca nową. Ale chcieliśmy zmodyfikować naszą istniejącą tablicę… Więc co teraz? Napisać pętlę? No chyba nie?</p>
+
+<p><code>apply</code> przychodzi na ratunek!</p>
+
+<pre class="brush: js">var array = ['a', 'b'];
+var elements = [0, 1, 2];
+array.push.apply(array, elements);
+console.info(array); // ["a", "b", 0, 1, 2]
+</pre>
+
+<p> </p>
+
+<h3 id="Using_apply_and_built-in_functions">Using <code>apply</code> and built-in functions</h3>
+
+<p> </p>
+
+<p>Clever usage of <code>apply</code> allows you to use built-ins functions for some tasks, that otherwise probably would have been written by looping over the array values. As an example here we are going to use <code>Math.max</code>/<code>Math.min</code>, to find out the maximum/minimum value in an array.</p>
+
+<pre class="brush: js">// min/max number in an array
+var numbers = [5, 6, 2, 3, 7];
+
+// using Math.min/Math.max apply
+var max = Math.max.apply(null, numbers);
+// This about equal to Math.max(numbers[0], ...)
+// or Math.max(5, 6, ...)
+
+var min = Math.min.apply(null, numbers);
+
+// vs. simple loop based algorithm
+max = -Infinity, min = +Infinity;
+
+for (var i = 0; i &lt; numbers.length; i++) {
+  if (numbers[i] &gt; max) {
+    max = numbers[i];
+  }
+  if (numbers[i] &lt; min) {
+    min = numbers[i];
+  }
+}
+</pre>
+
+<p>But beware: in using <code>apply</code> this way, you run the risk of exceeding the JavaScript engine's argument length limit. The consequences of applying a function with too many arguments (think more than tens of thousands of arguments) vary across engines (JavaScriptCore has hard-coded <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=80797">argument limit of 65536</a>), because the limit (indeed even the nature of any excessively-large-stack behavior) is unspecified. Some engines will throw an exception. More perniciously, others will arbitrarily limit the number of arguments actually passed to the applied function. To illustrate this latter case: if such an engine had a limit of four arguments (actual limits are of course significantly higher), it would be as if the arguments <code>5, 6, 2, 3</code> had been passed to <code>apply</code> in the examples above, rather than the full array.</p>
+
+<p>If your value array might grow into the tens of thousands, use a hybrid strategy: apply your function to chunks of the array at a time:</p>
+
+<pre class="brush: js">function minOfArray(arr) {
+  var min = Infinity;
+  var QUANTUM = 32768;
+
+  for (var i = 0, len = arr.length; i &lt; len; i += QUANTUM) {
+    var submin = Math.min.apply(null,
+                                arr.slice(i, Math.min(i+QUANTUM, len)));
+    min = Math.min(submin, min);
+  }
+
+  return min;
+}
+
+var min = minOfArray([5, 6, 2, 3, 7]);
+</pre>
+
+<p> </p>
+
+<h3 id="Using_apply_to_chain_constructors">Using <code>apply</code> to chain constructors</h3>
+
+<p> </p>
+
+<p>You can use <code>apply</code> to chain {{jsxref("Operators/new", "constructors", "", 1)}} for an object, similar to Java. In the following example we will create a global {{jsxref("Function")}} method called <code>construct</code>, which will enable you to use an array-like object with a constructor instead of an arguments list.</p>
+
+<pre class="brush: js">Function.prototype.construct = function(aArgs) {
+  var oNew = Object.create(this.prototype);
+  this.apply(oNew, aArgs);
+  return oNew;
+};
+</pre>
+
+<div class="note" style="height: 250px; overflow: auto;">
+<p><strong>Note:</strong> The <code>Object.create()</code> method used above is relatively new. For alternative methods, please consider one of the following approaches:</p>
+
+<p>Using {{jsxref("Object/__proto__", "Object.__proto__")}}:</p>
+
+<pre class="brush: js">Function.prototype.construct = function (aArgs) {
+  var oNew = {};
+  oNew.__proto__ = this.prototype;
+  this.apply(oNew, aArgs);
+  return oNew;
+};
+</pre>
+
+<p>Using <a href="/en-US/docs/Web/JavaScript/Closures">closures</a>:</p>
+
+<pre class="brush: js">Function.prototype.construct = function(aArgs) {
+  var fConstructor = this, fNewConstr = function() {
+    fConstructor.apply(this, aArgs);
+  };
+  fNewConstr.prototype = fConstructor.prototype;
+  return new fNewConstr();
+};</pre>
+
+<p>Using the {{jsxref("Function")}} constructor:</p>
+
+<pre class="brush: js">Function.prototype.construct = function (aArgs) {
+  var fNewConstr = new Function("");
+  fNewConstr.prototype = this.prototype;
+  var oNew = new fNewConstr();
+  this.apply(oNew, aArgs);
+  return oNew;
+};
+</pre>
+</div>
+
+<p>Example usage:</p>
+
+<pre class="brush: js">function MyConstructor() {
+  for (var nProp = 0; nProp &lt; arguments.length; nProp++) {
+    this['property' + nProp] = arguments[nProp];
+  }
+}
+
+var myArray = [4, 'Hello world!', false];
+var myInstance = MyConstructor.construct(myArray);
+
+console.log(myInstance.property1);                // logs 'Hello world!'
+console.log(myInstance instanceof MyConstructor); // logs 'true'
+console.log(myInstance.constructor);              // logs 'MyConstructor'
+</pre>
+
+<div class="note">
+<p><strong>Note:</strong> This non-native <code>Function.construct</code> method will not work with some native constructors; like {{jsxref("Date")}}, for example. In these cases you have to use the {{jsxref("Function.prototype.bind")}} method. For example, imagine having an array like the following, to be used with {{jsxref("Global_Objects/Date", "Date")}} constructor: <code>[2012, 11, 4]</code>; in this case you have to write something like: <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()</code>. This is not the best way to do things, and probably not to be used in any production environment.</p>
+</div>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>ES 5.1 generic array-like object as {{jsxref("Functions/arguments", "arguments")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>ES 5.1 generic array-like object as {{jsxref("Functions/arguments", "arguments")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("2.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Functions/arguments", "arguments")}} object</li>
+ <li>{{jsxref("Function.prototype.bind()")}}</li>
+ <li>{{jsxref("Function.prototype.call()")}}</li>
+ <li>{{jsxref("Functions", "Functions and function scope", "", 1)}}</li>
+ <li>{{jsxref("Reflect.apply()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/function/arguments/index.html b/files/pl/web/javascript/reference/global_objects/function/arguments/index.html
new file mode 100644
index 0000000000..2730721c86
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/function/arguments/index.html
@@ -0,0 +1,42 @@
+---
+title: Function.arguments
+slug: Web/JavaScript/Reference/Global_Objects/Function/arguments
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments
+original_slug: Web/JavaScript/Referencje/Obiekty/Function/arguments
+---
+<p>{{JSRef}}{{ Deprecated_header() }}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Obiekt tablicopodobny odpowiadający argumentom przekazywanym funkcji.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Należy użyć obiektu <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje/arguments">arguments</a></code> dostępnego wewnątrz funkcji zamiast <code>Function.arguments</code>.</p>
+
+<p>W przypadku rekurencji, tzn. jeśli funkcja <code>f</code> pojawia się kilkakrotnie na stosie wywołania, wartość of <code>f.arguments</code> reprezentuje argumenty odpowiadające ostatniemu wywołaniu funkcji.</p>
+
+<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2>
+
+<pre class="brush: js">function f(n) { g(n-1) }
+
+function g(n) {
+  console.log("przed: " + g.arguments[0]);
+  if(n&gt;0) { f(n); }
+  console.log("po: " + g.arguments[0]);
+}
+f(2);
+</pre>
+
+<p>wyświetli:</p>
+
+<pre class="eval">przed: 1
+przed: 0
+po: 0
+po: 1
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/function/bind/index.html b/files/pl/web/javascript/reference/global_objects/function/bind/index.html
new file mode 100644
index 0000000000..804d686f1d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/function/bind/index.html
@@ -0,0 +1,333 @@
+---
+title: Function.prototype.bind()
+slug: Web/JavaScript/Reference/Global_Objects/Function/bind
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind
+original_slug: Web/JavaScript/Referencje/Obiekty/Function/bind
+---
+<div>{{JSRef}}<br>
+Metoda <span class="seoSummary"><code><strong>bind()</strong></code> </span> tworzy nową funkcję, której wywołanie powoduje ustawienie <strong>this</strong> na podaną wartość, z podaną sekwencją argumentów poprzedzającą dowolną podaną podczas wywołania nowej funkcji.<br>
+ </div>
+
+<div>{{EmbedInteractiveExample („pages / js / function-bind.html”, „taller”)}}<br>
+Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do projektu interaktywnych przykładów, sklonuj https://github.com/mdn/interactive-examples i wyślij nam prośbę o pobranie.</div>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox notranslate">let boundFunc = <var>func</var>.bind(thisAtr[, <var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]]])
+</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code><var>thisAtr</var></code></dt>
+ <dd>Wartość, która ma być przekazana jako <strong>this</strong> do funkcji docelowej func po wywołaniu funkcji powiązanej. Wartość jest ignorowana, jeśli funkcja powiązana jest konstruowana przy użyciu operatora {{jsxref („Operators / new”, „new”)}}. Podczas używania funkcji <strong>bind</strong> do utworzenia funkcji (dostarczonej jako wywołanie zwrotne) wewnątrz setTimeout, każda prymitywna wartość przekazywana, gdy <strong>thisAtr</strong> jest konwertowany na obiekt. Jeśli nie podano żadnych argumentów, aby powiązać (bind), lub jeśli thisArg jest <strong>null</strong> lub <strong>undefined</strong>, <strong>this</strong> z zakresu wykonania jest traktowany jako <strong>thisAtr</strong> dla nowej funkcji.</dd>
+ <dt><code><var>arg1</var>, <var>arg2</var>, ...<var>argN</var></code> {{optional_inline}}</dt>
+ <dd>Argumenty poprzedzające argumenty dostarczone funkcji powiązanej podczas wywoływania func.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Kopia podanej funkcji z podaną tą wartością i początkowymi argumentami (jeśli podano).</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Funkcja <strong>bind</strong>() tworzy nową funkcję wiązania (bound function), która jest exotic function object (termin z ECMAScript 2015), który zawija oryginalny obiekt funkcji. Wywołanie funkcji powiązanej zazwyczaj skutkuje wykonaniem jej owrapowanej funkcji.</p>
+
+<p>Funckja wiązania <strong>(bound function)</strong> ma następujące właściwości wewnętrzne:</p>
+
+<dl>
+ <dt><strong><code>[[BoundTargetFunction]]</code> </strong></dt>
+ <dd>The wrapped function object</dd>
+ <dt><code><strong>[[BoundThis]]</strong></code></dt>
+ <dd>The value that is always passed as <code>this</code> value when calling the wrapped function.</dd>
+ <dt><code><strong>[[BoundArguments]]</strong></code></dt>
+ <dd>A list of values whose elements are used as the first arguments to any call to the wrapped function.</dd>
+ <dt><code><strong>[[Call]]</strong></code></dt>
+ <dd>Executes code associated with this object. Invoked via a function call expression. The arguments to the internal method are a <code>this</code> value and a list containing the arguments passed to the function by a call expression.</dd>
+</dl>
+
+<p>When a bound function is called, it calls internal method <code>[[Call]]</code> on <code>[[BoundTargetFunction]]</code>, with following arguments <code>Call(<var>boundThis</var>, ...<var>args</var>)</code>. Where <code><var>boundThis</var></code> is <code>[[BoundThis]]</code>, <code><var>args</var></code> is <code>[[BoundArguments]]</code>, followed by the arguments passed by the function call.</p>
+
+<p>A bound function may also be constructed using the {{jsxref("Operators/new", "new")}} operator. Doing so acts as though the target function had instead been constructed. The provided <code>this</code> value is ignored, while prepended arguments are provided to the emulated function.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Creating_a_bound_function">Creating a bound function</h3>
+
+<p>The simplest use of <code>bind()</code> is to make a function that, no matter how it is called, is called with a particular <code>this</code> value.</p>
+
+<p>A common mistake for new JavaScript programmers is to extract a method from an object, then to later call that function and expect it to use the original object as its <code>this</code> (e.g., by using the method in callback-based code).</p>
+
+<p>Without special care, however, the original object is usually lost. Creating a bound function from the function, using the original object, neatly solves this problem:</p>
+
+<pre class="brush: js notranslate">this.x = 9;    // 'this' refers to global 'window' object here in a browser
+const module = {
+  x: 81,
+  getX: function() { return this.x; }
+};
+
+module.getX();
+//  returns 81
+
+const retrieveX = module.getX;
+retrieveX();
+//  returns 9; the function gets invoked at the global scope
+
+//  Create a new function with 'this' bound to module
+//  New programmers might confuse the
+//  global variable 'x' with module's property 'x'
+const boundGetX = retrieveX.bind(module);
+boundGetX();
+//  returns 81
+</pre>
+
+<p><strong>Funkcje częściowo zastosowane</strong><br>
+ Kolejnym najprostszym zastosowaniem bind () jest utworzenie funkcji z wcześniej określonymi argumentami początkowymi.</p>
+
+<p>Argumenty te (jeśli występują) są zgodne z podaną wartością, a następnie są wstawiane na początku argumentów przekazywanych do funkcji docelowej, a następnie wszelkie argumenty przekazywane funkcja powiązana w momencie jej wywołania.</p>
+
+<pre class="brush: js notranslate">function list() {
+  return Array.prototype.slice.call(arguments);
+}
+
+function addArguments(arg1, arg2) {
+  return arg1 + arg2
+}
+
+const list1 = list(1, 2, 3);
+//  [1, 2, 3]
+
+const result1 = addArguments(1, 2);
+//  3
+
+// Create a function with a preset leading argument
+const leadingThirtysevenList = list.bind(null, 37);
+
+// Create a function with a preset first argument.
+const addThirtySeven = addArguments.bind(null, 37);
+
+const list2 = leadingThirtysevenList();
+//  [37]
+
+const list3 = leadingThirtysevenList(1, 2, 3);
+//  [37, 1, 2, 3]
+
+const result2 = addThirtySeven(5);
+//  37 + 5 = 42
+
+const result3 = addThirtySeven(5, 10);
+//  37 + 5 = 42
+//  (the second argument is ignored)
+
+
+</pre>
+
+<h3 id="With_setTimeout">With <code>setTimeout()</code></h3>
+
+<p>By default within <a href="/en-US/docs/Web/API/Window/setTimeout" title="REDIRECT WindowTimers.setTimeout"><code>window.setTimeout()</code></a>, the <code>this</code> keyword will be set to the <a href="/en-US/docs/Web/API/Window" title="The Window interface represents a window containing a DOM document; the document property points to the DOM document loaded in that window."><code>window</code></a> (or <code>global</code>) object. When working with class methods that require <code>this</code> to refer to class instances, you may explicitly bind <code>this</code> to the callback function, in order to maintain the instance.</p>
+
+<pre class="brush: js notranslate">function LateBloomer() {
+  this.petalCount = Math.floor(Math.random() * 12) + 1;
+}
+
+// Declare bloom after a delay of 1 second
+LateBloomer.prototype.bloom = function() {
+  window.setTimeout(this.declare.bind(this), 1000);
+};
+
+LateBloomer.prototype.declare = function() {
+  console.log(`I am a beautiful flower with ${this.petalCount} petals!`);
+};
+
+const flower = new LateBloomer();
+flower.bloom();
+//  after 1 second, calls 'flower.declare()'
+</pre>
+
+<h3 id="Funkcje_powiązane_używane_jako_kostruktory">Funkcje powiązane używane jako kostruktory</h3>
+
+<div class="warning">
+<p>Ostrzeżenie: ta sekcja pokazuje możliwości JavaScript i dokumentuje niektóre przypadki krawędzi metody bind ().</p>
+
+<p>Metody przedstawione poniżej nie są najlepszym sposobem na robienie rzeczy i prawdopodobnie nie powinny być stosowane w żadnym środowisku produkcyjnym.</p>
+</div>
+
+<p>Funkcje powiązane są automatycznie odpowiednie do użycia z operatorem {{jsxref („Operators / new”, „new”)}} do tworzenia nowych instancji utworzonych przez funkcję docelową. Gdy do utworzenia wartości używana jest funkcja powiązana, pod warunkiem, że jest to ignorowane.</p>
+
+<p>Jednak pod warunkiem, że argumenty są nadal dołączane do wywołania konstruktora:</p>
+
+<pre class="brush: js notranslate">function Point(x, y) {
+  this.x = x;
+  this.y = y;
+}
+
+Point.prototype.toString = function() {
+  return `${this.x},${this.y}`;
+};
+
+const p = new Point(1, 2);
+p.toString();
+// '1,2'
+
+
+//  not supported in the polyfill below,
+
+//  works fine with native bind:
+
+const YAxisPoint = Point.bind(null, 0/*x*/);
+
+
+const emptyObj = {};
+const YAxisPoint = Point.bind(emptyObj, 0/*x*/);
+
+const axisPoint = new YAxisPoint(5);
+axisPoint.toString();                    // '0,5'
+
+axisPoint instanceof Point;              // true
+axisPoint instanceof YAxisPoint;         // true
+new YAxisPoint(17, 42) instanceof Point; // true
+</pre>
+
+<p>Zauważ, że nie musisz robić nic specjalnego, aby utworzyć powiązaną funkcję do użycia z {{jsxref („Operators / new”, „new”)}}.</p>
+
+<p>Następstwem jest to, że nie musisz robić nic specjalnego, aby utworzyć funkcję powiązaną, która będzie wywoływana w sposób jawny, nawet jeśli wolisz, aby funkcja powiązana była wywoływana tylko za pomocą {{jsxref („Operators / new”, „new”)}} .</p>
+
+<pre class="brush: js notranslate">//  Example can be run directly in your JavaScript console
+//  ...continued from above
+
+//  Can still be called as a normal function
+//  (although usually this is undesired)
+YAxisPoint(13);
+
+`${emptyObj.x},${emptyObj.y}`;
+// &gt;  '0,13'
+</pre>
+
+<p>If you wish to support the use of a bound function only using {{jsxref("Operators/new", "new")}}, or only by calling it, the target function must enforce that restriction.</p>
+
+<h3 id="Tworzenie_skrótów">Tworzenie skrótów</h3>
+
+<p>bind () jest również pomocny w przypadkach, w których chcesz utworzyć skrót do funkcji, która wymaga podania tej wartości.</p>
+
+<p>Weźmy na przykład {{jsxref ("Array.prototype.slice ()")}}, którego chcesz użyć do konwersji obiektu podobnego do tablicy na prawdziwą tablicę. Możesz utworzyć taki skrót:</p>
+
+<pre class="brush: js notranslate">const slice = Array.prototype.slice;
+
+// ...
+
+slice.apply(arguments);
+</pre>
+
+<p>Za pomocą bind () można to uprościć.</p>
+
+<p>W poniższym fragmencie kodu slice () jest funkcją powiązaną z funkcją {{jsxref („Function.prototype.apply ()”, „Apply ()”)}} z {{jsxref („Function.prototype”) }}, z tą wartością ustawioną na {{jsxref („Array.prototype.slice ()”, „slice ()”)}} funkcji {{jsxref („Array.prototype”)}}. Oznacza to, że dodatkowe wywołania apply () można wyeliminować:</p>
+
+<pre class="brush: js notranslate">//  same as "slice" in the previous example
+const unboundSlice = Array.prototype.slice;
+const slice = Function.prototype.apply.bind(unboundSlice);
+
+// ...
+
+slice(arguments);
+</pre>
+
+<p>Polyfill<br>
+ Ponieważ starsze przeglądarki są na ogół również wolniejszymi przeglądarkami, jest to o wiele bardziej krytyczne niż większość ludzi rozpoznaje tworzenie polifillów wydajności, aby przeglądanie w przestarzałych przeglądarkach było nieco mniej straszne.</p>
+
+<p>W związku z tym poniżej przedstawiono dwie opcje dla funkcji wypełniania funkcji Function.prototype.bind ():</p>
+
+<p>Pierwszy jest znacznie mniejszy i bardziej wydajny, ale nie działa, gdy używasz nowego operatora.<br>
+ Drugi jest większy i mniej wydajny, ale pozwala na pewne użycie nowego operatora na powiązanych funkcjach.<br>
+ Zasadniczo w większości kodów bardzo rzadko widuje się nowe używane w funkcji powiązanej, więc najlepiej jest wybrać pierwszą opcję.</p>
+
+<pre class="brush: js notranslate">//  Does not work with `new funcA.bind(thisArg, args)`
+if (!Function.prototype.bind) (function(){
+  var slice = Array.prototype.slice;
+  Function.prototype.bind = function() {
+    var thatFunc = this, thatArg = arguments[0];
+    var args = slice.call(arguments, 1);
+    if (typeof thatFunc !== 'function') {
+      // closest thing possible to the ECMAScript 5
+      // internal IsCallable function
+      throw new TypeError('Function.prototype.bind - ' +
+             'what is trying to be bound is not callable');
+    }
+    return function(){
+      var funcArgs = args.concat(slice.call(arguments))
+      return thatFunc.apply(thatArg, funcArgs);
+    };
+  };
+})();</pre>
+
+<p>Możesz częściowo obejść ten problem, wstawiając następujący kod na początku skryptów, umożliwiając korzystanie z większości funkcji bind () w implementacjach, które nie obsługują go natywnie.</p>
+
+<pre class="brush: js notranslate">//  Yes, it does work with `new funcA.bind(thisArg, args)`
+if (!Function.prototype.bind) (function(){
+  var ArrayPrototypeSlice = Array.prototype.slice;
+  Function.prototype.bind = function(otherThis) {
+    if (typeof this !== 'function') {
+      // closest thing possible to the ECMAScript 5
+      // internal IsCallable function
+      throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
+    }
+
+    var baseArgs= ArrayPrototypeSlice .call(arguments, 1),
+        baseArgsLength = baseArgs.length,
+        fToBind = this,
+        fNOP    = function() {},
+        fBound  = function() {
+          baseArgs.length = baseArgsLength; // reset to default base arguments
+          baseArgs.push.apply(baseArgs, arguments);
+          return fToBind.apply(
+                 fNOP.prototype.isPrototypeOf(this) ? this : otherThis, baseArgs
+          );
+        };
+
+    if (this.prototype) {
+      // Function.prototype doesn't have a prototype property
+      fNOP.prototype = this.prototype;
+    }
+    fBound.prototype = new fNOP();
+
+    return fBound;
+  };
+})();
+</pre>
+
+<p>Niektóre z wielu różnic (mogą być też inne, ponieważ ta lista nie próbuje być wyczerpująca) między tym algorytmem a określonym algorytmem to:</p>
+
+<p>Częściowa implementacja opiera się na {{jsxref ("Array.prototype.slice ()")}}, {{jsxref ("Array.prototype.concat ()")}}, {{jsxref ("Function.prototype.call ( ) ")}} i {{jsxref (" Function.prototype.apply () ")}}, wbudowane metody mające swoje oryginalne wartości.<br>
+ Częściowa implementacja tworzy funkcje, które nie mają niezmiennej „pigułki trucizny” {{jsxref („Function.caller”, „caller”)}} i właściwości argumentów, które wyrzucają {{jsxref („Global_Objects / TypeError”, „TypeError”) }} przy pobieraniu, ustawianiu lub usuwaniu. (Można to dodać, jeśli implementacja obsługuje {{jsxref („Object.defineProperty”)}} lub częściowo zaimplementowana [bez zachowania polegającego na rzucaniu przy usuwaniu], jeśli implementacja obsługuje {{jsxref („Object .__ zdefiniujGetter__”, „ __defineGetter__ ”)}} i {{jsxref („ Object .__ definiSetter__ ”,„ __defineSetter__ ”)}}).<br>
+ Częściowa implementacja tworzy funkcje, które mają właściwość prototypu. (Właściwie powiązane funkcje nie mają żadnych.)<br>
+ Częściowa implementacja tworzy powiązane funkcje, których właściwość {{jsxref („Function.length”, „length”)}}} nie zgadza się z właściwością nakazaną przez ECMA-262: tworzy funkcje o długości 0. Pełna implementacja - w zależności od długość funkcji docelowej i liczba wcześniej określonych argumentów - może zwrócić niezerową długość.<br>
+ Częściowa implementacja tworzy powiązane funkcje, których właściwość {{jsxref („Function.name”, „name”)}} nie jest pochodną oryginalnej nazwy funkcji. Według ECMA-262 nazwa zwróconej funkcji powiązanej powinna być „związana” + nazwa funkcji docelowej.<br>
+ Jeśli zdecydujesz się użyć tej częściowej implementacji, nie możesz polegać na przypadkach, w których zachowanie odbiega od ECMA-262, wydanie 5! Na szczęście te odchylenia od specyfikacji rzadko (jeśli w ogóle) pojawiają się w większości sytuacji kodowania. Jeśli nie rozumiesz żadnego z odchyleń od powyższej specyfikacji, w tym konkretnym przypadku można bezpiecznie nie martwić się o te niezgodne szczegóły odchylenia.</p>
+
+<p>Jeśli jest to absolutnie konieczne, a wydajność nie stanowi problemu, znacznie wolniejsze (ale bardziej zgodne ze specyfikacją rozwiązanie) można znaleźć na stronie https://github.com/Raynos/function-bind.</p>
+
+<h2 id="Dane_techniczne">Dane techniczne</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h5 id="Kompatybilność_z_przeglądarkami_Tabela_zgodności_na_tej_stronie_jest_generowana_z_danych_strukturalnych._Jeśli_chcesz_przyczynić_się_do_danych_sprawdź_httpsgithub.commdnbrowser-compat-data_i_wyślij_nam_żądanie_ściągnięcia._Compat_javascript.builtins.Function.bind">Kompatybilność z przeglądarkami<br>
+ Tabela zgodności na tej stronie jest generowana z danych strukturalnych. Jeśli chcesz przyczynić się do danych, sprawdź https://github.com/mdn/browser-compat-data i wyślij nam żądanie ściągnięcia.<br>
+ {{Compat ("javascript.builtins.Function.bind")}}</h5>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Function.prototype.apply()")}}</li>
+ <li>{{jsxref("Function.prototype.call()")}}</li>
+ <li>{{jsxref("Functions", "Functions", "", 1)}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/function/caller/index.html b/files/pl/web/javascript/reference/global_objects/function/caller/index.html
new file mode 100644
index 0000000000..c32102869a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/function/caller/index.html
@@ -0,0 +1,70 @@
+---
+title: Function.caller
+slug: Web/JavaScript/Reference/Global_Objects/Function/caller
+tags:
+  - Function
+  - JavaScript
+  - Non-standard
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller
+original_slug: Web/JavaScript/Referencje/Obiekty/Function/caller
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Określa funkcję, która powołuje się na aktualnie wykonywaną funkcje.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli funkcja <code>f</code> została wywołana przez kod najwyższego poziomu, własność <code>f.caller</code> ma wartość {{jsxref("null")}}, w przeciwnym przypadku jest to funkcja, która wywołała <code>f</code>.</p>
+
+<p>Ta własność zastąpiła wycofaną własność {{jsxref("arguments.caller")}}.</p>
+
+<h3 id="Notes" name="Notes">Notes</h3>
+
+<p>Note that in case of recursion, you can't reconstruct the call stack using this property. Consider:</p>
+
+<pre class="brush: js">function f(n) { g(n-1); }
+function g(n) { if(n&gt;0) { f(n); } else { stop(); } }
+f(2);
+</pre>
+
+<p>At the moment <code>stop()</code> is called the call stack will be:</p>
+
+<pre class="eval">f(2) -&gt; g(1) -&gt; f(1) -&gt; g(0) -&gt; stop()
+</pre>
+
+<p>The following is true:</p>
+
+<pre class="eval">stop.caller === g &amp;&amp; f.caller === g &amp;&amp; g.caller === f
+</pre>
+
+<p>so if you tried to get the stack trace in the <code>stop()</code> function like this:</p>
+
+<pre class="brush: js">var f = stop;
+var stack = "Stack trace:";
+while (f) {
+  stack += "\n" + f.name;
+  f = f.caller;
+}
+</pre>
+
+<p>the loop would never stop.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Sprawdzenie_warto.C5.9Bci_w.C5.82asno.C5.9Bci_funkcji_caller" name="Przyk.C5.82ad:_Sprawdzenie_warto.C5.9Bci_w.C5.82asno.C5.9Bci_funkcji_caller">Przykład: Sprawdzenie wartości własności funkcji <code>caller</code></h3>
+
+<p>Następujący kod sprawdza wartość własności funkcji <code>caller</code>.</p>
+
+<pre class="brush: js">function myFunc() {
+   if (myFunc.caller == null) {
+      return ("The function was called from the top!");
+   } else {
+      return ("This function's caller was " + myFunc.caller);
+   }
+}
+</pre>
+
+<div class="noinclude"> </div>
diff --git a/files/pl/web/javascript/reference/global_objects/function/displayname/index.html b/files/pl/web/javascript/reference/global_objects/function/displayname/index.html
new file mode 100644
index 0000000000..c9fe6b741a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/function/displayname/index.html
@@ -0,0 +1,120 @@
+---
+title: Function.displayName
+slug: Web/JavaScript/Reference/Global_Objects/Function/displayName
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName
+original_slug: Web/JavaScript/Referencje/Obiekty/Function/displayName
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Właściwość <code><strong><em>function</em>.displayName</strong></code> zwraca wyświetlaną nazwę funkcji.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Gdy jest zdefiniowana, wlaściwość <code>displayName</code> zwraca wyświetlaną nazwę funkcji:</p>
+
+<pre class="brush: js">function doSomething() {}
+
+console.log(doSomething.displayName); // "undefined"
+
+var popup = function(content) { console.log(content); };
+
+popup.displayName = 'Pokaż Popup';
+
+console.log(popup.displayName); // "Pokaż Popup"
+</pre>
+
+<p>Możesz zdefiniować funkcję z wyświetlaną nazwą {{jsxref("Functions", "function expression", "", 1)}}:</p>
+
+<pre class="brush: js">var object = {
+  someMethod: function() {}
+};
+
+object.someMethod.displayName = 'jakaśMetoda';
+
+console.log(object.someMethod.displayName); // logs "jakaśMetoda"
+
+try { someMethod } catch(e) { console.log(e); }
+// ReferenceError: jakaśMetoda is not defined
+</pre>
+
+<p>Możesz dynamicznie zmieniać <code>displayName </code>z funkcji:</p>
+
+<pre class="brush: js">var object = {
+  // anonymous
+  someMethod: function(value) {
+    this.displayName = 'jakaśMetoda (' + value + ')';
+  }
+};
+
+console.log(object.someMethod.displayName); // "undefined"
+
+object.someMethod('123')
+console.log(object.someMethod.displayName); // "jakaśMetoda (123)"
+</pre>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<p>Zazwyczaj preferowane jest przez konsole i profilery podczas {{jsxref("Function.name", "func.name")}} aby wyświetlić nazwę funkcji.</p>
+
+<p>Umieszczony w konsoli powinien wyświetlić coś w rodzaju "<code>function Moja Funkcja()</code>":</p>
+
+<pre class="brush: js">var a = function() {};
+a.displayName = '<code>Moja Funkcja</code>';
+
+a; // "function <code>Moja Funkcja</code>()"</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<p>Nie jest częścią żadnej specyfikacji.</p>
+
+<h2 id="Zgodność_z_przeglądarką">Zgodność z przeglądarką</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop(13)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
diff --git a/files/pl/web/javascript/reference/global_objects/function/index.html b/files/pl/web/javascript/reference/global_objects/function/index.html
new file mode 100644
index 0000000000..5a9e96f266
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/function/index.html
@@ -0,0 +1,238 @@
+---
+title: Function
+slug: Web/JavaScript/Reference/Global_Objects/Function
+tags:
+  - Function
+  - JavaScript
+  - Konstruktor
+translation_of: Web/JavaScript/Reference/Global_Objects/Function
+original_slug: Web/JavaScript/Referencje/Obiekty/Function
+---
+<div>{{JSRef}}</div>
+
+<p><strong>Konstruktor</strong> <strong><code>Function</code> </strong>tworzy nowy obiekt Function(tworzy funkcję poprzez konstruktor). W JavaScripcie właściwie każda funkcja jest obiektem <code>Function</code>.</p>
+
+<h2 id="Syntax" name="Syntax">Składnia</h2>
+
+<pre class="syntaxbox"><code>new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parametry</h3>
+
+<dl>
+ <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
+ <dd>Names to be used by the function as formal argument names. Each must be a string that corresponds to a valid JavaScript identifier or a list of such strings separated with a comma; for example "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd>
+ <dt><code>functionBody</code></dt>
+ <dd>A string containing the JavaScript statements comprising the function definition.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Opis</h2>
+
+<p><code>Function</code> objects created with the <code>Function</code> constructor are parsed when the function is created. This is less efficient than declaring a function with a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expression</a> or <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a> and calling it within your code, because such functions are parsed with the rest of the code.</p>
+
+<p>All arguments passed to the function are treated as the names of the identifiers of the parameters in the function to be created, in the order in which they are passed.</p>
+
+<div class="note">
+<p><strong>Note:</strong> Functions created with the <code>Function</code> constructor do not create closures to their creation contexts; they always are created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the <code>Function</code> constructor was called. This is different from using {{jsxref("Global_Objects/eval", "eval")}} with code for a function expression.</p>
+</div>
+
+<p>Wywołanie konstruktora Function jako funkcję (bez użycia operatora 'new') ma taki sam efekt jak wywołanie konstruktora(z operatorem).</p>
+
+<h2 id="Właściwości_i_metody_Function">Właściwości i metody <code>Function</code></h2>
+
+<p>The global <code>Function</code> object has no methods or properties of its own, however, since it is a function itself it does inherit some methods and properties through the prototype chain from {{jsxref("Function.prototype")}}.</p>
+
+<h2 id="Function_prototype_object"><code>Function</code> prototype object</h2>
+
+<h3 id="Właściwości">Właściwości</h3>
+
+<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}</div>
+
+<h3 id="Methods" name="Methods">Metody</h3>
+
+<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}</div>
+
+<h2 id="Function_instances" name="Function_instances"><code>Function</code> instances</h2>
+
+<p><code>Function</code> instances inherit methods and properties from {{jsxref("Function.prototype")}}. As with all constructors, you can change the constructor's prototype object to make changes to all <code>Function</code> instances.</p>
+
+<h2 id="Examples" name="Examples">Przykłady</h2>
+
+<h3 id="Example.3A_Specifying_arguments_with_the_Function_constructor" name="Example.3A_Specifying_arguments_with_the_Function_constructor">Przykład: Specifying arguments with the <code>Function</code> constructor</h3>
+
+<p>Poniższy przykład tworzy obiekt Function(tworzy funkcję poprzez konstruktor), który przyjmuje dwa argumenty.</p>
+
+<pre class="brush: js">// Przykład może być uruchomiony bezpośrednio w konsoli JavaScript
+
+// Tworzy funkcję, która przyjmuje dwa argumenty i zwraca ich sumę
+var adder = new Function('a', 'b', 'return a + b');
+
+// Wywołanie funkcji
+adder(2, 6);
+// &gt; 8
+</pre>
+
+<p>Argumenty "<code>a</code>" i "<code>b</code>" są formanie nazwami argumentrów, które są użyte w ciele funkcji, "<code>return a + b</code>".</p>
+
+<h3 id="Example:_A_recursive_shortcut_to_massively_modify_the_DOM" name="Example:_A_recursive_shortcut_to_massively_modify_the_DOM">Przykład: A recursive shortcut to massively modify the DOM</h3>
+
+<p>Creating functions with the <code>Function</code> constructor is one of the ways to dynamically create an indeterminate number of new objects with some executable code into the global scope from a function. The following example (a recursive shortcut to massively modify the DOM) is impossible without the invocation of the <code>Function</code> constructor for each new query if you want to avoid closures.</p>
+
+<pre class="brush: html  language-html"><code class="language-html">&lt;!doctype html&gt;
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>html</span><span class="punctuation token">&gt;</span></span>
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>head</span><span class="punctuation token">&gt;</span></span>
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>meta</span> <span class="attr-name token">http-equiv</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>Content-Type<span class="punctuation token">"</span></span> <span class="attr-name token">content</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>text/html; charset<span class="punctuation token">=</span>UTF-8<span class="punctuation token">"</span></span> <span class="punctuation token">/&gt;</span></span>
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>title</span><span class="punctuation token">&gt;</span></span>MDN Example - a recursive shortcut to massively modify the DOM<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;/</span>title</span><span class="punctuation token">&gt;</span></span>
+<span class="script token"><span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>script</span> <span class="attr-name token">type</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>text/javascript<span class="punctuation token">"</span></span><span class="punctuation token">&gt;</span></span>
+<span class="keyword token">var</span> domQuery <span class="operator token">=</span> <span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  <span class="keyword token">var</span> aDOMFunc <span class="operator token">=</span> <span class="punctuation token">[</span>
+    Element<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>removeAttribute<span class="punctuation token">,</span>
+    Element<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>setAttribute<span class="punctuation token">,</span>
+    CSSStyleDeclaration<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>removeProperty<span class="punctuation token">,</span>
+    CSSStyleDeclaration<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>setProperty
+  <span class="punctuation token">]</span><span class="punctuation token">;</span>
+
+  <span class="keyword token">function</span> <span class="function token">setSomething<span class="punctuation token">(</span></span>bStyle<span class="punctuation token">,</span> sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">var</span> bSet <span class="operator token">=</span> <span class="function token">Boolean<span class="punctuation token">(</span></span>sVal<span class="punctuation token">)</span><span class="punctuation token">,</span> fAction <span class="operator token">=</span> aDOMFunc<span class="punctuation token">[</span>bSet <span class="operator token">|</span> bStyle <span class="operator token">&lt;</span><span class="operator token">&lt;</span> <span class="number token">1</span><span class="punctuation token">]</span><span class="punctuation token">,</span>
+        aArgs <span class="operator token">=</span> Array<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>slice<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span>arguments<span class="punctuation token">,</span> <span class="number token">1</span><span class="punctuation token">,</span> bSet <span class="operator token">?</span> <span class="number token">3</span> <span class="punctuation token">:</span> <span class="number token">2</span><span class="punctuation token">)</span><span class="punctuation token">,</span>
+        aNodeList <span class="operator token">=</span> bStyle <span class="operator token">?</span> <span class="keyword token">this</span><span class="punctuation token">.</span>cssNodes <span class="punctuation token">:</span> <span class="keyword token">this</span><span class="punctuation token">.</span>nodes<span class="punctuation token">;</span>
+
+    <span class="keyword token">if</span> <span class="punctuation token">(</span>bSet <span class="operator token">&amp;&amp;</span> bStyle<span class="punctuation token">)</span> <span class="punctuation token">{</span> aArgs<span class="punctuation token">.</span><span class="function token">push<span class="punctuation token">(</span></span><span class="string token">''</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="punctuation token">}</span>
+    <span class="keyword token">for</span> <span class="punctuation token">(</span>
+      <span class="keyword token">var</span> nItem <span class="operator token">=</span> <span class="number token">0</span><span class="punctuation token">,</span> nLen <span class="operator token">=</span> <span class="keyword token">this</span><span class="punctuation token">.</span>nodes<span class="punctuation token">.</span>length<span class="punctuation token">;</span>
+      nItem <span class="operator token">&lt;</span> nLen<span class="punctuation token">;</span>
+      fAction<span class="punctuation token">.</span><span class="function token">apply<span class="punctuation token">(</span></span>aNodeList<span class="punctuation token">[</span>nItem<span class="operator token">++</span><span class="punctuation token">]</span><span class="punctuation token">,</span> aArgs<span class="punctuation token">)</span>
+    <span class="punctuation token">)</span><span class="punctuation token">;</span>
+    <span class="keyword token">this</span><span class="punctuation token">.</span>follow <span class="operator token">=</span> setSomething<span class="punctuation token">.</span>caller<span class="punctuation token">;</span>
+    <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">;</span>
+  <span class="punctuation token">}</span>
+
+  <span class="keyword token">function</span> <span class="function token">setStyles<span class="punctuation token">(</span></span>sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> setSomething<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span><span class="keyword token">this</span><span class="punctuation token">,</span> <span class="keyword token">true</span><span class="punctuation token">,</span> sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="punctuation token">}</span>
+  <span class="keyword token">function</span> <span class="function token">setAttribs<span class="punctuation token">(</span></span>sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> setSomething<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span><span class="keyword token">this</span><span class="punctuation token">,</span> <span class="keyword token">false</span><span class="punctuation token">,</span> sProp<span class="punctuation token">,</span> sVal<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="punctuation token">}</span>
+  <span class="keyword token">function</span> <span class="function token">getSelectors<span class="punctuation token">(</span></span><span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">.</span>selectors<span class="punctuation token">;</span> <span class="punctuation token">}</span><span class="punctuation token">;</span>
+  <span class="keyword token">function</span> <span class="function token">getNodes<span class="punctuation token">(</span></span><span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">.</span>nodes<span class="punctuation token">;</span> <span class="punctuation token">}</span><span class="punctuation token">;</span>
+
+  <span class="keyword token">return</span> <span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span>sSelectors<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">var</span> oQuery <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Function</span><span class="punctuation token">(</span><span class="string token">'return arguments.callee.follow.apply(arguments.callee, arguments);'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+    oQuery<span class="punctuation token">.</span>selectors <span class="operator token">=</span> sSelectors<span class="punctuation token">;</span>
+    oQuery<span class="punctuation token">.</span>nodes <span class="operator token">=</span> document<span class="punctuation token">.</span><span class="function token">querySelectorAll<span class="punctuation token">(</span></span>sSelectors<span class="punctuation token">)</span><span class="punctuation token">;</span>
+    oQuery<span class="punctuation token">.</span>cssNodes <span class="operator token">=</span> Array<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>map<span class="punctuation token">.</span><span class="function token">call<span class="punctuation token">(</span></span>oQuery<span class="punctuation token">.</span>nodes<span class="punctuation token">,</span> <span class="keyword token">function</span><span class="punctuation token">(</span>oInlineCSS<span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="keyword token">return</span> oInlineCSS<span class="punctuation token">.</span>style<span class="punctuation token">;</span> <span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+    oQuery<span class="punctuation token">.</span>attributes <span class="operator token">=</span> setAttribs<span class="punctuation token">;</span>
+    oQuery<span class="punctuation token">.</span>inlineStyle <span class="operator token">=</span> setStyles<span class="punctuation token">;</span>
+    oQuery<span class="punctuation token">.</span>follow <span class="operator token">=</span> getNodes<span class="punctuation token">;</span>
+    oQuery<span class="punctuation token">.</span>toString <span class="operator token">=</span> getSelectors<span class="punctuation token">;</span>
+    oQuery<span class="punctuation token">.</span>valueOf <span class="operator token">=</span> getNodes<span class="punctuation token">;</span>
+    <span class="keyword token">return</span> oQuery<span class="punctuation token">;</span>
+  <span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;/</span>script</span><span class="punctuation token">&gt;</span></span></span>
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;/</span>head</span><span class="punctuation token">&gt;</span></span>
+
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>body</span><span class="punctuation token">&gt;</span></span>
+
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>div</span> <span class="attr-name token">class</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>testClass<span class="punctuation token">"</span></span><span class="punctuation token">&gt;</span></span>Lorem ipsum<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;/</span>div</span><span class="punctuation token">&gt;</span></span>
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>p</span><span class="punctuation token">&gt;</span></span>Some text<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;/</span>p</span><span class="punctuation token">&gt;</span></span>
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>div</span> <span class="attr-name token">class</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>testClass<span class="punctuation token">"</span></span><span class="punctuation token">&gt;</span></span>dolor sit amet<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;/</span>div</span><span class="punctuation token">&gt;</span></span>
+
+<span class="script token"><span class="tag token"><span class="tag token"><span class="punctuation token">&lt;</span>script</span> <span class="attr-name token">type</span><span class="attr-value token"><span class="punctuation token">=</span><span class="punctuation token">"</span>text/javascript<span class="punctuation token">"</span></span><span class="punctuation token">&gt;</span></span>
+<span class="function token">domQuery<span class="punctuation token">(</span></span><span class="string token">'.testClass'</span><span class="punctuation token">)</span>
+  <span class="punctuation token">.</span><span class="function token">attributes<span class="punctuation token">(</span></span><span class="string token">'lang'</span><span class="punctuation token">,</span> <span class="string token">'en'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'title'</span><span class="punctuation token">,</span> <span class="string token">'Risus abundat in ore stultorum'</span><span class="punctuation token">)</span>
+  <span class="punctuation token">.</span><span class="function token">inlineStyle<span class="punctuation token">(</span></span><span class="string token">'background-color'</span><span class="punctuation token">,</span> <span class="string token">'black'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'color'</span><span class="punctuation token">,</span> <span class="string token">'white'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'width'</span><span class="punctuation token">,</span> <span class="string token">'100px'</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="string token">'height'</span><span class="punctuation token">,</span> <span class="string token">'50px'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;/</span>script</span><span class="punctuation token">&gt;</span></span></span>
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;/</span>body</span><span class="punctuation token">&gt;</span></span>
+
+<span class="tag token"><span class="tag token"><span class="punctuation token">&lt;/</span>html</span><span class="punctuation token">&gt;</span></span></code></pre>
+
+<p> </p>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<p> </p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("Statements/function", "function statement")}}</li>
+ <li>{{jsxref("Operators/function", "function expression")}}</li>
+ <li>{{jsxref("Statements/function*", "function* statement")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("GeneratorFunction")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/function/length/index.html b/files/pl/web/javascript/reference/global_objects/function/length/index.html
new file mode 100644
index 0000000000..df26b64675
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/function/length/index.html
@@ -0,0 +1,43 @@
+---
+title: Function.length
+slug: Web/JavaScript/Reference/Global_Objects/Function/length
+tags:
+  - Function
+  - JavaScript
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/length
+original_slug: Web/JavaScript/Referencje/Obiekty/Function/length
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Określa liczbę argumentów oczekiwanych przez funkcję.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Obiekt <code>length</code> znajduje się na zewnątrz funkcji i określa jak wiele argumentów ma oczekiwać funkcja, i.e. liczbę oficjalnych parametrów. W przeciwieństwie do obiektu {{jsxref("arguments.length")}}, który znajduje się wewnątrz funkcji, określa liczbę argumentów faktycznie przekazywanych do funkcji.</p>
+
+<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length" name="Przyk.C5.82ad:_Zastosowanie_Function.length_i_arguments.length">Przykład: Zastosowanie <code>Function.length</code> i <code>arguments.length</code></h3>
+
+<p>Następujący przykład pokazuje w jaki należy zastosować <code>Function.length</code> i <code>arguments.length</code>.</p>
+
+<pre class="brush: js">function addNumbers(x, y){
+   if (arguments.length == addNumbers.length) {
+      return (x + y);
+   }
+   else
+      return 0;
+}
+</pre>
+
+<p>Jeśli podamy więcej niż dwa argumenty do tej funkcji, funkcja zwróci 0:</p>
+
+<pre class="eval">addNumbers(3,4,5)   // zwraca 0
+addNumbers(3,4)     // zwraca 7
+addNumbers(103,104) // zwraca 207
+</pre>
+
+<div class="noinclude"> </div>
diff --git a/files/pl/web/javascript/reference/global_objects/function/tostring/index.html b/files/pl/web/javascript/reference/global_objects/function/tostring/index.html
new file mode 100644
index 0000000000..675f65c662
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/function/tostring/index.html
@@ -0,0 +1,57 @@
+---
+title: Function.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Function/toString
+tags:
+  - Function
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/Function/toString
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący kod źródłowy funkcji.</p>
+
+<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3>
+
+<pre class="syntaxbox"><code><var>function</var>.toString(indentation)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>indentation</code> {{non-standard_inline}} {{obsolete_inline(17)}}</dt>
+ <dd>The amount of spaces to indent the string representation of the source code. If <code>indentation</code> is less than or equal to <code>-1</code>, most unnecessary spaces are removed.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Obiekt {{jsxref("Function")}} przesłania metodę {{jsxref("Object.prototype.toString", "toString")}} obiektu {{jsxref("Function")}}; nie dziedziczy {{jsxref("Object.prototype.toString")}}. Dla obiektów <code>Function</code>, metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt.</p>
+
+<p>JavaScript wywołuje metodę <code>toString()</code> automatycznie, gdy {{jsxref("Function")}} jest reprezentowana jako wartość tekstowa lub kiedy <code>Function</code> jest odsyłana do połączenia łańcuchów znaków.</p>
+
+<p>Dla obiektów {{jsxref("Function")}}, wbudowana metoda <code>toString)=</code> dekompiluje funkcję z powrotem do kodu JavaScript, który tę funkcję definiuje. Łańcuch znaków zawiera słowa kluczowe <code>function</code>, listę argumentów, nawiasy klamrowe oraz ciało funkcji.</p>
+
+<p>Załóżmy na przykład, że masz poniższy kod, który definiuje obiektowy typ <code>Dog</code> i tworzy <code>theDog</code>, obiekt typu <code>Dog</code>:</p>
+
+<pre class="brush:js">function Dog(name, breed, color, sex) {
+   this.name = name
+   this.breed = breed
+   this.color = color
+   this.sex = sex
+}
+
+theDog = new Dog( "Gabby", "Lab", "chocolate", "girl" );
+</pre>
+
+<p>W dowolnej chwili, gdy <code>Dog</code> jest użyty w kontekście jako łańcuch znaków, JavaScript automatycznie wywołuje funkcję <code>toString</code>, która zwraca poniższy łańcuch znaków:</p>
+
+<pre class="brush: js">function Dog(name, breed, color, sex) { this.name = name; this.breed = breed; this.color = color; this.sex = sex; }</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/generator/index.html b/files/pl/web/javascript/reference/global_objects/generator/index.html
new file mode 100644
index 0000000000..a84467e7ca
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/generator/index.html
@@ -0,0 +1,179 @@
+---
+title: Generator
+slug: Web/JavaScript/Reference/Global_Objects/Generator
+translation_of: Web/JavaScript/Reference/Global_Objects/Generator
+original_slug: Web/JavaScript/Referencje/Obiekty/Generator
+---
+<div>{{JSRef}}</div>
+
+<p>Obiekt <code><strong>Generator</strong></code> jest zwracany przez {{jsxref("Polecenia/function*", "generator function", "", 1)}} i odpowiada obu: <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable">iterable protocol</a> i <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator">iterator protocol</a>.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">function* gen() {
+  yield 1;
+  yield 2;
+  yield 3;
+}
+
+var g = gen(); // "Generator { }"</pre>
+
+<h2 id="Methods">Methods</h2>
+
+<dl>
+ <dt>{{jsxref("Generator.prototype.next()")}}</dt>
+ <dd>Returns a value yielded by the {{jsxref("Operators/yield", "yield")}} expression.</dd>
+ <dt>{{jsxref("Generator.prototype.return()")}}</dt>
+ <dd>Returns the given value and finishes the generator.</dd>
+ <dt>{{jsxref("Generator.prototype.throw()")}}</dt>
+ <dd>Throws an error to a generator.</dd>
+</dl>
+
+<h2 id="Example">Example</h2>
+
+<h3 id="An_infinite_iterator">An infinite iterator</h3>
+
+<pre class="brush: js">function* idMaker() {
+    var index = 0;
+    while(true)
+        yield index++;
+}
+
+var gen = idMaker(); // "Generator { }"
+
+console.log(gen.next().value); // 0
+console.log(gen.next().value); // 1
+console.log(gen.next().value); // 2
+// ...</pre>
+
+<h2 id="Legacy_generator_objects">Legacy generator objects</h2>
+
+<p>Firefox (SpiderMonkey) also implements an earlier version of generators in <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.7">JavaScript 1.7</a>, where the star (*) in the function declaration was not necessary (you just use the <code>yield</code> keyword in the function body). However, legacy generators are deprecated. Do not use them; they are going to be removed ({{bug(1083482)}}).</p>
+
+<h3 id="Legacy_generator_methods">Legacy generator methods</h3>
+
+<dl>
+ <dt><code>Generator.prototype.next() </code>{{non-standard_inline}}</dt>
+ <dd>Returns a value yielded by the {{jsxref("Operatory/yield", "yield")}} expression. This corresponds to <code>next()</code> in the ES2015 generator object.</dd>
+ <dt><code>Generator.prototype.close()</code> {{non-standard_inline}}</dt>
+ <dd>Closes the generator, so that when calling <code>next()</code> an {{jsxref("StopIteration")}} error will be thrown. This corresponds to the <code>return()</code> method in the ES2015 generator object.</dd>
+ <dt><code>Generator.prototype.send()</code> {{non-standard_inline}}</dt>
+ <dd>Used to send a value to a generator. The value is returned from the {{jsxref("Operatory/yield", "yield")}} expression, and returns a value yielded by the next {{jsxref("Operatory/yield", "yield")}} expression. <code>send(x)</code> corresponds to <code>next(x)</code> in the ES2015 generator object.</dd>
+ <dt><strong><code>Generator.</code></strong><code>prototype.</code><strong><code>throw()</code> </strong> {{non-standard_inline}}</dt>
+ <dd>Throws an error to a generator. This corresponds to the <code>throw()</code> method in the ES2015 generator object.</dd>
+</dl>
+
+<h3 id="Legacy_generator_example">Legacy generator example</h3>
+
+<pre class="brush: js">function fibonacci() {
+  var a = yield 1;
+  yield a * 2;
+}
+
+var it = fibonacci();
+console.log(it);          // "Generator {  }"
+console.log(it.next());   // 1
+console.log(it.send(10)); // 20
+console.log(it.close());  // undefined
+console.log(it.next());   // throws StopIteration (as the generator is now closed)
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-generator-objects', 'Generator objects')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-generator-objects', 'Generator objects')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(39.0)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(39.0)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(39.0)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<h3 id="Legacy_generators">Legacy generators</h3>
+
+<ul>
+ <li>{{jsxref("Statements/Legacy_generator_function", "The legacy generator function", "", 1)}}</li>
+ <li>{{jsxref("Operators/Legacy_generator_function", "The legacy generator function expression", "", 1)}}</li>
+ <li>{{jsxref("StopIteration")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features/The_legacy_Iterator_protocol">The legacy Iterator protocol</a></li>
+</ul>
+
+<h3 id="ES2015_generators">ES2015 generators</h3>
+
+<ul>
+ <li>{{jsxref("Functions", "Functions", "", 1)}}</li>
+ <li>{{jsxref("Statements/function", "function")}}</li>
+ <li>{{jsxref("Operators/function", "function expression")}}</li>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("Statements/function*", "function*")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("GeneratorFunction")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/index.html b/files/pl/web/javascript/reference/global_objects/index.html
new file mode 100644
index 0000000000..8d18c5e730
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/index.html
@@ -0,0 +1,194 @@
+---
+title: Obiekty
+slug: Web/JavaScript/Reference/Global_Objects
+tags:
+  - Dokumentacja
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects
+original_slug: Web/JavaScript/Referencje/Obiekty
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p>W tym rozdziale opisano wszystkie standardowe obiekty wbudowane JavaScript, w tym ich metody i właściwości.</p>
+
+<p>Pojęcie "obiekty globalne" (lub standardowe obiekty wbudowane) tutaj nie są tym samym, co <strong>obiekt globalny</strong>, który  odnosi się do <strong>obiektów o zasięgu globalnym</strong>. Dostęp do <strong>obiektu globalnego</strong> można uzyskać za pomocą operatoa {{jsxref("Operatory/this", "this")}} w zakresie globalnym (ale tylko, jeśli nie jest właczony tryb ścisły ECMAScript 5. W trybie ścisłym, w takim przypadku zostanie zwrócona wartość  {{jsxref("undefined")}}). W rzeczywistości, zakres globalny <strong>składa się</strong> z własciwości obiektu globalnego, w tym właściwości dziedziczonych, jeśli istnieją.</p>
+
+<p>Innymi obiektami o zasięgu globalnym są <a href="/pl/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">obiekty tworzone w skryptach przez użytkowników</a> albo dostarczane przez aplikacje hosta. Obiekty hosta dostępne w kontekście przeglądarki są opisane w  <a href="/pl/docs/Web/API/Reference">informatorze API</a>. Więcej informacji o różnicach dzielących <a href="/pl/docs/DOM/DOM_Reference">DOM</a> i rdzeń <a href="/pl/docs/Web/JavaScript">JavaScript</a>, znajdziesz we <a href="/pl/docs/Web/JavaScript/JavaScript_technologies_overview">Przeglądzie technologii JavaScript</a>.</p>
+
+<h2 id="Obiekty_standardowe_wg_kategorii">Obiekty standardowe wg kategorii</h2>
+
+<h3 id="Wartości">Wartości</h3>
+
+<p>Właściwości globalne zwracają proste wartości, które nie mają swoich własciwości ani metod</p>
+
+<ul>
+ <li>{{jsxref("Infinity")}}</li>
+ <li>{{jsxref("NaN")}}</li>
+ <li>{{jsxref("undefined")}}</li>
+ <li>literał {{jsxref("null")}}</li>
+</ul>
+
+<h3 id="Funkcje">Funkcje</h3>
+
+<p>Należą tu funkcje globalne (wywoływane globalnie a nie w jakimś obiekcie), które  zwracają swoją wartość bezpośredni do wywołania.</p>
+
+<ul>
+ <li>{{jsxref("Global_Objects/eval", "eval()")}}</li>
+ <li>{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li>
+ <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li>
+ <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li>
+ <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li>
+ <li>{{jsxref("Global_Objects/decodeURI", "decodeURI()")}}</li>
+ <li>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent()")}}</li>
+ <li>{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}</li>
+ <li>{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}</li>
+ <li>{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline}}</li>
+ <li>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline}}</li>
+</ul>
+
+<h3 id="Obiekty_podstawowe">Obiekty podstawowe</h3>
+
+<p>Są to  fundamentalne, podstawowe obiekty, stanowiące podstawę do tworzenia innych obiektów. Obejmuje to obiekty reprezentujace obiekty ogólne, funkcje i błędy.</p>
+
+<ul>
+ <li>{{jsxref("Object")}}</li>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("Boolean")}}</li>
+ <li>{{jsxref("Symbol")}}</li>
+ <li>{{jsxref("Error")}}</li>
+ <li>{{jsxref("EvalError")}}</li>
+ <li>{{jsxref("InternalError")}}</li>
+ <li>{{jsxref("RangeError")}}</li>
+ <li>{{jsxref("ReferenceError")}}</li>
+ <li>{{jsxref("SyntaxError")}}</li>
+ <li>{{jsxref("TypeError")}}</li>
+ <li>{{jsxref("URIError")}}</li>
+</ul>
+
+<h3 id="Liczby_i_daty">Liczby i daty</h3>
+
+<p>Są to obiekty podstawowe reprezentujace liczby, daty i obliczenia matematyczne.</p>
+
+<ul>
+ <li>{{jsxref("Number")}}</li>
+ <li>{{jsxref("Math")}}</li>
+ <li>{{jsxref("Date")}}</li>
+</ul>
+
+<h3 id="Przetwarzanie_tekstu">Przetwarzanie tekstu</h3>
+
+<p>Kategorie te tworzą obiekty reprezentujące łańcuchy i obsługujace manipulowanie łańcuchami.</p>
+
+<ul>
+ <li>{{jsxref("String")}}</li>
+ <li>{{jsxref("RegExp")}}</li>
+</ul>
+
+<h3 id="Indeksowane_kolekcje">Indeksowane kolekcje</h3>
+
+<p>Obiekty te reprezentują kolekcje danych, ktore są uporządkowane według wartości indeksu. Opejmuje to tablice, typowane tablice i konstrukcje podobne do tablic.</p>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+ <li>{{jsxref("Int8Array")}}</li>
+ <li>{{jsxref("Uint8Array")}}</li>
+ <li>{{jsxref("Uint8ClampedArray")}}</li>
+ <li>{{jsxref("Int16Array")}}</li>
+ <li>{{jsxref("Uint16Array")}}</li>
+ <li>{{jsxref("Int32Array")}}</li>
+ <li>{{jsxref("Uint32Array")}}</li>
+ <li>{{jsxref("Float32Array")}}</li>
+ <li>{{jsxref("Float64Array")}}</li>
+</ul>
+
+<h3 id="Kolekcje_z_kluczami">Kolekcje z kluczami</h3>
+
+<p>Są to obiekty reprezentujące kolekcje stosujace klucze. Zawierają elementy, które są iterowalne w kolejności estawiania.</p>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("WeakMap")}}</li>
+ <li>{{jsxref("WeakSet")}}</li>
+</ul>
+
+<h3 id="Kolekcje_wektorowe">Kolekcje wektorowe</h3>
+
+<p>Typy danych wektorowych {{Glossary("SIMD")}} są obiektami, w których dane formowane są w potoki.</p>
+
+<ul>
+ <li>{{jsxref("SIMD")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Float32x4", "SIMD.Float32x4")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Float64x2", "SIMD.Float64x2")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Int8x16", "SIMD.Int8x16")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Int16x8", "SIMD.Int16x8")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Int32x4", "SIMD.Int32x4")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Uint8x16", "SIMD.Uint8x16")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Uint16x8", "SIMD.Uint16x8")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Uint32x4", "SIMD.Uint32x4")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Bool8x16", "SIMD.Bool8x16")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Bool16x8", "SIMD.Bool16x8")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Bool32x4", "SIMD.Bool32x4")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Bool64x2", "SIMD.Bool64x2")}} {{experimental_inline}}</li>
+</ul>
+
+<h3 id="Dane_strukturalne">Dane strukturalne</h3>
+
+<p>Obiekty tej kategorii reprezentują i współdziałają ze strukturyzowanymi buforami danych i danymi kodowymi uzywającymi notacji JSON (JavaScript Object Notation).</p>
+
+<ul>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li>{{jsxref("SharedArrayBuffer")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Atomics")}} {{experimental_inline}}</li>
+ <li>{{jsxref("DataView")}}</li>
+ <li>{{jsxref("JSON")}}</li>
+</ul>
+
+<h3 id="Kontrola_obiektów_abstrakcyjnych">Kontrola obiektów abstrakcyjnych</h3>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Generator")}}</li>
+ <li>{{jsxref("GeneratorFunction")}}</li>
+ <li>{{experimental_inline}} {{jsxref("AsyncFunction")}}</li>
+</ul>
+
+<h3 id="Refleksy">Refleksy</h3>
+
+<ul>
+ <li>{{jsxref("Reflect")}}</li>
+ <li>{{jsxref("Proxy")}}</li>
+</ul>
+
+<h3 id="Internacjonalizacja">Internacjonalizacja</h3>
+
+<p>Dodatki do jadra ECMAScript dla funkcji językowych.</p>
+
+<ul>
+ <li>{{jsxref("Intl")}}</li>
+ <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li>
+ <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+ <li>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</li>
+</ul>
+
+<h3 id="WebAssembly">WebAssembly</h3>
+
+<ul>
+ <li>{{jsxref("WebAssembly")}}</li>
+ <li>{{jsxref("WebAssembly.Module")}}</li>
+ <li>{{jsxref("WebAssembly.Instance")}}</li>
+ <li>{{jsxref("WebAssembly.Memory")}}</li>
+ <li>{{jsxref("WebAssembly.Table")}}</li>
+ <li>{{jsxref("WebAssembly.CompileError")}}</li>
+ <li>{{jsxref("WebAssembly.LinkError")}}</li>
+ <li>{{jsxref("WebAssembly.RuntimeError")}}</li>
+</ul>
+
+<h3 id="Pozostałe">Pozostałe</h3>
+
+<ul>
+ <li><code><a href="/pl/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></code></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/infinity/index.html b/files/pl/web/javascript/reference/global_objects/infinity/index.html
new file mode 100644
index 0000000000..e20fe96052
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/infinity/index.html
@@ -0,0 +1,36 @@
+---
+title: Infinity
+slug: Web/JavaScript/Reference/Global_Objects/Infinity
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/Infinity
+original_slug: Web/JavaScript/Referencje/Obiekty/Infinity
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wartość numeryczna reprezentująca nieskończoność.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Infinity </code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>Infinity</code> jest własnością najwyższego rzędu i nie jest przypisana do żadnego obiektu.</p>
+
+<p>Początkową wartością <code>Infinity</code> jest {{jsxref("Number.POSITIVE_INFINITY")}}.</p>
+
+<p>Wartość <code>Infinity</code> (+nieskończoność) jest większa niż jakakolwiek liczba. Wartość ta ma wszystkie cechy matematycznej nieskończoności; np. cokolwiek pomnożone przez <code>Infinity</code> jest równe <code>Infinity</code>, a cokolwiek podzielone przez <code>Infinity</code> jest równe 0.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
+ <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/isfinite/index.html b/files/pl/web/javascript/reference/global_objects/isfinite/index.html
new file mode 100644
index 0000000000..9147ea7ad8
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/isfinite/index.html
@@ -0,0 +1,57 @@
+---
+title: isFinite()
+slug: Web/JavaScript/Reference/Global_Objects/isFinite
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/isFinite
+original_slug: Web/JavaScript/Referencje/Obiekty/isFinite
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Przetwarza argument w celu stwierdzenia czy jest on liczbą skończoną.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox">isFinite(<em>liczba</em>)</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>liczba</code> </dt>
+ <dd>Liczba do przetworzenia.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>isFinite()</code> jest funkcją najwyższego poziomu, niepowiązaną z żadnym obiektem.</p>
+
+<p>Można użyć tej metody do określenia czy dana liczba jest skończona. Metoda <code>isFinite()</code> sprawdza liczbę podaną jako jej argument. Jeśli argument ma wartość {{jsxref("NaN")}} (nie jest liczbą), jest dodatnią lub ujemną nieskończonością, metoda ta zwraca <code>false</code>, w przeciwnym wypadku zwraca wartość <code>true</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<pre class="brush: js">isFinite(Infinity);  // false
+isFinite(NaN);       // false
+isFinite(-Infinity); // false
+
+isFinite(0);         // true
+isFinite(2e64);      // true
+
+
+isFinite("0");       // true, would've been false with the
+                     // more robust Number.isFinite("0")
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.isFinite()")}}</li>
+ <li>{{jsxref("Number.NaN()")}}</li>
+ <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
+ <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/isnan/index.html b/files/pl/web/javascript/reference/global_objects/isnan/index.html
new file mode 100644
index 0000000000..fa2ec80b5c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/isnan/index.html
@@ -0,0 +1,54 @@
+---
+title: isNaN()
+slug: Web/JavaScript/Reference/Global_Objects/isNaN
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/isNaN
+original_slug: Web/JavaScript/Referencje/Obiekty/isNaN
+---
+<p>{{jsSidebar("Objects")}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Sprawdza, czy argument nie ma wartości NaN ("nie-liczba").</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>isNaN(<em>testowanaWartość</em>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>testowanaWartość</code> </dt>
+ <dd>Wartość do sprawdzenia.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>isNaN</code> jest funkcją najwyższego rzędu i nie jest przypisana do żadnego obiektu.</p>
+
+<p>Funkcje <code>parseFloat</code> i <code>parseInt</code> zwracają <code>NaN</code>, kiedy wyliczą wartość, która nie jest liczbą. <code>isNaN</code> zwraca <code>true</code>, jeśli przekazano jej <code>NaN</code>, a <code>false</code> w przeciwnym wypadku.</p>
+
+<p>Funkcja ta jest o tyle przydatna, że wartości {{jsxref("NaN", "NaN")}} nie można skutecznie sprawdzać przy użyciu operatorów równości. <code>x == NaN</code> i <code>x === NaN</code> mają zawsze wartość <code>false</code>, bez względu na to, jaką wartość ma <code>x</code>, nawet jeśli <code>x</code> to <code>NaN</code>. Na przykład, zarówno <code>1 == NaN</code>, jak i <code>NaN == NaN</code> zwracają <code>false</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_isNaN" name="Przyk.C5.82ad:_Zastosowanie_isNaN">Przykład: Zastosowanie <code>isNaN</code></h3>
+
+<p>Poniższy przykład wylicza wartość <code>floatValue</code>, by sprawdzić, czy jest liczbą, a następnie wywołuje odpowiednią procedurę.</p>
+
+<pre class="brush: js">var floatValue = parseFloat(toFloat);
+
+if (isNaN(floatValue)) {
+   notFloat();
+} else {
+   isFloat();
+}
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("NaN")}}</li>
+ <li>{{jsxref("Number.isNaN()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/json/index.html b/files/pl/web/javascript/reference/global_objects/json/index.html
new file mode 100644
index 0000000000..18d748958d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/json/index.html
@@ -0,0 +1,148 @@
+---
+title: JSON
+slug: Web/JavaScript/Reference/Global_Objects/JSON
+tags:
+  - JSON
+  - JavaScript
+  - Obiekt
+translation_of: Web/JavaScript/Reference/Global_Objects/JSON
+original_slug: Web/JavaScript/Referencje/Obiekty/JSON
+---
+<div>{{JSRef}}</div>
+
+<p>Obiekt <strong><code>JSON</code></strong> zawiera metody do analizy składniowej <a class="external" href="https://json.org/">JavaScript Object Notation</a> ({{glossary("JSON")}}) i konwertowania wartości do formatu JSON. Nie może być on wywołany lub utworzony i oprócz jego dwóch metod, sam w sobie nie ma interesującej funkcjonalności .</p>
+
+<h2 id="Różnice_między_językiem_JavaScript_i_formatem_JSON">Różnice między językiem JavaScript i formatem JSON</h2>
+
+<p>Format JSON jest składnią do serializowania obiektów, tablic, liczb, napisów, wartości logicznych oraz {{jsxref("null")}}. Bazuje na składni języka JavaScript, ale różni się od niego: <em>nie każdy</em> JavaScript to JSON.</p>
+
+<p><strong>Obiekty i tablice</strong>: Nazwy właściwości muszą znajdować się w podwójnym cudzysłowie;  przecinki na końcach (<a href="https://wiki.developer.mozilla.org/pl/docs/Web/JavaScript/Reference/Trailing_commas">trailing commas</a>) nie są dozwolone.</p>
+
+<p><strong>Liczby</strong>: Zera nieznaczące są zakazane. Po przecinku musi się znaleźć co najmniej jedna liczba. Wartości NaN i Infinity nie są wspierane.</p>
+
+<p><strong>Każdy tekst w formacie JSON jest poprawnym wyrażeniem w języku JavaScript</strong> – ale wyłącznie w silnikach JavaScript, które mają zaimplementową możliwości, <a href="https://github.com/tc39/proposal-json-superset">by wszystkie dokumenty w formacie JSON były zgodne ze standardem ECMA-262</a>. W przeciwnym razie, znaki U+2028 (separator linii) i U+2029 (separator akapitów) są dozwolone w literałach znakowych i kluczach w formacie JSON, ale ich użycie w tym konteksie w języku JavaScript skutkuje zgłoszeniem błędu {{jsxref("SyntaxError")}}.</p>
+
+<p>Rozważmy przykład, gdzie funkcja {{jsxref("JSON.parse()")}} przetwarza poniższy literał znakowy jako obiekt JSON, a funkcja <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval">eval</a></code> wykonuje go jako tekst w języku JavaScript:</p>
+
+<pre class="brush: js">var code = '"\u2028\u2029"';
+JSON.parse(code); // działa poprawnie
+eval(code); // zgłasza błąd SyntaxError
+</pre>
+
+<p>Inne różnice to zgoda wyłącznie na literały znakowe w podwójnym cudzysłowie, brak zabezpieczenia dla {{jsxref("undefined")}} lub komentarzy.</p>
+
+<h2 id="Pełna_składnia_JSON">Pełna składnia JSON</h2>
+
+<p>Pełna składnia JSON jest następująca:</p>
+
+<pre class="syntaxbox"><var>JSON</var> = <strong>null</strong>
+    <em>or</em> <strong>true</strong> <em>or</em> <strong>false</strong>
+    <em>or</em> <var>JSONNumber</var>
+    <em>or</em> <var>JSONString</var>
+    <em>or</em> <var>JSONObject</var>
+    <em>or</em> <var>JSONArray</var>
+
+<var>JSONNumber</var> = <strong>-</strong> <var>PositiveNumber</var>
+          <em>or</em> <var>PositiveNumber</var>
+<var>PositiveNumber</var> = DecimalNumber
+              <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var>
+              <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> <var>ExponentPart</var>
+              <em>or</em> <var>DecimalNumber</var> <var>ExponentPart</var>
+<var>DecimalNumber</var> = <strong>0</strong>
+             <em>or</em> <var>OneToNine</var> <var>Digits</var>
+<var>ExponentPart</var> = <strong>e</strong> <var>Exponent</var>
+            <em>or</em> <strong>E</strong> <var>Exponent</var>
+<var>Exponent</var> = <var>Digits</var>
+        <em>or</em> <strong>+</strong> <var>Digits</var>
+        <em>or</em> <strong>-</strong> <var>Digits</var>
+<var>Digits</var> = <var>Digit</var>
+      <em>or</em> <var>Digits</var> <var>Digit</var>
+<var>Digit</var> = <strong>0</strong> through <strong>9</strong>
+<var>OneToNine</var> = <strong>1</strong> through <strong>9</strong>
+
+<var>JSONString</var> = <strong>""</strong>
+          <em>or</em> <strong>"</strong> <var>StringCharacters</var> <strong>"</strong>
+<var>StringCharacters</var> = <var>StringCharacter</var>
+                <em>or</em> <var>StringCharacters</var> <var>StringCharacter</var>
+<var>StringCharacter</var> = any character
+                  <em>except</em> <strong>"</strong> <em>or</em> <strong>\</strong> <em>or</em> U+0000 through U+001F
+               <em>or</em> <var>EscapeSequence</var>
+<var>EscapeSequence</var> = <strong>\"</strong> <em>or</em> <strong>\/</strong> <em>or</em> <strong>\\</strong> <em>or</em> <strong>\b</strong> <em>or</em> <strong>\f</strong> <em>or</em> <strong>\n</strong> <em>or</em> <strong>\r</strong> <em>or</em> <strong>\t</strong>
+              <em>or</em> <strong>\u</strong> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var>
+<var>HexDigit</var> = <strong>0</strong> through <strong>9</strong>
+        <em>or</em> <strong>A</strong> through <strong>F</strong>
+        <em>or</em> <strong>a</strong> through <strong>f</strong>
+
+<var>JSONObject</var> = <strong>{</strong> <strong>}</strong>
+          <em>or</em> <strong>{</strong> <var>Members</var> <strong>}</strong>
+<var>Members</var> = <var>JSONString</var> <strong>:</strong> <var>JSON</var>
+       <em>or</em> <var>Members</var> <strong>,</strong> <var>JSONString</var> <strong>:</strong> <var>JSON</var>
+
+<var>JSONArray</var> = <strong>[</strong> <strong>]</strong>
+         <em>or</em> <strong>[</strong> <var>ArrayElements</var> <strong>]</strong>
+<var>ArrayElements</var> = <var>JSON</var>
+             <em>or</em> <var>ArrayElements</var> <strong>,</strong> <var>JSON</var>
+</pre>
+
+<p>Nieznaczące białe znaki nie mogą występować tylko wewnątrz <code><var>JSONNumber</var></code> (liczby nie mogą zawierać białych znaków) oraz <code><var>JSONString</var></code> (gdzie jest to interpretowane jako odpowiedni znak w litarale znakowym lub może spowodować błąd). Tabulacja pozioma (<a href="https://unicode-table.com/pl/#0009">U+0009</a>), powrót karetki (<a href="https://unicode-table.com/pl/#000D">U+000D</a>), nowa linia (<a href="https://unicode-table.com/pl/#000A">U+000A</a>) oraz spacja (<a href="https://unicode-table.com/pl/#0020">U+0020</a>) to jedyne prawidłowe białe znaki.</p>
+
+<h2 id="Metody">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("JSON.parse()")}}</dt>
+ <dd>Parsuje literał znakowy na JSON, opcjonalnie przekształca otrzymaną wartosć i ją zwraca. Każde naruszenie składni JSON, wliczając w różnice między językiem JavaScript i JSON, powodują zgłosznie błędu {{jsxref("SyntaxError")}}. Opcja <code>reviver</code> pozwala zinterpretować, co <code>replacer</code> użył zamiast innych typów danych.</dd>
+ <dt>{{jsxref("JSON.stringify()")}}</dt>
+ <dd>Zwraca literał znakowy JSON odpowiadający określonej wartosci, ewentualnie zawierający jedynie niektóre wartości lub ze zamienionymi wartościami w sposób zdefinowany przez użytkownika. Domyślnie, wszystkie instance {{jsxref("undefined")}} są zastępowane przez {{jsxref("null")}} i inne niewspierane typy danych są ocenzurowywane. Opcja <code>replacer</code> pozwala określić inne zachowanie.</dd>
+</dl>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.12', 'JSON')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-json-object', 'JSON')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-json-object', 'JSON')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność">Kompatybilność</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.JSON")}}</p>
+</div>
+</div>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toJSON()")}}</li>
+</ul>
+
+<h2 id="Tools">Tools</h2>
+
+<ul>
+ <li><a href="http://jsoncompare.org/">JSON Diff</a> checker.</li>
+ <li><a href="http://jsonbeautifier.org/">JSON Beautifier/editor</a>.</li>
+ <li><a href="http://jsonparser.org/">JSON Parser</a></li>
+ <li><a href="https://tools.learningcontainer.com/json-validator/">JSON Validator</a>.</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/clear/index.html b/files/pl/web/javascript/reference/global_objects/map/clear/index.html
new file mode 100644
index 0000000000..15fa630779
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/clear/index.html
@@ -0,0 +1,88 @@
+---
+title: Map.prototype.clear()
+slug: Web/JavaScript/Reference/Global_Objects/Map/clear
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Mapa
+  - Metodă
+  - Prototyp
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/clear
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/clear
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>clear()</strong></code> usuwa wszystkie elementy z obiektu <code>Map</code>.</p>
+
+<pre class="brush: js">var map1 = new Map();
+
+map1.set('bar', 'baz');
+map1.set(1, 'foo');
+
+console.log(map1.size);
+// wartość zwracana: 2
+
+map1.clear();
+
+console.log(map1.size);
+// wartość zwracana: 0
+</pre>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.clear();</code></pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>{{jsxref("undefined")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_metody_clear">Używanie metody <code>clear</code></h3>
+
+<pre class="brush: js">var myMap = new Map();
+myMap.set('bar', 'baz');
+myMap.set(1, 'foo');
+
+myMap.size;       // 2
+myMap.has('bar'); // true
+
+myMap.clear();
+
+myMap.size;       // 0
+myMap.has('bar')  // false
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.clear")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/delete/index.html b/files/pl/web/javascript/reference/global_objects/map/delete/index.html
new file mode 100644
index 0000000000..bb33f16d44
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/delete/index.html
@@ -0,0 +1,86 @@
+---
+title: Map.prototype.delete()
+slug: Web/JavaScript/Reference/Global_Objects/Map/delete
+tags:
+  - Mapa
+  - Metodă
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/delete
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/delete
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>delete()</strong></code> usuwa określony element z obiektu <code>Map</code>.</p>
+
+<pre class="brush: js">var map1 = new Map();
+map1.set('bar', 'foo');
+
+console.log(map1.delete('bar'));
+// oczekiwany wynik: true
+// (true wskazuje na poprawne usunięcie)
+
+console.log(map1.has('bar'));
+// oczekiwany wynik: false
+</pre>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="brush: js">myMap.delete(key);</pre>
+
+<h3 id="Parametery">Parametery</h3>
+
+<dl>
+ <dt>key</dt>
+ <dd>Wymagany. Klucz elementu, który ma zostać usunięty z obiektu <code>Map</code>.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<dl>
+ <dt>Boolean</dt>
+ <dd>Zwraca <code>true</code>, jeśli element w <code>Map</code> istniał i został usunięty lub <code>false</code>, jeśli nie.</dd>
+</dl>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_metody_delete">Używanie metody <code>delete</code></h3>
+
+<pre class="brush: js">var myMap = new Map();
+myMap.set('bar', 'foo');
+
+myMap.delete('bar'); // Zwraca true. Udało się usunąć.
+myMap.has('bar');    // Zwraca false. Element "bar" już nie istnieje.
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.delete")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/entries/index.html b/files/pl/web/javascript/reference/global_objects/map/entries/index.html
new file mode 100644
index 0000000000..25589210ac
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/entries/index.html
@@ -0,0 +1,129 @@
+---
+title: Map.prototype.entries()
+slug: Web/JavaScript/Reference/Global_Objects/Map/entries
+tags:
+  - ECMAScript2015
+  - Iterator
+  - JavaScript
+  - Mapa
+  - Metodă
+  - Prototyp
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/entries
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/entries
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>entries()</strong></code> zwraca nowy obiekt typu <a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a> który zawiera pary<code>[klucz, wartość]</code> dla każdego elementu <code>Mapy</code>. Można się do nich odnieść w takiej kolejności, jakiej zostały wstawione.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-entries.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.entries()</code></pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Nowy iterator obiektu typu {{jsxref("Map")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_entries()">Używanie <code>entries()</code></h3>
+
+<pre class="brush:js">var myMap = new Map();
+myMap.set('0', 'foo');
+myMap.set(1, 'bar');
+myMap.set({}, 'baz');
+
+var mapIter = myMap.entries();
+
+console.log(mapIter.next().value); // ["0", "foo"]
+console.log(mapIter.next().value); // [1, "bar"]
+console.log(mapIter.next().value); // [Object, "baz"]
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Początkowa definicja.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{ CompatGeckoDesktop("20") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("20")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype.keys()")}}</li>
+ <li>{{jsxref("Map.prototype.values()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/foreach/index.html b/files/pl/web/javascript/reference/global_objects/map/foreach/index.html
new file mode 100644
index 0000000000..ec53470515
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/foreach/index.html
@@ -0,0 +1,105 @@
+---
+title: Map.prototype.forEach()
+slug: Web/JavaScript/Reference/Global_Objects/Map/forEach
+tags:
+  - ECMAScript2015
+  - JavaScript
+  - Mapa
+  - Metodă
+  - Prototyp
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/forEach
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/forEach
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>forEach()</strong></code> wykonuje dostarczoną funcję <code>callback</code> raz dla każdej pary klucz-wartosć <code>Mapy</code> w kolejności, w jakiej zostały zostały wstawione.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-foreach.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.forEach(<em>callback</em>[, <em>thisArg</em>])</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Funkcja wykonywana dla każdego elementu.</dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Wartość przypisywana do <code>this</code> poczas wywołania zwrotnego (funkcja <code>callback</code>).</dd>
+</dl>
+
+<h3 id="Zwracana_wartosć">Zwracana wartosć</h3>
+
+<p>{{jsxref("undefined")}}.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Metoda <code>forEach</code> wykonuje dostarczoną funkcję <code>callback</code> raz dla każdego klucza mapy, który istnieje. Nie jest wywoływana dla usuniętych kluczy, ale dla istniejących z wartością <code>undefined</code> już tak.</p>
+
+<p>Funkcja <code>callback</code> przyjmuje <strong>trzy argumenty</strong>:</p>
+
+<ul>
+ <li><strong>wartość elementu</strong></li>
+ <li><strong>klucz elementu</strong></li>
+ <li>obiekt typu <strong><code>Map</code> do przetworzenia</strong></li>
+</ul>
+
+<p>Jeśli argument <code>thisArg</code> jest dostarczony do <code>forEach</code>, zostaje przekazany do fukncji <code>callback</code> podczas jej wywołania, jako jej własna wartość <code>this</code>.  W przeciwnym wypadku, <code>this</code> przyjmuje wartość <code>undefined</code>. </p>
+
+<p>Każda wartość jest odwiedzana raz, oprócz przypadku, gdzie została usunięta, a następnie dodana ponownie, nim metoda <code>forEach</code> zakończyła swoje działanie. Funkcja <code>callback</code> nie jest wywoływana dla wartości usuniętych przed ich odwiedzeniem. Nowe wartości dodane jeszcze przed zakończeniem <code>forEach</code> zostaną odwiedzone.</p>
+
+<p>Metoda <code>forEach</code> nie zwraca żadnej wartości.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Wyświetlanie_zawartości_Mapy">Wyświetlanie zawartości <code>Mapy</code></h3>
+
+<p>Poniższy kod wyświetla jedną linię dla każdej pary klucz-wartość <code>Mapy</code>:</p>
+
+<pre class="brush:js">function logMapElements(value, key, map) {
+    console.log(`m[${key}] = ${value}`);
+}
+new Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(logMapElements);
+// logs:
+// "m[foo] = 3"
+// "m[bar] = [object Object]"
+// "m[baz] = undefined"
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.forEach")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Set.prototype.forEach()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/get/index.html b/files/pl/web/javascript/reference/global_objects/map/get/index.html
new file mode 100644
index 0000000000..b9b3da5da3
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/get/index.html
@@ -0,0 +1,81 @@
+---
+title: Map.prototype.get()
+slug: Web/JavaScript/Reference/Global_Objects/Map/get
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Mapa
+  - Metodă
+  - Prototyp
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/get
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/get
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>get()</strong></code> zwraca podany element <code>Mapy</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-get.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.get(key);</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt>key</dt>
+ <dd>Wymagany. Klucz elementu, który ma zostać zwrócony.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Element powiązany z danym kluczym lub <code>undefined</code>, jeśli klucz nie został odnaleziony.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_metody_get">Używanie metody <code>get</code></h3>
+
+<pre class="brush: js">var myMap = new Map();
+myMap.set('bar', 'foo');
+
+myMap.get('bar');  // zwraca "foo".
+myMap.get('baz');  // zwraca undefined.
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype.get', 'Map.prototype.get')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.get")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("Map.prototype.set()")}}</li>
+ <li>{{jsxref("Map.prototype.has()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/has/index.html b/files/pl/web/javascript/reference/global_objects/map/has/index.html
new file mode 100644
index 0000000000..3f9f330b4e
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/has/index.html
@@ -0,0 +1,86 @@
+---
+title: Map.prototype.has()
+slug: Web/JavaScript/Reference/Global_Objects/Map/has
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Mapa
+  - Metodă
+  - Prototyp
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/has
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/has
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>has()</strong></code> zwraca <a href="/pl/docs/Web/JavaScript/Referencje/Obiekty/Boolean">Boolean</a>, który określa czy element o podanym kluczu istnieje.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-has.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.has(key);</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt>key</dt>
+ <dd>Wymagany. Klucz elementu, którego istnienie w <code>Mapie</code> zostanie sprawdzone.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<dl>
+ <dt>Boolean</dt>
+ <dd>
+ <p><code>true</code>, jeśli dany element istnieje w <code>Mapie</code> - w przeciwnym wypadku <code>false</code>.</p>
+ </dd>
+</dl>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_metody_has">Używanie metody <code>has</code></h3>
+
+<pre class="brush: js">var myMap = new Map();
+myMap.set('bar', "foo");
+
+myMap.has('bar');  // zwraca true
+myMap.has('baz');  // zwraca false
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype.has', 'Map.prototype.has')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.has', 'Map.prototype.has')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.has")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("Map.prototype.set()")}}</li>
+ <li>{{jsxref("Map.prototype.get()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/index.html b/files/pl/web/javascript/reference/global_objects/map/index.html
new file mode 100644
index 0000000000..a72cd3dc26
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/index.html
@@ -0,0 +1,459 @@
+---
+title: Map
+slug: Web/JavaScript/Reference/Global_Objects/Map
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Map
+translation_of: Web/JavaScript/Reference/Global_Objects/Map
+original_slug: Web/JavaScript/Referencje/Obiekty/Map
+---
+<div>{{JSRef}}</div>
+
+<p><strong>Map </strong>jest prostym obiektem mapującym klucze na wartości. Każdy element (zarówno obiekt jak i {{Glossary("Primitive", "wartości proste")}}) mogą być użyte zarówno jako klucz jak i wartość.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate">new Map([iterable])</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>iterable</code></dt>
+ <dd>Iterable jest tablicą lub innym iterowalnym obiektem, którego elementy są parami typu klucz-wartość (np. 2 elementowa tablica). Każda para klucz-wartość jest dodawana do obiektu new Map. <code>null</code> jest traktowane jako <code>undefined.</code></dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Obiekt Map iteruje swoje elementy we wprowadzonej kolejności — pętla {{jsxref("Statements/for...of", "for...of")}} zwraca tablicę  <code>[key, value] </code>dla każdej iteracji.</p>
+
+<p>Należy pamiętać, że kolejność iteracji dla <code>Map</code> mapującej obiekty, w szczególności np. dla słownika słowników, odzwieciedlać będzie jedynie kolejność dodawania obiektów do kolekcji, natomiast kolejność dodawania elementów do samych obiektów nie jest gwarantowana i powinna być traktowana jako losowa.</p>
+
+<h3 id="Równość_kluczy">Równość kluczy</h3>
+
+<p>Klucze porównywane są według algorytmu "same-value" (tej samej wartości).</p>
+
+<p><code>NaN</code> jest traktowana jako równa <code>NaN</code> (mimo tego, że <code>NaN !== NaN</code>). Wszystkie inne wartości są uważane za równe zgodnie z semantyką <code>===</code>  operatora równości.</p>
+
+<p>W obecnej specyfikacji ECMAScript <code>-0 === +0</code>, choć wcześniejsze propozycje zakładały inne zachowanie, co zaowocowało implementacją w niektórych wersjach przeglądarek. Szczegóły zawarte są w  "Value equality for -0 and 0"  w tabeli <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Map$edit#Browser_compatibility">kompatybilności przeglądarek</a>.</p>
+
+<h3 id="Porównanie_Obiektów_i_Map">Porównanie Obiektów i Map</h3>
+
+<p>{{jsxref("Object", "Obiekty")}} są podobne do Map. W obu przypadkach pozwalają ustawić klucze dla wartości, zwracają te wartości, usuwają klucze i wykrywają czy coś jest przechowywane jako klucz. Z tego powodu (i ponieważ nie było innych wbudowanych alternatyw), <code>Object</code>  był używany wcześniej jako <code>Map</code>. Istnieją jednak ważne różnice pomiędzy <code>Obiektami</code> i <code>Mapami</code>, które powodują, że <code>Map</code> jest lepszym wyborem w pewnych przypadkach:</p>
+
+<ul>
+ <li>Klucze obiektu są {{jsxref("String", "Stringami")}}' i {{jsxref("Symbol", "Symbolami")}}, podczas gdy dla <code>Map</code> mogą być dowolną wartością, włączając w to funkcje, obiekty czy wartości proste.</li>
+ <li>Można łatwo pobrać wielkość mapy używając właściwości <code>size</code>, podczas gdy wielkość obiektu musi być określana ręcznie.</li>
+ <li>Po mapie można iterować bezpośrednio, iteracja po obiekcie wymaga pobrania jego kluczy i iteracji po ich liście.</li>
+ <li>Obiekt posiada prototyp, istnieją więc domyślne klucze, które mogą kolidować z Twoimi kluczami, jeśli nie jesteś ostrożny. Można ominąć ten problem używając <code>Object.create(null)</code> (dostępne od ES5), ale było to rzadko stosowane rozwiązanie.</li>
+ <li>Mapa może osiągnąć lepszą wydajność w scenariuszu, w którym często dodajemy i usuwamy pary klucz-wartość.</li>
+</ul>
+
+<p>Nie oznacza to, że powinno się używać <code>Maps</code> wszędzie. Obiekty są wciąż używane w większości przypadków.  Instancje <code>Map</code> są użyteczne dla kolekcji, warto rozważyć ich zaadaptowanie jedynie w przypadkach, gdy wcześniej używano dla nich obiektów. Obiekty powinny być używane jako rejestr z polami i metodami. Jeśli wciąż nie jesteś pewien czego użyć, pomocne mogą okazać się poniższe pytania:</p>
+
+<ul>
+ <li>Czy klucze są nieznane do momentu uruchomienia programu? Czy potrzebujesz wyszukiwać lub tworzyć je dynamicznie?</li>
+ <li>Czy wszystkie wartości mają ten sam typ? Czy mogą być użyte wymiennie?</li>
+ <li>Czy potrzebujesz kluczy, które nie są typu string?</li>
+ <li>Czy pary klucz-wartość są często dodawane lub usuwane?</li>
+ <li>Czy kolekcja powinna być iterowalna?</li>
+</ul>
+
+<p>Jeśli odpowiedziałeś 'tak' na którekolwiek z tych pytań, prawdopodobnie powinieneś użyć <code>Map</code>. I przeciwnie, jeśli masz zamknięty zbiór kluczy, jeśli musisz odwoływać się do poszczególnych, specyficznych kluczy a każdy z nich ma swoje, odrębne od innych znaczenie, najprawdopodobniej potrzebujesz obiektu.</p>
+
+<h2 id="Własności">Własności</h2>
+
+<dl>
+ <dt><code>Map.length</code></dt>
+ <dd>Wartość <code>length</code>  jest zawsze równa 0.</dd>
+ <dt>{{jsxref("Map.@@species", "get Map[@@species]")}}</dt>
+ <dd>Funkcja konstruktora używana do tworzenia obiektów pochodnych.</dd>
+ <dt>{{jsxref("Map.prototype")}}</dt>
+ <dd>Reprezentuje prototyp funkcji konstruktora <code>Map</code>. Pozwala rozszerzać prototyp wszystkich obiektów <code>Map</code> o własne własności.</dd>
+</dl>
+
+<h2 id="Instancje_Map">Instancje <code>Map</code></h2>
+
+<p>Wszystkie instancje <code>Map</code>  dziedziczą po {{jsxref("Map.prototype")}}.</p>
+
+<h3 id="Własności_2">Własności</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Map/prototype','Properties')}}</p>
+
+<h3 id="Metody">Metody</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Map/prototype','Methods')}}</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_obiektu_typu_Map">Używanie obiektu typu <code>Map</code></h3>
+
+<pre class="brush: js notranslate">var myMap = new Map();
+
+var keyString = 'a string',
+    keyObj = {},
+    keyFunc = function() {};
+
+// setting the values
+myMap.set(keyString, "value associated with 'a string'");
+myMap.set(keyObj, 'value associated with keyObj');
+myMap.set(keyFunc, 'value associated with keyFunc');
+
+myMap.size; // 3
+
+// getting the values
+myMap.get(keyString);    // "value associated with 'a string'"
+myMap.get(keyObj);       // "value associated with keyObj"
+myMap.get(keyFunc);      // "value associated with keyFunc"
+
+myMap.get('a string');   // "value associated with 'a string'"
+                         // because keyString === 'a string'
+myMap.get({});           // undefined, because keyObj !== {}
+myMap.get(function() {}) // undefined, because keyFunc !== function () {}
+</pre>
+
+<h3 id="Użycie_NaN_jako_kluczy_w_Map">Użycie <code>NaN</code> jako kluczy w  <code>Map</code></h3>
+
+<p><code>NaN</code> can also be used as a key. Even though every <code>NaN</code> is not equal to itself (<code>NaN !== NaN</code> is true), the following example works, because <code>NaN</code>s are indistinguishable from each other:</p>
+
+<pre class="brush: js notranslate">var myMap = new Map();
+myMap.set(NaN, 'not a number');
+
+myMap.get(NaN); // "not a number"
+
+var otherNaN = Number('foo');
+myMap.get(otherNaN); // "not a number"
+</pre>
+
+<h3 id="Iteracja_po_Map_przy_użyciu_for..of">Iteracja po <code>Map</code> przy użyciu <code>for..of</code></h3>
+
+<pre class="brush: js notranslate">var myMap = new Map();
+myMap.set(0, 'zero');
+myMap.set(1, 'one');
+for (var [key, value] of myMap) {
+  console.log(key + ' = ' + value);
+}
+// 0 = zero
+// 1 = one
+
+for (var key of myMap.keys()) {
+  console.log(key);
+}
+// 0
+// 1
+
+for (var value of myMap.values()) {
+  console.log(value);
+}
+// zero
+// one
+
+for (var [key, value] of myMap.entries()) {
+  console.log(key + ' = ' + value);
+}
+// 0 = zero
+// 1 = one
+</pre>
+
+<h3 id="Iteracja_po_Map_przy_użyciu_forEach">Iteracja po <code>Map</code> przy użyciu <code>forEach()</code></h3>
+
+<pre class="brush: js notranslate">myMap.forEach(function(value, key) {
+  console.log(key + ' = ' + value);
+});
+// Will show 2 logs; first with "0 = zero" and second with "1 = one"
+</pre>
+
+<h3 id="Relacja_do_obiektów_typu_Array">Relacja do obiektów typu <code>Array</code></h3>
+
+<pre class="brush: js notranslate">var kvArray = [['key1', 'value1'], ['key2', 'value2']];
+
+// Use the regular Map constructor to transform a 2D key-value Array into a map
+var myMap = new Map(kvArray);
+
+myMap.get('key1'); // returns "value1"
+
+// Use the spread operator to transform a map into a 2D key-value Array.
+console.log(uneval([...myMap])); // Will show you exactly the same Array as kvArray
+
+// Or use the spread operator on the keys or values iterator to get
+// an array of only the keys or values
+console.log(uneval([...myMap.keys()])); // Will show ["key1", "key2"]
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map-objects', 'Map')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Początkowa definicja</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map-objects', 'Map')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>
+    <p>{{ CompatChrome(38) }} [1]</p>
+   </td>
+   <td>12</td>
+   <td>{{ CompatGeckoDesktop("13") }}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new Map(iterable)</code></td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{ CompatGeckoDesktop("13") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+  <tr>
+   <td>iterable</td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{ CompatGeckoDesktop("17") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td><code>Map.clear()</code></td>
+   <td>{{ CompatChrome(31) }}<br>
+    {{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("19")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td><code>Map.keys(), Map.values(), Map.entries()</code></td>
+   <td>{{ CompatChrome(37) }}<br>
+    {{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("20")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td><code>Map.forEach()</code></td>
+   <td>{{ CompatChrome(36) }}<br>
+    {{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("25")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>Key equality for -0 and 0</td>
+   <td>{{ CompatChrome(34) }}<br>
+    {{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("29")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new Map(null)</code></td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("37")}}</td>
+   <td>11</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+  <tr>
+   <td>Monkey-patched <code>set()</code> in Constructor</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("37")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+  <tr>
+   <td><code>Map[@@species]</code></td>
+   <td>{{CompatChrome("51")}}</td>
+   <td>13</td>
+   <td>{{CompatGeckoDesktop("41")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("38")}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+  <tr>
+   <td><code>Map()</code> without <code>new</code> throws</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>12</td>
+   <td>{{ CompatGeckoDesktop("42") }}</td>
+   <td>11</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(38) }} [1]</td>
+   <td>{{ CompatGeckoMobile("13") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new Map(iterable)</code></td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>{{ CompatGeckoMobile("13") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td>iterable</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatGeckoMobile("17") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td><code>Map.clear()</code></td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(31) }}<br>
+    {{ CompatChrome(38) }}</td>
+   <td>{{CompatGeckoMobile("19")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td><code>Map.keys(), Map.values(), Map.entries()</code></td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(37) }}<br>
+    {{ CompatChrome(38) }}</td>
+   <td>{{CompatGeckoMobile("20")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td><code>Map.forEach()</code></td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(36) }}<br>
+    {{ CompatChrome(38) }}</td>
+   <td>{{CompatGeckoMobile("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td>Key equality for -0 and 0</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(34) }}<br>
+    {{ CompatChrome(38) }}</td>
+   <td>{{CompatGeckoMobile("29")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new Map(null)</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("37")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td>Monkey-patched <code>set()</code> in Constructor</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("37")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td><code>Map[@@species]</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("41")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>10</td>
+  </tr>
+  <tr>
+   <td><code>Map()</code> without <code>new</code> throws</td>
+   <td>5.1</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("42")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>9</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Starting with Chrome 31, the feature was available behind a preference. In <code>chrome://flags</code>, activate the entry “Enable Experimental JavaScript”.</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697479">Map and Set bug at Mozilla</a></li>
+ <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets">ECMAScript Harmony proposal</a></li>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("WeakMap")}}</li>
+ <li>{{jsxref("WeakSet")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/keys/index.html b/files/pl/web/javascript/reference/global_objects/map/keys/index.html
new file mode 100644
index 0000000000..6d018a6f9a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/keys/index.html
@@ -0,0 +1,79 @@
+---
+title: Map.prototype.keys()
+slug: Web/JavaScript/Reference/Global_Objects/Map/keys
+tags:
+  - ECMAScript 2015
+  - Iterator
+  - JavaScript
+  - Mapa
+  - Metodă
+  - Prototyp
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/keys
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/keys
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>keys()</strong></code> zwraca nowy obiekt typu <strong><a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong>, który zawiera klucze dla każdego elementu w <code>Mapie</code>. Można się do nich odnieść w takiej kolejności, jakiej zostały wstawione.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-keys.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.keys()</code></pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Nowy iterator obiektu typu {{jsxref("Map")}}</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_keys()">Używanie <code>keys()</code></h3>
+
+<pre class="brush:js">var myMap = new Map();
+myMap.set('0', 'foo');
+myMap.set(1, 'bar');
+myMap.set({}, 'baz');
+
+var mapIter = myMap.keys();
+
+console.log(mapIter.next().value); // "0"
+console.log(mapIter.next().value); // 1
+console.log(mapIter.next().value); // Object
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.keys")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype.entries()")}}</li>
+ <li>{{jsxref("Map.prototype.values()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/set/index.html b/files/pl/web/javascript/reference/global_objects/map/set/index.html
new file mode 100644
index 0000000000..96f3340090
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/set/index.html
@@ -0,0 +1,97 @@
+---
+title: Map.prototype.set()
+slug: Web/JavaScript/Reference/Global_Objects/Map/set
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Mapa
+  - Metodă
+  - Prototyp
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/set
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/set
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>set()</strong></code> dodaje lub zmienia element o podany <code>kluczu</code> i <code>wartości</code> w <code>Mapie</code>. </p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-set.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.set(key, value);</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt>key</dt>
+ <dd>Wymagany. Klucz elementu, który zostanie dodany do <code>Mapy</code>.</dd>
+ <dt>value</dt>
+ <dd>Wymagany. Wartość elementu, który zostanie dodany do <code>Mapy</code>.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p> Obiekt typu <code>Map</code>.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_set()">Używanie <code>set()</code></h3>
+
+<pre class="brush: js">var myMap = new Map();
+
+// Dodawanie nowych elementu
+myMap.set('bar', 'foo');
+myMap.set(1, 'foobar');
+
+// Zmiana istniejącego już elementu
+myMap.set('bar', 'baz');
+</pre>
+
+<h3 id="Używanie_set_w_połączeniu_z_łańcuchowaniem">Używanie <code>set</code> w połączeniu z łańcuchowaniem</h3>
+
+<p>Ponieważ <code>set()</code> zwraca ten sam obiekt typu <code>Mapa</code>, można użyć chainingu (uruchamianie metod jedna po drugiej na danym obiekcie przy użyciu kropek).</p>
+
+<pre class="brush: js">// Dodawanie elementów do mapy za pomocą chainingu
+myMap.set('bar', 'foo')
+     .set(1, 'foobar')
+     .set(2, 'baz');
+
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype.set', 'Map.prototype.set')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja początowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.set', 'Map.prototype.set')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.set")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("Map.prototype.get()")}}</li>
+ <li>{{jsxref("Map.prototype.has()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/size/index.html b/files/pl/web/javascript/reference/global_objects/map/size/index.html
new file mode 100644
index 0000000000..cd85fbb940
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/size/index.html
@@ -0,0 +1,66 @@
+---
+title: Map.prototype.size
+slug: Web/JavaScript/Reference/Global_Objects/Map/size
+tags:
+  - JavaScript
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/size
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/size
+---
+<div>{{JSRef}}</div>
+
+<p>Atrybut <code><strong>size</strong></code> zwraca ilość elementów znajdujących się w obiekcie {{jsxref("Map")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-size.html")}}</div>
+
+<p class="hidden">Żródło dla tego przykładu interaktywnego jest przechowywane w repozytorium w serwisie GitHub. Jeśli chciałbyś pomoć przy projekcie przykładów, prosimy o sklonowanie repozytorium <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wysłanie pull request.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Wartość <code>size</code> to liczba reprezentująca ile elementów posiada obiekt <code>Map</code>. Funkcja set dla <code>size</code> to <code>undefined</code>; nie można edytować tego atrybutu.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_size">Użycie <code>size</code></h3>
+
+<pre class="brush:js">var myMap = new Map();
+myMap.set('a', 'alpha');
+myMap.set('b', 'beta');
+myMap.set('g', 'gamma');
+
+myMap.size // 3
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność">Kompatybilność</h2>
+
+<div class="hidden">Tabela kompatybilności na tej stronie jest generowana z danych zewnętrznych. Jeśli chciałbyś pomóc przy tych danych, polecamy zajrzeć na <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> i wysłać pull request.</div>
+
+<p>{{Compat("javascript.builtins.Map.size")}}</p>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/map/values/index.html b/files/pl/web/javascript/reference/global_objects/map/values/index.html
new file mode 100644
index 0000000000..163f99de5d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/map/values/index.html
@@ -0,0 +1,78 @@
+---
+title: Map.prototype.values()
+slug: Web/JavaScript/Reference/Global_Objects/Map/values
+tags:
+  - ECMAScript 2015
+  - Iterator
+  - JavaScript
+  - Mapa
+  - Metodă
+  - Prototyp
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/values
+original_slug: Web/JavaScript/Referencje/Obiekty/Map/values
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>values()</strong></code> zwraca nowy obiekt typu <strong><a href="/pl/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong>, który zawiera wartości dla każdego elementu w <code>Mapie</code>. Można się do nich odnieść w takiej kolejności, jakiej zostały wstawione.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-values.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.values()</code></pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Nowy iterator obiektu typu {{jsxref("Map")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_values()">Używanie <code>values()</code></h3>
+
+<pre class="brush:js">var myMap = new Map();
+myMap.set('0', 'foo');
+myMap.set(1, 'bar');
+myMap.set({}, 'baz');
+
+var mapIter = myMap.values();
+
+console.log(mapIter.next().value); // "foo"
+console.log(mapIter.next().value); // "bar"
+console.log(mapIter.next().value); // "baz"</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype.values', 'Map.prototype.values')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.values', 'Map.prototype.values')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.values")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype.entries()")}}</li>
+ <li>{{jsxref("Map.prototype.keys()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/abs/index.html b/files/pl/web/javascript/reference/global_objects/math/abs/index.html
new file mode 100644
index 0000000000..7130c60e4d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/abs/index.html
@@ -0,0 +1,55 @@
+---
+title: Math.abs()
+slug: Web/JavaScript/Reference/Global_Objects/Math/abs
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/abs
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca wartość bezwzględną danej liczby.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>&gt;</mo><mn>0</mn></mtd></mtr><mtr><mtd><mi>0</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>=</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>&lt;</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x &amp; \text{if} \quad x \geq 0 \\ -x &amp; \text{if} \quad x &lt; 0 \end{cases} </annotation></semantics></math></p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.abs(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>abs</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.abs()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.abs" name="Przyk.C5.82ad:_Zastosowanie_Math.abs">Przykład: Zastosowanie <code>Math.abs()</code></h3>
+
+<p>Poniższa funkcja zwraca wartość bezwzględną zmiennej <code>x</code>:</p>
+
+<pre class="brush: js">Math.abs('-1'); // 1
+Math.abs(-2); // 2
+Math.abs(null); // 0
+Math.abs('string'); // NaN
+Math.abs(); // NaN
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.ceil()")}}</li>
+ <li>{{jsxref("Math.floor()")}}</li>
+ <li>{{jsxref("Math.round()")}}</li>
+ <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/acos/index.html b/files/pl/web/javascript/reference/global_objects/math/acos/index.html
new file mode 100644
index 0000000000..1a5631dbf5
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/acos/index.html
@@ -0,0 +1,60 @@
+---
+title: Math.acos()
+slug: Web/JavaScript/Reference/Global_Objects/Math/acos
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/acos
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca arcus cosinus (w radianach) danej liczby.</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x</annotation></semantics></math></p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.acos(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>acos</code> zwraca wartość numeryczną od 0 do pi dla <code>x</code> pomiędzy -1 a 1. Jeśli liczba <code>x</code> jest spoza przedziału [-1, 1], zwracany jest {{jsxref("NaN")}}.</p>
+
+<p>Ponieważ <code>acos</code> jest statyczną metodą obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.acos()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.acos" name="Przyk.C5.82ad:_Zastosowanie_Math.acos">Przykład: Zastosowanie <code>Math.acos()</code></h3>
+
+<p>Poniższa funkcja zwraca arcus cosinus zmiennej <code>x</code>:</p>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN
+</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 3.141592653589793
+</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment"> // 1.5707963267948966
+</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">0.5</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.0471975511965979
+</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment"> // 0
+</span>Math<span class="token punctuation">.</span><span class="token function">acos<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment"> // NaN</span></code></pre>
+
+<p>Jeśli do <code>getAcos</code> przekazana zostanie wartość -1, funkcja zwróci 3.141592653589793; jeśli przekazana zostanie wartość 2, zwrócony zostanie <code>NaN</code>, ponieważ 2 jest poza zakresem (tj. dziedziną funkcji arcus cosinus).</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/asin/index.html b/files/pl/web/javascript/reference/global_objects/math/asin/index.html
new file mode 100644
index 0000000000..bd7d955271
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/asin/index.html
@@ -0,0 +1,59 @@
+---
+title: Math.asin()
+slug: Web/JavaScript/Reference/Global_Objects/Math/asin
+tags:
+  - JavaScript
+  - Math
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/asin
+---
+<p>{{jsref}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca arcus sinus (w radianach) danej liczby.</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x</annotation></semantics></math></p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.asin(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>Math.asin()</code> zwraca wartość liczbową pomiędzy <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> i <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianów dla <code>x</code> z przedziału [-1, 1]. Jeśli <code>x</code> jest poza tym zakresem, zwracany jest <code>NaN</code>.</p>
+
+<p>Ponieważ <code>asin</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.asin()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.asin" name="Przyk.C5.82ad:_Zastosowanie_Math.asin">Przykład: Zastosowanie <code>Math.asin()</code></h3>
+
+<p>Poniższa funkcja zwraca arcus sinus zmiennej <code>x</code>:</p>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // NaN
+</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -1.5707963267948966 (-pi/2)
+</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment"> // 0
+</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">0.5</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.5235987755982989
+</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment"> // 1.570796326794897 (pi/2)
+</span>Math<span class="token punctuation">.</span><span class="token function">asin<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment"> // NaN</span></code></pre>
+
+<p>Jeśli do funkcji <code>getAsin</code> przekazana zostanie wartość 1, funkcja ta zwróci 1.570796326794897 (pi/2); jeśli przekazana zostanie wartość 2, funkcja zwróci {{jsxref("<code>NaN</code>")}}, ponieważ 2 jest poza dziedziną funkcji arcus sinus.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/atan/index.html b/files/pl/web/javascript/reference/global_objects/math/atan/index.html
new file mode 100644
index 0000000000..06fa2229fe
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/atan/index.html
@@ -0,0 +1,52 @@
+---
+title: Math.atan()
+slug: Web/JavaScript/Reference/Global_Objects/Math/atan
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/atan
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca arcus tangens (w radianach) danej liczby.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x</annotation></semantics></math></p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.atan(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>atan</code> zwraca wartość liczbową pomiędzy <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> i <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianów.</p>
+
+<p>Ponieważ <code>atan</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.atan()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.atan" name="Przyk.C5.82ad:_Zastosowanie_Math.atan">Przykład: Zastosowanie <code>Math.atan()</code></h3>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">atan<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0.7853981633974483
+</span>Math<span class="token punctuation">.</span><span class="token function">atan<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/atan2/index.html b/files/pl/web/javascript/reference/global_objects/math/atan2/index.html
new file mode 100644
index 0000000000..e8cc44766c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/atan2/index.html
@@ -0,0 +1,64 @@
+---
+title: Math.atan2()
+slug: Web/JavaScript/Reference/Global_Objects/Math/atan2
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/atan2
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca kąta (w radianach) utworzony przez oś OX i prostą przechodzącą przez punkt o podanych współrzędnych.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.atan2(<var>y</var>, <var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>y, x</code> </dt>
+ <dd>liczby.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>atan2</code> zwraca wartość liczbową pomiędzy -π a π, reprezentującą kąt theta punktu <code>(x, y)</code>. Kąt ten, mierzony w radianach, został utworzony przez dodatnią oś OX i punkt <code>(x,y)</code>, z obrotem w kierunku przeciwnym do ruchu wskazówek zegara. Należy zwrócić uwagę na to, że pierwszym argumentem tej funkcji jest współrzędna y, a x jest argumentem drugim.</p>
+
+<p>Do metody Math.<code>atan2</code>() przekazywane są osobno argumenty <code>x</code> i <code>y</code>, podczas gdy do metody <code>atan</code> przekazywany jest stosunek tych dwóch wartości.</p>
+
+<p>Ponieważ <code>atan2()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.atan2()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.atan2" name="Przyk.C5.82ad:_Zastosowanie_Math.atan2">Przykład: Zastosowanie <code>Math.atan2()</code></h3>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span><span class="token number">90</span><span class="token punctuation">,</span> <span class="token number">15</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.4056476493802699
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span><span class="token number">15</span><span class="token punctuation">,</span> <span class="token number">90</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.16514867741462683
+</span>
+Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span>              <span class="token comment"> // ±PI.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> <span class="token operator">+</span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span>              <span class="token comment"> // ±0.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> <span class="token operator">-</span>x<span class="token punctuation">)</span><span class="token punctuation">;</span>              <span class="token comment"> // ±PI for x &gt; 0.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">0</span><span class="token punctuation">,</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>               <span class="token comment"> // ±0 for x &gt; 0.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span><span class="token operator">-</span>y<span class="token punctuation">,</span> ±<span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span>              <span class="token comment"> // -PI/2 for y &gt; 0.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>y<span class="token punctuation">,</span> ±<span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span>               <span class="token comment"> // PI/2 for y &gt; 0.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±y<span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span>       <span class="token comment"> // ±PI for finite y &gt; 0.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±y<span class="token punctuation">,</span> <span class="token operator">+</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span>       <span class="token comment"> // ±0 for finite y &gt; 0.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">Infinity</span><span class="token punctuation">,</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>        <span class="token comment"> // ±PI/2 for finite x.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">Infinity</span><span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // ±3*PI/4.
+</span>Math<span class="token punctuation">.</span><span class="token function">atan2<span class="token punctuation">(</span></span>±<span class="token number">Infinity</span><span class="token punctuation">,</span> <span class="token operator">+</span><span class="token number">Infinity</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // ±PI/4.</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/ceil/index.html b/files/pl/web/javascript/reference/global_objects/math/ceil/index.html
new file mode 100644
index 0000000000..a46dbd3069
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/ceil/index.html
@@ -0,0 +1,50 @@
+---
+title: Math.ceil()
+slug: Web/JavaScript/Reference/Global_Objects/Math/ceil
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/ceil
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca najmniejszą liczbę całkowitą większą od lub równą danej.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.ceil(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>ceil</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.ceil()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3>
+
+<h4 id="Przyk.C5.82ad:_Zastosowanie_Math.ceil" name="Przyk.C5.82ad:_Zastosowanie_Math.ceil">Przykład: Zastosowanie <code>Math.ceil()</code></h4>
+
+<p>Poniższa funkcja zwraca wartość metody ceil dla zmiennej <code>x</code>:</p>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">ceil<span class="token punctuation">(</span></span><span class="token punctuation">.</span><span class="token number">95</span><span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment"> // 1
+</span>Math<span class="token punctuation">.</span><span class="token function">ceil<span class="token punctuation">(</span></span><span class="token number">4</span><span class="token punctuation">)</span><span class="token punctuation">;</span>    <span class="token comment"> // 4
+</span>Math<span class="token punctuation">.</span><span class="token function">ceil<span class="token punctuation">(</span></span><span class="token number">7.004</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 8</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.abs()")}}</li>
+ <li>{{jsxref("Math.floor()")}}</li>
+ <li>{{jsxref("Math.round()")}}</li>
+ <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/cos/index.html b/files/pl/web/javascript/reference/global_objects/math/cos/index.html
new file mode 100644
index 0000000000..cb0c692240
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/cos/index.html
@@ -0,0 +1,53 @@
+---
+title: Math.cos()
+slug: Web/JavaScript/Reference/Global_Objects/Math/cos
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/cos
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca cosinus danej liczby.</p>
+
+<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3>
+
+<pre class="syntaxbox"><code>Math.cos(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>cos</code> zwraca wartość liczbową pomiędzy -1 a 1, która reprezentuje cosinus kąta.</p>
+
+<p>Ponieważ <code>cos()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.cos()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.cos" name="Przyk.C5.82ad:_Zastosowanie_Math.cos">Przykład: Zastosowanie <code>Math.cos()</code></h3>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span>          <span class="token comment"> // 1
+</span>Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span>          <span class="token comment"> // 0.5403023058681398
+</span>
+Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span>Math<span class="token punctuation">.</span>PI<span class="token punctuation">)</span><span class="token punctuation">;</span>    <span class="token comment"> // -1
+</span>Math<span class="token punctuation">.</span><span class="token function">cos<span class="token punctuation">(</span></span><span class="token number">2</span> <span class="token operator">*</span> Math<span class="token punctuation">.</span>PI<span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/e/index.html b/files/pl/web/javascript/reference/global_objects/math/e/index.html
new file mode 100644
index 0000000000..718bb943fd
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/e/index.html
@@ -0,0 +1,41 @@
+---
+title: Math.E
+slug: Web/JavaScript/Reference/Global_Objects/Math/E
+tags:
+  - JavaScript
+  - Math
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/E
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/E
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Stała Eulera stanowiąca podstawę logarytmów naturalnych, w przybliżeniu 2.718.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2.718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2.718</annotation></semantics></math></p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>E</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.E</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_E" name="Przyk.C5.82ad:_Zastosowanie_E">Przykład: Zastosowanie <code>Math.E</code></h3>
+
+<p>Poniższa funkcja zwraca e:</p>
+
+<pre class="brush: js  language-js">function getNapier() {
+   return Math.E;
+}
+
+<code class="language-js"><span class="token function">getNapier<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 2.718281828459045</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/exp/index.html b/files/pl/web/javascript/reference/global_objects/math/exp/index.html
new file mode 100644
index 0000000000..64ac1e7d0d
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/exp/index.html
@@ -0,0 +1,50 @@
+---
+title: Math.exp()
+slug: Web/JavaScript/Reference/Global_Objects/Math/exp
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/exp
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca e<sup>x</sup>, gdzie <code>x</code> to argument, a e to {{jsxref("Math.E", "stała Eulera", "", 1)}}, podstawa logarytmu naturalnego.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.exp(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>exp</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.exp()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.exp" name="Przyk.C5.82ad:_Zastosowanie_Math.exp">Przykład: Zastosowanie <code>Math.exp()</code></h3>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">exp<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.36787944117144233
+</span>Math<span class="token punctuation">.</span><span class="token function">exp<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1
+</span>Math<span class="token punctuation">.</span><span class="token function">exp<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 2.718281828459045</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.E")}}</li>
+ <li>{{jsxref("Math.expm1()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/floor/index.html b/files/pl/web/javascript/reference/global_objects/math/floor/index.html
new file mode 100644
index 0000000000..7ae1710c3c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/floor/index.html
@@ -0,0 +1,47 @@
+---
+title: Math.floor()
+slug: Web/JavaScript/Reference/Global_Objects/Math/floor
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/floor
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca największą liczbę całkowitą mniejszą od lub równą danej.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.floor(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>floor</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.floor()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.floor" name="Przyk.C5.82ad:_Zastosowanie_Math.floor">Przykład: Zastosowanie <code>Math.floor()</code></h3>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">floor<span class="token punctuation">(</span></span> <span class="token number">45.95</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> //  45
+</span>Math<span class="token punctuation">.</span><span class="token function">floor<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">45.95</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // -46</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.abs()")}}</li>
+ <li>{{jsxref("Math.ceil()")}}</li>
+ <li>{{jsxref("Math.round()")}}</li>
+ <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/index.html b/files/pl/web/javascript/reference/global_objects/math/index.html
new file mode 100644
index 0000000000..5fb44f3d1c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/index.html
@@ -0,0 +1,95 @@
+---
+title: Math
+slug: Web/JavaScript/Reference/Global_Objects/Math
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/Math
+original_slug: Web/JavaScript/Referencje/Obiekty/Math
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wbudowany obiekt zawierający własności i metody związane z funkcjami i stałymi matematycznymi. Na przykład własność {{jsxref("Math.PI", "PI")}} obiektu <code>Math</code> zawiera wartość liczby pi.</p>
+
+<h2 id="Tworzony_przez" name="Tworzony_przez">Tworzony przez</h2>
+
+<p>Obiekt <code>Math</code> w języku JavaScript jest predefiniowanym obiektem najwyższego poziomu. Można z niego korzystać od razu, bez korzystania z konstruktora lub wywoływania tworzącej metody.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wszystkie własności i metody obiektu <code>Math</code> są statyczne. Do stałej pi odwołujemy się poprzez <code>Math.PI</code>, a funkcję sinus wywołujemy jako <code>Math.sin(x)</code>, gdzie <code>x</code> jest argumentem metody. Stałe zdefiniowane są z pełną precyzją liczb rzeczywistych JavaScriptu.</p>
+
+<p>Czasami wygodniej jest skorzystać z polecenia {{jsxref("with")}}, kiedy w pewnym fragmencie kodu wykonywane jest wiele obliczeń korzystających z metod i stałych obiektu <code>Math</code>. Unika się wtedy wielokrotnego wpisywania "Math". Na przykład:</p>
+
+<pre class="brush: js">with (Math) {
+   a = PI * r*r;
+   y = r*sin(theta);
+   x = r*cos(theta);
+}
+</pre>
+
+<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2>
+
+<dl>
+ <dt>{{jsxref("Math.E")}}</dt>
+ <dd>stała Eulera, podstawa logarytmu naturalnego, w przybliżeniu 2.718.</dd>
+ <dt>{{jsxref("Math.LN2")}}</dt>
+ <dd>logarytm naturalny liczby 2, w przybliżeniu 0.693.</dd>
+ <dt>{{jsxref("Math.LN10")}}</dt>
+ <dd>logarytm naturalny liczby 10, w przybliżeniu 2.302.</dd>
+ <dt>{{jsxref("Math.LOG2E")}}</dt>
+ <dd>logarytm o podstawie 2 z liczby E, w przybliżeniu 1.442.</dd>
+ <dt>{{jsxref("Math.LOG10E")}}</dt>
+ <dd>logarytm o podstawie 10 z liczby E, w przybliżeniu 0.434.</dd>
+ <dt>{{jsxref("Math.PI")}}</dt>
+ <dd>stosunek obwodu okręgu do jego średnicy, w przybliżeniu 3.14159.</dd>
+ <dt>{{jsxref("Math.SQRT1_2")}}</dt>
+ <dd>pierwiastek kwadratowy z liczby 1/2, albo, inaczej mówiąc, odwrotność pierwiastka kwadratowego z liczby 2, w przybliżeniu 0.707.</dd>
+ <dt>{{jsxref("Math.SQRT2")}}</dt>
+ <dd>pierwiastek kwadratowy z liczby 2, w przybliżeniu 1.414.</dd>
+</dl>
+
+<h2 id="Metody" name="Metody">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("Math.abs()")}}</dt>
+ <dd>zwraca wartość bezwzględną danej liczby.</dd>
+ <dt>{{jsxref("Math.acos()")}}</dt>
+ <dd>zwraca arcus cosinus (w radianach) danej liczby.</dd>
+ <dt>{{jsxref("Math.asin()")}}</dt>
+ <dd>zwraca arcus sinus (w radianach) danej liczby.</dd>
+ <dt>{{jsxref("Math.atan()")}}</dt>
+ <dd>zwraca arcus tangens (w radianach) danej liczby.</dd>
+ <dt>{{jsxref("Math.atan2()")}}</dt>
+ <dd>zwraca kąt (w radianach) utworzony przez oś OX i prostą przechodzącą przez punkt o podanych współrzędnych.</dd>
+ <dt>{{jsxref("Math.ceil()")}}</dt>
+ <dd>zwraca najmniejszą liczbę całkowitą większą od lub równą danej.</dd>
+ <dt>{{jsxref("Math.cos()")}}</dt>
+ <dd>zwraca cosinus danej liczby.</dd>
+ <dt>{{jsxref("Math.exp()")}}</dt>
+ <dd>zwraca <code>E<sup>x</sup></code>, gdzie <code>x</code> to argument, a <code>E</code> to stała Eulera.</dd>
+ <dt>{{jsxref("Math.floor()")}}</dt>
+ <dd>zwraca największą liczbę całkowitą mniejszą od lub równą danej.</dd>
+ <dt>{{jsxref("Math.log()")}}</dt>
+ <dd>zwraca logarytm naturalny (tj. o podstawie E) z danej liczby.</dd>
+ <dt>{{jsxref("Math.max()")}}</dt>
+ <dd>zwraca większą z dwóch liczb.</dd>
+ <dt>{{jsxref("Math.min()")}}</dt>
+ <dd>zwraca mniejszą z dwóch liczb.</dd>
+ <dt>{{jsxref("Math.pow()")}}</dt>
+ <dd>zwraca daną liczbę podniesioną do danej potęgi.</dd>
+ <dt>{{jsxref("Math.random()")}}</dt>
+ <dd>zwraca liczbą pseudolosową z przedziału [0, 1).</dd>
+ <dt>{{jsxref("Math.round()")}}</dt>
+ <dd>zwraca daną liczbę zaokrągloną do najbliższej liczby całkowitej.</dd>
+ <dt>{{jsxref("Math.sin()")}}</dt>
+ <dd>zwraca sinus danej liczby.</dd>
+ <dt>{{jsxref("Math.sqrt()")}}</dt>
+ <dd>zwraca pierwiastek kwadratowy danej liczby.</dd>
+ <dt>{{jsxref("Math.tan()")}}</dt>
+ <dd>zwraca tangens danej liczby.</dd>
+</dl>
diff --git a/files/pl/web/javascript/reference/global_objects/math/ln10/index.html b/files/pl/web/javascript/reference/global_objects/math/ln10/index.html
new file mode 100644
index 0000000000..a7123ea09a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/ln10/index.html
@@ -0,0 +1,43 @@
+---
+title: Math.LN10
+slug: Web/JavaScript/Reference/Global_Objects/Math/LN10
+tags:
+  - JavaScript
+  - Math
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/LN10
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Logarytm naturalny liczby 10, w przybliżeniu 2.302.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2.302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>LN10</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.LN10</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_LN10" name="Przyk.C5.82ad:_Zastosowanie_LN10">Przykład: Zastosowanie <code>Math.LN10</code></h3>
+
+<p>Poniższa funkcja zwraca logarytm naturalny liczby 10:</p>
+
+<pre class="brush:js  language-js">function getNatLog10() {
+   return Math.LN10;
+}
+
+getNatLog10(); <code class="language-js"><span class="token comment">// 2.302585092994046</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/ln2/index.html b/files/pl/web/javascript/reference/global_objects/math/ln2/index.html
new file mode 100644
index 0000000000..58d20c3e2c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/ln2/index.html
@@ -0,0 +1,41 @@
+---
+title: Math.LN2
+slug: Web/JavaScript/Reference/Global_Objects/Math/LN2
+tags:
+  - JavaScript
+  - Math
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/LN2
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Logarytm naturalny liczby 2, w przybliżeniu 0.693</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0.693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693</annotation></semantics></math></p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>LN2</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.LN2</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_LN2" name="Przyk.C5.82ad:_Zastosowanie_LN2">Przykład: Zastosowanie <code>Math.LN2</code></h3>
+
+<p>Poniższa funkcja zwraca logarytm naturalny liczby 2:</p>
+
+<pre class="brush:js  language-js">function getNatLog2() {
+   return Math.LN2;
+}
+
+getNatLog2(); <code class="language-js"><span class="token comment">// 0.6931471805599453</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/log/index.html b/files/pl/web/javascript/reference/global_objects/math/log/index.html
new file mode 100644
index 0000000000..a037a745d4
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/log/index.html
@@ -0,0 +1,55 @@
+---
+title: Math.log()
+slug: Web/JavaScript/Reference/Global_Objects/Math/log
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/log
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/log
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca logarytm naturalny (o podstawie {{jsxref("Math.E", "e")}}) z danej liczby.</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x &gt; 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math></p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.log(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli wartość liczby <code>x</code> jest ujemna, zwracaną wartością jest zawsze {{jsxref("NaN")}}.</p>
+
+<p>Ponieważ <code>log()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.log()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.log" name="Przyk.C5.82ad:_Zastosowanie_Math.log">Przykład: Zastosowanie <code>Math.log()</code></h3>
+
+<p> </p>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // NaN, out of range
+</span>Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // -Infinity
+</span>Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0
+</span>Math<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token number">10</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 2.302585092994046</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/log10e/index.html b/files/pl/web/javascript/reference/global_objects/math/log10e/index.html
new file mode 100644
index 0000000000..19872df5f6
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/log10e/index.html
@@ -0,0 +1,45 @@
+---
+title: Math.LOG10E
+slug: Web/JavaScript/Reference/Global_Objects/Math/LOG10E
+tags:
+  - JavaScript
+  - Math
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/LOG10E
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Logarytm o podstawie 10 z E, w przybliżeniu 0.434.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0.434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="sect1"> </h2>
+
+<h3 id="Opis" name="Opis">Opis</h3>
+
+<p>Ponieważ <code>LOG10E</code> jest statyczną własnością obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.LOG10E</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_LOG10E" name="Przyk.C5.82ad:_Zastosowanie_LOG10E">Przykład: Zastosowanie <code>Math.LOG10E</code></h3>
+
+<p>Poniższa funkcja zwraca logarytm o podstawie 10 z E:</p>
+
+<pre class="brush:js  language-js">function getLog10e() {
+   return Math.LOG10E;
+}
+
+getLog10e();<code class="language-js"><span class="token comment"> // 0.4342944819032518</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/log2e/index.html b/files/pl/web/javascript/reference/global_objects/math/log2e/index.html
new file mode 100644
index 0000000000..aca585cea3
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/log2e/index.html
@@ -0,0 +1,43 @@
+---
+title: Math.LOG2E
+slug: Web/JavaScript/Reference/Global_Objects/Math/LOG2E
+tags:
+  - JavaScript
+  - Math
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/LOG2E
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Logarytm o podstawie 2 z E, w przybliżeniu 1.442.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1.442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>LOG2E</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.LOG2E</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_LOG2E" name="Przyk.C5.82ad:_Zastosowanie_LOG2E">Przykład: Zastosowanie <code>Math.LOG2E</code></h3>
+
+<p>Poniższa funkcja zwraca logarytm o podstawie 2 z E:</p>
+
+<pre class="brush: js  language-js">function getLog2e() {
+   return Math.LOG2E;
+}
+
+getLog2e(); <code class="language-js"><span class="token comment">// 1.4426950408889634</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/max/index.html b/files/pl/web/javascript/reference/global_objects/math/max/index.html
new file mode 100644
index 0000000000..ef23c6a7d8
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/max/index.html
@@ -0,0 +1,44 @@
+---
+title: Math.max()
+slug: Web/JavaScript/Reference/Global_Objects/Math/max
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/max
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/max
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca największą z podanych liczb.</p>
+
+<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3>
+
+<pre class="syntaxbox"><code>Math.max([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>value1, value2, ...</code></dt>
+ <dd>liczby.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>max</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez Math.max(), a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.max" name="Przyk.C5.82ad:_Zastosowanie_Math.max">Przykład: Zastosowanie <code>Math.max()</code></h3>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="punctuation token">.</span><span class="function token">max<span class="punctuation token">(</span></span><span class="number token">10</span><span class="punctuation token">,</span> <span class="number token">20</span><span class="punctuation token">)</span><span class="punctuation token">;</span>  <span class="comment token"> //  20
+</span>Math<span class="punctuation token">.</span><span class="function token">max<span class="punctuation token">(</span></span><span class="operator token">-</span><span class="number token">10</span><span class="punctuation token">,</span> <span class="operator token">-</span><span class="number token">20</span><span class="punctuation token">)</span><span class="punctuation token">;</span><span class="comment token"> // -10
+</span>Math<span class="punctuation token">.</span><span class="function token">max<span class="punctuation token">(</span></span><span class="operator token">-</span><span class="number token">10</span><span class="punctuation token">,</span> <span class="number token">20</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token"> //  20</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.min()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/min/index.html b/files/pl/web/javascript/reference/global_objects/math/min/index.html
new file mode 100644
index 0000000000..2994b7e363
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/min/index.html
@@ -0,0 +1,45 @@
+---
+title: Math.min()
+slug: Web/JavaScript/Reference/Global_Objects/Math/min
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/min
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/min
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca najmniejszą z podanych liczb.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.min([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>value1, value2, ...</code></dt>
+ <dd>liczby.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Ponieważ <code>min</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.min()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Przykład_Zastosowanie_Math.min()">Przykład: Zastosowanie <code>Math.min()</code></h3>
+
+<p>Poniższa funkcja porównuje zmienne <code>x</code> and <code>y</code> i zwraca mniejszą <code>z</code> nich:</p>
+
+<pre class="brush: js  language-js"><code class="language-js">var x = 10, y = -20;
+var z = Math.min(x, y);</code></pre>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.max()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/pi/index.html b/files/pl/web/javascript/reference/global_objects/math/pi/index.html
new file mode 100644
index 0000000000..f4c7c2c91e
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/pi/index.html
@@ -0,0 +1,41 @@
+---
+title: Math.PI
+slug: Web/JavaScript/Reference/Global_Objects/Math/PI
+tags:
+  - JavaScript
+  - Math
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/PI
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Stosunek obwodu okręgu do jego średnicy, w przybliżeniu 3.14159.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3.14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3.14159</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>PI</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.PI</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h4 id="Przyk.C5.82ad:_Zastosowanie_PI" name="Przyk.C5.82ad:_Zastosowanie_PI">Przykład: Zastosowanie <code>Math.PI</code></h4>
+
+<p>Poniższa funkcja zwraca wartość pi:</p>
+
+<pre class="brush: js  language-js">function getPi() {
+   return Math.PI;
+}
+
+<code class="language-js"><span class="token function">calculateCircumference<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 6.283185307179586</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Math", "Math")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/pow/index.html b/files/pl/web/javascript/reference/global_objects/math/pow/index.html
new file mode 100644
index 0000000000..82b449f8d2
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/pow/index.html
@@ -0,0 +1,50 @@
+---
+title: Math.pow()
+slug: Web/JavaScript/Reference/Global_Objects/Math/pow
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/pow
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca liczbę <code>podstawa</code> podniesioną do potęgi o wykładniku <code>wykładnik</code>, tj. <code>podstawa<sup>wykładnik</sup></code>.</p>
+
+<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3>
+
+<pre class="syntaxbox"><code>Math.pow(podstawa, wykładnik)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>podstawa</code> </dt>
+ <dd>liczba podnoszona do potęgi.</dd>
+</dl>
+
+<dl>
+ <dt><code>wykładnik</code> </dt>
+ <dd>wykładnik potęgi, do której podnoszona jest liczba <code>podstawa</code>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>pow</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.pow()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.pow" name="Przyk.C5.82ad:_Zastosowanie_Math.pow">Przykład: Zastosowanie <code>Math.pow()</code></h3>
+
+<pre class="brush: js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">pow<span class="token punctuation">(</span></span><span class="token number">7</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 49</span></code></pre>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.cbrt()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.sqrt()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/random/index.html b/files/pl/web/javascript/reference/global_objects/math/random/index.html
new file mode 100644
index 0000000000..fd68b5ea29
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/random/index.html
@@ -0,0 +1,68 @@
+---
+title: Math.random()
+slug: Web/JavaScript/Reference/Global_Objects/Math/random
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/random
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca pseudolosową, zmiennoprzecinkową liczbę z przedziału <code>[0, 1)</code> ( jedynka nie należy do przedziału). Podstawą generatora liczb losowych (ang.<em> seed</em> ) jest aktualny czas, tak samo jak w języku Java. Ponieważ <code>random</code> jest statyczną metodą obiektu <code>Math</code>, zawsze odwołujemy się do niej poprzez <code>Math.random()</code>, a nie jak do metody instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<div class="note">
+<p><strong>Notatka:</strong> <code>Math.random()</code> <strong>nie zapewnia</strong><span class="tlid-translation translation"><span title=""> kryptograficznie bezpiecznych liczb losowych.</span></span> <span class="tlid-translation translation"><span title="">Nie używaj ich do niczego związanego z bezpieczeństwem (np. generowanie haseł).</span></span> <span class="tlid-translation translation"><span title="">Zamiast tego użyj Web Crypto API, a dokładniej:</span></span> metodę {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.</p>
+</div>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.random()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h3 id="Wartość_zwracana">Wartość zwracana</h3>
+
+<p><span class="tlid-translation translation"><span title="">Liczba pseudolosowa, zmiennoprzecinkowa zawarta w przedziale <code>[0, 1)</code> (od 0 (włącznie) do 1 (wykluczając 1)).</span></span></p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad_Zastosowanie_Math.random" name="Przyk.C5.82ad:_Zastosowanie_Math.random">Zastosowanie <code>Math.random()</code></h3>
+
+<p>Zwraca losową liczbę większą lub równą 0 i mniejszą od 1.</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">function</span> getRandom<span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="punctuation token">}</span></code></pre>
+
+<h3 id="Uzyskanie_losowej_liczby_między_dwiema_wartościami"><span class="tlid-translation translation"><span title="">Uzyskanie losowej liczby między dwiema wartościami</span></span></h3>
+
+<p><span class="tlid-translation translation"><span title="">Ten przykład zwraca losową liczbę znajdującą się pomiędzy określonymi wartościami.</span> <span title="">Zwrócona wartość jest większa lub równa <code>min</code>, i jest mniejsza niż <code>max</code>.</span></span></p>
+
+<pre><code class="language-js"><span class="keyword token">function</span> <span class="function token">getRandomInt</span><span class="punctuation token">(</span>min<span class="punctuation token">,</span> max<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  min <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">ceil</span><span class="punctuation token">(</span>min<span class="punctuation token">)</span><span class="punctuation token">;</span>
+  max <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>max<span class="punctuation token">)</span><span class="punctuation token">;</span>
+  <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">*</span> <span class="punctuation token">(</span>max <span class="operator token">-</span> min<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">+</span> min<span class="punctuation token">;</span>
+<span class="punctuation token">}</span></code>
+</pre>
+
+<h3 id="Uzyskanie_losowej_liczby_między_dwiema_wartościami_z_przedziału_min_max_max_włącznie"><span class="tlid-translation translation"><span title="">Uzyskanie losowej liczby między dwiema wartościami z przedziału <code>[min, max]</code> (<code>max</code> włącznie)</span></span></h3>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">getRandomIntInclusive</span><span class="punctuation token">(</span>min<span class="punctuation token">,</span> max<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  min <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">ceil</span><span class="punctuation token">(</span>min<span class="punctuation token">)</span><span class="punctuation token">;</span>
+  max <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>max<span class="punctuation token">)</span><span class="punctuation token">;</span>
+  <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">*</span> <span class="punctuation token">(</span>max <span class="operator token">-</span> min <span class="operator token">+</span> <span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">+</span> min<span class="punctuation token">;</span>
+<span class="punctuation token">}</span></code></pre>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div class="hidden">
+<p><span class="tlid-translation translation"><span title="">Tabela zgodności na tej stronie jest generowana na podstawie danych strukturalnych.</span> <span title="">Jeśli chcesz przyczynić się do danych, sprawdź <a href="/pl/docs/">https://github.com/mdn/browser-compat-data</a> i wyślij nam pull request'a.</span></span></p>
+</div>
+
+<p>{{Compat("javascript.builtins.Math.random")}}</p>
diff --git a/files/pl/web/javascript/reference/global_objects/math/round/index.html b/files/pl/web/javascript/reference/global_objects/math/round/index.html
new file mode 100644
index 0000000000..01aabb9aa1
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/round/index.html
@@ -0,0 +1,51 @@
+---
+title: Math.round()
+slug: Web/JavaScript/Reference/Global_Objects/Math/round
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/round
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/round
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca daną liczbę zaokrągloną do najbliższej liczby całkowitej.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.round(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli część ułamkowa liczby <code>x</code> wynosi 0.5 lub więcej, argument jest zaokrąglany do najbliższej większej liczby całkowitej. Jeśli część ułamkowa liczby <code>x</code> jest mniejsza niż 0.5, argument jest zaokrąglany do najbliższej mniejszej liczby całkowitej.</p>
+
+<p>Ponieważ <code>round</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.round()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.round" name="Przyk.C5.82ad:_Zastosowanie_Math.round">Przykład: Zastosowanie <code>Math.round()</code></h3>
+
+<pre class="brush: js">// zwraca 20
+x = Math.round(20.49)
+
+// zwraca 21
+x = Math.round(20.5)
+
+// zwraca -20
+x = Math.round(-20.5)
+
+// zwraca -21
+x = Math.round(-20.51)
+</pre>
+
+<p> </p>
diff --git a/files/pl/web/javascript/reference/global_objects/math/sign/index.html b/files/pl/web/javascript/reference/global_objects/math/sign/index.html
new file mode 100644
index 0000000000..bd919f950a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/sign/index.html
@@ -0,0 +1,119 @@
+---
+title: Math.sign()
+slug: Web/JavaScript/Reference/Global_Objects/Math/sign
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/sign
+---
+<div>{{JSRef("Global_Objects", "Math")}}</div>
+
+<h2 id="Summary" name="Summary">Podsumowanie</h2>
+
+<p>Funkcja<strong style="font-weight: bold;"> </strong><code><strong>Math.sign() </strong></code>zwraca znak liczby. Wynik wskazuje czy liczba przekazana jako argument jest dodatnia, ujemna lub czy jest zerem.</p>
+
+<h2 id="Syntax" name="Syntax">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.sign(<em>x</em>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parametry</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Liczba, której znak ma zostać określony.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Opis</h2>
+
+<p>Metoda <code>sign</code> powinna być zawsze używana jako <code>Math.sign()</code>, ponieważ jest metodą statyczną w obiekcie <code>Math</code>. (Nie jako metoda stworzonego obiektu  (<code>Math</code> nie jest konstruktorem)).</p>
+
+<p>Funkcja ma pięć wartości wynikowych <code>1, -1, 0, -0, NaN,</code> które reprezentują odpowiednio: "liczbę dodatnią", "liczbę ujemną", "zero "dodatnie"", <span style="line-height: 1.572;"> "zero "ujemne"" </span><span style="line-height: 1.572;">oraz NaN (parametr nie jest liczbą).</span></p>
+
+<p>Argument funkcji jest domyślnie konwertowany do <code>number</code>.</p>
+
+<h2 id="Examples" name="Examples">Przykłady</h2>
+
+<h3 id="Example:_Using_Math.log" name="Example:_Using_Math.log">Przykład: Użycie <code>Math.sign</code></h3>
+
+<pre class="brush:js">Math.sign(3)     //  1
+Math.sign(-3)    // -1
+Math.sign("-3")  // -1
+Math.sign(0)     //  0
+Math.sign(-0)    // -0
+Math.sign(NaN)   // NaN
+Math.sign("foo") // NaN
+Math.sign()      // NaN
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.sign', 'Math.sign')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Tabela_zgodności_przeglądarek">Tabela zgodności przeglądarek</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoDesktop("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Zobacz również</h2>
+
+<ul>
+ <li>Obiekt {{jsxref("Math")}}, który definiuje tą funkcję.</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/sin/index.html b/files/pl/web/javascript/reference/global_objects/math/sin/index.html
new file mode 100644
index 0000000000..b61ffd0560
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/sin/index.html
@@ -0,0 +1,52 @@
+---
+title: Math.sin()
+slug: Web/JavaScript/Reference/Global_Objects/Math/sin
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/sin
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca sinus danej liczby.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.sin(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>sin</code> zwraca wartość numeryczną większą lub równą -1 i mniejszą lub równą 1, stanowiącą sinus argumentu.</p>
+
+<p>Ponieważ <code>sin</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.sin()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.sin" name="Przyk.C5.82ad:_Zastosowanie_Math.sin">Przykład: Zastosowanie <code>Math.sin()</code></h3>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">sin<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span>          <span class="token comment"> // 0
+</span>Math<span class="token punctuation">.</span><span class="token function">sin<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span>          <span class="token comment"> // 0.8414709848078965
+</span>
+Math<span class="token punctuation">.</span><span class="token function">sin<span class="token punctuation">(</span></span>Math<span class="token punctuation">.</span>PI <span class="token operator">/</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/sqrt/index.html b/files/pl/web/javascript/reference/global_objects/math/sqrt/index.html
new file mode 100644
index 0000000000..4622fd2620
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/sqrt/index.html
@@ -0,0 +1,47 @@
+---
+title: Math.sqrt()
+slug: Web/JavaScript/Reference/Global_Objects/Math/sqrt
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/sqrt
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca pierwiastek kwadratowy danej liczby.</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>s</mi><mi>q</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mi>x</mi></msqrt><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x</annotation></semantics></math></p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.sqrt(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli wartość <code>x</code> jest ujemna, funkcja <code>sqrt</code> zwraca {{jsxref("NaN")}}.</p>
+
+<p>Ponieważ <code>sqrt()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.sqrt()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_Math.sqrt" name="Przyk.C5.82ad:_Zastosowanie_Math.sqrt">Przykład: Zastosowanie <code>Math.sqrt()</code></h3>
+
+<pre class="brush: js  language-js"><code class="language-js">Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">9</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 3
+</span>Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.414213562373095
+</span>
+Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 1
+</span>Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // 0
+</span>Math<span class="token punctuation">.</span><span class="token function">sqrt<span class="token punctuation">(</span></span><span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // NaN</span></code></pre>
+
+<p> </p>
diff --git a/files/pl/web/javascript/reference/global_objects/math/sqrt1_2/index.html b/files/pl/web/javascript/reference/global_objects/math/sqrt1_2/index.html
new file mode 100644
index 0000000000..1c1215f5b7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/sqrt1_2/index.html
@@ -0,0 +1,40 @@
+---
+title: Math.SQRT1 2
+slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2
+tags:
+  - JavaScript
+  - Math
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/SQRT1_2
+---
+<p>{{jsref}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Pierwiastek kwadratowy z liczby 1/2, albo, inaczej mówiąc, odwrotność pierwiastka kwadratowego z liczby 2, w przybliżeniu 0.707.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0.707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707</annotation></semantics></math></p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>SQRT1_2</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.SQRT1_2</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_SQRT1_2" name="Przyk.C5.82ad:_Zastosowanie_SQRT1_2">Przykład: Zastosowanie <code>Math.SQRT1_2</code></h3>
+
+<p>Poniższa funkcja zwraca pierwiastek kwadratowy z 1/2:</p>
+
+<pre class="brush:js  language-js">function getRoot1_2() {
+   return Math.SQRT1_2
+}
+
+<code class="language-js"><span class="token function">getRoot1_2<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 0.7071067811865476</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.pow()")}}</li>
+ <li>{{jsxref("Math.sqrt()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/sqrt2/index.html b/files/pl/web/javascript/reference/global_objects/math/sqrt2/index.html
new file mode 100644
index 0000000000..4fca0036ce
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/sqrt2/index.html
@@ -0,0 +1,42 @@
+---
+title: Math.SQRT2
+slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT2
+tags:
+  - JavaScript
+  - Math
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/SQRT2
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Pierwiastek kwadratowy z liczby 2, w przybliżeniu 1.414.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1.414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ponieważ <code>SQRT2</code> jest statyczną własnością obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez {{jsxref("Math")}}<code>.SQRT2</code>, a nie jak do własności instancji obiektu Math utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_SQRT2" name="Przyk.C5.82ad:_Zastosowanie_SQRT2">Przykład: Zastosowanie <code>Math.SQRT2</code></h3>
+
+<p>Poniższa funkcja zwraca pierwiastek kwadratowy z liczby 2:</p>
+
+<pre class="brush: js  language-js">function getRoot2() {
+   return Math.SQRT2;
+}
+
+<code class="language-js"><span class="token function">getRoot2<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // 1.4142135623730951</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.pow()")}}</li>
+ <li>{{jsxref("Math.sqrt()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/math/tan/index.html b/files/pl/web/javascript/reference/global_objects/math/tan/index.html
new file mode 100644
index 0000000000..adede7c207
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/math/tan/index.html
@@ -0,0 +1,54 @@
+---
+title: Math.tan()
+slug: Web/JavaScript/Reference/Global_Objects/Math/tan
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan
+original_slug: Web/JavaScript/Referencje/Obiekty/Math/tan
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca tangens danej liczby.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Math.tan(<var>x</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>x</code> </dt>
+ <dd>liczba.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>tan</code> zwraca wartość numeryczną reprezentującą tangens kąta.</p>
+
+<p>Ponieważ <code>tan()</code> jest statyczną metodą obiektu {{jsxref("Math")}}, zawsze odwołujemy się do niej poprzez <code>Math.tan()</code>, a nie jak do metody instancji obiektu {{jsxref("Math")}} utworzonej przez użytkownika.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h4 id="Przyk.C5.82ad:_Zastosowanie_Math.tan" name="Przyk.C5.82ad:_Zastosowanie_Math.tan">Przykład: Zastosowanie <code>Math.tan()</code></h4>
+
+<p>Poniższa funkcja zwraca tangens zmiennej <code>x</code>:</p>
+
+<pre class="brush: js">function getTan(x) {
+   return Math.tan(x)
+}
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/nan/index.html b/files/pl/web/javascript/reference/global_objects/nan/index.html
new file mode 100644
index 0000000000..22a87a7002
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/nan/index.html
@@ -0,0 +1,46 @@
+---
+title: NaN
+slug: Web/JavaScript/Reference/Global_Objects/NaN
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Global_Objects/NaN
+original_slug: Web/JavaScript/Referencje/Obiekty/NaN
+---
+<div>
+<div>
+<div>{{jsSidebar("Obiekty")}}</div>
+</div>
+</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wartość reprezentująca
+ <i>Not-A-Number</i>
+ , tj. nie będąca liczbą.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>NaN</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>NaN</code> jest własnością najwyższego rzędu i nie jest powiązana z żadnym obiektem.</p>
+
+<p>Wartością początkową <code>NaN</code> jest <code>NaN</code>.</p>
+
+<p><code>NaN</code> nigdy nie jest równa innej liczbie, nie jest równa nawet samej sobie. Nie jest możliwe sprawdzenie, czy dana wartość jest NaN przez porównanie z {{jsxref("Number.NaN")}} – należy zamiast tego stosować funkcję {{jsxref("Obiekty.isNaN", "isNaN()")}}.</p>
+
+<p>Wiele metod języka JavaScript (m. in. konstruktor <code>Number</code>, <code>parseFloat</code> i <code>parseInt</code>) zwracają <code>NaN</code>, jeśli wartość ich parametrów nie jest liczbą lub nie daje się na liczbę skonwertować.</p>
+
+<p><code>NaN</code> można zastosować do zasygnalizowania błędu w funkcji, która zazwyczaj zwraca poprawną liczbę.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.NaN")}}</li>
+ <li>{{jsxref("Number.isNaN()")}}</li>
+ <li>{{jsxref("Obiekty.isNaN", "isNaN()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/null/index.html b/files/pl/web/javascript/reference/global_objects/null/index.html
new file mode 100644
index 0000000000..bfe3ad5a72
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/null/index.html
@@ -0,0 +1,135 @@
+---
+title: 'null'
+slug: Web/JavaScript/Reference/Global_Objects/null
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/null
+original_slug: Web/JavaScript/Referencje/Obiekty/null
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p>Wartość <code>null</code> reprezentuje zamierzony brak wartości jakiegoś obiektu. Jest jedną z {{Glossary("Primitive", "podstawowych wartości")}} w JavaSript.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>null </code></pre>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Wartość <code>null</code>, jak podpowiada nazwa, zapisujemy używając słowa "<code>null</code>". <code>null</code> nie jest zmienną globalną, w przeciwieństwie do {{jsxref("Global_Objects/undefined","undefined")}}. Zamiast tego <code>null</code> wyraża brak identyfikacji, mówiąc nam, że zmienna nie wskazuje na obiekt. W wielu API <code>null</code> jest często zwracany tam, gdzie może być obiekt, ale aktualnie jeszcze go tam nie ma.</p>
+
+<pre class="brush: js">// foo nie istnieje. Nie jest zdefiniowany oraz nigdy nie był zainicjalizowany:
+&gt; foo
+"ReferenceError: foo is not defined"
+
+// Teraz wiadomo że null istnieje, ale nie ma on żadnego typu ani wartości:
+&gt; var foo = null; foo;
+"null"
+</pre>
+
+<h3 id="Różnice_pomiędzy_null_i_undefined">Różnice pomiędzy <code>null</code> i <code>undefined</code></h3>
+
+<p>Podczas sprawdzania <code>null</code> lub <font face="Consolas, Liberation Mono, Courier, monospace">undefined</font>, uważaj na <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_porównania">róźnice pomiędzy operatorami równości (==) oraz identyczności (===)</a>, ponieważ ten pierwszy wykonuje konwersję typu.</p>
+
+<pre class="brush: js">typeof null        // "object" (nie jest to "null" ze względu na starsze przyczyny)
+typeof undefined   // "undefined"
+null === undefined // false
+null  == undefined // true
+null === null // true
+null == null // true
+!null // true
+isNaN(1 + null) // false
+isNaN(1 + undefined) // true</pre>
+
+<p> </p>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-4.3.11', 'null value')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-null-value', 'null value')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-null-value', 'null value')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("undefined")}}</li>
+ <li>{{jsxref("NaN")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/epsilon/index.html b/files/pl/web/javascript/reference/global_objects/number/epsilon/index.html
new file mode 100644
index 0000000000..09ea32708c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/epsilon/index.html
@@ -0,0 +1,77 @@
+---
+title: Number.EPSILON
+slug: Web/JavaScript/Reference/Global_Objects/Number/EPSILON
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Number
+  - Właściwość
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/EPSILON
+---
+<div>{{JSRef}}</div>
+
+<p>Właściwość <strong><code>Number.EPSILON</code></strong> reprezentuje różnicę pomiędzy 1 a najmniejszą liczbą zmiennoprzecinkową większą niż 1.</p>
+
+<p>Jest to właściwość statyczna. Nie musisz tworzyć obiektu {{jsxref("Number")}}, żeby mieć do niej dostęp (użyj <code>Number.EPSILON</code>).</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}</div>
+
+
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Wartość właściwości <code>EPSILON</code> to w przybliżeniu  <code>2.2204460492503130808472633361816E-16</code> lub <code>2<sup>-52</sup></code>.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Testowanie_równości">Testowanie równości</h3>
+
+<pre class="brush: js">x = 0.2;
+y = 0.3;
+z = 0.1;
+equal = (Math.abs(x - y + z) &lt; Number.EPSILON);
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">if (Number.EPSILON === undefined) {
+    Number.EPSILON = Math.pow(2, -52);
+}
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-number.epsilon', 'Number.EPSILON')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność">Kompatybilność</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.EPSILON")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Number")}} obiekt, do którego należy ta właściwość.</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/index.html b/files/pl/web/javascript/reference/global_objects/number/index.html
new file mode 100644
index 0000000000..57d2491e77
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/index.html
@@ -0,0 +1,112 @@
+---
+title: Number
+slug: Web/JavaScript/Reference/Global_Objects/Number
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/Number
+original_slug: Web/JavaScript/Referencje/Obiekty/Number
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Pozwala pracować z wartościami liczbowymi. Obiekt <code>Number</code> jest opakowaniem (ang.<em>wrapper</em> ) dla prymitywnych wartości numerycznych.</p>
+
+<h2 id="Tworzone_przez" name="Tworzone_przez">Tworzone przez</h2>
+
+<p>Konstruktor <code>Number</code>:</p>
+
+<pre class="syntaxbox">new Number(value);</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>value</code> </dt>
+ <dd>Wartość numeryczna tworzonego obiektu.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Obiekt <code>Number</code> jest głównie stosowany do:</p>
+
+<ul>
+ <li>Uzyskania dostępu do jego stałych własnościach, które reprezentują najmniejszą i największa możliwą (przestawialną) liczbę, dodatnią lub ujemną nieskończoność i wartość nieliczbową (<em>Not-a-Number</em> ).</li>
+</ul>
+
+<ul>
+ <li>Aby stworzyć obiekty liczbowe do których możesz dodać własności. Najprawdopodobniej rzadko, kiedy będziesz musiał stworzyć obiekt typu <code>Number</code>.</li>
+</ul>
+
+<p>Własności <code>Number</code> są własnościami jego klasy, nieindywidualnymi własnościami obiektu.</p>
+
+<p><strong>JavaScript 1.2</strong>: <code>Number(x)</code> teraz tworzy raczej <code>NaN</code> niż błąd jeśli <code>x</code> jest ciągiem znaków, który nie zawiera poprawnie sformatowanej liczby. Na przykład, poniższy kod drukuje <code>NaN</code>:</p>
+
+<pre class="brush: js">var x = Number("three");
+document.write(x + "&lt;BR&gt;");
+</pre>
+
+<p>Możesz przekonwertować, każdy obiekt na liczbę używając funkcji wysokiego poziomu <code>Number</code>.</p>
+
+<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2>
+
+<dl>
+ <dt>{{jsxref("Number.constructor")}}</dt>
+ <dd>Oznacza funkcję, która tworzy prototyp obiektu.</dd>
+ <dt>{{jsxref("Number.MAX_VALUE")}}</dt>
+ <dd>Największa możliwa do przedstawienia liczba.</dd>
+ <dt>{{jsxref("Number.MIN_VALUE")}}</dt>
+ <dd>Najmniejsza możliwa do przedstawienia liczba.</dd>
+ <dt>{{jsxref("Number.NaN")}}</dt>
+ <dd>Specjalna wartość "nie jest liczbą" (Not-a-Number).</dd>
+ <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt>
+ <dd>Specjalna wartość reprezentująca negatywną nieskończoność; zwracana przy przepełnieniu.</dd>
+ <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt>
+ <dd>Specjalna wartość reprezentująca nieskończoność; zwracana przy przepełnieniu.</dd>
+ <dt>{{jsxref("Number.prototype")}}</dt>
+ <dd>Pozwala na dodawanie (tworzenie) nowych własności obiektu <code>Number</code>.</dd>
+</dl>
+
+<h2 id="Metody" name="Metody">Metody</h2>
+
+<p><strong>{{jsxref("Number.isInteger()")}}</strong></p>
+
+<p>     Sprawdza czy liczba jest całkowita.</p>
+
+<dl>
+ <dt>{{jsxref("Number.toExponential()")}}</dt>
+ <dd>Zwraca ciąg znaków, reprezentujący liczbę zapisaną w postaci wykładniczej.</dd>
+ <dt>{{jsxref("Number.toFixed()")}}</dt>
+ <dd>Zwraca ciąg znaków, reprezentujący liczbę stałoprzecinkową.</dd>
+ <dt>{{jsxref("Number.toLocaleString()")}}</dt>
+ <dd>Zwraca czytelny dla ludzi ciąg znaków reprezentujący liczbę zapisaną przy wykorzystaniu lokalnego formatu zapisu liczb. Przesłania metodę {{jsxref("Object.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("Number.toPrecision()")}}</dt>
+ <dd>Zwraca ciąg znaków reprezentujący liczbę stałoprzecinkową o podanej precyzji.</dd>
+ <dt>{{jsxref("Number.toSource()")}}</dt>
+ <dd>Zwraca literał obiektu reprezentujący podany obiekt <code>Number</code>; możesz użyć tą wartość, przy tworzeniu nowego obiektu. Przesłania metodę {{jsxref("Object.toSource()")}}.</dd>
+ <dt>{{jsxref("Number.toString()")}}</dt>
+ <dd>Zwraca ciąg znaków reprezentujący podany obiekt. Przesłania metodę {{jsxref("Object.toString()")}}.</dd>
+ <dt>{{jsxref("Number.valueOf()")}}</dt>
+ <dd>Zwraca zmienną typu prostego reprezentującą wartość podanego obiektu. Przesłania metodę {{jsxref("Object.valueOf()")}}.</dd>
+</dl>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_obiektu_Number.2C_przy_przypisaniu_warto.C5.9Bci_zmiennym_liczbowym" name="Przyk.C5.82ad:_Zastosowanie_obiektu_Number.2C_przy_przypisaniu_warto.C5.9Bci_zmiennym_liczbowym">Przykład: Zastosowanie obiektu <code>Number</code>, przy przypisaniu wartości zmiennym liczbowym</h3>
+
+<p>Poniższy przykład używa własności obiektu <code>Number</code>, aby przypisać wartości do kilku wartości numerycznych:</p>
+
+<pre class="brush: js">var najwiekszaLiczba = Number.MAX_VALUE;
+var najmniejszaLiczba = Number.MIN_VALUE;
+var nieskonczonosc = Number.POSITIVE_INFINITY;
+var negatywnaNieskonczonosc = Number.NEGATIVE_INFINITY;
+var nieJestLiczba = Number.NaN;
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_obiektu_Number_do_modyfikacji_wszystkich_obiekt.C3.B3w_Number" name="Przyk.C5.82ad:_Zastosowanie_obiektu_Number_do_modyfikacji_wszystkich_obiekt.C3.B3w_Number">Przykład: Zastosowanie obiektu <code>Number</code> do modyfikacji wszystkich obiektów <code>Number</code></h3>
+
+<p>Poniższy przykład tworzy obiekt typu <code>Number</code>, &lt;code&gt;.mojaLiczba&lt;/code&gt;, wtedy dodaje własność <code>opis</code>, wszystkim obiektom <code>Number</code>. Następnie wartość jest przypisana do własności <code>opis</code> obiektu <code>mojaLiczba</code>.</p>
+
+<pre class="brush: js">var mojaLiczba = new Number(65);
+Number.prototype.opis = null;
+var mojaLiczba.opis = "prędkość wiatru";
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/number/isinteger/index.html b/files/pl/web/javascript/reference/global_objects/number/isinteger/index.html
new file mode 100644
index 0000000000..5e11d160c8
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/isinteger/index.html
@@ -0,0 +1,89 @@
+---
+title: Number.isInteger()
+slug: Web/JavaScript/Reference/Global_Objects/Number/isInteger
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/isInteger
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong><code>Number.isInteger()</code></strong> sprawdza czy wpisana wartość jest liczbą całkowitą.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Number.isInteger(v<var>alue</var>)</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>zmienna</code></dt>
+ <dd>Zmienna będzie testowana jako liczba.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Metoda zwraca wartość typu {{jsxref("Boolean")}}.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Jeśli sprawdzana zmienna jest liczbą całkowitą metoda zwraca <code>true</code>, w innym przypadku zwraca <code>false</code>. Jeśli zmienna jest typu {{jsxref("NaN")}} lub spoza zakresu metoda zwraca <code>false</code>.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<pre class="brush: js">Number.isInteger(0);         // true
+Number.isInteger(1);         // true
+Number.isInteger(-100000);   // true
+
+Number.isInteger(0.1);       // false
+Number.isInteger(Math.PI);   // false
+
+Number.isInteger(NaN);       // false
+Number.isInteger(Infinity);  // false
+Number.isInteger(-Infinity); // false
+Number.isInteger('10');      // false
+Number.isInteger(true);      // false
+Number.isInteger(false);     // false
+Number.isInteger([1]);       // false
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) {
+  return typeof value === 'number' &amp;&amp;
+    isFinite(value) &amp;&amp;
+    Math.floor(value) === value;
+};
+</pre>
+
+<h2 id="Dokumentacja">Dokumentacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.isinteger', 'Number.isInteger')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilne_przegladarki">Kompatybilne przegladarki</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.isInteger")}}</p>
+
+<h2 id="Sprawdź_również">Sprawdź również</h2>
+
+<ul>
+ <li>Metoda ta należy do klasy {{jsxref("Number")}}.</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/isnan/index.html b/files/pl/web/javascript/reference/global_objects/number/isnan/index.html
new file mode 100644
index 0000000000..41486c7204
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/isnan/index.html
@@ -0,0 +1,109 @@
+---
+title: Number.isNaN()
+slug: Web/JavaScript/Reference/Global_Objects/Number/isNaN
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Metodă
+  - NaN
+  - Number
+  - isNaN
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/isNaN
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong><code>Number.isNaN()</code></strong> określa czy podany parametr ma wartość {{jsxref("NaN")}} i czy jest typu {{jsxref("Number")}}. Jest to ulepszona wersja oryginalnej, globalne funkcji {{jsxref("isNaN", "isNaN()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-isnan.html", "taller")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Number.isNaN(<var>value</var>)</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code><var>value</var></code></dt>
+ <dd>Wartość, którą będziemy testować {{jsxref("NaN")}}.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p><strong>true</strong>, jeśli podana wartość jest {{jsxref("NaN")}}, a jej typem jest {{jsxref("Number")}}; w przeciwnym razie, <strong>false</strong>.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Ponieważ oba operatory porównania, {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} i {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}, dla zapytania czy {{jsxref("NaN")}} <em>jest równe</em> {{jsxref("NaN")}} zwracają <code>false</code> funkcja <code>Number.isNaN()</code> staje się niezbędna. Jest sytuacja wyjątkowa i nie występuje, gdy porównujemy dowolne inne wartości w języku JavaScript.</p>
+
+<p>W porównaniu do funkcji globalnej {{jsxref("isNaN", "isNaN()")}}, metoda <code>Number.isNaN()</code> nie ma problemu z usilnym konwertowaniem parametru na liczbę. To oznacza, że można bezpiecznie przekazywać wartości, które normalnie mogłyby zostać skonwertowane na {{jsxref("NaN")}}, ale nie mają tej samej wartości co {{jsxref("NaN")}}. To również oznacza, że jedynie wartości typu {{jsxref("Number")}}, które są również {{jsxref("NaN")}}, zwrócą <code>true</code>.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<pre class="brush: js">Number.isNaN(NaN);        // true
+Number.isNaN(Number.NaN); // true
+Number.isNaN(0 / 0);      // true
+
+// Gdybyśmy użyli funkcji isNaN(), te przykłady zwróciłby true
+Number.isNaN('NaN');      // false
+Number.isNaN(undefined);  // false
+Number.isNaN({});         // false
+Number.isNaN('blabla');   // false
+
+// Wszystkie zwracają false
+Number.isNaN(true);
+Number.isNaN(null);
+Number.isNaN(37);
+Number.isNaN('37');
+Number.isNaN('37.37');
+Number.isNaN('');
+Number.isNaN(' ');
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Następujący przykład działa, ponieważ {{jsxref("NaN")}} jest jedyną wartością w języku JavaScript, która nie jest równa samej sobie.</p>
+
+<pre class="brush: js">Number.isNaN = Number.isNaN || function(value) {
+    return value !== null &amp;&amp; (value != value || +value != value);
+}
+</pre>
+
+<h2 id="Opis_2">Opis</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.isnan', 'Number.isnan')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-number.isnan', 'Number.isnan')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność">Kompatybilność</h2>
+
+
+
+<div>{{Compat("javascript.builtins.Number.isNaN")}}</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Number")}}</li>
+ <li>{{jsxref("isNaN", "isNaN()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/max_value/index.html b/files/pl/web/javascript/reference/global_objects/number/max_value/index.html
new file mode 100644
index 0000000000..9013774586
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/max_value/index.html
@@ -0,0 +1,36 @@
+---
+title: Number.MAX_VALUE
+slug: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
+tags:
+  - JavaScript
+  - Number
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/MAX_VALUE
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Największa liczba, której reprezentacja jest możliwa w języku JavaScript.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Własność <code>MAX_VALUE</code> ma wartość ok. 1.79E+308. Wartości większe niż <code>MAX_VALUE</code> są reprezentowane jako "<code>Infinity</code>" (nieskończoność).</p>
+
+<p>Ponieważ <code>MAX_VALUE</code> jest statyczną własnością {{jsxref("Number")}}, używa jej się zawsze jako <code>Number.MAX_VALUE</code>, a nie jako własność utworzonego przez programistę obiektu {{jsxref("Number")}}.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h2 id="Przyk.C5.82ad:_Zastosowanie_MAX_VALUE" name="Przyk.C5.82ad:_Zastosowanie_MAX_VALUE">Przykład: Zastosowanie <code>MAX_VALUE</code></h2>
+
+<p>Poniższy kod mnoży dwie liczby. Jeśli wynik jest większy lub równy <code>MAX_VALUE</code>, wywoływana jest funkcja <code>func1</code>, w przeciwnym wypadku wywoływana jest funkcja <code>func2</code>.</p>
+
+<pre class="eval">if (num1 * num2 &lt;= Number.MAX_VALUE) {
+   func1();
+} else {
+   func2();
+}
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/number/min_value/index.html b/files/pl/web/javascript/reference/global_objects/number/min_value/index.html
new file mode 100644
index 0000000000..ca91bc36f9
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/min_value/index.html
@@ -0,0 +1,40 @@
+---
+title: Number.MIN VALUE
+slug: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
+tags:
+  - JavaScript
+  - Number
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/MIN_VALUE
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Najmniejsza dodatnia wartość liczbowa, której reprezentacja jest możliwa w języku JavaScript.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Własność <code>MIN_VALUE</code> to najbliższa zeru liczba dodatnia, jakiej reprezentacja jest możliwa w języku JavaScript - nie jest to najmniejsza liczba ujemna.</p>
+
+<p><code>MIN_VALUE</code> ma wartość ok. 5e-324. Wartości mniejsze niż <code>MIN_VALUE</code> (ang. "underflow values") konwertowane są do 0.</p>
+
+<p>Ponieważ <code>MIN_VALUE</code> jest statyczną własnością {{jsxref("Number")}}, używa jej się zawsze jako <code>Number.MIN_VALUE</code>, a nie jako własność utworzonego przez programistę obiektu {{jsxref("Number")}}.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_MIN_VALUE" name="Przyk.C5.82ad:_Zastosowanie_MIN_VALUE">Przykład: Zastosowanie <code>Number.MIN_VALUE</code></h3>
+
+<p>Poniższy kod dzieli jedną liczbę przez drugą. Jeśli wynik jest większy lub równy <code>MIN_VALUE</code>, wywoływana jest funkcja <code>func1</code>, w przeciwnym wypadku wywoływana jest funkcja <code>func2</code>.</p>
+
+<pre class="brush: js">if (num1 / num2 &gt;= Number.MIN_VALUE) {
+   func1();
+} else {
+   func2();
+}
+</pre>
+
+<div class="noinclude"> </div>
diff --git a/files/pl/web/javascript/reference/global_objects/number/nan/index.html b/files/pl/web/javascript/reference/global_objects/number/nan/index.html
new file mode 100644
index 0000000000..ca26af77cf
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/nan/index.html
@@ -0,0 +1,49 @@
+---
+title: Number.NaN
+slug: Web/JavaScript/Reference/Global_Objects/Number/NaN
+tags:
+  - JavaScript
+  - Number
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/NaN
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wartość reprezentująca Not-A-Number (Nie-Liczbę).</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartością <code>Number.NaN</code> jest Not-A-Number, taką samą jak wartość własności {{jsxref("Obiekty/NaN", "NaN")}} obiektu globalnego.</p>
+
+<p><span class="comment">Keep text below in sync with Properties:NaN page</span> <code>NaN</code> jest zawsze różna od dowolnej liczby, włączając również <code>NaN</code>; nie możesz sprawdzić wartości nieliczbowej poprzez porównanie do <code>Number.NaN</code>. Użyj zamiast tego funkcji {{jsxref("Obiekty/isNaN", "isNaN()")}}.</p>
+
+<p>Kilka metod JavaScript (takie jak konstruktor <code>Number</code>, <code>parseFloat</code> i <code>parseInt</code>) zwracają <code>NaN</code>, jeśli wartość określona w parametrze nie może być przetworzona jako liczba.</p>
+
+<p>Możesz użyć własności <code>NaN</code>, aby wskazać warunek błędu dla Twojej funkcji, która zwraca liczbę w przypadku sukcesu.</p>
+
+<p>JavaScript wyświetla wartość <code>Number.NaN</code> jako <code>NaN</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_NaN" name="Przyk.C5.82ad:_Zastosowanie_NaN">Przykład: Zastosowanie <code>Number.NaN</code></h3>
+
+<p>W poniższym przykładzie, jeśli miesiąc (month) jest wartość większą niż 12, zostaje mu przypisane <code>NaN</code> i wyświetlana jest informacja o nieprawidłowych wartościach.</p>
+
+<pre class="brush: js">var month = 13;
+if (month &lt; 1 || month &gt; 12) {
+   month = Number.NaN;
+   console.log("Miesiąc musi być liczbą między 1 i 12.");
+}
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Obiekty/NaN", "NaN")}}</li>
+ <li>The {{jsxref("Number")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/negative_infinity/index.html b/files/pl/web/javascript/reference/global_objects/number/negative_infinity/index.html
new file mode 100644
index 0000000000..a266fc571b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/negative_infinity/index.html
@@ -0,0 +1,54 @@
+---
+title: Number.NEGATIVE INFINITY
+slug: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY
+tags:
+  - JavaScript
+  - Number
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/NEGATIVE_INFINITY
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wartość reprezentująca ujemną nieskończoność.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość własności <code>Number.NEGATIVE_INFINITY</code> jest taka sama jak ujemna wartość własności {{jsxref("Infinity")}} obiektu globalnego.</p>
+
+<p>Wartość ta zachowuje się nieco inaczej niż matematyczna nieskończoność:</p>
+
+<ul>
+ <li>Dowolna dodatnia wartość, włączając {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, pomnożona przez <code>NEGATIVE_INFINITY</code> jest równa <code>NEGATIVE_INFINITY</code>.</li>
+ <li>Dowolna ujemna wartość, włączając <code>NEGATIVE_INFINITY</code>, pomnożona przez <code>NEGATIVE_INFINITY</code> jest równa {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li>
+ <li>Zero pomnożone przez <code>NEGATIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li>
+ <li>NaN pomnożone przez <code>NEGATIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li>
+ <li>Wartość <code>NEGATIVE_INFINITY</code> podzielona przez dowolną wartość ujemną za wyjątkiem <code>NEGATIVE_INFINITY</code> jest równa {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li>
+ <li>Wartość <code>NEGATIVE_INFINITY</code> podzielona przez dowolną wartość dodatnią za wyjątkiem {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}} jest równa <code>NEGATIVE_INFINITY</code>.</li>
+ <li>Wartość <code>NEGATIVE_INFINITY</code> podzielona przez <code>NEGATIVE_INFINITY</code> lub {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}} zwraca wartość NaN.</li>
+ <li>Dowolna liczba podzielona przez <code>NEGATIVE_INFINITY</code> jest równa zero.</li>
+</ul>
+
+<p>Własności <code>Number.NEGATIVE_INFINITY</code> można użyć do wskazania błędu warunku, który zwraca liczbę skończoną w przypadku powodzenia. Należy jednak zauważyć, że funkcja {{jsxref("Obiekty/isFinite", "isFinite")}} będzie w tym wypadku bardziej odpowiednia.</p>
+
+<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2>
+
+<p>W poniższym przykładzie do zmiennej smallNumber została przypisana wartość mniejsza niż wartość minimalna. Gdy zostaje wykonana instrukcja <code>if</code>, smallNumber posiada wartość "<code>-Infinity</code>", więc przed kontynuowaniem do zmiennej smallNumber jest przypisywana bardziej wykonywalna wartość.</p>
+
+<pre class="brush: js">var smallNumber = (-Number.MAX_VALUE) * 2;
+
+if (smallNumber == Number.NEGATIVE_INFINITY) {
+ smallNumber = returnFinite();
+}
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
+ <li>{{jsxref("Number.isFinite()")}}</li>
+ <li>{{jsxref("Obiekty/Infinity", "Infinity")}}</li>
+ <li>{{jsxref("Obiekty/isFinite", "isFinite()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/positive_infinity/index.html b/files/pl/web/javascript/reference/global_objects/number/positive_infinity/index.html
new file mode 100644
index 0000000000..b5643f1cdc
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/positive_infinity/index.html
@@ -0,0 +1,58 @@
+---
+title: Number.POSITIVE INFINITY
+slug: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY
+tags:
+  - JavaScript
+  - Number
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/POSITIVE_INFINITY
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wartość reprezentująca dodatnią nieskończoność.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartość własności <code>Number.POSITIVE_INFINITY</code> jest taka sama jak wartość własności {{jsxref("Infinity")}} obiektu globalnego.</p>
+
+<p>Wartość ta zachowuje się nieco inaczej niż matematyczna nieskończoność:</p>
+
+<ul>
+ <li>Dowolna dodatnia wartość, włączając <code>POSITIVE_INFINITY</code>, pomnożona przez <code>POSITIVE_INFINITY</code> jest równa <code>POSITIVE_INFINITY</code>.</li>
+ <li>Dowolna ujemna wartość, włączając {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, pomnożona przez <code>POSITIVE_INFINITY</code> jest równa {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li>
+ <li>Zero pomnożone przez <code>POSITIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li>
+ <li>NaN pomnożone przez <code>POSITIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li>
+ <li>Wartość <code>POSITIVE_INFINITY</code> podzielona przez dowolną wartość ujemną za wyjątkiem {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} jest równa {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li>
+ <li>Wartość <code>POSITIVE_INFINITY</code> podzielona przez dowolną wartość dodatnią za wyjątkiem <code>POSITIVE_INFINITY</code> jest równa <code>POSITIVE_INFINITY</code>.</li>
+ <li>Wartość <code>POSITIVE_INFINITY</code> podzielona przez {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} lub <code>POSITIVE_INFINITY</code> zwraca wartość {{jsxref("Obiekty/NaN", "NaN")}}.</li>
+ <li>Dowolna liczba podzielona przez <code>POSITIVE_INFINITY</code> jest równa <code>0</code>.</li>
+</ul>
+
+<p>Niektóre metody JavaScript (takie jak konstruktor <code>Number</code>, <code>parseFloat</code> i <code>parseInt</code>) zwracają wartość <code>NaN</code>, jeśli wartość określona w parametrze znacznie przewyższa wartość <code>Number.MAX_VALUE</code>.</p>
+
+<p>Własności <code>Number.POSITIVE_INFINITY</code> można użyć do wskazania błędu warunku, który zwraca liczbę skończoną w przypadku powodzenia. Należy jednak zauważyć, że funkcja {{jsxref("Obiekty/isFinite", "isFinite")}} będzie w tym wypadku bardziej odpowiednia.</p>
+
+<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2>
+
+<p>W poniższym przykładzie do zmiennej largeNumber została przypisana wartość większa niż wartość maksymalna. Gdy zostaje wykonana instrukcja {{jsxref("Polecenia/if...else", "if")}}, largeNumber posiada wartość <code>Infinity</code>, więc przed kontynuowaniem do zmiennej <code>bigNumber</code> jest przypisywana bardziej wykonywalna wartość.</p>
+
+<pre class="brush: js">var bigNumber = Number.MAX_VALUE * 2;
+
+if (bigNumber == Number.POSITIVE_INFINITY) {
+ bigNumber = returnFinite();
+}
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
+ <li>{{jsxref("Number.isFinite()")}}</li>
+ <li>{{jsxref("Infinity")}}</li>
+ <li>{{jsxref("Obiekty/isFinite", "isFinite()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/toexponential/index.html b/files/pl/web/javascript/reference/global_objects/number/toexponential/index.html
new file mode 100644
index 0000000000..946714b2b8
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/toexponential/index.html
@@ -0,0 +1,54 @@
+---
+title: Number.prototype.toExponential()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toExponential
+tags:
+  - JavaScript
+  - Method
+  - Number
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/toExponential
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący Number w notacji wykładniczej.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>numObj</var>.toExponential([<var>fractionDigits</var>])</code></pre>
+
+<h3 id="Parametr" name="Parametr">Parametr</h3>
+
+<dl>
+ <dt>fractionDigits</dt>
+ <dd>Liczba całkowita określająca liczbę cyfr występujących po kropce dziesiętnej. Domyślną wartością jest tyle cyfr, ile potrzeba do określenia liczby.</dd>
+</dl>
+
+<h3 id="Zwraca" name="Zwraca">Zwraca</h3>
+
+<p>Łańcuch znaków reprezentujący obiekt {{jsxref("Number")}} w notacji wykładniczej z jedną cyfrą przed kropką dziesiętną i zaokrągleniem do tylu cyfr po kropce, ile określa parametr <code>fractionDigits</code>. Jeśli argument <code>fractionDigits</code> zostanie pominięty, domyślnie przyjmowana jest taka wartość zaokrąglenia, która pozwala na przedstawienie wartości w sposób unikatowy.</p>
+
+<p>Jeśli metoda <code>toExponential()</code> zostanie użyta do literałów liczbowych, które nie posiadają wykładnika i kropki dziesiętnej, należy wstawić spację przed kropką poprzedzającą wywołanie metody, aby zapobiec zinterpretowaniu tej kropki jako kropki dziesiętnej.</p>
+
+<p>Jeśli liczba posiada więcej cyfr niż określono przez parametr <code>fractionDigits</code>, jest ona zaokrąglana do najbliższej liczby o ilości cyfr wskazanej przez wartość <code>fractionDigits</code>. Zobacz dyskusję na temat zaokrąglania w opisie metody <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Number/toFixed">toFixed</a>, która również odnosi się do metody <code>toExponential()</code>.</p>
+
+<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2>
+
+<pre>var num=77.1234;
+
+console.log("num.toExponential() is " + num.toExponential()); //wyświetla 7.71234e+1
+console.log("num.toExponential(4) is " + num.toExponential(4)); //wyświetla 7.7123e+1
+console.log("num.toExponential(2) is " + num.toExponential(2)); //wyświetla 7.71e+1
+console.log("77.1234.toExponential() is " + 77.1234.toExponential()); //wyświetla 7.71234e+1
+console.log("77 .toExponential() is " + 77 .toExponential()); //wyświetla 7.7e+1
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toFixed()")}}</li>
+ <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
+ <li>{{jsxref("Number.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/tofixed/index.html b/files/pl/web/javascript/reference/global_objects/number/tofixed/index.html
new file mode 100644
index 0000000000..df80458f16
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/tofixed/index.html
@@ -0,0 +1,62 @@
+---
+title: Number.prototype.toFixed()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toFixed
+tags:
+  - JavaScript
+  - Method
+  - Number
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/toFixed
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Formatuje liczbę stosując notację stałoprzecinkową.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>numObj</var>.toFixed([<var>digits</var>])</code></pre>
+
+<h3 id="Parametr" name="Parametr">Parametr</h3>
+
+<dl>
+ <dt>digits</dt>
+ <dd>Liczba cyfr, które mają zostać wyświetlone po kropce dziesiętnej; może to być wartość z zakresu od 0 do 20 włącznie, ale implementacje mogą opcjonalnie wprowadzać większe zakresy. Jeśli argument zostanie pominięty, przyjmowana jest wartość 0.</dd>
+</dl>
+
+<h3 id="Zwraca" name="Zwraca">Zwraca</h3>
+
+<p>Reprezentację wartości <code>number</code> w postaci łańcucha znaków, która nie stosuje notacji wykładniczej i posiada dokładnie tyle cyfr po separatorze dziesiętnym, ile wskazuje na to wartość parametru <code>digits</code>. Liczba w razie konieczności jest zaokrąglana, a część ułamkowa wypełniana zerami, aby liczba posiadała określoną długość. Jeśli liczba <code>number</code> jest większa niż 1e+21, metoda ta po prostu wywołuje {{jsxref("Number.prototype.toString()")}} i zwraca łańcuch znaków w notacji wykładniczej.</p>
+
+<h3 id="Wyrzuca" name="Wyrzuca">Wyrzuca</h3>
+
+<dl>
+ <dt>{{jsxref("Obiekty/RangeError", "RangeError")}}</dt>
+ <dd>Jeśli wartość parametru <code>digits</code> jest za duża lub za mała. Wartości z zakresu od 0 do 20 włącznie nie spowodują wystąpienia {{jsxref("Obiekty/RangeError", "RangeError")}}. Dopuszcza się na obsługę mniejszych lub większych wartości przez różne implementacje.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Obiekty/TypeError", "TypeError")}}</dt>
+ <dd>Jeśli ta metoda jest przywołana w obiekcie, który nie jest obiektem {{jsxref("Number")}}.</dd>
+</dl>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<pre class="brush: js">var n = 12345.6789;
+
+n.toFixed();              // zwraca 12346: zauważ zaokrąglenie i brak części ułamkowej
+n.toFixed(1);             // zwraca 12345.7: zauważ zaokrąglenie
+n.toFixed(6);             // zwraca 12345.678900: zauważ dodane zera
+(1.23e+20).toFixed(2);    // zwraca 123000000000000000000.00
+(1.23e-10).toFixed(2)     // zwraca 0.00
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toExponential()")}}</li>
+ <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
+ <li>{{jsxref("Number.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/tolocalestring/index.html b/files/pl/web/javascript/reference/global_objects/number/tolocalestring/index.html
new file mode 100644
index 0000000000..035efe8464
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/tolocalestring/index.html
@@ -0,0 +1,183 @@
+---
+title: Number.prototype.toLocaleString()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/toLocaleString
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong><code>toLocaleString()</code></strong> zwraca łańcuch znaków przedstawiający dany numer w formacie wybranej lokalizacji.</p>
+
+<p>Nowe argumenty - <code>lokalizacje</code> i <code>opcje</code> - pozwalają na wybranie lokalizacji w jakiej ma zostać przedstawiona liczba. Starsza implementacja, która nie posiadała tych argumentów, zwracała łańcuch znaków zależny od implementacji danego środowiska.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>numObj</em>.toLocaleString(</code><code>[lokalizacje [, opcje]])</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<p>W sekcji <a href="#Browser_compatibility">kompatybilności</a> możesz sprawdzić, które przeglądarki obsługują argumenty <code>lokalizacji</code> i <code>opcji</code> . W sekcji <a href="#Checking_for_support_for_locales_and_options_arguments">Przykład: Sprawdzanie obsługi argumentów <code>lokalizacji</code> i <code>opcji</code> </a>rozpisane są sposoby na przetestowanie obsługiwanych przez przeglądarkę argumentów tej metody.</p>
+
+<div class="note">
+<p><strong>Info:</strong> ECMAScript Internationalization API, zaimplementowane w Firefoxie 29, dodaje obsługę parametry<code>lokalizacje</code> do metody<code>Number.toLocaleString()</code>. Jeśli argument nie zostanie podany ({{jsxref("undefined")}}) metoda przyjmię lokalizację systemu operacyjnego. Poprzednie wersje Firefoxa zwracały liczby z lokalizacji <a href="https://en.wikipedia.org/wiki/Arabic_numerals">Western Arabic</a>. Zmiana zostala zgłoszona jako regresja rzutująca na wsteczną kompatybilność metody, i wkrótce zostanie naprawiona. ({{bug(999003)}})</p>
+</div>
+
+<div>{{page('/pl-PL/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat', 'Parameters')}}</div>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Łańcuch znaków przedstawiający liczbę w danym formacie.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Przykłady_użycia_metody_toLocaleString">Przykłady użycia metody <code>toLocaleString</code></h3>
+
+<p>Podstawowy sposób użycia, bez podanych argumentów, zwróci nam łańcuch znaków w domyślnej lokalizacji i z domyślnymi opcjami.</p>
+
+<pre class="brush: js">var liczba = 3500;
+
+console.log(liczba.toLocaleString()); // Wyświetli "3 500", jeśli twoją lokalizacją jest „pl-PL”
+</pre>
+
+<h3 id="Sprawdzanie_dostępności_argumentów_lokalizacji_i_opcji">Sprawdzanie dostępności argumentów <code>lokalizacji</code> i <code>opcji</code></h3>
+
+<p>Nie wszystkie przeglądarki obsługuję argumenty <code>lokalizacji</code> i <code>opcji</code>. Aby to sprawdzić w wersji języka ES5.1 i późniejszych możemy użyć wyjątku {{jsxref("Global_Objects/RangeError", "RangeError")}}, który zostanie rzucony gdy niepoprawna nazwa lokalizacji zostanie użyta:</p>
+
+<pre class="brush: js">function toLocaleStringSupportsLocales() {
+  var liczba = 0;
+  try {
+    liczba.toLocaleString('i');
+  } catch (e) {
+    return e.name === 'RangeError';
+  }
+  return false;
+}
+</pre>
+
+<p>W wersjach przed ES5.1 nie było obowiązku wyrzucania wyjątku Range Error jeśli metoda <code>toLocaleString</code> została wywołana z argumentami.</p>
+
+<p>Sprawdzenie działające na wszystkich wersjach języka przed 5.1 polega na użyciu funkcjonalności niezbędnych do działania tych argumentów bezpośrednio na <code>Number.prototype.toLocaleString</code>:</p>
+
+<pre class="brush: js">function toLocaleStringSupportsOptions() {
+  return !!(typeof Intl == 'object' &amp;&amp; Intl &amp;&amp; typeof Intl.NumberFormat == 'function');
+}
+</pre>
+
+<p>Sprawdzamy tutaj czy istnieje globalny obiekt <code>Intl</code>, czy nie jest <code>nullem</code>, a także czy posiada właściwość <code>NumberFormat</code>, która jest funkcją.</p>
+
+<h3 id="Przykłady_użycia_lokalizacji">Przykłady użycia <code>lokalizacji</code></h3>
+
+<p>Przykład ten pokazuje kilka różnych lokalizacji. Aby uzyskać foramt języka interfejsu użytkownika upewnij się, że podajesz tę lokalizację (i dla pewności kilka innych jako fallbacki) przy pomocy aargumentu <code>localizacji</code>:</p>
+
+<pre class="brush: js">var liczba = 123456.789;
+
+// Język niemiecki oddziela części dziesiętne przecinkiem, a tysiące kropką
+console.log(liczba.toLocaleString('de-DE'));
+// → 123.456,789
+
+// W większości krajów arabskich używa cyfr <a href="https://en.wikipedia.org/wiki/Eastern_Arabic_numerals">Eastern Arabic</a>
+console.log(liczba.toLocaleString('ar-EG'));
+// → ١٢٣٤٥٦٫٧٨٩
+
+// Indyjski używa separatorów tysięcy/lakh/crore
+console.log(liczba.toLocaleString('en-IN'));
+// → 1,23,456.789
+
+// Klucz rozszerzeń „nu” pyta o system numeryczny, np. Chiński system dziesiętny
+console.log(liczba.toLocaleString('zh-Hans-CN-u-nu-hanidec'));
+// → 一二三,四五六.七八九
+
+// jeśli masz zamiar użyć lokalizacji, która może nie być obsługiwana
+// jak np. Balinese, zawsze dodaj drugi lokalizację, tutaj Indonezyjską
+console.log(liczba.toLocaleString(['ban', 'id']));
+// → 123.456,789
+</pre>
+
+<h3 id="Przykłady_użycia_opcji">Przykłady użycia <code>opcji</code></h3>
+
+<p>Rezultaty metody<code>toLocaleString</code>  mogą być dostosowywane przy pomocy argumentu <code>opcje</code>:</p>
+
+<pre class="brush: js">var liczba = 123456.789;
+
+// format walutowy
+console.log(liczba.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' }));
+// → 123.456,79 €
+
+// Japoński yen
+console.log(liczba.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' }))
+// → ￥123,457
+
+// ogranicz wyświetlanie do 3 miejsc znaczących
+console.log(liczba.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));
+// → 1,23,000
+
+// Użyj domyślnego języka hosta z opcjami formatowania liczby
+var num = 30000.65;
+console.log(num.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2}));
+// → "30,000.65" w języku angielskim lub
+// → "30.000,65" w języku niemieckiem lub
+// → "30 000,65" w języku francuskim
+</pre>
+
+<h2 id="Wydajność">Wydajność</h2>
+
+<p>Jeśli zamierzasz formatować wiele liczb, lepiej użyć obiektu {{jsxref("NumberFormat")}} i formatować przy pomocy metody {{jsxref("NumberFormat.format")}}.</p>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Pierwsza definicja. Zaimplementowane w JavaScript 1.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.4.3', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 1.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sec-Number.prototype.toLocaleString', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność">Kompatybilność</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.toLocaleString")}}</p>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/toprecision/index.html b/files/pl/web/javascript/reference/global_objects/number/toprecision/index.html
new file mode 100644
index 0000000000..126b6c2d95
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/toprecision/index.html
@@ -0,0 +1,57 @@
+---
+title: Number.prototype.toPrecision()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toPrecision
+tags:
+  - JavaScript
+  - Method
+  - Number
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/toPrecision
+---
+<p>{{jsref}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący dany obiekt Number z określoną dokładnością.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>numObj</var>.toPrecision([<var>precision</var>])</code></pre>
+
+<h3 id="Parametr" name="Parametr">Parametr</h3>
+
+<dl>
+ <dt>precision</dt>
+ <dd>Liczba całkowita określająca liczbę cyfr po kropce dziesiętnej.</dd>
+</dl>
+
+<h3 id="Zwraca" name="Zwraca">Zwraca</h3>
+
+<p>Łańcuch znaków reprezentujący obiekt {{jsxref("Number")}} w notacji stałoprzecinkowej lub wykładniczej z zaokrągleniem do tylu ważnych cyfr, ile wskazuje wartość <code>precision</code>.</p>
+
+<p>Jeśli metoda <code>toPrecision()</code> zostanie użyta do literałów liczbowych, które nie posiadają wykładnika i kropki dziesiętnej, należy wstawić spację przed kropką poprzedzającą wywołanie metody, aby zapobiec zinterpretowaniu tej kropki jako kropki dziesiętnej.</p>
+
+<p>Jeśli argument <code>precision</code> zostanie pominięty, metoda zachowuje się jak {{jsxref("Number.prototype.toString()")}}.</p>
+
+<p>Jeśli liczba posiada więcej cyfr niż określono przez parametr <code>precision</code>, jest ona zaokrąglana do najbliższej liczby o ilości cyfr wskazanej przez wartość <code>precision</code>. Zobacz dyskusję na temat zaokrąglania w opisie metody {{jsxref("Number.prototype.toFixed()")}}, która również odnosi się do metody <code>toPrecision</code>.</p>
+
+<h2 id="Przyk.C5.82ad" name="Przyk.C5.82ad">Przykład</h2>
+
+<pre class="brush: js">var num=5.123456;
+
+console.log("num.toPrecision() is " + num.toPrecision()); //wyświetli 5.123456
+console.log("num.toPrecision(4) is " + num.toPrecision(4)); //wyświetli 5.123
+console.log("num.toPrecision(2) is " + num.toPrecision(2)); //wyświetli  5.1
+console.log("num.toPrecision(1) is " + num.toPrecision(1)); //wyświetli 5
+console.log("1250 .toPrecision(2) is " + 1250 .toPrecision(2)); //wyświetli 1.3e+3
+console.log("1250 .toPrecision(5) is " + 1250 .toPrecision(5)); //wyświetli 1250.0
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toFixed()")}}</li>
+ <li>{{jsxref("Number.prototype.toExponential()")}}</li>
+ <li>{{jsxref("Number.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/number/tostring/index.html b/files/pl/web/javascript/reference/global_objects/number/tostring/index.html
new file mode 100644
index 0000000000..672019ca59
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/number/tostring/index.html
@@ -0,0 +1,60 @@
+---
+title: Number.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toString
+tags:
+  - JavaScript
+  - Method
+  - Number
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/Number/toString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący dany obiekt {{jsxref("Number")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>numObj</var>.toString([<var>radix</var>])</code></pre>
+
+<h3 id="Parametr" name="Parametr">Parametr</h3>
+
+<dl>
+ <dt>radix</dt>
+ <dd>Liczba całkowita z zakresu od 2 do 36 określająca podstawę użytą do reprezentacji wartości liczbowych.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Obiekt <code>Number</code> przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektów <code>Number</code> metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt w danej podstawie wyliczeń.</p>
+
+<p>Metoda toString przetwarza pierwszy podany argument i próbuje zwrócić reprezentację w postaci łańcucha znaków w określonej podstawie wyliczeń. Dla podstawy większej od 10 litery alfabetu wskazują liczby większe niż 9. Przykładowo dla liczb heksadecymalnych (podstawa 16) użyte zostaną litery od A do F.</p>
+
+<p>Jeśli jako argument <code>toString()</code> podano podstawę nie będącą w zakresie od 2 do 36, zostanie wywołany wyjątek.</p>
+
+<p>Jeśli podstawa nie została określona, JavaScript przyjmuje za podstawę wartość 10.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<pre class="brush: js  language-js"><code class="language-js"><span class="token keyword">var</span> count <span class="token operator">=</span> <span class="token number">10</span><span class="token punctuation">;</span>
+
+console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>count<span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>   <span class="token comment"> // displays '10'
+</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token number">17</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>    <span class="token comment"> // displays '17'
+</span>
+<span class="token keyword">var</span> x <span class="token operator">=</span> <span class="token number">6</span><span class="token punctuation">;</span>
+
+console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>x<span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>      <span class="token comment"> // displays '110'
+</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token number">254</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">16</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // displays 'fe'
+</span>
+console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token operator">-</span><span class="token number">10</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment"> // displays '-1010'
+</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token punctuation">(</span><span class="token operator">-</span><span class="token number">0xff</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // displays '-11111111'</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toFixed()")}}</li>
+ <li>{{jsxref("Number.prototype.toExponential()")}}</li>
+ <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/assign/index.html b/files/pl/web/javascript/reference/global_objects/object/assign/index.html
new file mode 100644
index 0000000000..84c139a058
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/assign/index.html
@@ -0,0 +1,308 @@
+---
+title: Object.assign()
+slug: Web/JavaScript/Reference/Global_Objects/Object/assign
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/assign
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong><code>Object.assign()</code></strong> kopiuje wszystkie wartości wyliczalnych własnych właściwości z jednego lub więcej obiektów źródłowych do obiektu docelowego. Zwraca obiekt docelowy.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">Object.assign(<var>cel</var>, ...<var>zrodla</var>)</pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>cel</code></dt>
+ <dd>Obiekt docelowy.</dd>
+ <dt><code>zrodla</code></dt>
+ <dd>Obiekt(y) żródłowe.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Obiekt docelowy.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Właściwości w obiekcie docelowym zostaną nadpisane właściwościami obiektów źródłowych, jeśli właściwości te mają takie same nazwy. Właściwości obiektów źródłowych występujących później na liście argumentów, podobnie, nadpiszą właściwości obiektów występujących wcześniej.</p>
+
+<p>Metoda <code>Object.assign()</code> jedynie kopiuje <em>wyliczalne</em> i <em>własne</em> właściwości z obiektów źródłowych do obiektu docelowego. Używa do tego <code>[[Get]]</code> na źródle oraz <code>[[Set]]</code> na obiekcie docelowym, więc wywołuje gettery i settery odpowiednich obiektów. Dlatego też mowa tu o <em>przypisaniu</em> właściwości, a nie o ich kopiowaniu czy tworzeniu nowych. Metoda ta może być więc nieodpowiednia do przyłączania nowych właściwości do prototypu, w przypadku gdy źródła przyłączenia zawierają gettery. Do kopiowania definicji właściwości, wliczając ich wyliczalność, do prototypów należy użyć {{jsxref("Object.getOwnPropertyDescriptor()")}} oraz {{jsxref("Object.defineProperty()")}}.</p>
+
+<p>Obie właściwości {{jsxref("String")}} jak i {{jsxref("Symbol")}} są kopiowane.</p>
+
+<p>W przypadku błędu, na przykład gdy wartość jest zabezpieczona przed zapisem, zostanie rzucony błąd {{jsxref("TypeError")}}, a obiekt docelowy może zostać zmieniony, jeśli jakieś właściwości zostały do niego dodane przed wystąpieniem błędu.</p>
+
+<p>Zauważ, że <code>Object.assign()</code> nie rzuci błędu, gdy źródłem jest {{jsxref("null")}} lub {{jsxref("undefined")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Klonowanie_obiektu">Klonowanie obiektu</h3>
+
+<pre class="brush: js">var obiekt = { a: 1 };
+var kopia = Object.assign({}, obiekt);
+console.log(kopia); // { a: 1 }
+</pre>
+
+<h3 id="Deep_Clone" name="Deep_Clone">Ostrzeżenie przed Głębokim Klonowaniem</h3>
+
+<p>W przypadku głębokiego klonowania musimy użyć innych sposóbów, ponieważ <code>Object.assign()</code> kopiuje jedynie wartości przechowywane we właściwościach. Jeżeli właściwość źródłowa jest referencją do obiektu, to skopiowana zostanie jedynie ta referencja (wówczas zarówno źródło jak i cel będą posiadać referencję do tego samego obiektu, a nie osobne kopie tych obiektów).</p>
+
+<pre><code>function test() {
+  'use strict';
+
+  let obj1 = { a: 0 , b: { c: 0}};   // a: wartość, b: referencja, c: wartość
+  let obj2 = Object.assign({}, obj1);
+  console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}
+
+  obj1.a = 1; // zmiana wartości, dotyczy tylko obj1
+  console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}
+  console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}
+
+  obj2.a = 2; // zmiana wartości, dotyczy tylko obj2
+  console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}
+  console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 0}}
+
+  obj2.b.c = 3; // zmiana wartości w obiekcie o współdzielonej referencji
+  console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 3}} // teraz b.c == 3
+  console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 3}} // i tu też b.c == 3, bo obj1.b === obj2.b
+
+  // Klonowanie głębokie
+  obj1 = { a: 0 , b: { c: 0}};
+  let obj3 = JSON.parse(JSON.stringify(obj1));
+  obj1.a = 4;
+  obj1.b.c = 4;
+  console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}} // obj1.b !== obj2.b
+}
+
+test();</code></pre>
+
+<h3 id="Łączenie_obiektów">Łączenie obiektów</h3>
+
+<pre class="brush: js">var o1 = { a: 1 };
+var o2 = { b: 2 };
+var o3 = { c: 3 };
+
+var obj = Object.assign(o1, o2, o3);
+console.log(obj); // { a: 1, b: 2, c: 3 }
+console.log(o1);  // { a: 1, b: 2, c: 3 }, sam obiekt docelowy został zmieniony.</pre>
+
+<h3 id="Łączenie_obiektów_z_tymi_samymi_właściowściami">Łączenie obiektów z tymi samymi właściowściami</h3>
+
+<pre class="brush: js">var o1 = { a: 1, b: 1, c: 1 };
+var o2 = { b: 2, c: 2 };
+var o3 = { c: 3 };
+
+var obj = Object.assign({}, o1, o2, o3);
+console.log(obj); // { a: 1, b: 2, c: 3 }</pre>
+
+<p>Właściwość jest nadpisywana przez ostatni obiekt w liście parametrów, który ma taką samą właściwość.</p>
+
+<h3 id="Kopiowanie_właściwości-symboli">Kopiowanie właściwości-symboli</h3>
+
+<pre class="brush: js">var o1 = { a: 1 };
+var o2 = { [Symbol('foo')]: 2 };
+
+var obj = Object.assign({}, o1, o2);
+console.log(obj); // { a : 1, [Symbol("foo")]: 2 } (cf. bug 1207182 on Firefox)
+Object.getOwnPropertySymbols(obj); // [Symbol(foo)]
+</pre>
+
+<h3 id="Właściwości_nieprzeliczalne_oraz_te_z_łańcucha_prototypów_nie_są_kopiowane">Właściwości nieprzeliczalne oraz te z łańcucha prototypów nie są kopiowane</h3>
+
+<pre class="brush: js">var obj = Object.create({ foo: 1 }, { // foo jest właściwością prototypu obiektu obj
+  bar: {
+    value: 2  // bar jest nieprzeliczalną właściwością
+  },
+  baz: {
+    value: 3,
+    enumerable: true  // baz jest własną, przeliczalną właściwością obiektu obj
+  }
+});
+
+var kopia = Object.assign({}, obj);
+console.log(kopia); // { baz: 3 }
+</pre>
+
+<h3 id="Wartości_podstawowe_zostaną_włożone_do_ich_wrapperów">Wartości podstawowe zostaną włożone do ich wrapperów</h3>
+
+<pre class="brush: js">var v1 = 'abc';
+var v2 = true;
+var v3 = 10;
+var v4 = Symbol('foo');
+
+var obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
+// Wartości podstawowe będą we wrapperach, null i undefined zostaną zignorowane.
+// Zauważ, że jedynie wrapper string'a ma przeliczalne właściwości:
+console.log(obj); // { "0": "a", "1": "b", "2": "c" }
+</pre>
+
+<h3 id="Wyjątki_przerwą_wykonywanie_kopiowania">Wyjątki przerwą wykonywanie kopiowania</h3>
+
+<pre class="brush: js">var cel = Object.defineProperty({}, 'foo', {
+  value: 1,
+  writable: false
+}); // cel.foo jest właściwością tylko do odczytu
+
+Object.assign(cel, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 });
+// TypeError: "foo" is read-only
+// Wyjątek został wyrzucony podczas próby zapisania cel.foo
+
+console.log(cel.bar);  // 2, pierwsze źródło zostało skopiowane pomyślnie
+console.log(cel.foo2); // 3, pierwsza właściwość drugiego źródła zostało skopiowana pomyślnie
+console.log(cel.foo);  // 1, tutaj został wyrzucony wyjątek
+console.log(cel.foo3); // undefined, kopiowanie dobiegło końca, foo3 nie zostanie skopiowane
+console.log(cel.baz);  // undefined, trzecie źródło również nie zostanie skopiowane
+</pre>
+
+<h3 id="Kopiowanie_operatorów_pamięci">Kopiowanie operatorów pamięci</h3>
+
+<pre class="brush: js">var obj = {
+  foo: 1,
+  get bar() {
+    return 2;
+  }
+};
+
+var kopia = Object.assign({}, obj);
+console.log(kopia);
+// { foo: 1, bar: 2 }, wartość kopia.bar jest wartością zwracaną przez metodę getter właściwości obj.bar
+
+// Funkcja przypisania kopiująca całe deskryptory:
+function completeAssign(cel, ...zrodla) {
+  zrodla.forEach(zrodlo =&gt; {
+    let deskryptory = Object.keys(zrodlo).reduce((deskryptory, klucz) =&gt; {
+      deskryptory[klucz] = Object.getOwnPropertyDescriptor(zrodlo, klucz);
+      return deskryptory;
+    }, {});
+    // domyślnie Object.assign kopiuje również przeliczalne symbole
+    Object.getOwnPropertySymbols(zrodlo).forEach(sym =&gt; {
+      let deskryptor = Object.getOwnPropertyDescriptor(zrodlo, sym);
+      if (deskryptor.enumerable) {
+        deskryptory[sym] = deskryptor;
+      }
+    });
+    Object.defineProperties(cel, deskryptory);
+  });
+  return target;
+}
+
+var kopia = completeAssign({}, obj);
+console.log(kopia);
+// { foo:1, get bar() { return 2 } }
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Ten {{Glossary("Polyfill","polyfill")}} nie wspiera właściwości-symboli, ponieważ ES5 i tak ich nie ma.</p>
+
+<pre class="brush: js">if (typeof Object.assign != 'function') {
+  Object.assign = function(target, varArgs) { // .length of function is 2
+    'use strict';
+    if (target == null) { // TypeError if undefined or null
+      throw new TypeError('Cannot convert undefined or null to object');
+    }
+
+    var to = Object(target);
+
+    for (var index = 1; index &lt; arguments.length; index++) {
+      var nextSource = arguments[index];
+
+      if (nextSource != null) { // Skip over if undefined or null
+        for (var nextKey in nextSource) {
+          // Avoid bugs when hasOwnProperty is shadowed
+          if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+            to[nextKey] = nextSource[nextKey];
+          }
+        }
+      }
+    }
+    return to;
+  };
+}
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-object.assign', 'Object.assign')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.assign', 'Object.assign')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Edge</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("45")}}</td>
+   <td>{{CompatGeckoDesktop("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatOpera("32")}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("45")}}</td>
+   <td>{{CompatGeckoMobile("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperties()")}}</li>
+ <li><a href="/pl/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Przeliczalność i własność właściwości</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/constructor/index.html b/files/pl/web/javascript/reference/global_objects/object/constructor/index.html
new file mode 100644
index 0000000000..ec5cc5bc04
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/constructor/index.html
@@ -0,0 +1,50 @@
+---
+title: Object.prototype.constructor
+slug: Web/JavaScript/Reference/Global_Objects/Object/constructor
+tags:
+  - JavaScript
+  - Object
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/constructor
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/constructor
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Określa funkcję tworzącą prototyp obiektu. Należy pamiętać, że wartość tej własności jest referencją do funkcji, a nie łańcuchem znaków zawierającym jej nazwę.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wszystkie obiekty dziedziczą własność <code>constructor</code> z ich prototypu (<code>prototype</code>):</p>
+
+<pre class="brush: js">var o = {};
+o.constructor === Object; // true
+
+var a = [];
+a.constructor === Array; // true
+
+var n = new Number(3);
+n.constructor === Number; // true
+</pre>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_konstruktora_obiektu" name="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_konstruktora_obiektu">Przykład: Wyświetlanie konstruktora obiektu</h3>
+
+<p>Poniższy przykład tworzy prototyp, <code>Drzewo</code> i obiekt tego typu <code>sosna</code>. Następnie wyświetlana jest własność <code>constructor</code> obiektu <code>Drzewo</code>.</p>
+
+<pre class="brush: js">function Drzewo(nazwa) {
+   this.nazwa=nazwa;
+}
+
+sosna = new Drzewo("sosna");
+console.log("sosna.constructor to " + sosna.constructor)
+</pre>
+
+<p>Przykład ten wyświetla:</p>
+
+<pre>sosna.constructor to function Drzewo(nazwa) {
+   this.nazwa = nazwa;
+}
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/object/freeze/index.html b/files/pl/web/javascript/reference/global_objects/object/freeze/index.html
new file mode 100644
index 0000000000..7abf0aed56
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/freeze/index.html
@@ -0,0 +1,202 @@
+---
+title: Object.freeze()
+slug: Web/JavaScript/Reference/Global_Objects/Object/freeze
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/freeze
+---
+<div>{{JSRef}}</div>
+
+<div>Metoda <code><strong>Object.freeze()</strong> </code>"zamraża" obiekt, tzn. uniemożliwia dodawania nowych właściwości do obiektu; uniemożliwia usuwanie istniejących właściwości; uniemożliwia zmianę istniejących właściwości; oraz uniemożliwia zmianę prototypu obiektu. W efekcie obiekt jest naprawdę stały. Metoda zwraca obiekt w stanie "zamrożonym".</div>
+
+<div> </div>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Object.freeze(<var>obj</var>)</code></pre>
+
+<h3 id="Argumenty">Argumenty</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>Obiekt który ma zostać "zamrożony".</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>"Zamrożony" obiekt.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Nic nie może zostać dodane ani usunięte z "zamrożonego" obiektu. Każda próba tego wywoła błąd, albo po cichu, albo rzucając wyjątek {{jsxref("TypeError")}}(zawzwyczaj, choć nie zawsze, w przypadku używania {{jsxref("Strict_mode", "strict mode", "", 1)}}).</p>
+
+<p>Nie ma możliwości zmiany wartości właściwości obiektu. Metody dostępu (gettery i settery) działają bez zmian (sprawiają wrażenie skutecznej zmiany właściwości obiektu). Zwróć uwagę na to, że wartości, które są obiektami w dalszym ciągu mogą być modyfikowane, chyba że również są "zamrożone". Z uwagi na to, że Tablica (Array) jest obiektem, również może zostać zamrożona co uniemożliwi zmianę jej elementów, ich usuwanie oraz dodawanie nowych. </p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<p> </p>
+
+<h3 id="Zamrażanie_Obiektów">Zamrażanie Obiektów</h3>
+
+<p> </p>
+
+<pre class="brush: js">var obj = {
+  prop: function() {},
+  foo: 'bar'
+};
+
+// Nowe właściwości mogą być dodawane, istniejące mogą być zmieniane oraz usuwane
+obj.foo = 'baz';
+obj.lumpy = 'woof';
+delete obj.prop;
+
+// Zarówno obiekt przekazywany w funkcji freeze() jak i obiekt zwracany bedą "zamrożone"
+// Nie ma potrzeby przypisywania zwracanego obiektu do zmiennej jeśli chcemy tylko "zamrozić" obiekt przekazywany w funkcji
+var o = Object.freeze(obj);
+
+o === obj; // true
+Object.isFrozen(obj); // === true
+
+// Teraz wszelkie zmiany są niemożliwe
+obj.foo = 'quux'; // brak rezultatu nieskutkujący wyświetleniem błędu
+obj.quaxxor = 'the friendly duck'; // brak rezultatu nieskutkujący wyświetleniem błędu
+
+// przy strict mode tego typu próby spowodują wyświetlenie komunikatu o błędzie
+function fail(){
+  'use strict';
+  obj.foo = 'sparky'; // TypeError
+  delete obj.quaxxor; // TypeError
+  obj.sparky = 'arf'; // TypeError
+}
+
+fail();
+
+// Próby zmian poprzez Object.defineProperty spowodują wyświetlenie komunikatu o błędzie
+Object.defineProperty(obj, 'ohai', { value: 17 }); // TypeError
+Object.defineProperty(obj, 'foo', { value: 'eit' }); // TypeError
+
+// Niemożliwa jest również zmiana prototypu obiektu. Obie instrukcje poniżej wygenerują błąd
+Object.setPrototypeOf(obj, { x: 20})
+obj.__proto__ = { x: 20}
+</pre>
+
+<h3 id="Zamrażanie_Tablic_(Array)">Zamrażanie Tablic (Array)</h3>
+
+<p> </p>
+
+<pre class="brush: js"><code>let a = [0];
+Object.freeze(a); // Tablica nie może być teraz modyfikowana
+
+a[0]=1; // brak rezultatu nieskutkujący wyświetleniem błędu
+a.push(2); // brak rezultatu nieskutkujący wyświetleniem błędu
+
+// </code>przy strict mode tego typu próby spowodują wyświetlenie komunikatu o błędzie<code> TypeErrors
+function fail() {
+  "use strict"
+  a[0] = 1;
+  a.push(2);
+}
+
+fail();</code></pre>
+
+<p>"Zamrożony" obiekt jest <em>niemutowalny</em>. Nie jest on jednak <em>stałą</em>. Obrazuje to poniższy przykład.</p>
+
+<pre class="brush: js"><code>obj1 = {
+  internal: {}
+};
+
+Object.freeze(obj1);
+obj1.internal.a = 'aValue';
+
+obj1.internal.a // 'aValue'</code>
+</pre>
+
+<p> </p>
+
+<p>To be a constant object, the entire reference graph (direct and indirect references to other objects) must reference only immutable frozen objects.  The object being frozen is said to be immutable because the entire object <em>state </em>(values and references to other objects) within the whole object is fixed.  Note that strings, numbers, and booleans are always immutable and that Functions and Arrays are objects. </p>
+
+<p>To make an object constant, recursively freeze each property which is of type object (deep freeze).  Use the pattern on a case-by-case basis based on your design when you know the object contains no <em><a href="https://en.wikipedia.org/wiki/Cycle_(graph_theory)">cycles</a> </em>in the reference graph, otherwise an endless loop will be triggered.   An enhancement to deepFreeze() would be to have an internal function that receives a path (e.g. an Array) argument so you can supress calling deepFreeze() recursively when an object is in the process of being made constant.  You still run a risk of freezing an object that shouldn't be frozen, such as [window].</p>
+
+<pre class="brush: js"><code>// To do so, we use this function.
+function deepFreeze(obj) {
+
+  // Retrieve the property names defined on obj
+  var propNames = Object.getOwnPropertyNames(obj);
+
+  // Freeze properties before freezing self
+  propNames.forEach(function(name) {
+    var prop = obj[name];
+
+    // Freeze prop if it is an object
+    if (typeof prop == 'object' &amp;&amp; prop !== null)
+      deepFreeze(prop);
+  });
+
+  // Freeze self (no-op if already frozen)
+  return Object.freeze(obj);
+}
+
+obj2 = {
+  internal: {}
+};
+
+deepFreeze(obj2);
+obj2.internal.a = 'anotherValue';
+obj2.internal.a; // unde</code></pre>
+
+<p> </p>
+
+<p> </p>
+
+<h2 id="Notes">Notes</h2>
+
+<p>In ES5, if the argument to this method is not an object (a primitive), then it will cause a {{jsxref("TypeError")}}. In ES2015, a non-object argument will be treated as if it were a frozen ordinary object, and be simply returned.</p>
+
+<pre class="brush: js">&gt; Object.freeze(1)
+TypeError: 1 is not an object // ES5 code
+
+&gt; Object.freeze(1)
+1                             // ES2015 code
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.9', 'Object.freeze')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-object.freeze', 'Object.freeze')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.freeze', 'Object.freeze')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>
+<p>{{Compat("javascript.builtins.Object.freeze")}}</p>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html b/files/pl/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
new file mode 100644
index 0000000000..7ab7948ccc
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
@@ -0,0 +1,122 @@
+---
+title: Object.getOwnPropertyDescriptor()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/getOwnPropertyDescriptor
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>Object.getOwnPropertyDescriptor()</strong></code> zwraca deskryptor definiujący stan właściwości (właściwość musi być zdefiniowana bezpośrednio na obiekcie, ponieważ metoda nie sprawdza właściwości w łańcuchu prototypów obiektu) dla podanego obiektu.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Object.getOwnPropertyDescriptor(<var>obj</var>, <var>prop</var>)</code></pre>
+
+<h3 id="Argumenty">Argumenty</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>Obiekt, w którym będzie poszukiwana właściwość.</dd>
+ <dt><code>prop</code></dt>
+ <dd>Nazwa właściwości, dla której będzie pobrany deskryptor.</dd>
+</dl>
+
+<h3 id="Wartość_zwracana">Wartość zwracana</h3>
+
+<p>Jeżeli obiekt posiada podaną właściwość, wówczas zostanie zwrócony jej deskryptor, w przeciwnym razie zostanie zwrócony {{jsxref("undefined")}}.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Metoda ta pozwala na dokładne zbadanie stanu właściwości. W rzeczywistości właściwość obiektu w JavaScript to nie tylko jej nazwa oraz wartość ale również odpowiadający jej deskryptor. Więcej informacji o atrybutach deskryptora można znaleźć w {{jsxref("Object.defineProperty()")}}.</p>
+
+<p>Deskryptor właściwości jest obiektem zawierającym poniższe atrybuty:</p>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>Wartość związana z odpowiadającą właściwością (tylko dla deskryptorów danych).</dd>
+ <dt><code><strong>writable</strong></code></dt>
+ <dd>Jeżeli <code>true</code> odpowiadająca wartość właściwości może być zmieniona (tylko dla deskryptorów danych).</dd>
+ <dt><code>get</code></dt>
+ <dd>Funkcja, która zwraca getter dla odpowiadającej właściwości lub {{jsxref("undefined")}} jeżeli getter nie występuje (tylko dla deskryptorów dostępowych).</dd>
+ <dt><code>set</code></dt>
+ <dd>Funkcja, która zwraca setter dla odpowiadającej właściwości lub {{jsxref("undefined")}} jeżeli setter nie występuje (tylko dla deskryptorów dostępowych).</dd>
+ <dt><code>configurable</code></dt>
+ <dd>Jeżeli <code>true</code> odpowiadająca wartość właściwości może być zmieniona (również ich rodzaj - z właściwości danych na właściwość funkcji dostępowych, i odwrotnie) oraz usunięta z odopowiadającego obiektu.</dd>
+ <dt><code>enumerable</code></dt>
+ <dd>Jeżeli <code>true</code> odpowiadająca wartość właściwości będzie dostępna podczas iteracji po właściwosciach odpowiadającego obiektu.</dd>
+</dl>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<pre class="brush: js">var o, d;
+
+o = { get foo() { return 17; } };
+d = Object.getOwnPropertyDescriptor(o, 'foo');
+// d is { configurable: true, enumerable: true, get: /*the getter function*/, set: undefined }
+
+o = { bar: 42 };
+d = Object.getOwnPropertyDescriptor(o, 'bar');
+// d is { configurable: true, enumerable: true, value: 42, writable: true }
+
+o = {};
+Object.defineProperty(o, 'baz', { value: 8675309, writable: false, enumerable: false });
+d = Object.getOwnPropertyDescriptor(o, 'baz');
+// d is { value: 8675309, writable: false, enumerable: false, configurable: false }
+</pre>
+
+<h2 id="Uwagi">Uwagi</h2>
+
+<p>W ES5, jeżeli pierwszy argument dla podanej metody nie jest obiektem (jest typem prostym), wówczas zostanie wyrzucony wyjątek {{jsxref("TypeError")}}. Natomiast w ES2015, na typie prymitywnym najpierw zostanie wykonana koercja do obiektu.</p>
+
+<pre class="brush: js">Object.getOwnPropertyDescriptor('foo', 0);
+// TypeError: "foo" is not an object  // ES5 code
+
+Object.getOwnPropertyDescriptor('foo', 0);
+// {configurable:false, enumerable:true, value:"f", writable:false}  // ES2015 code
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.3', 'Object.getOwnPropertyDescriptor')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarkowa">Kompatybilność przeglądarkowa</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.getOwnPropertyDescriptor")}}</p>
+</div>
+</div>
+
+<p> </p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/hasownproperty/index.html b/files/pl/web/javascript/reference/global_objects/object/hasownproperty/index.html
new file mode 100644
index 0000000000..3a05d6d5ae
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/hasownproperty/index.html
@@ -0,0 +1,151 @@
+---
+title: Object.prototype.hasOwnProperty()
+slug: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/hasOwnProperty
+---
+<div>{{JSRef("Global_Objects", "Object")}}</div>
+
+<h2 id="Summary" name="Summary">Wstęp</h2>
+
+<p>Metoda <code><strong>hasOwnProperty()</strong></code> zwraca wartość <code>true</code> jeśli obiekt, na którym została wywołana posiada konkretną własność.</p>
+
+<h2 id="Syntax" name="Syntax">Składnia</h2>
+
+<pre class="syntaxbox notranslate"><code><var>obj</var>.hasOwnProperty(<var>prop</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parametry</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Nazwa ({{jsxref("String")}}) własności lub <a href="https://developer.mozilla.org/en-US/docs/Glossary/Symbol">Symbol</a>, do sprawdzenia.</dd>
+</dl>
+
+<h3 id="Wartość_zwracana">Wartość zwracana</h3>
+
+<p><span class="tlid-translation translation"><span class="alt-edited">A {{jsxref ("Boolean")}} wskazujący, czy obiekt zawiera w sobie określoną właściwość.</span></span></p>
+
+<h2 id="Description" name="Description">Opis</h2>
+
+<p>Każdy obiekt pochodzący od {{jsxref("Global_Objects/Object", "Object")}} dziedziczy metodę <code>hasOwnProperty</code>. Może być ona użyta do stwierdzenia czy obiekt posiada określoną własność, jako bezpośrednią (direct) własność. W przeciwieństwie do  operatora {{jsxref("Operators/in", "in")}}, metoda <code style="font-style: normal;">hasOwnProperty</code> nie sprawdza <u>w głąb łańcucha</u> własności obiektu.</p>
+
+<h2 id="Examples" name="Examples">Notatka</h2>
+
+<p><span class="tlid-translation translation"><span title=""><code>hasOwnProperty</code> zwraca <code>true</code>, nawet jeśli wartość właściwości to <code>null</code> lub <code>undefined</code>.</span></span></p>
+
+<pre class="brush: js line-numbers  language-js notranslate"><code class="language-js">o <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Object</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+o<span class="punctuation token">.</span>propOne <span class="operator token">=</span> <span class="keyword token">null</span><span class="punctuation token">;</span>
+o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'propOne'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>   <span class="comment token">// zwraca true</span>
+o<span class="punctuation token">.</span>propTwo <span class="operator token">=</span> undefined<span class="punctuation token">;</span>
+o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'propTwo'</span><span class="punctuation token">)</span><span class="punctuation token">;   // zwraca true</span></code>
+</pre>
+
+<h2 id="Examples" name="Examples">Przykłady</h2>
+
+<h3 id="Example_Using_hasOwnProperty_to_test_for_a_property.27s_existence" name="Example:_Using_hasOwnProperty_to_test_for_a_property.27s_existence">Użycie <code>hasOwnProperty</code> do testowania istnienia własności</h3>
+
+<p>Poniższy przykład określa czy obiekt <code>o</code> posiada własność o nazwie <code>prop</code>:</p>
+
+<pre class="brush: js line-numbers  language-js notranslate"><code class="language-js">o <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Object</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'prop'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>   <span class="comment token">// zwraca false</span>
+o<span class="punctuation token">.</span>prop <span class="operator token">=</span> <span class="string token">'istnieje'</span><span class="punctuation token">;</span>
+o<span class="punctuation token">.</span><span class="function token">hasOwnProperty</span><span class="punctuation token">(</span><span class="string token">'prop'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>   <span class="comment token">// zwraca true</span></code></pre>
+
+<h3 id="Example_Direct_versus_inherited_properties" name="Example:_Direct_versus_inherited_properties">Własności bezpośrednie kontra odziedziczone</h3>
+
+<p>Poniższy przykład rozróżnia bezpośrednie właściwości z właściwościami dziedziczonymi w łańcuchu prototypów:</p>
+
+<pre class="brush: js notranslate">o = new Object();
+o.prop = 'istnieje';
+o.hasOwnProperty('prop');             // zwraca true
+o.hasOwnProperty('toString');         // zwraca false
+o.hasOwnProperty('hasOwnProperty');   // zwraca false
+</pre>
+
+<h3 id="Example_Itarate_over_properties_not_considering_inherited_properties" name="Example:_Itarate_over_properties_not_considering_inherited_properties">Iterowanie przez właściwości obiektu</h3>
+
+<p><span class="tlid-translation translation"><span title="">Poniższy przykład ilustruje sposób iteracji po właściwościach obiektu bez wykonywania iteracji na dziedziczonych właściwościach.</span></span></p>
+
+<pre class="notranslate">const obj = {
+  prop: 'Wartość',
+  secondProp: 'Wartość 2'
+}
+
+for (const name in obj) {
+  if (obj.hasOwnProperty(name)) {
+    console.log('Znaleziono własność ' + name + ' o wartości ' + obj[name])
+  } else {
+    console.log('Brak własności: ', name)
+  }
+}</pre>
+
+<div class="blockIndicator warning">
+<p><span class="tlid-translation translation"><span title="">Zwróć uwagę, że pętla </span></span>{{jsxref("Statements/for...in", "for...in")}}<span class="tlid-translation translation"><span title=""> tylko iteruje właściwości przeliczalne</span></span>, a <a href="http://zduck.com/2013/non-enumerable-properties-in-javascript/">nieprzeliczanych</a> nie zauważa.</p>
+</div>
+
+<h3 id="Używanie_hasOwnProperty_jako_nazwy_właściwości"><span class="tlid-translation translation"><span title="">Używanie <code>hasOwnProperty</code> jako nazwy właściwości</span></span></h3>
+
+<p><span class="tlid-translation translation"><span title="">JavaScript nie chroni nazwy właściwości <code>hasOwnProperty</code>;</span> <span title="">tak więc, jeśli istnieje możliwość, że obiekt może mieć właściwość o tej nazwie, konieczne jest użycie zewnętrznej właściwości <code>hasOwnProperty</code>, aby uzyskać poprawne wyniki:</span></span></p>
+
+<pre class="brush: js notranslate">const obj = {
+  hasOwnProperty: function() {
+    return false;
+  },
+  prop: 'Kolejna właściwość'
+};
+
+obj.hasOwnProperty('prop'); // zawsze zwróci false
+
+// <span class="tlid-translation translation"><span class="alt-edited">Użyj właściwości hasOwnProperty innego obiektu i wywołaj ją, ustawiając "this" na obj</span></span>
+({}).hasOwnProperty.call(obj, 'prop'); // zwraca true
+
+// <span class="tlid-translation translation"><span title="">W tym celu można również użyć własności hasOwnProperty z prototypu Object</span></span>
+Object.prototype.hasOwnProperty.call(obj, 'prop'); // zwraca true
+</pre>
+
+<p><span class="tlid-translation translation"><span title="">Zwróć uwagę, że w ostatnim przypadku nie ma żadnych nowo utworzonych obiektów.</span></span></p>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 3rd Edition.</td>
+   <td>Standard</td>
+   <td>Initial definition. Implemented in JavaScript 1.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.5', 'Object.prototype.hasOwnProperty')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div class="hidden">
+<p><span class="tlid-translation translation"><span title="">Tabela zgodności na tej stronie jest generowana na podstawie danych strukturalnych.</span> <span title="">Jeśli chcesz przyczynić się do danych, sprawdź <a href="/pl/docs/">https://github.com/mdn/browser-compat-data</a> i wyślij nam pull request'a.</span></span></p>
+</div>
+
+<div>{{Compat("javascript.builtins.Object.hasOwnProperty")}}</div>
+
+<h2 id="See_also" name="See_also">Zobacz także</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+ <li>{{jsxref("Statements/for...in", "for...in")}}</li>
+ <li>{{jsxref("Operators/in", "in")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_Revisited">JavaScript Guide: Inheritance revisited</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/index.html b/files/pl/web/javascript/reference/global_objects/object/index.html
new file mode 100644
index 0000000000..e5df7e69c3
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/index.html
@@ -0,0 +1,213 @@
+---
+title: Object
+slug: Web/JavaScript/Reference/Global_Objects/Object
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/Object
+original_slug: Web/JavaScript/Referencje/Obiekty/Object
+---
+<div>{{JSRef}}</div>
+
+<p>Konstruktor <strong>Object</strong> tworzy wrapper obiektu.</p>
+
+<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia</h2>
+
+<pre class="syntaxbox"><code>// Notacja literałowa
+{ [ <var>paraWartoscNazwa1</var>[, <var>paraWartoscNazwa2</var>[, ...<var>paraWartoscNazwaN</var>] ] ] }
+
+// Wywoływany jako konstruktor
+new Object([<var>wartosc</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code><var>paraWartoscNazwa1</var>, <var>paraWartoscNazwa2</var>, ... <var>paraWartoscNazwaN</var></code></dt>
+ <dd>Pary nazw (string) oraz wartości (jakakolwiek wartość) przyczym nazwa oddzielona jest od wartości dwukropkiem.</dd>
+ <dt><code><var>wartosc</var></code></dt>
+ <dd>Jakakolwiek wartość.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Kostruktor obiektu tworzy wrapper dla danej wartości. Jeżeli podana wartość to {{jsxref("null")}} albo {{jsxref("undefined")}}, konstruktor stworzy i zwróci pusty obiekt. W przeciwnym razie stworzy i zwróci obiekt o takim samym typie jak podana wartość. Jeżeli podana wartość jest obiektem to konstruktor zwróci ten właśnie obiekt.</p>
+
+<p>Zobacz również <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">Inicjator obiektu / notacja literałowa</a>.</p>
+
+<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Właściwości</h2>
+
+<dl>
+ <dt><code>Object.length</code></dt>
+ <dd>Przyjmuje wartość 1.</dd>
+ <dt>{{jsxref("Object.prototype")}}</dt>
+ <dd>Pozwala na dodawanie właściwości i metod do wszystkich obiektów typu Object.</dd>
+</dl>
+
+<h2 id="Metody" name="Metody">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("Object.assign()")}}</dt>
+ <dd>Kopiuje wszystkie <strong>własne </strong>właściwości z jednego lub więcej obiektów żródłowych do obiektu docelowego.</dd>
+ <dt>{{jsxref("Object.create()")}}</dt>
+ <dd>Tworzy nowy obiekt z podanym prototypem oraz właściwościami</dd>
+ <dt>{{jsxref("Object.defineProperty()")}}</dt>
+ <dd>Dodaje do obiektu wymienioną właściwość opisywaną przez podany deskryptor.</dd>
+ <dt>{{jsxref("Object.defineProperties()")}}</dt>
+ <dd>Dodaje do obiektu wymienione właściwości opisywane przez podane deskryptory.</dd>
+ <dt>{{jsxref("Object.freeze()")}}</dt>
+ <dd>Zamraża obiekt. Uniemożliwia usuwanie oraz modyfikowanie jego właściwości.</dd>
+ <dt>{{jsxref("Object.getOwnPropertyDescriptor()")}}</dt>
+ <dd>Zwraca z obiektu deskryptor dla wymienionej właściwości. </dd>
+ <dt>{{jsxref("Object.getOwnPropertyNames()")}}</dt>
+ <dd>Zwraca tablicę zawierającą nazwy wszystkich <strong>własnych</strong> właściwości obiektu. (Zarówno przeliczalnych jak i nieprzeliczalnych)</dd>
+ <dt>{{jsxref("Object.getOwnPropertySymbols()")}}</dt>
+ <dd>Zwraca tablicę zawierającą wszystkie <strong>własne</strong> właściwości-symbole danego obiektu</dd>
+ <dt>{{jsxref("Object.getPrototypeOf()")}}</dt>
+ <dd>Zwraca prototyp określonego obiektu.</dd>
+ <dt>{{jsxref("Object.is()")}}</dt>
+ <dd>Sprawdza czy dwie podane wartości są takie same.</dd>
+ <dt>{{jsxref("Object.isExtensible()")}}</dt>
+ <dd>Sprawdza czy obiekt można rozszerzyć.</dd>
+ <dt>{{jsxref("Object.isFrozen()")}}</dt>
+ <dd>Sprawdza czy obiekt jest zamrożony.</dd>
+ <dt>{{jsxref("Object.isSealed()")}}</dt>
+ <dd>Sprawdza czy obiekt jest zapieczętowany.</dd>
+ <dt>{{jsxref("Object.keys()")}}</dt>
+ <dd>Zwraca tablicę zawierającą nazwy wszystkich <strong>własnych</strong> właściwości obiektu. (Tylko przeliczalnych)</dd>
+ <dt>{{jsxref("Object.preventExtensions()")}}</dt>
+ <dd>Zabopiega rozszerzaniu obiektu (tj. dodawaniu właściwości).</dd>
+ <dt>{{jsxref("Object.seal()")}}</dt>
+ <dd>Zapieczętowuje obiekt, zapobiegając dodawaniu oraz usuwaniu jego właściwości.</dd>
+ <dt>{{jsxref("Object.setPrototypeOf()")}}</dt>
+ <dd>Ustawia prototyp obiektu.</dd>
+ <dt>{{jsxref("Object.values()")}} {{experimental_inline}}</dt>
+ <dd>Zwraca tablicę zawierającą wszystkie <strong>własne</strong>, przeliczalne wartości obiektu.</dd>
+</dl>
+
+<h2 id="Instancje_i_prototyp_Object">Instancje i prototyp <code>Object</code></h2>
+
+<p>W Javascript, wsyzstkie obiekty pochodzą od obiektu <code>Object</code>, tymsamym dziedziczą metody i właściwości z {{jsxref("Object.prototype")}}, jednak mogą być one nadpisane. Na przykład, prototypy innych konstruktorów nadpisują właściwość <code>constructor</code> oraz metody <code>toString</code><code>()</code>. Wszelkie zmiany w prototypie <code>Object</code> są przekazywane do wszystkich obiektów, chyba że właściwości lub metody do których zmiany się odnośiły zostały gdzieś po drodze nadpisane.</p>
+
+<h3 id="Właściwości">Właściwości</h3>
+
+<div>{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Object/prototype', 'W.C5.82asno.C5.9Bci') }}</div>
+
+<h3 id="Metody_2">Metody</h3>
+
+<div>{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Object/prototype', 'Metody') }}</div>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_typów_null_i_undefined">Używanie <font face="Consolas, Liberation Mono, Courier, monospace">typów</font> <code>null</code> i <code>undefined</code></h3>
+
+<p>W poniższych przykładach zmienna o przechowuje pusty obiekt <code>Object</code>:</p>
+
+<pre class="brush: js">var o = new Object();
+</pre>
+
+<pre class="brush: js">var o = new Object(undefined);
+</pre>
+
+<pre class="brush: js">var o = new Object(null);
+</pre>
+
+<h3 id="Tworzenie_obiektu_Boolean">Tworzenie obiektu <code>Boolean</code></h3>
+
+<p>W poniższych przykładach zmienna o przechowuje obiekty {{jsxref("Boolean")}}:</p>
+
+<pre class="brush: js">// równoznaczne z: o = new Boolean(true);
+var o = new Object(true);
+</pre>
+
+<pre class="brush: js">// równoznaczne z: o = new Boolean(false);
+var o = new Object(Boolean());
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Początkowa definicja. Zaimplementowana w JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2', 'Object')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object-objects', 'Object')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Dodano Object.assign, Object.getOwnPropertySymbols, Object.setPrototypeOf, Object.is</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object-objects', 'Object')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Dodano Object.entries, Object.values oraz Object.getOwnPropertyDescriptors.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li><a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">Inicjalizator obiektu</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/proto/index.html b/files/pl/web/javascript/reference/global_objects/object/proto/index.html
new file mode 100644
index 0000000000..72951af19a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/proto/index.html
@@ -0,0 +1,194 @@
+---
+title: Object.prototype.__proto__
+slug: Web/JavaScript/Reference/Global_Objects/Object/proto
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/proto
+---
+<div class="warning">
+<p><strong>Ostrzeżenie:</strong> Zmiana <code>[[Prototype]]</code> obiektu, ze względu na sposób w jaki współczesny JavaScript optymalizuje dostęp do właściwości, jest bardzo powolną operacją (W każdej przeglądarce!). Efekty modyfikacji łańcucha dziedziczenia są rozległe, nie chodzi tu tylko o wydłużenie czasu potrzebnego na wykonanie operacji <code>obj.__proto__ = ...</code>, skutki wpływają na <strong>każdy</strong> fragment kodu który odwołuje się do <strong>jakiejkolwiek</strong> właściwości obiektu, którego <code>[[Prototype]]</code> został zmieniony. Dlatego jeżeli zależy ci na wydajności powinieneś unikać tej operacji. Zamiast tego, stwórz nowy obiekt z porządanym <code>[[Prototype]]</code> za pomocą {{jsxref("Object.create()")}}.</p>
+</div>
+
+<div class="warning">
+<p><strong>Ostrzeżenie:</strong> Mimo że w dzisiejszych czasach <code>Object.prototype.__proto__</code> jest wspierany w niemal każdej przeglądarce, jego istnienie oraz zachowanie zostały ujednolicone w specyfikacji ECMAScript 2015 jedynie jako <em>legacy feature</em> aby zapewnić kompatybilność z przeglądarkami. Dla lepszego wsparcia rekomenduje się używanie {{jsxref("Object.getPrototypeOf()")}}.</p>
+</div>
+
+<div>{{JSRef}}</div>
+
+<p>Właściwość <code>__proto__</code> obiektu {{jsxref("Object.prototype")}} jest operatorem dostępu (metoda getter i setter) która operuje na wewnętrznym <code>[[Prototype]]</code> (na obiekcie lub na {{jsxref("Global_Objects/null", "null")}}) obiektu do którego się odnosi.</p>
+
+<p>Użycie <code>__proto__</code> jest kontrowersyjne i podchodzi się do niego z niechęcią. Oryginalnie nigdy nie pojawiło się w specyfikacji EcmaScript, ale nowoczesne przeglądarki postanowiły mimo wszystko to zaimplementować. Dopiero niedawno właściwość <code>__proto__</code> znalazła swoje miejsce w specyfikacji ECMAScript 2015 aby zapewnić kompatybilność z tymi przeglądarkami. Jest ona jednak przestarzała ze względu na {{jsxref("Object.getPrototypeOf")}}/{{jsxref("Reflect.getPrototypeOf")}} oraz {{jsxref("Object.setPrototypeOf")}}/{{jsxref("Reflect.setPrototypeOf")}} (choć modyfikowanie <code>[[Prototype]]</code> wciąż jest operacją powolną, która powinna być unikana przez wzgląd na wydajność).</p>
+
+<p><code>Właściwość __proto__</code> może być również używana w notacji literałowej aby ustawić <code>[[Prototype]]</code> tworzonego obiektu, jako alterantywa do {{jsxref("Object.create()")}}. Zobacz: <a href="/pl/docs/Web/JavaScript/Reference/Operators/Object_initializer">inicjalizator obiektu / notacja literałowa</a>.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="brush: js">var Kolo = function () {};
+var ksztalt = {};
+var kolo = new Kolo();
+
+// Ustawianie prototypu obiektu
+// ZDEPRECJONOWANE. Używamy tego tylko dla przykładu. NIE RÓB TEGO w prawdziwym kodzie.
+ksztalt.__proto__ = kolo;
+
+// Sprawdzenie prototypu obiektu
+console.log(ksztalt.__proto__ === kolo); // true
+</pre>
+
+<pre class="brush: js">var ksztalt = function () {};
+var p =
+{
+    a: function ()
+    {
+        console.log('aaa');
+    }
+};
+ksztalt.prototype.__proto__ = p;
+
+var kolo = new ksztalt();
+kolo.a(); // aaa
+
+console.log(ksztalt.prototype === kolo.__proto__); // true
+
+// albo
+
+var ksztalt = function () {};
+var p =
+{
+    a: function ()
+    {
+        console.log('aaa');
+    }
+};
+
+var kolo = new ksztalt();
+kolo.__proto__ = p;
+circle.a(); // aaa
+
+console.log(ksztalt.prototype === kolo.__proto__); // false
+
+// albo
+
+function ksztalt() {};
+ksztalt.prototype.a = function ()
+{
+    console.log('aaa');
+}
+var kolo = new ksztalt();
+kolo.a(); // aaa
+
+console.log(kolo.__proto__ === ksztalt.prototype); // true
+
+// albo
+
+var ksztalt = function () {};
+ksztalt.prototype.a = function ()
+{
+    console.log('aaa');
+}
+
+var kolo =
+{
+    __proto__: ksztalt.prototype
+};
+kolo.a(); // aaa
+
+console.log(kolo.__proto__ === ksztalt.prototype); // true
+</pre>
+
+<p>Uwaga: <code>__proto__</code> zapisujemy jako dwie <em>podłogi</em>, następnie pięć liter "proto", następnie dwie kolejne <em>podłogi</em>.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Metoda getter właściwości <code>__proto__</code> daje nam dostęp do wewnętrznej wartości <code>[[Prototype]]</code> obiektu. Dla obiektów stworzonych przy użyciu literału jest to {{jsxref("Object.prototype")}}. Dla tablic stworzonych przy użyciu literału jest to {{jsxref("Array.prototype")}}. Dla funkcji ta wartość to {{jsxref("Function.prototype")}}. Dla obiektów stworzonych przy użyciu <code>new Funkcja</code>, gdzie <code>Funkcja</code> to jeden z wbudowanych konstruktorów dostarczanych przez JavaScript ({{jsxref("Array")}}, {{jsxref("Boolean")}}, {{jsxref("Date")}}, {{jsxref("Number")}}, {{jsxref("Object")}}, {{jsxref("String")}}, i tak dalej — wliczając nowe konstrukotry, które mogą zostać dodane w przyszłości), ta wartość to zawsze <code>Funkcja.prototype</code>. Dla obiektów stworzonych przy użyciu <code>new Funkcja</code>, gdzie <code>Funkcja</code> to funkcja zdefiniowana w kodzie, wartość ta przyjmuje taką samą wartość jak <code>Funkcja.prototype</code>.</p>
+
+<p>Metoda setter właściwości <code>__proto__ </code>umożliwia modyfikowanie <code>[[Prototype]]</code> obiektu. W tym celu obiekt musi być roszerzalny według funkcji {{jsxref("Object.isExtensible()")}}, jeżeli nie jest {{jsxref("Global_Objects/TypeError", "TypeError")}} zostanie wyrzucony. Dostarczana wartość musi być obiektem albo typem {{jsxref("Global_Objects/null", "null")}}. Podanie jakiejkolwiek innej wartości nie zrobi nic.</p>
+
+<p>Aby zrozumieć w jaki sposób prototypy używane są do dziedziczenia, zobacz artykuł o <a href="/pl/docs/Web/JavaScript/dziedziczenie_lancuch_prototypow">dziedziczeniu oraz łańcuchu prototypów</a>.</p>
+
+<p>Właściwość <code>__proto__</code> jest prostym operatorem pamięci na {{jsxref("Object.prototype")}} składającym się z metody getter i setter. Dostęp do właściwości <code>__proto__</code> który ostatecznie konsultuje się z {{jsxref("Object.prototype")}} znajdzie tę właściwość, ale dostęp który nie konsultuje {{jsxref("Object.prototype")}} nie znajdzie jej. Jeżeli jakaś inna właściwość <code>__proto__</code> zostanie znaleziona, zanim {{jsxref("Object.prototype")}} zostanie skonsultowany, to właściwość ta przesłoni tą znalezioną w {{jsxref("Object.prototype")}}.</p>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Dołączony (normatywnie) jako jeden z dodatkowych ECMAScript <em>legacy features</em> dla przeglądarek (zauważ że specyfikacja jedynie ujednoliciła coś, co było już zaimplementowane w przeglądarkach).</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatIE("11")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Uwagi_odnośnie_kompatybilności">Uwagi odnośnie kompatybilności</h2>
+
+<p>Mimo, że specyfikacja ECMAScript 2015 określa iż wsparcie dla <code>__proto__</code> jest wymagane <em>tylko</em> dla przeglądarek internetowych (w zasadzie normatywnie), to inne środowiska równieź mogą wspierać tę funkcjonalność.</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.setPrototypeOf()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/seal/index.html b/files/pl/web/javascript/reference/global_objects/object/seal/index.html
new file mode 100644
index 0000000000..b4ec8de711
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/seal/index.html
@@ -0,0 +1,166 @@
+---
+title: Object.seal()
+slug: Web/JavaScript/Reference/Global_Objects/Object/seal
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/seal
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/seal
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <code><strong>Object.seal()</strong></code> "uszczelnia" obiekt, zabezpieczając przed dodaniem nowych właściwości oraz czyniąc wszystkie już istniejące jako niekonfigurowalne. Wartość znajdujące się już w obiekcie mogą być cały czas zmieniane tak długo dopóki posiadają atrybut <strong>writable</strong>.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Object.seal(<var>obj</var>)</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>Obiekt który powinien zostać zamknięty.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Uszczelniony obiekt.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Standardowo obiekty są {{jsxref("Object.isExtensible()", "extensible", "", 1)}} (nowe właściwości mogą być do nich dodawane). Zamknięcie obiektu zabezpiecza przed możliwością ich dodawania oraz oznacza wszystkie już obecne jako niekonfigurowalne. To skutkuje tym, że zestaw właściwości obiektu staje się niemutowalny. Sprawienie, że wszystkie właściwości są również niekonfigurowalne  zabezpiecza je przed byciem przekonwertowane na akcesory/mutatory i odwrotnie, jednak nie zapobiega to zmianie wartości. Próba usunięcia lub dodania nowych właściwości do uszczelnionego obiektu lub konwersja jakiejś właściwości do akcesorów/mutatorów zawiedzie bez wyjątku lub wywołując {{jsxref("TypeError")}} (tak jest najczęściej, choć nie całkowicie, kiedy skrypt jest w {{jsxref("Strict_mode", "strict mode", "", 1)}}).</p>
+
+<p>Łancuch prototypów pozostaje nie zmieniony, jednakże właściwość {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}} jest również niemożliwa do zmiany.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<pre class="brush: js">var obj = {
+  prop: function() {},
+  foo: 'bar'
+};
+
+// Nowe właściwości mogą być dodane,
+// istniejące - zmienione lub usunięte.
+obj.foo = 'baz';
+obj.lumpy = 'woof';
+delete obj.prop;
+
+var o = Object.seal(obj);
+
+o === obj; // true
+Object.isSealed(obj); // === true
+
+// Zmiana wartości na zamkniętym obiekcie nadal działa.
+obj.foo = 'quux';
+
+// Jednak nie możesz zmienić właściwości obieku do akcesorów i odwrotnie
+Object.defineProperty(obj, 'foo', { get: function() { return 'g'; } }); // throws a TypeError
+
+// W tym momencie jakiekolwiek inne zmiany właściwości obiektu zawiodą
+obj.quaxxor = 'the friendly duck'; // nie doda właściwości, nie rzucając wyjątku
+delete obj.foo; // nie usunie właściwości, nie rzucając wyjątku
+
+// ...w trybie strict takie operacje będą rzucać wyjątkami.
+function fail() {
+  'use strict';
+  delete obj.foo; // rzuca TypeError
+  obj.sparky = 'arf'; // rzuca TypeError
+}
+fail();
+
+// Próba dodania właściwości przez Object.defineProperty zawiedzie
+Object.defineProperty(obj, 'ohai', { value: 17 }); // rzuca TypeError
+Object.defineProperty(obj, 'foo', { value: 'eit' }); // zmienia istniejącą wartość
+</pre>
+
+<h2 id="Uwagi">Uwagi</h2>
+
+<p>W ES5, jeżeli argumentem metody nie jest obiekt (jest to prymitywna struktura), spowoduje to wywołanie {{jsxref("TypeError")}}. W ES6, argument nie będący obiektem zostanie potraktowany jakby już był uszczelnionym, zwykłym obiektem i będzie zwrócony.</p>
+
+<pre class="brush: js">Object.seal(1);
+// TypeError: 1 is not an object (ES5 code)
+
+Object.seal(1);
+// 1                             (ES6 code)
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.8', 'Object.seal')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Wstępna definicja. Implementowano w  JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.seal', 'Object.seal')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_w_przeglądarkach">Kompatybilność w przeglądarkach</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("6")}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12")}}</td>
+   <td>{{CompatSafari("5.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/tolocalestring/index.html b/files/pl/web/javascript/reference/global_objects/object/tolocalestring/index.html
new file mode 100644
index 0000000000..e8187f90e3
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/tolocalestring/index.html
@@ -0,0 +1,36 @@
+---
+title: Object.prototype.toLocaleString()
+slug: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString
+tags:
+  - JavaScript
+  - Method
+  - Object
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/toLocaleString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący obiekt. Ta metoda najczęściej jest przysłonięta przez pochodne obiekty.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>obj</var>.toLocaleString();</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>Object</code> <code>toLocaleString</code> zwraca rezultat, który nazywamy {{jsxref("Object.toString", "toString()")}}.</p>
+
+<p>Ta metoda jest dostarczona dając obiektom generującą metodę <code>toLocaleString()</code>, nawet mimo to nie wszystkie go używają. Aktualnie, tylko <code>Array</code>, <code>Number</code> i <code>Date</code> nadpisują <code>toLocaleString</code>.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/tosource/index.html b/files/pl/web/javascript/reference/global_objects/object/tosource/index.html
new file mode 100644
index 0000000000..502cef66c7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/tosource/index.html
@@ -0,0 +1,74 @@
+---
+title: Object.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Object/toSource
+tags:
+  - JavaScript
+  - Method
+  - Non-standard
+  - Object
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca literał obiektowy reprezentujący kod źródłowy danego obiektu.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>Object.toSource();
+<var>obj</var>.toSource();
+</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>toSource()</code> zwraca następujące wartości:</p>
+
+<ul>
+ <li>dla obiektu wbudowanego {{jsxref("Object")}} metoda <code>toSource()</code> zwraca następujący ciąg znaków, wskazujący na niedostępność kodu źródłowego:
+
+  <pre class="brush: js">function Object() {
+   [native code]
+}
+</pre>
+ </li>
+ <li>dla instancji {{jsxref("Object")}} metoda <code>toSource()</code> zwraca ciąg reprezentujący ich kod źródłowy.</li>
+</ul>
+
+<p>Metoda ta zazwyczaj jest używana wewnętrznie przez interpreter JavaScriptu, a nie bezpośrednio w kodzie. Można jednak wywołać <code>toSource()</code> podczas debugowania, by zbadać zawartość danego obiektu.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_toSource" name="Przyk.C5.82ad:_Zastosowanie_toSource">Przykład: Zastosowanie <code>toSource()</code></h3>
+
+<p>Poniższy kod definiuje typ obiektowy <code>Pies</code> i tworzy instancję <code>piesek</code> jako obiekt typu <code>Pies</code>:</p>
+
+<pre class="brush: js  language-js"><code class="language-js"><span class="token keyword">function</span> </code>Pies<code class="language-js"><span class="token function"><span class="token punctuation">(</span></span></code>nazwa<code class="language-js"><span class="token punctuation">)</span> <span class="token punctuation">{</span>
+  <span class="token keyword">this</span><span class="token punctuation">.</span></code>nazwa<code class="language-js"> <span class="token operator">=</span> </code>nazwa<code class="language-js"><span class="token punctuation">;</span>
+<span class="token punctuation">}</span>
+
+</code><code>Pies</code><code class="language-js"><span class="token punctuation">.</span>prototype<span class="token punctuation">.</span>toSource <span class="token operator">=</span> <span class="token keyword">function</span> </code><code>Pies</code><code class="language-js"><span class="token function">_toSource<span class="token punctuation">(</span></span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
+  <span class="token keyword">return</span> <span class="token string">'new </span></code><code>Pies</code><code class="language-js"><span class="token string">('</span> <span class="token operator">+</span> <span class="token function">uneval<span class="token punctuation">(</span></span><span class="token keyword">this</span><span class="token punctuation">.</span>nazwa<span class="token punctuation">)</span> <span class="token operator">+</span> <span class="token string">')'</span><span class="token punctuation">;</span>
+<span class="token punctuation">}</span><span class="token punctuation">;</span>
+
+console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span><span class="token keyword">new</span> </code><code>Pies</code><code class="language-js"><span class="token punctuation">(</span><span class="token string">'Joe'</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">toSource<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // ---&gt; new </span></code> <code>Pies</code><code class="language-js"><span class="token comment">("Joe")</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Array", "Array")}} Object method.</li>
+ <li>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Boolean", "Boolean")}} Object method.</li>
+ <li>{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Date", "Date")}} Object method.</li>
+ <li>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Function", "Function")}} Object method.</li>
+ <li>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Number", "Number")}} Object method.</li>
+ <li>{{jsxref("Regexp.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/RegExp", "RegExp")}} Object method.</li>
+ <li>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/String", "String")}} Object method.</li>
+ <li>{{jsxref("Symbol.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Global_Objects/Symbol", "Symbol")}} Object method.</li>
+ <li><code>Math.toSource()</code> — Returns the String "Math".</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/tostring/index.html b/files/pl/web/javascript/reference/global_objects/object/tostring/index.html
new file mode 100644
index 0000000000..f78488b4c4
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/tostring/index.html
@@ -0,0 +1,99 @@
+---
+title: Object.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Object/toString
+tags:
+  - JavaScript
+  - Method
+  - Object
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/toString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący dany obiekt.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>obj</var>.toString()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Każdy obiekt posiada metodę <code>toString</code>, która jest wywoływana automatycznie, kiedy obiekt ma zostać przedstawiony jako wartość tekstowa, albo kiedy obiekt jest dołączany do ciągu znakowego. Poniższe przykłady wymagają, by <code>jakisPies</code> był reprezentowany jako łańcuch znaków:</p>
+
+<pre class="brush: js">console.log(jakisPies);
+console.log("jakisPies to " + jakisPies);
+</pre>
+
+<p>Domyślnie metoda <code>toString</code> jest dziedziczona przez każdy obiekt wyprowadzony z obiektu <code>Object</code>. Można przesłonić tę metodę dla własnych obiektów. Jeśli <code>toString</code> nie zostanie przesłonięta we własnych obiektach użytkownika, zwróci ona <code>[object
+ <i>typ</i>
+ ]</code>, gdzie <code>
+ <i>typ</i>
+ </code> jest typem obiektu lub nazwą funkcji konstruktora, która utworzyła ten obiekt.</p>
+
+<p>Na przykład:</p>
+
+<pre class="brush: js">var o = new Object()
+o.toString() // zwraca "[object Object]"
+</pre>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przes.C5.82anianie_domy.C5.9Blnej_metody_toString" name="Przes.C5.82anianie_domy.C5.9Blnej_metody_toString">Przesłanianie domyślnej metody <code>toString()</code></h3>
+
+<p>Można utworzyć funkcję, która będzie wywoływana zamiast domyślnej metody <code>toString()</code>. Metoda <code>toString()</code> nie pobiera żadnych argumentów i powinna zwrócić łańcuch znaków. Utworzona przez użytkownika metoda <code>toString()</code> może zwracać dowolną wartość, ale najlepiej, by przekazywała użyteczne informacje na temat obiektu.</p>
+
+<p>Poniższy kod definiuje typ obiektowy <code>Pies</code> i tworzy obiekt <code>jakisPies</code> typu <code>Pies</code>:</p>
+
+<pre class="brush: js">function Pies(nazwa,rasa,wiek,plec) {
+   this.nazwa=nazwa;
+   this.rasa=rasa;
+   this.wiek=wiek;
+   this.plec=plec;
+}
+
+jakisPies = new Pies("Szarik","owczarek niemiecki","5","samiec");</pre>
+
+<p>Jeśli wywołana zostanie metoda <code>toString</code> tego obiektu, zwrócona zostanie domyślna wartość odziedziczona po <code>Object</code>:</p>
+
+<pre class="brush: js">jakisPies.toString(); // zwraca [object Object]
+</pre>
+
+<p>Poniższy kod tworzy funkcję <code>piesToString</code>, która to funkcja będzie przesłaniać domyślną metodę <code>toString</code>. Funkcja ta tworzy łańcuch znaków zawierający każdą własność; budowany łańcuch będzie postaci "<code>własność = wartość;</code>".</p>
+
+<pre class="brush: js">function piesToString() {
+   var ret = "Pies " + this.nazwa + " to: [\n";
+   for (var prop in this)
+      ret += " " + prop + " = " + this[prop] + ";\n";
+   return ret + "]";
+}
+</pre>
+
+<p>Poniższy kod przypisuje zdefiniowaną powyżej funkcję do metody <code>toString</code> obiektów typu obiektowego Pies:</p>
+
+<pre class="brush: js">Pies.prototype.toString = piesToString;
+</pre>
+
+<p>Dzięki powyższemu kodowi za każdym razem, kiedy <code>jakisPies</code> używany jest w kontekście łańcucha znaków, interpreter JavaScriptu automatycznie wywołuje funkcję <code>piesToString</code>, która zwraca poniższy łańcuch:</p>
+
+<pre>Pies Szarik to: [
+  nazwa = Szarik;
+  rasa = owczarek niemiecki;
+  wiek = 5;
+  plec = samiec;
+]
+</pre>
+
+<p>Metoda <code>toString</code> danego obiektu jest zazwyczaj wywoływana przez interpreter JavaScriptu, ale można ją wywołać samodzielnie, jak poniżej:</p>
+
+<pre class="brush: js">var piesString = jakisPies.toString();
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/object/valueof/index.html b/files/pl/web/javascript/reference/global_objects/object/valueof/index.html
new file mode 100644
index 0000000000..a9ac36102c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/object/valueof/index.html
@@ -0,0 +1,64 @@
+---
+title: Object.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/Object/valueOf
+tags:
+  - JavaScript
+  - Method
+  - Object
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf
+original_slug: Web/JavaScript/Referencje/Obiekty/Object/valueOf
+---
+<p>{{jsRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca wartość podstawową danego obiektu.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>object</var>.valueOf()</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>JavaScript wywołuje metodę <code>valueOf()</code> by przekonwertować obiekt do wartości podstawowej. Metodę <code>valueOf</code> rzadko wykorzystuje się w pisanych programach, zazwyczaj JavaScript wywołuje ją automatycznie, kiedy oczekując wartości podstawowej napotka obiekt.</p>
+
+<p>Domyślnie metoda <code>valueOf()</code> jest dziedziczona przez każdy obiekt potomny obiektu {{jsxref("Object")}}. Każdy wbudowany obiekt jądra JavaScriptu przesłania tę metodą by zwracała właściwą wartość. Jeśli obiekt nie ma wartości podstawowej, <code>valueOf()</code> zwraca sam obiekt, który jest wyświetlany jako:</p>
+
+<pre>[object Object]
+</pre>
+
+<p>We własnych programach można oczywiście używać metody <code>valueOf</code> do konwersji obiektów na wartości podstawowe. Kiedy użytkownik tworzy własne obiekty, może przesłonić metodę <code>valueOf()</code> własną wersją.</p>
+
+<h3 id="Przes.C5.82anianie_metody_valueOf_dla_w.C5.82asnych_obiekt.C3.B3w" name="Przes.C5.82anianie_metody_valueOf_dla_w.C5.82asnych_obiekt.C3.B3w">Przesłanianie metody <code>valueOf</code> dla własnych obiektów</h3>
+
+<p>Można utworzyć funkcję, która będzie wywoływana zamiast domyślnej metody <code>valueOf</code>. Taka funkcja nie powinna mieć argumentów.</p>
+
+<p>Załóżmy, że mamy typ obiektowy <code>MojTypLiczbowy</code> i chcemy utworzyć dla niego metodę <code>valueOf</code>. Poniższy kod przypisuje zdefiniowaną przez użytkownika funkcję do metody <code>valueOf</code> obiektu:</p>
+
+<pre class="brush: js">MojTypLiczbowy.prototype.valueOf = new Function(tekstFunkcji);
+</pre>
+
+<p>Dzięki powyższej instrukcji za każdym razem, kiedy obiekt typu <code>MojTypLiczbowy</code> jest używany w kontekście wartości prostej, JavaScript automatycznie wywoła funkcję zdefiniowaną powyżej.</p>
+
+<p>Metoda <code>valueOf</code> obiektu jest zwykle wywoływana przez interpreter JavaScriptu, ale można ją wywołać samodzielnie:</p>
+
+<pre class="brush: js">mojaLiczba.valueOf();
+</pre>
+
+<h3 id="Uwaga" name="Uwaga">Uwaga</h3>
+
+<p>Obiekty używane w kontekście łańcucha znaków konwertowane są przy użyciu metody <code><a href="/pl/docs/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Object/toString">toString</a></code>, co różni się od konwertowania obiektów <code>String</code> do prostych łańcuchów znaków poprzez <code>valueOf</code>. Wszystkie obiekty posiadają konwersję do łańcucha znaków, choćby <code>[object
+ <i>typ</i>
+ ]</code>. Ale wiele obiektów nie posiada domyślnej konwersji do liczby, wartości logicznej lub funkcji.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+ <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/parsefloat/index.html b/files/pl/web/javascript/reference/global_objects/parsefloat/index.html
new file mode 100644
index 0000000000..e2187c39d8
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/parsefloat/index.html
@@ -0,0 +1,69 @@
+---
+title: parseFloat()
+slug: Web/JavaScript/Reference/Global_Objects/parseFloat
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/parseFloat
+original_slug: Web/JavaScript/Referencje/Obiekty/parseFloat
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Przetwarza argument w postaci łańcucha znaków zwracając liczbę zmiennoprzecinkową.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox">parseFloat(<em>string</em>)</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>string</code> </dt>
+ <dd>Łańcuch znaków do przetworzenia.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>parseFloat()</code> jest funkcją najwyższego poziomu, niepowiązaną z żadnym obiektem.</p>
+
+<p><code>parseFloat()</code> przetwarza argument będący łańcuchem znaków i zwraca liczbę zmiennoprzecinkową. Jeśli natknie się na znak inny niż <code>+</code>, <code>-</code>, liczbę (<code>0</code>-<code>9</code>), kropkę dziesiętną ("<code>.</code>") lub wykładnik potęgi, zwraca wartość do tego miejsca i ignoruje dany znak oraz wszystkie dalsze znaki. Dozwolone są spacje na początku i na końcu łańcucha znaków.</p>
+
+<p>Jeśli pierwszy znak nie może być przekonwertowany do liczby, <code>parseFloat()</code> zwraca <code>NaN</code>.</p>
+
+<p>W zastosowaniach arytmetycznych, wartość <code>NaN</code> nie jest liczbą w żadnej podstawie wyliczeń (ang.
+
+ <i>radix</i>
+ ). Aby stwierdzić, czy wynik <code>parseFloat</code> będzie <code>NaN</code>, można wywołać funkcję {{jsxref("isNan", "isNaN()")}}. Jeśli wartość <code>NaN</code> użyta zostanie w operacji arytmetycznej, wynikiem operacji także będzie <code>NaN</code>.</p>
+
+<p><b>Uwaga:</b> Funkcja <code>parseFloat</code> wymaga, aby punktem dziesiętnym była kropka, a nie przecinek. Zastosowanie przecinka spowoduje pominięcie części ułamkowej.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h2 id="Przyk.C5.82ad:_parseFloat_zwraca_liczb.C4.99" name="Przyk.C5.82ad:_parseFloat_zwraca_liczb.C4.99">Przykład: <code>parseFloat()</code> zwraca liczbę</h2>
+
+<p>Wszystkie poniższe przykłady zwracają 3.14.</p>
+
+<pre class="brush: js"><code>parseFloat("3.14");
+<code>parseFloat("314e-2");
+<code>parseFloat("0.0314E+2");
+<code>parseFloat("3.14 więcej znaków nienumerycznych");</code></code></code></code></pre>
+
+<h3 id="Przyk.C5.82ad:_parseFloat_zwraca_NaN" name="Przyk.C5.82ad:_parseFloat_zwraca_NaN">Przykład: <code>parseFloat()</code> zwraca NaN</h3>
+
+<p>Poniższy przykład zwraca <code>NaN</code>:</p>
+
+<pre class="brush: js"><code>parseFloat("FF2");</code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("parseInt", "parseInt()")}}</li>
+ <li>{{jsxref("Number.parseFloat()")}}</li>
+ <li>{{jsxref("Number.parseInt()")}}</li>
+ <li>{{jsxref("isNaN", "isNaN()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/parseint/index.html b/files/pl/web/javascript/reference/global_objects/parseint/index.html
new file mode 100644
index 0000000000..dad4b53ed7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/parseint/index.html
@@ -0,0 +1,113 @@
+---
+title: parseInt()
+slug: Web/JavaScript/Reference/Global_Objects/parseInt
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
+original_slug: Web/JavaScript/Referencje/Obiekty/parseInt
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Przetwarza argument w postaci łańcucha znaków i zwraca liczbę całkowitą typu
+ <i>integer</i>
+ , o zadanej podstawie.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox">parseInt(<em>string</em>, <em>radix</em>);</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>string</code> </dt>
+ <dd>Łańcuch znaków zawierający wartość do przetworzenia.</dd>
+</dl>
+
+<dl>
+ <dt><code>radix</code> </dt>
+ <dd>Liczba typu
+ <i>integer</i>
+ określająca podstawę powyższego łańcucha (np. 2 - system dwójkowy, 10 - system dziesiętny, przyp. tłum.)</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>parseInt</code> jest funkcją najwyższego poziomu i nie jest związana z żadnym obiektem.</p>
+
+<p>Funkcja <code>parseInt</code> parsuje jej pierwszy argument, łańcuch znaków, i próbuje zwrócić liczbę całkowitą typu
+
+ <i>integer</i>
+ o podanej podstawie. Na przykład, podstawa 10 oznacza że liczba w łańcuchu jest liczbą dziesiętną, podstawa 8 - ósemkową, 16 - szesnastkową (heksadecymalną), itd. Dla podstaw większych niż 10, litery alfabetu oznaczają cyfry większe niż 9. Dla przykładu, dla liczb szesnastkowych (o podstawie 16), używane są litery od A do F.</p>
+
+<p>Jeśli <code>parseInt</code> natknie się na znak nie będący cyfrą o danej podstawie, ignoruje ona ten znak i wszystkie następne znaki, a następnie zwraca wartość przetworzoną do tej pory. <code>parseInt</code> przycina liczby do wartości całkowitych. Początkowe i grupujące spacje są dozwolone.</p>
+
+<p>Jeśli podstawa nie jest podana lub jest podana jako 0, JavaScript przyjmuje:</p>
+
+<ul>
+ <li>Podstawę <code>16</code>, jeśli łańcuch wejściowy zaczyna się od "<code>0x</code>".</li>
+ <li>Podstawę <code>8</code> jeśli łańcuch wejściowy rozpoczyna się od "<code>0</code>". Ta cecha jest wycofywana.</li>
+ <li>Podstawę <code>10</code> jeśli łańcuch zaczyna się od jakiejkolwiek innej wartości.</li>
+</ul>
+
+<p>Jeśli pierwszy znak nie może być skonwertowany na liczbę, <code>parseInt</code> zwraca <code>NaN</code>.</p>
+
+<p>Dla potrzeb arytmetycznych, wartość <code>NaN</code> nie jest liczbą o żadnej podstawie. Możesz wywołać funkcję {{jsxref("isNaN", "isNaN()")}}, by stwierdzić czy wynik <code>parseInt</code> będzie <code>NaN</code>. Jeśli <code>NaN</code> jest podane do jakichkolwiek operacji arytmetycznych, wynikiem tych operacji również będzie <code>NaN</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_parseInt" name="Przyk.C5.82ad:_Zastosowanie_parseInt">Przykład: Zastosowanie <code>parseInt()</code></h3>
+
+<p>Wszystkie poniższe przykłady zwracają 15:</p>
+
+<pre class="brush: js"><code>parseInt(" 0xF, 16);
+parseInt(" F", 16);
+<code>parseInt("17", 8);
+<code>parseInt(021, 8);
+<code>parseInt(15.99, 10);
+<code><code><code><code>parseInt(<code>"FXX123", 16);</code></code></code></code></code></code></code></code></code>
+<code><code>parseInt("1111", 2);
+<code>parseInt("15*3", 10);
+parseInt("15e2", 10);
+parseInt("15px", 10);
+<code>parseInt("12", 13);</code></code></code></code></pre>
+
+<p>Wszystkie poniższe przykłady zwracają <strong><code>NaN</code></strong>:</p>
+
+<pre class="brush: js"><code>parseInt("Hello", 8); // nie jest wcale liczbą</code>
+<code>parseInt("546", 2); // te cyfry nie są używane do zapisu liczb binarnych</code></pre>
+
+<p>Wszystkie poniższe przykłady zwracają <strong>-15</strong>:</p>
+
+<pre class="brush: js"><code><code><code><code>parseInt("-F", 16);
+parseInt("-0F", 16);
+parseInt("-0XF", 16);</code></code></code></code>
+parseInt("-15.1, 10);
+parseInt(" -17", 8);
+parseInt(" -15", 10);
+parseInt("-1111", 2);
+parseInt("-15e1", 10);
+parseInt("-12", 13);
+</pre>
+
+<p>Wszystkie poniższe przykłady zwracają <strong>224</strong>:</p>
+
+<pre class="brush: js"><code><code><code><code>parseInt("0e0", 16);</code></code></code></code></pre>
+
+<p> </p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("parseFloat", "parseFloat()")}}</li>
+ <li>{{jsxref("Number.parseFloat()")}}</li>
+ <li>{{jsxref("Number.parseInt()")}}</li>
+ <li>{{jsxref("isNaN", "isNaN()")}}</li>
+ <li>{{jsxref("Number.toString()")}}</li>
+ <li>{{jsxref("Object.valueOf")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/promise/index.html b/files/pl/web/javascript/reference/global_objects/promise/index.html
new file mode 100644
index 0000000000..1227a0edab
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/promise/index.html
@@ -0,0 +1,257 @@
+---
+title: Promise
+slug: Web/JavaScript/Reference/Global_Objects/Promise
+tags:
+  - JavaScript
+  - Obietnice
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise
+original_slug: Web/JavaScript/Referencje/Obiekty/Promise
+---
+<div>{{JSRef}}</div>
+
+<p>Obiekt <strong><code>Promise</code></strong> reprezentuje ewentualne zakończenie (lub porażkę) asynchronicznej operacji i jej wartości.</p>
+
+<div class="note">
+<p>Artykuł opisuje konstruktor, metody i właściwości obiektu <code>Promise</code>. By nauczyć się jak działają obietnice i jak można ich używać zalecamy przeczytać najpierw <a href="/en-US/docs/Web/JavaScript/Guide/Using_promises">Użycie obietnic</a> . Ten konstruktor jest głównie używany do opakowania funkcji, które nie wspierają jeszcze obietnic.</p>
+</div>
+
+<div>{{EmbedInteractiveExample("pages/js/promise-constructor.html")}}</div>
+
+<p class="hidden">Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do interaktywnego projektu sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij do nas pull request.</p>
+
+<p class="hidden">Źródło tego interaktywnego przykładu jest przechowywane w repozytorium GitHub. Jeśli chcesz przyczynić się do interaktywnego projektu sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij do nas pull request.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="brush: js notranslate">new Promise( /* wykonawca */ function(resolve, reject) { ... } );</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt>wykonawca (executor)</dt>
+ <dd>Funkcja przekazywana z argumentami <code>resolve</code> i <code>reject</code>. Funkcja ta wykonywana jest natychmiast przez implementację obietnicy, przekazując funkcje <code>resolve</code> i <code>reject</code> (ta funkcja jest wywoływana, zanim konstruktor Promise zwróci utworzony obiekt). Funkcje <code>resolve</code> i <code>reject</code> , gdy są wywoływane, odpowiednio rozwiązują lub odrzucają obietnicę. Ta funkcja zwykle inicjuje pracę asynchroniczną, a następnie, po jej zakończeniu, wywołuje funkcję <code>resolve</code> w celu rozwiązania obietnicy lub odrzuca ją, jeśli wystąpił błąd. Jeśli błąd zostanie zgłoszony w tej funkcji, obietnica zostaje odrzucona. Wartość zwracana tej funkcji jest ignorowana.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p><code><strong>Promise</strong></code> jest proxy dla wartości niekoniecznie znanej, gdy jest tworzona. Pozwala na kojarzenie uchwytu z ewentualnym sukcesem lub porażką asynchroniczne akcji. Pozwala to metodom asynchronicznym zwracać wartości takie jak metody synchroniczne, zamiast natychmiastowego zwracania wartości końcowej, metoda asynchroniczna zwraca <em>obietnicę </em>dostarczenia wartości w pewnym momencie w przyszłości.</p>
+
+<p><code>Promise</code> jest dostępny w jednym z tych stanów:</p>
+
+<ul>
+ <li><em>pending</em>: stan inicjacji, ani wypełnione, ani odrzucone.</li>
+ <li><em>fulfilled</em>: operacja zakończona sukcesem.</li>
+ <li><em>rejected</em>: operacja zakończona porażką.</li>
+</ul>
+
+<p>Obowiązująca objetnica może być <em>zakończona </em>z wartością lub <em>odrzucona </em>z powodem(błędem). Kiedy dzieje się jedna z tych opcji, wywoływane są zakolejkowane, powiązane za pomocą metody <code>then</code> procedury. (Jeśli obietnica została już spełniona lub odrzucona, gdy dołączony jest odpowiedni moduł obsługi, zostanie on wywołany, więc nie ma potrzeby wyścigu między zakończeniem operacji asynchronicznej a jej obsługą).</p>
+
+<p>Tak jak w <code>{{jsxref("Promise.then", "Promise.prototype.then()")}}</code> oraz <code>{{jsxref("Promise.catch", "Promise.prototype.catch()")}}</code> gdy metoda zwróci obietnice, mogą one być łączone w łańcuchy.</p>
+
+<p><img alt="" src="https://mdn.mozillademos.org/files/8633/promises.png" style="height: 297px; width: 801px;"></p>
+
+<div class="note">
+<p><strong>Nie mylić z:</strong> Kilka innych języków ma mechanizmy leniwego oceniania i odraczania obliczeń, które nazywają również "obietnicami", np. Scheme. Obietnice w JavaScript oznaczają procesy, które już się odbywają, które mogą być powiązane z funkcjami wywołania zwrotnego. Jeśli chcesz leniwie oceniać wyrażenie, rozważ  <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">funkcje strzałkowe</a> bez argumentów: <code>f = () =&gt; <em>wyrażenie</em></code> by stworzyć leniwo oszacowane wyrażenie, i <code>f()</code> by ocenić.</p>
+</div>
+
+<div class="note">
+<p>Mówi się, że obietnica zostanie uregulowana, jeśli zostanie spełniona lub odrzucona, ale nie oczekuje na rozpatrzenie. Usłyszysz także termin <em>rozwiązany </em>używany z obietnicami - oznacza to, że obietnica jest ustalona lub "zamknięta", aby dopasować się do stanu innej obietnicy. <a href="https://github.com/domenic/promises-unwrapping/blob/master/docs/states-and-fates.md">Stany i losy</a> zawierają więcej szczegółów na temat obiecanej terminologii.</p>
+</div>
+
+<h2 id="Właściwości">Właściwości</h2>
+
+<dl>
+ <dt><code>Promise.length</code></dt>
+ <dd>Właściwość Length, której wartość wynosi zawsze 1 (liczba argumentów konstruktora).</dd>
+ <dt>{{jsxref("Promise.prototype")}}</dt>
+ <dd>Reprezentuje prototyp konstruktora <code>Promise</code>.</dd>
+</dl>
+
+<h2 id="Metody">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("Promise.all", "Promise.all(iterable)")}}</dt>
+ <dd>Zwraca obietnice, która albo kończy się sukcesem gdy wszystkie z obietnic w <code>iterable</code> się zakończą powodzeniem lub kończy sie porażką tak szybko jak jedna z obietnic skończy się porażką. Jeżeli zwrócona obietnica kończy się sukcesem jest ona wypełniana tablicą wartości z obietnic zakończonych sukcesem w takim samym układzie jak były one zdefiniowane w <code>iterable</code>. Jeżeli zwrócona obietnica zakończyła się porażką, jest ona odrzucana z Powodem z pierwszej obietnicy w <code>iterable</code>, która zakończyła się porażką. Ta metoda może być pomocna do zachowywania rezultatów różnych obietnic.</dd>
+ <dt>{{jsxref("Promise.race", "Promise.race(iterable)")}}</dt>
+ <dd>Returns a promise that fulfills or rejects as soon as one of the promises in the iterable fulfills or rejects, with the value or reason from that promise.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Promise.reject", "Promise.reject(reason)")}}</dt>
+ <dd>Returns a <code>Promise</code> object that is rejected with the given reason.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Promise.resolve", "Promise.resolve(value)")}}</dt>
+ <dd>Returns a <code>Promise</code> object that is resolved with the given value. If the value is a thenable (i.e. has a <code>then</code> method), the returned promise will "follow" that thenable, adopting its eventual state; otherwise the returned promise will be fulfilled with the value. Generally, if you don't know if a value is a promise or not, {{jsxref("Promise.resolve", "Promise.resolve(value)")}} it instead and work with the return value as a promise.</dd>
+</dl>
+
+<h2 id="Promise_prototype">Promise prototype</h2>
+
+<h3 id="Właściwości_2">Właściwości</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Properties')}}</p>
+
+<h3 id="Metody_2">Metody</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Methods')}}</p>
+
+<h2 id="Tworzenie_Promise">Tworzenie Promise</h2>
+
+<p>A <code>Promise</code> object is created using the <code>new </code>keyword and its constructor. This constructor takes as its argument a function, called the "executor function". This function should take two functions as parameters. The first of these functions (<code>resolve</code>) is called when the asynchronous task completes successfully and returns the results of the task as a value. The second (<code>reject</code>) is called when the task fails, and returns the reason for failure, which is typically an error object.</p>
+
+<pre class="brush: js notranslate">const myFirstPromise = new Promise((resolve, reject) =&gt; {
+  // do something asynchronous which eventually calls either:
+  //
+  //   resolve(someValue); // fulfilled
+  // or
+  //   reject("failure reason"); // rejected
+});
+</pre>
+
+<p>To provide a function with promise functionality, simply have it return a promise:</p>
+
+<pre class="brush: js notranslate">function myAsyncFunction(url) {
+  return new Promise((resolve, reject) =&gt; {
+    const xhr = new XMLHttpRequest();
+    xhr.open("GET", url);
+    xhr.onload = () =&gt; resolve(xhr.responseText);
+    xhr.onerror = () =&gt; reject(xhr.statusText);
+    xhr.send();
+  });
+}</pre>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Podstawowy_przykład">Podstawowy przykład</h3>
+
+<pre class="brush: js notranslate">let myFirstPromise = new Promise((resolve, reject) =&gt; {
+  // We call resolve(...) when what we were doing asynchronously was successful, and reject(...) when it failed.
+  // In this example, we use setTimeout(...) to simulate async code.
+  // In reality, you will probably be using something like XHR or an HTML5 API.
+  setTimeout(function(){
+    resolve("Success!"); // Yay! Everything went well!
+  }, 250);
+});
+
+myFirstPromise.then((successMessage) =&gt; {
+  // successMessage is whatever we passed in the resolve(...) function above.
+  // It doesn't have to be a string, but if it is only a succeed message, it probably will be.
+  console.log("Yay! " + successMessage);
+});
+</pre>
+
+<h3 id="Zaawansowany_Przykład">Zaawansowany Przykład</h3>
+
+<pre class="brush: html hidden notranslate">&lt;button id="btn"&gt;Make a promise!&lt;/button&gt;
+&lt;div id="log"&gt;&lt;/div&gt;
+</pre>
+
+<p>This small example shows the mechanism of a <code>Promise</code>. The <code>testPromise()</code> method is called each time the {{HTMLElement("button")}} is clicked. It creates a promise that will be fulfilled, using {{domxref("window.setTimeout()")}}, to the promise count (number starting from 1) every 1-3 seconds, at random. The <code>Promise()</code> constructor is used to create the promise.</p>
+
+<p>The fulfillment of the promise is simply logged, via a fulfill callback set using {{jsxref("Promise.prototype.then()","p1.then()")}}. A few logs show how the synchronous part of the method is decoupled from the asynchronous completion of the promise.</p>
+
+<pre class="brush: js notranslate">'use strict';
+var promiseCount = 0;
+
+function testPromise() {
+    let thisPromiseCount = ++promiseCount;
+
+    let log = document.getElementById('log');
+    log.insertAdjacentHTML('beforeend', thisPromiseCount +
+        ') Started (&lt;small&gt;Sync code started&lt;/small&gt;)&lt;br/&gt;');
+
+    // We make a new promise: we promise a numeric count of this promise, starting from 1 (after waiting 3s)
+    let p1 = new Promise(
+        // The resolver function is called with the ability to resolve or
+        // reject the promise
+       (resolve, reject) =&gt; {
+            log.insertAdjacentHTML('beforeend', thisPromiseCount +
+                ') Promise started (&lt;small&gt;Async code started&lt;/small&gt;)&lt;br/&gt;');
+            // This is only an example to create asynchronism
+            window.setTimeout(
+                function() {
+                    // We fulfill the promise !
+                    resolve(thisPromiseCount);
+                }, Math.random() * 2000 + 1000);
+        }
+    );
+
+    // We define what to do when the promise is resolved with the then() call,
+    // and what to do when the promise is rejected with the catch() call
+    p1.then(
+        // Log the fulfillment value
+        function(val) {
+            log.insertAdjacentHTML('beforeend', val +
+                ') Promise fulfilled (&lt;small&gt;Async code terminated&lt;/small&gt;)&lt;br/&gt;');
+        })
+    .catch(
+        // Log the rejection reason
+       (reason) =&gt; {
+            console.log('Handle rejected promise ('+reason+') here.');
+        });
+
+    log.insertAdjacentHTML('beforeend', thisPromiseCount +
+        ') Promise made (&lt;small&gt;Sync code terminated&lt;/small&gt;)&lt;br/&gt;');
+}</pre>
+
+<pre class="brush:js hidden notranslate">if ("Promise" in window) {
+  let btn = document.getElementById("btn");
+  btn.addEventListener("click",testPromise);
+} else {
+  log = document.getElementById('log');
+  log.innerHTML = "Live example not available as your browser doesn't support the &lt;code&gt;Promise&lt;code&gt; interface.";
+}
+</pre>
+
+<p>This example is started by clicking the button. You need a browser that supports <code>Promise</code>. By clicking the button several times in a short amount of time, you'll even see the different promises being fulfilled one after another.</p>
+
+<p>{{EmbedLiveSample("Advanced_Example", "500", "200")}}</p>
+
+<h2 id="Ładowanie_obrazka_z_XHR">Ładowanie obrazka z XHR</h2>
+
+<p>Another simple example using <code>Promise</code> and <code><a href="/en-US/docs/Web/API/XMLHttpRequest">XMLHttpRequest</a></code> to load an image is available at the MDN GitHub<a href="https://github.com/mdn/js-examples/tree/master/promises-test"> js-examples</a> repository. You can also <a href="https://mdn.github.io/js-examples/promises-test/">see it in action</a>. Each step is commented and allows you to follow the Promise and XHR architecture closely.</p>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-promise-objects', 'Promise')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition in an ECMA standard.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-promise-objects', 'Promise')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Zgodność_z_przeglądarkami">Zgodność z przeglądarkami</h2>
+
+<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.Promise")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Using_promises">Using promises</a></li>
+ <li><a href="http://promisesaplus.com/">Promises/A+ specification</a></li>
+ <li><a href="https://medium.com/@ramsunvtech/promises-of-promise-part-1-53f769245a53">Venkatraman.R - JS Promise (Part 1, Basics)</a></li>
+ <li><a href="https://medium.com/@ramsunvtech/js-promise-part-2-q-js-when-js-and-rsvp-js-af596232525c#.dzlqh6ski">Venkatraman.R - JS Promise (Part 2 - Using Q.js, When.js and RSVP.js)</a></li>
+ <li><a href="https://tech.io/playgrounds/11107/tools-for-promises-unittesting/introduction">Venkatraman.R - Tools for Promises Unit Testing</a></li>
+ <li><a href="http://www.html5rocks.com/en/tutorials/es6/promises/">Jake Archibald: JavaScript Promises: There and Back Again</a></li>
+ <li><a href="http://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript">Domenic Denicola: Callbacks, Promises, and Coroutines – Asynchronous Programming Patterns in JavaScript</a></li>
+ <li><a href="http://www.mattgreer.org/articles/promises-in-wicked-detail/">Matt Greer: JavaScript Promises ... In Wicked Detail</a></li>
+ <li><a href="https://www.promisejs.org/">Forbes Lindesay: promisejs.org</a></li>
+ <li><a href="https://github.com/jakearchibald/es6-promise/">Promise polyfill</a></li>
+ <li><a href="https://www.udacity.com/course/javascript-promises--ud898">Udacity: JavaScript Promises</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/proxy/index.html b/files/pl/web/javascript/reference/global_objects/proxy/index.html
new file mode 100644
index 0000000000..26c8cd88be
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/proxy/index.html
@@ -0,0 +1,402 @@
+---
+title: Proxy
+slug: Web/JavaScript/Reference/Global_Objects/Proxy
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy
+original_slug: Web/JavaScript/Referencje/Obiekty/Proxy
+---
+<div>
+<div>{{JSRef}}</div>
+</div>
+
+<p>Obiekt <strong>Proxy</strong> jest używany w celu definiowania specyficznego zachowania dla podstawowych operacji (n.p. wyszukiwanie atrybutu, przypisanie, wyliczanie, wywołanie funkcji, etc).</p>
+
+<h2 id="Terminologia">Terminologia</h2>
+
+<dl>
+ <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler">handler</a></dt>
+ <dd>Zastępczy obiekt zawierający pułapki (traps).</dd>
+ <dt>traps</dt>
+ <dd>Metody zapewniające dostęp do atrybutów. Pojęcie to jest analogiczne do pułapek w systemie operacyjnym.</dd>
+ <dt>target</dt>
+ <dd>Obiekt wirtualizowany przez proxy. Często jest używany aby magazyować dane obiektu proxy. Niezmienniki (wartości które pozostają niezmienione) dotyczące nierozszerzalności obiektu lub niekonfigurowalnnych atrybutów są weryfikowane w oparciu o <strong>target</strong>.</dd>
+</dl>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">var p = new Proxy(target, handler);
+</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>target</code></dt>
+ <dd>Docelowy obiekt (może być obiektem dowolnego typu, włącznie z wbudowanymi tablicami, funkcjami, a nawet innyi obiektami proxy) przeznaczony do opakowania przez <code>Proxy</code>.</dd>
+ <dt><code>handler</code></dt>
+ <dd>Obiekt obsługujący którego atrybuty są funkcjami definiującymi zachowanie proxy podczas wykonania na nim operacji.</dd>
+</dl>
+
+<h2 id="Metody">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("Proxy.revocable()")}}</dt>
+ <dd>Tworzy odwracalny obiekt <code>Proxy</code>.</dd>
+</dl>
+
+<h2 id="Metody_obiektu_obsługującego">Metody obiektu obsługującego</h2>
+
+<p>Obiekt obsługujący jest obiektem zastępczym zawierającym pułapki dla obieku <code>Proxy</code>.</p>
+
+<div>{{page('/pl/docs/Web/JavaScript/Referencje/Obiekty/Proxy/handler', 'Metody') }}</div>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Podstawowy_przykład">Podstawowy przykład</h3>
+
+<p>W tym prostym przykładzie liczba <code>37</code> jest zwracana jako domyślna wartość kiedy nazwa atrybutu nie istnieje w obiekcie. W tym celu użyty jest handler <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get"><code>get</code></a>.</p>
+
+<pre class="brush: js">var handler = {
+    get: function(target, name) {
+        return name in target ?
+            target[name] :
+            37;
+    }
+};
+
+var p = new Proxy({}, handler);
+p.a = 1;
+p.b = undefined;
+
+console.log(p.a, p.b); // 1, undefined
+console.log('c' in p, p.c); // false, 37
+</pre>
+
+<h3 id="Puste_proxy_przekazujące">Puste proxy przekazujące</h3>
+
+<p>W tym przykładzie używamy wbudowanego obiektu JavaScript do którego proxy przekaże wszystkie zaaplikowane na nim operacje.</p>
+
+<pre class="brush: js">var target = {};
+var p = new Proxy(target, {});
+
+p.a = 37; // operacja przekazana do obiektu target
+
+console.log(target.a); // 37. Operacja została prawidłowo przekazana
+</pre>
+
+<p>Zwróć uwagę, że ten przykład działa dla obiektów JavaScript jednak nie sprawdzi się w przypadku obiektów przeglądarki takich jak elementy DOM. <a href="/en-US/docs/">Sprawdź jedno rozwiązanie</a>.</p>
+
+<h3 id="Walidacja">Walidacja</h3>
+
+<p>Używając <code>Proxy</code>, łatwo możesz zwalidować wartości przekazywane do obiektu. Poniższy przykład używa metody obsługującej <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"><code>set</code></a>.</p>
+
+<pre class="brush: js">let validator = {
+  set: function(obj, prop, value) {
+    if (prop === 'age') {
+      if (!Number.isInteger(value)) {
+        throw new TypeError('The age is not an integer');
+      }
+      if (value &gt; 200) {
+        throw new RangeError('The age seems invalid');
+      }
+    }
+
+    // domyślnym zachowaniem jest zapisanie wartości
+    obj[prop] = value;
+
+    // oznacza pomyślne wykonanie
+    return true;
+  }
+};
+
+let person = new Proxy({}, validator);
+
+person.age = 100;
+console.log(person.age); // 100
+person.age = 'young'; // rzuca wyjątek
+person.age = 300; // rzuca wyjątek</pre>
+
+<h3 id="Rozszerzanie_konstruktora">Rozszerzanie konstruktora</h3>
+
+<p>Funkcja proxy może w łatwy sposób rozszerzyć konstruktor innym konstruktorem. W tym przykładzie użyto funkcje obsługujące <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/construct"><code>construct</code></a> oraz <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/apply"><code>apply</code></a>.</p>
+
+<pre class="brush: js">function extend(sup, base) {
+  var descriptor = Object.getOwnPropertyDescriptor(
+    base.prototype, 'constructor'
+  );
+  base.prototype = Object.create(sup.prototype);
+  var handler = {
+    construct: function(target, args) {
+      var obj = Object.create(base.prototype);
+      this.apply(target, obj, args);
+      return obj;
+    },
+    apply: function(target, that, args) {
+      sup.apply(that, args);
+      base.apply(that, args);
+    }
+  };
+  var proxy = new Proxy(base, handler);
+  descriptor.value = proxy;
+  Object.defineProperty(base.prototype, 'constructor', descriptor);
+  return proxy;
+}
+
+var Person = function(name) {
+  this.name = name;
+};
+
+var Boy = extend(Person, function(name, age) {
+  this.age = age;
+});
+
+Boy.prototype.sex = 'M';
+
+var Peter = new Boy('Peter', 13);
+console.log(Peter.sex);  // "M"
+console.log(Peter.name); // "Peter"
+console.log(Peter.age);  // 13</pre>
+
+<h3 id="Manipulacja_węzłami_DOM">Manipulacja węzłami DOM</h3>
+
+<p>Czasami konieczne jest przełączenie atrybutu lub nazwy klasy dwóch innych elementów. Poniższy przykład pokazuje wykonanie funkcją obsługującą <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"><code>set</code></a>.</p>
+
+<pre class="brush: js">let view = new Proxy({
+  selected: null
+},
+{
+  set: function(obj, prop, newval) {
+    let oldval = obj[prop];
+
+    if (prop === 'selected') {
+      if (oldval) {
+        oldval.setAttribute('aria-selected', 'false');
+      }
+      if (newval) {
+        newval.setAttribute('aria-selected', 'true');
+      }
+    }
+
+    // The default behavior to store the value
+    obj[prop] = newval;
+
+    // Indicate success
+    return true;
+  }
+});
+
+let i1 = view.selected = document.getElementById('item-1');
+console.log(i1.getAttribute('aria-selected')); // 'true'
+
+let i2 = view.selected = document.getElementById('item-2');
+console.log(i1.getAttribute('aria-selected')); // 'false'
+console.log(i2.getAttribute('aria-selected')); // 'true'</pre>
+
+<h3 id="Korekcja_wartości_i_dodatkowych_atrybutów">Korekcja wartości i dodatkowych atrybutów</h3>
+
+<p>Obiekt proxy <code>products</code> wylicza przekazaną wartość i konwertuje to tablicy w razie potrzeby. Obiekt dodatkowo obsługuje dodatkowy atrybut <code>latestBrowser</code> zarówno jako getter i setter.</p>
+
+<pre class="brush: js">let products = new Proxy({
+  browsers: ['Internet Explorer', 'Netscape']
+},
+{
+  get: function(obj, prop) {
+    // An extra property
+    if (prop === 'latestBrowser') {
+      return obj.browsers[obj.browsers.length - 1];
+    }
+
+    // The default behavior to return the value
+    return obj[prop];
+  },
+  set: function(obj, prop, value) {
+    // An extra property
+    if (prop === 'latestBrowser') {
+      obj.browsers.push(value);
+      return true;
+    }
+
+    // Convert the value if it is not an array
+    if (typeof value === 'string') {
+      value = [value];
+    }
+
+    // The default behavior to store the value
+    obj[prop] = value;
+
+    // Indicate success
+    return true;
+  }
+});
+
+console.log(products.browsers); // ['Internet Explorer', 'Netscape']
+products.browsers = 'Firefox'; // przekazano string (przez pomyłkę)
+console.log(products.browsers); // ['Firefox'] &lt;- nie ma problemu, wartość jest typu array
+
+products.latestBrowser = 'Chrome';
+console.log(products.browsers); // ['Firefox', 'Chrome']
+console.log(products.latestBrowser); // 'Chrome'</pre>
+
+<h3 id="Wyszukiwanie_elementu_tablicy_po_jego_właściwości">Wyszukiwanie elementu tablicy po jego właściwości</h3>
+
+<p>Poniższe proxy rozszerza tablicę o różne użyteczne funkcjonalności. Jak widać, można elastycznie "definiować" właściwości bez użycia <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties"><code>Object.defineProperties</code></a>. Ten przykład może być użyty aby znaleźć wiersz tabeli po jego komórce. W takim przypadku, celem będzie <a href="/en-US/docs/DOM/table.rows"><code>table.rows</code></a>.</p>
+
+<pre class="brush: js">let products = new Proxy([
+  { name: 'Firefox', type: 'browser' },
+  { name: 'SeaMonkey', type: 'browser' },
+  { name: 'Thunderbird', type: 'mailer' }
+],
+{
+  get: function(obj, prop) {
+    // domyślnym zachowaniem jest zwrócenie wartości; prop jest zwykle typu integer
+    if (prop in obj) {
+      return obj[prop];
+    }
+
+    // zwróć liczbę produktów; alias dla products.length
+    if (prop === 'number') {
+      return obj.length;
+    }
+
+    let result, types = {};
+
+    for (let product of obj) {
+      if (product.name === prop) {
+        result = product;
+      }
+      if (types[product.type]) {
+        types[product.type].push(product);
+      } else {
+        types[product.type] = [product];
+      }
+    }
+
+    // znajdź product po nazwie
+    if (result) {
+      return result;
+    }
+
+    // znajdź produkty po typie
+    if (prop in types) {
+      return types[prop];
+    }
+
+    // zwróć typy produktów
+    if (prop === 'types') {
+      return Object.keys(types);
+    }
+
+    return undefined;
+  }
+});
+
+console.log(products[0]); // { name: 'Firefox', type: 'browser' }
+console.log(products['Firefox']); // { name: 'Firefox', type: 'browser' }
+console.log(products['Chrome']); // undefined
+console.log(products.browser); // [{ name: 'Firefox', type: 'browser' }, { name: 'SeaMonkey', type: 'browser' }]
+console.log(products.types); // ['browser', 'mailer']
+console.log(products.number); // 3
+</pre>
+
+<h3 id="Pełna_lista_przykładów_pułapek">Pełna lista przykładów <code>pułapek</code></h3>
+
+<p>W celu stworzenia pełnej listy przykładów <code>pułapek</code>, w celach dydaktycznych, spróbujemy zastosować proxy na<em>nie natywnym obiekcie </em>który się szczególnie nadaje do tego typu operacji: globalny obiekt <code>docCookies</code> stworzony przez <a href="https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie/Simple_document.cookie_framework" title="https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support">"mały framework" opublikowany na stronie <code>document.cookie</code></a>.</p>
+
+<pre class="brush: js">/*
+  var docCookies = ... pobranie obiektu "docCookies" tutaj:
+  https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support
+*/
+
+var docCookies = new Proxy(docCookies, {
+  get: function (oTarget, sKey) {
+    return oTarget[sKey] || oTarget.getItem(sKey) || undefined;
+  },
+  set: function (oTarget, sKey, vValue) {
+    if (sKey in oTarget) { return false; }
+    return oTarget.setItem(sKey, vValue);
+  },
+  deleteProperty: function (oTarget, sKey) {
+    if (sKey in oTarget) { return false; }
+    return oTarget.removeItem(sKey);
+  },
+  enumerate: function (oTarget, sKey) {
+    return oTarget.keys();
+  },
+  ownKeys: function (oTarget, sKey) {
+    return oTarget.keys();
+  },
+  has: function (oTarget, sKey) {
+    return sKey in oTarget || oTarget.hasItem(sKey);
+  },
+  defineProperty: function (oTarget, sKey, oDesc) {
+    if (oDesc &amp;&amp; 'value' in oDesc) { oTarget.setItem(sKey, oDesc.value); }
+    return oTarget;
+  },
+  getOwnPropertyDescriptor: function (oTarget, sKey) {
+    var vValue = oTarget.getItem(sKey);
+    return vValue ? {
+      value: vValue,
+      writable: true,
+      enumerable: true,
+      configurable: false
+    } : undefined;
+  },
+});
+
+/* Cookies test */
+
+console.log(docCookies.my_cookie1 = 'First value');
+console.log(docCookies.getItem('my_cookie1'));
+
+docCookies.setItem('my_cookie1', 'Changed value');
+console.log(docCookies.my_cookie1);</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-objects', 'Proxy')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2016', '#sec-proxy-objects', 'Proxy')}}</td>
+   <td>{{Spec2('ES2016')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2017', '#sec-proxy-objects', 'Proxy')}}</td>
+   <td>{{Spec2('ES2017')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-objects', 'Proxy')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Proxy", 2)}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li><a class="external" href="https://www.youtube.com/watch?v=sClk6aB_CPk">"Proxies are awesome" Brendan Eich presentation at JSConf</a> (<a class="external" href="http://www.slideshare.net/BrendanEich/metaprog-5303821">slides</a>)</li>
+ <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies">ECMAScript Harmony Proxy proposal page</a> and <a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies_semantics">ECMAScript Harmony proxy semantics page</a></li>
+ <li><a class="external" href="http://soft.vub.ac.be/~tvcutsem/proxies/">Tutorial on proxies</a></li>
+ <li><a href="/en-US/docs/JavaScript/Old_Proxy_API" title="/en-US/docs/JavaScript/Old_Proxy_API">SpiderMonkey specific Old Proxy API</a></li>
+ <li>{{jsxref("Object.watch()")}} is a non-standard feature but has been supported in Gecko for a long time.</li>
+</ul>
+
+<h2 id="Licensing_note">Licensing note</h2>
+
+<p>Some content (text, examples) in this page has been copied or adapted from the <a class="external" href="http://wiki.ecmascript.org/doku.php">ECMAScript wiki</a> which content is licensed <a class="external" href="http://creativecommons.org/licenses/by-nc-sa/2.0/">CC 2.0 BY-NC-SA</a>.</p>
diff --git a/files/pl/web/javascript/reference/global_objects/proxy/proxy/apply/index.html b/files/pl/web/javascript/reference/global_objects/proxy/proxy/apply/index.html
new file mode 100644
index 0000000000..1037441e42
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/proxy/proxy/apply/index.html
@@ -0,0 +1,118 @@
+---
+title: handler.apply()
+slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Metodă
+  - Proxy
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply
+original_slug: Web/JavaScript/Referencje/Obiekty/Proxy/handler/apply
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong><code>handler.apply()</code></strong> jest pułapką na wywołanie funkcji.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/proxyhandler-apply.html", "taller")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="brush: js">var p = new Proxy(target, {
+  apply: function(target, thisArg, argumentsList) {
+  }
+});
+</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<p>Następujące parametry są przekazywane do metody <code>apply</code>. Wartością <code>this</code> jest handler.</p>
+
+<dl>
+ <dt><code>target</code></dt>
+ <dd>Obiekt, na którym została wywołana metoda.</dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Obiekt, który jest <code>this</code> w metodzie.</dd>
+ <dt><code>argumentsList</code></dt>
+ <dd>Lista argumentów, które zostały przekazane do metody.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Metoda <code>apply</code> może zwrócić dowolną wartość.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Metoda <code><strong>handler.apply</strong></code> jest pułapką na wywołanie funkcji.</p>
+
+<h3 id="Przechwycenia">Przechwycenia</h3>
+
+<p>Ta pułapka może przechwycić poniższe operacje:</p>
+
+<ul>
+ <li><code>proxy(...args)</code></li>
+ <li>{{jsxref("Function.prototype.apply()")}} i {{jsxref("Function.prototype.call()")}}</li>
+ <li>{{jsxref("Reflect.apply()")}}</li>
+</ul>
+
+<h3 id="Niezmienniki">Niezmienniki</h3>
+
+<p>Jeśli poniższe zmiemienniki są naruszone, poxy rzuci wyjątek TypeError:</p>
+
+<p><code>target</code> musi być obiektem, który da się wywołać. To znaczy, że musi być obiektem funkcyjnym.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<p>Poniższy kod przechwytuje wywołanie funkcji.</p>
+
+<pre class="brush: js">var p = new Proxy(function() {}, {
+  apply: function(target, thisArg, argumentsList) {
+    console.log('called: ' + argumentsList.join(', '));
+    return argumentsList[0] + argumentsList[1] + argumentsList[2];
+  }
+});
+
+console.log(p(1, 2, 3)); // "called: 1, 2, 3"
+                         // 6
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist', '[[Call]]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Początkowa definicja.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist', '[[Call]]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Proxy.handler.apply")}}</p>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+ <li>{{jsxref("Proxy.handler", "handler")}}</li>
+ <li>{{jsxref("Function.prototype.apply")}}</li>
+ <li>{{jsxref("Function.prototype.call")}}</li>
+ <li>{{jsxref("Reflect.apply()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/proxy/proxy/index.html b/files/pl/web/javascript/reference/global_objects/proxy/proxy/index.html
new file mode 100644
index 0000000000..0b5819767e
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/proxy/proxy/index.html
@@ -0,0 +1,79 @@
+---
+title: Proxy handler
+slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Proxy/handler
+original_slug: Web/JavaScript/Referencje/Obiekty/Proxy/handler
+---
+<div>{{JSRef}}</div>
+
+<p>Obiekt obsługujący proxy (proxy's handler object) jest obiektem zastępczym który zawiera pułapki dla obiektów {{jsxref("Proxy", "proxy", "", 1)}}.</p>
+
+<h2 id="Metody">Metody</h2>
+
+<p>Wszystkie pułapki są opcjonalne. Jeśli pułapka nie została zdefiniowana, domyślnym zachowaniem jest przekazanie operacji do obiektu docelowego.</p>
+
+<dl>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/getPrototypeOf", "handler.getPrototypeOf()")}}</dt>
+ <dd>Pułapka na {{jsxref("Object.getPrototypeOf")}}.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/setPrototypeOf", "handler.setPrototypeOf()")}}</dt>
+ <dd>Pułapka na {{jsxref("Object.setPrototypeOf")}}.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/isExtensible", "handler.isExtensible()")}}</dt>
+ <dd>Pułapka na {{jsxref("Object.isExtensible")}}.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/preventExtensions", "handler.preventExtensions()")}}</dt>
+ <dd>Pułapka na {{jsxref("Object.preventExtensions")}}.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/getOwnPropertyDescriptor", "handler.getOwnPropertyDescriptor()")}}</dt>
+ <dd>Pułapka na {{jsxref("Object.getOwnPropertyDescriptor")}}.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/defineProperty", "handler.defineProperty()")}}</dt>
+ <dd>Pułapka na {{jsxref("Object.defineProperty")}}.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/has", "handler.has()")}}</dt>
+ <dd>Pułapka na operator {{jsxref("Operators/in", "in")}}.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/get", "handler.get()")}}</dt>
+ <dd>Pułapka na pobieranie wartości atrybutu.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/set", "handler.set()")}}</dt>
+ <dd>Pułapka na ustawianie wartości atrybutu.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/deleteProperty", "handler.deleteProperty()")}}</dt>
+ <dd>Pułapka na operator {{jsxref("Operators/delete", "delete")}}.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/ownKeys", "handler.ownKeys()")}}</dt>
+ <dd>Pułapka na {{jsxref("Object.getOwnPropertyNames")}} i {{jsxref("Object.getOwnPropertySymbols")}}.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/apply", "handler.apply()")}}</dt>
+ <dd>Pułapka na wywołanie funkcji.</dd>
+ <dt>{{jsxref("Global_Objects/Proxy/handler/construct", "handler.construct()")}}</dt>
+ <dd>Pułapka na operator {{jsxref("Operators/new", "new")}}.</dd>
+</dl>
+
+<p>Niektóre niestandardowe pułapki są <a href="/en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features#Proxy">przestarzałe i zostały usunięte</a>.</p>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-object-internal-methods-and-internal-slots', 'Proxy Object Internal Methods and Internal Slots')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Początkowa definicja.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-object-internal-methods-and-internal-slots', 'Proxy Object Internal Methods and Internal Slots')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Usunięto funkcję obsługującą <code>enumerate</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Proxy.handler")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Proxy")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/rangeerror/index.html b/files/pl/web/javascript/reference/global_objects/rangeerror/index.html
new file mode 100644
index 0000000000..f9037c41a2
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/rangeerror/index.html
@@ -0,0 +1,163 @@
+---
+title: RangeError
+slug: Web/JavaScript/Reference/Global_Objects/RangeError
+translation_of: Web/JavaScript/Reference/Global_Objects/RangeError
+original_slug: Web/JavaScript/Referencje/Obiekty/RangeError
+---
+<div>{{JSRef}}</div>
+
+<p>Obiekt <code><strong>RangeError</strong></code> wskazuje na błąd, gdy wartość jest poza zakresem dozwolonych wartości.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>new RangeError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>message</code></dt>
+ <dd><code>Opcjonalne. Czytelny opis błędu.</code></dd>
+ <dt><code>fileName</code> {{non-standard_inline}}</dt>
+ <dd>Opcjonalne. Nazwa pliku zawierającego kod, któy wywołał wyjątek.</dd>
+ <dt><code>lineNumber</code> {{non-standard_inline}}</dt>
+ <dd>Opcjonalne. Numer linii kodu, gdzie wywołany został wyjątek.</dd>
+</dl>
+
+<h2 id="sect1"> </h2>
+
+<h2 id="Opis">Opis</h2>
+
+<p><code>RangeError</code> rzucany jest podczas próby przesłaniu numeru, jako argumentu do funkcji, która nie pozwala na zakresy zawierające ten numer. To może zdarzyć się podczas próby stworzenia listy (array) o niedozwolonej długości za pomocą konstruktora {{jsxref("Array")}}, lub podczas wywołania metod {{jsxref("Number.toExponential()")}}, {{jsxref("Number.toFixed()")}} lub {{jsxref("Number.toPrecision()")}} z przekazaną złą wartością.</p>
+
+<p> </p>
+
+<h2 id="Właściwości">Właściwości</h2>
+
+<dl>
+ <dt>{{jsxref("RangeError.prototype")}}</dt>
+ <dd>Pozwala na dodanie właściwości do obiektu RangeError.</dd>
+</dl>
+
+<h2 id="Metody">Metody</h2>
+
+<p><code>RangeError</code> nie posiada metod jako takich, ale dziedziczy pewne metody z łańcucha prototypów.</p>
+
+<h2 id="Instancje_RangeError"><code>Instancje RangeError</code></h2>
+
+<h3 id="Właściwości_2">Właściwości</h3>
+
+<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/RangeError/prototype', 'Właściwości')}}</div>
+
+<h3 id="Metody_2">Metody</h3>
+
+<div>{{page('pl/docs/Web/JavaScript/Referencje/Obiekty/RangeError/prototype', 'Metody')}}</div>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_RangeError">Użycie <code>RangeError</code></h3>
+
+<pre class="brush: js">var check = function(num) {
+  if (num &lt; MIN || num &gt; MAX) {
+    throw new RangeError('Parameter must be between ' + MIN + ' and ' + MAX);
+  }
+};
+
+try {
+  check(500);
+}
+catch (e) {
+  if (e instanceof RangeError) {
+    // Handle range error
+  }
+}
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.6.2', 'RangeError')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-rangeerror', 'RangeError')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Bazowe wsparcie</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Bazowe wsparcie</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Error")}}</li>
+ <li>{{jsxref("RangeError.prototype")}}</li>
+ <li>{{jsxref("Array")}}</li>
+ <li>{{jsxref("Number.toExponential()")}}</li>
+ <li>{{jsxref("Number.toFixed()")}}</li>
+ <li>{{jsxref("Number.toPrecision()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/regexp/exec/index.html b/files/pl/web/javascript/reference/global_objects/regexp/exec/index.html
new file mode 100644
index 0000000000..8385a71d92
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/regexp/exec/index.html
@@ -0,0 +1,145 @@
+---
+title: RegExp.prototype.exec()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/exec
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec
+original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/exec
+---
+<p>{{ JSRef }}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wykonuje operacje wyszukiwania danego łańcucha znaków. Wynikiem jest macierz.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>regexObj</var>.exec(<var>str</var>)</code></pre>
+
+<p> </p>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>str</code> </dt>
+ <dd>Łańcuch znaków, do którego ma być porównane wyrażenie.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jak wynika z opisu składni metoda exec może być wywołana w sposób bezpośredni (za pomocą <code>regexp.exec(str)</code>) lub pośredni (za pomocą <code>regexp(str)</code>).</p>
+
+<p>Jeśli wynik będzie pozytywny metoda <code>exec</code> zwróci macierz oraz zaktualizuje własności obiektu. W przeciwnym wypadku zostanie zwrócone <code>null</code>.</p>
+
+<p>Przejrzyj poniższy przykład:</p>
+
+<pre class="brush: js">//Znajdź pojedyncze "d" poprzedzone przez jedno lub więcej "b", po których następuje pojedyncze "d"
+//Zapamiętaj znalezione "b" oraz następujące "d"
+//Ignoruj wielkość liter
+var re=/d(b+)(d)/ig;
+var myArray = re.exec("cdbBdbsbz");
+</pre>
+
+<p>Poniższa tabela pokazuje rezultaty wygenerowane przez skrypt:</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header">Obiekt</td>
+   <td class="header">Właściwość/Indeks</td>
+   <td class="header">Opis</td>
+   <td class="header">Przykład</td>
+  </tr>
+  <tr>
+   <td rowspan="5"><code>myArray</code></td>
+   <td><code> </code></td>
+   <td>Zawartość <code>myArray</code>.</td>
+   <td><code>[ \"dbBd\", \"bB\", \"d\"') ]</code></td>
+  </tr>
+  <tr>
+   <td><code>index</code></td>
+   <td>Indeks wyszukania łańcucha znaków rozpoczynający się od 0.</td>
+   <td><code>1</code></td>
+  </tr>
+  <tr>
+   <td><code>input</code></td>
+   <td>Ciąg bazowy.</td>
+   <td><code>cdbBdbsbz</code></td>
+  </tr>
+  <tr>
+   <td><code>[0]</code></td>
+   <td>Ostatnie odnalezione znaki.</td>
+   <td><code>dbBd</code></td>
+  </tr>
+  <tr>
+   <td><code>[1], ...[<em>n</em> ]</code></td>
+   <td>Wyszukane podłańcuch w nawiasach. Liczba możliwych podłańcuch jest nieokreślona.</td>
+   <td><code>[1] = bB<br>
+    [2] = d</code></td>
+  </tr>
+  <tr>
+   <td rowspan="5"><code>myRe</code></td>
+   <td><code>lastIndex</code></td>
+   <td>Indeks, od którego rozpocząć nowe wyszukiwanie.</td>
+   <td><code>5</code></td>
+  </tr>
+  <tr>
+   <td><code>ignoreCase</code></td>
+   <td>Wskazuje czy flaga "<code>i</code>" została użyta.</td>
+   <td><code>true</code></td>
+  </tr>
+  <tr>
+   <td><code>global</code></td>
+   <td>Wskazuje czy flaga "<code>g</code>" została użyta do globalnego przeszukiwania.</td>
+   <td><code>true</code></td>
+  </tr>
+  <tr>
+   <td><code>multiline</code></td>
+   <td>Wskazuje czy flaga "<code>m</code>" została użyta do globalnego przeszukiwania.</td>
+   <td><code>false</code></td>
+  </tr>
+  <tr>
+   <td><code>source</code></td>
+   <td>Tekst wyszukiwanego łańcucha znaków.</td>
+   <td><code>d(b+)(d)</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Jeżeli twoje wyrażenie regularne korzysta z flagi "g", możesz wielokrotnie używać metody exec() aby porównać je z tym samym ciągiem znaków. W takim wypadku porównywanie rozpoczyna się od elementu zdefiniowanego jako <code>lastIndex. </code>Na przykład:</p>
+
+<pre class="brush: js  language-js"><code class="language-js"><span class="keyword token">var</span> myRe <span class="operator token">=</span> <span class="regex token">/ab*/g</span><span class="punctuation token">;</span>
+<span class="keyword token">var</span> str <span class="operator token">=</span> <span class="string token">'abbcdefabh'</span><span class="punctuation token">;</span>
+<span class="keyword token">var</span> myArray<span class="punctuation token">;</span>
+<span class="keyword token">while</span> <span class="punctuation token">(</span><span class="punctuation token">(</span>myArray <span class="operator token">=</span> myRe<span class="punctuation token">.</span><span class="function token">exec<span class="punctuation token">(</span></span>str<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">!</span><span class="operator token">==</span> <span class="keyword token">null</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  <span class="keyword token">var</span> msg <span class="operator token">=</span> <span class="string token">'Found '</span> <span class="operator token">+</span> myArray<span class="punctuation token">[</span><span class="number token">0</span><span class="punctuation token">]</span> <span class="operator token">+</span> <span class="string token">'. '</span><span class="punctuation token">;</span>
+  msg <span class="operator token">+</span><span class="operator token">=</span> <span class="string token">'Next match starts at '</span> <span class="operator token">+</span> myRe<span class="punctuation token">.</span>lastIndex<span class="punctuation token">;</span>
+  console<span class="punctuation token">.</span><span class="function token">log<span class="punctuation token">(</span></span>msg<span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="punctuation token">}</span></code></pre>
+
+<p>Skrypt ten wyświetli następujący tekst:</p>
+
+<pre>Found abb. Next match starts at 3
+Found ab. Next match starts at 9
+</pre>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_exec" name="Przyk.C5.82ad:_Zastosowanie_exec">Przykład: Zastosowanie <code>exec()</code></h3>
+
+<p>You can also use <code>exec()</code> without creating a {{jsxref("RegExp")}} object:</p>
+
+<pre class="brush: js  language-js"><code class="language-js"><span class="keyword token">var</span> matches <span class="operator token">=</span> <span class="regex token">/(hello \S+)/</span><span class="punctuation token">.</span><span class="function token">exec<span class="punctuation token">(</span></span><span class="string token">'This is a hello world!'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+console<span class="punctuation token">.</span><span class="function token">log<span class="punctuation token">(</span></span>matches<span class="punctuation token">[</span><span class="number token">1</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre>
+
+<p>This will display an alert containing 'hello world!'.</p>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="https://developer.mozilla.org//pl/docs/Web/JavaScript/Guide">JavaScript Guide</a></li>
+ <li>{{jsxref("RegExp")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/regexp/global/index.html b/files/pl/web/javascript/reference/global_objects/regexp/global/index.html
new file mode 100644
index 0000000000..db7b9adf71
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/regexp/global/index.html
@@ -0,0 +1,36 @@
+---
+title: RexExp.prototype.global
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/global
+tags:
+  - JavaScript
+  - Property
+  - Prototype
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/global
+original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/global
+---
+<div>{{JSRef("Global_Objects", "RegExp")}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Określa czy z wyrażeniem regularnym została użyta flaga "<code>g</code>".</p>
+
+<div>{{js_property_attributes(0, 0, 1)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>global</code> jest własnością pojedynczego obiektu wyrażenia regularnego.</p>
+
+<p>Wartość <code>global</code> wynosi true, jeśli użyta została flaga "<code>g</code>"; w przeciwnym przypadku będzie to wartość <code>false</code>. Flaga "<code>g</code>" wskazuje, że wyrażenie regularne powinno zostać sprawdzone w stosunku do wszystkich możliwych wyników w łańcuchu znaków.</p>
+
+<p>Tej własności nie można zmieniać bezpośrednio.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("RegExp.lastIndex")}}</li>
+ <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li>
+ <li>{{jsxref("RegExp.prototype.multiline")}}</li>
+ <li>{{jsxref("RegExp.prototype.source")}}</li>
+ <li>{{jsxref("RegExp.prototype.sticky")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/regexp/ignorecase/index.html b/files/pl/web/javascript/reference/global_objects/regexp/ignorecase/index.html
new file mode 100644
index 0000000000..5de3081dbf
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/regexp/ignorecase/index.html
@@ -0,0 +1,36 @@
+---
+title: RegExp.prototype.ignoreCase
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase
+tags:
+  - JavaScript
+  - Property
+  - RegExp
+  - protype
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase
+original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/ignoreCase
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Określa czy z wyrażeniem regularnym została użyta flaga "<code>i</code>".</p>
+
+<div>{{js_property_attributes(0, 0, 1)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>ignoreCase</code> jest własnością pojedynczego obiektu wyrażenia regularnego.</p>
+
+<p>Wartość <code>ignoreCase</code> wynosi <code>true</code>, jeśli użyta została flaga "<code>i</code>"; w przeciwnym przypadku będzie to wartość <code>false</code>. Flaga "<code>i</code>" wskazuje, że wielkość znaków ma być ignorowana podczas dokonywania porównań w łańcuchu znaków.</p>
+
+<p>Tej własności nie można zmieniać bezpośrednio.</p>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("RegExp.lastIndex")}}</li>
+ <li>{{jsxref("RegExp.prototype.global")}}</li>
+ <li>{{jsxref("RegExp.prototype.multiline")}}</li>
+ <li>{{jsxref("RegExp.prototype.source")}}</li>
+ <li>{{jsxref("RegExp.prototype.sticky")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/regexp/index.html b/files/pl/web/javascript/reference/global_objects/regexp/index.html
new file mode 100644
index 0000000000..8d3d520453
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/regexp/index.html
@@ -0,0 +1,384 @@
+---
+title: RegExp
+slug: Web/JavaScript/Reference/Global_Objects/RegExp
+tags:
+  - Constructor
+  - JavaScript
+  - RegExp
+  - Regular Expressions
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
+original_slug: Web/JavaScript/Referencje/Obiekty/RegExp
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Obiekt wyrażeń regularnych (ang. <em>regular expression</em>) zawiera wzór regularnego wyrażenia. Posiada ono właściwości i metody, które umożliwiają znalezienie lub zmianę ciągu znaków w innym ciągu znaków.</p>
+
+<p>W dodatku do właściwości pojedynczego obiektu wyrażenia regularnego, które tworzysz używając funkcji konstruktora <code>RegExp</code>, predefiniowany obiekt <code>RegExp</code> posiada własności statyczne, które są ustawione, kiedy jakiekolwiek wyrażenie regularne jest użyte.</p>
+
+<h2 id="Tworzony_przez" name="Tworzony_przez">Tworzony przez</h2>
+
+<p>Odpowiednik tekstowy lub funkcja-konstruktor <code>RegExp</code>.</p>
+
+<p>Odpowiednik tekstowy jest używany jak poniżej:</p>
+
+<pre class="brush: js"><em>/wzór/flagi</em>
+</pre>
+
+<p>Konstruktor jest używany jak poniżej:</p>
+
+<pre class="brush: js">new RegExp("<em>wzór</em>"[, "<em>flagi</em>"])
+</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>wzór</code></dt>
+ <dd>Tekst wyrażenia regularnego.</dd>
+ <dt><code>flagi</code></dt>
+ <dd>Jeśli podane, flagi mogą mieć jakąkolwiek kombinację poniższych wartości: <code>g</code> - wyszukiwanie globalne, <code>i</code> - ignoruje wielkość liter, <code>m</code> - wyszukiwanie w wielu liniach.</dd>
+</dl>
+
+<p>Zauważ, że parametry w formacie tekstowym nie używają cudzysłowu do oznaczenia ciągów znaków, kiedy parametry funkcji konstruktora używają cudzysłów. Tak, więc poniższe wyrażenia tworzą to samo wyrażenie regularne:</p>
+
+<pre class="brush: js">/ab+c/i;
+new RegExp("ab+c", "i");
+</pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Podczas użycia funkcji konstruktora, standardowe znaki ucieczki (<em>string escape rule</em>, poprzedzanie znaków specjalnych <em>backslash'’ "\" kiedy użyte w ciągu znaków) są wymagane. Na przykład poniższe dwa przykłady są identyczne:</em></p>
+
+<pre class="brush: js">re = new RegExp("\\w+");
+re = /\w+/;
+</pre>
+
+<h3 id="Znaki_specjalne_w_wyra.C5.BCeniach_regularnych" name="Znaki_specjalne_w_wyra.C5.BCeniach_regularnych">Znaki specjalne w wyrażeniach regularnych</h3>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header">Znak</td>
+   <td class="header">Znaczenie</td>
+  </tr>
+  <tr>
+   <td><code>\</code></td>
+   <td>
+    <p>Dla znaków które zwykle są traktowane dosłownie, oznacza że następny znak jest specjalny i nie ma być interpretowany standardowo.</p>
+
+    <p>Na przykład, <code>/b/</code> szuka znaku "b". Wstawiając backslash (<code>\</code>) przed b, to jest używając <code>/\b/</code>, znak staje się specjalny "znajdź granicę wyrazu".</p>
+
+    <p>-lub-</p>
+
+    <p>Dla znaków, które zwykle są traktowane jako specjalne oznacza, że następny znak jest zwykły powinien być interpretowany dosłownie.</p>
+
+    <p>Na przykład, <code>*</code> jest znakiem specjalnym oznaczającym 0 lub więcej wystąpień poprzedzającego znaku powinno być znalezionych; na przykład, <code>/a*/</code> oznacza "znajdź 0 lub więcej znaków <code>a</code>". Aby znaleźć dosłownie <code>*</code>, poprzedź ten znak backslashem (<code>\</code>), na przykład <code>/a\*/</code> znajduje "a*".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>^</code></td>
+   <td>
+    <p>Znajduje początek wejścia. Jeśli flaga wielu linii (ang. <em>multiline</em>) jest ustawiona na <em>prawda</em> (<code>true</code>), znajduje również od razu po znaku nowej linii.</p>
+
+    <p>Na przykład, <code>/^B/</code> nie znajdzie "B" w "Andrzej B" ale znajdzie "B" w "Bogusław A".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>$</code></td>
+   <td>
+    <p>Oznacza koniec wejścia. Jeśli flaga wielu linii (ang. <em>multiline</em>) jest ustawiona na <em>prawda</em> (<code>true</code>), znajduje również bezpośrednio przed znakiem końca linii.</p>
+
+    <p>Na przykład, <code>/a$/</code> nie znajdzie "a" w "mrówkojad" ale znajdzie "a" w "mrówka".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>*</code></td>
+   <td>
+    <p>Znajduje poprzedzającą pozycję 0 lub więcej razy.</p>
+
+    <p>Na przykład, <code>/bu*/</code> znajdzie "buuuu" w "Duch krzyknął buuuu" i "b" w "Głośnik zabrzmiał basowo" ale nic w "Ptak zaśpiewał".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>+</code></td>
+   <td>
+    <p>Znajduje poprzedzającą pozycję 1 lub więcej razy. Równoważne do <code>{1,}</code>.</p>
+
+    <p>Na przykład, <code>/r+/</code> dopasuje się do "r" w "cukierek" i do wszystkich "r" w "cukierrrrrrrek".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>?</code></td>
+   <td>
+    <p>Znajduje poprzedzającą pozycję 0 razy lub 1 raz.</p>
+
+    <p>Na przykład <code>/o?ąt?/</code> znajdzie "oł" w "anioł" i "ąt" w "kąt".</p>
+
+    <p>Jeśli zostanie użyte zaraz po którymś ze znaków *, +, ?, lub {}, to wymusza przejście do trybu niezachłannego (domyślne jest dopasowanie zachłanne), czyli dopasowanie następuje do najmniejszego ciągu spełniającego wyrażenie, a nie do największego.</p>
+
+    <p>Pytajnik używany jest także w <em>lookahead assertions</em>, opisanych pod <code>(?=)</code>, <code>(?!)</code> i <code>(?:)</code> w tej tabeli.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>.</code></td>
+   <td>
+    <p>(Kropka) znajduje jakikolwiek pojedynczy znak poza znakiem nowej linii.</p>
+
+    <p>Na przykład, <code>/.a/</code> znajdzie "ja" i "na" w "jabłko rośnie na drzewie ale arbuz nie", ale nie znajdzie "al" i "ar".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>(x)</code></td>
+   <td>
+    <p>Znajduje "x" i zapamiętuje to dopasowanie. Nazywa się to "nawiasy wychwytujące" (ang. <em>capturing parentheses</em>).</p>
+
+    <p>Na przykład, <code>/(foo)/</code> znajduje i zapamiętuje "foo" w "foo bar". Znaleziony pod-ciąg (<em>substring</em>) może być ponownie wywołany elementów tablicy wynikowej <code>1, ..., n</code> jak również z predefiniowanych własności obiektu <code>RegExp</code>, <code>$1, ..., $9</code>.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>(?:x)</code></td>
+   <td>
+    <p>Znajduje "x", ale nie pamięta dopasowania. Nazywa się to "nawiasy niewychwytujące" (ang. <em>non-capturing parentheses</em>). Znaleziony podciąg (<em>substring</em>) nie może być wywołany ponownie z elementów wynikowych tablicy <code>1, ..., n</code> ani za pomocą właściwości obiektu <code>RegExp</code>, <code>$1, ..., $9</code>.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>x(?=y)</code></td>
+   <td>
+    <p>Znajduje "x", tylko wtedy, gdy zaraz po "x" jest "y". Na przykład, <code>/Jacek(?=Szprotka)/</code> znajdzie "Jacek" tylko, jeśli zaraz po tym jest wyraz "Szprotka". <code>/Jacek(?=Szprotka|Mróz)/</code> znajdzie "Jacek" tylko, jeśli po tym jest zaraz wyraz "Szprotka" lub "Mróz"). Jednakże, ani "Szprotka" ani "Mróz" nie jest częścią wyników.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>x(?!y)</code></td>
+   <td>
+    <p>Znajduje "x", tylko, jeśli po "x" nie ma "y". Na przykład, <code>/\d+(?!\,)/</code> zostanie dopasowane do liczby całkowitej, tylko jeśli nie ma po niej przecinka.</p>
+
+    <p><code>/\d+(?!\,)/.exec("3,141")</code> zostanie dopasowane tylko do 141, nie zostanie dopasowane do 3, bo wystąpił po niej przecinek.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>x|y</code></td>
+   <td>
+    <p>Znajduje "x" lub "y".</p>
+
+    <p>Na przykład, <code>/zielone|czerwone/</code> znajdzie "zielone" w "zielone jabłko" i "czerwone" w "czerwone jabłko".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>{n}</code></td>
+   <td>
+    <p>Gdzie <code>n</code> jest dodatnią liczbą całkowitą. Znajduje dokładnie <code>n</code> wystąpień poprzedzającej pozycji.</p>
+
+    <p>Na przykład, <code>/u{2}/</code> nie znajdzie "u" w "cukierek", ale znajdzie wszystkie "u" w "cuukierek" i pierwsze dwa "u" w "cuuukierek".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>{n,}</code></td>
+   <td>
+    <p>Gdzie <code>n</code> jest dodatnią liczbą całkowitą. Znajduje, co najmniej <code>n</code> wystąpień poprzedzającej pozycji.</p>
+
+    <p>Na przykład, <code>/u{2,}/</code> nie znajdzie "u" w "cukierek", ale znajdzie wszystkie "u" w "cuukierek" i w "cuuukierek".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>{n,m}</code></td>
+   <td>
+    <p>Gdzie <code>n</code> i <code>m</code> są pozytywnymi liczbami całkowitymi. Wyszukuje, co najmniej <code>n</code> i co najwyżej <code>m</code> wystąpień poprzedzającego wyrażenia.</p>
+
+    <p>Na przykład, <code>/u{1,3}/</code> nie znajdzie niczego w "ckierek", znajdzie "u" w "cukierek", znajdzie dwa "u" w "cuukierek" i pierwsze trzy "u" w "cuuuuukierek". Zauważ, że podczas wyszukiwania w "cuuuuukierek", wynik wyszukiwania to "uuu" mimo iż ciąg oryginalny zawiera więcej liter "u".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>xyz</code></td>
+   <td>
+    <p>Zestaw znaków. Wyszukuje jakikolwiek z podanych znaków. Możesz podać przedział znaków używając myślnika.</p>
+
+    <p>Na przykład, <code>abcd</code> oznacza tyle samo, co <code>a-d</code>. Wyrażenia te znajdą "b" w "buziak" i "d" w "kasza".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>^xyz</code></td>
+   <td>
+    <p>Przeciwny zestaw znaków. Wyszukuje cokolwiek, co nie jest wewnątrz nawiasów. Podobnie jak powyżej można podać zakres znaków używając myślnika.</p>
+
+    <p>Na przykład, <code>^abc</code> oznacza tyle samo, co <code>^a-c</code>. Wyrażenia te znajdą "u" w "buziak" i "k" w "kasza".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\\b</code></td>
+   <td>
+    <p>Wyszukuje znak backspace (nie mylić z <code>\b</code>).</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\b</code></td>
+   <td>
+    <p>Wyszukuje granicę wyrazów (ang. <em>word boundary</em>), jak na przykład spację (nie mylić z <code>\\b</code>).</p>
+
+    <p>Na przykład, <code>/\bn\w/</code> zaznaczy "no" w "noonday"; <code>/\wy\b/</code> zaznaczy "ly" w "possibly yesterday".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\B</code></td>
+   <td>
+    <p>Znajduje brak granicy niewyrazu (ang. <em>non-word boundary</em>).</p>
+
+    <p>Na przykład, <code>/\w\Bn/</code> zaznaczy "on" w "noonday", a <code>/y\B\w/</code> zaznaczy "ye" w "possibly yesterday".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\cX</code></td>
+   <td>
+    <p>Gdzie <code>X</code> jest literą od A do Z. Zaznacza znak kontrolny w ciągu.</p>
+
+    <p>Na przykład, <code>/\cM/</code> zaznaczy <code>control-M</code> w <em>string</em>u.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\d</code></td>
+   <td>
+    <p>Znajduje cyfrę. Odpowiednik <code>0-9</code>.</p>
+
+    <p>Na przykład, <code>/\d/</code> lub <code>/0-9/&lt;code&gt; zaznaczy "2" w "B2 jest numerem pokoju". &lt;/td&gt; &lt;/tr&gt; </code></p>
+   </td>
+  </tr>
+  <tr>
+   <td>\D</td>
+   <td>
+    <p>Wyszukuje jakikolwiek znak nieliczbowy. Odpowiednik <code>^0-9') }}</code>.</p>
+
+    <p>Na przykład, <code>/\D/</code> lub <code>/^0-9/</code> zaznaczy "B" w "B2 jest numerem pokoju".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\f</code></td>
+   <td>
+    <p>Znajduje znak wysuwu wiersza (<em>form feed</em>).</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\n</code></td>
+   <td>
+    <p>Znajduje znak następnego wiersza (<em>line feed</em>).</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\r</code></td>
+   <td>
+    <p>Znajduje znak powrotu karetki (<em>carriage return</em>).</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\s</code></td>
+   <td>
+    <p>Znajduje pojedynczy biały znak (ang. <em>white space character</em>), wliczając w to spację, tabulator, znak wysuwu wiersza, znak następnego wiersza. Odpowiednik <code>\\f\\n\\r\\t\\u00A0\\u2028\\u2029</code>.</p>
+
+    <p>Na przykład, <code>/\s\w*/</code> zaznaczy " bar" w "foo bar".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\S</code></td>
+   <td>
+    <p>Zaznacza jakikolwiek znak inny niż biały (ang. <em>white space</em>). Odpowiednik <code>^ \\f\\n\\r\\t\\u00A0\\u2028\\u2029</code>.</p>
+
+    <p>Na przykład, <code>/\S/\w*</code> zaznaczy "foo" w "foo bar".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\t</code></td>
+   <td>
+    <p>Znajduje tabulator.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\v</code></td>
+   <td>
+    <p>Znajduje pionowy tabulator (ang. <em>vertical tab</em>).</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\w</code></td>
+   <td>
+    <p>Znajduje jakikolwiek znak alfanumeryczny i znak podkreślenia <code>_</code>. Odpowiednik <code>A-Za-z0-9_</code>.</p>
+
+    <p>Na przykład, <code>/\w/</code> zaznaczy "j" w "jabłko", "5" w "??5.28", i "3" w "3D".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\W</code></td>
+   <td>
+    <p>Zaznaczy jakikolwiek znak niewyrazowy. Odpowiednik <code>^A-Za-z0-9_</code>.</p>
+
+    <p>Na przykład, <code>/\W/</code> lub <code>/^$A-Za-z0-9_/</code> znajdzie "%" w "50%".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\n</code></td>
+   <td>
+    <p>Gdzie <code>n</code> jest pozytywną liczbą całkowitą. Odwołanie wsteczne (ang. <em>back reference</em>) do ostatniego podciągu (<em>substring</em>) pasującego do n wyrażenia umieszczonego w nawiasie (licząc od nawiasu otwierającego "(").</p>
+
+    <p>Na przykład, <code>/jabłko(,)\spomarańcz\1/</code> pasuje do "jabłko, pomarańcz," w "jabłko, pomarańcz, wiśnia, brzoskwinia". Dokładniejszy przykład znajduje się po tabeli.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\0</code></td>
+   <td>
+    <p>Wyszukuje znak NUL. Bezpośrednio po <code>\0</code> nie powinna znajdować się żadna liczba.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\xhh</code></td>
+   <td>
+    <p>Znajduje znak o kodzie hh (dwie cyfry szesnastkowe)</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\uhhhh</code></td>
+   <td>
+    <p>Znajduje znak o kodzie hhhh (cztery cyfry szesnastkowe).</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Notacja tekstowa zostaje skompilowana, kiedy wyrażenie regularne jest wykonane. Używaj notacji tekstowej wtedy, kiedy wyrażenie regularne pozostanie niezmienione. Na przykład, jeśli użyjesz notacji tekstowej do konstrukcji wyrażenia regularnego w pętli, wyrażenie to nie zostanie przekompilowane podczas każdej iteracji.</p>
+
+<p>Konstruktor obiektu wyrażenia regularnego, na przykład <code>new RegExp("ab+c")</code>, pozwala na kompilację podczas czasu wykonywania (ang. <em>runtime compilation</em>) wyrażenia. Używaj funkcji konstruktora, kiedy wiesz, że wzór wyrażenia regularnego będzie się zmieniać lub gdy nie znasz tego wzoru i pobierasz go z innego źródła, jak na przykład wejście użytkownika.</p>
+
+<p>Oddzielny predefiniowany obiekt <code>RegExp</code> jest dostępny dla każdego okna, to jest każdy oddzielny wątek uruchomienia JavaScriptu dostaje jego własny obiekt <code>RegExp</code>. Jako że każdy skrypt uruchamiany jest cały w oddzielnym wątku, zapewnia to, iż oddzielne skrypty nie nadpisują wartości obiektu <code>RegExp</code>.</p>
+
+<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2>
+
+<dl>
+ <dt>{{jsxref("RegExp.prototype")}}</dt>
+ <dd>Pozwala na dodanie własności wszystkim obiektom.</dd>
+ <dt><code>RegExp.length</code></dt>
+ <dd>Wartość parametru <code>RegExp.length</code> wynosi 2.</dd>
+ <dt>{{jsxref("RegExp.lastIndex")}}</dt>
+ <dd>Indeks, od którego rozpoczynać następne szukanie.</dd>
+</dl>
+
+<h2 id="Metody" name="Metody">Metody</h2>
+
+<p>Globalny objekt <code>RegExp</code> nie posiada własnych metod, jednam może dziedziczyć metody z innych obiektów.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_replace" name="Przyk.C5.82ad:_Zastosowanie_metody_replace">Przykład: Zastosowanie metody <code>replace</code></h3>
+
+<p>Poniższy przykład używa metodę <code>replace</code> do zamiany wyrazów w ciągu (<em>stringu</em>). Podczas zamiany tekstu, skrypt używa "<code>$1</code>" i "<code>$2</code>" do oznaczenia wyników odpowiadających im nawiasów we wzorze wyrażenia regularnego.</p>
+
+<pre class="brush: js">var re = /(\w+)\s(\w+)/;
+var str = "Jan Kowalski";
+var newstr = str.replace(re, "$2, $1");
+document.write(newstr);
+</pre>
+
+<p>Wyświetli "Kowalski, Jan".</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>Rozdział w <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a> o <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a></li>
+ <li>{{jsxref("String.prototype.match()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/regexp/lastmatch/index.html b/files/pl/web/javascript/reference/global_objects/regexp/lastmatch/index.html
new file mode 100644
index 0000000000..f9f1c9a129
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/regexp/lastmatch/index.html
@@ -0,0 +1,55 @@
+---
+title: RegExp.lastMatch ($&)
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/lastMatch
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/lastMatch
+original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/lastMatch
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Niestandardowa właściwość <strong>lastMatch</strong> jest właściwością statyczną, tylko do odczytu wyrażeń regularnych, który zawiera ostatnie dopasowane znaki. <code>RegExp.$&amp;</code> jest aliasem tej właściwości.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>RegExp</var>.lastMatch
+RegExp['$&amp;']
+</pre>
+
+<h2 id="Description">Description</h2>
+
+<p>The <code>lastMatch</code> property is static, it is not a property of an individual regular expression object. Instead, you always use it as <code>RegExp.lastMatch</code> or <code>RegExp['$&amp;'].</code></p>
+
+<p>The value of the <code>lastMatch</code> property is read-only and modified whenever a successful match is made.</p>
+
+<p>You can not use the shorthand alias with the dot property accessor (<code>RegExp.$&amp;</code>), because the parser expects an expression with "&amp;" in that case and a {{jsxref("SyntaxError")}} is thrown. Use the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors">bracket notation for property access</a>.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_lastMatch_and">Using <code>lastMatch</code> and <code>$&amp;</code></h3>
+
+<pre class="brush: js">var re = /hi/g;
+re.test('hi there!');
+RegExp.lastMatch; // "hi"
+RegExp['$&amp;'];     // "hi"
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<p>Niestandardowe. Nie jest częścią aktualnej specyfikacji.</p>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.RegExp.lastMatch")}}</p>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}</li>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</li>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</li>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</li>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/regexp/source/index.html b/files/pl/web/javascript/reference/global_objects/regexp/source/index.html
new file mode 100644
index 0000000000..c508b9f257
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/regexp/source/index.html
@@ -0,0 +1,30 @@
+---
+title: RegExp.prototype.source
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/source
+tags:
+  - JavaScript
+  - Property
+  - Prototype
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/source
+original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/source
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Własność tylko do odczytu stanowiąca wzór tekstu, wykluczając przesyłanie slashy.</p>
+
+<div>{{js_property_attributes(0, 0, 1)}}</div>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>source</code> jest własnością indywidualnej instancji wyrażenia regularnego obiektu.</p>
+
+<p>Nie możesz zmienić tej własności bezpośrednio.</p>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("RegExp.prototype.flags")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/regexp/test/index.html b/files/pl/web/javascript/reference/global_objects/regexp/test/index.html
new file mode 100644
index 0000000000..8acfb1eae2
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/regexp/test/index.html
@@ -0,0 +1,54 @@
+---
+title: RegExp.prototype.test()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/test
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test
+original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/test
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wykonuje poszukiwanie łańcucha znaków pomiędzy wyrażeniem regularnym i określonym wzorcem. Zwraca <code>true</code> lub <code>false</code>.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>regexObj</var>.test(<var>str</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>str</code> </dt>
+ <dd>Łańcuch znaków w zależności od tego, czym jest wyrażenie regularne.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli chcesz wiedzieć, czy wzorzec został znaleziony w łańcuchu znaków zastosuj metodę <code>test</code> (podobną do metody {{jsxref("String.prototype.search()")}}); aby uzyskać więcej informacji (lecz powolniej wykonywana) zastosuj metodę {{jsxref("RegExp.prototype.exec()", "exec()")}}(podobną do metody {{jsxref("String.prototype.match()")}} ).</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_test" name="Przyk.C5.82ad:_Zastosowanie_test">Przykład: Zastosowanie <code>test()</code></h3>
+
+<p>Poniższy funkcja wypisuje wiadomość, której tekst zależy od powodzenia testu:</p>
+
+<pre class="brush: js">function testinput(re, str){
+   if (re.test(str)) {
+      midstring = " zawiera ";
+   } else {
+      midstring = " nie zawiera ";
+   }
+   console.log(str + midstring + re.source);
+}
+</pre>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Guide">JavaScript Guide</a></li>
+ <li>{{jsxref("RegExp")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/regexp/tosource/index.html b/files/pl/web/javascript/reference/global_objects/regexp/tosource/index.html
new file mode 100644
index 0000000000..ae5886df86
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/regexp/tosource/index.html
@@ -0,0 +1,48 @@
+---
+title: RegExp.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/toSource
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toSource
+original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/toSource
+---
+<p>{{JSRef}}{{Non-standard_header}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący kod źródłowy obiektu.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>regexObj</var>.toSource()
+</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>toSource()</code> zwraca następujące wartości:</p>
+
+<ul>
+ <li>Dla wbudowanego obiektu {{jsxref("RegExp")}}, <code>toSource()</code> zwraca następujący łańcuch znaków sygnalizujący, który kod źródłowy nie jest dostępny:
+
+  <pre class="brush: js">function RegExp() {
+   [native code]
+}
+</pre>
+ </li>
+ <li>Dla instancji {{jsxref("RegExp")}}, <code>toSource()</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li>
+</ul>
+
+<p>Ta metoda jest często nazywana wewnętrzną metodą JavaScriptu i nie jest widoczna w kodzie.</p>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/regexp/tostring/index.html b/files/pl/web/javascript/reference/global_objects/regexp/tostring/index.html
new file mode 100644
index 0000000000..b62621fa71
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/regexp/tostring/index.html
@@ -0,0 +1,47 @@
+---
+title: RegExp.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/toString
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/RegExp/toString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący określony obiekt.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>regexObj</var>.toString();</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<p>Brak.</p>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Obiekt {{jsxref("RegExp")}} przypisuje <code>toString()</code> metodzie obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektu {{jsxref("RegExp")}}, metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_toString" name="Przyk.C5.82ad:_Zastosowanie_toString">Przykład: Zastosowanie <code>toString()</code></h3>
+
+<p>Następujący przykład wyświetla wartość łańcucha znaków obiektu <code>RegExp</code>:</p>
+
+<pre class="brush: js"><code class="language-js"><span class="token keyword">var</span> myExp <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">RegExp</span><span class="token punctuation">(</span><span class="token string">'a+b+c'</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
+console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>myExp<span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment"> // </span></code><code class="language-js"><span class="token comment">wyświetli</span></code><code class="language-js"><span class="token comment"> '/a+b+c/'
+</span>
+<span class="token keyword">var</span> foo <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">RegExp</span><span class="token punctuation">(</span><span class="token string">'bar'</span><span class="token punctuation">,</span> <span class="token string">'g'</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
+console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>foo<span class="token punctuation">.</span><span class="token function">toString<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>   <span class="token comment"> // </span></code><code class="language-js"><span class="token comment">wyświetli</span></code><code class="language-js"><span class="token comment"> '/bar/g'</span></code>
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/set/add/index.html b/files/pl/web/javascript/reference/global_objects/set/add/index.html
new file mode 100644
index 0000000000..8b143212d7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/set/add/index.html
@@ -0,0 +1,135 @@
+---
+title: Set.prototype.add()
+slug: Web/JavaScript/Reference/Global_Objects/Set/add
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Method
+  - Prototype
+  - set
+translation_of: Web/JavaScript/Reference/Global_Objects/Set/add
+original_slug: Web/JavaScript/Referencje/Obiekty/Set/Set.prototype.add()
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong>add()</strong> dodaje nowy element o określonej wartości (<code>value</code>) na koniec obieku <code>Set</code>.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>mySet</em>.add(value);</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt>value</dt>
+ <dd>Wymagany parametr. Wartość elementu, która zostanie dodana do obieku <code>Set</code>.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Obiekt <code>Set</code>.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_metody_add">Użycie metody add</h3>
+
+<pre class="brush: js">var mySet = new Set();
+
+mySet.add(1);
+mySet.add(5).add('some text'); // można stworzyć "łańcuch"
+
+console.log(mySet);
+// Set [1, 5, "some text"]
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-set.prototype.add', 'Set.prototype.add')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Początkowa definicja</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype.add', 'Set.prototype.add')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("13.0")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("13.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Specyficzne_zachowania_w_przeglądarkach">Specyficzne zachowania w przeglądarkach</h2>
+
+<ul>
+ <li>W Firefox 33 {{geckoRelease("33")}} i wcześniejszych wersjach, <code>Set.prototype.add</code> zwracał <code>undefined</code> i nie można było stworzyć "łańcucha". Błąd został naprawiony ({{bug(1031632)}}). Również w Chrome/v8 występuje ten <a href="https://code.google.com/p/v8/issues/detail?id=3410">problem</a>.</li>
+</ul>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("Set.prototype.delete()")}}</li>
+ <li>{{jsxref("Set.prototype.has()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/set/clear/index.html b/files/pl/web/javascript/reference/global_objects/set/clear/index.html
new file mode 100644
index 0000000000..32df4660f3
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/set/clear/index.html
@@ -0,0 +1,125 @@
+---
+title: Set.prototype.clear()
+slug: Web/JavaScript/Reference/Global_Objects/Set/clear
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Method
+  - Prototype
+  - set
+translation_of: Web/JavaScript/Reference/Global_Objects/Set/clear
+original_slug: Web/JavaScript/Referencje/Obiekty/Set/Set.prototype.clear()
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong>clear()</strong> usuwa wszystkie elementy obiektu <code>Set</code>.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>mySet</em>.clear();</code></pre>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>{{jsxref("undefined")}}.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_metody_clear">Użycie metody clear</h3>
+
+<pre class="brush: js">var mySet = new Set();
+mySet.add(1);
+mySet.add('foo');
+
+mySet.size;       // 2
+mySet.has('foo'); // true
+
+mySet.clear();
+
+mySet.size;       // 0
+mySet.has('bar')  // false
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Początkowa definicja.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("19.0")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("19.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("Set.prototype.delete()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/set/delete/index.html b/files/pl/web/javascript/reference/global_objects/set/delete/index.html
new file mode 100644
index 0000000000..a9358078f1
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/set/delete/index.html
@@ -0,0 +1,103 @@
+---
+title: Set.prototype.delete()
+slug: Web/JavaScript/Reference/Global_Objects/Set/delete
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Method
+  - Prototype
+  - set
+translation_of: Web/JavaScript/Reference/Global_Objects/Set/delete
+original_slug: Web/JavaScript/Referencje/Obiekty/Set/Set.prototype.delete()
+---
+<div>{{JSRef}}</div>
+
+<p>Metoda <strong>delete()</strong> usuwa określony element z obiektu <code>Set</code>.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><em>mySet</em>.delete(value);</code></pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt>value</dt>
+ <dd>Wymagany parametr. Wartość elementu, która zostanie usunięta z obiektu <code>Set</code>.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p><code>true </code>jeżeli element został pomyślnie usunięty, w innym wypadku <code>false</code>.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_metody_delete">Użycie metody delete</h3>
+
+<pre class="brush: js">var mySet = new Set();
+mySet.add('foo');
+
+mySet.delete('bar'); // Zwraca false. Brak elementu "bar" do usunięca.
+mySet.delete('foo'); // Zwraca true.  Usunięto pomyślnie.
+
+mySet.has('foo');    // Zwraca false. Element "foo" nie znajduje się już w Set.
+</pre>
+
+<p>Jak usunąć obiekt z Set:</p>
+
+<pre class="brush: js">var points = new Set(); // Tworzy Set
+
+points.add({x: 10, y: 20}); // Dodaje obiekt do Set
+points.add({x: 20, y: 30}); // Dodaje obiekt do Set
+
+// Usuwa point, dla którego `x &gt; 10`
+points.forEach(function(point){
+  if(point.x &gt; 10){
+    points.delete(point);
+  }
+})
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Początkowa definicja</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<p> </p>
+
+<div class="hidden">
+<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+</div>
+
+<p>{{Compat("javascript.builtins.Set.delete")}}</p>
+
+<p> </p>
+
+<div id="compat-desktop"> </div>
+
+<div id="compat-mobile"> </div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("Set.prototype.clear()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/set/index.html b/files/pl/web/javascript/reference/global_objects/set/index.html
new file mode 100644
index 0000000000..995d238f97
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/set/index.html
@@ -0,0 +1,487 @@
+---
+title: Set
+slug: Web/JavaScript/Reference/Global_Objects/Set
+tags:
+  - ECMAScript 2015
+  - ECMAScript6
+  - Global Objects
+  - JavaScript
+  - Object
+  - set
+translation_of: Web/JavaScript/Reference/Global_Objects/Set
+original_slug: Web/JavaScript/Referencje/Obiekty/Set
+---
+<div>{{JSRef}}</div>
+
+<p>Obiekt <code><strong>Set</strong></code> umożliwia przechowywanie <em>unikalnych </em>wartości każdego typu, zarówno {{Glossary("Primitive", "primitywów")}} jak i obiektów.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">new Set([<em>iterable</em>]);</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>iterable</code></dt>
+ <dd>Jeżeli przekażesz <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of">obiekt iterowalny</a>, wszystkie jego elementy zostaną dodane do nowego <code>Set</code>. Podczas gdy nie przekażemy żadnego parametru lub wartość parametru będzie równa <em><code>null</code></em>, zostanie stworzony pusty <code>Set</code>.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>Nowy obiekt <code>Set</code>.</p>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Obiekt <code><em>Set</em></code> jest kolekcją wartości. Możesz iterować po elementach <code><em>Set</em></code> w kolejności, w której zostały dodane. Wartość w <code><em>Set</em></code> <strong>może występować tylko jeden raz</strong>.</p>
+
+<h3 id="Równość_wartości">Równość wartości</h3>
+
+<p>Dlatego, że każda wartość w <code>Set </code>musi być unikalna, musi zostać to sprawdzone. We wcześniejszych specyfikacjach ECMAScript nie było to oparte na tym samym algorytmie co w przypadku operatora ===. Konkretnie dla Set +0 (co jest tym samym co -0) i -0 były innymi wartościami. W specyfikacji ECMAScript 2015 zostało to zmienione. Zobacz "Value equality for -0 and 0" w tabeli <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Set#Kompatybilność_przeglądarek">Kompatybilność z przeglądarkami</a>.</p>
+
+<p><code>NaN</code> i <code>undefined</code> mogą być przechowywane w <code>Set</code>. <code>NaN</code> w <code>Set</code> uważane jest za równe <code>NaN</code>, podczas gdy <code>NaN !== NaN</code> zwraca <code>true</code></p>
+
+<h2 id="Własności">Własności</h2>
+
+<dl>
+ <dt><code>Set.length</code></dt>
+ <dd>Wartość <code>length</code> zawsze wynosi 0.</dd>
+ <dt>{{jsxref("Set.@@species", "get Set[@@species]")}}</dt>
+ <dd>Funkcja wykorzystywana do stworzenia pochodnych obiektów.</dd>
+ <dt>{{jsxref("Set.prototype")}}</dt>
+ <dd>Reprezentuje prototyp konstruktora <code>Set.</code> Pozwala na dodanie własności do obiektu <code>Set</code>.</dd>
+</dl>
+
+<h2 id="Instancje_Set"><font face="consolas, Liberation Mono, courier, monospace">Instancje <code>Set</code></font></h2>
+
+<p>Wszystkie instancje <code>Set</code> dziedziczą od {{jsxref("Set.prototype")}}.</p>
+
+<h3 id="Własności_2">Własności</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Properties')}}</p>
+
+<h3 id="Metody">Metody</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Methods')}}</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Użycie_obiektu_Set">Użycie obiektu <code>Set</code></h3>
+
+<pre class="brush: js">var mySet = new Set();
+
+mySet.add(1); // Set { 1 }
+mySet.add(5); // Set { 1, 5 }
+mySet.add(5); // Set { 1, 5 }
+mySet.add('some text'); // Set { 1, 5, 'some text' }
+var o = {a: 1, b: 2};
+mySet.add(o);
+
+mySet.add({a: 1, b: 2}); // o jest referencją do innego obiektu, więc dwa obiekty zostają dodane do Set.
+
+mySet.has(1); // true
+mySet.has(3); // false, 3 nie zostało dodane do Set.
+mySet.has(5);              // true
+mySet.has(Math.sqrt(25));  // true
+mySet.has('Some Text'.toLowerCase()); // true
+mySet.has(o); // true
+
+mySet.size; // 5
+
+mySet.delete(5); // Usuwa 5 z Set.
+mySet.has(5);    // false, 5 zostało usunięte.
+
+mySet.size; // 4, usuneliśmy jedną wartość.
+console.log(mySet);// Set {1, "some text", Object {a: 1, b: 2}, Object {a: 1, b: 2}}</pre>
+
+<h3 id="Iterowanie_po_Set.">Iterowanie po Set.</h3>
+
+<pre class="brush: js">// Iterowanie po items w Set.
+// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2}
+for (let item of mySet) console.log(item);
+
+// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2}
+for (let item of mySet.keys()) console.log(item);
+
+// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2}
+for (let item of mySet.values()) console.log(item);
+
+// wypisuje items w kolejności: 1, "some text", {"a": 1, "b": 2}
+//(key i value są takie same)
+for (let [key, value] of mySet.entries()) console.log(key);
+
+// zamienia Set na Array, przy użyciu Array.from
+var myArr = Array.from(mySet); // [1, "some text", {"a": 1, "b": 2}]
+
+// następujące funkcje również zadziałają, jeżeli skrypt odpalony jest w dokumencie HTML
+mySet.add(document.body);
+mySet.has(document.querySelector('body')); // true
+
+// zamiana Array na Set i na odwrót
+mySet2 = new Set([1, 2, 3, 4]);
+mySet2.size; // 4
+[...mySet2]; // [1, 2, 3, 4]
+
+// Set z wartościami, które są w set1 i set2, może być uzyskany następująco
+var intersection = new Set([...set1].filter(x =&gt; set2.has(x)));
+
+// Set z różnicami wartości set1 i set2 może być uzyskany następująco
+var difference = new Set([...set1].filter(x =&gt; !set2.has(x)));
+
+// iterowanie po Set za pomocą .forEach
+mySet.forEach(function(value) {
+  console.log(value);
+});
+// 1
+// 2
+// 3
+// 4</pre>
+
+<h3 id="Implementacja_podstawowych_operacji_Set">Implementacja podstawowych operacji <code>Set</code></h3>
+
+<pre class="brush: js">Set.prototype.isSuperset = function(subset) {
+    for (var elem of subset) {
+        if (!this.has(elem)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+Set.prototype.union = function(setB) {
+    var union = new Set(this);
+    for (var elem of setB) {
+        union.add(elem);
+    }
+    return union;
+}
+
+Set.prototype.intersection = function(setB) {
+    var intersection = new Set();
+    for (var elem of setB) {
+        if (this.has(elem)) {
+            intersection.add(elem);
+        }
+    }
+    return intersection;
+}
+
+Set.prototype.difference = function(setB) {
+    var difference = new Set(this);
+    for (var elem of setB) {
+        difference.delete(elem);
+    }
+    return difference;
+}
+
+// Przykłady
+var setA = new Set([1, 2, 3, 4]),
+    setB = new Set([2, 3]),
+    setC = new Set([3, 4, 5, 6]);
+
+setA.isSuperset(setB); // =&gt; true
+setA.union(setC); // =&gt; Set [1, 2, 3, 4, 5, 6]
+setA.intersection(setC); // =&gt; Set [3, 4]
+setA.difference(setC); // =&gt; Set [1, 2]
+
+</pre>
+
+<h3 id="Relacje_z_Tablicami_(Array)">Relacje z Tablicami (<code>Array</code>)</h3>
+
+<pre class="brush: js">var myArray = ['value1', 'value2', 'value3'];
+
+// Użycie konstruktora Set do zamiany Array na Set.
+var mySet = new Set(myArray);
+
+mySet.has('value1'); // =&gt; true
+
+// Użycie spread operator do zamiany Set na Array.
+console.log([...mySet]); // Will show you exactly the same Array as myArray</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-set-objects', 'Set')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Początkowa definicja.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set-objects', 'Set')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>
+    <p>{{ CompatChrome(38) }} [1]</p>
+   </td>
+   <td>12</td>
+   <td>{{ CompatGeckoDesktop("13") }}</td>
+   <td>{{ CompatIE("11") }}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new Set(iterable)</code></td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{ CompatGeckoDesktop("13") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>9.0</td>
+  </tr>
+  <tr>
+   <td>iterable</td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{ CompatGeckoDesktop("17") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td><code>Set.add()</code> returns the set</td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{ CompatGeckoDesktop("13") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td><code>Set.clear()</code></td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("19")}}</td>
+   <td>{{ CompatIE("11") }}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td><code>Set.keys(), Set.values(), Set.entries()</code></td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("24")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td><code>Set.forEach()</code></td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("25")}}</td>
+   <td>{{ CompatIE("11") }}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>Value equality for -0 and 0</td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("29")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>{{CompatSafari(9)}}</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new Set(null)</code></td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("37")}}</td>
+   <td>{{CompatIE(11)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatSafari(7.1)}}</td>
+  </tr>
+  <tr>
+   <td>Monkey-patched <code>add()</code> in Constructor</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("37")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatSafari(9)}}</td>
+  </tr>
+  <tr>
+   <td><code>Set[@@species]</code></td>
+   <td>{{ CompatChrome(51) }}</td>
+   <td>13</td>
+   <td>{{CompatGeckoDesktop("41")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatOpera(38) }}</td>
+   <td>{{CompatSafari(10)}}</td>
+  </tr>
+  <tr>
+   <td><code>Set()</code> without <code>new</code> throws</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop("42")}}</td>
+   <td>{{CompatIE(11)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>9</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(38)}} [1]</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{ CompatGeckoMobile("13") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new Set(iterable)</code></td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(38)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{ CompatGeckoMobile("13") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td>iterable</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{ CompatGeckoMobile("17") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td><code>Set.clear()</code></td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("19")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td><code>Set.keys(), Set.values(), Set.entries()</code></td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("24")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td><code>Set.forEach()</code></td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td>Value equality for -0 and 0</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatChrome(38) }}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("29")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new Set(null)</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("37")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>8</td>
+  </tr>
+  <tr>
+   <td>Monkey-patched <code>add()</code> in Constructor</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("37")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td><code>Set[@@species]</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("41")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>10</td>
+  </tr>
+  <tr>
+   <td><code>Set()</code> without <code>new</code> throws</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("42")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>9</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] The feature was available behind a preference from Chrome 31. In <code>chrome://flags</code>, activate the entry “Enable Experimental JavaScript”.</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("WeakMap")}}</li>
+ <li>{{jsxref("WeakSet")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/anchor/index.html b/files/pl/web/javascript/reference/global_objects/string/anchor/index.html
new file mode 100644
index 0000000000..3f70573b83
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/anchor/index.html
@@ -0,0 +1,57 @@
+---
+title: String.prototype.anchor()
+slug: Web/JavaScript/Reference/Global_Objects/String/anchor
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor
+original_slug: Web/JavaScript/Referencje/Obiekty/String/anchor
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Tworzy kotwicę HTML {{HTMLElement("a")}} do użycia jako cel odnośnika.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.anchor(<var>name</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>name</code></dt>
+ <dd>Łańcuch znaków.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Use the <code>anchor()</code> method to programmatically create and display an anchor in a document.</p>
+
+<p>W składni łańcuch znaków reprezentuje literał tekstowy, który ma zobaczyć użytkownik. Łańcuch <code>name</code> reprezentuje atrybut <code>name</code> znacznika <code>a</code>.</p>
+
+<p>Kotwice stworzone za pomocą metody <code>anchor</code> stają się elementami tablicy <code>document.anchors</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_anchor" name="Przyk.C5.82ad:_Zastosowanie_anchor">Przykład: Zastosowanie <code>anchor()</code></h3>
+
+<p>Następujący przykład wewnątrz kodu HTML elementu <code>script</code>:</p>
+
+<pre class="brush: js">var myString = "Tabela zawartości";
+
+document.body.innerHTML = myString.anchor("contents_anchor");
+</pre>
+
+<p>spowoduje otrzymanie na wyjściu kodu HTML:</p>
+
+<pre class="brush: js">&lt;a name="contents_anchor"&gt;Tabela zawartości&lt;/a&gt;
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.link()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/big/index.html b/files/pl/web/javascript/reference/global_objects/string/big/index.html
new file mode 100644
index 0000000000..e0dfbfbf7c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/big/index.html
@@ -0,0 +1,44 @@
+---
+title: String.prototype.big()
+slug: Web/JavaScript/Reference/Global_Objects/String/big
+tags:
+  - Deprecated
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/big
+original_slug: Web/JavaScript/Referencje/Obiekty/String/big
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje, iż łańcuch znaków zostanie wyświetlony jakby znajdował się wewnątrz znacznika {{HTMLElement("big")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.big()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>The <code>big()</code> method embeds a string in a <code>&lt;big&gt;</code> tag: <code>"&lt;big&gt;str&lt;/big&gt;"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_big" name="Przyk.C5.82ad:_Zastosowanie_big">Przykład: Zastosowanie <code>big()</code></h3>
+
+<p>Następujący przykład stosuje metodę string do zmiany rozmiaru łańcucha znaków:</p>
+
+<pre class="brush: js">var worldString = "Witaj, Świecie";
+
+console.log(worldString.small())<code class="language-js"><span class="token punctuation">;</span>    <span class="token comment"> // </span></code>&lt;small&gt;Witaj, Świecie&lt;/small&gt;
+console.log(worldString.big());       // &lt;big&gt;Witaj, Świecie&lt;/big&gt;
+console.log(worldString.fontsize(7)); // &lt;fontsize=7&gt;Witaj, Świecie&lt;/fontsize&gt;</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.fontsize()")}}</li>
+ <li>{{jsxref("String.prototype.small()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/blink/index.html b/files/pl/web/javascript/reference/global_objects/string/blink/index.html
new file mode 100644
index 0000000000..7430744309
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/blink/index.html
@@ -0,0 +1,51 @@
+---
+title: String.prototype.blink()
+slug: Web/JavaScript/Reference/Global_Objects/String/blink
+tags:
+  - Deprecated
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/blink
+original_slug: Web/JavaScript/Referencje/Obiekty/String/blink
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje, iż łańcuch będzie migotał tak, jakby był on wewnątrz znacznika {{HTMLElement("blink")}}.</p>
+
+<div class="warning">
+<p><strong>Warning:</strong> Blinking text is frowned upon by several accessibility standards. The <code>&lt;blink&gt;</code> element itself is non-standard and deprecated!</p>
+</div>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.blink()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>The <code>blink()</code> method embeds a string in a <code>&lt;blink&gt;</code> tag: <code>"&lt;blink&gt;str&lt;/blink&gt;"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <code>blink()</code></h3>
+
+<p>Następujący przykład stosuje metodę string do zmiany formatowania łańcucha znaków:</p>
+
+<pre class="brush: js">var worldString="Witaj, Świecie";
+
+console.log(worldString.blink());   // &lt;blink&gt;Witaj, Świecie&lt;/blink&gt;
+console.log(worldString.bold());    // &lt;bold&gt;Witaj, Świecie&lt;/bold&gt;
+console.log(worldString.italics()); // &lt;i&gt;Witaj, Świecie&lt;/i&gt;
+console.log(worldString.strike());  // &lt;s&gt;Witaj, Świecie&lt;/s&gt;
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.bold()")}}</li>
+ <li>{{jsxref("String.prototype.italics()")}}</li>
+ <li>{{jsxref("String.prototype.strike()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/bold/index.html b/files/pl/web/javascript/reference/global_objects/string/bold/index.html
new file mode 100644
index 0000000000..49b5f4446b
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/bold/index.html
@@ -0,0 +1,46 @@
+---
+title: String.prototype.bold()
+slug: Web/JavaScript/Reference/Global_Objects/String/bold
+tags:
+  - Deprecated
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/bold
+original_slug: Web/JavaScript/Referencje/Obiekty/String/bold
+---
+<p>{{JSRef}}{{deprecated_header}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje wyświetlenie łańcucha znaków jako pogrubienia, jakby był w znaczniku {{HTMLElement("b")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.bold()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>The <code>bold()</code> method embeds a string in a <code>&lt;b&gt;</code> tag: <code>"&lt;b&gt;str&lt;/b&gt;"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h4 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <strong><code>bold()</code></strong></h4>
+
+<p>Następujący przykład stosuje metodę string do zmiany rozmiaru łańcucha znaków:</p>
+
+<pre class="brush: js">var worldString="Witaj, Świecie";
+
+console.log(worldString.blink());   // &lt;blink&gt;Witaj, Świecie&lt;/blink&gt;
+console.log(worldString.bold());    // &lt;bold&gt;Witaj, Świecie&lt;/bold&gt;
+console.log(worldString.italics()); // &lt;i&gt;Witaj, Świecie&lt;/i&gt;
+console.log(worldString.strike());  // &lt;s&gt;Witaj, Świecie&lt;/s&gt;</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.blink()")}}</li>
+ <li>{{jsxref("String.prototype.italics()")}}</li>
+ <li>{{jsxref("String.prototype.strike()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/charat/index.html b/files/pl/web/javascript/reference/global_objects/string/charat/index.html
new file mode 100644
index 0000000000..44526655bd
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/charat/index.html
@@ -0,0 +1,69 @@
+---
+title: String.prototype.charAt()
+slug: Web/JavaScript/Reference/Global_Objects/String/charAt
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt
+original_slug: Web/JavaScript/Referencje/Obiekty/String/charAt
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca określony znak z łańcucha znaków.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.charAt(<var>index</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>index</code> </dt>
+ <dd>Liczba całkowita z przedziału od 0 do liczby o 1 mniejszej od długości łańcucha.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Znaki w łańcuchu znaków są indeksowane od lewej do prawej strony. Indeksem pierwszego znaku jest 0, a indeksem ostatniego znaku w łańcuchu znaków o nazwie <code>stringName</code> jest <code>stringName.length - 1</code>. Jeśli dostarczona wartość parametru <code>index</code> znajduje się poza zakresem, JavaScript zwróci pusty łańcuch znaków.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_r.C3.B3.C5.BCnych_znak.C3.B3w_z_okre.C5.9Blonego_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Wy.C5.9Bwietlanie_r.C3.B3.C5.BCnych_znak.C3.B3w_z_okre.C5.9Blonego_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Wyświetlanie różnych znaków z określonego łańcucha znaków</h3>
+
+<p>Poniższy przykład wyświetla różne znaki łańcucha "<code>Brave new world</code>":</p>
+
+<pre class="brush: js">var anyString="Brave new world";
+
+console.log("Znakiem o indeksie 0   jest '" + anyString.charAt(0)   + "'");
+console.log("Znakiem o indeksie 1   jest '" + anyString.charAt(1)   + "'");
+console.log("Znakiem o indeksie 2   jest '" + anyString.charAt(2)   + "'");
+console.log("Znakiem o indeksie 3   jest '" + anyString.charAt(3)   + "'");
+console.log("Znakiem o indeksie 4   jest '" + anyString.charAt(4)   + "'");
+console.log("Znakiem o indeksie 999 jest '" + anyString.charAt(999) + "'");
+</pre>
+
+<p>Powyższy kod wyświetli:</p>
+
+<pre>Znakiem o indeksie 0   jest 'B'
+Znakiem o indeksie 1   jest 'r'
+Znakiem o indeksie 2   jest 'a'
+Znakiem o indeksie 3   jest 'v'
+Znakiem o indeksie 4   jest 'e'
+Znakiem o indeksie 999 jest ''
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.indexOf()")}}</li>
+ <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
+ <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
+ <li>{{jsxref("String.prototype.codePointAt()")}}</li>
+ <li>{{jsxref("String.prototype.split()")}}</li>
+ <li>{{jsxref("String.fromCodePoint()")}}</li>
+ <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/charcodeat/index.html b/files/pl/web/javascript/reference/global_objects/string/charcodeat/index.html
new file mode 100644
index 0000000000..fefe5418b5
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/charcodeat/index.html
@@ -0,0 +1,43 @@
+---
+title: String.prototype.charCodeAt()
+slug: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+  - Unicode
+translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
+original_slug: Web/JavaScript/Referencje/Obiekty/String/charCodeAt
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca liczbę oznaczającą wartość Unicode znaku o podanym indeksie.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.charCodeAt(<var>index</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>index</code> </dt>
+ <dd>Liczba całkowita z przedziału od 0 do liczby o 1 mniejszej od długości łańcucha.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wartości Unicode mieszczą się w zakresie od 0 do 65535. Pierwsze 128 wartości Unicode jest takie same jak w zbiorze znaków ASCII. Aby dowiedzieć się więcej o Unicode, zobacz <a href="/pl/docs/Web/JavaScript/Guide/Grammar_and_types#Unicode">Przewodnik po języku JavaScript</a>.</p>
+
+<p>Zgodność wsteczna: JavaScript 1.2 — Metoda <code>charCodeAt</code> zwraca liczbę wskazującą wartość ze zbioru kodowania ISO-Latin-1 znaku o podanym indeksie. Zbiór kodowania ISO-Latin-1 posiada zakres od 0 do 255. Znaki od 0 do 127 są identyczne, co te w zbiorze znaków ASCII.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_charCodeAt" name="Przyk.C5.82ad:_Zastosowanie_charCodeAt">Przykład: Zastosowanie <code>charCodeAt()</code></h3>
+
+<p>Następujący przykład zwróci 65, wartość A w Unicode.</p>
+
+<pre class="brush: js">"ABC".charCodeAt(0); // zwróci 65
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/string/concat/index.html b/files/pl/web/javascript/reference/global_objects/string/concat/index.html
new file mode 100644
index 0000000000..ea0dbf7847
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/concat/index.html
@@ -0,0 +1,45 @@
+---
+title: String.prototype.concat()
+slug: Web/JavaScript/Reference/Global_Objects/String/concat
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/concat
+original_slug: Web/JavaScript/Referencje/Obiekty/String/concat
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Łączy tekst dwóch lub więcej łańcuchów znaków i zwraca nowy łańcuch.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.concat(<var>string2</var>, <var>string3</var>[, ..., <var>stringN</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>string2...string
+ <i>N</i>
+ </code> </dt>
+ <dd>Łańcuchy znaków mające być dołączone do tego łańcucha.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>concat()</code> łączy tekst jednego lub więcej łańcuchów znaków i zwraca nowy łańcuch znaków. Zmiana tekstu w jednym łańcuchu znaków nie ma wpływu na drugi łańcuch.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_concat" name="Przyk.C5.82ad:_Zastosowanie_concat">Przykład: Zastosowanie <code>concat()</code></h3>
+
+<p>Następujący przykład łączy łańcuchy znaków w nowy łańcuch znaków.</p>
+
+<pre class="brush: js">var s1="Och, ";
+var s2="jaki piękny ";
+var s3="poranek.";
+var s4=s1.concat(s2,s3); // zwraca "Och, jaki piękny poranek."
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/string/fontcolor/index.html b/files/pl/web/javascript/reference/global_objects/string/fontcolor/index.html
new file mode 100644
index 0000000000..4753478194
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/fontcolor/index.html
@@ -0,0 +1,51 @@
+---
+title: String.prototype.fontcolor()
+slug: Web/JavaScript/Reference/Global_Objects/String/fontcolor
+tags:
+  - Deprecated
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor
+original_slug: Web/JavaScript/Referencje/Obiekty/String/fontcolor
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje, iż łańcuch zostanie wyświetlony podanym kolorem tak jakby był wewnątrz znacznika {{HTMLElement("font")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.fontcolor(<var>color</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>color</code> </dt>
+ <dd>Łańcuch znaków wyrażający kolor jako trójka heksadecymalna RGB lub jako łańcuch znaków. Lista nazw w postaci łańcucha znaków dla kolorów jest dostępna w <a href="pl/Przewodnik_po_j%c4%99zyku_JavaScript_1.5">przewodniku po języku JavaScript 1.5</a>.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli wyrażamy kolor w postaci trójki heksadecymalnej RGB, to musisz zastosować format <code>rrggbb</code>. Na przykład, wartość heksadecymalna koloru łososiowego składa się z red=FA, green=80 i blue=72, więc trójka RGB dla łososiowego będzie miała wartość "<code>FA8072</code>".</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_fontcolor" name="Przyk.C5.82ad:_Zastosowanie_fontcolor">Przykład: Zastosowanie <code>fontcolor()</code></h3>
+
+<p>Następujący przykład stosuje metodę <code>string</code> do zmiany koloru łańcucha znaków:</p>
+
+<pre class="brush: js">var worldString="Witaj, Świecie";
+
+console.log(worldString.fontcolor("red") + " jest koloru czerwonego w tej linii");
+// &lt;font color="red"&gt;Witaj, Świecie&lt;/font&gt; jest koloru czerwonego w tej linii
+
+console.log(worldString.fontcolor("FF00") +" linia jest czerwona i podany kolor heksadecymalny");
+// &lt;font color="FF00"&gt;Witaj, Świecie&lt;/font&gt; linia jest czerwona i podany kolor heksadecymalny
+</pre>
+
+<div class="noinclude"> </div>
+
+<p> </p>
diff --git a/files/pl/web/javascript/reference/global_objects/string/fontsize/index.html b/files/pl/web/javascript/reference/global_objects/string/fontsize/index.html
new file mode 100644
index 0000000000..7c15a79def
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/fontsize/index.html
@@ -0,0 +1,49 @@
+---
+title: String.prototype.fontsize()
+slug: Web/JavaScript/Reference/Global_Objects/String/fontsize
+tags:
+  - Deprecated
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize
+original_slug: Web/JavaScript/Referencje/Obiekty/String/fontsize
+---
+<p>{{JSRef}}{{ Non-standard_header() }}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje wyświetlenie łańcucha znaków w określonym rozmiarze czcionki, tak jak to było w znaczniku {{HTMLElement("font")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.fontsize(<var>size</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>size</code> </dt>
+ <dd>Liczba całkowita pomiędzy 1 a 7, łańcuch znaków reprezentujący rozmiar znaku liczby całkowitej między 1 a 7.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Kiedy określisz rozmiar jako liczbę całkowitą, ustaw rozmiar <code>stringName</code> na jeden z 7 innych rozmiarów. Kiedy określisz <code>size</code> łańcucha znaków jako "-2", to dostosujesz rozmiar czcionki <code>stringName</code> relatywnie do rozmiaru jaki został ustawiony w znaczniku {{HTMLElement("basefont")}}.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <strong><code>fontsize()</code></strong></h3>
+
+<pre class="brush: js  language-js"><code class="language-js"><span class="token keyword">var</span> worldString <span class="token operator">=</span> <span class="token string">"Witaj, Świecie"</span><span class="token punctuation">;</span>
+
+console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>worldString<span class="token punctuation">.</span><span class="token function">small<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>    <span class="token comment"> // &lt;small&gt;Witaj, Świecie&lt;/small&gt;
+</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>worldString<span class="token punctuation">.</span><span class="token function">big<span class="token punctuation">(</span></span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>      <span class="token comment"> // &lt;big&gt;Witaj, Świecie&lt;/big&gt;
+</span>console<span class="token punctuation">.</span><span class="token function">log<span class="token punctuation">(</span></span>worldString<span class="token punctuation">.</span><span class="token function">fontsize<span class="token punctuation">(</span></span><span class="token number">7</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment"> // &lt;fontsize=7&gt;Witaj, Świecie&lt;/fontsize&gt;</span></code></pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.big()")}}</li>
+ <li>{{jsxref("String.prototype.small()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/pl/web/javascript/reference/global_objects/string/fromcharcode/index.html
new file mode 100644
index 0000000000..d9a96bafd0
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/fromcharcode/index.html
@@ -0,0 +1,51 @@
+---
+title: String.fromCharCode()
+slug: Web/JavaScript/Reference/Global_Objects/String/fromCharCode
+tags:
+  - JavaScript
+  - Method
+  - String
+  - Unicode
+translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode
+original_slug: Web/JavaScript/Referencje/Obiekty/String/fromCharCode
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków stworzony przez podaną sekwencję kodów Unicode.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>num1, ..., num<em>N</em> </code> </dt>
+ <dd>Sekwencja liczb, które są wartościami Unicode.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Ta metoda zwraca łańcuch znaków nie będący {{jsxref("String")}}.</p>
+
+<p>Ponieważ <code>fromCharCode()</code> jest metodą statyczną {{jsxref("String")}}, używaj ją zawsze jako <code>String.fromCharCode()</code>, a nie jako metodę obiektu {{jsxref("String")}}.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_fromCharCode" name="Przyk.C5.82ad:_Zastosowanie_fromCharCode">Przykład: Zastosowanie <code>fromCharCode()</code></h3>
+
+<p>Następujący przykład zwraca łańcuch znaków <code>"ABC"</code>.</p>
+
+<pre class="brush: js">String.fromCharCode(65,66,67); // "ABC"
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.fromCodePoint()")}}</li>
+ <li>{{jsxref("String.prototype.charAt()")}}</li>
+ <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
+ <li>{{jsxref("String.prototype.codePointAt()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/fromcodepoint/index.html b/files/pl/web/javascript/reference/global_objects/string/fromcodepoint/index.html
new file mode 100644
index 0000000000..d929675696
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/fromcodepoint/index.html
@@ -0,0 +1,150 @@
+---
+title: String.fromCodePoint()
+slug: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint
+translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint
+original_slug: Web/JavaScript/Referencje/Obiekty/String/fromCodePoint
+---
+<div>{{JSRef}}</div>
+
+<p>The static <strong><code>String.fromCodePoint()</code></strong> method returns a string created by using the specified sequence of code points.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-fromcodepoint.html","shorter")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox notranslate">String<code>.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code><var>num1</var>, ..., <var>numN</var></code></dt>
+ <dd>A sequence of code points.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>A string created by using the specified sequence of code points.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>A {{jsxref("Errors/Not_a_codepoint", "RangeError")}} is thrown if an invalid Unicode code point is given (e.g. <code>"RangeError: NaN is not a valid code point"</code>).</li>
+</ul>
+
+<h2 id="Description">Description</h2>
+
+<p>This method returns a string (and <em>not</em> a {{jsxref("String")}} object).</p>
+
+<p>Because <code>fromCodePoint()</code> is a static method of {{jsxref("String")}}, you must call it as <code>String.fromCodePoint()</code>, rather than as a method of a {{jsxref("String")}} object you created.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>The <code>String.fromCodePoint()</code> method has been added to ECMAScript 2015 and may not be supported in all web browsers or environments yet.</p>
+
+<p>Use the code below for a polyfill:</p>
+
+<pre class="brush: js notranslate">if (!String.fromCodePoint) (function(stringFromCharCode) {
+    var fromCodePoint = function(_) {
+      var codeUnits = [], codeLen = 0, result = "";
+      for (var index=0, len = arguments.length; index !== len; ++index) {
+        var codePoint = +arguments[index];
+        // correctly handles all cases including `NaN`, `-Infinity`, `+Infinity`
+        // The surrounding `!(...)` is required to correctly handle `NaN` cases
+        // The (codePoint&gt;&gt;&gt;0) === codePoint clause handles decimals and negatives
+        if (!(codePoint &lt; 0x10FFFF &amp;&amp; (codePoint&gt;&gt;&gt;0) === codePoint))
+          throw RangeError("Invalid code point: " + codePoint);
+        if (codePoint &lt;= 0xFFFF) { // BMP code point
+          codeLen = codeUnits.push(codePoint);
+        } else { // Astral code point; split in surrogate halves
+          // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+          codePoint -= 0x10000;
+          codeLen = codeUnits.push(
+            (codePoint &gt;&gt; 10) + 0xD800,  // highSurrogate
+            (codePoint % 0x400) + 0xDC00 // lowSurrogate
+          );
+        }
+        if (codeLen &gt;= 0x3fff) {
+          result += stringFromCharCode.apply(null, codeUnits);
+          codeUnits.length = 0;
+        }
+      }
+      return result + stringFromCharCode.apply(null, codeUnits);
+    };
+    try { // IE 8 only supports `Object.defineProperty` on DOM elements
+      Object.defineProperty(String, "fromCodePoint", {
+        "value": fromCodePoint, "configurable": true, "writable": true
+      });
+    } catch(e) {
+      String.fromCodePoint = fromCodePoint;
+    }
+}(String.fromCharCode));
+</pre>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_fromCodePoint">Using <code>fromCodePoint()</code></h3>
+
+<p>Valid input:</p>
+
+<pre class="brush: js notranslate">String.fromCodePoint(42);       // "*"
+String.fromCodePoint(65, 90);   // "AZ"
+String.fromCodePoint(0x404);    // "\u0404" == "Є"
+String.fromCodePoint(0x2F804);  // "\uD87E\uDC04"
+String.fromCodePoint(194564);   // "\uD87E\uDC04"
+String.fromCodePoint(0x1D306, 0x61, 0x1D307); // "\uD834\uDF06a\uD834\uDF07"
+</pre>
+
+<p>Invalid input:</p>
+
+<pre class="brush: js notranslate">String.fromCodePoint('_');      // RangeError
+String.fromCodePoint(Infinity); // RangeError
+String.fromCodePoint(-1);       // RangeError
+String.fromCodePoint(3.14);     // RangeError
+String.fromCodePoint(3e-2);     // RangeError
+String.fromCodePoint(NaN);      // RangeError
+</pre>
+
+<h3 id="Compared_to_fromCharCode">Compared to <code>fromCharCode()</code></h3>
+
+<p>{{jsxref("String.fromCharCode()")}} cannot return supplementary characters (i.e. code points <code>0x010000</code> – <code>0x10FFFF</code>) by specifying their code point. Instead, it requires the UTF-16 surrogate pair in order to return a supplementary character:</p>
+
+<pre class="brush: js notranslate">String.fromCharCode(0xD83C, 0xDF03); // Code Point U+1F303 "Night with
+String.fromCharCode(55356, 57091);   // Stars" == "\uD83C\uDF03"
+</pre>
+
+<p><code>String.fromCodePoint()</code>, on the other hand, can return 4-byte supplementary characters, as well as the more common 2-byte BMP characters, by specifying their code point (which is equivalent to the UTF-32 code unit):</p>
+
+<pre class="brush: js notranslate">String.fromCodePoint(0x1F303); // or 127747 in decimal
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.fromCodePoint")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("String.fromCharCode()")}}</li>
+ <li>{{jsxref("String.prototype.charAt()")}}</li>
+ <li>{{jsxref("String.prototype.codePointAt()")}}</li>
+ <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/index.html b/files/pl/web/javascript/reference/global_objects/string/index.html
new file mode 100644
index 0000000000..e343b8b35a
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/index.html
@@ -0,0 +1,195 @@
+---
+title: String
+slug: Web/JavaScript/Reference/Global_Objects/String
+tags:
+  - JavaScript
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String
+original_slug: Web/JavaScript/Referencje/Obiekty/String
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Tworzy obiekt pozwalający działać na ciągach znaków.</p>
+
+<h2 id="Tworzony_przez" name="Tworzony_przez">Składnia</h2>
+
+<p>Literały znakowe są postaci:</p>
+
+<pre class="syntaxbox notranslate">'string text'
+"string text"
+"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ்"
+</pre>
+
+<p>Beside regular, printable characters, special characters can be encoded using escape notation:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Code</th>
+   <th scope="col">Output</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><code>\0</code></td>
+   <td>the NUL character</td>
+  </tr>
+  <tr>
+   <td><code>\'</code></td>
+   <td>single quote</td>
+  </tr>
+  <tr>
+   <td><code>\"</code></td>
+   <td>double quote</td>
+  </tr>
+  <tr>
+   <td><code>\\</code></td>
+   <td>backslash</td>
+  </tr>
+  <tr>
+   <td><code>\n</code></td>
+   <td>new line</td>
+  </tr>
+  <tr>
+   <td><code>\r</code></td>
+   <td>carriage return</td>
+  </tr>
+  <tr>
+   <td><code>\v</code></td>
+   <td>vertical tab</td>
+  </tr>
+  <tr>
+   <td><code>\t</code></td>
+   <td>tab</td>
+  </tr>
+  <tr>
+   <td><code>\b</code></td>
+   <td>backspace</td>
+  </tr>
+  <tr>
+   <td><code>\f</code></td>
+   <td>form feed</td>
+  </tr>
+  <tr>
+   <td><code>\uXXXX</code></td>
+   <td>unicode codepoint</td>
+  </tr>
+  <tr>
+   <td><code>\xXX</code></td>
+   <td>the Latin-1 character</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Or, using the <code>String</code> global object directly:</p>
+
+<pre class="syntaxbox notranslate">String(thing)
+new String(thing)
+</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>thing</code></dt>
+ <dd>Dowolny łańcuch znaków.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>trings are useful for holding data that can be represented in text form. Some of the most-used operations on strings are to check their {{jsxref("String.length", "length")}}, to build and concatenate them using the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">+ and += string operators</a>, checking for the existence or location of substrings with the {{jsxref("String.prototype.indexOf()", "indexOf()")}} method, or extracting substrings with the {{jsxref("String.prototype.substring()", "substring()")}} method.</p>
+
+<h3 id="Character_access" name="Character_access">Character access</h3>
+
+<p>There are two ways to access an individual character in a string. The first is the {{jsxref("String.prototype.charAt()", "charAt()")}} method:</p>
+
+<pre class="brush: js notranslate">return 'cat'.charAt(1); // returns "a"</pre>
+
+<div class="line-number" style="top: 0px;"></div>
+
+<p>The other way (introduced in ECMAScript 5) is to treat the string as an array-like object, where individual characters correspond to a numerical index:</p>
+
+<pre class="brush: js notranslate">return 'cat'[1]; // returns "a"</pre>
+
+<div class="line-number" style="top: 0px;"></div>
+
+<p>For character access using bracket notation, attempting to delete or assign a value to these properties will not succeed. The properties involved are neither writable nor configurable. (See {{jsxref("Object.defineProperty()")}} for more information.)</p>
+
+<h3 id="Comparing_strings" name="Comparing_strings">Comparing strings</h3>
+
+<p>C developers have the <code>strcmp()</code> function for comparing strings. In JavaScript, you just use the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">less-than and greater-than operators</a>:</p>
+
+<pre class="brush: js notranslate">var a = 'a';
+var b = 'b';
+if (a &lt; b) { // true
+  print(a + ' is less than ' + b);
+} else if (a &gt; b) {
+  print(a + ' is greater than ' + b);
+} else {
+  print(a + ' and ' + b + ' are equal.');
+}</pre>
+
+<p>A similar result can be achieved using the {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} method inherited by <code>String</code> instances.</p>
+
+<h3 id="Distinction_between_string_primitives_and_String_objects">Distinction between string primitives and <code>String</code> objects</h3>
+
+<p>Note that JavaScript distinguishes between <code>String</code> objects and primitive string values. (The same is true of {{jsxref("Global_Objects/Boolean", "Boolean")}} and {{jsxref("Global_Objects/Number", "Numbers")}}.)</p>
+
+<p>String literals (denoted by double or single quotes) and strings returned from <code>String</code> calls in a non-constructor context (i.e., without using the {{jsxref("Operators/new", "new")}} keyword) are primitive strings. JavaScript automatically converts primitives to <code>String</code> objects, so that it's possible to use <code>String</code> object methods for primitive strings. In contexts where a method is to be invoked on a primitive string or a property lookup occurs, JavaScript will automatically wrap the string primitive and call the method or perform the property lookup.</p>
+
+<pre class="brush: js notranslate">var s_prim = 'foo';
+var s_obj = new String(s_prim);
+
+console.log(typeof s_prim); // Logs "string"
+console.log(typeof s_obj);  // Logs "object"</pre>
+
+<div class="line-number" style="top: 76px;"></div>
+
+<p>String primitives and <code>String</code> objects also give different results when using {{jsxref("Global_Objects/eval", "eval()")}}. Primitives passed to <code>eval</code> are treated as source code; <code>String</code> objects are treated as all other objects are, by returning the object. For example:</p>
+
+<pre class="brush: js notranslate">var s1 = '2 + 2';             // creates a string primitive
+var s2 = new String('2 + 2'); // creates a String object
+console.log(eval(s1));        // returns the number 4
+console.log(eval(s2));        // returns the string "2 + 2"</pre>
+
+<p>For these reasons, code may break when it encounters <code>String</code> objects when it expects a primitive string instead, although generally authors need not worry about the distinction.</p>
+
+<p>A <code>String</code> object can always be converted to its primitive counterpart with the {{jsxref("String.prototype.valueOf()", "valueOf()")}} method.</p>
+
+<pre class="brush: js notranslate">console.log(eval(s2.valueOf())); // returns the number 4</pre>
+
+<div class="note"><strong>Note:</strong> For another possible approach to strings in JavaScript, please read the article about <a href="https://developer.mozilla.org/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — a C-like representation of strings based on typed arrays</a>.</div>
+
+<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2>
+
+<dl>
+ <dt>{{jsxref("String.prototype")}}</dt>
+ <dd>Pozwala na dodawanie własności do obiektu <code>String</code>.</dd>
+</dl>
+
+<div>{{jsOverrides("Function", "Properties", "prototype")}}</div>
+
+<h2 id="Metody">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("String.fromCharCode()")}}</dt>
+ <dd>Zwraca łańcuch znaków stworzony przez podaną sekwencję kodów Unicode.</dd>
+ <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt>
+ <dd>Returns a string created by using the specified sequence of code points.</dd>
+ <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt>
+ <dd>Returns a string created from a raw template string.</dd>
+</dl>
+
+<div>{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint", "raw")}}</div>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Example_String_conversion">Example: String conversion</h3>
+
+<p>It's possible to use <code>String</code> as a "safer" {{jsxref("String.prototype.toString()", "toString()")}} alternative, as although it still normally calls the underlying <code>toString()</code>, it also works for {{jsxref("null")}} and {{jsxref("undefined")}}. For example:</p>
+
+<pre class="brush: js notranslate">var outputStrings = [];
+for (var i = 0, n = inputValues.length; i &lt; n; ++i) {
+  outputStrings.push(String(inputValues[i]));
+}</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/string/italics/index.html b/files/pl/web/javascript/reference/global_objects/string/italics/index.html
new file mode 100644
index 0000000000..16c5d77bcb
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/italics/index.html
@@ -0,0 +1,46 @@
+---
+title: String.prototype.italics()
+slug: Web/JavaScript/Reference/Global_Objects/String/italics
+tags:
+  - Deprecated
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/italics
+original_slug: Web/JavaScript/Referencje/Obiekty/String/italics
+---
+<p>{{JSRef}}{{deprecated_header}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje, iż łańcuch zostanie wyświetlony kursywą tak jakby był wewnątrz znacznika {{HTMLElement("i")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.italics()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>The <code>italics()</code> method embeds a string in an <code>&lt;i&gt;</code> tag: <code>"&lt;i&gt;str&lt;/i&gt;"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego">Przykład: Zastosowanie metody <code>italics()</code></h3>
+
+<p>Następujący przykład stosuje metodę <code>string</code> do zmiany formatowania łańcucha znakowego:</p>
+
+<pre class="brush: js">var worldString="Witaj, Świecie";
+
+console.log(worldString.blink());   // &lt;blink&gt;Witaj, Świecie&lt;/blink&gt;
+console.log(worldString.bold());    // &lt;bold&gt;Witaj, Świecie&lt;/bold&gt;
+console.log(worldString.italics()); // &lt;i&gt;Witaj, Świecie&lt;/i&gt;
+console.log(worldString.strike());  // &lt;s&gt;Witaj, Świecie&lt;/s&gt;</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.blink()")}}</li>
+ <li>{{jsxref("String.prototype.bold()")}}</li>
+ <li>{{jsxref("String.prototype.strike()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/link/index.html b/files/pl/web/javascript/reference/global_objects/string/link/index.html
new file mode 100644
index 0000000000..dddd49ecf7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/link/index.html
@@ -0,0 +1,44 @@
+---
+title: String.prototype.link()
+slug: Web/JavaScript/Reference/Global_Objects/String/link
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/link
+original_slug: Web/JavaScript/Referencje/Obiekty/String/link
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Tworzy <a class="external" href="http://www.w3.org/TR/html401/struct/links.html#adef-href">łącze hipertekstowe</a>, które wywołuje inny URL.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.link(<var>url</var>)</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>url</code></dt>
+ <dd>Jakikolwiek łańcuch określony w <code>href</code> ze znacznika <code>a</code>; powinien być umieszczany poprawny URL (relatywny lub absolutny).</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Linki tworzymy poprzez metodę <code>link</code> stającą się elementami tablicy <code>links</code> z obiektu <code>document</code>. Zobacz <code>document.links</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_link" name="Przyk.C5.82ad:_Zastosowanie_link">Przykład: Zastosowanie <code>link()</code></h3>
+
+<p>Następujący przykład wyświetla słowo "MDN" jako odnośnik hipertekstowy, poprzez który użytkownik będzie mógł przejść na stronę domową Netscape:</p>
+
+<pre class="brush: js">var hotText="MDN";
+var URL="<code class="language-js"><span class="token string">https://developer.mozilla.org/</span></code>";
+
+console.log("Kliknij, aby powrócić do " + hotText.link(URL));
+// Kliknij, aby powrócić do &lt;a href="https://developer.mozilla.org"&gt;MDN&lt;/a&gt;
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/string/repeat/index.html b/files/pl/web/javascript/reference/global_objects/string/repeat/index.html
new file mode 100644
index 0000000000..a6542a4bb7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/repeat/index.html
@@ -0,0 +1,167 @@
+---
+title: String.prototype.repeat()
+slug: Web/JavaScript/Reference/Global_Objects/String/repeat
+translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat
+original_slug: Web/JavaScript/Referencje/Obiekty/String/repeat
+---
+<div>{{JSRef}}</div>
+
+<p>The <strong><code>repeat()</code></strong> method constructs and returns a new string which contains the specified number of copies of the string on which it was called, concatenated together.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><var>str</var>.repeat(<var>count</var>)</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>count</code></dt>
+ <dd>An integer between 0 and +∞: [0, +∞), indicating the number of times to repeat the string in the newly-created string that is to be returned.</dd>
+</dl>
+
+<h3 id="Zwracana_wartość">Zwracana wartość</h3>
+
+<p>A new string containing the specified number of copies of the given string.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: repeat count must be non-negative.</li>
+ <li>{{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: repeat count must be less than infinity and not overflow maximum string size.</li>
+</ul>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<pre class="brush: js">'abc'.repeat(-1);   // RangeError
+'abc'.repeat(0);    // ''
+'abc'.repeat(1);    // 'abc'
+'abc'.repeat(2);    // 'abcabc'
+'abc'.repeat(3.5);  // 'abcabcabc' (count will be converted to integer)
+'abc'.repeat(1/0);  // RangeError
+
+({ toString: () =&gt; 'abc', repeat: String.prototype.repeat }).repeat(2);
+// 'abcabc' (repeat() is a generic method)
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>This method has been added to the ECMAScript 6 specification and may not be available in all JavaScript implementations yet. However, you can polyfill <code>String.prototype.repeat()</code> with the following snippet:</p>
+
+<pre class="brush: js">if (!String.prototype.repeat) {
+  String.prototype.repeat = function(count) {
+    'use strict';
+    if (this == null) {
+      throw new TypeError('can\'t convert ' + this + ' to object');
+    }
+    var str = '' + this;
+    count = +count;
+    if (count != count) {
+      count = 0;
+    }
+    if (count &lt; 0) {
+      throw new RangeError('repeat count must be non-negative');
+    }
+    if (count == Infinity) {
+      throw new RangeError('repeat count must be less than infinity');
+    }
+    count = Math.floor(count);
+    if (str.length == 0 || count == 0) {
+      return '';
+    }
+    // Ensuring count is a 31-bit integer allows us to heavily optimize the
+    // main part. But anyway, most current (August 2014) browsers can't handle
+    // strings 1 &lt;&lt; 28 chars or longer, so:
+    if (str.length * count &gt;= 1 &lt;&lt; 28) {
+      throw new RangeError('repeat count must not overflow maximum string size');
+    }
+    var rpt = '';
+    for (;;) {
+      if ((count &amp; 1) == 1) {
+        rpt += str;
+      }
+      count &gt;&gt;&gt;= 1;
+      if (count == 0) {
+        break;
+      }
+      str += str;
+    }
+    // Could we try:
+    // return Array(count + 1).join(this);
+    return rpt;
+  }
+}
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("41")}} </td>
+   <td>{{CompatGeckoDesktop("24")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("36")}}</td>
+   <td>{{CompatGeckoMobile("24")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
diff --git a/files/pl/web/javascript/reference/global_objects/string/search/index.html b/files/pl/web/javascript/reference/global_objects/string/search/index.html
new file mode 100644
index 0000000000..ab4d438903
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/search/index.html
@@ -0,0 +1,50 @@
+---
+title: String.prototype.search()
+slug: Web/JavaScript/Reference/Global_Objects/String/search
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/search
+original_slug: Web/JavaScript/Referencje/Obiekty/String/search
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wykonuje przeszukanie dla dopasowanych wyrażeń regularnych i tego obiektu {{jsxref("String")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><var>str</var>.search(<var>regexp</var>)</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>regexp</code> </dt>
+ <dd>Nazwa wyrażenia regularnego. Może być to nazwa zmiennej lub literał.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli sukces, rezultat przeszukania indeksu wyrażenia regularnego wewnątrz łańcucha znaków. Inaczej zwróci -1.</p>
+
+<p>Kiedy chcesz wiedzieć gdzie jest znaleziony wzorzec w łańcuchu znaków zastosuj <code>search()</code> (podobne do wyrażenia regularnego metody {{jsxref("RegExp.prototype.test()", "test()")}}); aby uzyskać więcej informacji (lecz wolniej wykonywanie) zastosuj {{jsxref("String.prototype.match()", "match()")}} (podobne do wyrażenia regularnego metody {{jsxref("RegExp.prototype.exec()", "exec()")}} method).</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_search" name="Przyk.C5.82ad:_Zastosowanie_search">Przykład: Zastosowanie <code>search</code>()</h3>
+
+<p>Następujący przykład drukuje wiadomość, która zależy od sukcesu testu.</p>
+
+<pre class="brush: js">function testinput(re, str){
+   var midstring;
+   if (str.search(re) != -1) {
+      midstring = " contains ";
+   } else {
+      midstring = " does not contain ";
+   }
+   console.log (str + midstring + re.source);
+}
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/string/slice/index.html b/files/pl/web/javascript/reference/global_objects/string/slice/index.html
new file mode 100644
index 0000000000..65ae41a685
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/slice/index.html
@@ -0,0 +1,52 @@
+---
+title: String.prototype.slice()
+slug: Web/JavaScript/Reference/Global_Objects/String/slice
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/slice
+original_slug: Web/JavaScript/Referencje/Obiekty/String/slice
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wydobywa część łańcucha znaków i zwraca go jako nowy łańcuch znaków.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.slice(<var>beginSlice</var>[, <var>endSlice</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>beginSlice</code> </dt>
+ <dd>Oparty na zerze początek indeksu rozpoczynający wyciąganie.</dd>
+</dl>
+
+<dl>
+ <dt><code>endSlice</code> </dt>
+ <dd>Oparty na zerze początek indeksu, który kończy wyciąganie. Jeśli pominięty <code>slice()</code> wydobywa do końca łańcuch znaków.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>slice()</code> wyciąga tekst z jednego łańcucha znaków i zwraca nowy łańcuch znaków. Zmiany w treści jednego łańcucha znaków nie mają wpływu na drugi.</p>
+
+<p><code>slice()</code> wyciąga tekst do <code>endSlice</code> lecz go nie włącza. <code>string.slice(1,4)</code> wyciąga drugi znak aż do czwartego (znaki o indeksach 1, 2 i 3).</p>
+
+<p>Jako ujemny indeks <code>endSlice</code> sygnalizuje przesunięcie z końca łańcucha znaków. <code>str.slice(2,-1)</code> wyciąga trzeci przez ostatni znak w łańcuchu znaków.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad_Zastosowanie_slice_do_stworzenia_nowego_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_slice_do_stworzenia_nowego_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie <code>slice()</code></h3>
+
+<p>Poniższy przykład używa <code>slice</code> do stworzenia nowego łańcucha znaków.</p>
+
+<pre class="brush: js">var str1 = 'The morning is upon us.';
+var str2 = str1.slice(4,-2);
+
+console.log(str2); // OUTPUT: morning is upon u
+</pre>
diff --git a/files/pl/web/javascript/reference/global_objects/string/small/index.html b/files/pl/web/javascript/reference/global_objects/string/small/index.html
new file mode 100644
index 0000000000..176d59deed
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/small/index.html
@@ -0,0 +1,38 @@
+---
+title: String.prototype.small()
+slug: Web/JavaScript/Reference/Global_Objects/String/small
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/String/small
+original_slug: Web/JavaScript/Referencje/Obiekty/String/small
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje to, że łańcuch znaków będzie wyświetlany małą czcionką, jakby znajdował się wewnątrz znacznika {{HTMLElement("small")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.small()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>The <code>small()</code> method embeds a string in a <code>&lt;small&gt;</code> tag: <code>"&lt;small&gt;str&lt;/small&gt;"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znakowego" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_rozmiaru_.C5.82a.C5.84cucha_znakowego">Przykład: Zastosowanie metody <code>small()</code></h3>
+
+<pre class="brush: js">var worldString = "Witaj, Świecie";
+
+console.log(worldString.small());     // &lt;small&gt;Witaj, Świecie&lt;/small&gt;
+console.log(worldString.big());       // &lt;big&gt;Witaj, Świecie&lt;/big&gt;
+console.log(worldString.fontsize(7)); // &lt;fontsize=7&gt;Witaj, Świecie&lt;/fontsize&gt;</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.fontsize()")}}</li>
+ <li>{{jsxref("String.prototype.big()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/strike/index.html b/files/pl/web/javascript/reference/global_objects/string/strike/index.html
new file mode 100644
index 0000000000..09e3615055
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/strike/index.html
@@ -0,0 +1,45 @@
+---
+title: String.prototype.strike()
+slug: Web/JavaScript/Reference/Global_Objects/String/strike
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/strike
+original_slug: Web/JavaScript/Referencje/Obiekty/String/strike
+---
+<p>{{JSRef}}{{deprecated_header}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje, iż łańcuch zostanie wyświetlony przekreślony, tak jakby był wewnątrz znacznika {{HTMLElement("strike")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.strike()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>The <code>strike()</code> method embeds a string in a <code>&lt;strike&gt;</code> tag: <code>"&lt;strike&gt;str&lt;/strike&gt;"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego" name="Przyk.C5.82ad:_Zastosowanie_metody_string_do_zmiany_formatowania_.C5.82a.C5.84cucha_znakowego">Przykład: Zastosowanie metody <code>strike()</code></h3>
+
+<p>Następujący przykład stosuje metodę <code>string</code> do zmiany formatowania łańcucha znakowego:</p>
+
+<pre class="brush: js">var worldString="Witaj, Świecie";
+
+console.log(worldString.blink());   // &lt;blink&gt;Witaj, Świecie&lt;/blink&gt;
+console.log(worldString.bold());    // &lt;bold&gt;Witaj, Świecie&lt;/bold&gt;
+console.log(worldString.italics()); // &lt;i&gt;Witaj, Świecie&lt;/i&gt;
+console.log(worldString.strike());  // &lt;s&gt;Witaj, Świecie&lt;/s&gt;</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.blink()")}}</li>
+ <li>{{jsxref("String.prototype.bold()")}}</li>
+ <li>{{jsxref("String.prototype.italics()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/sub/index.html b/files/pl/web/javascript/reference/global_objects/string/sub/index.html
new file mode 100644
index 0000000000..94bfb8722e
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/sub/index.html
@@ -0,0 +1,45 @@
+---
+title: String.prototype.sub()
+slug: Web/JavaScript/Reference/Global_Objects/String/sub
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/sub
+original_slug: Web/JavaScript/Referencje/Obiekty/String/sub
+---
+<p>{{JSRef}}{{deprecated_header}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje, iż łańcuch zostanie wyświetlony jako indeks dolny tak jakby był wewnątrz znacznika {{HTMLElement("sub")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.sub()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>The <code>sub()</code> method embeds a string in a <code>&lt;sub&gt;</code> tag: <code>"&lt;sub&gt;str&lt;/sub&gt;"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h4 id="Przyk.C5.82ad:_Zastosowanie_metod_sub_i_sup_do_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metod_sub_i_sup_do_formatowania_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie metod <code>sub()</code> i <code>sup()</code></h4>
+
+<p>Następujący przykład stosuje metody <code>sub()</code> i {{jsxref("String.prototype.sup()", "sup()")}} do formatowania łańcucha znaków:</p>
+
+<pre class="brush: js">var superText="superscript";
+var subText="subscript";
+
+console.log("This is what a " + superText.sup() + " looks like.");
+// This is what a &lt;sup&gt;superscript&lt;/sup&gt; looks like
+
+console.log("This is what a " + subText.sub() + " looks like.");
+// This is what a &lt;sub&gt;subscript&lt;/sub&gt; looks like.</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.sup()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/substr/index.html b/files/pl/web/javascript/reference/global_objects/string/substr/index.html
new file mode 100644
index 0000000000..de389081b7
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/substr/index.html
@@ -0,0 +1,67 @@
+---
+title: String.prototype.substr()
+slug: Web/JavaScript/Reference/Global_Objects/String/substr
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/substr
+original_slug: Web/JavaScript/Referencje/Obiekty/String/substr
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca określoną liczbę początkowych znaków w łańcuchu znaków w określonej lokalizacji.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.substr(<var>start</var>[, <var>length</var>])</code></pre>
+
+<h2 id="Parametry" name="Parametry">Parametry</h2>
+
+<dl>
+ <dt><code>start</code> </dt>
+ <dd>Lokalizacja, w której rozpoczyna się wyciąganie znaków (wartość liczbowa pomiędzy 0, a jeden znak mniej niż długość łańcucha znaków).</dd>
+</dl>
+
+<dl>
+ <dt><code>length</code> </dt>
+ <dd>Liczba znaków do wyciągnięcia.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>start</code> jest indeksem znaków. Pierwszym znakiem w indeksie jest 0 i ostatnim znakiem w indeksie jest liczba o 1 mniejsza niż długość łańcucha znaków. <code>substr()</code> rozpoczyna wyciąganie znaków w <code>start</code> i ściąga liczbę <code>length</code> znaków.</p>
+
+<p>Jeśli <code>start</code> jest dodatnie i jest długością łańcucha znaków lub dłuższą wartością, <code>substr()</code> nie zwraca znaków.</p>
+
+<p>Jeśli <code>start</code> jest ujemne, <code>substr()</code> stosuje to jako indeks znaków z końca łańcucha znaków. Jeśli <code>start</code> jest ujemne i <code>abs(start)</code> jest większe niż długość łańcucha znaków to <code>substr()</code> stosuje 0 jako początek indeksu.</p>
+
+<p>Jeśli <code>length</code> jest 0 lub ujemne, <code>substr()</code> nie zwróci znaków. Jeśli <code>length</code> jest opuszczone, <code>substr()</code> wyciągnie znaki aż do końca łańcucha znaków.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_substr" name="Przyk.C5.82ad:_Zastosowanie_substr">Przykład: Zastosowanie <code>substr()</code></h3>
+
+<p>Rozpatrz poniższy skrypt:</p>
+
+<pre class="brush: js">var str = 'abcdefghij';
+
+console.log('(1, 2): ' + str.substr(1, 2)); // '(1, 2): bc'
+console.log('(-3, 2): ' + str.substr(-3, 2)); // '(-3, 2): hi'
+console.log('(-3): ' + str.substr(-3)); // '(-3): hij'
+console.log('(1): ' + str.substr(1)); // '(1): bcdefghij'
+console.log('(-20, 2): ' + str.substr(-20, 2)); // '(-20, 2): ab'
+console.log('(20, 2): ' + str.substr(20, 2)); // '(20, 2): '
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<p> </p>
+
+<ul>
+ <li>{{jsxref("String.prototype.slice()")}}</li>
+ <li>{{jsxref("String.prototype.substring()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/substring/index.html b/files/pl/web/javascript/reference/global_objects/string/substring/index.html
new file mode 100644
index 0000000000..718663d8f4
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/substring/index.html
@@ -0,0 +1,91 @@
+---
+title: String.prototype.substring()
+slug: Web/JavaScript/Reference/Global_Objects/String/substring
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/substring
+original_slug: Web/JavaScript/Referencje/Obiekty/String/substring
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca podciąg obiektu <code>String</code>.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.substring(<var>indexA</var>[, <var>indexB</var>])</code></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>indexA</code> </dt>
+ <dd>Liczba całkowita pomiędzy 0, a liczbą o jeden mniejszą niż długość łańcucha znaków.</dd>
+ <dt><code>indexB</code> </dt>
+ <dd>Opcjonalny. Liczba całkowita pomiędzy 0 i długością łańcucha znaków.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>substring</code> urywa znaki z <code>indexA</code> lecz nie włącza ich do <code>indexB</code>. W szczególności:</p>
+
+<ul>
+ <li>Jeśli <code>indexA</code> jest mniejsze niż 0, <code>indexA</code> zostanie potraktowany tak, jakby był 0.</li>
+ <li>Jeśli <code>indexB</code> jest większe niż <code>stringName.length</code>, <code>indexB</code> zostanie potraktowany tak, jakby był <code>stringName.length</code>.</li>
+ <li>Jeśli <code>indexA</code> jest równe <code>indexB</code>, <code>substring</code> zwraca pusty łańcuch znaków.</li>
+ <li>Jeśli <code>indexB</code> jest pominięty, <code>substring</code> urwie znaki znajdujące się na końcu łańcucha znaków.</li>
+</ul>
+
+<p>Jeśli <code>indexA</code> jest większy niż <code>indexB</code>, JavaScript zwróci <code>substring(indexB, indexA)</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_substring" name="Przyk.C5.82ad:_Zastosowanie_substring">Przykład: Zastosowanie <code>substring()</code></h3>
+
+<p>Następujący przykład <code>substring</code> stosujemy do wyświetlenia znaków ze słowa "<code>Mozilla</code>":</p>
+
+<pre class="brush: js">var anyString = "Mozilla";
+
+// Wyświetli  "Moz"
+console.log(anyString.substring(0,3));
+console.log(anyString.substring(3,0));
+
+// Wyświetli  "lla"
+console.log(anyString.substring(4));
+console.log(anyString.substring(4,7));
+console.log(anyString.substring(7,4));
+
+// Wyświetli  "Mozill"
+console.log(anyString.substring(0,6));
+
+// Wyświetli "Mozilla"
+console.log(anyString.substring(0,7));
+console.log(anyString.substring(0,10));
+</pre>
+
+<h3 id="Przyk.C5.82ad:_Zamina_podci.C4.85gu_wewn.C4.85trz_ci.C4.85gu" name="Przyk.C5.82ad:_Zamina_podci.C4.85gu_wewn.C4.85trz_ci.C4.85gu">Przykład: Zamiana podciągu wewnątrz ciągu</h3>
+
+<p>Następujący przykład zamienia podciąg wewnątrz ciągu. Zostaną zamienione oba poszczególne znaki i podciągi. Funkcja zostanie wywołana na koniec przykładu zmieniając łańcuch znaków; "<code>Brave New World</code>" na "<code>Brave New Web</code>".</p>
+
+<pre class="brush: js">function replaceString(oldS, newS, fullS) {
+// Replaces oldS with newS in the string fullS
+   for (var i = 0; i &lt; fullS.length; i++) {
+      if (fullS.substring(i, i + oldS.length) == oldS) {
+         fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length);
+      }
+   }
+   return fullS;
+}
+
+replaceString("World", "Web", "Brave New World");
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.substr()")}}</li>
+ <li>{{jsxref("String.prototype.slice()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/sup/index.html b/files/pl/web/javascript/reference/global_objects/string/sup/index.html
new file mode 100644
index 0000000000..50aca68b97
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/sup/index.html
@@ -0,0 +1,46 @@
+---
+title: String.prototype.sup()
+slug: Web/JavaScript/Reference/Global_Objects/String/sup
+tags:
+  - Deprecated
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/sup
+original_slug: Web/JavaScript/Referencje/Obiekty/String/sup
+---
+<p>{{JSRef}}{{deprecated_header}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Powoduje, iż łańcuch zostanie wyświetlony jako indeks górny tak jakby był wewnątrz znacznika {{HTMLElement("sup")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.sup()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>The <code>sup()</code> method embeds a string in a <code>&lt;sup&gt;</code> tag: <code>"&lt;sup&gt;str&lt;/sup&gt;"</code>.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h4 id="Przyk.C5.82ad:_Zastosowanie_metody_sub_i_sup_do_zmiany_formatu_.C5.82a.C5.84cucha_znak.C3.B3w" name="Przyk.C5.82ad:_Zastosowanie_metody_sub_i_sup_do_zmiany_formatu_.C5.82a.C5.84cucha_znak.C3.B3w">Przykład: Zastosowanie metody <code>sub()</code> i <code>sup()</code></h4>
+
+<p>Następujący przykład stosuje metodę {{jsxref("String.prototype.sub()", "sub()")}} i <code>sup()</code> do zmiany formatu łańcucha znaków:</p>
+
+<pre class="brush: js">var superText="superscript";
+var subText="subscript";
+
+console.log("This is what a " + superText.sup() + " looks like.");
+// This is what a &lt;sup&gt;superscript&lt;/sup&gt; looks like
+
+console.log("This is what a " + subText.sub() + " looks like.");
+// This is what a &lt;sub&gt;subscript&lt;/sub&gt; looks like.</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.sub()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/pl/web/javascript/reference/global_objects/string/tolowercase/index.html
new file mode 100644
index 0000000000..8cb6d10a10
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/tolowercase/index.html
@@ -0,0 +1,41 @@
+---
+title: String.prototype.toLowerCase()
+slug: Web/JavaScript/Reference/Global_Objects/String/toLowerCase
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase
+original_slug: Web/JavaScript/Referencje/Obiekty/String/toLowerCase
+---
+<p>{{jsref}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca wartość wywołującego łańcucha znaków, skonwertowaną na małe litery.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.toLowerCase()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>toLowerCase()</code> zwraca wartość łańcucha znaków skonwertowanego na małe litery. <code>toLowerCase()</code> nie wpływa na wartość samego łańcucha.</p>
+
+<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3>
+
+<h4 id="Przyk.C5.82ad:_Zastosowanie_toLowerCase" name="Przyk.C5.82ad:_Zastosowanie_toLowerCase">Przykład: Zastosowanie <code>toLowerCase</code></h4>
+
+<p>Następujący przykład wyświetli łańcuch "<code>alfabet</code>" złożony z małych liter:</p>
+
+<pre class="brush: js">console.log('ALFABET'.toLowerCase()); // 'alfabet'
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
+ <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
+ <li>{{jsxref("String.prototype.toUpperCase()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/tosource/index.html b/files/pl/web/javascript/reference/global_objects/string/tosource/index.html
new file mode 100644
index 0000000000..3540727b00
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/tosource/index.html
@@ -0,0 +1,42 @@
+---
+title: String.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/String/toSource
+tags:
+  - JavaScript
+  - Method
+  - Non-standard
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource
+original_slug: Web/JavaScript/Referencje/Obiekty/String/toSource
+---
+<p>{{JSRef}}{{non-standard_header}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący kod źródłowy obiektu.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>String.toSource()
+<var>str</var>.toSource()
+</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>toSource()</code> zwraca następujące wartości:</p>
+
+<ul>
+ <li>Dla wbudowanego obiektu {{jsxref("String")}}, <code>toSource()</code> zwraca następujący łańcuch znaków wskazujący, że kod źródłowy nie jest dostępny:
+
+  <pre class="brush: js">function String() {
+   [natywny kod]
+}
+</pre>
+ </li>
+ <li>W przypadku obiektu {{jsxref("String")}} lub łańcuchów znaków, <code>toSource()</code> zwraca łańcuch znaków reprezentujący kod źródłowy.</li>
+</ul>
+
+<p>Ta metoda jest w JavaScript wywoływana zazwyczaj wewnętrznie, nie bezpośrednio w kodzie.</p>
+
+<div class="noinclude"> </div>
diff --git a/files/pl/web/javascript/reference/global_objects/string/tostring/index.html b/files/pl/web/javascript/reference/global_objects/string/tostring/index.html
new file mode 100644
index 0000000000..ab19cbe40c
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/tostring/index.html
@@ -0,0 +1,42 @@
+---
+title: String.protype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/String/toString
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toString
+original_slug: Web/JavaScript/Referencje/Obiekty/String/toString
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca łańcuch znaków reprezentujący dany obiekt.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.toString()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Obiekt {{jsxref("String")}} przesłania metodę <code>toString</code> obiektu {{jsxref("Object")}}; nie dziedziczy {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref("String")}}, metoda <code>toString()</code> zwraca łańcuch znaków reprezentujący obiekt.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_toString" name="Przyk.C5.82ad:_Zastosowanie_toString">Przykład: Zastosowanie <code>toString()</code></h3>
+
+<p>Następujący przykład wyświetli wartość łańcuch znaków obiektu {{jsxref("String")}}:</p>
+
+<pre class="brush: js">var x = new String("Witaj świecie");
+
+console.log(x.toString())      // Wyświetla "Witaj świecie"
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+ <li>{{jsxref("String.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/touppercase/index.html b/files/pl/web/javascript/reference/global_objects/string/touppercase/index.html
new file mode 100644
index 0000000000..f56902e420
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/touppercase/index.html
@@ -0,0 +1,39 @@
+---
+title: String.prototype.toUpperCase()
+slug: Web/JavaScript/Reference/Global_Objects/String/toUpperCase
+tags:
+  - JavaScript
+  - Method
+  - Prototype
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase
+original_slug: Web/JavaScript/Referencje/Obiekty/String/toUpperCase
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca wartość wywołującego łańcucha znaków, skonwertowaną na duże litery.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.toUpperCase()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>toUpperCase()</code> zwraca wartość łańcucha znaków skonwertowanego na duże litery. <code>toUpperCase()</code> nie wpływa na wartość samego łańcucha.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_toUpperCase" name="Przyk.C5.82ad:_Zastosowanie_toUpperCase">Przykład: Zastosowanie <code>toUpperCase()</code></h3>
+
+<pre class="brush: js">console.log('alfabet'.toUpperCase()); // 'ALFABET'
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
+ <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
+ <li>{{jsxref("String.prototype.toLowerCase()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/string/valueof/index.html b/files/pl/web/javascript/reference/global_objects/string/valueof/index.html
new file mode 100644
index 0000000000..9d7e986682
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/string/valueof/index.html
@@ -0,0 +1,41 @@
+---
+title: String.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/String/valueOf
+tags:
+  - JavaScript
+  - Method
+  - Property
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf
+original_slug: Web/JavaScript/Referencje/Obiekty/String/valueOf
+---
+<p>{{JSRef}}</p>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Zwraca pierwotną wartość obiektu {{jsxref("String")}}.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code><var>str</var>.valueOf()</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Metoda <code>valueOf()</code> obiektu {{jsxref("String")}} zwraca pierwotną wartość obiektu {{jsxref("String")}} jako łańcuch znaków. Ta wartość jest równoważna do {{jsxref("String.prototype.toString()")}}.</p>
+
+<p>Ta metoda jest w JavaScript wywoływana zazwyczaj wewnętrznie, nie bezpośrednio w kodzie.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<h3 id="Przyk.C5.82ad:_Zastosowanie_valueOf" name="Przyk.C5.82ad:_Zastosowanie_valueOf">Przykład: Zastosowanie <code>valueOf()</code></h3>
+
+<pre class="brush: js">var x = new String("Witaj świecie");
+console.log(x.valueOf()); // Wyświetla "Witaj świecie"
+</pre>
+
+<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.toString()")}}</li>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/symbol/index.html b/files/pl/web/javascript/reference/global_objects/symbol/index.html
new file mode 100644
index 0000000000..4ff4612b3f
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/symbol/index.html
@@ -0,0 +1,228 @@
+---
+title: Symbol
+slug: Web/JavaScript/Reference/Global_Objects/Symbol
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol
+original_slug: Web/JavaScript/Referencje/Obiekty/Symbol
+---
+<div>{{JSRef}}</div>
+
+<p>Funkcja <code>Symbol()</code> zwraca wartość typu <strong>symbol</strong>, posiada statyczne własności wystawiające kilka wartości używanych we wbudowanych obiektach, posiada statyczne metody wystawiające globalny rejestr symboli i przypomina wbudowaną klasę obiektu, jest jednak niekompletna jako konstruktor ponieważ nie wspiera składni "<code>new Symbol()</code>".  </p>
+
+<p>Każdy symbol zwrócony przez <code>Symbol()</code> jest unikalny. Symbol powinien być użyty jako identyfikator własności obiektu, został zaprojektowany jedynie w tym celu. Pełniejsze wyjaśnienie dotyczące jego przeznaczenia i użycia można znaleźć w <a href="/en-US/docs/Glossary/Symbol">poświęconym mu wpisie w glosariuszu</a>.</p>
+
+<p>Typ <strong>symbol</strong> jest {{Glossary("Primitive", "typem prostym")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-constructor.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">Symbol(<em>[opis]</em>)</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>opis</code> {{optional_inline}}</dt>
+ <dd>Ciąg znaków, parametr opcjonalny. Opis symbolu, może być użyty do debugowania, ale nie do dostania się do samego symbolu.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Aby stworzyć nowy symbol należy użyć funkcji <code>Symbol()</code>, opcjonalnie przekazując jej opisowy ciąg znaków:</p>
+
+<pre class="brush: js">var sym1 = Symbol();
+var sym2 = Symbol('foo');
+var sym3 = Symbol('foo');
+</pre>
+
+<p>Powyższy kod tworzy trzy nowe symbole. Należy zwrócić uwagę, że <code>Symbol("foo")</code> nie konwertuje ciągu znaków "foo" na symbol, tylko tworzy za każdym razem nowy symbol:</p>
+
+<pre class="brush: js">Symbol('foo') === Symbol('foo'); // false</pre>
+
+<p>Następująca składnia z operatorem {{jsxref("Operators/new", "new")}} spowoduje wyjątek {{jsxref("TypeError")}}:</p>
+
+<pre class="brush: js">var sym = new Symbol(); // TypeError</pre>
+
+<p>Dzieje się tak dlatego żeby powstrzymać programistów przed opakowywaniem wartości symboli w obiekty i może być zaskakujące, gdyż tworzenie opakowanych wartości dla typów prostych jest zazwyczaj możliwe (na przykład <code>new Boolean</code>, <code>new String</code> i <code>new Number</code>).</p>
+
+<p>Jeśli stworzenie opakowanego symbolu jest dokładnie tym czego chce programista, może do tego użyć funkcji <code>Object()</code>:</p>
+
+<pre class="brush: js">var sym = Symbol('foo');
+typeof sym;     // "symbol"
+var symObj = Object(sym);
+typeof symObj;  // "object"
+</pre>
+
+<h3 id="Symbole_współdzielone_w_globalnym_rejestrze_symboli">Symbole współdzielone w globalnym rejestrze symboli</h3>
+
+<p>Powyższa składnia używająca funkcji <code>Symbol()</code> nie stworzy globalnego symbolu, który będzie dostępny w całym kodzie. Aby stworzyć symbol dostępny między plikami, a nawet między sferami (z których każda ma swoją globalną przestrzeń) należy użyć metody {{jsxref("Symbol.for()")}}. Z kolei metody {{jsxref("Symbol.keyFor()")}} można użyć aby uzyskać nazwę globalnego klucza dla posiadanego symbolu.</p>
+
+<h3 id="Znajdowanie_własności_indeksowanych_symbolami_na_obiekcie">Znajdowanie własności indeksowanych symbolami na obiekcie</h3>
+
+<p>Metoda {{jsxref("Object.getOwnPropertySymbols()")}} zwraca tablicę symboli i pozwala znaleźć własności indeksowane symbolami na danym obiekcie. Każdy obiekt jest inicjowany bez takich własności, więc metoda ta zwróci pustą tablicę do czasu ustawienia na obiekcie własności pod kluczem typu symbol.</p>
+
+<h2 id="Własności">Własności</h2>
+
+<dl>
+ <dt><code>Symbol.length</code></dt>
+ <dd>Własność length której wartością jest 0.</dd>
+ <dt>{{jsxref("Symbol.prototype")}}</dt>
+ <dd>Reprezentuje prototyp konstruktora <code>Symbol</code>.</dd>
+</dl>
+
+<h3 id="Znane_symbole">Znane symbole</h3>
+
+<p>Oprócz symboli zdefiniowanych przez programistę, JavaScript posiada wbudowane symbole reprezentujące wewnętrzne mechanizmy języka, które nie były widoczne dla programisty w wersji ECMAScript 5 i wcześniejszych. Dostęp do tych symboli jest możliwy za pomocą następujących własności statycznych:</p>
+
+<h4 id="Symbole_iteracji">Symbole iteracji</h4>
+
+<dl>
+ <dt>{{jsxref("Symbol.iterator")}}</dt>
+ <dd>Metoda zwracająca domyślny iterator dla obiektu. Używana przez <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>.</dd>
+ <dt>{{jsxref("Symbol.asyncIterator")}} {{experimental_inline}}</dt>
+ <dd>Metoda zwracająca domyślny asynchroniczny iterator dla obiektu. Używana przez <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for-await-of"><code>for await of</code></a>.</dd>
+</dl>
+
+<h4 id="Symbole_wyrażeń_regularnych">Symbole wyrażeń regularnych</h4>
+
+<dl>
+ <dt>{{jsxref("Symbol.match")}}</dt>
+ <dd>Metoda dopasowująca dla ciągu znaków, używana również dla określenia czy obiekt może zostać użyty jako wyrażenie regularne. Używana przez {{jsxref("String.prototype.match()")}}.</dd>
+ <dt>{{jsxref("Symbol.replace")}}</dt>
+ <dd>Metoda zastępująca dopasowany ciąg w ciągu znaków. Używana przez {{jsxref("String.prototype.replace()")}}.</dd>
+ <dt>{{jsxref("Symbol.search")}}</dt>
+ <dd>Metoda zwracająca indeks początku ciągu znaków który został dopasowany do wyrażenia regularnego. Używana przez {{jsxref("String.prototype.search()")}}.</dd>
+ <dt>{{jsxref("Symbol.split")}}</dt>
+ <dd>Metoda dzieląca łańcuch znaków w miejscu w którym został dopasowany do wyrażenia regularnego. Używana przez {{jsxref("String.prototype.split()")}}.</dd>
+</dl>
+
+<h4 id="Pozostałe_symbole">Pozostałe symbole</h4>
+
+<dl>
+ <dt>{{jsxref("Symbol.hasInstance")}}</dt>
+ <dd>Metoda określająca czy konstruktor rozpoznaje obiekt jako swoją instancję. Używana przez {{jsxref("Operators/instanceof", "instanceof")}}.</dd>
+ <dt>{{jsxref("Symbol.isConcatSpreadable")}}</dt>
+ <dd>Wartość logiczna określająca czy obiekt powinien zostać spłaszczony do jego elementów tablicy. Używana przez {{jsxref("Array.prototype.concat()")}}.</dd>
+ <dt>{{jsxref("Symbol.unscopables")}}</dt>
+ <dd>Wartość obiektu którego własne i dziediczone nazwy własności są wykluczone ze środowiska <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> powiązanego obiektu.</dd>
+ <dt>{{jsxref("Symbol.species")}}</dt>
+ <dd>Funkcja konstruktora używana do tworzenia obiektów wywodzących się z danego.</dd>
+ <dt>{{jsxref("Symbol.toPrimitive")}}</dt>
+ <dd>Metoda konwertująca obiekt na typ prosty.</dd>
+ <dt>{{jsxref("Symbol.toStringTag")}}</dt>
+ <dd>Ciąg znaków używany dla domyślnego opisu obiektu. Używany przez {{jsxref("Object.prototype.toString()")}}.</dd>
+</dl>
+
+<h2 id="Metody">Metody</h2>
+
+<dl>
+ <dt>{{jsxref("Symbol.for()", "Symbol.for(key)")}}</dt>
+ <dd>Szuka istniejącego symbolu o podanym kluczu i zwraca go, jeśli został znaleziony. W przeciwnym razie w globalnym rejestrze tworzony jest nowy symbol o podanym kluczu i również zwracany.</dd>
+ <dt>{{jsxref("Symbol.keyFor", "Symbol.keyFor(sym)")}}</dt>
+ <dd>Zwraca klucz w globalnym rejestrze zapisany dla danego symbolu.</dd>
+</dl>
+
+<h2 id="Symbol_prototype"><code>Symbol</code> prototype</h2>
+
+<p>Wszystkie symbole dziecidzą po {{jsxref("Symbol.prototype")}}.</p>
+
+<h3 id="Własności_2">Własności</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Properties')}}</p>
+
+<h3 id="Metody_2">Metody</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Methods')}}</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Używanie_operatora_typeof_z_symbolami">Używanie operatora <code>typeof</code> z symbolami</h3>
+
+<p>Operator {{jsxref("Operators/typeof", "typeof")}} może pomóc w identyfikacji symboli.</p>
+
+<pre class="brush: js">typeof Symbol() === 'symbol'
+typeof Symbol('foo') === 'symbol'
+typeof Symbol.iterator === 'symbol'
+</pre>
+
+<h3 id="Konwersje_typu_symbol">Konwersje typu symbol</h3>
+
+<ul>
+ <li>Podczas próby konwersji symbolu na liczbę zostanie rzucony wyjątek {{jsxref("TypeError")}}.<br>
+  (np. <code>+sym</code> lub <code>sym | 0</code>).</li>
+ <li>Przy porównaniu z pominięciem typu <code>Object(sym) == sym</code> zwraca <code>true.</code></li>
+ <li><code>Symbol("foo") + "bar" </code>wyrzuci {{jsxref("TypeError")}} (nie można skonwertować symbolu na ciąg znaków). Służy to powstrzymaniu programisty na przykład przed stworzeniem nowej nazwy własności z użyciem symbolu.</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#String_conversion">"Bezpieczniejsza" konwersja <code>String(sym)</code></a> działa jak wywołanie {{jsxref("Symbol.prototype.toString()")}} ale należy mieć na uwadze, że <code>new String(sym)</code> rzuci wyjątkiem.</li>
+</ul>
+
+<h3 id="Symbole_i_iteracja_for...in">Symbole i iteracja <code>for...in</code></h3>
+
+<p>Symbole nie są iterowalne w pętlach <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a>. Dodatkowo, {{jsxref("Object.getOwnPropertyNames()")}} nie zwróci własności obiektu zapisanych pod kluczem którym jest symbol, do tego celu można użyć {{jsxref("Object.getOwnPropertySymbols()")}}.</p>
+
+<pre class="brush: js">var obj = {};
+
+obj[Symbol('a')] = 'a';
+obj[Symbol.for('b')] = 'b';
+obj['c'] = 'c';
+obj.d = 'd';
+
+for (var i in obj) {
+   console.log(i); // loguje "c" i "d"
+}</pre>
+
+<h3 id="Symbole_i_JSON.stringify()">Symbole i <code>JSON.stringify()</code></h3>
+
+<p>Własności obiektu znajdujące się pod kluczem w postaci symbolu są ignorowane przez <code>JSON.stringify()</code>:</p>
+
+<pre class="brush: js">JSON.stringify({[Symbol('foo')]: 'foo'});
+// '{}'</pre>
+
+<p>Żeby dowiedzieć się więcej zobacz {{jsxref("JSON.stringify()")}}.</p>
+
+<h3 id="Symbole_opakowane_w_obiekty_jako_klucze_własności">Symbole opakowane w obiekty jako klucze własności</h3>
+
+<p>Gdy symbol opakowany w obiekt jest użyty jako klucz własności, obiekt opakowujący zostanie skonwertowany do symbolu który opakowuje:</p>
+
+<pre class="brush: js">var sym = Symbol('foo');
+var obj = {[sym]: 1};
+obj[sym];            // 1
+obj[Object(sym)];    // nadal 1
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-symbol-objects', 'Symbol')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Wstępna definicja</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol-objects', 'Symbol')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol")}}</p>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Glossary/Symbol">Glosariusz: typ Symbol</a></li>
+ <li>{{jsxref("Operators/typeof", "typeof")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Data_structures">Typy i struktury danych</a></li>
+ <li><a href="https://hacks.mozilla.org/2015/06/es6-in-depth-symbols/">"ES6 In Depth: Symbols" na hacks.mozilla.org</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/syntaxerror/index.html b/files/pl/web/javascript/reference/global_objects/syntaxerror/index.html
new file mode 100644
index 0000000000..eaef4344ce
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/syntaxerror/index.html
@@ -0,0 +1,101 @@
+---
+title: SyntaxError
+slug: Web/JavaScript/Reference/Global_Objects/SyntaxError
+tags:
+  - Błąd składniowy
+  - JavaScript
+  - Klasa
+  - Obiekt
+  - Referencja
+  - SyntaxError
+translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError
+original_slug: Web/JavaScript/Referencje/Obiekty/SyntaxError
+---
+<div>{{JSRef}}</div>
+
+<p>Obiekt <code><strong>SyntaxError</strong></code> reprezentuje błąd przy próbie interpretacji kodu niepoprawnego pod względem składni. Jest wyrzucany wtedy, gdy silnik JavaScript podczas interpretacji kodu napotyka znak lub ciąg znaków niezgodny ze składnią języka.</p>
+
+<h2 id="Konstruktor">Konstruktor</h2>
+
+<dl>
+ <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/SyntaxError"><code>SyntaxError()</code></a></dt>
+ <dd>Tworzy nowy obiekt <code>SyntaxError</code>.</dd>
+</dl>
+
+<h2 id="Właściwości_instancji">Właściwości instancji</h2>
+
+<dl>
+ <dt>{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}</dt>
+ <dd>Wiadomość błędu. Chociaż ECMA-262 mówi, że {{jsxref("SyntaxError")}} powinien dostarczać własną właściwość <code>message</code>, w <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> jest ona dziedziczona z {{jsxref("Error.prototype.message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}</dt>
+ <dd>Nazwa błędu. Odziedziczone z {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}</dt>
+ <dd>Ścieżka do pliku zawierającego błąd. Odziedziczone z {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}</dt>
+ <dd>Numer zawierającej błąd linii w pliku. Odziedziczone z {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}</dt>
+ <dd>Numer zawierającej błąd kolumny w linii kodu. Odziedziczone z {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}}</dt>
+ <dd>Stos wywołań. Odziedziczone z {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Obsługa_SyntaxError">Obsługa <code>SyntaxError</code></h3>
+
+<pre class="brush: js">try {
+  eval('hoo bar');
+} catch (e) {
+  console.error(e instanceof SyntaxError);
+  console.error(e.message);
+  console.error(e.name);
+  console.error(e.fileName);
+  console.error(e.lineNumber);
+  console.error(e.columnNumber);
+  console.error(e.stack);
+}
+</pre>
+
+<h3 id="Tworzenie_SyntaxError">Tworzenie <code>SyntaxError</code></h3>
+
+<pre class="brush: js">try {
+  throw new SyntaxError('Hej', 'jakisPlik.js', 10);
+} catch (e) {
+  console.error(e instanceof SyntaxError); // true
+  console.error(e.message);                // Hej
+  console.error(e.name);                   // SyntaxError
+  console.error(e.fileName);               // jakisPlik.js
+  console.error(e.lineNumber);             // 10
+  console.error(e.columnNumber);           // 0
+  console.error(e.stack);                  // @debugger eval code:3:9
+}
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-syntaxerror', 'SyntaxError')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.SyntaxError")}}</p>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Error")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/uint16array/index.html b/files/pl/web/javascript/reference/global_objects/uint16array/index.html
new file mode 100644
index 0000000000..759ad9d56e
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/uint16array/index.html
@@ -0,0 +1,225 @@
+---
+title: Uint16Array
+slug: Web/JavaScript/Reference/Global_Objects/Uint16Array
+translation_of: Web/JavaScript/Reference/Global_Objects/Uint16Array
+original_slug: Web/JavaScript/Referencje/Obiekty/Uint16Array
+---
+<div>{{JSRef("Global_Objects", "TypedArray", "Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array")}}</div>
+
+<h2 id="Summary">Summary</h2>
+
+<p>The <strong><code>Uint16Array</code></strong> typed array represents an array of 16-bit unsigned integers in the platform byte order. If control over byte order is needed, use {{jsxref("DataView")}} instead. The contents are initialized to <code>0</code>. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Uint16Array(length);
+Uint16Array(typedArray);
+Uint16Array(object);
+Uint16Array(buffer [, byteOffset [, length]]);</pre>
+
+<p>For more information about the constructor syntax and the parameters, see <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p>
+
+<h2 id="Properties">Properties</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Uint16Array.BYTES_PER_ELEMENT")}}</dt>
+ <dd>Returns a number value of the element size. <code>2</code> in the case of an <code>Uint16Array</code>.</dd>
+ <dt>Uint16Array.length</dt>
+ <dd>Length property whose value is 3.</dd>
+ <dt>{{jsxref("TypedArray.name", "Uint16Array.name")}}</dt>
+ <dd>Returns the string value of the constructor name. In the case of the <code>Uint16Array</code> type: "Uint16Array".</dd>
+ <dt>{{jsxref("TypedArray.prototype", "Uint16Array.prototype")}}</dt>
+ <dd>Prototype for the <em>TypedArray</em> objects.</dd>
+</dl>
+
+<h2 id="Methods">Methods</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.from", "Uint16Array.from()")}}</dt>
+ <dd>Creates a new <code>Uint16Array</code> from an array-like or iterable object. See also {{jsxref("Array.from()")}}.</dd>
+ <dt>{{jsxref("TypedArray.of", "Uint16Array.of()")}}</dt>
+ <dd>Creates a new <code>Uint16Array</code> with a variable number of arguments. See also {{jsxref("Array.of()")}}.</dd>
+</dl>
+
+<h2 id="Boolean_instances" name="Boolean_instances"><code>Uint16Array</code> prototype</h2>
+
+<p>All <code>Uint16Array</code> objects inherit from {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
+
+<h3 id="Properties_2">Properties</h3>
+
+<dl>
+ <dt><code>Uint16Array.prototype.constructor</code></dt>
+ <dd>Returns the function that created an instance's prototype. This is the <code>Uint16Array</code> constructor by default.</dd>
+ <dt>{{jsxref("TypedArray.prototype.buffer", "Uint16Array.prototype.buffer")}} {{readonlyInline}}</dt>
+ <dd>Returns the {{jsxref("ArrayBuffer")}} referenced by the <code>Uint16Array</code> Fixed at construction time and thus <strong>read only</strong>.</dd>
+ <dt>{{jsxref("TypedArray.prototype.byteLength", "Uint16Array.prototype.byteLength")}} {{readonlyInline}}</dt>
+ <dd>Returns the length (in bytes) of the <code>Uint16Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd>
+ <dt>{{jsxref("TypedArray.prototype.byteOffset", "Uint16Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
+ <dd>Returns the offset (in bytes) of the <code>Uint16Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd>
+ <dt>{{jsxref("TypedArray.prototype.length", "Uint16Array.prototype.length")}} {{readonlyInline}}</dt>
+ <dd>Returns the number of elements hold in the <code>Uint16Array</code>. Fixed at construction time and thus <strong>read only.</strong></dd>
+</dl>
+
+<h3 id="Methods_2">Methods</h3>
+
+<dl>
+ <dt>{{jsxref("TypedArray.copyWithin", "Uint16Array.prototype.copyWithin()")}}</dt>
+ <dd>Copies a sequence of array elements within the array. See also {{jsxref("Array.prototype.copyWithin()")}}.</dd>
+ <dt>{{jsxref("TypedArray.entries", "Uint16Array.prototype.entries()")}}</dt>
+ <dd>Returns a new <code>Array Iterator</code> object that contains the key/value pairs for each index in the array. See also {{jsxref("Array.prototype.entries()")}}.</dd>
+ <dt>{{jsxref("TypedArray.every", "Uint16Array.prototype.every()")}}</dt>
+ <dd>Tests whether all elements in the array pass the test provided by a function. See also {{jsxref("Array.prototype.every()")}}.</dd>
+ <dt>{{jsxref("TypedArray.fill", "Uint16Array.prototype.fill()")}}</dt>
+ <dd>Fills all the elements of an array from a start index to an end index with a static value. See also {{jsxref("Array.prototype.fill()")}}.</dd>
+ <dt>{{jsxref("TypedArray.filter", "Uint16Array.prototype.filter()")}}</dt>
+ <dd>Creates a new array with all of the elements of this array for which the provided filtering function returns true. See also {{jsxref("Array.prototype.filter()")}}.</dd>
+ <dt>{{jsxref("TypedArray.find", "Uint16Array.prototype.find()")}}</dt>
+ <dd>Returns the found value in the array, if an element in the array satisfies the provided testing function or <code>undefined</code> if not found. See also {{jsxref("Array.prototype.find()")}}.</dd>
+ <dt>{{jsxref("TypedArray.findIndex", "Uint16Array.prototype.findIndex()")}}</dt>
+ <dd>Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found. See also {{jsxref("Array.prototype.findIndex()")}}.</dd>
+ <dt>{{jsxref("TypedArray.forEach", "Uint16Array.prototype.forEach()")}}</dt>
+ <dd>Calls a function for each element in the array. See also {{jsxref("Array.prototype.forEach()")}}.</dd>
+ <dt>{{jsxref("TypedArray.includes", "Uint16Array.prototype.includes()")}} {{experimental_inline}}</dt>
+ <dd>Determines whether a typed array includes a certain element, returning <code>true</code> or <code>false</code> as appropriate. See also {{jsxref("Array.prototype.includes()")}}.</dd>
+ <dt>{{jsxref("TypedArray.indexOf", "Uint16Array.prototype.indexOf()")}}</dt>
+ <dd>Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.indexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.join", "Uint16Array.prototype.join()")}}</dt>
+ <dd>Joins all elements of an array into a string. See also {{jsxref("Array.prototype.join()")}}.</dd>
+ <dt>{{jsxref("TypedArray.keys", "Uint16Array.prototype.keys()")}}</dt>
+ <dd>Returns a new <code>Array Iterator</code> that contains the keys for each index in the array. See also {{jsxref("Array.prototype.keys()")}}.</dd>
+ <dt>{{jsxref("TypedArray.lastIndexOf", "Uint16Array.prototype.lastIndexOf()")}}</dt>
+ <dd>Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.map", "Uint16Array.prototype.map()")}}</dt>
+ <dd>Creates a new array with the results of calling a provided function on every element in this array. See also {{jsxref("Array.prototype.map()")}}.</dd>
+ <dt>{{jsxref("TypedArray.move", "Uint16Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
+ <dd>Former non-standard version of {{jsxref("TypedArray.copyWithin", "Uint16Array.prototype.copyWithin()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reduce", "Uint16Array.prototype.reduce()")}}</dt>
+ <dd>Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduce()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reduceRight", "Uint16Array.prototype.reduceRight()")}}</dt>
+ <dd>Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduceRight()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reverse", "Uint16Array.prototype.reverse()")}}</dt>
+ <dd>Reverses the order of the elements of an array — the first becomes the last, and the last becomes the first. See also {{jsxref("Array.prototype.reverse()")}}.</dd>
+ <dt>{{jsxref("TypedArray.set", "Uint16Array.prototype.set()")}}</dt>
+ <dd>Stores multiple values in the typed array, reading input values from a specified array.</dd>
+ <dt>{{jsxref("TypedArray.slice", "Uint16Array.prototype.slice()")}}</dt>
+ <dd>Extracts a section of an array and returns a new array. See also {{jsxref("Array.prototype.slice()")}}.</dd>
+ <dt>{{jsxref("TypedArray.some", "Uint16Array.prototype.some()")}}</dt>
+ <dd>Returns true if at least one element in this array satisfies the provided testing function. See also {{jsxref("Array.prototype.some()")}}.</dd>
+ <dt>{{jsxref("TypedArray.sort", "Uint16Array.prototype.sort()")}}</dt>
+ <dd>Sorts the elements of an array in place and returns the array. See also {{jsxref("Array.prototype.sort()")}}.</dd>
+ <dt>{{jsxref("TypedArray.subarray", "Uint16Array.prototype.subarray()")}}</dt>
+ <dd>Returns a new <code>Uint16Array</code> from the given start and end element index.</dd>
+ <dt>{{jsxref("TypedArray.values", "Uint16Array.prototype.values()")}}</dt>
+ <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array. See also {{jsxref("Array.prototype.values()")}}.</dd>
+ <dt>{{jsxref("TypedArray.toLocaleString", "Uint16Array.prototype.toLocaleString()")}}</dt>
+ <dd>Returns a localized string representing the array and its elements. See also {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.toString", "Uint16Array.prototype.toString()")}}</dt>
+ <dd>Returns a string representing the array and its elements. See also {{jsxref("Array.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.@@iterator", "Uint16Array.prototype[@@iterator]()")}}</dt>
+ <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array.</dd>
+</dl>
+
+<h2 id="Examples">Examples</h2>
+
+<pre class="brush: js">// From a length
+var uint16 = new Uint16Array(2);
+uint16[0] = 42;
+console.log(uint16[0]); // 42
+console.log(uint16.length); // 2
+console.log(uint16.BYTES_PER_ELEMENT); // 2
+
+// From an array
+var arr = new Uint16Array([21,31]);
+console.log(arr[1]); // 31
+
+// From another TypedArray
+var x = new Uint16Array([21, 31]);
+var y = new Uint16Array(x);
+console.log(y[0]); // 21
+
+// From an ArrayBuffer
+var buffer = new ArrayBuffer(8);
+var z = new Uint16Array(buffer, 0, 4);
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td><a href="https://www.khronos.org/registry/typedarray/specs/latest/#7">Typed Array Specification</a></td>
+   <td>Obsolete</td>
+   <td><span><span>Superseded by ECMAScript 6.</span></span></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#table-45', 'TypedArray constructors')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition in an ECMA standard.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>7.0</td>
+   <td>{{ CompatGeckoDesktop("2") }}</td>
+   <td>10</td>
+   <td>11.6</td>
+   <td>5.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>4.0</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatGeckoMobile("2") }}</td>
+   <td>10</td>
+   <td>11.6</td>
+   <td>4.2</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li>{{jsxref("DataView")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/global_objects/undefined/index.html b/files/pl/web/javascript/reference/global_objects/undefined/index.html
new file mode 100644
index 0000000000..f2e31e90c2
--- /dev/null
+++ b/files/pl/web/javascript/reference/global_objects/undefined/index.html
@@ -0,0 +1,41 @@
+---
+title: undefined
+slug: Web/JavaScript/Reference/Global_Objects/undefined
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/undefined
+original_slug: Web/JavaScript/Referencje/Obiekty/undefined
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>
+
+<p>Wartość niezdefiniowana.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><code>undefined</code></pre>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p><code>undefined</code> jest własnością najwyższego rzędu i nie jest przypisana do żadnego obiektu.</p>
+
+<p>Zmienna, której nie przypisano wartości, jest typu undefined. Metoda lub wyrażenie zwraca <code>undefined</code>, jeśli wyliczana zmienna nie posiada wartości.</p>
+
+<p>Można wykorzystać <code>undefined</code> do zbadania, czy dana zmienna ma wartość. W poniższym kodzie zmienna <code>x</code> nie jest zdefiniowana i wyrażenie <code>if</code> ma wartość "prawda" (true).</p>
+
+<pre class="brush: js">var x;
+if (x === undefined) {
+   // polecenia tu umieszczone są wykonywane
+} else {
+   // polecenia tu umieszczone nie są wykonywane
+}
+</pre>
+
+<p><code>undefined</code> jest także wartością prostą.</p>
diff --git a/files/pl/web/javascript/reference/index.html b/files/pl/web/javascript/reference/index.html
new file mode 100644
index 0000000000..b73167e191
--- /dev/null
+++ b/files/pl/web/javascript/reference/index.html
@@ -0,0 +1,71 @@
+---
+title: Dokumentacja referencyjna JavaScript
+slug: Web/JavaScript/Reference
+tags:
+  - AJAX
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference
+original_slug: Web/JavaScript/Referencje
+---
+<h4 id="JsSidebar">{{JsSidebar}}</h4>
+
+<p>Ta część rozdziału JavaScript na MDN służy jako repozytorium faktów dotyczących jezyka JavaScript. Więcej na ten temat na stronie <a href="/pl/docs/Web/JavaScript/Reference/About">O dokumentacji referencyjnej</a>.<br>
+  </p>
+
+<h2 id="Obiekty_globalne">Obiekty globalne</h2>
+
+<p>W tym rozdziale udokumentowano wszystkie <a href="/pl/docs/Web/JavaScript/Reference/Global_Objects">standardowe wbudowane obiekty JavaScript</a>, wraz z ich metodami i właściwościami.<br>
+  </p>
+
+<p>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects', 'Standard_objects_by_category')}}</p>
+
+<h2 id="Instrukcje">Instrukcje</h2>
+
+<p>Rozdział ten dokumentuje wszystkie  <a href="/pl/docs/Web/JavaScript/Reference/Statements">deklaracje i instrukcje JavaScript</a>.</p>
+
+<p>{{page('/en-US/docs/Web/JavaScript/Reference/Statements', 'Statements_and_declarations_by_category')}}</p>
+
+<p> </p>
+
+<h2 id="Wyrażenia_i_operatory">Wyrażenia i operatory</h2>
+
+<p>Udokumentowano tu wszystkie <a href="/pl/docs/Web/JavaScript/Reference/Operators">wyrażenie i operatory JavaScript</a>.</p>
+
+<p>{{page('/en-US/docs/Web/JavaScript/Reference/Operators', 'Expressions_and_operators_by_category')}}</p>
+
+<p> </p>
+
+<h2 id="Funkcje">Funkcje</h2>
+
+<p>W tym rozdziale opisano pracę z <a href="/pl/docs/Web/JavaScript/Reference/Functions">funkcjami JavaScript</a> przy tworzeniu aplikacji.</p>
+
+<ul>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/arguments"><code>argumenty</code></a></li>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/Arrow_functions">funkcje strzałkowe</a></li>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/Default_parameters">parametry domyślne</a></li>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/rest_parameters">parametry resztowe</a></li>
+</ul>
+
+<p> </p>
+
+<h2 id="Dodatkowe_strony_z_informacjami">Dodatkowe strony z informacjami</h2>
+
+<ul>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Lexical_grammar">Gramatyka leksykalna</a></li>
+ <li><a href="/pl/docs/Web/JavaScript/Data_structures">Typy danych i struktury danych</a></li>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Strict_mode">Tryb ścisły</a></li>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features">Funkcjonalności zdeprecjonowane</a></li>
+</ul>
+
+<p> </p>
+
+<p> </p>
+
+<p> </p>
+
+<p> </p>
+
+<p> </p>
diff --git a/files/pl/web/javascript/reference/lexical_grammar/index.html b/files/pl/web/javascript/reference/lexical_grammar/index.html
new file mode 100644
index 0000000000..e91df42d84
--- /dev/null
+++ b/files/pl/web/javascript/reference/lexical_grammar/index.html
@@ -0,0 +1,56 @@
+---
+title: Komentarz
+slug: Web/JavaScript/Reference/Lexical_grammar
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Lexical_grammar#Comments
+translation_of_original: Web/JavaScript/Reference/Code_comments
+original_slug: Web/JavaScript/Referencje/Komentarz
+---
+<p> </p>
+<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3>
+<p>Uwagi od programisty wyjaśniające działanie kodu. Komentarze są ignorowane przez interpreter.</p>
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header" colspan="2">Komentarze</td>
+  </tr>
+  <tr>
+   <td>Zaimplementowane w:</td>
+   <td>JavaScript 1.0, NES2.0</td>
+  </tr>
+  <tr>
+   <td>Wersja ECMA:</td>
+   <td>ECMA-262</td>
+  </tr>
+ </tbody>
+</table>
+<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3>
+<p><code>// tekst komentarza </code></p>
+<p><code>/* wieloliniowy tekst komentarza */ </code></p>
+<h3 id="Opis" name="Opis">Opis</h3>
+<p>JavaScript obsługuje komentarze w stylu Javy:</p>
+<ul>
+ <li>Komentarze zawarte w jednej linii poprzedzone są dwoma ukośnikami (<code>//</code>),</li>
+ <li>Komentarze zawarte w wielu liniach poprzedzone są znakami <code>/*</code>, a zakończone znakami <code>*/</code>. Komentarze wieloliniowe
+  <i>
+   nie mogą</i>
+  być zagnieżdżane.</li>
+</ul>
+<h3 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h3>
+<h4 id="Przyk.C5.82ad:_Komentarz_jednoliniowy" name="Przyk.C5.82ad:_Komentarz_jednoliniowy">Przykład: Komentarz jednoliniowy</h4>
+<pre>// To jest komentarz jednoliniowy.
+var intAge = 37; //To jest inny komentarz
+</pre>
+<h4 id="Przyk.C5.82ad:_Komentarz_wieloliniowy" name="Przyk.C5.82ad:_Komentarz_wieloliniowy">Przykład: Komentarz wieloliniowy</h4>
+<pre>/* To jest komentarz wieloliniowy.
+   Może być dowolnie długi i zawierać dowolne znaki,
+   za wyjątkiem innych komentarzy wieloliniowych. */
+</pre>
+<p> </p>
+<div class="noinclude">
+  </div>
+<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Comments/comment", "es": "es/Referencia_de_JavaScript_1.5/Comentarios/comentario", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Commentaires", "ja": "ja/Core_JavaScript_1.5_Reference/Comments/comment" } ) }}</p>
diff --git a/files/pl/web/javascript/reference/operators/comma_operator/index.html b/files/pl/web/javascript/reference/operators/comma_operator/index.html
new file mode 100644
index 0000000000..b0614efae6
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/comma_operator/index.html
@@ -0,0 +1,38 @@
+---
+title: Operator przecinkowy
+slug: Web/JavaScript/Reference/Operators/Comma_Operator
+tags:
+  - JavaScript
+  - Operator
+  - Przecinek
+  - Przecinkowy
+translation_of: Web/JavaScript/Reference/Operators/Comma_Operator
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_przecinkowy
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<h3 id="Podsumowanie" name="Podsumowanie"></h3>
+
+<p>Operator przecinkowy wykonuje wszystkie argumenty i zwraca wynik ostatniego argumentu.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate"><em>wyr1</em>, <em>wyr2, wyr3...</em></pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>wyr1</code>, <code>wyr2, wyr3</code></dt>
+ <dd>Wyrażenia, z których jedynie ostatnie jest zwracane.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Możemy zastosować operator przecinkowy, kiedy chcemy utworzyć wyrażenie składające się z kilku wyrażeń. Operator przecinkowy jest chyba najczęściej używany w instrukcji pętli for.</p>
+
+<p>Na przykład, jeśli <code>a</code> jest tablicą dwuwymiarową z 10 elementami w sobie, następujący kod użyje operatora przecinkowego do zwiększenia dwóch zmiennych na raz. Kod wypisze wartości elementów ułożonych po przekątnej w tablicy:</p>
+
+<pre class="brush: js notranslate">var a = [[]];
+for (var i=0, j=9; i &lt;= 9; i++, j--)
+   console.log("a["+i+","+j+"]= " + a[i,j])
+</pre>
diff --git a/files/pl/web/javascript/reference/operators/conditional_operator/index.html b/files/pl/web/javascript/reference/operators/conditional_operator/index.html
new file mode 100644
index 0000000000..5714f03aed
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/conditional_operator/index.html
@@ -0,0 +1,35 @@
+---
+title: Operator warunkowy
+slug: Web/JavaScript/Reference/Operators/Conditional_Operator
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Operators/Conditional_Operator
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_warunkowy
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Operator warunkowy jest jedynym operatorem w JavaScript, który pobiera trzy argumenty. Operator jest często stosowany jako skrócenie instrukcji <code>if</code>.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox"><em>warunek</em> ? <em>wyr1</em> : <em>wyr2</em> </pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>warunek</code></dt>
+ <dd>Wyrażenie, które sprawdza czy warunek jest spełniony (<code>true</code> lub <code>false</code>).</dd>
+</dl>
+
+<dl>
+ <dt><code>wyr1</code>, <code>wyr2</code></dt>
+ <dd>Wyrażenia z wartością jakiegoś typu.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Jeśli <code>warunek</code> jest <code>true</code>, operator zwraca wartość <code>wyr1</code>; w przeciwnym razie zwraca wartość <code>wyr2</code>. Na przykład, do wyświetlenia różnych wiadomości opartych na wartości zmiennej <code>isMember</code>, będziesz mógł zastosować poniższą instrukcję:</p>
+
+<pre>console.log("Opłata wynosi " + (isMember ? "$2.00" : "$10.00"));
+console.log("Opłata wynosi " + (zarejestrowany == 1) ? "$2.00" : "$10.00");
+</pre>
diff --git a/files/pl/web/javascript/reference/operators/delete/index.html b/files/pl/web/javascript/reference/operators/delete/index.html
new file mode 100644
index 0000000000..c3652b8a45
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/delete/index.html
@@ -0,0 +1,75 @@
+---
+title: Operator delete
+slug: Web/JavaScript/Reference/Operators/delete
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Operators/delete
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_delete
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Operator delete usuwa obiekt, własność obiektu lub element w określonym indeksie w tablicy.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="syntaxbox">delete <em> nazwaObiektu</em>
+</pre>
+
+<pre class="syntaxbox">delete <em>nazwaObiektu.własność</em>
+delete <em>nazwaObiektu</em>['<code><em>własność</em>'</code>]
+</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>nazwaObiektu</code></dt>
+ <dd>Nazwa obiektu.</dd>
+</dl>
+
+<dl>
+ <dt><code>własność</code></dt>
+ <dd>Własność do usunięcia.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Czwarta forma jest dozwolona tylko wewnątrz instrukcji <code>with</code> w celu usunięcia własności z obiektu.</p>
+
+<p>Możesz użyć operatora <code>delete</code>, aby usunąć zmienne zadeklarowane bezpośrednio, jednak nie możesz usunąć zmiennych zadeklarowanych za pomocą instrukcji <code>var</code>.</p>
+
+<p>Jeśli operator <code>delete</code> zadziała prawidłowo, ustawi on własność lub element jako <code>undefined</code> (niezdefiniowany). Operator <code>delete</code> zwraca wartość true (prawda), jeśli operacja jest możliwa, zaś wartość <code>false</code> (fałsz), gdy operacja nie jest możliwa.</p>
+
+<pre class="brush: js">x = 42;
+var y = 43;
+myobj = new Number();
+myobj.h = 4;      // tworzy własność h
+delete x;         // zwraca true (można usuwać, jeśli zadeklarowano bezpośrednio)
+delete y;         // zwraca false (nie można usuwać, jeśli zadeklarowano za pomocą var)
+delete Math.PI;   // zwraca false (nie można usuwać własności predefiniowanych)
+delete myobj.h;   // zwraca true (można usuwać własności zdefiniowane przez użytkownika)
+delete myobj;     // zwraca true (można usuwać obiekty)
+</pre>
+
+<h3 id="Usuwanie_element.C3.B3w_tablicy" name="Usuwanie_element.C3.B3w_tablicy">Usuwanie elementów tablicy</h3>
+
+<p>Gdy usuwasz element tablicy nie ma to wpływu na jej długość. Na przykład: jeśli usuniesz a{{ mediawiki.external(3) }}, a{{ mediawiki.external(4) }} będzie wciąż a{{ mediawiki.external(4) }}, natomiast a{{ mediawiki.external(3) }} będzie niezdefiniowane.</p>
+
+<p>Gdy operator <code>delete</code> usuwa element tablicy, element ten przestaje już w niej istnieć. W poniższym przykładzie drzewa{{ mediawiki.external(3) }} jest usunięte za pomocą <code>delete</code>.</p>
+
+<pre class="brush: js">drzewa = new Array("sekwoja","wawrzyn","cedr","dąb","klon");
+delete drzewa[3];
+if (3 in drzewa) {
+   // to nie zostanie wykonane
+}
+</pre>
+
+<p>Jeśli chcesz, aby element tablicy nadal istniał, ale posiadał wartość niezdefiniowaną, użyj słowa kluczowego <code>undefined</code> zamiast operatora <code>delete</code>. W poniższym przykładzie, drzewa{{ mediawiki.external(3) }} jest przypisana wartość niezdefiniowana, ale element tablicy nadal istnieje:</p>
+
+<pre class="brush: js">drzewa = new Array("sekwoja","wawrzyn","cedr","dąb","klon");
+drzewa[3] = undefined;
+if (3 in drzewa) {
+   // to zostanie wykonane
+}
+</pre>
+
+<div class="noinclude"> </div>
diff --git a/files/pl/web/javascript/reference/operators/destructuring_assignment/index.html b/files/pl/web/javascript/reference/operators/destructuring_assignment/index.html
new file mode 100644
index 0000000000..1cb7728404
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/destructuring_assignment/index.html
@@ -0,0 +1,494 @@
+---
+title: Przypisanie destrukturyzujące
+slug: Web/JavaScript/Reference/Operators/Destructuring_assignment
+translation_of: Web/JavaScript/Reference/Operators/Destructuring_assignment
+original_slug: Web/JavaScript/Referencje/Operatory/Destructuring_assignment
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Składnia <strong>przypisania destrukturyzującego</strong> jest wyrażeniem w JavaScript, które pozwala na wyciągnięcie danych z tablic bądź obiektów do odrębnych zmiennych.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="brush: js notranslate">var a, b, rest;
+[a, b] = [1, 2];
+console.log(a); // 1
+console.log(b); // 2
+
+[a, b, ...rest] = [1, 2, 3, 4, 5];
+console.log(a); // 1
+console.log(b); // 2
+console.log(rest); // [3, 4, 5]
+
+({a, b} = {a:1, b:2});
+console.log(a); // 1
+console.log(b); // 2
+
+// ES2016 - nie zaimplementowane w przeglądarce Firefox 47a01
+({a, b, ...rest} = {a:1, b:2, c:3, d:4}); </pre>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Wyrażenie literału obiektowego i tablicowego umożliwiają łatwe tworzenie paczek danych <em>ad-hoc</em>. </p>
+
+<pre class="brush: js notranslate">var x = [1, 2, 3, 4, 5];</pre>
+
+<p>Składnia przypisania destrukturyzacyjnego używa podobnej składni, ale z lewej strony przypisania definiujemy, które elementy wyciągnąć ze zmiennej źródłowej.</p>
+
+<pre class="brush: js notranslate">var x = [1, 2, 3, 4, 5];
+var [y, z] = x;
+console.log(y); // 1
+console.log(z); // 2
+</pre>
+
+<p>Funkcjonalność ta jest podobna do tych obecnych w językach takich jak Perl i Python.</p>
+
+<h2 id="Destrukturyzacja_tablic">Destrukturyzacja tablic</h2>
+
+<h3 id="Podstawowe_przypisanie_zmiennych">Podstawowe przypisanie zmiennych</h3>
+
+<pre class="brush: js notranslate">var foo = ["one", "two", "three"];
+
+var [one, two, three] = foo;
+console.log(one); // "one"
+console.log(two); // "two"
+console.log(three); // "three"
+</pre>
+
+<h3 id="Przypisanie_oddzielne_od_deklaracji">Przypisanie oddzielne od deklaracji</h3>
+
+<p>Zmiennej można przypisać wartość poprzez destrukturyzację oddzielnie od deklaracji tej zmiennej.</p>
+
+<pre class="brush:js notranslate">var a, b;
+
+[a, b] = [1, 2];
+console.log(a); // 1
+console.log(b); // 2
+</pre>
+
+<h3 id="Domyślne_wartości">Domyślne wartości</h3>
+
+<p>Zmiennej można przypisać wartość domyślną, w wypadku, gdy wartość wyciągnięta z tablicy jest niezdefiniowana - <code>undefined</code>.</p>
+
+<pre class="brush: js notranslate">var a, b;
+
+[a=5, b=7] = [1];
+console.log(a); // 1
+console.log(b); // 7
+</pre>
+
+<h3 id="Zamiana_zmiennych">Zamiana zmiennych</h3>
+
+<p>Dwie zmienne mogą zamienić się miejscami przy wykorzystaniu jednego wyrażenia destrukturyzującego.</p>
+
+<p>Bez wyrażenia destrukturyzującego, zamiana zmiennych wymaga zmiennej tymaczasowej (bądź, w niektórych językach niskiego poziomu, tricku <a class="external" href="https://en.wikipedia.org/wiki/XOR_swap_algorithm">XOR-swap</a>).</p>
+
+<pre class="brush:js notranslate">var a = 1;
+var b = 3;
+
+[a, b] = [b, a];
+console.log(a); // 3
+console.log(b); // 1
+</pre>
+
+<h3 id="Parsowanie_tablicy_zwróconej_przez_funkcję">Parsowanie tablicy zwróconej przez funkcję</h3>
+
+<p>Zwrócenie tablicy poprzez funkcję zawsze było możliwe. Destrukturyzacja może sprawić, że praca ze zwróconymi wartościami typu array będzie bardziej zwięzła.</p>
+
+<p>W tym przykładzie, <code>f()</code> zwraca wartości <code>[1, 2]</code> jako jej wyjście, mogą one być sparsowane w jednej linijce poprzez użycie destrukturyzacji.</p>
+
+<pre class="brush:js notranslate">function f() {
+  return [1, 2];
+}
+
+var a, b;
+[a, b] = f();
+console.log(a); // 1
+console.log(b); // 2
+</pre>
+
+<h3 id="Ignorowanie_niektórych_zwróconych_wartości">Ignorowanie niektórych zwróconych wartości</h3>
+
+<p>Możesz zignorować zwrócone wartości, którymi nie jesteś zainteresowany.</p>
+
+<pre class="brush:js notranslate">function f() {
+  return [1, 2, 3];
+}
+
+var [a, , b] = f();
+console.log(a); // 1
+console.log(b); // 3
+</pre>
+
+<p>Możesz także zignorować wszystkie zwrócone wartości:</p>
+
+<pre class="brush:js notranslate">[,,] = f();
+</pre>
+
+
+
+<h3 id="Przypisanie_reszty_tablicy_do_zmiennej">Przypisanie reszty tablicy do zmiennej</h3>
+
+<p>Podczas destrukturyzacji array'a możesz wypakować i przypisać jego pozostałą część do zmiennej używając operatora reszty:</p>
+
+<pre class="brush: js notranslate">var [a, ...b] = [1, 2, 3];
+console.log(a); // 1
+console.log(b); // [2, 3]</pre>
+
+<p>Zwróć uwagę, że zostanie wyrzucony {{jsxref("SyntaxError")}} jeśli końcowy przecinek będzie użyty z prawej strony wyrażenia z elementem reszty: </p>
+
+<pre class="brush: js notranslate">var [a, ...b,] = [1, 2, 3];
+// SyntaxError: rest element may not have a trailing comma</pre>
+
+<h3 id="Wypakowywanie_wartości_z_wyników_wyrażenia_regularnego">Wypakowywanie wartości z wyników wyrażenia regularnego</h3>
+
+<p>Gdy metoda wyrażenia regularnego  <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec">exec()</a></code> znajdzie pasujący element, zwraca ona tablicę zawierającą kolejno cały string zawierajacy pasujące elementy, a później elementy stringa, które pasowały do każdej grupy wyrażenia regularnego znajdującej się w nawiasach. Wyrażenie destrukturyzujące pozwala na łatwe wypakowanie elementów tej tablicy ignorując pełny string, gdy nie jest on potrzebny. </p>
+
+<pre class="brush: js notranslate">function parseProtocol(url) {
+  var parsedURL = /^(\w+)\:\/\/([^\/]+)\/(.*)$/.exec(url);
+  if (!parsedURL) {
+    return false;
+  }
+  console.log(parsedURL); // ["https://developer.mozilla.org/en-US/Web/JavaScript", "https", "developer.mozilla.org", "en-US/Web/JavaScript"]
+
+  var [, protocol, fullhost, fullpath] = parsedURL;
+  return protocol;
+}
+
+console.log(parseProtocol('https://developer.mozilla.org/en-US/Web/JavaScript')); // "https"</pre>
+
+<h2 id="Destrukturyzacja_obiektów">Destrukturyzacja obiektów</h2>
+
+<h3 id="Podstawowe_przypisanie">Podstawowe przypisanie</h3>
+
+<pre class="brush: js notranslate">var o = {p: 42, q: true};
+var {p, q} = o;
+
+console.log(p); // 42
+console.log(q); // true
+</pre>
+
+<h3 id="Przypisanie_bez_deklaracji">Przypisanie bez deklaracji</h3>
+
+<p>Zmiennej można przypisać wartość poprzez destrukturyazację oddzielnie od deklaracji tej zmiennej.</p>
+
+<pre class="brush:js notranslate">var a, b;
+
+({a, b} = {a:1, b:2});</pre>
+
+<div class="note">
+<p>Nawiasy<code>( .. )</code> na krawędziach wyrażenia przypisania są składnią wymaganą podczas używania wyrażenia destrukturyzującego literał obiektowy bez deklaracji.</p>
+
+<p><code>{a, b} = {a:1, b:2}</code> nie jest poprawną składnią samą w sobie, ponieważ <code>{a, b}</code> z lewej strony wyrażenia jest odbierana jako blok, a nie literał obiektowy.</p>
+
+<p>Ale już, <code>({a, b} = {a:1, b:2})</code> jest poprawne, tak samo jak <code>var {a, b} = {a:1, b:2}</code></p>
+</div>
+
+<h3 id="Przypisanie_do_nowych_nazw_zmiennych">Przypisanie do nowych nazw zmiennych</h3>
+
+<p>Zmienna może być wyciągnięta z obiektu i przypisana do zmiennej z inną nazwą niż nazwa właściwości obiektu.</p>
+
+<pre class="brush: js notranslate">var o = {p: 42, q: true};
+var {p: foo, q: bar} = o;
+
+console.log(foo); // 42
+console.log(bar); // true  </pre>
+
+<h3 id="Wartości_domyślne">Wartości domyślne</h3>
+
+<p>Zmiennej można przypisać wartość domyślną, w wypadku, gdy wartość wyciągnięta z obiektu jest <code>undefined</code>.</p>
+
+<pre class="brush: js notranslate">var {a=10, b=5} = {a: 3};
+
+console.log(a); // 3
+console.log(b); // 5</pre>
+
+
+
+<h3 id="Przypisywanie_do_nowych_nazw_zmiennych_i_zapewnienie_wartości_domyślnych">Przypisywanie do nowych nazw zmiennych i zapewnienie wartości domyślnych</h3>
+
+<p>Właściwość może być zarówno 1) wypakowana z obiektu i przypisana do zmiennej z inną nazwą 2) może być jej przypisana wartość domyślna, gdy wypakowana wartość jest <code>undefined</code>.</p>
+
+<pre class="brush: js notranslate">var {a:aa = 10, b:bb = 5} = {a: 3};
+
+console.log(aa); // 3
+console.log(bb); // 5</pre>
+
+
+
+<h3 id="Ustawianie_domyślnej_wartości_parametru_funkcji">Ustawianie domyślnej wartości parametru funkcji </h3>
+
+<h4 id="Wersja_ES5">Wersja ES5</h4>
+
+<pre class="brush: js notranslate">function drawES5Chart(options) {
+  options = options === undefined ? {} : options;
+  var size = options.size === undefined ? 'big' : options.size;
+  var cords = options.cords === undefined ? { x: 0, y: 0 } : options.cords;
+  var radius = options.radius === undefined ? 25 : options.radius;
+  console.log(size, cords, radius);
+  // now finally do some chart drawing
+}
+
+drawES5Chart({
+  cords: { x: 18, y: 30 },
+  radius: 30
+});</pre>
+
+<h4 id="Wersja_ES2015_ES6">Wersja ES2015 (ES6)</h4>
+
+<pre class="brush: js notranslate">function drawES2015Chart({size = 'big', cords = { x: 0, y: 0 }, radius = 25} = {}) {
+  console.log(size, cords, radius);
+  // do some chart drawing
+}
+
+// In Firefox, default values for destructuring assignments are not yet implemented (as described below).
+// The workaround is to write the parameters in the following way:
+// ({size: size = 'big', cords: cords = { x: 0, y: 0 }, radius: radius = 25} = {})
+
+drawES2015Chart({
+  cords: { x: 18, y: 30 },
+  radius: 30
+});</pre>
+
+<div class="note">
+<p>W definicji funkcji <strong><code>drawES2015Chart()</code></strong> powyżej, destrukturyzowana lewa strona wyrażenia jest przypisana do pustego literału obiektowego z prawej strony: <code>{size = 'big', cords = {x: 0, y: 0}, radius = 25} = {}</code>. Można by było również napisać funkcję bez prawostronnego przypisania. Jednakże jeśli zostawisz prawą stroę przypisania, funkcja będzie szukać przynajmniej jednego argumentu podczas wywołania, natomiast w jej obecnej formie możesz po prostu wywołać <code><strong>drawES2015Chart()</strong></code> bez podawania parametrów. Ten sposób jest użyteczny gdy chcesz mieć możliwość wywołania funkcji bez podawania parametrów, ten drugi może być użyteczny, gdy chcesz być pewny, że obiekt został wprowadzony do funkcji.</p>
+</div>
+
+<h3 id="Obiekt_zagnieżdżony_i_destrukturyzacja_tablic">Obiekt zagnieżdżony i destrukturyzacja tablic</h3>
+
+<pre class="brush:js notranslate">var metadata = {
+    title: "Scratchpad",
+    translations: [
+       {
+        locale: "de",
+        localization_tags: [ ],
+        last_edit: "2014-04-14T08:43:37",
+        url: "/de/docs/Tools/Scratchpad",
+        title: "JavaScript-Umgebung"
+       }
+    ],
+    url: "/en-US/docs/Tools/Scratchpad"
+};
+
+var { title: englishTitle, translations: [{ title: localeTitle }] } = metadata;
+
+console.log(englishTitle); // "Scratchpad"
+console.log(localeTitle);  // "JavaScript-Umgebung"</pre>
+
+<h3 id="Iteracja_for..of_i_destrukturyzacja">Iteracja for..of i destrukturyzacja</h3>
+
+<pre class="brush: js notranslate">var people = [
+  {
+    name: "Mike Smith",
+    family: {
+      mother: "Jane Smith",
+      father: "Harry Smith",
+      sister: "Samantha Smith"
+    },
+    age: 35
+  },
+  {
+    name: "Tom Jones",
+    family: {
+      mother: "Norah Jones",
+      father: "Richard Jones",
+      brother: "Howard Jones"
+    },
+    age: 25
+  }
+];
+
+for (var {name: n, family: { father: f } } of people) {
+  console.log("Name: " + n + ", Father: " + f);
+}
+
+// "Name: Mike Smith, Father: Harry Smith"
+// "Name: Tom Jones, Father: Richard Jones"</pre>
+
+<h3 id="Wyciąganie_pól_z_obiektów_przekazanych_jako_parametr_funkcji">Wyciąganie pól z obiektów przekazanych jako parametr funkcji</h3>
+
+<pre class="brush:js notranslate">function userId({id}) {
+  return id;
+}
+
+function whois({displayName, fullName: {firstName: name}}){
+  console.log(displayName + " is " + name);
+}
+
+var user = {
+  id: 42,
+  displayName: "jdoe",
+  fullName: {
+      firstName: "John",
+      lastName: "Doe"
+  }
+};
+
+console.log("userId: " + userId(user)); // "userId: 42"
+whois(user); // "jdoe is John"</pre>
+
+<p>To wyciąga <code>id</code>, <code>displayName</code> i <code>firstName</code> z obiektu <em>user </em>i wypisuje je.</p>
+
+<h3 id="Wyznaczane_nazwy_właściwości_obiektów_i_destrukturyzacja">Wyznaczane nazwy właściwości obiektów i destrukturyzacja</h3>
+
+<p>Wyznaczane nazwy waściwości, tak samo jak wh <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names">literałach obiektowych</a>, mogą być używane z destrukturyzacją.</p>
+
+<pre class="brush: js notranslate">let key = "z";
+let { [key]: foo } = { z: "bar" };
+
+console.log(foo); // "bar"
+</pre>
+
+
+
+<h3 id="Reszta_w_destrukturyzacji_obiektów">Reszta w destrukturyzacji obiektów</h3>
+
+<p><a href="https://github.com/tc39/proposal-object-rest-spread">Własciwości reszty/rozproszenia dla ECMAScript</a> (proponowane, etap 3) dodają składnię <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">reszty</a> do destrukturyzacji. Właściwości reszty zbierają pozostałe klucze, które nie zostały pobrane poprzez wzorzec destrukturyzacji.</p>
+
+<pre class="brush: js notranslate">let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40}
+a; // 10
+b; // 20
+rest; // { c: 30, d: 40 }</pre>
+
+<h3 id="Nipoprawny_identyfikator_JavaScript_jako_nazwa_własności">Nipoprawny identyfikator JavaScript jako nazwa własności</h3>
+
+<p>Destrukturyzacja może zostać użyta z nazwami własności, które nie są poprawnymi <a href="https://developer.mozilla.org/en-US/docs/Glossary/Identifier">identyfikatorami</a> JavaScript poprzez zapewnienie alternatywnego, poprawnego identyfikatora.</p>
+
+<pre class="brush: js notranslate">const foo = { 'fizz-buzz': true };
+const { 'fizz-buzz': fizzBuzz } = foo;
+
+console.log(fizzBuzz); // "true"</pre>
+
+
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-destructuring-assignment', 'Destructuring assignment')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja wstępna.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-destructuring-assignment', 'Destructuring assignment')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Edge</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoDesktop("1.8.1") }}</td>
+   <td>14</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>Computed property names</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoDesktop("34") }}</td>
+   <td>14</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Spread operator</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoDesktop("34") }}</td>
+   <td>12<sup>[1]</sup></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoMobile("1.0") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+   <td>{{CompatChrome(49.0)}}</td>
+  </tr>
+  <tr>
+   <td>Computed property names</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoMobile("34") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+  </tr>
+  <tr>
+   <td>Spread operator</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoMobile("34") }}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Wymaga odblokowanej flagi "Enable experimental Javascript features" w `about:flags`</p>
+
+<h2 id="Notatki_specyficzne_dla_Firefoxa">Notatki specyficzne dla Firefox'a</h2>
+
+<ul>
+ <li>Firefox zapewnił niestandardowe rozszerzenie języka w <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.7">JS1.7</a> dla destrukturyzacji. To rozszerzenie zostało usunięte w Gecko 40 {{geckoRelease(40)}}. Zobacz {{bug(1083498)}}.</li>
+ <li>Poczynając od Gecko 41 {{geckoRelease(41)}} żeby dostosować się do specyfikacji ES2015, składnia destrukturyzacji używająca nawiasów, takia jak<code>([a, b]) = [1, 2])</code> lub <code>({a, b}) = { a: 1, b: 2 }</code>, jest teraz uważana za niepoprawną i spowoduje {{jsxref("SyntaxError")}}. Zobacz<a class="external external-icon" href="http://whereswalden.com/2015/06/20/new-changes-to-make-spidermonkeys-and-firefoxs-parsing-of-destructuring-patterns-more-spec-compliant/">post Jeffa Waldena </a>oraz {{bug(1146136)}} aby uzyskać więcej informacji.</li>
+</ul>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Assignment operators</a></li>
+ <li><a href="https://hacks.mozilla.org/2015/05/es6-in-depth-destructuring/">"ES6 in Depth: Destructuring" on hacks.mozilla.org</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/function/index.html b/files/pl/web/javascript/reference/operators/function/index.html
new file mode 100644
index 0000000000..33d31d0306
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/function/index.html
@@ -0,0 +1,145 @@
+---
+title: Operator function
+slug: Web/JavaScript/Reference/Operators/function
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Operators/function
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_function
+---
+<p> </p>
+
+<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3>
+
+<p>Operator <code>function</code> jest używany do definiowania funkcji wewnątrz wyrażenia.</p>
+
+<h2 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h2>
+
+<pre class="eval">function [<em>nazwa</em>]([<em>argument1[</em>, <em>argument2[</em>, ..., <em>argumentN</em>]]]) { <em>instrukcje </em>}
+</pre>
+
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>nazwa</code></dt>
+ <dd>Nazwa funkcji. Może zostać pominięta, w takim wypadku funkcja staje się anonimowa. Nazwa jest tylko lokalna i istnieje wewnętrz funkcji.</dd>
+</dl>
+
+<dl>
+ <dt><code>argumentN</code></dt>
+ <dd>Nazwa argumentu, który ma zostać przekazany do funkcji. Funkcja może posiadać do 255 argumentów.</dd>
+</dl>
+
+<dl>
+ <dt><code>instrukcje</code></dt>
+ <dd>Instrukcje, które stanowią ciało funkcji.</dd>
+</dl>
+
+<h2 id="Opis" name="Opis">Opis</h2>
+
+<p>Wyrażenie funkcji jest bardzo podobne do deklaracji funkcji i posiada niemal identyczną składnię (zobacz <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/function">function</a>, aby uzyskać bardziej szczegółowe informacje). Główną różnicą pomiędzy wyrażeniem a definicją jest <em>nazwa funkcji, </em>która może zostać pominięta i utworzyć funkcję<em> anonimową</em>. Zobacz <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje">Funkcje</a>, aby uzyskać informacje o różnicach między instrukcjami funkcji a wyrażeniami funkcji.</p>
+
+<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>
+
+<p>Poniższy przykład definiuje nienazwaną funkcję i przypisują ją do <code>x</code>. Funkcja zwraca kwadrat jej argumentów:</p>
+
+<pre>var x = function(y) {
+   return y * y;
+};
+</pre>
+
+<h3 id="Nazwane_wyrażenie">Nazwane wyrażenie</h3>
+
+<pre><code>var math = {
+  'factorial': function factorial(n) {
+    if (n &lt;= 1)
+      return 1;
+    return n * factorial(n - 1);
+  }
+};</code></pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table>
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarze</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-13', 'Function definition')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-13', 'Function definition')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Zaimplementowano w JavaScript 1.5.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<table>
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<table>
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Zobacz_także">Zobacz także</h2>
+
+<p><code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Funkcje">Funkcje</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Obiekty/Function">Function</a></code>, <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Polecenia/function">Polecenie function</a></code></p>
diff --git a/files/pl/web/javascript/reference/operators/function_star_/index.html b/files/pl/web/javascript/reference/operators/function_star_/index.html
new file mode 100644
index 0000000000..027e2d2c2b
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/function_star_/index.html
@@ -0,0 +1,91 @@
+---
+title: wyrażenie function*
+slug: Web/JavaScript/Reference/Operators/function*
+tags:
+  - ECMAScript2015
+  - Iterator
+  - JavaScript
+  - Operator
+  - funkcja
+translation_of: Web/JavaScript/Reference/Operators/function*
+original_slug: Web/JavaScript/Referencje/Operatory/function*
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Słowo kluczowe <strong><code>function*</code></strong> może być użyte do zdefiniowania funkcji generatora wewnątrz wyrażenia.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-functionasteriskexpression.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">function* [nazwa]([<em>param1</em>[, <em>param2[</em>, ..., <em>paramN</em>]]]) {
+   wyrażenia
+}</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>nazwa</code></dt>
+ <dd>Nazw funkcji. Może być pominięta w przyadku funkcji <em>anonimowych</em>. Nazwa jest lokalna i ograniczona do ciała funkcji.</dd>
+ <dt><code>paramN</code></dt>
+ <dd>Nazwa argumentu przekazywanego do funkcji. Funkcja może mieć do 255 argumentów.</dd>
+ <dt><code>wyrażenia</code></dt>
+ <dd>Wyrażenia, które zawiera ciało funkcji.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Wyrażenie <code>function*</code> jest bardzo podobne i ma niemal taką samą składnię jak {{jsxref('Statements/function*', 'polecenie function*')}}. Zasadnicza różnica między wyrażenem <code>function*</code> a poleceniem <code>function*</code> to <em>nazwa funkcji</em>, która może być pominięta w wyrażeniach <code>function*</code>, co pozwala na tworzenie anonimowych funkcji generatorów. Zobacz również rozdział o <a href="/en-US/docs/Web/JavaScript/Reference/Functions">funkcjach</a>, aby dowiedzieć się więcej.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<p>Następujący przykład definiuje nienazwaną funkcję generatora i przypisuje ją do <code>x</code>. Funkcja zwraca przekazany argument podniesiony do kwadratu.</p>
+
+<pre class="brush: js">var x = function*(y) {
+   yield y * y;
+};
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-generator-function-definitions', 'function*')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-generator-function-definitions', 'function*')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.operators.function_star")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Statements/function*", "function* statement")}}</li>
+ <li>{{jsxref("GeneratorFunction")}} object</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li>
+ <li>{{jsxref("Operators/yield", "yield")}}</li>
+ <li>{{jsxref("Operators/yield*", "yield*")}}</li>
+ <li>{{jsxref("Function")}} object</li>
+ <li>{{jsxref("Statements/function", "function statement")}}</li>
+ <li>{{jsxref("Operators/function", "function expression")}}</li>
+ <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/grouping/index.html b/files/pl/web/javascript/reference/operators/grouping/index.html
new file mode 100644
index 0000000000..41d40d22a5
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/grouping/index.html
@@ -0,0 +1,91 @@
+---
+title: Operator grupowania
+slug: Web/JavaScript/Reference/Operators/Grouping
+tags:
+  - JavaScript
+  - Operator
+translation_of: Web/JavaScript/Reference/Operators/Grouping
+original_slug: Web/JavaScript/Referencje/Operatory/Grouping
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Operator grupowania <code>( )</code> pozwala na określenie kolejności wykonywania działań w wyrażeniach.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-groupingoperator.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"> ( )</pre>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Operator grupowania składa się z pary nawiasów otaczających wyrażenie lub podwyrażenie. Pozwala na nadpisanie standardowego <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Operatory/Pierwsze%C5%84stwo_operator%C3%B3w">pierwszeństwa operatorów</a>, tak że wyrażenia z niższym piorytetem mogą być wykonane przed wyrażeniami z wyższym priorytetem. Zgodnie z nazwą, operator ten grupuje wyrażenia znajdujące się w nawiasach.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<p>Nadpisanie zasady wykonywania mnożenia i dzielenia przed dodawaniem i odejmowaniem w taki sposób, by dodawanie wykonane było jako pierwsze.</p>
+
+<pre class="brush:js">var a = 1;
+var b = 2;
+var c = 3;
+
+// domyślna kolejność
+a + b * c     // 7
+// wykonywana domyślnie w taki sposób
+a + (b * c)   // 7
+
+// zmiana kolejności wykonywania działań
+// dodawanie przed mnożeniem
+(a + b) * c   // 9
+
+// co odpowiada wyrażeniu
+a * c + b * c // 9
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-grouping-operator', 'The Grouping Operator')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-grouping-operator', 'The Grouping Operator')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.1.6', 'The Grouping Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-11.1.4', 'The Grouping Operator')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.operators.grouping")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Operatory/Pierwsze%C5%84stwo_operator%C3%B3w">Pierwszeństwo operatorów</a></li>
+ <li>{{jsxref("Operators/delete", "delete")}}</li>
+ <li>{{jsxref("Operators/typeof", "typeof")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/in/index.html b/files/pl/web/javascript/reference/operators/in/index.html
new file mode 100644
index 0000000000..adaff558e3
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/in/index.html
@@ -0,0 +1,93 @@
+---
+title: Operator in
+slug: Web/JavaScript/Reference/Operators/in
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Operators/in
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_in
+---
+<p> </p>
+<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3>
+<p>Operator <code>in</code> zwraca wartość <code>true</code> (prawda), jeśli określona własność jest w określonym obiekcie.</p>
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header" colspan="2">Operator</td>
+  </tr>
+  <tr>
+   <td>Zaimplementowany w:</td>
+   <td>JavaScript 1.4</td>
+  </tr>
+ </tbody>
+</table>
+<h3 id="Sk.C5.82adnia" name="Sk.C5.82adnia">Składnia</h3>
+<p><code>
+ <i>
+  propNameOrNumber</i>
+ in
+ <i>
+  objectName</i>
+ </code></p>
+<h3 id="Parametry" name="Parametry">Parametry</h3>
+<dl>
+ <dt>
+  <code>propNameOrNumber</code></dt>
+ <dd>
+  Łańcuch znaków lub wartość liczbowa reprezentujące nazwę własności lub indeks tablicy.</dd>
+</dl>
+<dl>
+ <dt>
+  <code>objectName</code></dt>
+ <dd>
+  Nazwa obiektu.</dd>
+</dl>
+<h3 id="Opis" name="Opis">Opis</h3>
+<p>Poniższe przykłady pokazują wybrane sposoby użycia operatora <code>in</code>.</p>
+<pre>// Tablice
+trees=new Array("redwood","bay","cedar","oak","maple")
+0 in trees        // zwraca true
+3 in trees        // zwraca true
+6 in trees        // zwraca false
+"bay" in trees    // zwraca false (musisz określić numer indeksu,
+                  // nie wartość w tym indeksie)
+"length" in trees // zwraca true (length jest własnością tablicy Array)
+
+// Obiekty predefiniowane
+"PI" in Math          // zwraca true
+myString=new String("coral")
+"length" in myString  // zwraca true
+
+// Custom objects
+mycar = {make:"Honda",model:"Accord",year:1998}
+"make" in mycar  // zwraca true
+"model" in mycar // zwraca true
+</pre>
+<p>Musisz określić obiekt z prawej strony operatora <code>in</code>. Na przykład: możesz określić łańcuch znaków stworzony za pomocą konstruktora <code>String</code>, ale nie możesz określić łańcucha znaków wprost.</p>
+<pre>color1=new String("green")
+"length" in color1 // zwraca true
+color2="coral"
+"length" in color2 // generuje błąd (color nie jest obiektem typu String)
+</pre>
+<h4 id="Zastosowanie_in_z_usuni.C4.99tymi_lub_niezdefiniowanymi_w.C5.82asno.C5.9Bciami" name="Zastosowanie_in_z_usuni.C4.99tymi_lub_niezdefiniowanymi_w.C5.82asno.C5.9Bciami">Zastosowanie <code>in</code> z usuniętymi lub niezdefiniowanymi własnościami</h4>
+<p>Jeśli usuniesz własność za pomocą operatora <code><a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_delete">delete</a></code>, operator <code>in</code> zwróci wartość false (fałsz) dla tej własności.</p>
+<pre>mycar = {make:"Honda",model:"Accord",year:1998}
+delete mycar.make
+"make" in mycar  // zwraca false
+
+trees=new Array("redwood","bay","cedar","oak","maple")
+delete trees[3]
+3 in trees // zwraca false
+</pre>
+<p>Jeśli ustalisz własność jako niezdefiniowaną, ale nie usuniesz jej, operator <code>in</code> zwróci wartość true (prawda) dla tej własności.</p>
+<pre>mycar = {make:"Honda",model:"Accord",year:1998}
+mycar.make=undefined
+"make" in mycar  // zwraca true
+
+trees=new Array("redwood","bay","cedar","oak","maple")
+trees[3]=undefined
+3 in trees // zwraca true
+</pre>
+<p>Aby uzyskać dodatkowe informacje o zastosowaniu operatora <code>in</code> z usuniętymi elementami tablicy, zobacz <a href="pl/Dokumentacja_j%c4%99zyka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_delete">delete</a>.</p>
diff --git a/files/pl/web/javascript/reference/operators/index.html b/files/pl/web/javascript/reference/operators/index.html
new file mode 100644
index 0000000000..94b7e05429
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/index.html
@@ -0,0 +1,283 @@
+---
+title: Operatory
+slug: Web/JavaScript/Reference/Operators
+tags:
+  - JavaScript
+  - Operators
+translation_of: Web/JavaScript/Reference/Operators
+original_slug: Web/JavaScript/Referencje/Operatory
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>This chapter documents all the JavaScript language operators, expressions and keywords.</p>
+
+<h2 id="Wyrażenia_i_operatory_w_podziale_na_kategorie">Wyrażenia i operatory w podziale na  kategorie</h2>
+
+<h2 id="sect1"> </h2>
+
+<h2 id="Lista_operatorów_w_kolejności_alfabetycznej_znajduje_sie_w_pasku_bocznym_po_lewej_stronie."><span style="font-size: 14px; font-weight: normal;">Lista operatorów w kolejności alfabetycznej znajduje sie w pasku bocznym po lewej stronie.</span></h2>
+
+<h3 id="Wyrażenia_podstawowe">Wyrażenia podstawowe</h3>
+
+<p>Podstawowe słowa kluczowe i wyrażenia w  JavaScript.</p>
+
+<dl>
+ <dt>{{jsxref("Operator/this", "this")}}</dt>
+ <dd>Słowo <code>this</code> odnosi się do kontekstu wywołania.</dd>
+ <dt>{{jsxref("Operator/function", "function")}}</dt>
+ <dd>Słowo <code>function</code> umożliwia zdefniowanie wyrażenia funkcji .</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operatory/class", "class")}}</dt>
+ <dd>Słowo <code>class</code> definiuje wyrażenie klasy.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operatory/function*", "function*")}}</dt>
+ <dd>The <code>function*</code> keyword defines a generator function expression.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operatory/yield", "yield")}}</dt>
+ <dd>Pause and resume a generator function</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operatory/yield*", "yield*")}}</dt>
+ <dd>Delegate to another generator function or iterable object.</dd>
+ <dt>{{jsxref("Global_Objecty/Array", "[]")}}</dt>
+ <dd>Array initializer/literal syntax.</dd>
+ <dt>{{jsxref("Operatory/Object_initializer", "{}")}}</dt>
+ <dd>Object initializer/literal syntax.</dd>
+ <dt>{{jsxref("RegExp", "/ab+c/i")}}</dt>
+ <dd>Regular expression literal syntax.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operatory/Array_comprehensions", "[for (x of y) x]")}}</dt>
+ <dd>Array comprehensions.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operatory/Generator_comprehensions", "(for (x of y) y)")}}</dt>
+ <dd>Generator comprehensions.</dd>
+ <dt>{{jsxref("Operatory/Grouping", "( )")}}</dt>
+ <dd>Grouping operator.</dd>
+</dl>
+
+<h3 id="Left-hand-side_expressions">Left-hand-side expressions</h3>
+
+<p>Left values are the destination of an assignment.</p>
+
+<dl>
+ <dt>{{jsxref("Operatory/Property_accessors", "Property accessors", "", 1)}}</dt>
+ <dd>Member operators provide access to a property or method of an object<br>
+ (<code>object.property</code> and <code>object["property"]</code>).</dd>
+ <dt>{{jsxref("Operatory/new", "new")}}</dt>
+ <dd>The <code>new</code> operator creates an instance of a constructor.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operatory/super", "super")}}</dt>
+ <dd>The <code>super</code> keyword calls the parent constructor.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operatory/Spread_operator", "...obj")}}</dt>
+ <dd>The spread operator allows an expression to be expanded in places where multiple arguments (for function calls) or multiple elements (for array literals) are expected.</dd>
+</dl>
+
+<h3 id="Increment_and_decrement">Increment and decrement</h3>
+
+<p>Postfix/prefix increment and postfix/prefix decrement operators.</p>
+
+<dl>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "A++", "#Inkrementacja")}}</dt>
+ <dd>Postfix increment operator.</dd>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "A--", "#Dekrementacja")}}</dt>
+ <dd>Postfix decrement operator.</dd>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "++A", "#Inkrementacja")}}</dt>
+ <dd>Prefix increment operator.</dd>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "--A", "#Dekrementacja")}}</dt>
+ <dd>Prefix decrement operator.</dd>
+</dl>
+
+<h3 id="Unary_operators">Unary operators</h3>
+
+<p>A unary operation is operation with only one operand.</p>
+
+<dl>
+ <dt>{{jsxref("Operatoryy/delete", "delete")}}</dt>
+ <dd>The <code>delete</code> operator deletes a property from an object.</dd>
+ <dt>{{jsxref("Operatory/void", "void")}}</dt>
+ <dd>The <code>void</code> operator discards an expression's return value.</dd>
+ <dt>{{jsxref("Operatory/typeof", "typeof")}}</dt>
+ <dd>The <code>typeof</code> operator determines the type of a given object.</dd>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "+", "#Unary_plus")}}</dt>
+ <dd>The unary plus operator converts its operand to Number type.</dd>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "-", "#Unary_negation")}}</dt>
+ <dd>The unary negation operator converts its operand to Number type and then negates it.</dd>
+ <dt>{{jsxref("Operatory/Bitwise_Operators", "~", "#Bitwise_NOT")}}</dt>
+ <dd>Bitwise NOT operator.</dd>
+ <dt>{{jsxref("Operatory/Logical_Operators", "!", "#Logical_NOT")}}</dt>
+ <dd>Logical NOT operator.</dd>
+</dl>
+
+<h3 id="Operatory_arytmetyczne">Operatory arytmetyczne</h3>
+
+<h3 id="Arithmetic_operators_take_numerical_values_(either_literals_or_variables)_as_their_operands_and_return_a_single_numerical_value."><span style="font-size: 14px;">Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value.</span></h3>
+
+<dl>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "+", "#Addition")}}</dt>
+ <dd>Addition operator.</dd>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "-", "#Subtraction")}}</dt>
+ <dd>Subtraction operator.</dd>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "/", "#Division")}}</dt>
+ <dd>Division operator.</dd>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "*", "#Multiplication")}}</dt>
+ <dd>Multiplication operator.</dd>
+ <dt>{{jsxref("Operatory/Operatory_arytmetyczne", "%", "#Remainder")}}</dt>
+ <dd>Remainder operator.</dd>
+</dl>
+
+<h3 id="Operatory_porównania">Operatory porównania</h3>
+
+<p>Operator porównania, jak nazwa wskazuje, porównuje operandy  i zwraca wartość logiczną zależną od tego, czy wartość porównania jest prawdziwa. </p>
+
+<dl>
+ <dt>{{jsxref("Operatory/in", "in")}}</dt>
+ <dd>Operator <code>in</code> ustala, czy obiekt posiada daną właściwość.</dd>
+ <dt>{{jsxref("Operatory/instanceof", "instanceof")}}</dt>
+ <dd>Operator <code>instanceof</code> ustala czy obiekt jest instancją innego obiektu.</dd>
+ <dt>{{jsxref("Operatory/Comparison_Operators", "&lt;", "#Less_than_operator")}}</dt>
+ <dd>Less than operator.</dd>
+ <dt>{{jsxref("Operatory/Comparison_Operators", "&gt;", "#Greater_than_operator")}}</dt>
+ <dd>Greater than operator.</dd>
+ <dt>{{jsxref("Operatory/Comparison_Operators", "&lt;=", "#Less_than_or_equal_operator")}}</dt>
+ <dd>Less than or equal operator.</dd>
+ <dt>{{jsxref("Operatory/Comparison_Operators", "&gt;=", "#Greater_than_or_equal_operator")}}</dt>
+ <dd>Greater than or equal operator.</dd>
+</dl>
+
+<h3 id="Equality_operators">Equality operators</h3>
+
+<p>The result of evaluating an equality operator is always of type <code>Boolean</code> based on whether the comparison is true.</p>
+
+<dl>
+ <dt>{{jsxref("Operatory/Comparison_Operators", "==", "#Equality")}}</dt>
+ <dd>Equality operator.</dd>
+ <dt>{{jsxref("Operatory/Comparison_Operators", "!=", "#Inequality")}}</dt>
+ <dd>Inequality operator.</dd>
+ <dt>{{jsxref("Operatory/Comparison_Operators", "===", "#Identity")}}</dt>
+ <dd>Identity operator.</dd>
+ <dt>{{jsxref("Operatory/Comparison_Operators", "!==", "#Nonidentity")}}</dt>
+ <dd>Nonidentity operator.</dd>
+</dl>
+
+<h3 id="Bitwise_shift_operators">Bitwise shift operators</h3>
+
+<p>Operations to shift all bits of the operand.</p>
+
+<dl>
+ <dt>{{jsxref("Operatory/Bitwise_Operators", "&lt;&lt;", "#Left_shift")}}</dt>
+ <dd>Bitwise left shift operator.</dd>
+ <dt>{{jsxref("Operatory/Bitwise_Operators", "&gt;&gt;", "#Right_shift")}}</dt>
+ <dd>Bitwise right shift operator.</dd>
+ <dt>{{jsxref("Operatory/Bitwise_Operators", "&gt;&gt;&gt;", "#Unsigned_right_shift")}}</dt>
+ <dd>Bitwise unsigned right shift operator.</dd>
+</dl>
+
+<h3 id="Binary_bitwise_operators">Binary bitwise operators</h3>
+
+<p>Bitwise operators treat their operands as a set of 32 bits (zeros and ones) and return standard JavaScript numerical values.</p>
+
+<dl>
+ <dt>{{jsxref("Operatory/Bitwise_Operators", "&amp;", "#Bitwise_AND")}}</dt>
+ <dd>Bitwise AND.</dd>
+ <dt>{{jsxref("Operatory/Bitwise_Operators", "|", "#Bitwise_OR")}}</dt>
+ <dd>Bitwise OR.</dd>
+ <dt>{{jsxref("Operatory/Bitwise_Operators", "^", "#Bitwise_XOR")}}</dt>
+ <dd>Bitwise XOR.</dd>
+</dl>
+
+<h3 id="Binary_logical_operators">Binary logical operators</h3>
+
+<p>Logical operators are typically used with boolean (logical) values, and when they are, they return a boolean value.</p>
+
+<dl>
+ <dt>{{jsxref("Operatory/Logical_Operators", "&amp;&amp;", "#Logical_AND")}}</dt>
+ <dd>Logical AND.</dd>
+ <dt>{{jsxref("Operatory/Logical_Operators", "||", "#Logical_OR")}}</dt>
+ <dd>Logical OR.</dd>
+</dl>
+
+<h3 id="Conditional_(ternary)_operator">Conditional (ternary) operator</h3>
+
+<dl>
+ <dt>{{jsxref("Operatory/Conditional_Operator", "(condition ? ifTrue : ifFalse)")}}</dt>
+ <dd>
+ <p>The conditional operator returns one of two values based on the logical value of the condition.</p>
+ </dd>
+</dl>
+
+<h3 id="Assignment_operators">Assignment operators</h3>
+
+<p>An assignment operator assigns a value to its left operand based on the value of its right operand.</p>
+
+<dl>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "=", "#Assignment")}}</dt>
+ <dd>Assignment operator.</dd>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "*=", "#Multiplication_assignment")}}</dt>
+ <dd>Multiplication assignment.</dd>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "/=", "#Division_assignment")}}</dt>
+ <dd>Division assignment.</dd>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "%=", "#Remainder_assignment")}}</dt>
+ <dd>Remainder assignment.</dd>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "+=", "#Addition_assignment")}}</dt>
+ <dd>Addition assignment.</dd>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "-=", "#Subtraction_assignment")}}</dt>
+ <dd>Subtraction assignment</dd>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "&lt;&lt;=", "#Left_shift_assignment")}}</dt>
+ <dd>Left shift assignment.</dd>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "&gt;&gt;=", "#Right_shift_assignment")}}</dt>
+ <dd>Right shift assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "&gt;&gt;&gt;=", "#Unsigned_right_shift_assignment")}}</dt>
+ <dd>Unsigned right shift assignment.</dd>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "&amp;=", "#Bitwise_AND_assignment")}}</dt>
+ <dd>Bitwise AND assignment.</dd>
+ <dt>{{jsxref("OperatorsyAssignment_Operators", "^=", "#Bitwise_XOR_assignment")}}</dt>
+ <dd>Bitwise XOR assignment.</dd>
+ <dt>{{jsxref("Operatory/Assignment_Operators", "|=", "#Bitwise_OR_assignment")}}</dt>
+ <dd>Bitwise OR assignment.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operatory/Destructuring_assignment", "[a, b] = [1, 2]")}}<br>
+ {{experimental_inline}} {{jsxref("Operatory/Destructuring_assignment", "{a, b} = {a:1, b:2}")}}</dt>
+ <dd>
+ <p>Destructuring assignment allows you to assign the properties of an array or object to variables using syntax that looks similar to array or object literals.</p>
+ </dd>
+</dl>
+
+<h3 id="Comma_operator">Comma operator</h3>
+
+<dl>
+ <dt>{{jsxref("Operatory/Comma_Operator", ",")}}</dt>
+ <dd>The comma operator allows multiple expressions to be evaluated in a single statement and returns the result of the last expression.</dd>
+</dl>
+
+<h3 id="Non-standard_features">Non-standard features</h3>
+
+<dl>
+ <dt>{{non-standard_inline}} {{jsxref("Operatory/Legacy_generator_function", "Legacy generator function", "", 1)}}</dt>
+ <dd>The <code>function</code> keyword can be used to define a legacy generator function inside an expression. To make the function a legacy generator, the function body should contains at least one {{jsxref("Operators/yield", "yield")}} expression.</dd>
+ <dt>{{non-standard_inline}} {{jsxref("Operatory/Expression_closures", "Expression closures", "", 1)}}</dt>
+ <dd>The expression closure syntax is a shorthand for writing simple function.</dd>
+</dl>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11', 'Expressions')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>New: Spread operator, destructuring assignment, <code>super</code> keyword, Array comprehensions, Generator comprehensions</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Operator precedence</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/instanceof/index.html b/files/pl/web/javascript/reference/operators/instanceof/index.html
new file mode 100644
index 0000000000..bd98d29e0f
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/instanceof/index.html
@@ -0,0 +1,169 @@
+---
+title: Operator instanceof
+slug: Web/JavaScript/Reference/Operators/instanceof
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Operators/instanceof
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_instanceof
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p><strong>Operator</strong> <strong><code>instanceof</code> </strong>sprawdza czy właściwość konstruktora <code>prototype</code> pojawia się gdziekolwiek w łańcuchu prototypowym obiektu.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/expressions-instanceof.html")}}</p>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"><em>object</em> instanceof <em>constructor</em></pre>
+
+<dl>
+ <dt>
+ <h3 id="Parametry">Parametry</h3>
+ <code>object</code></dt>
+ <dd>Obiekt do testowania.</dd>
+</dl>
+
+<dl>
+ <dt><code>constructor</code></dt>
+ <dd>Funkcja przeciwko której testujemy.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Operator <code>instanceof</code> sprawdza obecność <code>constructor.prototype</code> w łańcuchu prototypowym obiektu <code>object</code></p>
+
+<pre class="brush: js">// definiowanie konstruktorów
+function C() {}
+function D() {}
+
+var o = new C();
+
+// true, ponieważ: Object.getPrototypeOf(o) === C.prototype
+o instanceof C;
+
+// false, ponieważ D.prototype nie występuje w łańcuchu prototypowym o.
+o instanceof D;
+
+o instanceof Object; // true, ponieważ:
+C.prototype instanceof Object // true
+
+C.prototype = {};
+var o2 = new C();
+
+o2 instanceof C; // true
+
+// false, ponieważ C.prototype nie ma już w łańcuchu prototypowym o
+o instanceof C;
+
+D.prototype = new C(); // add C to [[Prototype]] linkage of D
+var o3 = new D();
+o3 instanceof D; // true
+o3 instanceof C; // true since C.prototype is now in o3's prototype chain
+</pre>
+
+<p>Note that the value of an <code>instanceof</code> test can change based on changes to the <code>prototype</code> property of constructors, and it can also be changed by changing an object prototype using <code>Object.setPrototypeOf</code>. It is also possible using the non-standard <code>__proto__</code> pseudo-property.</p>
+
+<h3 id="instanceof_and_multiple_context_(e.g._frames_or_windows)"><code>instanceof</code> and multiple context (e.g. frames or windows)</h3>
+
+<p>Different scopes have different execution environments. This means that they have different built-ins (different global object, different constructors, etc.). This may result in unexpected results. For instance, <code>[] instanceof window.frames[0].Array</code> will return <code>false</code>, because <code>Array.prototype !== </code><code>window.frames[0].Array</code> and arrays inherit from the former.</p>
+
+<p>This may not make sense at first but when you start dealing with multiple frames or windows in your script and pass objects from one context to another via functions, this will be a valid and strong issue. For instance, you can securely check if a given object is, in fact, an Array using <code>Array.isArray(myObj)</code></p>
+
+<p>For example checking if a <a href="/en-US/docs/Web/API/Node">Nodes</a> is a <a href="/en-US/docs/Web/API/SVGElement">SVGElement</a> in a different context you can use <code>myNode instanceof myNode.ownerDocument.defaultView.SVGElement</code></p>
+
+<div class="note"><strong>Note for Mozilla developers:</strong><br>
+In code using XPCOM <code>instanceof</code> has special effect: <code>obj instanceof </code><em><code>xpcomInterface</code></em> (e.g. <code>Components.interfaces.nsIFile</code>) calls <code>obj.QueryInterface(<em>xpcomInterface</em>)</code> and returns <code>true</code> if QueryInterface succeeded. A side effect of such call is that you can use <em><code>xpcomInterface</code></em>'s properties on <code>obj</code> after a successful <code>instanceof</code> test. Unlike standard JavaScript globals, the test <code>obj instanceof xpcomInterface</code> works as expected even if <code>obj</code> is from a different scope.</div>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Demonstrating_that_String_and_Date_are_of_type_Object_and_exceptional_cases">Demonstrating that <code>String</code> and <code>Date</code> are of type <code>Object</code> and exceptional cases</h3>
+
+<p>The following code uses <code>instanceof</code> to demonstrate that <code>String</code> and <code>Date</code> objects are also of type <code>Object</code> (they are derived from <code>Object</code>).</p>
+
+<p>However, objects created with the object literal notation are an exception here: Although the prototype is undefined, <code>instanceof Object</code> returns <code>true</code>.</p>
+
+<pre class="brush: js">var simpleStr = 'This is a simple string';
+var myString  = new String();
+var newStr    = new String('String created with constructor');
+var myDate    = new Date();
+var myObj     = {};
+
+simpleStr instanceof String; // returns false, checks the prototype chain, finds undefined
+myString  instanceof String; // returns true
+newStr    instanceof String; // returns true
+myString  instanceof Object; // returns true
+
+myObj instanceof Object;    // returns true, despite an undefined prototype
+({})  instanceof Object;    // returns true, same case as above
+
+myString instanceof Date;   // returns false
+
+myDate instanceof Date;     // returns true
+myDate instanceof Object;   // returns true
+myDate instanceof String;   // returns false
+</pre>
+
+<h3 id="Demonstrating_that_mycar_is_of_type_Car_and_type_Object">Demonstrating that <code>mycar</code> is of type <code>Car</code> and type <code>Object</code></h3>
+
+<p>The following code creates an object type <code>Car</code> and an instance of that object type, <code>mycar</code>. The <code>instanceof</code> operator demonstrates that the <code>mycar</code> object is of type <code>Car</code> and of type <code>Object</code>.</p>
+
+<pre class="brush: js">function Car(make, model, year) {
+  this.make = make;
+  this.model = model;
+  this.year = year;
+}
+var mycar = new Car('Honda', 'Accord', 1998);
+var a = mycar instanceof Car;    // returns true
+var b = mycar instanceof Object; // returns true
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-relational-operators', 'Relational Operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-relational-operators', 'Relational Operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.8.6', 'The instanceof operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-11.8.6', 'The instanceof operator')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.4.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+
+
+<p>{{Compat("javascript.operators.instanceof")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof" title="/en-US/docs/JavaScript/Reference/Operators/typeof">typeof</a></code></li>
+ <li>{{jsxref("Symbol.hasInstance")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/new.target/index.html b/files/pl/web/javascript/reference/operators/new.target/index.html
new file mode 100644
index 0000000000..f992f20edb
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/new.target/index.html
@@ -0,0 +1,135 @@
+---
+title: new.target
+slug: Web/JavaScript/Reference/Operators/new.target
+translation_of: Web/JavaScript/Reference/Operators/new.target
+original_slug: Web/JavaScript/Referencje/Operatory/new.target
+---
+<div>{{JSSidebar("Operators")}}</div>
+
+<p><strong><code>new.target</code></strong> pozwala sprawdzić czy konstruktor lub funkcja była zainicjalizowana używając operatora <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>. Kiedy w konstruktorze lub funkcji zainicjalizowany jest operatora <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>, <code>new.target</code> zwraca referencje do konstruktora lub funkcji. W normalnym wywołaniu funkcji, <code>new.target</code> jest {{jsxref("undefined")}}.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">new.target</pre>
+
+<h2 id="Opis">Opis</h2>
+
+<p><code>new.target</code> składa się ze słowa <code>"new</code>", kropki i pola o nazwie <code>"target"</code>. Przeważnie "<code>new."</code> jest kontekstem dostępu do pola, ale w tym przypadku "new." nie jest tak naprawdę obiektem. W wywołaniu konstruktora, <code>new.target</code> nawiązuje do konstruktora wywołanego przez <code>new</code> więc "<code>new.</code>" staje się wirtualnym kontekstem.</p>
+
+<p><code><font face="Open Sans, Arial, sans-serif">Pole </font>new.target</code> jest meta polem które jest dostępne dla wszystkich funkcji. W <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a>, <code>new.target</code> nawiązuje do <code>new.target</code> otaczającej funkcji.</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="new.target_w_wywołaniu_funkcji">new.target w wywołaniu funkcji</h3>
+
+<p>W normalnym wywołaniu funkcji (w przeciwieństwie do wywołania konstruktora), <code>new.target</code> jest {{jsxref("undefined")}}. Pozwala Ci to stwierdzić, czy funkcja została wywołana wraz z <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a> jako konstruktor.</p>
+
+<pre class="brush: js">function Foo() {
+  if (!new.target) throw "Foo() must be called with new";
+  console.log("Foo instantiated with new");
+}
+
+Foo(); // throws "Foo() must be called with new"
+new Foo(); // logs "Foo instantiated with new"
+</pre>
+
+<h3 id="new.target_w_konstruktorze">new.target w konstruktorze</h3>
+
+<p>W konstruktorach klasy, <code>new.target</code> nawiązuje do konstruktora który został bezpośrednio wywołany z <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>. Dzieje się tak również w przypadku kiedy konstruktor znajduje się w klasie rodzica, i został wywołany z konstruktorze dziecka.</p>
+
+<pre class="brush: js">class A {
+  constructor() {
+    console.log(new.target.name);
+  }
+}
+
+class B extends A { constructor() { super(); } }
+
+var a = new A(); // logs "A"
+var b = new B(); // logs "B"
+</pre>
+
+<h2 id="Specyfikacja">Specyfikacja</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-built-in-function-objects', 'Built-in Function Objects')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-built-in-function-objects', 'Built-in Function Objects')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_przeglądarek">Kompatybilność przeglądarek</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(46.0)}}</td>
+   <td>{{CompatGeckoDesktop(41)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(46.0)}}</td>
+   <td>{{CompatGeckoMobile(41)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(46.0)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions">Functions</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/new/index.html b/files/pl/web/javascript/reference/operators/new/index.html
new file mode 100644
index 0000000000..15e6d37549
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/new/index.html
@@ -0,0 +1,184 @@
+---
+title: Operator new
+slug: Web/JavaScript/Reference/Operators/new
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Operators/new
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_new
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p><strong>Operator</strong><strong> <code>new</code> </strong>tworzy nową instancję typu obiektu zdenifiowanego przez użytkownika lub instancję wbudowanego typu obiektu, który posiada konstruktor.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-newoperator.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate">new <em>constructor</em>[([<em>arguments</em>])]</pre>
+
+<h3 id="Parametry">Parametry</h3>
+
+<dl>
+ <dt><code>constructor</code></dt>
+ <dd>Klasa bądź funkcja, która definiuje typ obiektu instancji.</dd>
+</dl>
+
+<dl>
+ <dt><code>arguments</code></dt>
+ <dd>Lista wartości z którymi zostanie wywołany <code>constructor</code>.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Tworzenie obiektu przez zdefiniowanego przez użytkownika przebiega w dwóch krokach:</p>
+
+<ol>
+ <li>Zdefiniowanie typu obiektu poprzez napisanie funkcji.</li>
+ <li>Tworzenie jego instancji przy użyciu słowa kluczowego <code>new</code>.</li>
+</ol>
+
+<p>Aby zdefiniować typ obiektu, stwórz funkcję dla tego typu, która określa jego nazwę i właściwości. Obiekt może mieć właściwość, której wartością jest on sam lub inny obiekt. Spójrz na przykłady poniżej</p>
+
+<p>Kiedy wykonywaniy jest kod <code>new <em>Foo</em>(...)</code>, dzieją się następujące rzeczy:</p>
+
+<ol>
+ <li>Tworzeny jest nowy obiekt, dzidziczący po <code><em>Foo</em>.prototype</code>.</li>
+ <li>Wywoływany jest konstruktor <em><code>Foo</code></em> z określonymi argumentami, a kontekst <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code> zostaje przypisany do nowo utworzonego obiektu. <code>new <em>Foo</em></code> jest równoznaczne z <code>new </code><em><code>Foo</code></em><code>()</code>, tzn. w przypadku gdy lista argumentów jst nieokreślona, <em><code>Foo</code></em> jest wywoływane bez argumentów.</li>
+ <li>Obiekt zwrócony przez konstruktor staje się wynikiem całego wyrażenia <code>new</code>. Jeżeli konstruktor nie zwraca obiektu, obiekt stworzony w kroku 1 jest używany zamiast niego. (Zwykle kontruktory nie zwracają żadnej wartości, ale mogą tak czynić jeśli chcą nadpiać normalny proces tworzenia obiektu.)</li>
+</ol>
+
+<p>Zawsze można dodać właściwość do wcześniej stworzonego obiektu. Na przykład, wyrażenie <code>car1.color = "black"</code> dodaje właściwość <code>color</code> do <code>car1</code>, przypisuje mu wartość "<code>black</code>". Jednakże, nie wpływa to w żaden sposób na inne obiekty. Aby dodać właściwość do wszystkich obiektów tego samego typu, trzeba dodać tę właściwość do definicji typu obiektu <code>Car</code>.</p>
+
+<p>Można dodać wspólną właściwość do wcześniej zdefiniowanego typu obiektu korzystając z właściwości <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype">Function.prototype</a></code>. Definiuje ona wspólną właściwość dla wszystkich obiektów tego typu, a nie charakterystyczną dla instancji typu obiektu. Następujący kod dodaje właściwość <code>color</code> o wartości <code>null</code> do wszystkich obiektów typu <code>Car</code>, a następnie znienia tę wartość tylko w obiekcie <code>car1</code> na łańcuch "<code>black</code>" . Po więcej informacji, zobacz <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype">prototype</a>.</p>
+
+<pre class="brush: js notranslate">function Car() {}
+car1 = new Car();
+
+console.log(car1.color);    // undefined
+
+Car.prototype.color = null;
+console.log(car1.color);    // null
+
+car1.color = 'black';
+console.log(car1.color);   // black
+</pre>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Typ_obiektu_i_jego_instancja">Typ obiektu i jego instancja</h3>
+
+<p>Przypuśćmy, że chcesz stworzyś typ obiektu dla aut. Chcesz, żeby był nazwany <code>car</code> i by miał właściwości <code>make</code>, <code>model</code> i <code>year</code>. Żeby to osiągnąć należy stworzyć następującą funkcję:</p>
+
+<pre class="brush: js notranslate">function Car(make, model, year) {
+  this.make = make;
+  this.model = model;
+  this.year = year;
+}
+</pre>
+
+<p>Teraz można stworzyć obiekt <code>mycar</code>:</p>
+
+<pre class="brush: js notranslate">var mycar = new Car('Eagle', 'Talon TSi', 1993);
+</pre>
+
+<p>Powyższy kod deklaruje zmienną <code>mycar</code> i przypisuje do niej określone właściwości. Wartość <code>mycar.make</code> to łańcuch "Eagle", <code>mycar.year</code> to liczba 1993 itd.</p>
+
+<p>Można stworzyć nieograniczoną ilość obiektów <code>Car</code> poprzez słowo kluczowe <code>new</code>. Na przykład:</p>
+
+<pre class="brush: js notranslate">var kenscar = new Car('Nissan', '300ZX', 1992);
+</pre>
+
+<h3 id="Właściwość_obiektu_będąca_innym_obiektem">Właściwość obiektu, będąca innym obiektem</h3>
+
+<p>Przypuśćmy, że definiujemy typ obiektu <code>Person</code> jak poniżej:</p>
+
+<pre class="brush: js notranslate">function Person(name, age, sex) {
+  this.name = name;
+  this.age = age;
+  this.sex = sex;
+}
+</pre>
+
+<p>A następnie tworzymy dwa obiekty <code>Person</code>:</p>
+
+<pre class="brush: js notranslate">var rand = new Person('Rand McNally', 33, 'M');
+var ken = new Person('Ken Jones', 39, 'M');
+</pre>
+
+<p>Teraz możemy przepisać definicję <code>Car</code> tak, by zawierała właściwość <code>owner</code>, która przyjmuje obiekt:</p>
+
+<pre class="brush: js notranslate">function Car(make, model, year, owner) {
+  this.make = make;
+  this.model = model;
+  this.year = year;
+  this.owner = owner;
+}
+</pre>
+
+<p>Aby utworzyć nowe obiekty, należy napisać:</p>
+
+<pre class="brush: js notranslate">var car1 = new Car('Eagle', 'Talon TSi', 1993, rand);
+var car2 = new Car('Nissan', '300ZX', 1992, ken);
+</pre>
+
+<p>Zamiast przekazywania wartości liczbowych lub łańcuchów znaków, w powyższym przykładzie przekazywane są obiekty: <code>rand</code> oraz <code>ken</code>. Aby uzyskać imię właściciela samochodu <code>car2</code>, należy napisać:</p>
+
+<pre class="brush: js notranslate">car2.owner.name
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specifikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Komentarz</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-new-operator', 'The new Operator')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-new-operator', 'The new Operator')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.2.2', 'The new Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-11.2.2', 'The new Operator')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-11.2.2', 'The new Operator')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Wstępna definicja. Zaimpelementowano w JavaScript 1.0.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.operators.new")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("Reflect.construct()")}}</li>
+ <li>{{jsxref("Object.prototype")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/nullish_coalescing_operator/index.html b/files/pl/web/javascript/reference/operators/nullish_coalescing_operator/index.html
new file mode 100644
index 0000000000..8ae6ee56a2
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/nullish_coalescing_operator/index.html
@@ -0,0 +1,252 @@
+---
+title: Operator null'owego scalania (??)
+slug: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator
+tags:
+  - JavaScript
+  - Language feature
+  - Operator
+  - Reference
+  - nullish coalescing
+translation_of: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator
+original_slug: Web/JavaScript/Referencje/Operatory/Nullish_coalescing_operator
+---
+<p>{{JSSidebar("Operators")}}</p>
+
+<p><strong>Operator null'owego scalania (<code>??</code>)</strong> - to operator logiczny, stosowany w wyrażeniach, który zwraca to co jest po jego lewej stronie, tak długo, jak to nie jest <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code>, albo <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code>, wtedy zwraca to, co jest po prawej.</p>
+
+<div class="blockIndicator note">
+<p>Początkowo ewaluowane jest tylko wyrażenie z lewej strony.<br>
+ Dopiero, gdy zachodzi taka potrzeba, ewaluowane jest prawe wyrażenie.</p>
+</div>
+
+<p>Jest podobny do <strong>logicznego operatora LUB (<code>||</code>)</strong> ( <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR">Logical OR (||)</a> ), ale <strong>LUB</strong> decyduje o tym, czy wziąć prawą wartość, na innej podstawie:<br>
+ <em>Czy lewa wartość jest fałszopodobna</em> (<a href="/en-US/docs/Glossary/Falsy">Falsy</a>)<em>?</em><br>
+ <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code> i <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code> są fałszopodobne, ale sęk w tym, że nie tylko one, ale również np. <code>0</code>, czy <code>""</code>. Czasem nie chce się podmieniać niczego za <code>0</code> i <code>""</code>, uważając je za dopuszczalne wartości.<br>
+ Wtedy właśnie przydaje się ten operator.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-nullishcoalescingoperator.html")}}</div>
+
+<p class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.<br>
+ See <a href="https://github.com/mdn/interactive-examples/pull/1482#issuecomment-553841750">PR #1482</a> regarding the addition of this example.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate"><u>LWyr</u> ?? <u>PWyr</u></pre>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Pole</th>
+   <th scope="col">Opis</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>LWyr</td>
+   <td>Wyrażenie główne, ewaluowane na początku.<br>
+    Jeżeli jego wartość wynikowa jest <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code>, albo <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code>, to nie ona zostanie zwrócona, ale wartość wynikowa wyrażenia <u>PWyr</u>. </td>
+  </tr>
+  <tr>
+   <td>PWyr</td>
+   <td>Wyrażenie zamienne, ewaluowane, kiedy wartość <u>LWyr</u> jest <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code>, albo <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Przykłady"><span style="">Przykłady</span></h2>
+
+<h3 id="Użycie_operatora">Użycie operatora</h3>
+
+<p>W tym przykładzie użyjemy <strong>operatora null'owego scalania</strong> do podania zapasowych wartości, przy inicjowaniu stałych:</p>
+
+<pre class="brush: js notranslate">const wartoscNull = null;
+const warA = wartoscNull ?? "domyślne dla A";
+console.log(warA);
+
+// konsola: "domyślne dla A"
+
+
+
+const pustyTekst = "";   // fałszopodobny
+const warB = pustyTekst ?? "domyślne dla B";
+console.log(warB);
+
+// konsola: ""
+// ponieważ "??" reaguje tylko konkretnie na null albo undefined
+
+
+
+const jakasLiczba = 42;
+const warC = jakasLiczba ?? 0;
+console.log(warC);
+
+// konsola: 42</pre>
+
+<h3 id="Porównanie_działania_i">Porównanie działania "??" i "||"</h3>
+
+<p>Wcześniej przed pojawieniem się tego operatora, używano <strong>LUB (<code>||</code>) (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR">Logical OR (||)</a>)</strong>:</p>
+
+<pre class="notranslate">let liczba;
+let zabezpLicz = liczba || 1;
+// zmienna "wejscie" nie była nigdy zapełniona żadną wartością,
+// więc była "undefined", a undefined jest fałszopodobne, więc
+// JavaScript wziął zapasowe '1'.
+
+console.log(2 * zabezpLicz);
+// konsola: 2
+</pre>
+
+<p>To działa, ale...<br>
+ przez to jakim operatorem jest <strong>LUB</strong>, nie tylko <code>undefined</code> zostanie tu zamienione, ale też i <code>0</code>, które, w kontekście tego przykładu, powiedzmy, że jest wartością, która powinna być ok:</p>
+
+<pre class="brush: js notranslate">let liczba = 0;
+let zabezpLicz = liczba || 1;
+// zmienna "wejscie" została zapełniona zerem, ale jest fałszopodobne,
+//więc JavaScript wziął zapasowe '1'.
+
+console.log(2 * zabezpLicz);
+// konsola: 2
+// chcieliśmy: 0
+</pre>
+
+<p>Operator null'owego scalania rozwiązuje ten problem:</p>
+
+<pre class="brush: js notranslate">let liczba = 0;
+let zabezpLicz = liczba ?? 1;
+// zmienna "wejscie" została zapełniona zerem,
+//mimo tego, że jest fałszopodobne, "??" akceptuje je, bo to nie null, ani undefined, i
+//JavaScript zostawia '0'.
+
+console.log(2 * zabezpLicz);
+// konsola: 0
+</pre>
+
+<h3 id="Pomijanie_ewaluacji">Pomijanie ewaluacji</h3>
+
+<p>Podobnie jak inne operatory logiczne <strong>LUB (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR" style="">Logical OR (||)</a>)</strong> i <strong>I (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND">Logical AND (&amp;&amp;)</a>)</strong>, ten operator rozpoczyna od ewaluacji wyrażenia po lewej stronie, i dopiero gdy trzeba, zajmuje się prawą stroną:</p>
+
+<pre class="brush: js notranslate">function A(){
+  console.log("Tu A!");
+  return false;
+}
+function B(){
+  console.log("Tu B!");
+  return true;
+}
+
+if( A() ?? B() ) console.log("Otrzymano 'true'");
+else console.log("Otrzymano 'false'");
+// konsola: "Otrzymano 'false'"
+</pre>
+
+<p>i :</p>
+
+<pre class="brush: js notranslate">function A(){
+  console.log("Tu A!");
+  return null; // teraz tu jest zwracany null, na który reaguje "??"
+}
+function B(){
+  console.log("Tu B!");
+  return true;
+}
+
+if( A() ?? B() ) console.log("Otrzymano 'true'");
+else console.log("Otrzymano 'false'");
+// konsola: "Otrzymano 'true'"</pre>
+
+<h3 id="Nie_działa_seryjnie_ani_z_LUB_ani_z_I">Nie działa seryjnie, ani z LUB, ani z I</h3>
+
+<p>W wyrażeniach, nie można stawiać zwyczajnie <strong>operatora null'owego scalania</strong> w otoczeniu operatorów <strong>LUB</strong> i <strong>I</strong>, mimo ustalonej kolejności wykonywania działań. Będzie to odbierane jako błąd składniowy:</p>
+
+<pre class="brush: js example-bad notranslate">null || undefined ?? "yyy..."; // to będzie SyntaxError
+true || undefined ?? "aha.";   // to też będzie SyntaxError
+//bo tu chodzi o to, że jest "||" i "??" razem, nie o wartości.
+</pre>
+
+<p>Trzeba je rozdzielić nawiasami:</p>
+
+<pre class="brush: js example-good notranslate">(null || undefined) ?? "yyy...";  // zwraca: "yyy..."
+null || (undefined ?? "działa!"); // zwraca: "działa!"
+</pre>
+
+<h3 id="Odniesienie_do_Operatora_opcjonalnego_dostępu_.">Odniesienie do Operatora opcjonalnego dostępu "?."</h3>
+
+<p>Sposób w który <strong>operator null'owego scalania</strong> pracuje z wartościami <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null" style="">null</a></code> i <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code>, jest intuicyjny analogicznie u <strong>operatora opcjonalnego dostępu</strong> (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining">Optional chaining (?.)</a>, i razem pozwalają na ciekawe akcje, np.:</p>
+
+<pre class="notranslate">class objekt{
+  tekst;
+
+  constructor(tekst = null){
+    this.tekst = tekst;
+  }
+
+  odczytTekst(){
+    return this.tekst;
+  }
+  wpisTekst(w){
+    this.tekst = w;
+    return true;
+  }
+}
+
+let objekty = [new objekt("cześć!"), null, new objekt()];
+
+
+
+// zadanie kodu: zamień tekst'y w objekt'ach na duże litery,
+// używając funkcji dostępu, a pozostawiając puste wartości
+// bez zmian
+
+
+// wersja typeof
+for(let i = 0; i &lt; objekty.length; i++)
+  if(typeof(objekty[i]) == "object")
+    if(typeof(objekty[i].odczytTekst()) == "string")
+      objekty[i].wpisTekst(objekty[i].odczytTekst().toUpperCase());
+
+
+// wersja operatorów "??" i "?."
+for(let i = 0; i &lt; objekty.length; i++)
+  objekty[i]?.wpisTekst(objekty[i]?.odczytTekst()?.toUpperCase() ?? null);
+
+console.log(objekty);
+</pre>
+
+<p>Czasami użycie tych operatorów upraszcza kod.<br>
+ Poza tym każda funkcja jest wywoływana najwyżej raz i może to być co kolwiek.</p>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#prod-Nulli', 'nullish coalescing expression')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.operators.nullish_coalescing")}}</p>
+
+<h3 id="Postępy_implementacji">Postępy implementacji</h3>
+
+<p>Tabelka pod spodem pokazuje codzienny status implementacji tej funkcji. Jest tak, ponieważ nie osiągnięto jeszcze stabilności między przeglądarkami.<br>
+ Dane są generowane, poprzez przeprowadzanie odpowiednich testów funkcji w <a href="https://github.com/tc39/test262" style="">Test262</a>, standardowym zestawie testów dla JavaScripta, na najnowszych kompilacjach (en: "nightly build"), lub najnowszych wydaniach (en: "latest release") silników JavaScripta przeglądarek.</p>
+
+<div>{{EmbedTest262ReportResultsTable("coalesce-expression")}}</div>
+
+<h2 id="Zobacz_też...">Zobacz też...</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining">The optional chaining operator</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR_2">The logical OR (<code>||</code>) operator</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">Default parameters in functions</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/object_initializer/index.html b/files/pl/web/javascript/reference/operators/object_initializer/index.html
new file mode 100644
index 0000000000..545c4130bb
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/object_initializer/index.html
@@ -0,0 +1,388 @@
+---
+title: Inicjalizator obiektu
+slug: Web/JavaScript/Reference/Operators/Object_initializer
+translation_of: Web/JavaScript/Reference/Operators/Object_initializer
+original_slug: Web/JavaScript/Referencje/Operatory/Object_initializer
+---
+<div>{{JsSidebar("Operators")}}</div>
+
+<p>Obiekty można tworzyć używając <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>new Object()</code></a>,<code> <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create">Object.create()</a></code>, bądź wykorzystując notację literałową (notację <em>inicializacyjną</em>). Inicjalizator obiektu to lista zera lub więcej par - nazw właściwości oraz ich wartości - otoczonych nawiasami klamrowymi (<code>{}</code>).</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="brush: js">var o = {};
+var o = { a: "foo", b: 42, c: {} };
+
+var a = "foo", b = 42, c = {};
+var o = { a: a, b: b, c: c };
+
+var o =
+{
+  <var>wlasciwosc: function </var>([<var>parametry</var>]) {},
+  get <var>wlasciwosc</var>() {},
+  set <var>wlasciwosc</var>(<var>wartosc</var>) {},
+};
+</pre>
+
+<h3 id="Nowe_notacje_w_ECMAScript_2015">Nowe notacje w ECMAScript 2015</h3>
+
+<p>Pamiętaj aby zapoznać się z tabelą kompatybilności. Środowiska nie obsługujące tych notacji będą wyrzucać błędy składni.</p>
+
+<pre class="brush: js">// Skrótowe nazwy właściwości (ES6)
+var a = "foo", b = 42, c = {};
+var o = { a, b, c };
+
+// Skrótowe nazwy metod (ES6)
+var o = {
+  <var>wlasciwosc</var>([<var>parametry</var>]) {},
+  get <var>wlasciwosc</var>() {},
+  set <var>wlasciwosc</var>(<var>wartosc</var>) {},
+  * <var>generator</var>() {}
+};
+
+// Obliczone nazwy właściwości (ES6)
+var nazwa = "foo";
+var o = {
+  [nazwa]: "dzien",
+  ["b" + "ar"]: "dobry",
+};</pre>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Inicjalizator obiektu to wyrażenie opisujące inicjalizację obiektu {{jsxref("Object")}}. Obiekty składają się z <em>właściwości</em> używanych do opisywania obiektu. Wartości tych właściwości mogą zawierać {{Glossary("primitive")}} typy danych albo inne obiekty.</p>
+
+<h3 id="Tworzenie_obiektów">Tworzenie obiektów</h3>
+
+<p>Pusty obiekt możemy stworzyć w taki sposób:</p>
+
+<pre class="brush: js">var obiekt = {};</pre>
+
+<p>Jednak prawdziwą przewagą notacji literałowej jest możliwość tworzenia w szybki sposób obiektów ze zdefiniowanymi od razu właściwościami. Wystarczy wypisać listę kluczy: wartości odzdzielonych dwukropkiem. Poniższy przykład tworzy obiekt <code>osoba</code> z trzema właściwościami: "<code>imie</code>", "<code>wiek</code>" i "<code>wyglad</code>". Ich wartościami jest string "<code>Adam</code>", numer <code>42</code> oraz inny obiekt.</p>
+
+<pre class="brush: js">var osoba =
+{
+  imie: "Adam",
+  wiek: 42,
+  wyglad: { wzrost: 179 },
+}</pre>
+
+<h3 id="Dostęp_do_właściwości">Dostęp do właściwości</h3>
+
+<p>Kiedy już stworzyłeś obiekt, możesz chcieć zobaczyć lub zmienić jego właściwości. Można zrobić to używając zapisu z kropką lub nawiasami. Zajrzyj do <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_pamięci">operatorów pamięci</a> po więcej informacji.</p>
+
+<pre class="brush: js">object.imie; // "Adam"
+object["wiek"]; // 42
+
+object.imie = "Ewa";
+</pre>
+
+<h3 id="Definiowanie_właściwości">Definiowanie właściwości</h3>
+
+<p>Nauczyliśmy się już jak zapisywać właściwości używając notacji literałowej. Czasami jednak mamy w kodzie zmienne, które chcielibyśmy dodać do naszego obiektu. Możemy to zrobić w taki sposób:</p>
+
+<pre class="brush: js">var a = "foo",
+    b = 42,
+    c = {};
+
+var o =
+{
+  a: a,
+  b: b,
+  c: c
+};</pre>
+
+<p>Ale ECMAScript 2015 oddaje nam do dyspozycji krótszy zapis, pozwalający uzyskać ten sam efekt:</p>
+
+<pre class="brush: js">var a = "foo",
+    b = 42,
+    c = {};
+
+// Skrótowe nazwy właściwości (ES6)
+var o = { a, b, c };</pre>
+
+<h4 id="Duplikowanie_nazw_właściwości">Duplikowanie nazw właściwości</h4>
+
+<p>W momencie, gdy użyjemy już istniejącej nazwy właściwości jej wartość nadpisze tę poprzednią.</p>
+
+<pre class="brush: js">var a = {x: 1, x: 2};
+console.log(a); // { x: 2}
+</pre>
+
+<p>W ECMAScript 5 <em>strict mode,</em> duplikowanie nazw właściwości było postrzegane jako {{jsxref("SyntaxError")}}. Zmieniono to jednak po wprowadzeniu obliczanych nazw właściwości. Duplikacja stała się wówczas możliwa podczas wykonywania kodu, dlatego też w ECMAScript 2015 usunięto tę rystrykcję.</p>
+
+<pre class="brush: js">function czyES6UmozliwiaDuplikowanieWlasciwosci()
+{
+  "use strict";
+  try
+  {
+    ({ prop: 1, prop: 2 });
+
+    // Nie wyrzucono błędu, duplikacja dozwolona w <em>strict mode</em>.
+    return true;
+  }
+  catch (e)
+  {
+    // Wyrzucono błąd, duplikacja w <em>strict mode</em> zabroniona.
+    return false;
+  }
+}</pre>
+
+<h3 id="Definicje_metod">Definicje metod</h3>
+
+<p>Właściwość obiektu może również odnosić się do <a href="pl/docs/Web/JavaScript/Reference/Functions">funkcji</a> albo metody <a href="/pl/docs/Web/JavaScript/Reference/Functions/get">getter</a> lub <a href="/pl/docs/Web/JavaScript/Reference/Functions/set">setter</a>.</p>
+
+<pre class="brush: js">var o = {
+  <var>wlasciwos: function </var>([<var>parametry</var>]) {},
+  get <var>wlasciwos</var>() {},
+  set <var>wlasciwos</var>(<var>wartosc</var>) {},
+};</pre>
+
+<p>w ECMAScript 2015, mamy dostęp do skróconego zapisu, takiego w którym słowo kluczowe "function" nie jest nam już potrzebne.</p>
+
+<pre class="brush: js">// Shorthand method names (ES6)
+var o = {
+  <var>property</var>([<var>parameters</var>]) {},
+  get <var>property</var>() {},
+  set <var>property</var>(<var>value</var>) {},
+  * <var>generator</var>() {}
+};</pre>
+
+<p>W ECMAScript 2015 możemy również w prostszy sposób zapisać właściwość będącą funkcją generatora:</p>
+
+<pre class="brush: js">var o = {
+  * <var>generator</var>() {
+    ...........
+  }
+};</pre>
+
+<p>W ECMAScript 5 musielibyśmy zapisać to tak (aczkolwiek pamiętaj że w ES5 nie ma generatorów):</p>
+
+<pre class="brush: js">var o = {
+  generator<var>: function *</var>() {
+    ...........
+  }
+};</pre>
+
+<p>Po więcej informacji zajrzyj do <a href="/pl/docs/Web/JavaScript/Reference/Functions/Method_definitions">definicji metod</a>.</p>
+
+<h3 id="Obliczone_nazwy_właściwości">Obliczone nazwy właściwości</h3>
+
+<p>Od ECMAScript 2015, składnia inicjalizatora obiektu wspiera także obliczone nazwy właściwości. Umożliwia to umieszczenie wyrażenia w nawiasach <code>[]</code>, które potem zostanie przeliczone na nazwę właściwości. Działa to na tej samej zasadzie co zapis klamrowy w <a href="/pl/docs/Web/JavaScript/Reference/Operators/Property_Accessors">operatorach pamięci</a>, z którymi zapewne miałeś już styczność. Teraz możemy użwać tej samej składni w notacji literałowej:</p>
+
+<pre class="brush: js">// Obliczone nazwy właściwości (ES6)
+var i = 0;
+var a = {
+  ["foo" + ++i]: i,
+  ["foo" + ++i]: i,
+  ["foo" + ++i]: i
+};
+
+console.log(a.foo1); // 1
+console.log(a.foo2); // 2
+console.log(a.foo3); // 3
+
+var param = 'typ';
+var info = {
+  [param]: 'strona',
+  ["pod" + param.charAt(0).toUpperCase() + param.slice(1)]: 'forum'
+};
+
+console.log(info); // { typ: 'strona', 'podTyp': 'forum' }</pre>
+
+<h3 id="Zmiana_prototypu">Zmiana prototypu</h3>
+
+<p>Definicja właściwości w formie <code>__proto__: wartosc</code> albo <code>"__proto__": wartosc</code> nie stworzy właściwości z nazwą <code>__proto__</code>. Zamiast tego, jeżeli podana wartość jest obiektem lub typem <code>null</code>, zamieni ona <code>[[Prototype]]</code> tworzonego obiektu na podaną wartość. (Jeżeli wartość nie jest ani obiektem ani typem <code>null</code> prototyp nie zostanie zmieniony.)</p>
+
+<pre class="brush: js">var obj1 = {};
+console.log(Object.getPrototypeOf(obj1) === Object.prototype); // true
+
+var obj2 = { __proto__: null };
+console.log(Object.getPrototypeOf(obj2) === null); // true
+
+var protoObj = {};
+var obj3 = { "__proto__": protoObj };
+console.log(Object.getPrototypeOf(obj3) === protoObj); // true
+
+var obj4 = { __proto__: "not an object or null" };
+console.log(Object.getPrototypeOf(obj4) === Object.prototype); // true
+console.log(!obj4.hasOwnProperty("__proto__")); // true
+</pre>
+
+<p>Podczas notacji literałowej możemy zmienić prototyp tylko raz, kolejne próby będą skutkować błędami składni.</p>
+
+<p>Jeżeli użyjemy w defninicji nazwy <code>__proto__</code> bez używania składni z dwukropkiem, nazwa ta będzie się zachowywać jak kazda inna.</p>
+
+<pre class="brush: js">var __proto__ = "wartosc";
+
+var obj1 = { __proto__ };
+console.log(Object.getPrototypeOf(obj1) === Object.prototype); // true
+console.log(obj1.hasOwnProperty("__proto__")); // true
+console.log(obj1.__proto__ === "wartosc"); // true
+
+var obj2 = { __proto__() { return "witaj"; } };
+console.log(obj2.__proto__() === "witaj"); // true
+
+var obj3 = { ["__prot" + "o__"]: 17 };
+console.log(obj3.__proto__ === 17); // true
+</pre>
+
+<h2 id="Notacja_literałowa_vs_JSON">Notacja literałowa vs JSON</h2>
+
+<p>Notacja literałowa to nie to samo co <strong>J</strong>ava<strong>S</strong>cript <strong>O</strong>bject <strong>N</strong>otation (<a href="/pl/docs/Glossary/JSON">JSON</a>). Pomimo, że wyglądają podobnie, są miedzy nimi poważne różnice:</p>
+
+<ul>
+ <li>JSON dopuszcza tylko składnie <code>"wlasnosc": wartosc</code>.  Nazwa własności musi być w cudzysłowie, a defnicja nie może być skrócona.</li>
+ <li>W JSON wartościami moga być tylko string'i, liczby, tablice, <code>true</code>, <code>false</code>, <code>null</code>, lub inny obiekt JSON.</li>
+ <li>Funkcja nie może być przypisana do wartości w JSON.</li>
+ <li>Obiekty jak {{jsxref("Date")}} zostaną zamienione na string po użyciu {{jsxref("JSON.parse()")}}.</li>
+ <li>{{jsxref("JSON.parse()")}} odrzuni obliczone nazwy zmiennych oraz wyrzuci błąd.</li>
+</ul>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Początkowa definicja.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Dodano metody <a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">getter</a> oraz <a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setter</a>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object-initializer', 'Object Initializer')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Skrócone nazwy właściwości/metod oraz obliczone nazwy właściwości.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object-initializer', 'Object Initializer')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(1.0)}}</td>
+   <td>{{CompatGeckoDesktop("1.0")}}</td>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>Computed property names</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>Shorthand property names</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("33")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Shorthand method names</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatGeckoDesktop("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("1.0")}}</td>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+   <td>{{CompatChrome(1.0)}}</td>
+  </tr>
+  <tr>
+   <td>Computed property names</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Shorthand property names</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("33")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Shorthand method names</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatGeckoMobile("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(42.0)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Operatory pamięci</a></li>
+ <li><code><a href="/pl/docs/Web/JavaScript/Reference/Functions/get">get</a></code> / <code><a href="/pl/docs/Web/JavaScript/Reference/Functions/set">set</a></code></li>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Functions/Method_definitions">Definicje metod</a></li>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Lexical_grammar">Gramatyka leksykalna</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/operator_precedence/index.html b/files/pl/web/javascript/reference/operators/operator_precedence/index.html
new file mode 100644
index 0000000000..5b377584c9
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/operator_precedence/index.html
@@ -0,0 +1,337 @@
+---
+title: Pierwszeństwo operatorów
+slug: Web/JavaScript/Reference/Operators/Operator_Precedence
+tags:
+  - JavaScript
+  - Operator
+  - pierwszeństwo
+translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence
+original_slug: Web/JavaScript/Referencje/Operatory/Pierwszeństwo_operatorów
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<div></div>
+
+<div>Pierwszeństwo operatorów ustala kolejność, w jakiej operatory są ewaluowane. Operatory z wyższym pierwszeństwem są ewaluowane jako pierwsze.</div>
+
+<div></div>
+
+<p>Prosty przykład:</p>
+
+<pre class="brush: js notranslate">3 + 4 * 5 // zwraca 23
+</pre>
+
+<p>Operator mnożenia ("<code>*</code>") ma wyższe pierwszeństwo niż operator dodawania ("<code>+</code>") i dlatego będzie ewaluowany jako pierwszy.</p>
+
+<h2 id="Associativity" name="Associativity">Łączność</h2>
+
+<p>Łączność określa kolejność, w jakiej przetwarzane są operatory o takim samym pierwszeństwie. Przykłądowo, rozważny wyrażenie:</p>
+
+<pre class="syntaxbox notranslate">a OP b OP c
+</pre>
+
+<p>Jeżeli  <code>OP<sub>1</sub></code> and <code>OP<sub>2 </sub></code>mają różne poziomy pierwszeństwa operatorów (patrz tabela poniżej), operator z wyższym poziomem pierwszeństwa zostanie wykonany jako pierwszy, a kolejność zapisu nie ma znaczenia. Zwróćmy uwagę na w poniższym przykładzie, że mnożenie ma wyższy poziom pierwszeństwa i tym samym zostanie wykonane jako pierwsze, pomimo tego, że to dodawanie jest zapisane w kodzie jako pierwsze.</p>
+
+<pre class="notranslate">console.log(3 + 10 * 2);   // wynik 23
+console.log(3 + (10 * 2)); // wynik 23 ponieważ nawiasy tutaj nie mają znaczenia
+console.log((3 + 10) * 2); // wynik 26 ponieważ nawiasy zmieniają kolejność działań</pre>
+
+<p>Lewo-łączność (od lewej do prawej) oznacza, iż będzie ono przetworzone jako <code>(a OP b) OP c</code>, podczas gdy prawo-łączność (od prawej do lewej) oznacza, iż będzie ono zinterpretowane jako <code>a OP (b OP c)</code>. Operatory przypisania są prawo-łączne, więc możesz napisać:</p>
+
+<pre class="brush: js notranslate">a = b = 5;
+</pre>
+
+<p>oczekując, że <code>a</code> i <code>b</code> otrzymają wartość 5. Wynika to z faktu, iż operator przypisania zwraca wartość, która jest przypisana. Najpierw wartość <code>b</code> ustawiana jest na 5, a następnie wartość zmiennej <code>a</code> jest ustawiana na wartość <code>b</code>.</p>
+
+<h2 id="Tabela" name="Tabela">Tabela</h2>
+
+<p>Poniższa tabela uporządkowana jest od najwyższego (19) do najniższego (0) pierwszeństwa.</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <th>Pierwszeństwo</th>
+   <th>Rodzaj operatora</th>
+   <th>Łączność</th>
+   <th>Operator</th>
+  </tr>
+  <tr>
+   <td>19</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Grouping">Grouping</a></td>
+   <td>n/a</td>
+   <td><code>( … )</code></td>
+  </tr>
+  <tr>
+   <td rowspan="3">18</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors#Dot_notation">Member Access</a></td>
+   <td>left-to-right</td>
+   <td><code>… . …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors#Dot_notation">Computed Member Access</a></td>
+   <td>left-to-right</td>
+   <td><code>… [ … ]</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Special/new" title="JavaScript/Reference/Operators/Special_Operators/new_Operator">new</a> (z listą argumentów)</td>
+   <td>n/a</td>
+   <td><code>new … ( … )</code></td>
+  </tr>
+  <tr>
+   <td rowspan="2">17</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions" title="JavaScript/Reference/Operators/Special_Operators/function_call">Wywołanie funkcji</a></td>
+   <td>left-to-right</td>
+   <td><code>… ( <var>… </var>)</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new" title="JavaScript/Reference/Operators/Special_Operators/new_Operator">new</a> (bez listy argumentów)</td>
+   <td>right-to-left</td>
+   <td><code>new …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="2">16</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment" title="JavaScript/Reference/Operators/Arithmetic_Operators">Postinkrementacja</a></td>
+   <td>n/a</td>
+   <td><code>… ++</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement" title="JavaScript/Reference/Operators/Arithmetic_Operators">Postdekrementacja</a></td>
+   <td>n/a</td>
+   <td><code>… --</code></td>
+  </tr>
+  <tr>
+   <td rowspan="9">15</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT" title="JavaScript/Reference/Operators/Logical_Operators">Negacja logiczna (NOT)</a></td>
+   <td>right-to-left</td>
+   <td><code>! …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_NOT" title="JavaScript/Reference/Operators/Bitwise_Operators">Negacja bitowa (NOT)</a></td>
+   <td>right-to-left</td>
+   <td><code>~ …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_plus" title="JavaScript/Reference/Operators/Arithmetic_Operators">Unary Plus</a></td>
+   <td>right-to-left</td>
+   <td><code>+ …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_negation" title="JavaScript/Reference/Operators/Arithmetic_Operators">Unary Negation</a></td>
+   <td>right-to-left</td>
+   <td><code>- …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment" title="JavaScript/Reference/Operators/Arithmetic_Operators">Preinkrementacja</a></td>
+   <td>right-to-left</td>
+   <td><code>++ …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement" title="JavaScript/Reference/Operators/Arithmetic_Operators">Predekrementacja</a></td>
+   <td>right-to-left</td>
+   <td><code>-- …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof" title="JavaScript/Reference/Operators/Special_Operators/typeof_Operator">typeof</a></td>
+   <td>right-to-left</td>
+   <td><code>typeof …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void" title="JavaScript/Reference/Operators/Special_Operators/void_Operator">void</a></td>
+   <td>right-to-left</td>
+   <td><code>void …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete" title="JavaScript/Reference/Operators/Special_Operators/delete_Operator">delete</a></td>
+   <td>right-to-left</td>
+   <td><code>delete …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="3">14</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Multiplication" title="JavaScript/Reference/Operators/Arithmetic_Operators">Mnożenie</a></td>
+   <td>left-to-right</td>
+   <td><code>… * …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Division" title="JavaScript/Reference/Operators/Arithmetic_Operators">Dzielenie</a></td>
+   <td>left-to-right</td>
+   <td><code>… / …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder" title="JavaScript/Reference/Operators/Arithmetic_Operators">Reszta z dzielenia</a></td>
+   <td>left-to-right</td>
+   <td><code>… % …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="2">13</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition" title="JavaScript/Reference/Operators/Arithmetic_Operators">Dodawanie</a></td>
+   <td>left-to-right</td>
+   <td><code>… + …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Subtraction" title="JavaScript/Reference/Operators/Arithmetic_Operators">Odejmowanie</a></td>
+   <td>left-to-right</td>
+   <td><code>… - …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="3">12</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="JavaScript/Reference/Operators/Bitwise_Operators">Bitowe przesunięcie w lewo</a></td>
+   <td>left-to-right</td>
+   <td><code>… &lt;&lt; …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="JavaScript/Reference/Operators/Bitwise_Operators">Bitowe przesunięcie w prawo</a></td>
+   <td>left-to-right</td>
+   <td><code>… &gt;&gt; …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="JavaScript/Reference/Operators/Bitwise_Operators">Bitowe przesunięcie w prawo bez znaku</a></td>
+   <td>left-to-right</td>
+   <td><code>… &gt;&gt;&gt; …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="6">11</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Mniejsze niż</a></td>
+   <td>left-to-right</td>
+   <td><code>… &lt; …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than__or_equal_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Mniejsze lub równe</a></td>
+   <td>left-to-right</td>
+   <td><code>… &lt;= …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Greater_than_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Większe niż</a></td>
+   <td>left-to-right</td>
+   <td><code>… &gt; …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Greater_than_or_equal_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Większe lub równe</a></td>
+   <td>left-to-right</td>
+   <td><code>… &gt;= …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/in" title="JavaScript/Reference/Operators/Special_Operators/in_Operator">in</a></td>
+   <td>left-to-right</td>
+   <td><code>… in …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof" title="JavaScript/Reference/Operators/Special_Operators/instanceof_Operator">instanceof</a></td>
+   <td>left-to-right</td>
+   <td><code>… instanceof …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="4">10</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Equality" title="JavaScript/Reference/Operators/Comparison_Operators">Równość</a></td>
+   <td>left-to-right</td>
+   <td><code>… == …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Inequality" title="JavaScript/Reference/Operators/Comparison_Operators">Nierówność</a></td>
+   <td>left-to-right</td>
+   <td><code>… != …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Identity" title="JavaScript/Reference/Operators/Comparison_Operators">Ścisła równość</a></td>
+   <td>left-to-right</td>
+   <td><code>… === …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Nonidentity" title="JavaScript/Reference/Operators/Comparison_Operators">Ścisła nierówność</a></td>
+   <td>left-to-right</td>
+   <td><code>… !== …</code></td>
+  </tr>
+  <tr>
+   <td>9</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_AND" title="JavaScript/Reference/Operators/Bitwise_Operators">Koniunkcja bitowa (AND)</a></td>
+   <td>left-to-right</td>
+   <td><code>… &amp; …</code></td>
+  </tr>
+  <tr>
+   <td>8</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR" title="JavaScript/Reference/Operators/Bitwise_Operators">Bitowa alternatywa wykluczająca (XOR)</a></td>
+   <td>left-to-right</td>
+   <td><code>… ^ …</code></td>
+  </tr>
+  <tr>
+   <td>7</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_OR" title="JavaScript/Reference/Operators/Bitwise_Operators">Alternatywa bitowa (OR)</a></td>
+   <td>left-to-right</td>
+   <td><code>… | …</code></td>
+  </tr>
+  <tr>
+   <td>6</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_AND" title="JavaScript/Reference/Operators/Logical_Operators">Koniunkcja logiczna (AND)</a></td>
+   <td>left-to-right</td>
+   <td><code>… &amp;&amp; …</code></td>
+  </tr>
+  <tr>
+   <td>5</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR" title="JavaScript/Reference/Operators/Logical_Operators">Alternatywa logiczna (OR)</a></td>
+   <td>left-to-right</td>
+   <td><code>… || …</code></td>
+  </tr>
+  <tr>
+   <td>4</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator" title="JavaScript/Reference/Operators/Special_Operators/Conditional_Operator">Warunek</a></td>
+   <td>right-to-left</td>
+   <td><code>… ? … : …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="12">3</td>
+   <td rowspan="12"><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators" title="JavaScript/Reference/Operators/Assignment_Operators">Przypisanie</a></td>
+   <td rowspan="12">right-to-left</td>
+   <td><code>… = …</code></td>
+  </tr>
+  <tr>
+   <td><code>… += …</code></td>
+  </tr>
+  <tr>
+   <td><code>… -= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… *= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… /= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… %= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… &lt;&lt;= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… &gt;&gt;= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… &gt;&gt;&gt;= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… &amp;= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… ^= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… |= …</code></td>
+  </tr>
+  <tr>
+   <td>2</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield" title="JavaScript/Reference/Operators/yield">yield</a></td>
+   <td>right-to-left</td>
+   <td><code>yield …</code></td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator" title="JavaScript/Reference/Operators/Spread_operator">Spread</a></td>
+   <td>n/a</td>
+   <td><code>...</code> …</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator" title="JavaScript/Reference/Operators/Comma_Operator">Comma / Sequence</a></td>
+   <td>left-to-right</td>
+   <td><code>… , …</code></td>
+  </tr>
+ </tbody>
+</table>
diff --git a/files/pl/web/javascript/reference/operators/pipeline_operator/index.html b/files/pl/web/javascript/reference/operators/pipeline_operator/index.html
new file mode 100644
index 0000000000..6f62fbda6d
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/pipeline_operator/index.html
@@ -0,0 +1,66 @@
+---
+title: Operator potoku
+slug: Web/JavaScript/Reference/Operators/Pipeline_operator
+tags:
+  - JavaScript
+  - Operator
+  - ekxperymentalny
+translation_of: Web/JavaScript/Reference/Operators/Pipeline_operator
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_potoku
+---
+<div>{{jsSidebar("Operators")}} {{SeeCompatTable}}</div>
+
+<div>Eskperymentalny operator potoku <code>|&gt;</code> (obecnie na pierwszym etapie testów) pozwala na tworzenie łańcuchów wywołań funkcji w czytelny sposób. Dodaje lukier syntaktyczny do wywołania funkcji z pojedynczym argumentem, pozwalając przykładowo na pisanie <code>'%21' |&gt; decodeURI</code> zamiast <code>decodeURI('%21')</code>.</div>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">wyrażenie |&gt; funkcja</pre>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Łańcuchowe_wywołania_funkcji">Łańcuchowe wywołania funkcji</h3>
+
+<p>Operator potoku może poprawić czytelność kodu przy łańcuchowych wywołaniach wielu funkcji.</p>
+
+<pre class="brush: js">const double = (n) =&gt; n * 2;
+const increment = (n) =&gt; n + 1;
+
+// bez operatora potoku
+double(increment(double(double(5)))); // 42
+
+// z użyciem potoku
+5 |&gt; double |&gt; double |&gt; increment |&gt; double; // 42
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Uwagi</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><a href="http://tc39.github.io/proposal-pipeline-operator/">Pipeline operator draft</a></td>
+   <td>Stage 1</td>
+   <td>Nie jest jeszcze częścią specyfikacji ECMAScript.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.operators.pipeline")}}</p>
+</div>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li><a href="https://github.com/tc39/proposals">TC39 proposals</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/property_accessors/index.html b/files/pl/web/javascript/reference/operators/property_accessors/index.html
new file mode 100644
index 0000000000..2f9a053fd8
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/property_accessors/index.html
@@ -0,0 +1,178 @@
+---
+title: Operatory pamięci
+slug: Web/JavaScript/Reference/Operators/Property_Accessors
+tags:
+  - JavaScript
+  - Operator
+translation_of: Web/JavaScript/Reference/Operators/Property_Accessors
+original_slug: Web/JavaScript/Referencje/Operatory/Operatory_pamięci
+---
+<div>
+<div>{{jsSidebar("Operators")}}</div>
+</div>
+
+<p>Operatory pamięci umożliwiają dostęp do właściwości lub metod obiektu.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox">object.property
+object['property']
+</pre>
+
+<h2 id="Opis">Opis</h2>
+
+<p>Obiekt, w rzeczywistości, jest <em>kojarzeniową tablicą</em> (jak <em>mapa, słownik, hash, poglądowa tabela</em>).<em> Klucze </em>w tablicy są nazwami właściwości i metod (właściwości odnoszących się do funkcji). Istnieją dwa sposoby uzyskania dostępu do właściwości: zapis z kropką lub zapis z nawiasem (operator indeksu dolnego).</p>
+
+<h3 id="Dot_notation" name="Dot_notation">Zapis z kropką</h3>
+
+<pre class="brush: js">get = object.property;
+object.property = set;
+</pre>
+
+<p><code>property</code> musi być nazwane poprawnie, według zasad JavaScript, innymi słowy: musi być sekwencją znaków alfanumerycznych (włączając w to znak podkreślenia oraz znak dolara), która nie zaczyna się od cyfry. Na przykład: <code>object.$1</code> jest poprawny, natomiast <code>object.1</code> jest nieprawidłowy.</p>
+
+<p>Przykład:</p>
+
+<pre class="brush: js">document.createElement('pre');
+</pre>
+
+<p>Metoda "createElement" jest wywoływana z poziomu <code>document</code>.</p>
+
+<pre class="brush: js" id="Bracket_notation">Zapis z nawiasem</pre>
+
+<pre>get = object[property_name];
+object[property_name] = set;
+</pre>
+
+<p><code>property_name</code> jest łańcuchem znaków, nie musi być poprawnym identyfikatorem - może być zupełnie dowolny, przykładowo: "1foo", "!bar!" lub nawet " " (spacja).</p>
+
+<pre class="brush: js">document['createElement']('pre');
+</pre>
+
+<p>Mimo różnic, powyższa notacja wykonuje dokładnie to samo co zapis z kropką.</p>
+
+<h3 id="Nazwy_w.C5.82asno.C5.9Bci" name="Nazwy_w.C5.82asno.C5.9Bci">Nazwy właściwości</h3>
+
+<p>Nazwy właściwości muszą być łańcuchami. Oznacza to, że nazwy nie będące łańcuchami nie mogą być używane jako klucze w obiekcie. Dowolny obiekt nie będący łańcuchem, wliczając w to liczby, zostanie zrzutowany do obiektu string poprzez metodę {{jsxref("Object.toString", "toString()")}}.</p>
+
+<pre class="brush: js">var object = {};
+object['1'] = 'value';
+alert(object[1]);
+</pre>
+
+<p>Powyższy kod wyświetla "value", ponieważ 1 został zrzutowany do '1'.</p>
+
+<pre class="brush: js">var foo = {unique_prop: 1}, bar = {unique_prop: 2}, object = {};
+object[foo] = 'value';
+console.log(object[bar]);
+</pre>
+
+<p>W tym przykładzie także zostanie wypisany "value", ponieważ zarówno foo jak i bar zostały skonwertowane do tego samego łańcucha. W silniku JavaScript <a href="/pl/docs/SpiderMonkey" title="SpiderMonkey">SpiderMonkey</a>, łańcuch będzie wyglądał następująco: "{{ mediawiki.external('object Object') }}".</p>
+
+<h3 id="Wi.C4.85zanie_metod" name="Wi.C4.85zanie_metod">Wiązanie metod</h3>
+
+<p>Metoda nie jest powiązana z obiektem, którego jest metodą. Innymi słowy: <code>this</code> w metodzie nie jest ustawiony na sztywno. Nie musi on koniecznie odnosić się do obiektu zawierającego metodę. Zamiast tego <code>this</code> jest przekazywany do funkcji podczas jej wywoływania. Zajrzyj do <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operatory_specjalne/Operator_this#Wi.C4.85zanie_metod" title="Dokumentacja_języka_JavaScript_1.5/Operatory/Operatory_specjalne/Operator_this#Wi.C4.85zanie_metod">wiązania metod</a> po więcej informacji.</p>
+
+<h3 id="Note_on_eval" name="Note_on_eval">Uwaga dotycząca <code>eval</code></h3>
+
+<p>Początkujący programiści JavaScript popełniają częsty błąd, używając <a href="/pl/docs/Dokumentacja_j%C4%99zyka_JavaScript_1.5/Funkcje/eval" title="Dokumentacja_języka_JavaScript_1.5/Funkcje/eval">eval</a> tam gdzie może być użyty zapis z nawiasem. Poniżej zaprezentowany jest przykład.</p>
+
+<pre class="brush: js">x = eval('document.form_name.' + strFormControl + '.value');
+</pre>
+
+<p><code>eval</code> jest wolno-działającą funkcją i powinien być jak najrzadziej używany. Zoptymalizowany fragment kodu brzmi:</p>
+
+<pre class="brush: js">x = document.form_name[strFormControl].value;
+</pre>
+
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-property-accessors', 'Property Accessors')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-property-accessors', 'Property Accessors')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.2.1', 'Property Accessors')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-11.2.1', 'Property Accessors')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definicja początkowa. Zaimplementowana w JavaScript 1.0.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność_z_przeglądarkami">Kompatybilność z przeglądarkami</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Zobacz_również">Zobacz również</h2>
+
+<ul>
+ <li>{{jsxref("Object")}}</li>
+ <li>{{jsxref("Object/defineProperty")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/spread_syntax/index.html b/files/pl/web/javascript/reference/operators/spread_syntax/index.html
new file mode 100644
index 0000000000..fe872cea4c
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/spread_syntax/index.html
@@ -0,0 +1,245 @@
+---
+title: Składnia rozwinięcia
+slug: Web/JavaScript/Reference/Operators/Spread_syntax
+translation_of: Web/JavaScript/Reference/Operators/Spread_syntax
+original_slug: Web/JavaScript/Referencje/Operatory/Składnia_rozwinięcia
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<div><strong>Składnia rozwinięcia</strong> (ang. <em>spread syntax</em>) pozwala na rozwinięcie iterowalnego wyrażenia, takiego jak wyrażenie tablicowe lub ciąg znaków, tam gdzie oczekiwanych jest zero lub więcej argumentów (dla wywołań funkcji) lub elementów (dla literałów tablicowych). Pozwala również na rozwinięcie wyrażeń obiektowych w miejscach, gdzie oczekiwanych jest zero lub więcej par klucz-wartość (dla literałów obiektowych).</div>
+
+<div> </div>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-spreadsyntax.html")}}</div>
+
+
+
+<h2 id="Składnia">Składnia</h2>
+
+<p>Dla wywołań funkcji:</p>
+
+<pre class="syntaxbox">mojaFunkcja(...iterowalnyObiekt);
+</pre>
+
+<p>Dla literałów tablicowych lub łańcuchów znaków:</p>
+
+<pre class="syntaxbox">[...iterowalnyObiekt, '3', 'cztery', 5];</pre>
+
+<p>Dla literałów obiektowych (nowe w ECMAScript 2018):</p>
+
+<pre class="syntaxbox">let klonObiektu = { ...obiekt };</pre>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Rozwinięcie_w_wywołaniach_funkcji">Rozwinięcie w wywołaniach funkcji</h3>
+
+<h4 id="Zastąpienie_apply">Zastąpienie <code>apply</code></h4>
+
+<p>Powszechne jest używanie {{jsxref( "Function.prototype.apply")}} w przypadkach, w których chcemy użyć elementów tablicy jako argumentów funkcji.</p>
+
+<pre class="brush: js">function mojaFunkcja(x, y, z) { }
+var argumenty = [0, 1, 2];
+mojaFunkcja.apply(null, argumenty);</pre>
+
+<p>Przy użyciu operatora rozpakowania można to zapisać jako:</p>
+
+<pre class="brush: js">function mojaFunkcja(x, y, z) { }
+var argumenty = [0, 1, 2];
+mojaFunkcja(...argumenty);</pre>
+
+<p>Każdy argument na liście argumentów może użyć operatora rozpakowania, można go także używać wielokrotnie.</p>
+
+<pre class="brush: js">function mojaFunkcja(v, w, x, y, z) { }
+var argumenty = [0, 1];
+mojaFunkcja(-1, ...argumenty, 2, ...[3]);</pre>
+
+<h4 id="Apply_for_new">Apply for new</h4>
+
+<p>When calling a constructor with <code>new</code>, it's not possible to <strong>directly</strong> use an array and <code>apply</code> (<code>apply</code> does a <code>[[Call]]</code> and not a <code>[[Construct]]</code>). However, an array can be easily used with <code>new</code> thanks to spread syntax:</p>
+
+<pre class="brush: js">var dateFields = [1970, 0, 1];  // 1 Jan 1970
+var d = new Date(...dateFields);
+</pre>
+
+<p>To use new with an array of parameters without spread syntax, you would have to do it <strong>indirectly</strong> through partial application:</p>
+
+<pre class="brush: js">function applyAndNew(constructor, args) {
+   function partial () {
+      return constructor.apply(this, args);
+   };
+   if (typeof constructor.prototype === "object") {
+      partial.prototype = Object.create(constructor.prototype);
+   }
+   return partial;
+}
+
+
+function myConstructor () {
+   console.log("arguments.length: " + arguments.length);
+   console.log(arguments);
+   this.prop1="val1";
+   this.prop2="val2";
+};
+
+var myArguments = ["hi", "how", "are", "you", "mr", null];
+var myConstructorWithArguments = applyAndNew(myConstructor, myArguments);
+
+console.log(new myConstructorWithArguments);
+// (internal log of myConstructor):           arguments.length: 6
+// (internal log of myConstructor):           ["hi", "how", "are", "you", "mr", null]
+// (log of "new myConstructorWithArguments"): {prop1: "val1", prop2: "val2"}</pre>
+
+<h3 id="Rozwinięcie_w_literałach_tablicowych">Rozwinięcie w literałach tablicowych</h3>
+
+<h4 id="Potężniejszy_literał_tablicowy">Potężniejszy literał tablicowy</h4>
+
+<p>Bez składni rozwinięcia, aby utworzyć nową tablicę, używając tablicy już istniejącej jako jej części, składnia literału tablicowego nie jest już wystarczająca i musimy użyć kodu imperatywnego, używając kombinacji <code>push</code>, <code>splice</code>, <code>concat</code> itd. Z użyciem składni rozwinięcia staje się to o wiele prostsze i bardziej zwięzłe:</p>
+
+<pre class="brush: js">var czesci = ['kotek', 'na', 'plotek'];
+var wierszyk = ['wlazl', ...czesci, 'i', 'mruga'];
+// ["wlazl", "kotek", "na", "plotek", "i", "mruga"]
+</pre>
+
+<p>Tak jak dla list argumentów w wywołaniach funkcji, operator <code>...</code> może być użyty wielokrotnie i w każdym miejscu literału tablicowego.</p>
+
+<h4 id="Kopia_tablicy">Kopia tablicy</h4>
+
+<pre class="brush: js">var tab = [1, 2, 3];
+var tab2 = [...tab]; // jak tab.slice()
+tab2.push(4);
+
+// tab2 staje się [1, 2, 3, 4]
+// tab pozostaje niezmieniona
+</pre>
+
+<p><strong>Uwaga:</strong> Składnia rozwinięcia skutecznie sięga tylko na jeden poziom wgłąb przy kopiowaniu tablicy. W związku z tym takie podejście może być nieodpowiednie przy kopiowaniu tablic wielowymiarowych, jak pokazuje poniższy przykład (tak samo jest z {{jsxref("Object.assign()")}}  i kładnią rozwinięcia).</p>
+
+<pre class="brush: js">var a = [[1], [2], [3]];
+var b = [...a];
+b.shift().shift(); // 1
+// Tablica a została zmodyfikowana: [[], [2], [3]]
+</pre>
+
+<h4 id="Lepszy_sposób_na_łączenie_tablic">Lepszy sposób na łączenie tablic</h4>
+
+<p>{{jsxref("Array.concat")}} jest często używane do dołączania elementów jednej tablicy na koniec drugiej. Bez składni rozwinięcia wygląda to tak:</p>
+
+<pre class="brush: js">var tab1 = [0, 1, 2];
+var tab2 = [3, 4, 5];
+// Dołącz wszystkie elementy tab2 na koniec tab1
+tab1 = tab1.concat(tab2);</pre>
+
+<p>Przy użyciu składni rozwinięcia wygląda to natomiast tak:</p>
+
+<pre class="brush: js">var tab1 = [0, 1, 2];
+var tab2 = [3, 4, 5];
+tab1 = [...tab1, ...tab2];
+</pre>
+
+<p>{{jsxref("Array.unshift")}} jest często używane do dołączania elementów jednej tablicy na początek drugiej. Bez składni rozwinięcia wygląda to w następujący sposób:</p>
+
+<pre class="brush: js">var tab1 = [0, 1, 2];
+var tab2 = [3, 4, 5];
+// Dodaj wszystkie elementy tab2 na początek tab1
+Array.prototype.unshift.apply(tab1, tab2) // tab1 staje się [3, 4, 5, 0, 1, 2]</pre>
+
+<p>Przy użyciu składni rozwinięcia otrzymuje to następującą postać [jednak zauważ, że w tym przypadku utworzona zostaje nowa tablica <code>tab1</code> – w odróżnieniu od {{jsxref("Array.unshift")}}, <code>tab1</code> nie jest automatycznie modyfikowana):</p>
+
+<pre class="brush: js">var tab1 = [0, 1, 2];
+var tab2 = [3, 4, 5];
+tab1 = [...tab2, ...tab1]; // tab1 staje się [3, 4, 5, 0, 1, 2]
+</pre>
+
+<h3 id="Rozwinięcie_w_literałach_tablicowych_2">Rozwinięcie w literałach tablicowych</h3>
+
+<p>The <a href="https://github.com/tc39/proposal-object-rest-spread">Rest/Spread Properties for ECMAScript</a> proposal (stage 4) adds spread properties to <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">object literals</a>. It copies own enumerable properties from a provided object onto a new object.</p>
+
+<p>Shallow-cloning (excluding prototype) or merging of objects is now possible using a shorter syntax than {{jsxref("Object.assign()")}}.</p>
+
+<pre class="brush: js">var obj1 = { foo: 'bar', x: 42 };
+var obj2 = { foo: 'baz', y: 13 };
+
+var clonedObj = { ...obj1 };
+// Object { foo: "bar", x: 42 }
+
+var mergedObj = { ...obj1, ...obj2 };
+// Object { foo: "baz", x: 42, y: 13 }</pre>
+
+<p>Note that {{jsxref("Object.assign()")}} triggers <a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setters</a> whereas spread syntax doesn't.</p>
+
+<p>Note that you cannot replace nor mimic the {{jsxref("Object.assign()")}} function:</p>
+
+<pre class="brush: js">var obj1 = { foo: 'bar', x: 42 };
+var obj2 = { foo: 'baz', y: 13 };
+const merge = ( ...objects ) =&gt; ( { ...objects } );
+
+var mergedObj = merge ( obj1, obj2);
+// Object { 0: { foo: 'bar', x: 42 }, 1: { foo: 'baz', y: 13 } }
+
+var mergedObj = merge ( {}, obj1, obj2);
+// Object { 0: {}, 1: { foo: 'bar', x: 42 }, 2: { foo: 'baz', y: 13 } }</pre>
+
+<p>In the above example, the spread syntax does not work as one might expect: it spreads an <em>array</em> of arguments into the object literal, due to the rest parameter.</p>
+
+<h3 id="Tylko_dla_obiektów_iterowalnych">Tylko dla obiektów iterowalnych</h3>
+
+<p>Składnia rozwinięcia może być użyta jedynie dla obiektów<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator"> iterowalnych</a>:</p>
+
+<pre class="brush: js">var obiekt = {'klucz1': 'wartosc1'};
+var tablica = [...obiekt]; // TypeError: obiekt is not iterable
+</pre>
+
+<h3 id="Rozwinięcie_z_wieloma_wartościami">Rozwinięcie z wieloma wartościami</h3>
+
+<p>Kiedy używaż składni rozwinięcia do wywołań funkcji, musisz być świadomy możliwości przekroczenia limitu liczby argumentów w silniku JavaScript. Po więcej szczegółów zajrzyj do <a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Function/apply" title="The apply() method calls a function with a given this value, and arguments provided as an array (or an array-like object)."><code>apply()</code>.</a></p>
+
+<h2 id="Składnia_reszty_(parametry)">Składnia reszty (parametry)</h2>
+
+<p>Składnia reszty ang. <em>rest syntax</em>) wygląda dokładnie jak składnia rozwinięcia, ale jest używana do destrukturyzacji tablic i obiektów. W pewnym sensie składnia reszty jest przeciwieństwem składni rozpakowania: rozwinięcie „rozpakowuje” elementy tablicy, natomiast składnia reszty „zbiera” wiele elementów i „pakuje” je do pojedynczego elementu. Zobacz: <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">rest parameters.</a></p>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array-initializer')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer">Array Initializer</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-argument-lists">Argument Lists</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2018', '#sec-object-initializer')}}</td>
+   <td>{{Spec2('ES2018')}}</td>
+   <td>Defined in <a href="http://www.ecma-international.org/ecma-262/9.0/#sec-object-initializer">Object Initializer</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array-initializer')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>No changes.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object-initializer')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>No changes.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.operators.spread")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">Rest parameters</a> (również ‘<code>...</code>’)</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply">fn.apply</a> (również ‘<code>...</code>’)</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/super/index.html b/files/pl/web/javascript/reference/operators/super/index.html
new file mode 100644
index 0000000000..d3b49b5886
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/super/index.html
@@ -0,0 +1,172 @@
+---
+title: super
+slug: Web/JavaScript/Reference/Operators/super
+translation_of: Web/JavaScript/Reference/Operators/super
+original_slug: Web/JavaScript/Referencje/Operatory/super
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Słowo kluczowe <strong>super </strong>jest wykorzystywane do udostępniania i korzystania z funkcji klasy po której nasz obiekt dziedziczy.</p>
+
+<p>Wyrażenia <code>super.prop</code> i <code>super[expr]</code> są poprawne w każdej definicji metody zarówno w <a href="/pl/docs/Web/JavaScript/Reference/Classes">klasach</a> i <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">literałach obiektowych</a>.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox notranslate">super([arguments]); // wywołuje konstruktor klasy rodzica
+super.functionOnParent([arguments]);
+</pre>
+
+<h2 id="Opis">Opis</h2>
+
+<p>W przypadku użycia w konstruktorze, słowo kluczowe <code>super</code> pojawia się samodzielnie i musi zostać użyte przed użyciem słowa kluczowego <code>this</code> . Słowo kluczowe <code>super</code>  można również wykorzystać do wywoływania funkcji które nasz obiekt odziedziczył po swoim rodzicu.</p>
+
+<h2 id="Przykład">Przykład</h2>
+
+<h3 id="Użycie_super_w_klasach">Użycie <code>super</code> w klasach</h3>
+
+<p>Poniższy snippet został pobrany z <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">próbki klasy</a> (live demo). W tym przykładzie, super() jest wywoływane w celu uniknięcia powielania tych części konstruktora, które są wspólne zarówno dla <code>Rectangle</code> (trójkąta) jak i <code>Square</code> (kwadratu).</p>
+
+<pre class="brush: js notranslate">class Rectangle {
+  constructor(height, width) {
+    this.name = 'Rectangle';
+    this.height = height;
+    this.width = width;
+  }
+  sayName() {
+    console.log('Hi, I am a ', this.name + '.');
+  }
+  get area() {
+    return this.height * this.width;
+  }
+  set area(value) {
+    this._area = value;
+  }
+}
+
+class Square extends Rectangle {
+  constructor(length) {
+    this.height; // ReferenceError, super needs to be called first!
+
+    // Wywołanie konstruktora klasy nadrzędnej
+    // określenie szerokości i wysokości prostokąta
+    super(length, length);
+    // Uwaga: W pochodnych klasach, super() musi być wywołane wcześniej niż
+    // pierwsze użycie 'this'. W przeciwnym wypadku pojawi się błąd odniesienia.
+    this.name = 'Square';
+  }
+}</pre>
+
+<h3 id="Super-wywołanie_metod_statycznych">Super-wywołanie metod statycznych</h3>
+
+<p>Za pomocą <code>super</code> jesteś w stanie także wywołać metody statyczne.</p>
+
+<pre class="brush: js notranslate">class Rectangle {
+  constructor() {}
+  static logNbSides() {
+    return 'I have 4 sides';
+  }
+}
+
+class Square extends Rectangle {
+  constructor() {}
+  static logDescription() {
+    return super.logNbSides() + ' which are all equal';
+  }
+}
+Square.logDescription(); // 'I have 4 sides which are all equal'
+</pre>
+
+<h3 id="Usuwanie_właściwości_z_super_wyrzuci_błąd">Usuwanie właściwości z super wyrzuci błąd</h3>
+
+<p>Nie możesz użyć <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Operator_delete">operatora usuwania</a> oraz <code>super.prop</code> bądź <code>super[expr]</code> w celu usunięcia właściwości klasy rodzica ponieważ zostanie zwrócony błąd {{jsxref("ReferenceError")}}.</p>
+
+<pre class="brush: js notranslate">class Base {
+  constructor() {}
+  foo() {}
+}
+class Derived extends Base {
+  constructor() {}
+  delete() {
+    delete super.foo; // to jest niepoprawnie
+  }
+}
+
+new Derived().delete(); // ReferenceError: invalid delete involving 'super'. </pre>
+
+<h3 id="super.prop_nie_może_nadpisać_właściwości_typu_non-writable"><code>super.prop</code> nie może nadpisać właściwości typu non-writable </h3>
+
+<p>Definiując właściwości non-writable (niezapisywalne) np. {{jsxref("Object.defineProperty")}}, pamiętaj, że <code>super</code> nie może nadpisać takiej wartości.</p>
+
+<pre class="brush: js notranslate">class X {
+  constructor() {
+    Object.defineProperty(this, 'prop', {
+      configurable: true,
+      writable: false,
+      value: 1
+    });
+  }
+}
+
+class Y extends X {
+  constructor() {
+    super();
+  }
+  foo() {
+    super.prop = 2;   // Nie można nadpisać wartości
+  }
+}
+
+var y = new Y();
+y.foo(); // TypeError: "prop" is read-only
+console.log(y.prop); // 1
+</pre>
+
+<h3 id="Używanie_super.prop_w_literałach_obiektowych">Używanie <code>super.prop</code> w literałach obiektowych</h3>
+
+<p><code>super</code> może być także wykorzystane <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Object_initializer">inicjalizatorze / literale obiektu</a>.</p>
+
+<p>W tym przykładzie dwa obiekty definiują swoją metodę. W drugim obiekcie, <code>super</code> wywołuje metodę obiektu pierwszego. To działa dzięki {{jsxref("Object.setPrototypeOf()")}} z czym jesteśmy w stanie ustawić prototyp obiektu <code>obj2</code> na <code>obj1</code>, tak aby <code>super</code><span> było w stanie znaleźć metodę </span><code>method1</code><span> </span>w obiekcie <code>obj1</code><span>. </span></p>
+
+<pre class="brush: js notranslate">var obj1 = {
+  method1() {
+    console.log('method 1');
+  }
+}
+
+var obj2 = {
+  method2() {
+    super.method1();
+  }
+}
+
+Object.setPrototypeOf(obj2, obj1);
+obj2.method2(); // wypisze "method 1"
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-super-keyword', 'super')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Kompatybilność">Kompatybilność</h2>
+
+
+
+<p>{{Compat("javascript.operators.super")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li><a href="/pl/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+ <li><a href="https://medium.com/beginners-guide-to-mobile-web-development/super-and-extends-in-javascript-es6-understanding-the-tough-parts-6120372d3420">Anurag Majumdar - Super &amp; Extends in JavaScript</a></li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/this/index.html b/files/pl/web/javascript/reference/operators/this/index.html
new file mode 100644
index 0000000000..427d3f843e
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/this/index.html
@@ -0,0 +1,347 @@
+---
+title: this
+slug: Web/JavaScript/Reference/Operators/this
+translation_of: Web/JavaScript/Reference/Operators/this
+original_slug: Web/JavaScript/Referencje/Operatory/this
+---
+<div>
+<div>{{jsSidebar("Operators")}}</div>
+</div>
+
+<h2 id="Summary">Summary</h2>
+
+<p>W JavaScript słówko kluczowe <code>this</code> zachowuje się nieco inaczej w porównaniu do innych języków programowania. Istnieje również kilka różnic między trybem <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">strict mode</a> oraz non-strict mode.</p>
+
+<p>W większości przypadków wartość <code>this</code> jest ustalana na podstawie tego, jak wywołana została dana funkcja. Wartość ta nie może być przypisana podczas wykonywania się funkcji i może być inna za każdym wywołaniem. ES5 wprowadziło metodę <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">bind</a></code> dzięki której <a href="#The_bind_method">możemy przypisać wartość <code>this</code> w funkcji, niezależnie od tego jak została ona wywołana.</a></p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">this</pre>
+
+<h2 id="Global_context">Global context</h2>
+
+<p>In the global execution context (outside of any function), <code>this</code> refers to the global object, whether in strict mode or not.</p>
+
+<pre class="brush:js">console.log(this.document === document); // true
+
+// In web browsers, the window object is also the global object:
+console.log(this === window); // true
+
+this.a = 37;
+console.log(window.a); // 37
+</pre>
+
+<h2 id="Function_context">Function context</h2>
+
+<p>Inside a function, the value of <code>this</code> depends on how the function is called.</p>
+
+<h3 id="Simple_call">Simple call</h3>
+
+<pre class="brush:js">function f1(){
+  return this;
+}
+
+f1() === window; // global object
+</pre>
+
+<p>In this case, the value of <code>this</code> is not set by the call. Since the code is not in strict mode, the value of <code>this</code> must always be an object so it defaults to the global object.</p>
+
+<pre class="brush:js">function f2(){
+  "use strict"; // see strict mode
+  return this;
+}
+
+f2() === undefined;
+</pre>
+
+<p>In strict mode, the value of <code>this</code> remains at whatever it's set to when entering the execution context. If it's not defined, it remains undefined. It can also be set to any value, such as <code>null</code> or <code>42</code> or <code>"I am not this"</code>.</p>
+
+<div class="note"><strong>Note:</strong> In the second example, <code>this</code> should be <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a>, because <code>f2</code> was called without providing any base (e.g. <code>window.f2()</code>). This feature wasn't implemented in some browsers when they first started to support <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode" title="Strict mode">strict mode</a>. As a result, they incorrectly returned the <code>window</code> object.</div>
+
+<h3 id="As_an_object_method">As an object method</h3>
+
+<p>When a function is called as a method of an object, its <code>this</code> is set to the object the method is called on.</p>
+
+<p>In the following example, when <code>o.f()</code> is invoked, inside the function <code>this</code> is bound to the <code>o</code> object.</p>
+
+<pre class="brush:js">var o = {
+  prop: 37,
+  f: function() {
+    return this.prop;
+  }
+};
+
+console.log(o.f()); // logs 37
+</pre>
+
+<p>Note that this behavior is not at all affected by how or where the function was defined. In the previous example, we defined the function inline as the <code>f</code> member during the definition of <code>o</code>. However, we could have just as easily defined the function first and later attached it to <code>o.f</code>. Doing so results in the same behavior:</p>
+
+<pre class="brush:js">var o = {prop: 37};
+
+function independent() {
+  return this.prop;
+}
+
+o.f = independent;
+
+console.log(o.f()); // logs 37
+</pre>
+
+<p>This demonstrates that it matters only that the function was invoked from the <code>f</code> member of <code>o</code>.</p>
+
+<p>Similarly, the <code>this</code> binding is only affected by the most immediate member reference. In the following example, when we invoke the function, we call it as a method <code>g</code> of the object <code>o.b</code>. This time during execution, <code>this</code> inside the function will refer to <code>o.b</code>. The fact that the object is itself a member of <code>o</code> has no consequence; the most immediate reference is all that matters.</p>
+
+<pre class="brush:js">o.b = {g: independent, prop: 42};
+console.log(o.b.g()); // logs 42
+</pre>
+
+<h4 id="this_on_the_objects_prototype_chain"><code>this</code> on the object's prototype chain</h4>
+
+<p>The same notion holds true for methods defined somewhere on the object's prototype chain. If the method is on an object's prototype chain, <code>this</code> refers to the object the method was called on, as if the method was on the object.</p>
+
+<pre class="brush:js">var o = {f:function(){ return this.a + this.b; }};
+var p = Object.create(o);
+p.a = 1;
+p.b = 4;
+
+console.log(p.f()); // 5
+</pre>
+
+<p>In this example, the object assigned to the variable <code>p</code> doesn't have its own <code>f</code> property, it inherits it from its prototype. But it doesn't matter that the lookup for <code>f</code> eventually finds a member with that name on <code>o</code>; the lookup began as a reference to <code>p.f</code>, so <code>this</code> inside the function takes the value of the object referred to as <code>p</code>. That is, since <code>f</code> is called as a method of <code>p</code>, its <code>this</code> refers to <code>p</code>. This is an interesting feature of JavaScript's prototype inheritance.</p>
+
+<h4 id="this_with_a_getter_or_setter"><code>this</code> with a getter or setter</h4>
+
+<p>Again, the same notion holds true when a function is invoked from a getter or a setter. A function used as getter or setter has its <code>this</code> bound to the object from which the property is being set or gotten.</p>
+
+<pre class="brush:js">function modulus(){
+  return Math.sqrt(this.re * this.re + this.im * this.im);
+}
+
+var o = {
+  re: 1,
+  im: -1,
+  get phase(){
+    return Math.atan2(this.im, this.re);
+  }
+};
+
+Object.defineProperty(o, 'modulus', {
+    get: modulus, enumerable:true, configurable:true});
+
+console.log(o.phase, o.modulus); // logs -0.78 1.4142
+</pre>
+
+<h3 id="As_a_constructor">As a constructor</h3>
+
+<p>When a function is used as a constructor (with the <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code> keyword), its <code>this</code> is bound to new object being constructed.</p>
+
+<p>Note: while the default for a constructor is to return the object referenced by <code>this</code>, it can instead return some other object (if the return value isn't an object, then the <code>this</code> object is returned).</p>
+
+<pre class="brush:js">/*
+ * Constructors work like this:
+ *
+ * function MyConstructor(){
+ *   // Actual function body code goes here.
+ *   // Create properties on |this| as
+ *   // desired by assigning to them.  E.g.,
+ *   this.fum = "nom";
+ *   // et cetera...
+ *
+ *   // If the function has a return statement that
+ *   // returns an object, that object will be the
+ *   // result of the |new| expression.  Otherwise,
+ *   // the result of the expression is the object
+ *   // currently bound to |this|
+ *   // (i.e., the common case most usually seen).
+ * }
+ */
+
+function C(){
+  this.a = 37;
+}
+
+var o = new C();
+console.log(o.a); // logs 37
+
+
+function C2(){
+  this.a = 37;
+  return {a:38};
+}
+
+o = new C2();
+console.log(o.a); // logs 38
+</pre>
+
+<p>In the last example (<code>C2</code>), because an object was returned during construction, the new object that <code>this</code> was bound to simply gets discarded. (This essentially makes the statement "<code>this.a = 37;</code>" dead code. It's not exactly dead, because it gets executed, but it can be eliminated with no outside effects.)</p>
+
+<h3 id="call_and_apply"><code>call</code> and <code>apply</code></h3>
+
+<p>Where a function uses the <code>this</code> keyword in its body, its value can be bound to a particular object in the call using the <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call">call</a></code> or <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply">apply</a></code> methods that all functions inherit from <code>Function.prototype</code>.</p>
+
+<pre class="brush:js">function add(c, d){
+  return this.a + this.b + c + d;
+}
+
+var o = {a:1, b:3};
+
+// The first parameter is the object to use as
+// 'this', subsequent parameters are passed as
+// arguments in the function call
+add.call(o, 5, 7); // 1 + 3 + 5 + 7 = 16
+
+// The first parameter is the object to use as
+// 'this', the second is an array whose
+// members are used as the arguments in the function call
+add.apply(o, [10, 20]); // 1 + 3 + 10 + 20 = 34
+</pre>
+
+<p>Note that with <code>call</code> and <code>apply</code>, if the value passed as <code>this</code> is not an object, an attempt will be made to convert it to an object using the internal <code>ToObject</code> operation. So if the value passed is a primitive like <code>7</code> or <code>'foo'</code>, it will be converted to an Object using the related constructor, so the primitive number <code>7</code> is converted to an object as if by <code>new Number(7)</code> and the string <code>'foo'</code> to an object as if by <code>new String('foo'), e.g.</code></p>
+
+<pre class="brush:js">function bar() {
+  console.log(Object.prototype.toString.call(this));
+}
+
+bar.call(7); // [object Number]
+</pre>
+
+<h3 id="The_bind_method">The <code>bind</code> method</h3>
+
+<p>ECMAScript 5 introduced <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">Function.prototype.bind</a></code>. Calling <code>f.bind(someObject)</code> creates a new function with the same body and scope as <code>f</code>, but where <code>this</code> occurs in the original function, in the new function it is permanently bound to the first argument of <code>bind</code>, regardless of how the function is being used.</p>
+
+<pre class="brush:js">function f(){
+  return this.a;
+}
+
+var g = f.bind({a:"azerty"});
+console.log(g()); // azerty
+
+var o = {a:37, f:f, g:g};
+console.log(o.f(), o.g()); // 37, azerty
+</pre>
+
+<h3 id="As_a_DOM_event_handler">As a DOM event handler</h3>
+
+<p>When a function is used as an event handler, its <code>this</code> is set to the element the event fired from (some browsers do not follow this convention for listeners added dynamically with methods other than <code>addEventListener</code>).</p>
+
+<pre class="brush:js">// When called as a listener, turns the related element blue
+function bluify(e){
+  // Always true
+  console.log(this === e.currentTarget);
+  // true when currentTarget and target are the same object
+  console.log(this === e.target);
+  this.style.backgroundColor = '#A5D9F3';
+}
+
+// Get a list of every element in the document
+var elements = document.getElementsByTagName('*');
+
+// Add bluify as a click listener so when the
+// element is clicked on, it turns blue
+for(var i=0 ; i&lt;elements.length ; i++){
+  elements[i].addEventListener('click', bluify, false);
+}</pre>
+
+<h3 id="In_an_in–line_event_handler">In an in–line event handler</h3>
+
+<p>When code is called from an in–line handler, its <code>this</code> is set to the DOM element on which the listener is placed:</p>
+
+<pre class="brush:js">&lt;button onclick="alert(this.tagName.toLowerCase());"&gt;
+  Show this
+&lt;/button&gt;
+</pre>
+
+<p>The above alert shows <code>button</code>. Note however that only the outer code has its <code>this</code> set this way:</p>
+
+<pre class="brush:js">&lt;button onclick="alert((function(){return this}()));"&gt;
+  Show inner this
+&lt;/button&gt;
+</pre>
+
+<p>In this case, the inner function's <code>this</code> isn't set so it returns the global/window object (i.e. the default object in non–strict mode where <code>this</code> isn't set by the call).</p>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Initial definition. Implemented in JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.1.1', 'The this keyword')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-this-keyword', 'The this keyword')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">Strict mode</a></li>
+ <li><a href="http://bjorn.tipling.com/all-this">All this</a>, an article about <code>this</code> in different contexts</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/typeof/index.html b/files/pl/web/javascript/reference/operators/typeof/index.html
new file mode 100644
index 0000000000..d842ce1751
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/typeof/index.html
@@ -0,0 +1,92 @@
+---
+title: Operator typeof
+slug: Web/JavaScript/Reference/Operators/typeof
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Operators/typeof
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_typeof
+---
+<p> </p>
+
+<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3>
+
+<p>Operator <code>typeof</code> używa się na jeden z poniższych sposobów:</p>
+
+<ol>
+ <li><code>typeof <em>operand</em> </code></li>
+ <li><code>typeof (<em>operand</em> )</code></li>
+</ol>
+
+<p>Operator <code>typeof</code> zwraca łańcuch zawierający <span class="comment">type of unevaluated operand: jak przetłumaczyć unevaluated?</span>typ operandu. <code>operand</code> jest łańcuchem znaków, zmienną, słowem kluczowym lub obiektem, którego typ ma zostać zwrócony. Zastosowanie nawiasów jest opcjonalne.</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header" colspan="2">Operator</td>
+  </tr>
+  <tr>
+   <td>Zaimplementowany w:</td>
+   <td>JavaScript 1.1</td>
+  </tr>
+  <tr>
+   <td>Wersja ECMA:</td>
+   <td>ECMA-262</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Zakładamy, że możemy zdefiniować następujące zmienne:</p>
+
+<pre>var myFun = new Function("5+2")
+var shape="round"
+var size=1
+var today=new Date()
+</pre>
+
+<p>Operator <code>typeof</code> zwróci następujący rezultat dla tych zmiennych:</p>
+
+<pre>typeof myFun is object
+typeof shape is string
+typeof size is number
+typeof today is object
+typeof dontExist is undefined
+</pre>
+
+<p>Dla słów kluczowych <code>true</code> oraz <code>null</code>, operator <code>typeof</code> zwraca następujący rezultat:</p>
+
+<pre>typeof true is boolean
+typeof null is object
+</pre>
+
+<p>Dla liczby lub łańcucha znaków, operator <code>typeof</code> zwraca następujący rezultat:</p>
+
+<pre>typeof 62 is number
+typeof 'Hello world' is string
+</pre>
+
+<p>Dla własności wartości, operator <code>typeof</code> zwraca typ wartości własności, jakie składają się na treść:</p>
+
+<pre>typeof document.lastModified is string
+typeof window.length is number
+typeof Math.LN2 is number
+</pre>
+
+<p>Dla metod i funkcji, operator <code>typeof</code> zwraca następujący rezultat:</p>
+
+<pre>typeof blur is function
+typeof eval is function
+typeof parseInt is function
+typeof shape.split is function
+</pre>
+
+<p>Dla obiektów predefiniowanych, operator <code>typeof</code> zwraca następujący rezultat:</p>
+
+<pre>typeof Date is function
+typeof Function is function
+typeof Math is function
+typeof Option is function
+typeof String is function
+</pre>
diff --git a/files/pl/web/javascript/reference/operators/void/index.html b/files/pl/web/javascript/reference/operators/void/index.html
new file mode 100644
index 0000000000..7170f6a91e
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/void/index.html
@@ -0,0 +1,52 @@
+---
+title: Operator void
+slug: Web/JavaScript/Reference/Operators/void
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Operators/void
+original_slug: Web/JavaScript/Referencje/Operatory/Operator_void
+---
+<p> </p>
+
+<h3 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h3>
+
+<p>Operator <code>void</code> może być używany na jeden z dwóch sposobów:</p>
+
+<ol>
+ <li><code>void (<em>wyrażenie</em> )</code></li>
+ <li><code>void <em>wyrażenie</em> </code></li>
+</ol>
+
+<p>Operator <code>void</code> określa wyrażenie, które ma zostać ocenione bez zwracania wartości. <code>wyrażenie</code> jest wyrażeniem JavaScript, które ma zostać ocenione. Nawiasy dookoła wyrażenia są opcjonalne, ale używanie ich jest w dobrym stylu.</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header" colspan="2">Operator</td>
+  </tr>
+  <tr>
+   <td>Zaimplementowany w:</td>
+   <td>JavaScript 1.1</td>
+  </tr>
+  <tr>
+   <td>Wersja ECMA:</td>
+   <td>ECMA-262</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Możesz użyć operatora <code>void</code>, aby określić wyrażenie jako hipertekstowy odnośnik. Wyrażenie jest oceniane, ale nie jest ładowane w miejsce aktualnego dokumentu.</p>
+
+<p>Poniższy kod tworzy hipertekstowy odnośnik, który nie wykonuje nic po kliknięciu go przez użytkownika. Gdy użytkownik kliknie odnośnik, void(0) zostanie oceniony jako 0, jednak nie ma to żadnego efektu w JavaScripcie.</p>
+
+<pre>&lt;a href="javascript:void(0)"&gt;Kliknij tutaj, żeby nic się nie stało&lt;/a&gt;
+</pre>
+
+<p>Poniższy kod tworzy hipertekstowy odnośnik, który wysyła formularz, gdy zostanie kliknięty przez użytkownika.</p>
+
+<pre>&lt;a href="javascript:void(document.form.submit())"&gt;
+Kliknij tutaj, aby wysłać.&lt;/a&gt;
+</pre>
diff --git a/files/pl/web/javascript/reference/operators/yield/index.html b/files/pl/web/javascript/reference/operators/yield/index.html
new file mode 100644
index 0000000000..05d2999160
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/yield/index.html
@@ -0,0 +1,169 @@
+---
+title: yield
+slug: Web/JavaScript/Reference/Operators/yield
+translation_of: Web/JavaScript/Reference/Operators/yield
+original_slug: Web/JavaScript/Referencje/Operatory/yield
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Słowo kluczowe <code>yield</code> jest używane do zatrzymania i powrotu funkcji generatora ({{jsxref("Statements/function*", "function*")}} lub <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Legacy_generator_function">legacy generator function</a>).</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">[<em>rv</em>] = <strong>yield</strong> [<em>expression</em>];</pre>
+
+<dl>
+ <dt><code>expression</code></dt>
+ <dd>Definiuje wartość która ma być zwrócona przez funkcję generatora przez <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol">the iterator protocol</a>, jeżeli pominięte, zostanie zwrócone <code>undefined</code>.</dd>
+ <dt><code>rv</code></dt>
+ <dd>
+ <p>Zwraca opcjonalną wartość przekazaną do metody next() generatora, do powrotu do jej wykonania.</p>
+ </dd>
+</dl>
+
+<h2 id="Description">Description</h2>
+
+<p>The <code>yield</code> keyword causes generator function execution to pause and the value of the expression following the <code>yield</code> keyword is returned to the generator's caller. It can be thought of as a generator-based version of the <code>return</code> keyword.</p>
+
+<p>The <code>yield</code> keyword actually returns an <code>IteratorResult</code> object with two properties, <code>value</code> and <code>done</code>. The <code>value</code> property is the result of evaluating the <code>yield</code> expression, and <code>done</code> is <code>false</code>, indicating that the generator function has not fully completed.</p>
+
+<p>Once paused on a <code>yield</code> expression, the generator's code execution remains paused until the generator's <code>next()</code> method is called. Each time the generator's <code>next()</code> method is called, the generator resumes execution and runs until it reaches one of the following:</p>
+
+<ul>
+ <li> A <code>yield</code>, which causes the generator to once again pause and return the generator's new value. The next time <code>next()</code> is called, execution resumes with the statement immediately after the <code>yield</code>.</li>
+ <li>{{jsxref("Statements/throw", "throw")}} is used to throw an exception from the generator. This halts execution of the generator entirely, and execution resumes in the caller as is normally the case when an exception is thrown.</li>
+ <li>The end of the generator function is reached; in this case, execution of the generator ends and an <code>IteratorResult</code> is returned to the caller in which the <code>value</code> is {{jsxref("undefined")}} and <code>done</code> is <code>true</code>.</li>
+ <li>A {{jsxref("Statements/return", "return")}} statement is reached. In this case, execution of the generator ends and an <code>IteratorResult</code> is returned to the caller in which the <code>value</code> is the value specified by the <code>return</code> statement and <code>done</code> is <code>true</code>.</li>
+</ul>
+
+<p>If an optional value is passed to the generator's <code>next()</code> method, that value becomes the value returned by the generator's current <code>yield</code> operation.</p>
+
+<p>Between the generator's code path, its <code>yield</code> operators, and the ability to specify a new starting value by passing it to {{jsxref("Generator.prototype.next()")}}, generators offer enormous power and control.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<p>The following code is the declaration of an example generator function.</p>
+
+<pre class="brush: js">function* foo() {
+  var index = 0;
+  while (index &lt;= 2)
+    yield index++;
+}</pre>
+
+<p>Once a generator function is defined, it can be used by constructing an iterator as shown.</p>
+
+<pre class="brush: js">var iterator = foo();
+console.log(iterator.next()); // { value: 0, done: false }
+console.log(iterator.next()); // { value: 1, done: false }
+console.log(iterator.next()); // { value: 2, done: false }
+console.log(iterator.next()); // { value: undefined, done: true }</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#', 'Yield')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#', 'Yield')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>39</td>
+   <td>{{CompatGeckoDesktop("26.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+  <tr>
+   <td><code>IteratorResult</code> object instead of throwing</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("29.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("26.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{ CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+  <tr>
+   <td><code>IteratorResult</code> object instead of throwing</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("29.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Firefox-specific_notes">Firefox-specific notes</h2>
+
+<ul>
+ <li>Starting with Gecko 29 {{geckoRelease(29)}}, the completed generator function no longer throws a {{jsxref("TypeError")}} "generator has already finished". Instead, it returns an <code>IteratorResult</code> object like <code>{ value: undefined, done: true }</code> ({{bug(958951)}}).</li>
+ <li>Starting with Gecko 33 {{geckoRelease(33)}}, the parsing of the <code>yield</code> expression has been updated to conform with the ES2015 specification ({{bug(981599)}}):
+  <ul>
+   <li>The expression after the <code>yield</code> keyword is optional and omitting it no longer throws a {{jsxref("SyntaxError")}}: <code>function* foo() { yield; }</code></li>
+  </ul>
+ </li>
+</ul>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li>
+ <li>{{jsxref("Statements/function*", "function*")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("Operators/yield*", "yield*")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/operators/yield_star_/index.html b/files/pl/web/javascript/reference/operators/yield_star_/index.html
new file mode 100644
index 0000000000..e27a1c3aca
--- /dev/null
+++ b/files/pl/web/javascript/reference/operators/yield_star_/index.html
@@ -0,0 +1,201 @@
+---
+title: yield*
+slug: Web/JavaScript/Reference/Operators/yield*
+translation_of: Web/JavaScript/Reference/Operators/yield*
+original_slug: Web/JavaScript/Referencje/Operatory/yield*
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p><strong><code>Wyrażenie yield*</code> </strong> służy do wydelegowania działania generatora do innego {{jsxref("Statements/function*", "generatora")}} lub obiektu iterowalnego.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-yieldasterisk.html")}}</div>
+
+<p class="hidden">Źródło poniższego interaktywnego przykładu przechowywane jest w repozytorium na GitHub. Jeśli chcesz współtworzyć projekt interaktywnych przykładów, sklonuj <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> i wyślij nam pull request.</p>
+
+<h2 id="Składnia">Składnia</h2>
+
+<pre class="syntaxbox"> yield* [[expression]];</pre>
+
+<dl>
+ <dt><code>expression</code></dt>
+ <dd>Wyrażenie, które zwraca iterowalny obiekt lub generator.</dd>
+</dl>
+
+<h2 id="Opis">Opis</h2>
+
+<p><code>yield*</code> iteruje po iterowalnym obiekcie i wywołuje <code>yield</code> z każdą kolejną zwracaną przez niego wartością.</p>
+
+<p>Wartość samego <code>yield*</code> jest wartością zwróconą przez iterator w momencie jego zakończenia (tzn. kiedy <code>done</code> ma wartość <code>true</code>).</p>
+
+<h2 id="Przykłady">Przykłady</h2>
+
+<h3 id="Delegowanie_logiki_do_osobnego_generatora">Delegowanie logiki do osobnego generatora</h3>
+
+<p>W poniższym kodzie wartości <code>yeld</code> dla  <code>g1()</code> zwracane są przy wywołaniu <code>next()</code> dokładnie tak samo jak te, które zwraca <code>yeld</code> generatora <code>g2()</code>.</p>
+
+<pre class="brush: js">function* g1() {
+  yield 2;
+  yield 3;
+  yield 4;
+}
+
+function* g2() {
+  yield 1;
+  yield* g1();
+  yield 5;
+}
+
+var iterator = g2();
+
+console.log(iterator.next()); // {value: 1, done: false}
+console.log(iterator.next()); // {value: 2, done: false}
+console.log(iterator.next()); // {value: 3, done: false}
+console.log(iterator.next()); // {value: 4, done: false}
+console.log(iterator.next()); // {value: 5, done: false}
+console.log(iterator.next()); // {value: undefined, done: true}
+</pre>
+
+<h3 id="Inne_obiekty_iterowalne">Inne obiekty iterowalne</h3>
+
+<p><code>yield*</code> może wywoływać <code>yield</code> z wartościami dostarczanymi przez inne rodzje obiektów iterowalnych , np. tablice, stringi lub obiekt <code>arguments</code>.</p>
+
+<pre class="brush: js">function* g3() {
+  yield* [1, 2];
+  yield* '34';
+  yield* Array.from(arguments);
+}
+
+var iterator = g3(5, 6);
+
+console.log(iterator.next()); // {value: 1, done: false}
+console.log(iterator.next()); // {value: 2, done: false}
+console.log(iterator.next()); // {value: "3", done: false}
+console.log(iterator.next()); // {value: "4", done: false}
+console.log(iterator.next()); // {value: 5, done: false}
+console.log(iterator.next()); // {value: 6, done: false}
+console.log(iterator.next()); // {value: undefined, done: true}
+</pre>
+
+<h3 id="Wartość_samego_wyrażenia_yield*">Wartość samego wyrażenia <code>yield*</code></h3>
+
+<p><code>yield*</code> jest wyrażeniem (expression) a nie statement, więc rozwiązuje się do konkretnej wartości.</p>
+
+<pre class="brush: js">function* g4() {
+  yield* [1, 2, 3];
+  return 'foo';
+}
+
+var result;
+
+function* g5() {
+  result = yield* g4();
+}
+
+var iterator = g5();
+
+console.log(iterator.next()); // {value: 1, done: false}
+console.log(iterator.next()); // {value: 2, done: false}
+console.log(iterator.next()); // {value: 3, done: false}
+console.log(iterator.next()); // {value: undefined, done: true},
+                              // g4() zwrócił w tym momencie {value: 'foo', done: true}
+
+console.log(result);          // "foo"
+</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#', 'Yield')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#', 'Yield')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("27.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("27.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Firefox-specific_notes">Firefox-specific notes</h2>
+
+<ul>
+ <li>Starting with Gecko 33 {{geckoRelease(33)}}, the parsing of the yield expression has been updated to conform with the ES2015 specification ({{bug(981599)}}):
+  <ul>
+   <li>The line terminator restriction is now implemented. No line terminator between "yield" and "*" is allowed. Code like the following will throw a {{jsxref("SyntaxError")}}:
+    <pre class="brush: js">function* foo() {
+  yield
+  *[];
+}</pre>
+   </li>
+  </ul>
+ </li>
+</ul>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li>
+ <li>{{jsxref("Statements/function*", "function*")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("Operators/yield", "yield")}}</li>
+</ul>
diff --git a/files/pl/web/javascript/reference/statements/async_function/index.html b/files/pl/web/javascript/reference/statements/async_function/index.html
new file mode 100644
index 0000000000..75666ca091
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/async_function/index.html
@@ -0,0 +1,265 @@
+---
+title: funkcja async
+slug: Web/JavaScript/Reference/Statements/async_function
+translation_of: Web/JavaScript/Reference/Statements/async_function
+original_slug: Web/JavaScript/Referencje/Polecenia/funkcja_async
+---
+<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 =&gt; {
+    setTimeout(function() {
+      resolve("slow");
+      console.log("wolna obietnica została wykonana");
+    }, 2000);
+  });
+};
+
+var resolveAfter1Second = function() {
+  console.log("starting fast promise");
+  return new Promise(resolve =&gt; {
+    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) =&gt; {
+    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()=&gt;console.log(await resolveAfter2Seconds()))(),
+      (async()=&gt;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)=&gt;console.log(message));
+  resolveAfter1Second().then((message)=&gt;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 =&gt; {
+      return downloadFallbackData(url); // returns a promise
+    })
+    .then(v =&gt; {
+      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..fa96c171fe
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/block/index.html
@@ -0,0 +1,161 @@
+---
+title: block
+slug: Web/JavaScript/Reference/Statements/block
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/block
+original_slug: Web/JavaScript/Referencje/Polecenia/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..3d78bf4f1a
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/break/index.html
@@ -0,0 +1,68 @@
+---
+title: break
+slug: Web/JavaScript/Reference/Statements/break
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/break
+original_slug: Web/JavaScript/Referencje/Polecenia/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 &lt; 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..a073ac3959
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/class/index.html
@@ -0,0 +1,114 @@
+---
+title: class
+slug: Web/JavaScript/Reference/Statements/class
+translation_of: Web/JavaScript/Reference/Statements/class
+original_slug: Web/JavaScript/Referencje/Polecenia/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..ee672c1eee
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/const/index.html
@@ -0,0 +1,54 @@
+---
+title: const
+slug: Web/JavaScript/Reference/Statements/const
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/const
+original_slug: Web/JavaScript/Referencje/Polecenia/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..3087e1b374
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/continue/index.html
@@ -0,0 +1,167 @@
+---
+title: continue
+slug: Web/JavaScript/Reference/Statements/continue
+tags:
+  - JavaScript
+  - instrukcja
+  - polecenie
+translation_of: Web/JavaScript/Reference/Statements/continue
+original_slug: Web/JavaScript/Referencje/Polecenia/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 &lt; 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 &lt; 4) {
+  console.log('i: ' + i);
+  i += 1;
+
+  checkj: while (j &gt; 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..ffc338c1f0
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/debugger/index.html
@@ -0,0 +1,127 @@
+---
+title: debugger
+slug: Web/JavaScript/Reference/Statements/debugger
+translation_of: Web/JavaScript/Reference/Statements/debugger
+original_slug: Web/JavaScript/Referencje/Polecenia/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..4ccd8b8666
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/do...while/index.html
@@ -0,0 +1,55 @@
+---
+title: do...while
+slug: Web/JavaScript/Reference/Statements/do...while
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/do...while
+original_slug: Web/JavaScript/Referencje/Polecenia/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&lt;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..f38b0612c3
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/empty/index.html
@@ -0,0 +1,93 @@
+---
+title: empty
+slug: Web/JavaScript/Reference/Statements/Empty
+tags:
+  - JavaScript
+  - funkcja języka
+  - wyrażenie
+translation_of: Web/JavaScript/Reference/Statements/Empty
+original_slug: Web/JavaScript/Referencje/Polecenia/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 &lt; 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..0b3aaa1bae
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/export/index.html
@@ -0,0 +1,48 @@
+---
+title: export
+slug: Web/JavaScript/Reference/Statements/export
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/export
+original_slug: Web/JavaScript/Referencje/Polecenia/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..6e79b44b84
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/for...in/index.html
@@ -0,0 +1,174 @@
+---
+title: for...in
+slug: Web/JavaScript/Reference/Statements/for...in
+tags:
+  - JavaScript
+  - wyrażenie
+translation_of: Web/JavaScript/Reference/Statements/for...in
+original_slug: Web/JavaScript/Referencje/Polecenia/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..b6040c8e71
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/for/index.html
@@ -0,0 +1,59 @@
+---
+title: for
+slug: Web/JavaScript/Reference/Statements/for
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/for
+original_slug: Web/JavaScript/Referencje/Polecenia/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 &lt; 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..745680d28e
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/function/index.html
@@ -0,0 +1,69 @@
+---
+title: function
+slug: Web/JavaScript/Reference/Statements/function
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/function
+original_slug: Web/JavaScript/Referencje/Polecenia/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..d8212ed492
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/function_star_/index.html
@@ -0,0 +1,310 @@
+---
+title: function*
+slug: Web/JavaScript/Reference/Statements/function*
+translation_of: Web/JavaScript/Reference/Statements/function*
+original_slug: Web/JavaScript/Referencje/Polecenia/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 &lt; 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&amp;list=PLuoyIZT5fPlG44bPq50Wgh0INxykdrYX7&amp;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..3a829581c6
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/if...else/index.html
@@ -0,0 +1,66 @@
+---
+title: if...else
+slug: Web/JavaScript/Reference/Statements/if...else
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/if...else
+original_slug: Web/JavaScript/Referencje/Polecenia/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..07388d5a96
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/import/index.html
@@ -0,0 +1,56 @@
+---
+title: import
+slug: Web/JavaScript/Reference/Statements/import
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/import
+original_slug: Web/JavaScript/Referencje/Polecenia/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..ba1f639312
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/index.html
@@ -0,0 +1,150 @@
+---
+title: Polecenia
+slug: Web/JavaScript/Reference/Statements
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements
+original_slug: Web/JavaScript/Referencje/Polecenia
+---
+<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..073a568a3c
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/label/index.html
@@ -0,0 +1,52 @@
+---
+title: etykieta
+slug: Web/JavaScript/Reference/Statements/label
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/label
+original_slug: Web/JavaScript/Referencje/Polecenia/etykieta
+---
+<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..c6676b151d
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/return/index.html
@@ -0,0 +1,49 @@
+---
+title: return
+slug: Web/JavaScript/Reference/Statements/return
+tags:
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/return
+original_slug: Web/JavaScript/Referencje/Polecenia/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..d67905077e
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/switch/index.html
@@ -0,0 +1,286 @@
+---
+title: switch
+slug: Web/JavaScript/Reference/Statements/switch
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/switch
+original_slug: Web/JavaScript/Referencje/Polecenia/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 &lt; 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..d47ab9803b
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/throw/index.html
@@ -0,0 +1,198 @@
+---
+title: throw
+slug: Web/JavaScript/Reference/Statements/throw
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Strony_wymagające_dopracowania
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/throw
+original_slug: Web/JavaScript/Referencje/Polecenia/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 &lt;= 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..e9e8633814
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/var/index.html
@@ -0,0 +1,62 @@
+---
+title: var
+slug: Web/JavaScript/Reference/Statements/var
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/var
+original_slug: Web/JavaScript/Referencje/Polecenia/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..2523fcee19
--- /dev/null
+++ b/files/pl/web/javascript/reference/statements/while/index.html
@@ -0,0 +1,62 @@
+---
+title: while
+slug: Web/JavaScript/Reference/Statements/while
+tags:
+  - Dokumentacja_JavaScript
+  - Dokumentacje
+  - JavaScript
+  - Wszystkie_kategorie
+translation_of: Web/JavaScript/Reference/Statements/while
+original_slug: Web/JavaScript/Referencje/Polecenia/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 &lt; 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 &lt; 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" } ) }}