Nivel inicial9 min de lectura · Publicado el

Diferencias entre == y === en JavaScript (y Object.is)

Diferencia entre == y === en JavaScript: comparando 1 y "1", el cajero de === dice false y el de ==, que convierte antes, true. Usa ===: no convierte tiposrubentejera.com 1"1"===false==true"1"1
Dos cajeros comparan el número 1 y la cadena "1". El de === mira valor y tipo: false. El de == convierte la cadena en número antes: true, y con reglas raras, como 0 == "" → true. Usa === y !==.

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 == "" y 0 == "0" son true, pero "" == "0" es false. 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" == true es false. El booleano se convierte en número (true pasa a 1) 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:

  1. Si los dos valores son del mismo tipo, los compara sin convertir, igual que ===.
  2. Si uno es null o undefined, solo es igual si el otro también es null o undefined.
  3. Si uno es un objeto y el otro un primitivo, convierte el objeto en primitivo.
  4. Si uno es booleano, lo convierte en número (true a 1, false a 0) y vuelve a comparar.
  5. Si uno es número y el otro cadena, convierte la cadena en número.
  6. Si uno es número o cadena y el otro BigInt, compara su valor matemático.
Cómo deciden === y ==. Con ===, si los tipos son diferentes, no son iguales: no hay conversión; si no, compara sin convertir. Con ==, paso a paso: 1, si son del mismo tipo, compara sin convertir, igual que ===; 2, si uno es null o undefined, solo es igual si el otro también lo es; 3, si uno es un objeto y el otro un primitivo, convierte el objeto en primitivo; 4, si uno es booleano, lo convierte en número y vuelve a comparar; 5, si uno es número y el otro cadena, convierte la cadena en número; 6, si uno es número o cadena y el otro BigInt, compara su valor matemático.
Arriba, ===: 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é hace Number con cada texto, frente a parseInt, lo tienes en parseInt o Number.
  • La excepción aceptada: x == null para comprobar a la vez null y undefined.
  • 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.is y qué usan indexOf e includes.
  • 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 da SyntaxError.