Conocemos muchos operadores de comparación de matemáticas.
En JavaScript están escritos así:
Mayor/menor que: a > b , a < b .
Mayor/menor que o igual: a >= b , a <= b .
Es igual a: a == b , tenga en cuenta que el doble signo de igualdad == significa la prueba de igualdad, mientras que un solo a = b significa una asignación.
No es igual: en matemáticas la notación es ≠ , pero en JavaScript se escribe como a != b .
En este artículo aprenderemos más sobre los diferentes tipos de comparaciones, cómo las realiza JavaScript, incluidas peculiaridades importantes.
Al final encontrará una buena receta para evitar problemas relacionados con las “peculiaridades de JavaScript”.
Todos los operadores de comparación devuelven un valor booleano:
true – significa “sí”, “correcto” o “la verdad”.
false : significa "no", "incorrecto" o "no es la verdad".
Por ejemplo:
alerta( 2 > 1 ); // verdadero (correcto) alerta( 2 == 1 ); // falso (incorrecto) alerta( 2 != 1 ); // verdadero (correcto)
Se puede asignar un resultado de comparación a una variable, como cualquier valor:
sea resultado = 5 > 4; // asigna el resultado de la comparación alerta (resultado); // verdadero
Para ver si una cadena es mayor que otra, JavaScript utiliza el llamado orden "diccionario" o "lexicográfico".
En otras palabras, las cadenas se comparan letra por letra.
Por ejemplo:
alerta('Z' > 'A'); // verdadero
alerta('Resplandor' > 'Alegría'); // verdadero
alerta('Abeja' > 'Ser'); // verdaderoEl algoritmo para comparar dos cadenas es simple:
Compare el primer carácter de ambas cadenas.
Si el primer carácter de la primera cadena es mayor (o menor) que el de la otra cadena, entonces la primera cadena es mayor (o menor) que la segunda. Hemos terminado.
De lo contrario, si los primeros caracteres de ambas cadenas son iguales, compare los segundos caracteres de la misma manera.
Repita hasta el final de cualquiera de las cuerdas.
Si ambas cuerdas terminan en la misma longitud, entonces son iguales. De lo contrario, la cuerda más larga es mayor.
En el primer ejemplo anterior, la comparación 'Z' > 'A' llega a un resultado en el primer paso.
La segunda comparación, 'Glow' y 'Glee' necesita más pasos ya que las cadenas se comparan carácter por carácter:
G es lo mismo que G
l es lo mismo que l .
o es mayor que e . Deténgase aquí. La primera cuerda es mayor.
No es un diccionario real, sino un orden Unicode.
El algoritmo de comparación proporcionado anteriormente es aproximadamente equivalente al utilizado en diccionarios o guías telefónicas, pero no es exactamente el mismo.
Por ejemplo, el caso importa. Una letra "A" mayúscula no es igual a la "a" minúscula. ¿Cuál es mayor? La "a" minúscula. ¿Por qué? Debido a que el carácter minúscula tiene un índice mayor en la tabla de codificación interna que utiliza JavaScript (Unicode). Volveremos a detalles específicos y consecuencias de esto en el capítulo Cadenas.
Al comparar valores de diferentes tipos, JavaScript convierte los valores en números.
Por ejemplo:
alerta( '2' > 1 ); // verdadero, la cadena '2' se convierte en el número 2
alerta ('01' == 1); // verdadero, la cadena '01' se convierte en el número 1 Para valores booleanos, true se convierte en 1 y false se convierte en 0 .
Por ejemplo:
alerta (verdadero == 1); // verdadero alerta (falso == 0); // verdadero
Una consecuencia divertida
Es posible que al mismo tiempo:
Dos valores son iguales.
Uno de ellos es true como booleano y el otro es false como booleano.
Por ejemplo:
sea a = 0; alerta (booleano (a)); // FALSO sea b = "0"; alerta (booleano (b)); // verdadero alerta(a == b); // ¡verdadero!
Desde el punto de vista de JavaScript, este resultado es bastante normal. Una verificación de igualdad convierte valores mediante la conversión numérica (por lo tanto, "0" se convierte en 0 ), mientras que la conversión Boolean explícita utiliza otro conjunto de reglas.
Una verificación de igualdad regular == tiene un problema. No puede diferenciar 0 de false :
alerta (0 == falso); // verdadero
Lo mismo ocurre con una cadena vacía:
alerta( '' == falso ); // verdadero
Esto sucede porque el operador de igualdad == convierte operandos de diferentes tipos en números. Una cadena vacía, al igual que false , se convierte en cero.
¿Qué hacer si queremos diferenciar 0 de false ?
Un operador de igualdad estricta === verifica la igualdad sin conversión de tipo.
En otras palabras, si a y b son de diferentes tipos, entonces a === b devuelve false inmediatamente sin intentar convertirlos.
Probémoslo:
alerta (0 === falso); //falso, porque los tipos son diferentes
También existe un operador de “no igualdad estricta” !== análogo a != .
El operador de igualdad estricta es un poco más largo de escribir, pero deja claro lo que está pasando y deja menos espacio para errores.
Hay un comportamiento no intuitivo cuando se comparan valores null o undefined con otros valores.
Para una estricta verificación de igualdad ===
Estos valores son diferentes, porque cada uno de ellos es de un tipo diferente.
alerta (nulo === indefinido); // FALSO
Para un control no estricto ==
Hay una regla especial. Estos dos son una “dulce pareja”: se igualan entre sí (en el sentido de == ), pero no con ningún otro valor.
alerta (nulo == indefinido); // verdadero
Para matemáticas y otras comparaciones < > <= >=
null/undefined se convierten a números: null se convierte en 0 , mientras que undefined se convierte en NaN .
Ahora veamos algunas cosas divertidas que suceden cuando aplicamos estas reglas. Y, lo que es más importante, cómo no caer en una trampa con ellos.
Comparemos null con un cero:
alerta (nulo > 0); // (1) falso alerta (nulo == 0); // (2) falso alerta (nulo >= 0); // (3) verdadero
Matemáticamente, eso es extraño. El último resultado indica que " null es mayor o igual a cero", por lo que en una de las comparaciones anteriores debe ser true , pero ambas son falsas.
La razón es que una verificación de igualdad == y las comparaciones > < >= <= funcionan de manera diferente. Las comparaciones convierten null en un número, tratándolo como 0 . Es por eso que (3) null >= 0 es verdadero y (1) null > 0 es falso.
Por otro lado, la verificación de igualdad == para undefined y null se define de manera que, sin ninguna conversión, sean iguales entre sí y no sean iguales a nada más. Por eso (2) null == 0 es falso.
El valor undefined no debe compararse con otros valores:
alerta (indefinido > 0); // falso (1) alerta (indefinido < 0); // falso (2) alerta (indefinido == 0); // falso (3)
¿Por qué le disgusta tanto el cero? ¡Siempre falso!
Obtenemos estos resultados porque:
Las comparaciones (1) y (2) devuelven false porque undefined se convierte a NaN y NaN es un valor numérico especial que devuelve false para todas las comparaciones.
La verificación de igualdad (3) devuelve false porque undefined solo es igual null , undefined y ningún otro valor.
¿Por qué repasamos estos ejemplos? ¿Deberíamos recordar estas peculiaridades todo el tiempo? Bueno, en realidad no. En realidad, estas cosas complicadas se irán familiarizando gradualmente con el tiempo, pero existe una forma sólida de evitar problemas con ellas:
Trate cualquier comparación con undefined/null excepto la estricta igualdad === con excepcional cuidado.
No utilice comparaciones >= > < <= con una variable que pueda ser null/undefined , a menos que esté realmente seguro de lo que está haciendo. Si una variable puede tener estos valores, compruébelos por separado.
Los operadores de comparación devuelven un valor booleano.
Las cadenas se comparan letra por letra en el orden del "diccionario".
Cuando se comparan valores de diferentes tipos, se convierten en números (con la exclusión de una estricta verificación de igualdad).
Los valores null e undefined son iguales == entre sí y no son iguales a ningún otro valor.
Tenga cuidado al utilizar comparaciones como > o < con variables que ocasionalmente pueden ser null/undefined . Comprobar si hay null/undefined por separado es una buena idea.
importancia: 5
¿Cuál será el resultado de estas expresiones?
5 > 4 "manzana" > "piña" "2" > "12" indefinido == nulo indefinido === nulo nulo == "n0n" nulo === +"n0n"
5 > 4 → verdadero "manzana" > "piña" → falso "2" > "12" → verdadero indefinido == nulo → verdadero indefinido === nulo → falso nulo == "n0n" → falso nulo === +"n0n" → falso
Algunas de las razones:
Obviamente, cierto.
Comparación de diccionarios, por lo tanto falsa. "a" es más pequeña que "p" .
Nuevamente, comparación de diccionarios, el primer carácter "2" es mayor que el primer carácter "1" .
Los valores null e undefined sólo son iguales entre sí.
La igualdad estricta es estricta. Diferentes tipos de ambos lados conducen a lo falso.
Similar a (4) , null solo es igual a undefined .
Estricta igualdad de diferentes tipos.