Comparación en

Acerca de Comparación

Comparar números

En JavaScript, los números se pueden comparar con los siguientes operadores relacionales y de igualdad.

El resultado de la comparación siempre es un valor Boolean, es decir, true o false.

1 < 3;
// => true

2 !== 2;
// => false

1 === 1.0;
// => true
// All numbers are floating-points, so this is different syntax
// for the exact same value.

Comparar strings

En JavaScript, los operadores de comparación anteriores también se pueden usar para comparar strings. En ese caso, se aplica un orden de diccionario (lexicográfico). Puedes encontrar una lista del orden exacto de todos los caracteres aquí.

'Apple' > 'Pear';
// => false

'a' < 'above';
// => true

'a' === 'A';
// => false

Tienes que tener cuidado cuando comparas dos variables que parecen contener valores numéricos pero son de tipo string. Debido al orden de diccionario, el resultado no será el mismo que al comparar valores de tipo Number.

10 < 2;
// => false

'10' < '2';
// => true (because "1" comes before "2")

Otra forma de comparar strings es el método localeCompare. Permite establecer diversas opciones para ajustar la manera en que se comparan los strings.

Igualdad estricta

Quizá te preguntes por qué en JavaScript se usan tres signos igual para comprobar la igualdad. === representa la comprobación de igualdad estricta, lo que significa que no se realiza ninguna conversión de tipo y que los valores de tipos distintos siempre son desiguales.

'3' === 3;
// => false
// The value on the left has type string, the value on the right
// has type number.

1 === 1n;
// => false
// The value on the left has type number, the value on the right
// has type bigint.

Usar === y !== es la manera recomendada de comprobar la igualdad en JavaScript.

Evitar la conversión de tipo implícita

También existen == y !=, que representan la comprobación de igualdad débil. Deberías evitarlos, porque aplican una conversión de tipo implícita antes de realizar la comparación. Los resultados en estos casos son difíciles de predecir y, a veces, no son lo que esperarías. Puedes leer más sobre ello aquí.

0 == false;
// => true

En teoría, también puedes comparar valores de tipos distintos (por ejemplo, "1" < 2). Entonces los valores se convertirán implícitamente para determinar si el resultado es verdadero o falso. Al igual que la comprobación de igualdad débil, esto tampoco se recomienda por el mismo motivo mencionado antes.

¿Qué deberías hacer en su lugar? Puedes aplicar una conversión de tipo explícita. Con eso, puedes asegurarte de que los valores tengan el tipo correcto antes de realizar la comparación. Así, tu código será más fácil de entender y menos propenso a errores.