Object.is vs ===

Eu me deparei com um exemplo de código que estava usando essa comparação:

var someVar = 0;
Object.is(false, someVar); //Returns false 

Eu sei que false == 0será truepor isso que temos ===.

Qual é a Object.isdiferença ===?

===é chamado operador de comparação estrita em JavaScript. Object.ise o operador de comparação estrita se comporta exatamente da mesma maneira, exceto NaNe +0/-0.

Do MDN:

Object.is()O método não é o mesmo que ser igual, de acordo com o ===operador. O ===operador (e também o ==operador) trata os valores numéricos -0 e +0 como iguais e trata Number.NaNcomo não iguais a NaN.

O código abaixo destaca a diferença entre ===e Object.is().

console.log(+0 === -0); //true
console.log(Object.is(+0, -0)); //false

console.log(NaN === NaN); // false
console.log(Object.is(NaN, NaN)); //true

console.log(Number.NaN === Number.NaN); // false
console.log(Object.is(Number.NaN, Number.NaN)); // true

console.log(NaN === Number.NaN); // false
console.log(Object.is(NaN, Number.NaN)); // true

Você pode encontrar mais exemplos aqui .

Nota : Object.isfaz parte da proposta do ECMAScript 6 e ainda não é amplamente suportado (por exemplo, não é suportado por nenhuma versão do Internet Explorer ou por muitas versões anteriores de outros navegadores). No entanto, você pode usar um polyfill para navegadores não-ES6, que pode ser encontrado no link fornecido acima.

Object.isusa o algoritmo SameValue da especificação , enquanto ===usa o algoritmo de igualdade estrita . Uma observação sobre o algoritmo de igualdade estrita destaca a diferença:

Este algoritmo difere do algoritmo SameValue ... no tratamento de zeros e NaNs assinados.

Observe que:

• NaN === NaNé falso, mas Object.is(NaN, NaN)é verdadeiro
• +0 === -0é verdade, mas Object.is(+0, -0)é falsa
• -0 === +0é verdade, mas Object.is(-0, +0)é falsa

JavaScript possui pelo menos quatro tipos de "igualdade":

• "Loose" ( ==), onde os operandos serão coagidos a tentar fazê-los corresponder. As regras são claramente especificadas , mas não óbvias. ( "" == 0é true; "true" == trueé false, ...).
• "Strict" ( ===), onde operandos de tipos diferentes não serão coagidos (e não serão iguais), mas veja a nota acima sobre NaNe zero positivo e negativo.
• SameValue - conforme listado acima (usado por Object.is).
• SameValueZero - como SameValueexceto, +0e -0é o mesmo em vez de diferente (usado por Mappara chaves e por Array.prototype.includes).

Também há equivalência de objetos , que não é fornecida pelo idioma ou pelo próprio tempo de execução, mas geralmente é expressa como: Os objetos têm o mesmo protótipo, mesmas propriedades e seus valores de propriedade são os mesmos (por uma definição razoável de "o mesmo" )

Algoritmo SameValue :

• Se o Tipo (x) for diferente do Tipo (y), retorne false.
• Se o Tipo (x) for Número, então
  • Se x for NaN e y for NaN, retorne verdadeiro.
  • Se x é +0 e y é -0, retorne false.
  • Se x é -0 e y é +0, retorne false.
  • Se x é o mesmo valor numérico que y, retorne true.
  • Retorna falso.
• Retorno SameValueNonNumber (x, y).

... onde SameValueNonNumber é:

• Afirmar: O tipo (x) não é Número.
• Afirmar: o tipo (x) é o mesmo que o tipo (y).
• Se o Tipo (x) for Indefinido, retorne verdadeiro.
• Se o Tipo (x) for Nulo, retorne verdadeiro.
• Se o Tipo (x) for String, então
  • Se x e y são exatamente a mesma sequência de unidades de código (o mesmo comprimento e as mesmas unidades de código nos índices correspondentes), retorne true; caso contrário, retorne false.
• Se o Tipo (x) for Booleano,
  • Se xey forem verdadeiros ou falsos, retorne verdadeiro; caso contrário, retorne false.
• Se o Tipo (x) for Símbolo, então
  • Se xey forem ambos o mesmo valor do símbolo, retorne true; caso contrário, retorne false.
• Retorne true se xey forem o mesmo valor do objeto. Caso contrário, retorne false.

Algoritmo de igualdade estrita :

1. Se o Tipo (x) for diferente do Tipo (y), retorne false.
2. Se o Tipo (x) for Número, então
   • Se x for NaN, retorne false.
   • Se y for NaN, retorne false.
   • Se x é o mesmo valor numérico que y, retorne true.
   • Se x é +0 e y é -0, retorne true.
   • Se x é -0 e y é +0, retorne true.
   • Retorna falso.
3. Retorno SameValueNonNumber (x, y).

Object.is = function(v1, v2){
  //test for `-0`
  if(v1 === 0 && v2 === 0) {
    return 1 / v1 === 1 / v2;
  }
  
  //test for `NaN`
  if(v1 !== v1) {
    return v2 !== v2;
  }
  
  //everything else
  return v1 === v2;
}

A descrição acima é a função polyfill para mostrar como Object.isfunciona, para quem estiver interessado em saber. Uma referência a Você-Não-Sabe-JS

Resumo:

A Object.is()função aceita 2 valores como argumentos e retorna true se os 2 valores fornecidos forem exatamente iguais, caso contrário, retornará false.

Por que nós precisamos disso?

Você pode pensar que já temos uma igualdade estrita (verifica tipo + valor) verificando javascript com o ===operador, por que precisamos dessa função? Bem, a igualdade estrita não é suficiente em alguns casos e são os seguintes:

console.log(NaN === NaN);   // false
console.log(-0 === +0);     // true

Object.is() nos ajuda a comparar esses valores para ver se são semelhantes, algo que o operador de igualdade estrita não pode fazer.

console.log(Object.is(NaN, NaN));  // true
console.log(Object.is(-0, 0));     // false
console.log(Object.is(+0, +0));    // true
console.log(Object.is(+0, -0));    // false

Em poucas palavras, eles são semelhantes, mas Object.issão mais inteligentes e mais precisos ...

Vejamos isso ...

+0 === -0 //true

Mas isso não está totalmente certo, pois ignora -e +antes ...

Agora usamos:

Object.is(+0, -0) //false

Como você vê, é mais preciso comparar isso.

Também no caso de NaNque funciona mais como correto, como considere NaNo mesmo.