Cual es la diferencia entre == y === ? JavaScript


Estar haciendo comparaciones es algo que se usa día a día en la programación y a pesar que son muy usadas, es muy importante dejar en claro como funcionan, hay una confusión muy común entre el uso de == y === y en este articulo veremos cuando usar cada caso.

Primero definamos los términos, string equals: El doble signo de igual es oficialmente conocido como el operador de comparación de igualdad mientras que el triple signo de igual es conocido como operador de comparación de igualdad estricta .

Veamos el siguiente ejemplo:

console.log(3 == “3”); // true
console.log(3 === “3”); // false.

Usar dos signos de igual (==) regresa true por que el string 3 es convertido a el numero 3 antes de que la comparacion sea hecha. los tres signos de igual (===) ve que los tipos de dato son diferentes y regresa false.

console.log(true == ‘1’); // true
console.log(true === ‘1’); // false

De nuevo, (==) hace una conversión de tipo, en este caso ambos el booleano true y el sting 1 son convertidos al numero 1

Hay algunos escenarios donde el comportamiento de estos operadores no es intuitivo, veamos mas ejemplos:

console.log(undefined == null); // true
console.log(undefined === null); // false. Undefined y null son distintos tipos y no son intercambiables.
console.log(true == ‘true’); // false. Un string no va a ser convertido a boolean o viceversa.
console.log(true === ‘true’); // false

El ejemplo de abajo es interesante por que ilustra que los string literals son diferentes a los string objects.

console.log(“This is a string.” == new String(“This is a string.”)); // true
console.log(“This is a string.” === new String(“This is a string.”)); // false

Para analizar por que el modo de igualdad estricto regreso false veamos lo siguiente::

console.log(typeof “This is a string.”); // string
console.log(typeof new String(“This is a string.”)); //object

El nuevo operador siempre regresa un objeto por lo cual al hacerlo estricto identifica diferentes tipos.

Tipos referencias

Hablando de objetos, que pasa si queremos comparar arrays y objetos ,Las comparaciones == y === funcionan de la misma manera pero debemos tener en cuenta una regla importante

Cuando comparamos tipos arreglos y objetos(tipos referenciados) en cualquiera de los dos modos de comparación va a regresar false a menos de que los dos sean exactamente el mismo.

var a = [];
var b = [];
var c = a;
console.log(a == b); // false
console.log(a === b); // false
console.log(a == c); // true
console.log(a === c); // true

Entonces cual debería de usar?

Hay que mantenerlo estricto (===) usando el operador de igualdad estricto incrementa la claridad del código y previene posibles bugs o errores en comparaciones.Mientras mas explicito sea el código, sera mejor.


Otras lecturas

Para mas información en este tema, puedes leer ECMAScript Language Specification. y también ver la nifty table showing con todos los tipos posibles de comparaciones.

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.