path: root/files/pt-br/conflicting/web/javascript/reference/operators_8fa8b34b0547a749514637a15d386886/index.html

---
title: Operadores Lógicos
slug: >-
  conflicting/Web/JavaScript/Reference/Operators_8fa8b34b0547a749514637a15d386886
tags:
  - Operador
  - Operadores lógicos
  - Referencia
  - e
  - não
  - ou
translation_of: Web/JavaScript/Reference/Operators
translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators
original_slug: Web/JavaScript/Reference/Operators/Operadores_Logicos
---
<div>{{jsSidebar("Operators")}}</div>

<h2 id="Summary" name="Summary">Resumo</h2>

<p>Operadores lógicos são tipicamente usados com valores <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Booleanos</a></code> (lógicos). Quando eles o são, retornam um valor booleano. Porém, os operadores <code>&amp;&amp;</code> e <code>||</code> de fato retornam o valor de um dos operandos especificos, então se esses operadores são usados com valores não booleanos, eles podem retornar um valor não booleano.</p>

<h2 id="Descrição">Descrição</h2>

<p>Os operadores lógicos são descritos na tabela abaixo:</p>

<table class="fullwidth-table">
 <tbody>
  <tr>
   <th>Operador</th>
   <th>Utilização</th>
   <th>Descrição</th>
  </tr>
  <tr>
   <td>Logical AND (<code>&amp;&amp;</code>)</td>
   <td><code><em>expr1</em> &amp;&amp; <em>expr2</em></code></td>
   <td>Retorna <code>expr1</code> se essa pode ser convertido para <code>falso</code>; senão, retorna <code>expr2</code>. Dessa forma, quando usado para valores Booleanos, <code>&amp;&amp;</code> retorna <code>verdadeiro</code> se ambos os operandos forem <code>verdadeiro</code> ; senão, retorna <code>falso</code>.</td>
  </tr>
  <tr>
   <td>Logical OR (<code>||</code>)</td>
   <td><code><em>expr1</em> || <em>expr2</em></code></td>
   <td>Retorna <code>expr1</code> se essa pode ser convertido para <code>verdadeiro</code>; senão, retorna <code>expr2</code>. Dessa forma, quando usado para valores Booleanos, <code>||</code> retorna <code>verdadeiro</code> se qualquer dos operandos for <code>verdadeiro</code>; se ambos são <code>falso</code>, retorna <code>falso</code>.</td>
  </tr>
  <tr>
   <td>Logical NOT (<code>!</code>)</td>
   <td><code>!<em>expr</em></code></td>
   <td>
    <p>Retorna <code>falso</code>se o seu operando pode ser convertido para verdadeiro; senão, retorna <code>verdadeiro</code>.</p>
   </td>
  </tr>
 </tbody>
</table>

<p>Se um valor pode ser convertido para <code>verdadeiro</code>, este valor é chamado de {{Glossary("truthy")}}. Se um valor pode ser convertido para <code>falso</code>, este valor é chamado de {{Glossary("falsy")}}.</p>

<p>Exemplos de expressões que podem ser convertidas para falso são:</p>

<ul>
 <li><code>null</code>;</li>
 <li><code>NaN;</code></li>
 <li><code>0</code>;</li>
 <li>string vazia (<code>""</code>); </li>
 <li><code>undefined</code>.</li>
</ul>

<p>Mesmo que os operadores <code>&amp;&amp;</code> and <code>||</code> possam ser utilizados com operandos que não são valores Booleanos, eles ainda podem ser considerados como operadores booleanos visto que seus valores de saída sempre podem ser convertidos em valores booleanos.</p>

<h3 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Avaliação de Curto-Circuito (Short-Circuit) </h3>

<p>Como as expressões lógicas são avaliadas da esquerda pra direita, elas são testadas para possível avaliação de "curto-circuito" ("short-circuit") utilizando as seguintes regras:</p>

<ul>
 <li><code>falso &amp;&amp; (<em>qualquer coisa)</em></code><em>  </em>é avaliado como falso através de curto-circuito.</li>
 <li><code>true || (<em>qualquer coisa)</em></code><em> </em>é avaliado como verdadeiro através de curto-circuito.</li>
</ul>

<p>As regras de lógica garantem que essas avaliações estejam sempre corretas. Repare que a porção <em>qualquer coisa</em> das expressões acima não é avaliada, logo qualquer problema oriundo de tê-lo feito não é consumado. Note também  que a parte<em> qualquer coisa</em> das expressões acima pode ser qualquer expressão lógica unitária (conforme é indicado pelos <span style="line-height: 1.5;">parênteses</span>).</p>

<p>Por exemplo, as duas funções a seguir são equivalentes.</p>

<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">shortCircuitEvaluation</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
  <span class="comment token">// logical OR (||)</span>
  <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">||</span> <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>

  <span class="comment token">// logical AND (&amp;&amp;)</span>
  <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">&amp;&amp;</span> <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><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">equivalentEvaluation</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>

  <span class="comment token">// logical OR (||)</span>
  <span class="keyword token">var</span> orFlag <span class="operator token">=</span> <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
  <span class="keyword token">if</span> <span class="punctuation token">(</span><span class="operator token">!</span>orFlag<span class="punctuation token">)</span> <span class="punctuation token">{</span>
    <span class="function token">doSomethingElse</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">// logical AND (&amp;&amp;)</span>
  <span class="keyword token">var</span> andFlag <span class="operator token">=</span> <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
  <span class="keyword token">if</span> <span class="punctuation token">(</span>andFlag<span class="punctuation token">)</span> <span class="punctuation token">{</span>
    <span class="function token">doSomethingElse</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></code></pre>

<p>Contudo, as expressões a seguir não são equivalentes, devido <span style="line-height: 1.5;">a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">precedência do operador</a>, e reforçam a importância de que o operador do lado direito (right hand) seja uma única expressão (agrupada com o uso de parênteses, caso seja necessário)</span><span style="line-height: 1.5;">.</span></p>

<pre class="brush: js"> false &amp;&amp; true || true       // retorna true
 false &amp;&amp; (true || true)     // retorna falso</pre>

<h3 id="Logical_AND_.28.29" name="Logical_AND_.28&amp;&amp;.29"><a name="Logical_AND">AND Lógico (<code>&amp;&amp;</code>)</a></h3>

<p>O código a seguir demonstra exemplos do operador <code>&amp;&amp;</code> (AND lógico). </p>

<pre class="brush: js">a1 = true  &amp;&amp; true       // t &amp;&amp; t retorna true
a2 = true  &amp;&amp; false      // t &amp;&amp; f retorna false
a3 = false &amp;&amp; true       // f &amp;&amp; t retorna false
a4 = false &amp;&amp; (3 == 4)   // f &amp;&amp; f retorna false
a5 = 'Cat' &amp;&amp; 'Dog'      // t &amp;&amp; t retorna "Dog"
a6 = false &amp;&amp; 'Cat'      // f &amp;&amp; t retorna false
a7 = 'Cat' &amp;&amp; false      // t &amp;&amp; f retorna false
a8 = ''    &amp;&amp; false      // f &amp;&amp; f retorna ""
a9 = false &amp;&amp; ''         // f &amp;&amp; t retorna false
</pre>

<h3 id="OR_Lógico_()"><a name="Logical_OR">OR Lógico (<code>||</code>)</a></h3>

<p>O código a seguir demonstra exemplos do operador <code>||</code> (OR lógico).</p>

<pre class="brush: js line-numbers  language-js"><code class="language-js">o1 <span class="operator token">=</span> <span class="keyword token">true</span>  <span class="operator token">||</span> <span class="keyword token">true</span>       <span class="comment token">// t || t retorna true</span>
o2 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="keyword token">true</span>       <span class="comment token">// f || t retorna true</span>
o3 <span class="operator token">=</span> <span class="keyword token">true</span>  <span class="operator token">||</span> <span class="keyword token">false</span>      <span class="comment token">// t || f retorna true</span>
o4 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="punctuation token">(</span><span class="number token">3</span> <span class="operator token">==</span> <span class="number token">4</span><span class="punctuation token">)</span>   <span class="comment token">// f || f retorna false</span>
o5 <span class="operator token">=</span> <span class="string token">'Cat'</span> <span class="operator token">||</span> <span class="string token">'Dog'</span>      <span class="comment token">// t || t retorna "Cat"</span>
o6 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="string token">'Cat'</span>      <span class="comment token">// f || t retorna "Cat"</span>
o7 <span class="operator token">=</span> <span class="string token">'Cat'</span> <span class="operator token">||</span> <span class="keyword token">false</span>      <span class="comment token">// t || f retorna "Cat"</span>
o8 <span class="operator token">=</span> <span class="string token">''</span>    <span class="operator token">||</span> <span class="keyword token">false</span>      <span class="comment token">// f || f retorna false</span>
o9 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="string token">''</span>         <span class="comment token">// f || f retorna ""</span></code></pre>

<h3 id="Logical_NOT_.28.21.29" name="Logical_NOT_.28.21.29"><a name="Logical_NOT">NOT Logico (<code>!</code>)</a></h3>

<p>O código a seguir demonstra exemplos do operador <code>!</code> (NOT lógico) .</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="keyword token">true</span>               <span class="comment token">// !t returns false</span>
n2 <span class="operator token">=</span> <span class="operator token">!</span><span class="keyword token">false</span>              <span class="comment token">// !f returns true</span>
n3 <span class="operator token">=</span> <span class="operator token">!</span><span class="string token">'Cat'</span>              <span class="comment token">// !t returns false</span></code></pre>

<h3 id="Regras_de_conversão">Regras de conversão</h3>

<h4 id="Convertendo_AND_para_OR">Convertendo AND para OR</h4>

<p>A operação a seguir, envolvendo Booleanos:</p>

<pre class="brush: js">bCondition1 &amp;&amp; bCondition2</pre>

<p>é sempre igual a:</p>

<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre>

<h4 id="Convertendo_OR_to_AND">Convertendo OR to AND</h4>

<p>A operação a seguir, envolvendo Booleanos:</p>

<pre class="brush: js">bCondition1 || bCondition2</pre>

<p>é sempre igual a:</p>

<pre class="brush: js">!(!bCondition1 &amp;&amp; !bCondition2)</pre>

<h4 id="Convertendo_entre_dois_NOT">Convertendo entre dois NOT</h4>

<p>A seguinte operação envolvendo Booleanos:</p>

<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="operator token">!</span><span class="operator token">!</span>bCondition</code></pre>

<p>é sempre igual a:</p>

<pre class="brush: js line-numbers  language-js"><code class="language-js">bCondition</code></pre>

<h3 id="Removendo_parenteses_aninhados">Removendo parenteses aninhados</h3>

<p>Como as expressões lógicas são avaliadas da esquerda pra direita, é sempre possível remover os parênteses de uma expressão complexa seguindo algumas regras:</p>

<h4 id="Removendo_AND_aninhado">Removendo AND aninhado</h4>

<p>A seguinte operação composta envolvendo Booleanos:</p>

<pre class="brush: js">bCondition1 || (bCondition2 &amp;&amp; bCondition3)</pre>

<p>é igual a :</p>

<pre class="brush: js">bCondition1 || bCondition2 &amp;&amp; bCondition3</pre>

<h4 id="Removendo_OR_aninhado">Removendo OR aninhado</h4>

<p>A operação composta a seguir, envolvendo Booleanos:</p>

<pre class="brush: js">bCondition1 &amp;&amp; (bCondition2 || bCondition3)</pre>

<p>é sempre igual a:</p>

<pre class="brush: js">!(!bCondition1 || !bCondition2 &amp;&amp; !bCondition3)</pre>

<h2 id="Especificações">Especificações</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Especificação</th>
   <th scope="col">Estatus</th>
   <th scope="col">Comentário</th>
  </tr>
  <tr>
   <td>ECMAScript 1st Edition.</td>
   <td>Standard</td>
   <td>Initial definition.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-11.4.9', 'Logical NOT Operator')}}<br>
    {{SpecName('ES5.1', '#sec-11.11', 'Binary Logical Operators')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-logical-not-operator', 'Logical NOT operator')}}<br>
    {{SpecName('ES6', '#sec-binary-logical-operators', 'Binary Logical Operators')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Compatibilidade_com_o_Navegador">Compatibilidade com o Navegador</h2>

<p>{{ CompatibilityTable() }}</p>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Recurso</th>
   <th>Chrome</th>
   <th>Firefox (Gecko)</th>
   <th>Internet Explorer</th>
   <th>Opera</th>
   <th>Safari</th>
  </tr>
  <tr>
   <td><a href="#Logical_AND">Logical AND (<code>&amp;&amp;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Logical_OR">Logical OR (<code>||</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Logical_NOT">Logical NOT (<code>!</code>)</a></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 para Android</th>
   <th>Firefox Mobile (Gecko)</th>
   <th>IE Mobile</th>
   <th>Opera Mobile</th>
   <th>Safari Mobile</th>
  </tr>
  <tr>
   <td><a href="#Logical_AND">Logical AND (<code>&amp;&amp;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Logical_OR">Logical OR (<code>||</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Logical_NOT">Logical NOT (<code>!</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
 </tbody>
</table>
</div>

<h3 id="JavaScript_1.0_and_1.1" name="JavaScript_1.0_and_1.1">Retrocompatibilidade: Comportamento no  JavaScript 1.0 e1.1</h3>

<p>Os operadores  &amp;&amp; and <code>|| se comportam da seguinte maneira:</code></p>

<table class="fullwidth-table">
 <tbody>
  <tr>
   <th>Operador</th>
   <th>Utilização</th>
   <th>Comportamento</th>
  </tr>
  <tr>
   <td><code>&amp;&amp;</code></td>
   <td><code><em>expr1</em> &amp;&amp; <em>expr2</em></code></td>
   <td>Se o primeiro operando (<code>expr1</code>) pode ser convertido para falso, o operador <code>&amp;&amp; </code> retorna false ao invés do valor do <code>expr1</code>.</td>
  </tr>
  <tr>
   <td><code>||</code></td>
   <td><code><em>expr1</em> || <em>expr2</em></code></td>
   <td>If the first operand (<code>expr1</code>) can be converted to true, the <code>||</code> operator retorna true rather than the value of <code>expr1</code>.</td>
  </tr>
 </tbody>
</table>

<h2 id="See_also" name="See_also">Veja Também</h2>

<ul>
 <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Bitwise operators</a></li>
</ul>