JavaScript
Igualdad y comparaciones
Analiza igualdad estricta y no estricta, comparación de objetos, NaN, fechas, decimales y criterios de igualdad según el dominio.
- Última actualización
- Actualizada
- Nivel
- Fundamentos
- Fundamentos de programación
JavaScript
Analiza igualdad estricta y no estricta, comparación de objetos, NaN, fechas, decimales y criterios de igualdad según el dominio.
Comparar valores significa responder preguntas como “¿son iguales?”, “¿cuál es mayor?” o “¿se trata del mismo objeto?”. En JavaScript, el resultado depende del operador y del tipo de los valores.
10 === 10; // true
10 === "10"; // falseLa igualdad estricta compara el tipo y el valor sin realizar coerción.
5 === 5; // true
5 === "5"; // false
true === 1; // false
null === null; // trueEn la mayoría del código, === debe ser la opción por defecto porque su comportamiento es más directo y predecible.
5 !== "5"; // true
5 !== 5; // falseExpresa que los valores no son estrictamente iguales.
== permite que JavaScript convierta tipos antes de comparar.
5 == "5"; // true
false == 0; // true
"" == 0; // true
null == undefined; // trueEste comportamiento puede ser útil en casos muy concretos, pero también hace que el lector necesite conocer las reglas de coerción para entender una línea aparentemente sencilla.
Por claridad, usa === salvo que exista una razón deliberada y documentada para usar ==.
null == undefined; // true
null === undefined; // falseLa igualdad no estricta considera equivalentes null y undefined, pero no los iguala con otros valores falsy.
null == 0; // false
null == ""; // falseEn ocasiones se utiliza este patrón para comprobar ambas ausencias:
if (value == null) {
// value es null o undefined.
}Es un uso válido si el equipo conoce y acepta esta regla. Una versión más explícita es:
if (value === null || value === undefined) {
// Ausencia de valor.
}Los primitivos se comparan por su valor.
"Nico" === "Nico"; // true
25 === 25; // true
true === true; // truePara strings, la comparación distingue mayúsculas y minúsculas:
"JavaScript" === "javascript"; // falseCuando la comparación debe ignorar el formato, primero normaliza:
const left = " JavaScript ".trim().toLowerCase();
const right = "javascript".trim().toLowerCase();
left === right; // trueLos objetos se comparan por identidad de referencia, no por su contenido.
{} === {}; // false
[] === []; // falseCada literal crea un objeto diferente.
const user = { name: "Nicolás" };
const sameUser = user;
user === sameUser; // trueDos objetos con las mismas propiedades siguen siendo distintos:
const first = { name: "Nicolás" };
const second = { name: "Nicolás" };
first === second; // falseSi necesitas comparar contenido, define qué significa igualdad en ese contexto:
function haveSameIdentity(first, second) {
return first.id === second.id;
}const first = { id: "user-1", name: "Nicolás" };
const second = { id: "user-1", name: "Nico" };
haveSameIdentity(first, second); // true10 > 5; // true
10 < 5; // false
10 >= 10; // true
10 <= 9; // falseAlgunos decimales no pueden representarse exactamente en binario:
0.1 + 0.2 === 0.3; // falseconsole.log(0.1 + 0.2); // 0.30000000000000004Para comparar resultados decimales puede utilizarse una tolerancia:
function areClose(first, second, tolerance = Number.EPSILON) {
return Math.abs(first - second) < tolerance;
}
areClose(0.1 + 0.2, 0.3); // trueEn dinero, suele ser más seguro trabajar con unidades enteras como centavos:
const priceInCents = 1999;
const discountInCents = 500;
priceInCents - discountInCents === 1499; // trueNaN === NaN; // falsePara comprobar NaN:
Number.isNaN(NaN); // true
Number.isNaN("producto"); // falseNo uses la función global isNaN sin conocer su coerción:
isNaN("producto"); // true
Number.isNaN("producto"); // falseNumber.isNaN pregunta si el valor ya es exactamente NaN.
Object.is es similar a ===, pero maneja de forma distinta dos casos especiales:
Object.is(NaN, NaN); // true
Object.is(0, -0); // false
NaN === NaN; // false
0 === -0; // trueNo reemplaza normalmente a ===, pero ayuda cuando esos casos importan. React utiliza una comparación basada en Object.is para decidir si ciertos valores cambiaron.
Dos objetos Date diferentes no son iguales aunque representen el mismo instante:
const first = new Date("2026-07-23");
const second = new Date("2026-07-23");
first === second; // falseCompara sus marcas de tiempo:
first.getTime() === second.getTime(); // trueLos operadores relacionales comparan strings según sus unidades de código, lo cual no siempre coincide con el orden alfabético esperado por una persona.
"10" < "2"; // trueSe comparan como texto: primero "1" contra "2".
Para ordenar texto visible para usuarios:
const names = ["Álvaro", "Ana", "Nicolás"];
names.sort((a, b) => a.localeCompare(b, "es"));== sin considerar la coerción.===.NaN con ===.=== compara sin coerción y debe ser la opción habitual.== aplica reglas de conversión antes de comparar.NaN se comprueba con Number.isNaN.Object.is resuelve los casos especiales de NaN y -0.getTime.Predice los resultados:
5 == "5";
5 === "5";
null == undefined;
null === undefined;
[] === [];
NaN === NaN;
Object.is(NaN, NaN);5 == "5"; // true
5 === "5"; // false
null == undefined; // true
null === undefined; // false
[] === []; // false
NaN === NaN; // false
Object.is(NaN, NaN); // trueOperadores reúne las herramientas que permiten calcular, asignar, comparar y combinar valores una vez entendidas sus reglas.