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

---
title: Operadores de comparação
slug: >-
  conflicting/Web/JavaScript/Reference/Operators_0d2e4b8154642b5a9dbd76a2a48cf96a
tags:
  - Comparando String
  - Comparação
  - Igualdade
  - Operadores
  - Relacionais
translation_of: Web/JavaScript/Reference/Operators
translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators
original_slug: Web/JavaScript/Reference/Operators/Operadores_de_comparação
---
<div>{{jsSidebar("Operators")}}</div>

<p>O JavaScript possui comparações estritas e conversão de tipos. Uma comparação estrita (e.g., <code>===</code>) somente é verdade se os operandos forem do mesmo tipo e de conteúdo correspondente. A comparação abstrata mais comumente utilizada (e.g. <code>==</code>) converte os operandos no mesmo tipo antes da comparação. Para comparações abstratas relacionais (e.g., <code>&lt;=</code>), os operandos são primeiro convertidos em primitivos, depois para o mesmo tipo, depois comparados.</p>

<p>Strings são comparadas baseadas na ordenação lexicografica padrão, usando valores Unicode.</p>

<div>{{EmbedInteractiveExample("pages/js/expressions-comparisonoperators.html")}}</div>

<p class="hidden">Os fontes para este exemplo interativo estão em um repositório no GitHub. Se você gostaria de contribuir com projetos de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie para nós um pull request.</p>

<p>Características de comparação:</p>

<ul>
 <li>Duas strings são estritamente iguals quando elas possuem a mesma sequência de caracteres, o mesmo tamanho, Duas string são estritamente iguals quando elas possuem a mesma sequência de caracteres, o mesmo tamanho, e os mesmos caracteres em posições correspondentes.</li>
 <li>Dois números são estritamente iguais quando eles são numericamente iguais (tem o mesmo valor numérico). <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="NaN">NaN</a> não é igual a nada, incluindo NaN. Zeros positivos e negativos são iguals entre si.</li>
 <li>Dois operadores Boleanos são estritamente iguais se ambos são <code>true</code> ou ambos são <code>false</code>.</li>
 <li>Dois objetos distintos nunca são iguais para comparações estritas ou abstratas.</li>
 <li>Uma expressão comparando Objetos somente é verdadeira se os operandos referenciarem o mesmo Objeto.</li>
 <li>Os tipo Null e Undefined são estritamente iguais entre eles mesmos e abstratamente iguais entre si.</li>
</ul>

<h2 id="Operadores_de_Igualdade">Operadores de Igualdade </h2>

<h3 id="Igualdade"><a name="Equality">Igualdade (==)</a></h3>

<p>O operador de igualdade converte o operando se ele <strong>não for do mesmo tipo</strong>, então aplica a comparação estrita. Se <strong>ambos os operandos são objetos</strong>, então o JavaScript compara referencias internas que são iguais quando os operandos se referem ao mesmo objeto em memória.</p>

<h4 id="Sintaxe">Sintaxe</h4>

<pre class="syntaxbox notranslate">x == y
</pre>

<h4 id="Exemplos">Exemplos</h4>

<pre class="brush: js notranslate">1    ==  1         // verdade
'1'  ==  1         // verdade
1    == '1'        // verdade
0    == false      // verdade
0    == null       // falso
var object1 = {'key': 'value'}, object2 = {'key': 'value'};
object1 == object2 // falso
0    == undefined  // falso
null == undefined  // verdade
</pre>

<h3 id="Desigualdade_!"><a name="Inequality">Desigualdade (!=)</a></h3>

<p>O operador de desigualdade retorna true (verdade) se os operandos não são iguais. Se os dois operandos <strong>não são do mesmo tipo</strong>, o JavaScript tenta converter os operandos para o tipo apropriado para a comparação. Se <strong>ambos os operandos são objetos</strong>, então o JavaScript compara referências internas que não são iguais quando os operandos se referem a objetos diferentes na memória.</p>

<h4 id="Sintaxe_2">Sintaxe</h4>

<pre class="syntaxbox notranslate">x != y</pre>

<h4 id="Exemplos_2">Exemplos</h4>

<pre class="brush: js notranslate">1 !=   2     // verdade
1 !=  '1'    // falso
1 !=  "1"    // falso
1 !=  true   // falso
0 !=  false  // falso
</pre>

<h3 id="Identidade_igualdade_estrita"><a name="Identity">Identidade / igualdade estrita (===)</a></h3>

<p>O operador de identidade retorna true (verdade) se os operandos são estritamente iguais (veja acima) <strong>sem conversão de tipo</strong>. </p>

<h4 id="Sintaxe_3">Sintaxe</h4>

<pre class="syntaxbox notranslate">x === y</pre>

<h4 id="Exemplos_3">Exemplos</h4>

<pre class="brush: js  notranslate">3 === 3   // verdade
3 === '3' // falso
var object1 = {'key': 'value'}, object2 = {'key': 'value'};
object1 === object2 //f also</pre>

<h3 id="Non-identity_desigualdade_estrita_!"><a name="Nonidentity">Non-identity / desigualdade estrita (!==)</a></h3>

<p>O operador desigualdade estrita (Non-identity) retorna verdadeiro se os operandos <strong>não são iguais e / ou não são do mesmo tipo</strong>.</p>

<h4 id="Sintaxe_4">Sintaxe</h4>

<pre class="syntaxbox notranslate">x !== y</pre>

<h4 id="Exemplos_4">Exemplos</h4>

<pre class="brush: js notranslate">3 !== '3' // verdade
4 !== 3   // verdade
</pre>

<h2 id="Operadores_relacionais">Operadores relacionais</h2>

<p>Cada um desses operadores chamará a função valueOf () em cada operando antes que uma comparação seja feita.</p>

<h3 id="Operador_Maior_>"><a name="Greater_than_operator">Operador Maior (&gt;)</a></h3>

<p>O operador de Maior retorna true se o operando da esquerda for maior que o operando da direita.</p>

<h4 id="Sintaxe_5">Sintaxe</h4>

<pre class="syntaxbox notranslate">x &gt; y</pre>

<h4 id="Exemplos_5">Exemplos</h4>

<pre class="brush: js notranslate">4 &gt; 3 // verdade
</pre>

<h3 id="Operador_maior_ou_igual_>"><a name="Greater_than_or_equal_operator">Operador maior ou igual (&gt;=)</a></h3>

<p>O operador maior ou igual retorna true se o operando da esquerda for maior ou igual ao operando da direita.</p>

<h4 id="Sintaxe_6">Sintaxe</h4>

<pre class="syntaxbox notranslate"> x &gt;= y</pre>

<h4 id="Exemplos_6">Exemplos</h4>

<pre class="brush: js notranslate">4 &gt;= 3 // verdade
3 &gt;= 3 // verdade
</pre>

<h3 id="Operador_Menor_&lt;"><a name="Less_than_operator">Operador Menor (&lt;)</a></h3>

<p>O operador menor retorna true (verdadeiro) se o operando da esquerda for menor que o operando da direita.</p>

<h4 id="Sintaxe_7">Sintaxe</h4>

<pre class="syntaxbox notranslate"> x &lt; y</pre>

<h4 id="Exemplos_7">Exemplos</h4>

<pre class="brush: js notranslate">3 &lt; 4 // verdade
</pre>

<h3 id="Operador_menor_ou_igual_&lt;"><a id="Less_than_or_equal_operator" name="Less_than_or_equal_operator">Operador menor ou igual (&lt;=)</a></h3>

<p>O operador menor ou igual retorna true (verdadeiro) se o operando da esquerda for menor ou igual ao operando da direita.</p>

<h4 id="Sintaxe_8">Sintaxe</h4>

<pre class="syntaxbox notranslate"> x &lt;= y</pre>

<h4 id="Exemplos_8">Exemplos</h4>

<pre class="brush: js notranslate">3 &lt;= 4 // verdade
</pre>

<h2 id="Usando_Operadores_de_Igualdade">Usando Operadores de Igualdade</h2>

<p>Os operadores de igualdade padrão (== e! =) Usam o <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">Algoritmo de Comparação de Igualdade Abstrata</a> </p>

<p>para comparar dois operandos. Se os operandos forem de tipos diferentes, ele tentará convertê-los para o mesmo tipo antes de fazer a comparação. Por exemplo, na expressão 5 == '5', a sequência à direita é convertida em {{jsxref ("Number" )}} antes da comparação ser feita.</p>

<p>Os operadores de igualdade estrita (=== e! ==) usam o <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">Algoritmo de comparação estrita de igualdade</a> e se destinam a executar comparações de igualdade em operandos do mesmo tipo. Se os operandos são de tipos diferentes, o resultado é sempre falso, então 5! == '5'.<br>
 <br>
 Use operadores de igualdade estrita se os operandos precisarem ser de um tipo específico e também de valor ou se o tipo exato dos operandos for importante. Caso contrário, use os operadores de igualdade padrão, que permitem comparar a identidade de dois operandos, mesmo que não sejam do mesmo tipo.<br>
 <br>
 Quando a conversão de tipos está envolvida na comparação (por exemplo, comparação não estrita), o JavaScript converte os tipos {{jsxref ("String")}}, {{jsxref ("Number")}}, {{jsxref ("Booleano" )}} ou {{jsxref ("Object")}}) operandos da seguinte forma:</p>

<ul>
 <li>Ao comparar um número e uma string, a string é convertida em um valor numérico. JavaScript tenta converter o literal numérico de string em um valor de tipo Number. Primeiro, um valor matemático é derivado do literal numérico da string. Em seguida, esse valor é arredondado para o valor de tipo de número mais próximo.</li>
 <li>Se um dos operandos for booleano, o operando booleano é convertido em 1 se for verdadeiro e +0 se for falso.</li>
 <li>Se um objeto é comparado com um número ou string, o JavaScript tenta retornar o valor padrão para o objeto. Os operadores tentam converter o objeto em um valor primitivo, um valor String ou Number, usando os métodos valueOf e toString dos objetos. Se essa tentativa de converter o objeto falhar, será gerado um erro de tempo de execução.</li>
 <li>Observe que um objeto é convertido em primitivo se, e somente se, seu comparando for um primitivo. Se os dois operandos forem objetos, eles serão comparados como objetos, e o teste de igualdade será verdadeiro apenas se ambos fizerem referência ao mesmo objeto.</li>
</ul>

<div class="note"><strong>Nota:</strong> Os objetos String são do Tipo Objeto, não String! Os objetos de string raramente são usados, portanto, os seguintes resultados podem ser surpreendentes:</div>

<pre class="brush:js notranslate">// true, pois ambos os operandos são do tipo String (ou seja, primitivos de string):
'foo' === 'foo'

var a = new String('foo');
var b = new String('foo');

// falso (false) pois a e b, embora do tipo "Objeto", são instâncias diferentes
a == b

// falso (false) pois a e b, embora do tipo "Objeto", são instâncias diferentes
a === b

// verdadeiro (true) pois o objeto a e 'foo' (String) são de tipos diferentes e, o Objeto (a)
// é convertido para String ('foo') antes da comparação
a == 'foo'</pre>

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

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Especificação</th>
   <th scope="col">Status</th>
   <th scope="col">Comentário</th>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2('ES1')}}</td>
   <td>Definição Inicial. Implementado em JavaScript 1.0</td>
  </tr>
  <tr>
   <td>{{SpecName('ES3')}}</td>
   <td>{{Spec2('ES3')}}</td>
   <td>Adicionandos os operadores <code>===</code> e <code>!==</code> . Implementado em JavaScript 1.3</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-11.8')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td>Definidos em várias seções das especificações: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Operadores Relacionais </a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdade</a></td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-relational-operators')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Definidos em várias seções das especificações: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Operadores Relacionais </a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdade</a></td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td>Definidos em várias seções das especificações: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Operadores Relacionais </a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdade</a></td>
  </tr>
 </tbody>
</table>

<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>

<p>{{Compat("javascript.operators.comparison")}}</p>

<h2 id="Consulte_também">Consulte também</h2>

<ul>
 <li>{{jsxref("Object.is()")}}</li>
 <li>{{jsxref("Math.sign()")}}</li>
 <li><a href="/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness">Comparações de igualdade e similaridades</a></li>
</ul>

<div id="gtx-trans" style="position: absolute; left: 32px; top: 2185.4px;">
<div class="gtx-trans-icon"></div>
</div>