Comparación entre operador '==' y '==='

4 de marzo, 2022

Como se describe en la documentación de MDN, el operador de comparación '==' se encarga de comparar el valor de dos variables, mientras que el operador de igualdad estricta '===' compara que las dos variables son del mismo tipo y tienen el mismo valor.

const a = 2
const b = '2'
console.log(a == b) // true
console.log(a === b) // false

En esta imagen podemos ver la diferencia entre estos operadores. El operador de igualdad estricta no realiza la conversión de tipos mientras que el operador de comparación sí.

El operador de comparación sigue un comportamiento dependiendo del tipo de los operandos.

Objetos

Si los dos operandos son objetos realiza una comparación de las referencias del objeto.

const a = { prop: 'test' }
const b = { prop: 'test' }
const c = a
a == b // false
a === b // false
a == c // true
a === c // true

En este caso, b está apuntando al mismo espacio de memoria que a, por lo que la comparación devolverá true.

Null y undefined

Si un valor es null y el otro undefined, el operador de comparación devuelve true mientras que la comparación de igualdad estricta devuelve false

const a = null
const b = undefined
a == b // true
a === b // false

Valores primitivos de diferente tipo

Si los valores son valores primitivos de diferente tipo, la comparación de igualdad estricta siempre devolverá false porque siempre comprueba que tienen el mismo tipo y valor.

const text = '2'
const num = 2
test === num // false

En cambio, el operador de igualdad intenta convertirlos al mismo tipo antes de comparar:

Al comparar un número con una cadena, convierte la cadena en un valor numérico.

const text = '2'
const num = 2
text == num // true

Si uno de los valores es booleano, convierte el booleano en 0 si es false y en 1 si es true

const a = false
const b = 0
a == b // true
a === b // false

const c = true
const d = 1
c == d // true
c === d // false

Si uno de los valores es un objeto y el otro es un número o una cadena de texto, convierte el objeto en un valor primitivo utilizando los métodos valueOf() y toString() del objeto.

Valores primitivos del mismo tipo

Si los dos valores son valores primitivos del mismo tipo, tanto el operador de comparación (==) como la comparación de igualdad estricta (===) devolverán true si tienen el mismo valor y false sin tienen distinto valor.

const a = 'test'
const b = 'test2'
a == a // true
a === a // true
a == b // false
a === b // false

const c = 1
const d = 2
c == c // true
c === c // true
c == d // false
c === d // false