== vs === en JavaScript: cuál es la diferencia y cómo no romper el código

Introducción: por qué esta pregunta atormenta a miles de desarrolladores

Si alguna vez has escrito en JavaScript, seguro te has encontrado con una situación: tu código no funcionaba como esperabas y la culpa era de los operadores de comparación == y ===. La pregunta "Which equals operator (== vs ===) should be used in JavaScript comparisons?" está entre las más populares en Stack Overflow — millones de desarrolladores la han visto. Y no es casualidad.

La diferencia entre la igualdad no estricta (==) y la estricta (===) es una de las primeras trampas en las que caen los principiantes. Pero incluso los programadores experimentados a veces olvidan los matices. En este artículo analizaremos todas las dificultades, mostraremos con ejemplos reales cómo evitar errores típicos y daremos reglas claras sobre cuándo usar cada uno.

¿Listos? ¡Allá vamos!

1. Conceptos básicos: qué son == y === en JavaScript

Ambos operadores se usan para comparar valores. Pero hay una diferencia clave:

\n
• == (igualdad no estricta) — compara valores con conversión de tipos. Si los tipos son diferentes, JavaScript intenta convertir un valor al tipo del otro y luego comparar.
\n
• === (igualdad estricta) — compara tanto el valor como el tipo de dato sin ninguna conversión. Si los tipos son diferentes — inmediatamente false.
\n

¿Suena simple? Pero el diablo, como siempre, está en los detalles.

Ejemplo para calentar

console.log(5 == "5");   // true (el número 5 se convierte a la cadena "5")\nconsole.log(5 === "5");  // false (tipos diferentes: number vs string)

El primer caso es una trampa clásica: esperas false, pero obtienes true. Y esto es solo el comienzo.

2. Cómo JavaScript convierte tipos: momentos no obvios

Al usar ==, el intérprete ejecuta algoritmos complejos de conversión. Aquí hay algunos ejemplos que pueden sorprender:

Cadenas y números

console.log(0 == false);   // true (false → 0)\nconsole.log("" == false);  // true ("" → 0)\nconsole.log(null == undefined); // true (regla especial)\nconsole.log(null === undefined); // false

Especialmente peligrosos son null y undefined: con == son iguales entre sí, pero no iguales a nada más (ni siquiera a false o 0).

Arrays y objetos

console.log([] == false);   // true (array vacío → "" → 0)\nconsole.log([1] == true);   // true ([1] → "1" → 1)\nconsole.log([1,2] == "1,2"); // true (array → cadena)

Aquí ya se puede perder el hilo de la lógica. Precisamente por estas "sorpresas", muchos desarrolladores rechazan por principio el uso de ==.

3. Errores reales de la práctica: cuando == rompe la lógica

Analicemos varias situaciones que pueden provocar errores en producción.

Error 1: Verificación de vacío

function isEmpty(value) {\n    return value == false; // ¡mal!\n}\n\nconsole.log(isEmpty(0));      // true\nconsole.log(isEmpty(""));     // true\nconsole.log(isEmpty(null));   // true? Sí, null == false → false\nconsole.log(isEmpty([]));     // true? Sí, [] == false → true\nconsole.log(isEmpty("text")); // false\n

Parece que funciona, pero en realidad null no es igual a false con == — esto es false. ¿Y un array vacío se considera true? No, se convierte a 0. Confusión total. La opción correcta es usar una verificación estricta o condiciones explícitas.

Error 2: Comparación con undefined

let user = { name: "Alice" };\nif (user.age == undefined) { // ok, pero mejor ===\n    console.log("Edad no especificada");\n}\n// ¿Pero si age = null?\nuser.age = null;\nconsole.log(user.age == undefined); // true! ¡Debería ser false!\n<