JavaScript Resumen igualdad / desigualdad y conversión de tipos


Ejemplo

El problema

Los operadores abstractos de igualdad y desigualdad ( == y != ) Convierten sus operandos si los tipos de operandos no coinciden. Este tipo de coerción es una fuente común de confusión sobre los resultados de estos operadores, en particular, estos operadores no siempre son transitivos como se podría esperar.

"" ==  0;     // true A
 0 == "0";    // true A
"" == "0";    // false B
false == 0;   // true
false == "0"; // true

"" !=  0;     // false A
 0 != "0";    // false A
"" != "0";    // true B
false != 0;   // false
false != "0"; // false

Los resultados comienzan a tener sentido si considera cómo JavaScript convierte las cadenas vacías en números.

Number("");    // 0
Number("0");   // 0
Number(false); // 0

La solución

En la declaración false B , ambos operandos son cadenas ( "" y "0" ), por lo tanto no habrá conversión de tipos y como "" y "0" no tienen el mismo valor, "" == "0" es false como se esperaba.

Una forma de eliminar el comportamiento inesperado aquí es asegurarse de que siempre compare operandos del mismo tipo. Por ejemplo, si desea que los resultados de la comparación numérica use conversión explícita:

var test = (a,b) => Number(a) == Number(b); 
test("", 0);        // true;
test("0", 0);       // true
test("", "0");      // true;
test("abc", "abc"); // false as operands are not numbers 

O, si quieres comparación de cadenas:

var test = (a,b) => String(a) == String(b);
test("", 0);   // false;
test("0", 0);  // true
test("", "0"); // false;

Nota al margen : ¡El Number("0") y el new Number("0") no son lo mismo! Mientras que el primero realiza una conversión de tipo, el segundo creará un nuevo objeto. Los objetos se comparan por referencia y no por valor, lo que explica los resultados a continuación.

Number("0") == Number("0");         // true;
new Number("0") == new Number("0"); // false 

Finalmente, tiene la opción de utilizar operadores de igualdad y desigualdad estrictos que no realizarán conversiones de tipo implícitas.

"" ===  0;  // false
 0 === "0"; // false
"" === "0"; // false

Más referencia a este tema se puede encontrar aquí:

¿Qué operador igual (== vs ===) se debe usar en las comparaciones de JavaScript? .

Igualdad abstracta (==)