Operadores de Comparación

Conoces los operadores de comparación de la clase de matemáticas, pero vamos a refrescar tu conocimiento:

Operador mayor que (a > b) devuelve true si el operando de la izquierda es mayor que el operando de la derecha.

Sintaxis:

a > b

Ejemplo del operador mayor que:

Javascript Greater than operator

console.log(7 > 4); // true

Operador menor que (a < b) devuelve true si el operando de la izquierda es menor que el operando de la derecha.

Sintaxis:

a < b

Ejemplo del operador menor que:

Javascript less than operator

console.log(4 < 7); // true

Operador mayor o igual que (a >= b) devuelve true si el operando de la izquierda es mayor o igual que el operando de la derecha.

Sintaxis:

a >= b

Ejemplo del operador mayor o igual que:

jJvascript Greater than or equal operator

console.log(7 >= 4); // true console.log(4 >= 4); // true

Operador menor o igual que (a <= b) devuelve true si el operando de la izquierda es menor o igual que el operando de la derecha.

Sintaxis:

a <= b

Ejemplo del operador menor o igual que:

Javascript less than or equal operator

console.log(4 <= 7); // true console.log(4 <= 4); // true

El operador de igualdad (a == b) convierte los operandos si no son del mismo tipo, luego aplica una comparación estricta. Si ambos operandos son objetos, JavaScript compara las referencias internas que son iguales cuando los operandos se refieren al mismo objeto en memoria.

Sintaxis:

a == b

Ejemplo del operador de igualdad:

Javascript equality operator

console.log(1 == 1); // true console.log("2" == 2); // true console.log(3 == '3'); // true console.log(0 == false); // true console.log(0 == null); // false console.log(0 == undefined); // false console.log(null == undefined); // true

Si los operandos no son iguales, el operador de desigualdad (!=) devuelve true. Cuando dos operandos no son del mismo tipo, JavaScript intenta convertir los operandos a un tipo apropiado para la comparación.

Si ambos operandos son objetos, JavaScript compara referencias que no son iguales, cuando los operandos se refieren a diferentes objetos en memoria.

Sintaxis:

a != b

Ejemplo del operador de desigualdad:

Javascript inequality operator

console.log(1 != 2) ; // true console.log(2 != "2"); // false console.log(3 != '3' ); // false console.log(1 != true); // false console.log(0 != false); // false

Boolean es el resultado

Una comparación devuelve un valor como cualquier otro operador. El valor, en este caso, es un boolean.

true es "sí", "correcto" o "la verdad";
false es "no", "incorrecto" o "no es la verdad".

Comparison operator in javascript

console.log( 3 > 1 ); // true (correct) console.log( 3 == 1 ); // false (wrong) console.log( 3 != 1 ); // true (correct)

El resultado de una comparación puede asignarse a una variable, como cualquier valor:

Comparison operator javascript

let result = 7 > 4; // the result of the comparison console.log ( result ); // true

Comparación de cadenas

JavaScript utiliza el orden "diccionario" o "lexicográfico" para ver si una cadena es mayor que otra. En otras palabras, las cadenas se comparan letra por letra.

Ejemplo de la comparación de cadenas:

The string comparison in javascript

console.log( 'Z' > 'A' ); // true console.log( 'Want' > 'Walk' ); // true console.log( 'Too' > 'To' ); // true

En los ejemplos la comparación 'Z' > 'A' llega a un resultado en el primer paso mientras que las cadenas "Want" y "Walk" se comparan carácter por carácter:

W es igual a W.
a es igual a a.
n es mayor que l.

Comparación de diferentes tipos

Para comparar valores de diferentes tipos, JavaScript convierte los valores a números.

The comparison of different types in javascript

console.log( '3' > 1 ); // true, string '3' becomes a number 3 console.log( '02' == 2 ); // true, string '02' becomes a number 2

Para los valores booleanos, true se convierte en 1, false se convierte en 0.

Comparison of different types in javascript

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

Igualdad estricta

Un problema con la comprobación de igualdad regular == es que no puede diferenciar 0 de false:

The regular equality == in javascript

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

Nos encontramos con lo mismo con una cadena vacía:

The regular equality == in javascript

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

Comparación con null y undefined

Un comportamiento no intuitivo es cuando null o undefined se comparan con otros valores. Para una comprobación de igualdad estricta ===. Estos valores son diferentes, ya que cada uno de ellos es de un tipo diferente.

The strict equality === in javascript

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

Para una comprobación no estricta ==

Estos dos son una "pareja dulce", significa que se igualan entre sí.

The regular equality == in javascript

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

La diferencia entre == y ===

JavaScript tiene dos formas visiblemente similares, pero muy diferentes de probar la igualdad:

== (Operador de doble igual): el operador de igualdad o comparación abstracta

=== (Operador de triple igual): el operador de identidad o comparación estricta

Aquí están las diferencias entre == y ===:

antes de mostrar la comparación == convierte los valores de las variables al mismo tipo;
=== no hace ninguna conversión de tipo y devuelve true solo si ambos valores y tipos son idénticos para las dos variables que se comparan.

== and === equality in javascript

var val1 = 13; var val2 = 13; console.log(val1 == val2); // true console.log(val1 === val2); // also true

Para matemáticas y otras comparaciones < > <= >=

Null/undefined se convierten en números, aquí null se convierte en 0, undefined se convierte en NaN.

Te presentamos algunas cosas divertidas que ocurren cuando aplicamos estas reglas. Y también, cómo no caer en una trampa con ellos.

Resultado extraño: null vs 0

Ejemplo de la comparación de null con un cero:

Compare null with a zero in javascript

console.log( null > 0 ); // (1) false console.log( null == 0 ); // (2) false console.log( null >= 0 ); // (3) true

Matemáticamente, eso es extraño. El último resultado dice que "null es mayor o igual a cero", significa que en una de las comparaciones anteriores debe ser verdadero, pero ambas son falsas.

La razón principal es que una comprobación de igualdad == y comparaciones > < >= <= funcionan de diferente manera: las comparaciones convierten null en un número, tratándolo como 0. Esa es la razón por la que (3) null >= 0 es verdadero y (1) null > 0 es falso.

Pero por otro lado, la comprobación de igualdad == para undefined y null está definido sin ninguna conversión. Se igualan entre sí y no se igualan a nada más, por eso (2) null == 0 es falso.

Un undefined incomparable

No podemos comparar el valor undefined con otros valores:

Compare the value with undefined in javascript

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

Las razones por las que obtenemos estos resultados son:

Las comparaciones (1) y (2) devuelven falso, ya que undefined se convierte en NaN, es un valor numérico especial que devuelve falso para todas las comparaciones.
La comprobación de igualdad (3) devuelve falso, ya que aquí undefined sólo es igual a null, undefined y ningún otro valor.

Hora del Cuestionario: ¡Pon a Prueba Tus Habilidades!

¿Listo para desafiar lo que has aprendido? Sumérgete en nuestros cuestionarios interactivos para una comprensión más profunda y una forma divertida de reforzar tu conocimiento.