Operadores de comparación

Los operadores de comparación comparan los valores de dos operandos y evalúan que forman es true o false. En el siguiente ejemplo, se usa la 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 número 4 son iguales, esta expresión se evalúa como true:

2 + 2 === 4
> true

Coerción e igualdad de tipos

Dos de los operadores de comparación más usados son == para la igualdad baja y === para una igualdad estricta. == realiza una comparación flexible entre dos valores coercionando los operandos para que coincidan con tipos de datos, si es posible. Para Por ejemplo, 2 == "2" muestra true, aunque se esté haciendo la comparación. 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 en comparación no son iguales de forma flexible.

2 != 3
> true

2 != "2"
> false

Las comparaciones estrictas que usan === o !== no realizan la coerción de tipo. Para un una comparación estricta para evaluar como true, los valores que se comparan deben tener lo siguiente: mismo tipo de datos. Por este motivo, 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 como sea posible.

Operador	Descripción	Uso	Resultado
===	Estrictamente igual	2 === 2	verdadero
!==	No es estrictamente igual	2 !== "2"	verdadero
==	Igual (o "libremente 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

Verdaderos y falsos

Todos los valores en JavaScript son true o false de manera implícita, y se pueden forzar a el valor booleano correspondiente (por ejemplo, mediante el uso del parámetro "loosely equal" comparador. Un conjunto limitado de valores se fuerza a false:

• 0
• null
• undefined
• NaN
• Una cadena vacía ("")

Todos los demás valores se coercionan a true, incluida cualquier cadena que contenga uno o más. caracteres y todos los números que no sean cero. Por lo general, se los llama "verdad" y "falso" de salida.

"My string" == true
> true

100 == true
> true

0 == true
> false

Operadores lógicos

Usa los operadores lógicos AND (&&), OR (||) y NOT (!) para controlar el flujo de una secuencia de comandos según 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 NOT (!) lógica niega el valor veracoso o falso de un operando, y evalúa como true si el operando se evalúa como false, y false si el operando se evalúa como true:

true
> true

!true
> false

!false
> true

Usar el operador lógico NOT (!) frente a otro tipo de datos, como un o una cadena, fuerza ese valor a booleano y revierte la fórmula falso del resultado.

"string"
> "string"

!"string"
> false

0
> 0

!0
> true

Es una práctica común usar dos operadores NOT para coercionar 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í mismos. Ellas devuelve el valor de uno de los dos operandos evaluados, con el valor elegido el operando determinado determinado por esa evaluación.

La lógica AND (&&) muestra el primero de sus dos operandos solo si ese operando se evalúa como false y, de lo contrario, el segundo operando. En las comparaciones que evalúa como valores booleanos, muestra true solo si los operandos en ambos lados del operador lógico AND que se evalúa como true. Si alguno 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, se muestra el primer operando. sin cambios si se puede forzar a false. Si el primer operando se puede forzar en 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 lógico OR (||) muestra el primero de sus dos operandos solo si ese operando se evalúa como true y, de lo contrario, el segundo operando. En las comparaciones que evalúas en 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, se muestra el primer operando sin cambios si se puede forzar a true. Si el primer operando se puede forzar en 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 coalescente nulo

Presentada en ES2020, el "operador coalescente nulo" (??) muestra el primer operando solo si ese el operando tiene cualquier valor diferente de 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 más estricto en cuanto a cómo es el primer operando y cómo se evalúa. || muestra el segundo operando para cualquier expresión que se puede se convirtió en false, lo que incluye undefined y null. ?? muestra el segundo cuando el primer operando no sea null ni undefined, incluso si se podría forzar a false:

0 ?? "My string";
> 0

false ?? "My string";
> false

undefined ?? "My string";
> "My string"

Operadores de asignación lógicos

Usa operadores de asignación para asignar el valor de un segundo operador a un primero como "autor" y "título" usando un operador lógico. El ejemplo más común es un signo igual (=), que se usa para asignar un valor a una variable declarada.

Usar operadores de asignación lógicos para asignar un valor a una variable de forma condicional basadas en el valor verdadero o falso de esa variable.

El operador lógico de asignación AND (&&=) evalúa el segundo operando y asigna al primer operando si el valor solo si el primer operando evaluaría como true (efectivamente, "si el primer operando es verdadero, asígnale el valor del el 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 una asignación de que ocurra la evaluación. Sin embargo, intentar evaluar el primer operando usando una comparación el operador genera un valor booleano true o false, al que no se le puede asignar una valor:

let myVariable = 5;
myVariable > 2 &&= "My string"
> SyntaxError: Invalid left-hand side in assignment

El operador lógico de asignación OR (||=) evalúa el segundo operando y asignar al primer operando si este se evalúa como false, efectivamente "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 tus conocimientos