Operadores de igualdad en JavaScript: == vs === y Object.is

Las dos formas de preguntar "¿esto es igual?"

En JavaScript tenemos dos operadores de igualdad: === (estricta) y == (débil o con coerción). A simple vista parecen lo mismo, pero su comportamiento es muy distinto.

=== verifica que ambos operandos sean del mismo tipo y del mismo valor. En cambio, == primero convierte los operandos a un tipo común y luego compara. Esa conversión —la coerción de tipos— es la responsable de casi toda la mala fama que arrastra la igualdad en JavaScript.

En resumen: usa === por defecto. La versión larga vale la pena leerla al menos una vez, para saber a qué estás renunciando cuando eliges el otro.

Igualdad estricta: lo que casi siempre quieres usar

=== devuelve true únicamente cuando ambos lados coinciden en tipo y valor. Sin coerción, sin sorpresas:

Si los tipos no coinciden, el resultado es false al instante. Si coinciden, JavaScript compara los valores. En los primitivos se compara el valor; en los objetos se compara la referencia (ahora entramos en detalle).

!== es el operador de desigualdad estricta y aplica las mismas reglas, pero al revés.

Igualdad débil: coerción de tipos disfrazada

== permite que ambos lados sean de tipos distintos. Antes de comparar, hace todo un baile de coerción para intentar que encajen:

Las reglas exactas están en la especificación y no son horribles, pero recordarlas en plena depuración ya es otra historia. Que "0" == false dé true pilla desprevenidos incluso a desarrolladores con experiencia. Lo mismo pasa con [] == false (también true, porque el array se convierte a "", que a su vez se convierte a 0).

Por eso la mayoría de las guías de estilo —y la regla eqeqeq de ESLint— recomiendan usar === por defecto. Tecleas un carácter más a cambio de reglas que sí puedes recordar.

El único patrón útil con ==

Hay un solo idiom de igualdad débil que vale la pena conocer: x == null devuelve true cuando x es null o undefined, y false en cualquier otro caso.

El equivalente estricto es x === null || x === undefined, que funciona pero queda más ruidoso. Muchos proyectos permiten == null como la única excepción aceptada. Elige una regla y aplícala siempre igual.

Los objetos se comparan por referencia

Cuando hablamos de objetos, arrays y funciones, tanto === como == hacen la misma pregunta: "¿Ambos lados apuntan al mismo objeto en memoria?". No preguntan "¿tienen el mismo contenido?".

Dos objetos literales con el mismo contenido siguen siendo dos objetos distintos. A todos nos pilla desprevenidos al menos una vez.

Si lo que quieres es comparar por valor, tienes que escribir tu propio helper, tirar de una librería (lodash.isequal) o, para objetos planos sencillos, serializar con JSON.stringify:

JSON.stringify solo sirve para datos simples: ignora funciones, undefined, símbolos y no garantiza el mismo orden de claves entre motores en todos los casos. Es un truco rápido, no una solución general.

NaN no es igual a nada, ni siquiera a sí mismo

NaN ("not a number") es el valor que devuelve JavaScript cuando una operación numérica no tiene un resultado con sentido: 0/0, Number("abc"), Math.sqrt(-1). Ambos operadores de igualdad devuelven false cuando cualquiera de los lados es NaN, incluso cuando los dos lo son:

Para detectar NaN, usa Number.isNaN(value). Evita la función global isNaN de toda la vida, porque primero convierte su argumento, así que isNaN("hello") devuelve true, algo que casi nunca es lo que buscas.

Object.is: casi como ===, pero con dos matices

Object.is(a, b) se comporta igual que ===, salvo en dos casos puntuales:

La mayoría de las veces === es lo que quieres. Recurre a Object.is solo cuando necesites tratar NaN como igual a sí mismo, o distinguir entre +0 y -0. Ambos casos son poco frecuentes, pero a veces importan: aparecen en código numérico y en internals de frameworks (por ejemplo, React usa Object.is para comparar el estado).

Los operadores de desigualdad siguen la misma lógica

!== es estricto, != es flexible (hace coerción de tipos), y aplica el mismo consejo:

Por defecto, usa !==. Si ya permites == null en tu código, también puedes admitir su contraparte != null para comprobar "ni null ni undefined".

Checklist para comparar valores en JavaScript

Cuando necesites comparar dos valores, repasa esta lista:

• ¿Primitivos del mismo tipo? Usa ===.
• ¿Quieres detectar null o undefined? x == null sirve si tu guía de estilo lo acepta; si no, tira de x === null || x === undefined.
• ¿Necesitas detectar NaN? Number.isNaN(x).
• ¿Comparar objetos por identidad (misma referencia)? === hace justo eso.
• ¿Comparar objetos por contenido? Escribe una función auxiliar, usa una librería o serializa. Los operadores nativos no te van a ayudar aquí.

Quédate con ===, reserva == como herramienta puntual para el caso == null, y te ahorrarás la mayoría de las rarezas de la igualdad en JavaScript que llenan las FAQ del lenguaje.

Siguiente paso: los operadores

La igualdad es solo una parte del repertorio de operadores de JavaScript. En el próximo artículo repasamos el resto: aritméticos, lógicos, de asignación y las versiones abreviadas que vas a usar día a día al programar.