Comparaciones de igualdad

En JavaScript, las comparaciones de igualdad se utilizan para verificar si dos valores son iguales entre sí.

Las comparaciones de igualdad en JavaScript son fundamentales para verificar si dos valores son iguales y, a su vez, para tomar decisiones en el flujo del código. Sin embargo, JavaScript ofrece dos formas principales de comparar igualdad: igualdad débil (==) e igualdad estricta (===), cada una con sus propias reglas y peculiaridades.

Cuando comparamos valores en JavaScript, debemos tener en cuenta que el lenguaje es dinámico y admite diferentes tipos de datos (números, cadenas, booleanos, objetos, etc.). Debido a esto, comparar valores de distintos tipos puede ser problemático o, al menos, ambiguo. Para abordar este desafío, JavaScript implementa dos tipos de operadores de igualdad que permiten comportamientos diferentes según la necesidad:

Igualdad débil ( == )

Este operador verifica si los valores son iguales tras aplicar una coerción de tipos, lo cual significa que JavaScript intentará convertir los valores a un tipo común antes de compararlos.

Igualdad estricta ( === )

Este operador compara tanto el valor como el tipo de los operandos. No realiza coerción de tipos, por lo que ambos valores deben ser del mismo tipo y tener el mismo valor para ser considerados iguales.

¿Por qué existen dos tipos de comparación?

La diferencia entre igualdad débil y estricta refleja una decisión de diseño en JavaScript para hacer el lenguaje más flexible y accesible. El operador == permite una comparación más permisiva y flexible al hacer conversiones implícitas de tipos cuando es necesario. Sin embargo, esta flexibilidad puede producir resultados inesperados en algunos casos, debido a las reglas de coerción que JavaScript aplica automáticamente.

Por otro lado, el operador === fue introducido para asegurar que tanto el tipo como el valor sean exactamente iguales, lo que resulta en una comparación más segura y predecible, especialmente útil en aplicaciones donde la precisión y consistencia son críticas.

// Igualdad debil
console.log(5 == "5"); // true (JavaScript convierte "5" en 5 antes de comparar) 
console.log(null == undefined); // true (considerados iguales en igualdad débil)
 
// Igualdad estricta
console.log(5 === "5"); // false (diferentes tipos: number y string)
console.log(null === undefined); // false (diferentes tipos)

Comparación entre objetos

Cuando se comparan objetos (incluyendo arrays y funciones), tanto == como === verifican si ambos operandos hacen referencia a la misma ubicación en la memoria, es decir, si son el mismo objeto. Esto significa que dos objetos con el mismo contenido serán considerados distintos a menos que sean el mismo objeto en memoria.

const obj1 = { nombre: "Juan" };
const obj2 = { nombre: "Juan" };
console.log(obj1 === obj2); // false (diferentes referencias en memoria)

Object.is()

El método Object.is() determina si dos valores son iguales.

Object.is(valor1, valor2);

Este método devuelve un valor de tipo {js}Boolean indicando si los valores pasados como parámetros son iguales o no.

Esta comparación no es igual a la que realiza el operador ==. El operador == aplica varias coerciones(comprobaciones) en ambos sentidos (si no tienen el mismo {ts}Type) antes de probar la igualdad (lo que resulta en comportamientos como {js}"" == false siendo {js}true), pero {js}Object.is no obliga a ninguno de los valores.

Esta tampoco es igual a la que realiza el operador ===. El operador === (y el operador ==) trata los valores -0 y +0 como iguales, y además, trata Number.NaN como no igual a NaN.

Object.is("foo", "foo"); // true
Object.is(window, window); // true
 
Object.is("foo", "bar"); // false
Object.is([], []); // false
 
var test = { a: 1 };
Object.is(test, test); // true
 
Object.is(null, null); // true
 
// Special Cases
Object.is(0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0 / 0); // true