Cómo usar operadores lógicos en JavaScript

Los operadores lógicos le permiten realizar operaciones lógicas en valores booleanos. Le permiten combinar, negar o comparar valores booleanos y tomar decisiones lógicas en su código según el resultado.

Explore los diversos operadores lógicos que admite JavaScript, incluido el operador de fusión nulo ES6.

El operador lógico AND (&&)

El operador AND (&&) es un operador lógico que devuelve verdadero si ambos operandos se evalúan como verdadero y FALSO de lo contrario.

Esta es la sintaxis del operador AND:

a & & b

Aquí hay un ejemplo del operador AND en uso:

constante un = 5;
constante segundo = 10;
constante c = 15;
constante resultado_1 = (a < b) && (b < c);
consola.log (resultado_1); // verdadero
constante resultado_2 = (a > b) && (b < c);
consola.log (resultado_2); // FALSO

En este ejemplo, resultado_1 evalúa a verdadero porque los dos operandos en la expresión se evalúan como

verdadero. Sin embargo, resultado_2 evalúa a FALSO porque el primer operando (a > b) devoluciones FALSO.

Si ambos operandos no son booleanos, JavaScript intentará convertirlos en valores booleanos antes de evaluar la expresión. Para convertirlos en booleanos, JavaScript primero evalúa si los valores son verdaderos o falsos.

JavaScript considera cualquier valor que no sea explícitamente falso, un valor verdadero. Cuando se convierten, se evalúan a un valor booleano verdadero.

Sin embargo, ciertos valores y tipos de datos en JavaScript son falsos, por lo que cuando JavaScript los convierte, se evalúan como un valor booleano FALSO.

Los valores falsos en JavaScript son:

• FALSO
• nulo
• indefinido
• Yaya (No un número)
• 0
• Empezando (0n)
• Cuerda vacía ("" o '' o ``)
• indefinido

Cuando usa el operador AND para evaluar valores no booleanos, la expresión devuelve inmediatamente el valor del primer operando si el operando es falso sin evaluar el segundo. Este comportamiento se conoce como cortocircuito y puede usarlo para escribir declaraciones condicionales en JavaScript.

Sin embargo, si el primer operando es verdadero, la expresión procede a evaluar el segundo operando. Si el segundo operando es verdadero, lo devuelve.

Por ejemplo:

constante un = 5;
constante segundo = 'Hola';
constante c = nulo;
constante resultado_1 = a && b;
consola.log (resultado_1); // "Hola"
constante resultado_2 = c && b;
consola.log (resultado_2); // nulo

En este ejemplo, resultado_1 se evalúa como "Hola" porque ambos operandos en la expresión son verdaderos. Sin embargo, resultado_2 cortocircuitos y retornos nulo sin evaluar el segundo operando.

Tenga en cuenta que si hay más operandos, el operador AND continuará evaluándolos hasta que encuentre un valor falso. Si no encuentra un valor falso, devuelve el último valor verdadero que encuentra.

El operador lógico OR (||)

El operador OR (||) es un operador lógico que devuelve verdadero si y solo si uno o más de sus operandos es verdadero. solo regresa FALSO cuando ambos operandos son FALSO.

Esta es la sintaxis del operador OR:

un || b

Aquí hay un ejemplo del operador OR en uso:

constante un = 5;
constante segundo = 10;
constante c = 15;
constante resultado_1 = (a < b) || (b consola.log (resultado_1); // verdadero
constante resultado_2 = (a > b) || (b consola.log (resultado_2); // verdadero
constante resultado_3 = (a > b) || (b > c);
consola.log (resultado_3); // FALSO

En el ejemplo anterior, resultado_1 evalúa a verdadero porque ambos operandos en la expresión se evalúan como verdadero. resultado_2 evalúa a verdadero porque el segundo operando se evalúa como verdadero. resultado_3 evalúa a FALSO porque los dos operandos en la expresión se evalúan como FALSO.

Cuando usa el operador OR en contextos no booleanos, JavaScript intenta convertirlos en valores booleanos antes de evaluar la expresión.

Cuando se evalúa la expresión, si el primer operando es verdadero, el operador hace un cortocircuito y lo devuelve. Sin embargo, si es falso, procede a evaluar el siguiente operando hasta que encuentra un operando verdadero. Si no hay operandos verdaderos en la expresión, devuelve el último valor falso que encuentra.

Por ejemplo:

constante un = 5;
constante segundo = 'Hola';
constante c = nulo;
constante resultado_1 = un || b;
consola.log (resultado_1); // 5
constante resultado_2 = c || b;
consola.log (resultado_2); // "Hola"
constante resultado_3 = c || " ";
consola.log (resultado_3); // " "

En el ejemplo anterior, resultado_1 cortocircuitos y retornos 5 porque es un valor verídico. resultado_2 devuelve "Hola" porque es el primer valor de verdad que encuentra en la expresión. resultado_3 devuelve una cadena vacía porque es el último valor falso de la expresión.

El operador lógico NOT (!)

El operador lógico NOT (!) es un operador unario que devuelve el valor booleano opuesto de su operando.

Esta es la sintaxis del operador NOT:

!X

Dónde X es un valor booleano o verdadero o falso.

Aquí hay un ejemplo del operador NOT en uso:

constante un = 5;
constante segundo = '';
constante c = verdadero;
constante resultado_1 = !a;
consola.log (resultado_1); // FALSO
constante resultado_2 = !b;
consola.log (resultado_2); // verdadero
constante resultado_3 = !c;
consola.log (resultado_3); // FALSO

En el ejemplo anterior, el operador NOT devuelve el valor inverso de los operandos booleanos. Cuando usa el operador NOT en contextos no booleanos (resultado_1 & resultado_2), convierte los valores verdaderos al valor inverso de verdadero y convierte los valores falsos al valor inverso de FALSO.

El operador coalescente nulo (??)

El operador coalescente nulo es un operador lógico que evalúa dos operandos y devuelve el primer operando si no es nulo o indefinido. De lo contrario, devuelve el segundo operando.

De un vistazo, el operador coalescente nulo puede parecer idéntico al operador lógico OR (||), pero ese no es el caso. La diferencia clave es que el operador OR devuelve el operando del lado derecho si el operando de la izquierda es "cualquier" valor falso, no solo nulo o indefinido.

Proporciona una forma concisa de elegir un valor predeterminado al encontrar nulo o indefinido valores.

Esta es la sintaxis del operador coalescente nulo:

¿¿X?? y

Aquí hay un ejemplo del operador coalescente nulo en uso:

constante nombre = nulo;
constante nombrepredeterminado = "Juan Doe";
constante resultado_1 = nombre?? nombrepredeterminado;
consola.log (resultado_1); // "Juan Pérez"
constante edad = 0;
constante edad por defecto = 25;
constante resultado_2 = edad?? edadpredeterminada;
consola.log (resultado_2); // 0

En el ejemplo anterior, resultado_1 devuelve "John Doe" porque el primer operando tenía un valor de nulo. resultado_2 devoluciones 0 porque, aunque es un valor falso, tampoco lo es nulo ni indefinido.

Uso de operadores lógicos en su código

Los operadores lógicos se usan comúnmente para escribir declaraciones condicionales, asignar valores predeterminados o alternar valores booleanos según las condiciones.

Al utilizar estos operadores lógicos, puede escribir un código más conciso y expresivo que maneje diferentes escenarios en función de la veracidad o falsedad de los valores.