Los operadores de comparación comparan los valores de dos operandos y evalúan si la sentencia que forman es true o false. En el siguiente ejemplo, se usa el operador de igualdad estricta (===) para comparar dos operandos: la expresión 2 + 2 y el valor 4. Como el resultado de la expresión y el valor numérico 4 son iguales, esta expresión se evalúa como true:
2 + 2 === 4
> true
Coerción y igualdad de tipos
Dos de los operadores de comparación más usados son == para la igualdad flexible y === para la igualdad estricta. == realiza una comparación imprecisa entre dos valores forzando a los operandos a que coincidan con los tipos de datos, si es posible. Por ejemplo, 2 == "2" muestra true, aunque la comparación se realice entre un valor numérico y un valor de cadena.
2 == 2
> true
2 == "2"
> true
Lo mismo sucede con !=, que muestra true solo si los operandos que se comparan no son iguales de forma no estricta.
2 != 3
> true
2 != "2"
> false
Las comparaciones estrictas con === o !== no realizan una coerción de tipo. Para que una comparación estricta evalúe a true, los valores que se comparan deben tener el mismo tipo de datos. Debido a esto, 2 == "2" muestra true, pero 2 === "2" muestra false:
2 === 3
> false
2 === "2"
> false
Para quitar cualquier ambigüedad que pueda resultar de la coerción automática, usa === siempre que sea posible.
| Operador | Descripción | Uso | Resultado |
|---|---|---|---|
| === | Estrictamente igual | 2 === 2 | verdadero |
| !== | No es estrictamente igual | 2 !== "2" | verdadero |
| == | Igual (o "aproximadamente igual") | 2 == "2" | verdadero |
| != | No igual | 2 != "3" | verdadero |
| > | Mayor que | 3 > 2 | verdadero |
| >= | Mayor o igual que | 2 >= 2 | verdadero |
| < | Menor que | 2 < 3 | verdadero |
| <= | Menor o igual que | 2 <= 3 | verdadero |
Valores verdaderos y falsos
Todos los valores en JavaScript son true o false de forma implícita y se pueden forzar al valor booleano correspondiente, por ejemplo, con el comparador "igual de forma imprecisa". Un conjunto limitado de valores se convierte en false:
0nullundefinedNaN- Una cadena vacía (
"")
Todos los demás valores se convierten a true, incluida cualquier cadena que contenga uno o más caracteres y todos los números distintos de cero. Por lo general, se denominan valores “verdaderos” y “falsos”.
"My string" == true
> true
100 == true
> true
0 == true
> false
Operadores lógicos
Usa los operadores lógicos Y (&&), O (||) y NO (!) para controlar el flujo de una secuencia de comandos en función de la evaluación de dos o más sentencias condicionales:
2 === 3 || 5 === 5;
> true
2 === 2 && 2 === "2"
> false
2 === 2 && !"My string."
> false
Una expresión lógica NOT (!) niega el valor verdadero o falso de un operando, y se evalúa como true si el operando se evalúa como false, y como false si el operando se evalúa como true:
true
> true
!true
> false
!false
> true
El uso del operador lógico NOT (!) antes de otro tipo de datos, como un número o una cadena, convierte ese valor en un booleano y revierte el valor verdadero o falso del resultado.
"string"
> "string"
!"string"
> false
0
> 0
!0
> true
Es una práctica común usar dos operadores NOT para forzar rápidamente los datos a su valor booleano coincidente:
!!"string"
> true
!!0
> false
Los operadores lógicos AND y OR no realizan ninguna coerción por sí solos. Muestran el valor de uno de los dos operandos que se evalúan, y el operando elegido se determina según esa evaluación.
El operador lógico AND (&&) muestra el primero de sus dos operandos solo si ese operando se evalúa como false y el segundo operando de lo contrario. En las comparaciones que se evalúan como valores booleanos, muestra true solo si los operandos a ambos lados del operador Y lógico se evalúan como true. Si cualquiera de los lados se evalúa como false, muestra false.
true && false
> false
false && true
> false
false && false
> false
true && true
> true
Cuando se usa && con dos operandos no booleanos, el primer operando se muestra sin cambios si se puede forzar a false. Si el primer operando se puede forzar a true, el segundo operando se muestra sin cambios:
false && "My string"
> false
null && "My string"
> null
"My string" && false
> false
"My string" && "My second string"
> "My second string"
2 === 2 && "My string"
> "My string"
El operador O lógico (||) muestra el primero de sus dos operandos solo si ese operando se evalúa como true y el segundo operando de lo contrario. En las comparaciones que se evalúan como valores booleanos, esto significa que muestra true si cualquiera de los operandos se evalúa como true y, si ninguno de los lados se evalúa como true, muestra false:
true || false
> true
false || true
> true
true || true
> true
false || false
> false
Cuando se usa || con dos operandos no booleanos, muestra el primer operando sin cambios si se puede forzar a true. Si el primer operando se puede forzar a false, el segundo operando se muestra sin cambios:
false || "My string"
> "My string"
null || "My string"
> "My string"
"My string" || false
> "My string"
"My string" || "My second string"
> "My string"
2 === 2 || "My string"
> true
Operador de incorporación nula
Presentado en ES2020, el “operador coalescente nulo” (??) muestra el primer operando solo si ese operando tiene cualquier valor que no sea null o undefined. De lo contrario, muestra el segundo operando.
null ?? "My string"
> "My string"
undefined ?? "My string"
> "My string"
true ?? "My string";
> true
?? es similar a un OR lógico, pero es más estricto en la forma en que se evalúa el primer operando. || muestra el segundo operando para cualquier expresión que se pueda forzar a false, incluidos undefined y null. ?? muestra el segundo operando solo cuando el primer operando es estrictamente igual a null o undefined, incluso si se puede forzar a false:
0 ?? "My string";
> 0
false ?? "My string";
> false
undefined ?? "My string";
> "My string"
Operadores de asignación lógica
Usa operadores de asignación para asignar el valor de un segundo operador a un primer operador. El ejemplo más común de esto es un solo signo igual (=), que se usa para asignar un valor a una variable declarada.
Usa operadores de asignación lógica para asignar condicionalmente un valor a una variable según el valor verdadero o falso de esa variable.
El operador de asignación lógica Y (&&=) evalúa el segundo operando y lo asigna al primero solo si este se evalúa como true; en efecto, "si el primer operando es verdadero, asígnale el valor del segundo operando:"
let myVariable = false;
myVariable &&= 2 + 2;
> false
myVariable = true;
myVariable &&= 2 + 2;
> 4
El valor verdadero o falso del primer operando determina si se realiza una asignación. Sin embargo, intentar evaluar el primer operando con un operador de comparación genera un valor booleano true o false, al que no se le puede asignar un valor:
let myVariable = 5;
myVariable > 2 &&= "My string"
> SyntaxError: Invalid left-hand side in assignment
El operador de asignación OR lógico (||=) evalúa el segundo operando y lo asigna al primer operando si este se evalúa como false, es decir, "si el primer operando es falso, asígnale el valor del segundo operando":
let myVariable = false;
myVariable ||= 2 + 2;
> 4
myVariable = true;
myVariable ||= 2 + 2;
> true
Verifica tu comprensión
¿Qué operador indica “igual exactamente”?
======!=