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 true
se o valor for false
e vice-versa. Por exemplo:
let eligible = false,
required = true;
console.log(!eligible);
console.log(!required);
Linguagem de código: JavaScript ( javascript )
Saída:
true
false
Linguagem de código: JavaScript ( javascript )
Neste exemplo, eligible
is true
so !eligible
retorna false
. E como required
é true
, os !required
retornos 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
a
forundefined
, o resultado étrue
. - Se
a
fornull
, o resultado étrue
. - Se
a
for um número diferente de0
, o resultado seráfalse
. - Se
a
forNaN
, o resultado étrue
. - Se a for um objeto, o resultado será falso.
- Se a for uma string vazia, o resultado será verdadeiro. No caso
a
de 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); //false
Linguagem 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); // true
Linguagem de código: JavaScript ( javascript )
O primeiro !
operador nega o valor booleano da counter
variável. Se counter
for 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 counter
variá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 a
puder 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); // false
Linguagem de código: JavaScript ( javascript )
Neste exemplo, eligible
is false
, portanto, o valor da expressão eligible && required
é false
.
Veja o exemplo a seguir:
let eligible = true,
required = true;
console.log(eligible && required); // true
Linguagem de código: JavaScript ( javascript )
Neste exemplo, ambos eligible
e required
sã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:
Infinity
Linguagem de código: JavaScript ( javascript )
Neste exemplo, b
portanto , true
o &&
operador não poderia determinar o resultado sem avaliar melhor a segunda expressão ( 1/0
).
O resultado é Infinity
qual é 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:
false
Linguagem de código: JavaScript ( javascript )
Neste caso, b
is false
, o &&
operador não precisa avaliar a segunda expressão porque pode determinar o resultado final como false
valor 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 a
puder 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 false
se 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); // true
Linguagem de código: JavaScript ( javascript )
Veja outro exemplo:
let eligible = false,
required = false;
console.log(eligible || required); // false
Linguagem de código: JavaScript ( javascript )
Neste exemplo, a expressão eligible || required
retorna false
porque 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:
- Lógico NÃO (!)
- E lógico (&&)
- 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 retornatrue
se um dos operandos fortrue
. - 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
!
.&&
||