Uma introdução aos operadores lógicos JavaScript

Resumo : neste tutorial, você aprenderá como usar os operadores lógicos JavaScript, incluindo o operador lógico NOT ( !), o operador lógico AND ( &&) e o operador lógico OR ( ||).

Os operadores lógicos são importantes em JavaScript porque permitem comparar variáveis ​​e fazer algo com base no resultado dessa comparação.

Por exemplo, se o resultado da comparação for true, você poderá executar um bloco de código; se for false, você pode executar outro bloco de código.

JavaScript fornece três operadores lógicos:

• ! (NÃO lógico)
• || (OU lógico)
• && (E lógico)

1) O operador lógico NOT (!)

JavaScript usa um ponto de exclamação !para representar o operador lógico NOT. O !operador pode ser aplicado a um único valor de qualquer tipo, não apenas a um valor booleano.

Quando você aplica o !operador a um valor booleano, ele !retorna truese o valor for falsee vice-versa. Por exemplo:

let eligible = false,
    required = true;

console.log(!eligible);
console.log(!required);Linguagem de código:  JavaScript  ( javascript )

Saída:

true
falseLinguagem de código:  JavaScript  ( javascript )

Neste exemplo, eligibleis trueso !eligibleretorna false. E como requiredé true, os !requiredretornos false.

Quando você aplica o !operador a um valor não booleano. O !operador primeiro converte o valor em um valor booleano e depois o nega.

O exemplo a seguir mostra como usar o !operador:

!a

O operador lógico !funciona com base nas seguintes regras:

• Se afor undefined, o resultado é true.
• Se afor null, o resultado é true.
• Se afor um número diferente de 0, o resultado será false.
• Se afor NaN, o resultado é true.
• Se a for um objeto, o resultado será falso.
• Se a for uma string vazia, o resultado será verdadeiro. No caso ade uma string não vazia, o resultado éfalse

A seguir demonstramos os resultados do !operador lógico quando aplicado a um valor não booleano:

console.log(!undefined); // true
console.log(!null); // true
console.log(!20); //false
console.log(!0); //true
console.log(!NaN); //true
console.log(!{}); // false
console.log(!''); //true
console.log(!'OK'); //false
console.log(!false); //true
console.log(!true); //falseLinguagem de código:  JavaScript  ( javascript )

Negação dupla ( !!)

Às vezes, você pode ver a negação dupla ( !!) no código. O !!usa o operador lógico NOT ( !) duas vezes para converter um valor em seu valor booleano real.

O resultado é o mesmo que usar a função Boolean() . Por exemplo:

let counter = 10;
console.log(!!counter); // trueLinguagem de código:  JavaScript  ( javascript )

O primeiro !operador nega o valor booleano da countervariável. Se counterfor true, o !operador o torna falso e vice-versa.

O segundo !operador nega o resultado do primeiro !operador e retorna o valor booleano real da countervariável.

2) O operador lógico AND ( &&)

JavaScript usa o “e” comercial duplo ( &&) para representar o operador lógico AND. A expressão a seguir usa o &&operador:

let result = a && b;Linguagem de código:  JavaScript  ( javascript )

Se apuder ser convertido em true, o &&operador retornará b; caso contrário, ele retornará o a. Na verdade, esta regra se aplica a todos os valores booleanos.

A tabela verdade a seguir ilustra o resultado do &&operador quando ele é aplicado a dois valores booleanos:

a	b	um && b
verdadeiro	verdadeiro	verdadeiro
verdadeiro	falso	falso
falso	verdadeiro	falso
falso	falso	falso

O resultado do &&operador é verdadeiro apenas se ambos os valores forem true, caso contrário, é false. Por exemplo:

let eligible = false,
    required = true;

console.log(eligible && required); // falseLinguagem de código:  JavaScript  ( javascript )

Neste exemplo, eligibleis false, portanto, o valor da expressão eligible && requiredé false.

Veja o exemplo a seguir:

let eligible = true,
    required = true;

console.log(eligible && required); // trueLinguagem de código:  JavaScript  ( javascript )

Neste exemplo, ambos eligiblee requiredsão true, portanto, o valor da expressão eligible && requiredé true.

Avaliação de curto-circuito

O &&operador está em curto-circuito. Isso significa que o &&operador avalia o segundo valor somente se o primeiro não for suficiente para determinar o valor de uma expressão. Por exemplo:

let b = true;
let result = b && (1 / 0);
console.log(result);Linguagem de código:  JavaScript  ( javascript )

Saída:

InfinityLinguagem de código:  JavaScript  ( javascript )

Neste exemplo, bportanto , trueo &&operador não poderia determinar o resultado sem avaliar melhor a segunda expressão ( 1/0).

O resultado é Infinityqual é o resultado da expressão ( 1/0). No entanto:

let b = false;
let result = b && (1 / 0);
console.log(result);Linguagem de código:  JavaScript  ( javascript )

Saída:

falseLinguagem de código:  JavaScript  ( javascript )

Neste caso, bis false, o &&operador não precisa avaliar a segunda expressão porque pode determinar o resultado final como falsevalor baseado no primeiro valor.

A cadeia de &&operadores

A expressão a seguir usa vários &&operadores:

let result = value1 && value2 && value3;Linguagem de código:  JavaScript  ( javascript )

O && operador carrega o seguinte:

• Avalia valores da esquerda para a direita.
• Para cada valor, converta-o em booleano. Se o resultado for  false, para e retorna o valor original.
• Se todos os valores forem valores verdadeiros, retorne o último valor.

Em outras palavras, o &&operador retorna o primeiro valor falso ou o último valor se nenhum for encontrado.

Se um valor puder ser convertido em  true, ele será chamado de valor verdadeiro. Se um valor puder ser convertido em  false, é o chamado valor falso.

3) O operador lógico OR ( ||)

JavaScript usa a barra dupla ||para representar o operador lógico OR. Você pode aplicar o ||operador a dois valores de qualquer tipo:

let result = a || b;Linguagem de código:  JavaScript  ( javascript )

Se  apuder ser convertido em  true, retornará  a; caso contrário, retorna  b. Esta regra também se aplica a valores booleanos.

A tabela verdade a seguir ilustra o resultado do ||operador com base no valor dos operandos:

a	b	uma || b
verdadeiro	verdadeiro	verdadeiro
verdadeiro	falso	verdadeiro
falso	verdadeiro	verdadeiro
falso	falso	falso

O ||operador retorna falsese ambos os valores forem avaliados como false. Caso um dos valores seja true, o ||operador retorna true. Por exemplo:

let eligible = true,
    required = false;

console.log(eligible || required); // trueLinguagem de código:  JavaScript  ( javascript )

Veja outro exemplo:

let eligible = false,
    required = false;

console.log(eligible || required); // falseLinguagem de código:  JavaScript  ( javascript )

Neste exemplo, a expressão eligible || requiredretorna falseporque ambos os valores são false.

O ||operador também está em curto-circuito

Semelhante ao &&operador, o ||operador está em curto-circuito. Isso significa que se o primeiro valor for avaliado como true, o &&operador não avaliará o segundo.

A cadeia de ||operadores

O exemplo a seguir mostra como usar vários || operadores em uma expressão:

let result = value1 || value2 || value3;Linguagem de código:  JavaScript  ( javascript )

O || operador faz o seguinte:

• Avalia valores da esquerda para a direita.
• Para cada valor, converte-o em um valor booleano. Se o resultado da conversão for  true, para e retorna o valor.
• Se todos os valores foram avaliados como false, retorna o último valor.

Em outras palavras, a cadeia de || operadores retorna o primeiro valor verdadeiro ou o último se nenhum valor verdadeiro for encontrado.

Precedência do operador lógico

Quando você mistura operadores lógicos em uma expressão, o mecanismo JavaScript avalia os operadores com base em uma ordem especificada. E esta ordem é chamada de precedência do operador .

Em outras palavras, a precedência do operador é a ordem de avaliação dos operadores lógicos em uma expressão.

A precedência do operador lógico está na seguinte ordem, da mais alta para a mais baixa:

1. Lógico NÃO (!)
2. E lógico (&&)
3. OU lógico (||)

Resumo

• O operador NOT ( !) nega um valor booleano. O ( !!) converte um valor em seu valor booleano real.
• O operador AND ( &&) é aplicado a dois valores booleanos e retorna verdadeiro se ambos os valores forem verdadeiros.
• O operador OR( ||) é aplicado a dois valores booleanos e retorna truese um dos operandos for true.
• Ambos &&e ||o operador estão em curto-circuito. Eles também podem ser aplicados a valores não booleanos.
• A precedência do operador lógico do mais alto para o mais baixo é e !.&&||