Object.is vs ===

Me topé con un ejemplo de código que estaba usando esta comparación:

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

Sé false == 0que será truepor eso que tenemos ===.

¿Cómo es Object.isdiferente de ===?

===se llama operador de comparación estricta en JavaScript. Object.isy el operador de comparación estricto se comportan exactamente igual excepto por NaNy +0/-0.

De MDN:

Object.is()El método no es lo mismo que ser igual según el ===operador. El ===operador (y el ==operador también) trata los valores numéricos -0 y +0 como iguales y los trata Number.NaNcomo no iguales a NaN.

El siguiente código resalta la diferencia entre ===y 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

Puedes encontrar más ejemplos aquí .

Nota : Object.ises parte de la propuesta ECMAScript 6 y aún no es ampliamente compatible (por ejemplo, no es compatible con ninguna versión de Internet Explorer o muchas versiones anteriores de otros navegadores). Sin embargo, puede usar un polyfill para navegadores que no son ES6 que se pueden encontrar en el enlace anterior.

Object.isusa el algoritmo SameValue de la especificación , mientras que ===usa el algoritmo de igualdad estricta . Una nota sobre el algoritmo de igualdad estricta señala la diferencia:

Este algoritmo difiere del algoritmo SameValue ... en su tratamiento de ceros con signo y NaN.

Tenga en cuenta que:

• NaN === NaNes falso pero Object.is(NaN, NaN)es cierto
• +0 === -0es cierto, pero Object.is(+0, -0)es falso
• -0 === +0es cierto, pero Object.is(-0, +0)es falso

JavaScript tiene al menos cuatro tipos de "igualdad":

• "Loose" ( ==), donde los operandos serán obligados a intentar hacerlos coincidir. Las reglas están claramente especificadas , pero no son obvias. ( "" == 0es true; "true" == truees false, ...).
• "Estricto" ( ===), donde los operandos de diferentes tipos no serán coaccionados (y no serán iguales), pero vea la nota anterior sobre NaNcero positivo y negativo.
• SameValue: como se enumeró anteriormente (utilizado por Object.is).
• SameValueZero: igual que SameValueexcepto +0y -0son iguales en lugar de diferentes (utilizado por Mappara las teclas y por Array.prototype.includes).

También hay equivalencia de objetos , que no es proporcionada por el lenguaje o el tiempo de ejecución en sí, pero generalmente se expresa como: Los objetos tienen el mismo prototipo, las mismas propiedades y sus valores de propiedad son los mismos (por alguna definición razonable de "lo mismo" )

Algoritmo SameValue :

• Si el Tipo (x) es diferente del Tipo (y), devuelve falso.
• Si Tipo (x) es Número, entonces
  • Si x es NaN e y es NaN, devuelve verdadero.
  • Si x es +0 e y es -0, devuelve falso.
  • Si x es -0 e y es +0, devuelve falso.
  • Si x es el mismo valor numérico que y, devuelve verdadero.
  • Falso retorno.
• Devuelve SameValueNonNumber (x, y).

... donde SameValueNonNumber es:

• Afirmar: Tipo (x) no es Número.
• Afirmar: Tipo (x) es lo mismo que Tipo (y).
• Si Tipo (x) no está definido, devuelve verdadero.
• Si Tipo (x) es Nulo, devuelve verdadero.
• Si Tipo (x) es Cadena, entonces
  • Si x e y son exactamente la misma secuencia de unidades de código (misma longitud y mismas unidades de código en los índices correspondientes), devuelve verdadero; de lo contrario, devuelve falso.
• Si Tipo (x) es booleano, entonces
  • Si x e y son verdaderas o ambas falsas, devuelve verdadero; de lo contrario, devuelve falso.
• Si Tipo (x) es Símbolo, entonces
  • Si x e y son ambos el mismo valor de Símbolo, devuelve verdadero; de lo contrario, devuelve falso.
• Devuelve verdadero si x e y son el mismo valor de objeto. De lo contrario, devuelve falso.

Algoritmo de igualdad estricto :

1. Si el Tipo (x) es diferente del Tipo (y), devuelve falso.
2. Si Tipo (x) es Número, entonces
   • Si x es NaN, devuelve falso.
   • Si y es NaN, devuelve falso.
   • Si x es el mismo valor numérico que y, devuelve verdadero.
   • Si x es +0 e y es -0, devuelve verdadero.
   • Si x es -0 e y es +0, devuelve verdadero.
   • Falso retorno.
3. Devuelve 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;
}

Lo anterior es la función polyfill para mostrar cómo Object.isfunciona, para cualquier persona interesada en saber. Una referencia a You-Don't-Know-JS

Resumen:

La Object.is()función toma 2 valores como argumentos y devuelve verdadero si los 2 valores dados son exactamente iguales, de lo contrario devolverá falso.

¿Porqué necesitamos esto?

Puede pensar que ya tenemos una igualdad estricta (tipo de cheques + valor) al verificar javascript con el ===operador, ¿por qué necesitamos esta función? Bueno, la igualdad estricta no es suficiente en algunos casos y son los siguientes:

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

Object.is() nos ayuda al poder comparar estos valores para ver si son similares, algo que el operador de igualdad estricta no puede hacer.

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

En pocas palabras, son similares, pero Object.isson más inteligentes y precisos ...

Veamos esto ...

+0 === -0 //true

Pero esto no es del todo correcto ya que ignora -y +antes ...

Ahora usamos:

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

Como puede ver, esto es más preciso para comparar.

También en caso de NaNque funcione más bien como correcto, ya que consideramos NaNlo mismo.