Como usar operadores lógicos em JavaScript

Os operadores lógicos permitem que você execute operações lógicas em valores booleanos. Eles permitem que você combine, negue ou compare valores booleanos e tome decisões lógicas em seu código com base no resultado.

Explore os vários operadores lógicos suportados pelo JavaScript, incluindo o operador de coalescência ES6 Nullish.

O operador lógico AND (&&)

O operador AND (&&) é um operador lógico que retorna verdadeiro se ambos os operandos forem avaliados como verdadeiro e falso de outra forma.

Aqui está a sintaxe do operador AND:

a && b

Aqui está um exemplo do operador AND em uso:

const um = 5;
const b = 10;
const c = 15;
const resultado_1 = (a < b) && (b < c);
console.log (resultado_1); // verdadeiro
const resultado_2 = (a > b) && (b < c);
console.log (resultado_2); // falso

Neste exemplo, resultado_1 avalia para verdadeiro porque os dois operandos na expressão são avaliados como

verdadeiro. No entanto, resultado_2 avalia para falso porque o primeiro operando (a > b) retorna falso.

Se ambos os operandos não forem booleanos, O JavaScript tentará convertê-los em valores booleanos antes de avaliar a expressão. Para convertê-los em booleanos, o JavaScript primeiro avalia se os valores são verdadeiros ou falsos.

JavaScript considera qualquer valor que não seja explicitamente falso, um valor verdadeiro. Quando convertidos, eles avaliam para um valor booleano verdadeiro.

No entanto, certos valores e tipos de dados em JavaScript são falsos, então quando o JavaScript os converte, eles são avaliados como booleanos falso.

Os valores falsos em JavaScript são:

• falso
• nulo
• indefinido
• NaN (Não é um número)
• 0
• BigInt (0n)
• Cadeia vazia ("" ou '' ou ``)
• indefinido

Quando você usa o operador AND para avaliar valores não booleanos, a expressão retorna imediatamente o valor do primeiro operando se o operando for falso sem avaliar o segundo. Esse comportamento é conhecido como curto-circuito e você pode usá-lo para escrever declarações condicionais em JavaScript.

No entanto, se o primeiro operando for verdadeiro, a expressão procede para avaliar o segundo operando. Se o segundo operando for verdadeiro, ele o retorna.

Por exemplo:

const um = 5;
const b = 'Olá';
const c = nulo;
const resultado_1 = a && b;
console.log (resultado_1); // "Olá"
const resultado_2 = c && b;
console.log (resultado_2); // nulo

Neste exemplo, resultado_1 avalia como “Hello” porque ambos os operandos na expressão são verdadeiros. No entanto, resultado_2 curtos-circuitos e retornos nulo sem avaliar o segundo operando.

Observe que se houver mais operandos, o operador AND continuará avaliando-os até encontrar um valor falso. Se não encontrar um valor falso, ele retornará o último valor verdadeiro que encontrar.

O operador lógico OU (||)

O operador OR (||) é um operador lógico que retorna verdadeiro se e somente se um ou mais de seus operandos for verdadeiro. Ele só retorna falso quando ambos os operandos são falso.

Aqui está a sintaxe do operador OR:

um || b

Aqui está um exemplo do operador OR em uso:

const um = 5;
const b = 10;
const c = 15;
const resultado_1 = (a < b) || (b < c);
console.log (resultado_1); // verdadeiro
const resultado_2 = (a > b) || (b < c);
console.log (resultado_2); // verdadeiro
const resultado_3 = (a > b) || (b > c);
console.log (resultado_3); // falso

No exemplo acima, resultado_1 avalia para verdadeiro porque ambos os operandos na expressão são avaliados como verdadeiro. resultado_2 avalia para verdadeiro porque o segundo operando é avaliado como verdadeiro. resultado_3 avalia para falso porque os dois operandos na expressão são avaliados como falso.

Quando você usa o operador OR em contextos não booleanos, o JavaScript tenta converter em valores booleanos antes de avaliar a expressão.

Quando a expressão é avaliada, se o primeiro operando for verdadeiro, o operador causa um curto-circuito e o retorna. No entanto, se for falso, ele avalia o próximo operando até encontrar um operando verdadeiro. Se não houver operandos verdadeiros na expressão, ela retornará o último valor falso encontrado.

Por exemplo:

const um = 5;
const b = 'Olá';
const c = nulo;
const resultado_1 = a || b;
console.log (resultado_1); // 5
const resultado_2 = c || b;
console.log (resultado_2); // "Olá"
const resultado_3 = c || " ";
console.log (resultado_3); // " "

No exemplo acima, resultado_1 curtos-circuitos e retornos 5 porque é um valor verdadeiro. resultado_2 retorna “Hello” porque é o primeiro valor verdadeiro que encontra na expressão. resultado_3 retorna uma string vazia porque é o último valor falso na expressão.

O operador lógico NOT (!)

O operador lógico NOT (!) é um operador unário que retorna o valor booleano oposto de seu operando.

Aqui está a sintaxe do operador NOT:

!x

Onde x é um valor booleano ou verdadeiro ou falso.

Aqui está um exemplo do operador NOT em uso:

const um = 5;
const b = '';
const c = verdadeiro;
const resultado_1 = !a;
console.log (resultado_1); // falso
const resultado_2 = !b;
console.log (resultado_2); // verdadeiro
const resultado_3 = !c;
console.log (resultado_3); // falso

No exemplo acima, o operador NOT retorna o valor inverso dos operandos booleanos. Quando você usa o operador NOT em contextos não booleanos (resultado_1 & resultado_2), ele converte valores verdadeiros para o valor inverso de verdadeiro e converte os valores falsos para o valor inverso de falso.

O Operador Coalescente Nulo (??)

O operador de coalescência nullish é um operador lógico que avalia dois operandos e retorna o primeiro operando se não for nulo ou indefinido. Caso contrário, retorna o segundo operando.

À primeira vista, o operador de coalescência nula pode parecer idêntico ao operador lógico OR (||), mas esse não é o caso. A principal diferença é que o operador OR retorna o operando do lado direito se o operando esquerdo for "qualquer" valor falso, não apenas nulo ou indefinido.

Ele fornece uma maneira concisa de escolher um valor padrão ao encontrar nulo ou indefinido valores.

Aqui está a sintaxe para o operador de coalescência nullish:

x?? y

Aqui está um exemplo do operador de coalescência nullish em uso:

const nome = nulo;
const defaultName = "John Doe";
const resultado_1 = nome?? defaultName;
console.log (resultado_1); // "João Silva"
const idade = 0;
const idade padrão = 25;
const resultado_2 = idade?? idade padrão;
console.log (resultado_2); // 0

No exemplo acima, resultado_1 retorna “John Doe” porque o primeiro operando tinha um valor de nulo. resultado_2 retorna 0 porque, embora seja um valor falso, não é nem nulo nem indefinido.

Usando operadores lógicos em seu código

Os operadores lógicos são comumente usados ​​para escrever instruções condicionais, atribuir valores padrão ou alternar valores booleanos com base em condições.

Ao utilizar esses operadores lógicos, você pode escrever um código mais conciso e expressivo que lida com diferentes cenários com base na veracidade ou falsidade dos valores.