Comparadores de igualdad en JavaScript

Uno de los temas que más sorprender a los usuarios al iniciarse en JavaScript es la existencia de dos operadores de igualdad: el de igualdad abstracta (==) y el de igualdad estricta (===). Algo que no suele existir en otros lenguajes. La principal diferencia de los dos comparadores de igualdad en JavaScript es que == realiza una conversión de tipos mientras que === no lo hace. Por lo que el resultado de los operadores puede ser diferente. Esto es lo que se explicará en más detalle en esta entrada.

La diferencia entre == y === en JavaScript

Como se ha explicado la diferencia entre los operadores == y === es que el primero realiza una conversión de tipos mientras que el segundo no. Pero ¿qué significa esto? El operador de igualdad abstracta (==) al realizar una conversión de tipos compara el contenido de la variable, aunque sean de tipos diferentes. Por ejemplo, cadenas de texto con numéricos o numérico con booleanos. Por otro lado, igualdad estricta (===), al no realizar una conversión de tipos, devuelve falso cuando los tipos no coinciden. Aunque los valores dentro de las variables sean iguales.

Ejemplos de uso de == y === en JavaScript

Para entender la diferencia entre == y === en JavaScript lo mejor es verlo a través de unos ejemplos. En el siguiente trozo de código se muestran diferentes comparaciones y su resultado.

true == 1   // true
true === 1  // false
1 == '1'    // true
1 === '1'   // false
1 == 1      // true
1 === 1     // true

En las dos primeras líneas se comprar un tipo de dato booleano (true) con un tipo numérico (1). Cuando se utiliza el operador == el resultado es verdadero, mientras que al utilizar === se obtienen como resultado falso. Lo que es debido a la conversión de tipos. El operador == convierte automáticamente un tipo en otros y comparar el valor resultante. Por lo que el resultado de la primera comparación es verdadero. Por otro lado, al no coincidir los tipos en el operador === el resultado es falso.

En la tercera y cuarta línea se puede ver cómo funcionan los operadores cuando se comparan un valor numérico con una cadena de caracteres. Como en el caso anterior, el operador == devuelve verdadero, aunque los tipos de datos sean diferentes. Por otro lado, el operador === solamente devuelve verdadero cuando es el mismo tipo de dato.

Finalmente, en la dos últimas líneas se puede ver que cuando el tipo de dato es el mismo los dos operadores ofrecen el mismo resultado.

Los operadores desigualdad: !=y !==

En JavaScript también existe dos operadores para evaluar la desigualdad de dos variables. Al igual que en el caso anterior el operador de desigualdad abstracta (!=) realiza una conversión de tipos mientras que el operador de desigualdad estricta (!==) no. Una comparativa de los resultados esperados con estos operadores se puede ver en el siguiente ejemplo.

true != 1   // false
true !== 1  // true
1 != '1'    // false
1 !== '1'   // true
1 != 1      // false
1 !== 1     // true

Conclusiones

En esta entrada se ha visto la diferencia que existe entre los comparadores de igualdad en JavaScript. Viendo el funcionamiento de cada uno. A la hora de trabajar la mejor opción es utilizar siempre los operadores de igualdad estrictos para tener un código más fiable. Incluso si es necesario la conversión de tipos. Siendo aconsejable hacer esta conversión de forma explícita para mejorar la legibilidad del código.

Imágenes: Pixabay (fancycrave1)