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

Unslugging pl

1 files changed, 256 insertions, 0 deletions

diff --git a/files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html b/files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html
new file mode 100644
index 0000000000..3e1a60bdb4
--- /dev/null
+++ b/files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html
@@ -0,0 +1,256 @@
+---
+title: Operatory logiczne
+slug: >-
+  conflicting/Web/JavaScript/Reference/Operators_8afb1abf2138289c890ee09e799ff26e
+translation_of: Web/JavaScript/Reference/Operators
+translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators
+original_slug: Web/JavaScript/Referencje/Operatory/Logical_Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<div>Operatory logiczne są zazwyczaj używane z wartościami typu {{jsxref("Boolean")}} (logicznymi) – wówczas zwracają również wartość typu logicznego. Jednakże operatory <code>&amp;&amp;</code> i <code>||</code> w istocie zwracają wartość jednego z podanych operandów, więc jeśli operatory te są używane z wartościami nie-boolowskimi, wtedy mogą również zwracać nie-boolowskie wartości.</div>
+
+<div></div>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}</div>
+
+
+
+<h2 id="Opis">Opis</h2>
+
+<p>Operatory logiczne są opisane w poniższej tabeli:</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <th>Operator</th>
+   <th>Użycie</th>
+   <th>Opis</th>
+  </tr>
+  <tr>
+   <td>Logiczne AND (<code>&amp;&amp;</code>)</td>
+   <td><code><em>expr1</em> &amp;&amp; <em>expr2</em></code></td>
+   <td>Zwraca <code>expr1</code> jeśli wartość ta może być przekonwertowana na <code>false</code>, w przeciwnym razie zwraca <code>expr2</code>. Zatem, używany z wartościami typu logicznego, operator <code>&amp;&amp;</code> zwraca <code>true</code> jeśli obydwa operandy mają wartość <code>true</code>, w przeciwnym razie zwraca <code>false</code>.</td>
+  </tr>
+  <tr>
+   <td>Logiczne OR (<code>||</code>)</td>
+   <td><code><em>expr1</em> || <em>expr2</em></code></td>
+   <td>Zwraca <code>expr1</code>, jeśli wartość ta może być przekonwertowana na <code>true</code>; w przeciwnym razie zwraca <code>expr2</code>. Tak więc, używany z wartościami typu logicznego, operator <code>||</code> zwraca <code>true</code> którykolwiek z operandów równy jest <code>true</code>.</td>
+  </tr>
+  <tr>
+   <td>Logiczne NOT (<code>!</code>)</td>
+   <td><code>!<em>expr</em></code></td>
+   <td>Zwraca <code>false</code> jeśli jego operand można przekonwertować na <code>true</code>; w przeciwnym razie zwraca <code>true</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Jeśli dana wartość może być przekonwertowana na <code>true</code>, wówczas jest to tzw. wartość {{Glossary("truthy")}}. Jeśli dana wartość może być przekonwertowana na <code>false</code>, jest to tzw. wartość {{Glossary("falsy")}}.</p>
+
+<p>Przykładami wyrażeń, które mogą być przekonwertowane na <a href="/en-US/docs/Glossary/Falsy">false</a> są:</p>
+
+<ul>
+ <li><code>null</code>;</li>
+ <li><code>NaN;</code></li>
+ <li><code>0</code>;</li>
+ <li>pusty łańcuch znaków (string) – <code>""</code> lub <code>''</code>; </li>
+ <li><code>undefined</code>.</li>
+</ul>
+
+<p>Mimo tego, że operatory <code>&amp;&amp;</code> i <code>||</code> mogą być używane z wartościami nie-boolowskimi, nadal mogą być uznane za operatory boolowskie (logiczne), gdyż zwracane przez nie wartości mogą być zawsze przekonwertowane na wartości logiczne.</p>
+
+<h3 id="Ewaluacja_short-circuit">Ewaluacja <em>short-circuit</em></h3>
+
+<p>Ponieważ wyrażenia logiczne są przetwarzane od lewej do prawej, sprawdzana jest najkrótsza możliwa ścieżka, pozwalająca na zwrócenie wyniku całego wyrażenia (tzw. <em>short-circuit evaluation</em>), zgodnie z następującymi zasadami:</p>
+
+<ul>
+ <li><code>false &amp;&amp; (<em>cokolwiek)</em></code> zostanie przetworzone na false.</li>
+ <li><code>true || (<em>cokolwiek)</em></code> zostanie przetworzone na true.</li>
+</ul>
+
+<p>Zasady logiki gwarantują, że powyższe ewaluacje są zawsze poprawne. Zauważ, że części wyrażeń oznaczone słowem <code>cokolwiek</code> nie są ewaluowane, więc nie pojawią się żadne efekty uboczne. Zauważ też, że część <code>cokolwiek</code> powyższych wyrażeń może być dowolnym pojedynczym wyrażeniem logicznym (co wskazano przez nawiasy).</p>
+
+<p>Dla przykładu, poniższe dwie funkcje są równoważne.</p>
+
+<pre class="brush: js">function shortCircuitEvaluation() {
+  // logiczne OR (||)
+  doSomething() || doSomethingElse();
+
+  // logiczne AND (&amp;&amp;)
+  doSomething() &amp;&amp; doSomethingElse();
+}
+
+function equivalentEvaluation() {
+
+  // logiczne OR (||)
+  var orFlag = doSomething();
+  if (!orFlag) {
+    doSomethingElse();
+  }
+
+
+  // logiczne AND (&amp;&amp;)
+  var andFlag = doSomething();
+  if (andFlag) {
+    doSomethingElse();
+  }
+}
+</pre>
+
+<p>Poniższe wyrażenia nie są jednak równoważne ze względu na <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Pierwsze%C5%84stwo_operator%C3%B3w">pierwszeństwo operatorów</a>, co podkreśla, jak ważne jest, by operator po prawej stronie był pojedynczym wyrażeniem (zgrupowanym w razie potrzeby przy pomocy nawiasów).</p>
+
+<pre class="brush: js">false &amp;&amp; true  || true      // zwraca true
+false &amp;&amp; (true || true)     // zwraca false</pre>
+
+<h3 id="Logiczne_AND"><a id="Logiczne AND" name="Logiczne AND">Logiczne AND (<code>&amp;&amp;</code>)</a></h3>
+
+<p>Poniżej pokazane są przykłady użycia operatora <code>&amp;&amp;</code> (logicznego AND).</p>
+
+<pre class="brush: js">a1 = true  &amp;&amp; true       // t &amp;&amp; t zwraca true
+a2 = true  &amp;&amp; false      // t &amp;&amp; f zwraca false
+a3 = false &amp;&amp; true       // f &amp;&amp; t zwraca false
+a4 = false &amp;&amp; (3 == 4)   // f &amp;&amp; f zwraca false
+a5 = 'Cat' &amp;&amp; 'Dog'      // t &amp;&amp; t zwraca "Dog"
+a6 = false &amp;&amp; 'Cat'      // f &amp;&amp; t zwraca false
+a7 = 'Cat' &amp;&amp; false      // t &amp;&amp; f zwraca false
+a8 = ''    &amp;&amp; false      // f &amp;&amp; f zwraca ""
+a9 = false &amp;&amp; ''         // f &amp;&amp; f zwraca false
+</pre>
+
+<h3 id="Logiczne_OR"><a id="Logiczne OR" name="Logiczne OR">Logiczne OR (<code>||</code>)</a></h3>
+
+<p>Poniżej pokazane są przykłady użycia operatora <code>||</code> (logicznego OR).</p>
+
+<pre class="brush: js">o1 = true  || true       // t || t zwraca true
+o2 = false || true       // f || t zwraca true
+o3 = true  || false      // t || f zwraca true
+o4 = false || (3 == 4)   // f || f zwraca false
+o5 = 'Cat' || 'Dog'      // t || t zwraca "Cat"
+o6 = false || 'Cat'      // f || t zwraca "Cat"
+o7 = 'Cat' || false      // t || f zwraca "Cat"
+o8 = ''    || false      // f || f zwraca false
+o9 = false || ''         // f || f zwraca ""
+</pre>
+
+<h3 id="Logiczne_NOT_!"><a id="Logiczne NOT" name="Logiczne NOT">Logiczne NOT (<code>!</code>)</a></h3>
+
+<p>Poniżej pokazane są przykłady użycia operatora <code>!</code> (logicznego NOT).</p>
+
+<pre class="brush: js">n1 = !true               // !t zwraca false
+n2 = !false              // !f zwraca true
+n3 = !'Cat'              // !t zwraca false
+</pre>
+
+<h4 id="Podwójne_NOT_!!">Podwójne NOT (<code>!!</code>)</h4>
+
+<p>Jest możliwe użycie kilku operatorów NOT naraz, by wprost wymusić konwersję dowolnej wartości do odpowiedniej wartości <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type">boolowskiej</a>. Konwersja bazuje na „prawdziwości” lub „fałszywości” wartości (zobacz {{Glossary("truthy")}} i {{Glossary("falsy")}}).</p>
+
+<p>Taka sama konwersja może być dokonana poprzez funkcję {{jsxref("Boolean")}}.</p>
+
+<pre class="brush: js line-numbers language-js"><code class="language-js">n1 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="boolean token">true</span>                   <span class="comment token">// !!prawda zwraca true</span>
+n2 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="punctuation token">{</span><span class="punctuation token">}</span>                     <span class="comment token">// !!prawda returns true: każdy obiekt jest "prawdą"...</span>
+n3 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="punctuation token">(</span><span class="keyword token">new</span> <span class="class-name token">Boolean</span><span class="punctuation token">(</span><span class="boolean token">false</span><span class="punctuation token">)</span><span class="punctuation token">)</span>   <span class="comment token">// ...nawet obiekty booloweskie z false jako wartością .valueOf()!</span>
+n4 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="boolean token">false</span>                  <span class="comment token">// !!fałsz zwraca false</span>
+n5 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="string token">""</span>                     <span class="comment token">// !!fałsz zwraca false</span>
+n6 <span class="operator token">=</span> <span class="operator token">!</span><span class="operator token">!</span><span class="function token">Boolean</span><span class="punctuation token">(</span><span class="boolean token">false</span><span class="punctuation token">)</span>         <span class="comment token">// !!fałsz zwraca false</span></code></pre>
+
+<h3 id="Zasady_przekształcania_wyrażeń">Zasady przekształcania wyrażeń</h3>
+
+<h4 id="Przekształcanie_AND_na_OR">Przekształcanie AND na OR</h4>
+
+<p>Poniższa operacja na wartościach logicznych:</p>
+
+<pre class="brush: js">bCondition1 &amp;&amp; bCondition2</pre>
+
+<p>jest zawsze równa:</p>
+
+<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre>
+
+<h4 id="Przekształcanie_OR_na_AND">Przekształcanie OR na AND</h4>
+
+<p>Poniższa operacja na wartościach logicznych:</p>
+
+<pre class="brush: js">bCondition1 || bCondition2</pre>
+
+<p>jest zawsze równa:</p>
+
+<pre class="brush: js">!(!bCondition1 &amp;&amp; !bCondition2)</pre>
+
+<h4 id="Przekształcanie_NOT">Przekształcanie NOT</h4>
+
+<p>Poniższa operacja na wartościach logicznych:</p>
+
+<pre class="brush: js">!!bCondition</pre>
+
+<p>jest zawsze równa:</p>
+
+<pre class="brush: js">bCondition</pre>
+
+<h3 id="Usuwanie_zagnieżdżonych_wyrażeń_z_nawiasami">Usuwanie zagnieżdżonych wyrażeń z nawiasami</h3>
+
+<p>Jako że wyrażenia logiczne są ewaluowane od lewej do prawej, jest zawsze możliwe usunięcie nawiasów ze złożonego wyrażenia przy użyciu pewnych, przedstawionych dalej, reguł.</p>
+
+<h4 id="Usuwanie_zagnieżdżonego_AND">Usuwanie zagnieżdżonego AND</h4>
+
+<p>Następujące wyrażenie złożone na wartościach logicznych:</p>
+
+<pre class="brush: js">bCondition1 || (bCondition2 &amp;&amp; bCondition3)</pre>
+
+<p>jest zawsze równe:</p>
+
+<pre class="brush: js">bCondition1 || bCondition2 &amp;&amp; bCondition3</pre>
+
+<h4 id="Usuwanie_zagnieżdżonego_OR">Usuwanie zagnieżdżonego OR</h4>
+
+<p>Następujące wyrażenie złożone na wartościach logicznych:</p>
+
+<pre class="brush: js">bCondition1 &amp;&amp; (bCondition2 || bCondition3)</pre>
+
+<p>jest zawsze równe:</p>
+
+<pre class="brush: js">!(!bCondition1 || !bCondition2 &amp;&amp; !bCondition3)</pre>
+
+<h2 id="Specyfikacje">Specyfikacje</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specyfikacja</th>
+   <th scope="col">Status</th>
+   <th scope="col">Uwagi</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definicja początkowa.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.11')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Zdefiniowane w kilku sekcjach specyfikacji: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.9">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.11">Binary Logical Operators</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-binary-logical-operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Zdefiniowane w kilku sekcjach specyfikacji: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-logical-operators">Binary Logical Operators</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-binary-logical-operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Zdefiniowane w kilku sekcjach specyfikacji: <a href="http://tc39.github.io/ecma262/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-logical-operators">Binary Logical Operators</a></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2>
+
+
+
+<p>{{Compat("javascript.operators.logical")}}</p>
+
+<h2 id="Zobacz_też">Zobacz też</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Bitwise operators</a></li>
+ <li><a href="https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Boolean">Boolean</a></li>
+</ul>