path: root/files/pt-br/web/javascript/equality_comparisons_and_sameness/index.html

---
title: Comparações de igualdade e uniformidade
slug: Web/JavaScript/Equality_comparisons_and_sameness
tags:
  - Comparação
  - Igualdade
  - Intermediário
  - JavaScript
  - NaN
  - mesmo valor zero
  - uniformidade
translation_of: Web/JavaScript/Equality_comparisons_and_sameness
---
<div>{{jsSidebar("Intermediate")}}</div>

<div class="summary">
<p>JavaScript fornece três diferentes operações de comparação de valores:</p>

<ul>
 <li>igualdade estrita (ou "três iguais" ou "identidade") usando <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Identity">===</a>,</li>
 <li>igualdade ampla ("dois iguais") usando <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Equality">==</a>,</li>
 <li>e <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> (novo no ECMAScript 6).</li>
</ul>

<p>A escolha de qual operação usar depende da ordem de comparação que você está procurando executar.</p>
</div>

<p>Em resumo, dois iguais irá realizar uma conversão de tipo ao comparar duas coisas; três iguais irá fazer a mesma comparação, sem conversão de tipo (simplesmente retornando false se os tipos forem diferentes); e <code>Object.is</code> irá se comportar da mesma forma que três iguais, mas com tratamento especial para <code>NaN </code> e <code>-0</code> e <code>+0</code> de modo que os dois últimos não são referidos como sendo o mesmo, enquanto <code>Object.is(NaN, NaN)</code> será <code>true</code>. (Comparando <code>NaN</code> com <code>NaN</code> ordinariamente - ou seja, usando tanto iguais duplo ou iguais triplo - avalia como <code>false</code>, porque IEEE 754 diz isso.) Note que a distinção entre todos eles têm a ver com seu manuseio dos primitivos; nenhum deles compara se os parâmetros são conceitualmente semelhante em estrutura. Para qualquer objetos não-primitivo x e y que têm a mesma estrutura, mas são objetos distintos entre si, todas as formas acima será avaliada como falsa.</p>

<h2 id="Igualdade_estrita_usando">Igualdade estrita usando <code>===</code></h2>

<p>Igualdade estrita compara dois valores para a igualdade. Nenhum valor é convertido implicitamente para algum outro valor antes de serem comparados. Se os valores tem tipos diferentes, os valores são considerados não-iguais. Caso contrário, se os valores têm o mesmo tipo e não são números, eles são considerados iguais, se tiverem o mesmo valor. Finalmente, se ambos os valores são números, eles são considerados iguais se ambos não são <code>NaN</code> e são do mesmo valor, ou se um é <code>+0</code> e outro é <code>-0</code>.</p>

<pre class="brush: js">var num = 0;
var obj = new String("0");
var str = "0";

console.log(num === num); // true
console.log(obj === obj); // true
console.log(str === str); // true

console.log(num === obj); // false
console.log(num === str); // false
console.log(obj === str); // false
console.log(null === undefined); // false
console.log(obj === null); // false
console.log(obj === undefined); // false
</pre>

<p>Igualdade estrita é quase sempre a operação de comparação correta a se usar. Para todos os valores, exceto os números, ele usa a semântica óbvia: um valor é apenas igual a ele mesmo. Para os números que ele usa uma semântica ligeiramente diferente para encobrir dois casos extremamente diferentes. A primeira é que o zero de ponto flutuante é positiva ou negativamente assinada. Isso é útil em representar certas soluções matemáticas, mas como a maioria das situações não se preocupam com a diferença entre <code>+0</code> e <code>-0</code>, igualdade estrita trata-os como o mesmo valor. A segunda é que ponto flutuante inclui o conceito de um valor não-numérico, <code>NaN</code>, para representar a solução para certos problemas matemáticos mal definidos: infinito negativo adicionado ao infinito positivo, por exemplo. Igualdade estrita trata <code>NaN</code> como desigual a qualquer outro valor - incluindo o próprio. (O único caso em que <code>(x! == X)</code> é <code>true</code> é quando <code>x</code> é <code>NaN</code>.)</p>

<h2 id="Igualdade_ampla_usando">Igualdade ampla usando ==</h2>

<p>Igualdade ampla compara dois valores para a igualdade, <em>após</em> converter ambos os valores para um tipo comum.   Após as conversões (um ou ambos os lados podem sofrer conversões), a comparação de igualdade final é realizada exatamente como <code>===</code> executa.  Igualdade ampla é <em>simétrica</em>: <code>A == B</code> sempre tem semântica idêntica à <code>B == A</code> para quaisquer valores de <code>A</code> e <code>B</code>. </p>

<p>A comparação de igualdade é realizado da seguinte forma para os operandos dos vários tipos:</p>

<table class="standard-table">
 <thead>
  <tr>
   <th scope="row"><code> </code></th>
   <th colspan="7" scope="col" style="text-align: center;"><code>Operand B</code></th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <th scope="row"><code> </code></th>
   <td><code> </code></td>
   <td style="text-align: center;">Undefined</td>
   <td style="text-align: center;">Null</td>
   <td style="text-align: center;">Number</td>
   <td style="text-align: center;">String</td>
   <td style="text-align: center;">Boolean</td>
   <td style="text-align: center;">Object</td>
  </tr>
  <tr>
   <th colspan="1" rowspan="6" scope="row">Operand A</th>
   <td>Undefined</td>
   <td style="text-align: center;"><code>true</code></td>
   <td style="text-align: center;"><code>true</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>IsFalsy(B)</code></td>
  </tr>
  <tr>
   <td>Null</td>
   <td style="text-align: center;"><code>true</code></td>
   <td style="text-align: center;"><code>true</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>IsFalsy(B)</code></td>
  </tr>
  <tr>
   <td>Number</td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>A === B</code></td>
   <td style="text-align: center;"><code>A === ToNumber(B)</code></td>
   <td style="text-align: center;"><code>ToNumber(B) === A</code></td>
   <td style="text-align: center;"><code>ToPrimitive(B) == A</code></td>
  </tr>
  <tr>
   <td>String</td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>B === ToNumber(A)</code></td>
   <td style="text-align: center;"><code>A === B</code></td>
   <td style="text-align: center;"><code>ToNumber(A) === ToNumber(B)</code></td>
   <td style="text-align: center;"><code>ToPrimitive(B) == A</code></td>
  </tr>
  <tr>
   <td>Boolean</td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;"><code>ToNumber(A) === B</code></td>
   <td style="text-align: center;"><code>ToNumber(A) === ToNumber(B)</code></td>
   <td style="text-align: center;"><code>A === B</code></td>
   <td style="text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td>Object</td>
   <td style="text-align: center;"><code>IsFalsy(A)</code></td>
   <td style="text-align: center;"><code>IsFalsy(A)</code></td>
   <td style="text-align: center;"><code>ToPrimitive(A) == B</code></td>
   <td style="text-align: center;"><code>ToPrimitive(A) == B</code></td>
   <td style="text-align: center;"><code>false</code></td>
   <td style="text-align: center;">
    <p><code>A === B</code></p>
   </td>
  </tr>
 </tbody>
</table>

<p>Na tabela acima, <code>ToNumber(A)</code> tenta converter seu argumento para um número antes de comparação. Seu comportamento é equivalente a <code>+A</code> (o operador + unário). <code>ToPrimitive(A)</code> tenta converter seu argumento de objeto para um valor primitivo, tentando invocar sequências diferentes de <code>A.toString</code> e<code> A.valueOf</code> métodos em <code>A</code>.</p>

<p>Tradicionalmente, e de acordo com ECMAScript, todos os objetos são amplamente desiguais a <code>undefined</code> e <code>null</code>. Mas a maioria dos navegadores permitem uma classe muito limitada de objetos (especificamente, o objeto <code>document.all</code> para qualquer página), em alguns contextos, para agir como se eles <em>emulassem</em> o valor <code>undefined</code>. Igualdade ampla é um desses contexto. Portanto, o método <code>IsFalsy(A)</code> é avaliada como verdadeira se, e somente se, A for um objeto que <em> emula</em> <code>undefined</code>. Em todos os outros casos, um objeto não é amplamente igual a <code>undefined</code> ou <code>null</code>.</p>

<pre class="brush: js"><code>
var num = 0;
var obj = new String("0");
var str = "0";

console.log(num == num); // true
console.log(obj == obj); // true
console.log(str == str); // true

console.log(num == obj); // true
console.log(num == str); // true
console.log(obj == str); // true
console.log(null == undefined); // true

// both false, except in rare cases
console.log(obj == null);
console.log(obj == undefined);
</code></pre>

<p>Alguns desenvolvedores consideram que nunca é uma boa idéia, praticamente, usar a igualdade ampla. O resultado de uma comparação usando a igualdade estrita é mais fácil de prever, e como nenhum tipo de coerção ocorre, a avaliação pode ser mais rápida.</p>

<h2 id="Igualdade_de_mesmo_valor">Igualdade de mesmo valor</h2>

<p>Igualdade de mesmo valor aborda um caso de uso final: determinar se dois valores são <em>funcionalmente idêntico</em> em todos os contextos. (Este caso de uso demonstra uma instância de <a href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" title="http://en.wikipedia.org/wiki/Liskov_substitution_principle">Liskove substitution principle</a>. Princípio de substituição de Liskove.) Uma instância ocorre quando é feita uma tentativa de transformar uma propriedade imutável:</p>

<pre class="brush: js"><code><code>
// Add an immutable NEGATIVE_ZERO property to the Number constructor.
Object.defineProperty(Number, "NEGATIVE_ZERO",
                      { value: -0, writable: false, configurable: false, enumerable: false });

function attemptMutation(v)
{
  Object.defineProperty(Number, "NEGATIVE_ZERO", { value: v });
}
</code></code></pre>

<p><code><code><code>Object.defineProperty</code> </code></code>irá disparar uma exceção ao tentar alterar uma propriedade imutável que realmente iria alterá-lo, mas ele não faz nada se nenhuma mudança real for solicitada.  Se <code>v</code> for <code>-0</code>, nenhuma mudança foi solicitada, e nenhum erro será disparado.   Mas se <code>v</code> for <code>+0</code>, <code>Number.NEGATIVE_ZERO</code> não teria mais o seu valor imutável.   Internamente, quando uma propriedade imutável é redefinida, o valor recém-especificado é comparado com o valor atual usando a igualdade de mesmo valor.</p>

<p>Igualdade de mesmo valor é fornecida pelo método <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is">Object.is</a>.</code></p>

<h2 id="Igualdade_abstrata_igualdade_estrita_e_de_mesmo_valor_na_especificação">Igualdade abstrata, igualdade estrita, e de mesmo valor na especificação</h2>

<p>No ES5, a comparação efetuada por<code> <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Comparison_Operators" title="/pt-BR/docs/Web/JavaScript/Reference/Operators/Comparison_Operators"><code>==</code></a> </code>é descrita em <a href="http://ecma-international.org/ecma-262/5.1/#sec-11.9.3" title="http://ecma-international.org/ecma-262/5.1/#sec-11.9.3">Seção 11.9.3, O Algoritmo da Igualdade Abstrata</a>. A comparação <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Comparison_Operators" title="/pt-BR/docs/Web/JavaScript/Reference/Operators/Comparison_Operators"><code>===</code></a> </code>está em <a href="http://ecma-international.org/ecma-262/5.1/#sec-11.9.6" title="http://ecma-international.org/ecma-262/5.1/#sec-11.9.6">11.9.6, O Algoritmo de Igualdade Estrita</a>. (Veja estes. Eles são breve e legível. Dica: leia o algoritmo de igualdade estrita primeiro.) ES5 também descreve, em <a href="http://ecma-international.org/ecma-262/5.1/#sec-9.12" title="http://ecma-international.org/ecma-262/5.1/#sec-9.12">Seção 9.12, o Algoritmo de Mesmo Valor</a> para uso internamente pelo motor de JS. É em grande parte o mesmo que o Algoritmo de Igualdade Estrita, exceto que 11.9.6.4 e 9.12.4 diferem em manipulação do <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Number"><code>Number</code></a></code>. ES6 simplesmente se propõe a expor este algoritmo através de <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a></code>.</p>

<p>Podemos ver que com iguais duplos e triplos, com exceção de fazer uma verificação de tipo inicial 11.9.6.1, o Algoritmo de Igualdade Estrita é um subconjunto do Algoritmo Igualdade Abstrata, porque 11.9.6.2-7 correspondem a 11.9.3.1.a -f.</p>

<h2 id="Um_modelo_para_a_compreensão_comparações_de_igualdade">Um modelo para a compreensão comparações de igualdade?</h2>

<p>Antes do ES6, você poderia dizer, de iguais duplos e iguais triplos, que um é uma versão "melhorada" do outro. Por exemplo, alguém poderia dizer que dois iguais é uma versão estendida de três iguais, porque o anterior faz tudo o que este último faz, mas com conversão de tipo nos seus operandos. Por exemplo, 6 == "6". (Alternativamente, alguém poderia dizer que dois iguais é a linha de base, e três iguais são uma versão melhorada, porque requer dois operandos para ser do mesmo tipo, por isso adiciona uma restrição extra. Qual deles é o melhor modelo para compreensão depende como você optar por ver as coisas.)</p>

<p>No entanto, esta forma de pensar sobre os operadores de igualdade embutida não é um modelo que pode ser esticado para permitir um lugar para <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is">Object.is</a> de ES6 neste "espectro". <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is">Object.is</a> não é simplesmente "mais frouxo" que dois iguais ou "mais rigorosa" do que três iguais, nem se encaixa em algum lugar entre eles (ex: sendo tanto mais rigorosas que dois iguais, mas mais flexível do que três iguais). Podemos ver a partir da tabela de comparações de igualdade abaixo que isto é devido à forma que <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is">Object.is</a> manipula <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a>. Observe que, se Object.is(NaN, NaN) avalia como false, nós <em>poderiamos</em> dizer que ele se encaixa no espectro amplo/estrito como um forma ainda mais rigorosa das três iguais, um que distingue entre -0 e +0. A manipulação do <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a> significa que este é não-verdadeiro, entretanto. Infelizmente, <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is">Object.is</a> simplesmente tem que ser pensado em termos de suas características específicas, ao invés de sua amplitude ou rigorosidade no que diz respeito aos operadores de igualdade.</p>

<table class="standard-table">
 <caption>Sameness Comparisons</caption>
 <thead>
  <tr>
   <th scope="col" style="text-align: center;">x</th>
   <th scope="col" style="text-align: center;">y</th>
   <th scope="col" style="width: 10em; text-align: center;">==</th>
   <th scope="col" style="width: 10em; text-align: center;">===</th>
   <th scope="col" style="width: 10em; text-align: center;">Object.is</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>undefined</code></td>
   <td><code>undefined</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
  </tr>
  <tr>
   <td><code>null</code></td>
   <td><code>null</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
  </tr>
  <tr>
   <td><code>true</code></td>
   <td><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
  </tr>
  <tr>
   <td><code>false</code></td>
   <td><code>false</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
  </tr>
  <tr>
   <td><code>"foo"</code></td>
   <td><code>"foo"</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
  </tr>
  <tr>
   <td><code>{ foo: "bar" }</code></td>
   <td><code>x</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
  </tr>
  <tr>
   <td><code>0</code></td>
   <td><code>0</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
  </tr>
  <tr>
   <td><code>+0</code></td>
   <td><code>-0</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>0</code></td>
   <td><code>false</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>""</code></td>
   <td><code>false</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>""</code></td>
   <td><code>0</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>"0"</code></td>
   <td><code>0</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>"17"</code></td>
   <td><code>17</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>[1,2]</code></td>
   <td><code>"1,2"</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>new String("foo")</code></td>
   <td><code>"foo"</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>null</code></td>
   <td><code>undefined</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>null</code></td>
   <td><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>undefined</code></td>
   <td><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>{ foo: "bar" }</code></td>
   <td><code>{ foo: "bar" }</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>new String("foo")</code></td>
   <td><code>new String("foo")</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>0</code></td>
   <td><code>null</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>0</code></td>
   <td><code>NaN</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>"foo"</code></td>
   <td><code>NaN</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
  </tr>
  <tr>
   <td><code>NaN</code></td>
   <td><code>NaN</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
   <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
  </tr>
 </tbody>
</table>

<h2 id="Quando_usar_Object.is_ao_invés_de_três_iguais">Quando usar <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is">Object.is</a></code> ao invés de três iguais</h2>

<p>Além da forma como trata <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a></code>, geralmente, a única vez que o comportamento especial do <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is">Object.is</a> em direção a zeros é provável que seja interessante é na busca de determinados regimes de meta-programação, especialmente em relação a descritores de propriedade quando é desejável para o seu trabalho para espelhar algumas das características de <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a>. Se o seu caso de uso não exige isso, sugere-se a evitar <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is">Object.is</a> e usar <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Comparison_Operators" title="/pt-BR/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">===</a> em vez disso. Mesmo se suas exigências envolvem comparações entre dois valores <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a> avaliarem para true, geralmente é mais fácil para caso especial o <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a> checar (usando o <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/isNaN" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN">isNaN</a> método disponível a partir de versões anteriores do ECMAScript) do que descobrir como cálculos circundantes podem afetar o sinal de todos os zeros que você encontra em sua comparação.</p>

<p>Aqui está uma lista exaustiva de métodos e operadores integrados que pode causar uma distinção entre -0 e +0 a manifestar-se em seu código:</p>

<dl>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#-_.28Unary_Negation.29" title="/pt-BR/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators">- (negação unário)</a></code></dt>
</dl>

<dl>
 <dd>
 <p>É óbvio que negando 0 produz -0. Mas a abstração de uma expressão pode causar -0 a fluência em quanto você não percebe isso. Por exemplo, considere:</p>

 <pre class="brush:js">let stoppingForce = obj.mass * -obj.velocity</pre>

 <p>If obj.velocity is 0 (ou calcula para 0), um -0 é introduzido naquele lugar e propaga-se em stoppingForce.</p>
 </dd>
</dl>

<dl>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2">Math.atan2</a></code></dt>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil">Math.ceil</a></code></dt>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/pow" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/pow">Math.pow</a></code></dt>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/round" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/round">Math.round</a></code></dt>
</dl>

<dl>
 <dd>É possível que um -0 para ser introduzido em uma expressão como um valor de retorno desses métodos, em alguns casos, mesmo quando nenhum -0 exista como um dos parâmetros. Por exemplo, usando <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/pow" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/pow">Math.pow</a> para levantar -<a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Infinity" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Infinity">Infinity</a> para o poder de qualquer, expoente ímpar negativo avaliada como -0. Consulte a documentação para os métodos individuais.</dd>
</dl>

<dl>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/floor" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/floor">Math.floor</a></code></dt>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/max" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/max">Math.max</a></code></dt>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/min" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/min">Math.min</a></code></dt>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/sin" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/sin">Math.sin</a></code></dt>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt">Math.sqrt</a></code></dt>
 <dt><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/tan" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/tan">Math.tan</a></code></dt>
</dl>

<dl>
 <dd>É possível obter um -0 valor de retorno para fora destes métodos em alguns casos em que um -0 existe como um dos parâmetros. Por exemplo, <code>Math.min(-0, +0)</code> resulte em -0. Consulte a documentação para os métodos individuais.</dd>
</dl>

<dl>
 <dt><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="/pt-BR/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">~</a></dt>
 <dt><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="/pt-BR/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">&lt;&lt;</a></dt>
 <dt><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="/pt-BR/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">&gt;&gt;</a></dt>
 <dd>Cada um destes operadores usa o algoritmo ToInt32 internamente. Uma vez que existe apenas uma representação para 0 no tipo integer de 32 bits interno, -0 não vai sobreviver a uma ida e volta após uma operação inversa. Por exemplo, tanto <code>Object.is(~~(-0), -0)</code> e <code>Object.is(-0 &lt;&lt; 2 &gt;&gt; 2, -0)</code> avaliar como <code>false</code>.</dd>
</dl>

<p>Baseando-se em <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/is">Object.is</a></code> quando a sinalização de zeros não é levado em conta podem ser perigosos. Claro que, quando a intenção é fazer a distinção entre <code>-0</code> e <code>+0</code>, que faz exatamente o que é desejado.</p>

<h2 id="Veja_também">Veja também</h2>

<ul>
 <li><a href="http://dorey.github.io/JavaScript-Equality-Table/">Tabela de Comparação JS</a></li>
</ul>