Comparaciones JavaScript

Las comparaciones en JavaScript son más traicioneras de lo que parecen. Aunque a menudo se enseñan como simples operadores, en realidad abren la puerta a uno de los temas más confusos del lenguaje: la coerción de tipos y las referencias.

Este fundamental expande lo que vimos brevemente en el módulo de operadores.

Igualdad débil (==) y desigualdad débil (!=)

Realizan coerción de tipo antes de comparar. Esto significa que convierten los operandos para que "encajen" antes de decidir si son iguales.

console.log(5 == '5');       // true
console.log(null == undefined); // true
console.log(false == 0);     // true
console.log('' == 0);        // true

Esta coerción sigue una tabla interna compleja que no es intuitiva.

Por eso se dice que == puede parecer que funciona, hasta que no.

Igualdad estricta (===) y desigualdad estricta (!==)

Comparan sin convertir tipos: tipo y valor deben ser exactamente iguales.

console.log(5 === '5');     // false
console.log(null === undefined); // false
console.log(false === 0);   // false

Pero cuidado: con objetos, arrays y funciones, incluso === compara referencias, no contenido.

console.log([] === []);        // false
console.log({} === {});        // false
let a = [1, 2];
let b = a;
console.log(a === b);          // true

¿Por qué [] === [] da false?

Porque cada array es un objeto distinto en memoria. Aunque su contenido sea igual, no son el mismo objeto. En JavaScript, recuerda: los objetos se comparan por referencia, no por valor.

Comparaciones con null y undefined

console.log(null == undefined);  // true
console.log(null === undefined); // false

• == los considera iguales porque ambos representan "ausencia de valor".
• === los considera distintos porque sus tipos son distintos (null es un objeto*, undefined es... undefined).

Este caso causa errores cuando esperas detectar "valor no definido" y usas == sin entender lo que incluye.

Comparaciones con NaN

NaN (Not a Number) no es igual a sí mismo.

console.log(NaN === NaN);         // false
console.log(Number.isNaN(NaN));   // true

Esto rompe la intuición: ningún otro valor en JS se comporta así. Si estás comparando cosas que podrían contener NaN, usa el método Number.isNaN().

Comparaciones con 0, false, '' (valores falsy)

console.log(0 == false);     // true
console.log('' == false);    // true
console.log('' == 0);        // true

Esto vuelve especialmente peligrosas las comparaciones con ==.

En un formulario, por ejemplo, input == false puede atrapar más cosas de las que esperas.

Comparaciones con Object.is()

Object.is() es como === pero con algunas diferencias sutiles:

console.log(Object.is(NaN, NaN));     // true
console.log(Object.is(0, -0));        // false
console.log(0 === -0);                // true

• Detecta NaN como igual a sí mismo.
• Distingue entre 0 y -0.

En casos extremos o en validaciones críticas, Object.is() es más preciso.

Comparaciones relacionales (<, >, etc.)

Cuando haces comparaciones como <, >, <=, >=, JavaScript convierte los valores a número (si no son strings comparables).

Esto puede dar resultados muy raros:

console.log(null < 1);        // true
console.log(undefined < 1);   // false

Caso: null < 1

• En comparaciones relacionales, null se convierte a 0.
• Así que: 0 < 1 → true.

Pero atención:

console.log(null == 0); // false

• Aquí no hay conversión a número. Solo undefined == null es true.

Caso: undefined < 1

• undefined se convierte a NaN en contextos numéricos.
• Y cualquier comparación con NaN siempre da false.

console.log(undefined < 1); // false
console.log(undefined > 1); // false
console.log(undefined == 0); // false

Reglas clave

• null → 0 en comparaciones numéricas.
• undefined → NaN en comparaciones numéricas.
• Comparar con NaN siempre da false.

console.log(null < 1);        // true
console.log(null >= 0);       // true
console.log(undefined < 1);   // false
console.log(undefined == null); // true

Comparación de referencia vs valor

• Los primitivos (number, string, boolean, null, undefined, symbol, bigint) se comparan por valor.
• Los objetos (arrays, function, object) se comparan por referencia.

let a = { name: 'Juan' };
let b = { name: 'Juan' };

console.log(a === b); // false

Aunque el contenido sea igual, los objetos están en espacios distintos de memoria.

Comparación de strings

Si comparas dos strings, se compara carácter a carácter según su orden Unicode:

console.log('apple' < 'banana'); // true
console.log('2' < '10');         // false → because '2' comes after '1' in Unicode

Evita comparar strings numéricos con <, >.

Comparar objetos

Cuando comparas objetos con == o ===, estás comparando referencias, no contenido:

let a = { age: 30 };
let b = { age: 30 };
let c = a;

console.log(a === b); // false → distintos objetos
console.log(a === c); // true → misma referencia

truthy y falsy en comparaciones

Recuerda que en contextos booleanos, ciertos valores son considerados falsy:

• false, 0, '', null, undefined, NaN.

Todo lo demás es truthy.

Esto puede producir comparaciones engañosas:

console.log([] == false);        // true (!)
console.log('' == 0);            // true (!)
console.log([] == ![]);          // true (!)

• [] es un array vacío → en coerción a boolean, se considera true.
• false ya es un boolean.
• Pero como es ==, JavaScript convierte ambos operandos a número:
  • [] → '' → 0 (array vacío → string vacío → número 0).
  • false → 0
  • Resultado: 0 == 0 → true

Enlaces útiles

• MDN - Comparisons and equality
• JavaScript Equality Table
• MDN - Relational operators
• Explained Visually: == vs ===