path: root/files/pl/conflicting/web/javascript/reference/operators_8afb1abf2138289c890ee09e799ff26e/index.html

---
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>