Diferencias entre == y === en JavaScript (y Object.is)
JavaScript tiene dos operadores para preguntar «¿son iguales?», y no responden lo mismo. 1 == "1" dice que sí; 1 === "1" dice que no. Si no sabes por qué, tarde o temprano un if hará algo que no esperabas.
La diferencia está en una sola cosa: si JavaScript convierte los tipos antes de comparar.
Piensa en dos cajeros que comparan precios. El primero (===) mira la cantidad y la moneda: 10 euros y 10 dólares no son lo mismo. El segundo (==) intenta pasarlo todo a la misma moneda antes de comparar. Suena cómodo, pero su tabla de cambio es muy rara: para él, una cadena vacía vale lo mismo que el número cero. El símil se queda corto en eso: las conversiones de == no siempre tienen sentido intuitivo, y por eso conviene evitarlas.
Qué significa === (y !==): comparación estricta
Si los dos valores tienen tipos diferentes, no son iguales. No hay conversión.
1 === "1" // false: número frente a cadena
1 !== "1" // true
null === undefined // false: son tipos distintos
"hola" === "hola" // true
!== es el contrario de ===: devuelve true cuando los valores no son estrictamente iguales. Dicho de otra forma, !== significa «distinto en valor o en tipo».
== y !=: comparación débil
Si los tipos son diferentes, JavaScript intenta convertirlos para que sean comparables. A esto se le llama coerción de tipos.
1 == "1" // true: convierte "1" en el número 1
1 != "1" // false
null == undefined // true
null == false // false (aunque parezca que sí)
!= es el contrario de ==: significa «distinto de», pero convierte los tipos antes de comparar, igual que ==. La pareja es == con != y === con !==.
Tabla de casos, probada en Node 24
Estos son los casos que más sorprenden. Todos se han ejecutado en Node 24.21.0; la salida es la real.
| Comparación | == |
=== |
Object.is |
|---|---|---|---|
1 y "1" |
true |
false |
false |
0 y "" |
true |
false |
false |
0 y "0" |
true |
false |
false |
"" y "0" |
false |
false |
false |
0 y false |
true |
false |
false |
"1" y true |
true |
false |
false |
"true" y true |
false |
false |
false |
null y undefined |
true |
false |
false |
null y false |
false |
false |
false |
null y 0 |
false |
false |
false |
NaN y NaN |
false |
false |
true |
0 y -0 |
true |
true |
false |
[] y false |
true |
false |
false |
[] y "" |
true |
false |
false |
[1] y 1 |
true |
false |
false |
{} y {} |
false |
false |
false |
1n (BigInt) y 1 |
true |
false |
false |
Fíjate en dos detalles:
0 == ""y0 == "0"sontrue, pero"" == "0"esfalse. Con==, la igualdad ni siquiera es transitiva: que A sea igual a B y B igual a C no garantiza que A sea igual a C."true" == trueesfalse. El booleano se convierte en número (truepasa a1) y la cadena"true"no es un número.
Puedes reproducir la tabla con este script (guárdalo como casos.mjs y ejecuta node casos.mjs):
const casos = [
['1', '"1"', 1, "1"],
['0', '""', 0, ""],
['NaN', 'NaN', NaN, NaN],
['0', '-0', 0, -0],
['[]', 'false', [], false],
['{}', '{}', {}, {}],
];
for (const [a, b, x, y] of casos) {
console.log(`${a} y ${b}: == ${x == y} | === ${x === y} | Object.is ${Object.is(x, y)}`);
}
Los casos raros, uno a uno
null y undefined
Con ==, null y undefined solo son iguales entre sí y a nada más. Por eso null == false y null == 0 dan false.
Esto tiene un uso práctico: x == null es una forma corta de preguntar «¿x es null o undefined?».
let x = null;
x == null // true
x = undefined;
x == null // true
Cuidado con mezclarlo con < o >=, que siguen otras reglas: null == 0 es false, pero null >= 0 es true.
NaN
NaN («not a number», lo que sale de operaciones como 0 / 0) no es igual a nada, ni a sí mismo, ni con == ni con ===. Para saber si algo es NaN, usa Number.isNaN(valor).
Esto también afecta a los arrays: [NaN].indexOf(NaN) devuelve -1 porque usa ===, mientras que [NaN].includes(NaN) devuelve true porque usa otra comparación que sí trata NaN como igual a sí mismo.
0 y -0
JavaScript tiene un cero positivo y uno negativo. === los considera iguales, aunque se comportan distinto: 1 / -0 es -Infinity. Casi nunca importa, pero si necesitas distinguirlos, usa Object.is.
Cadenas y números
Al comparar un número con una cadena, == convierte la cadena en número. La cadena vacía "" se convierte en 0, y por eso 0 == "" es true. Si la cadena no es un número ("hola"), se convierte en NaN y la comparación da false.
Objetos y arrays
Con objetos, == y === no miran el contenido, sino si son el mismo objeto. Dos objetos con los mismos datos son distintos si se crearon por separado:
const a = { nombre: 'Ana' };
const b = a; // b apunta al mismo objeto
const c = { nombre: 'Ana' }; // otro objeto con el mismo contenido
a === b // true
a === c // false
a == c // false
Es como dos llaves: comparar con === no pregunta si abren puertas parecidas, sino si son la misma llave. Si quieres repasar qué es un objeto, lo explico en Qué es un objeto en JavaScript, y la diferencia entre referencia y copia, en Paso por referencia y paso por valor en JavaScript.
Cuando comparas un objeto con un valor primitivo (número, cadena…), == convierte el objeto en primitivo. Un array vacío se convierte en "", y por eso [] == false acaba siendo true. === no hace nada de esto.
¿Y Object.is?
Object.is(a, b) funciona como ===, con dos diferencias: considera NaN igual a NaN y distingue 0 de -0. No convierte tipos.
NaN y NaN |
0 y -0 |
Convierte tipos | |
|---|---|---|---|
== |
false |
true |
Sí |
=== |
false |
true |
No |
Object.is |
true |
false |
No |
En el día a día te basta con ===. Object.is sirve para esos dos casos límite.
¿Y la diferencia entre = y ==?
= no compara: asigna un valor a una variable. == y === comparan y devuelven true o false.
let edad = 18; // asigna 18 a edad
edad === 18 // compara: true
Si escribes if (edad = 20) por error, no compruebas nada: asignas 20 y el if siempre entra.
Cómo decide ==, resumido
La especificación de JavaScript (ECMAScript) define == con un algoritmo llamado IsLooselyEqual. Este es el resumen que da MDN:
- Si los dos valores son del mismo tipo, los compara sin convertir, igual que
===. - Si uno es
nulloundefined, solo es igual si el otro también esnulloundefined. - Si uno es un objeto y el otro un primitivo, convierte el objeto en primitivo.
- Si uno es booleano, lo convierte en número (
truea 1,falsea 0) y vuelve a comparar. - Si uno es número y el otro cadena, convierte la cadena en número.
- Si uno es número o cadena y el otro BigInt, compara su valor matemático.
===: una sola pregunta, sin conversiones. Abajo, ==: baja por la columna de preguntas hasta el primer «sí» y aplica lo que dice su derecha.Regla práctica
Usa === y !==. Si necesitas convertir, hazlo tú y que se vea.
- Por defecto,
===y!==. - Si te llega un número como texto (de un formulario, por ejemplo), conviértelo de forma explícita:
Number(entrada) === 18. Así quien lea el código sabe qué pasa. Qué haceNumbercon cada texto, frente aparseInt, lo tienes en parseInt o Number. - La excepción aceptada:
x == nullpara comprobar a la veznullyundefined. - Si dudas de qué hace una comparación, escribe un test pequeño que lo compruebe. Es la forma más rápida de salir de dudas, y la duda queda resuelta para el siguiente que lea el código.
Para más trampas de este tipo, mira los 10 errores más comunes en proyectos de JavaScript.
Fuentes
- MDN, Equality comparisons and sameness, revisada el 27 de septiembre de 2026: algoritmos de
==,===,Object.isy qué usanindexOfeincludes. - Especificación ECMAScript 2027 (borrador), secciones IsLooselyEqual e IsStrictlyEqual. El resumen del algoritmo es el de MDN, no una cita literal de la especificación.
- Todos los ejemplos y la tabla se han ejecutado en Node.js 24.21.0 en Linux.
1 !=== "1"se ha ejecutado también para confirmar que daSyntaxError.