Operadores lógicos: combinando perguntas (E, OU, NÃO)

Imagine que você está decidindo se vai sair de casa. Você não pensa apenas "Está chovendo?". Você pensa: "Está chovendo E está frio?" ou "Está sol OU está nublado, mas não chovendo?".

Em programação, os operadores lógicos nos permitem combinar múltiplas condições (perguntas) para formar uma condição maior e mais complexa. Eles são essenciais para a tomada de decisões no seu código.

Existem três operadores lógicos principais em JavaScript:

1. AND (&&): O "E" lógico.
2. OR (||): O "OU" lógico.
3. NOT (!): O "NÃO" lógico.

Todos eles trabalham com valores booleanos (true ou false) e sempre retornam um valor booleano.

1. Operador AND (&&) - O "E" lógico

O operador && retorna true somente se AMBAS as condições forem verdadeiras. Se uma ou ambas forem falsas, o resultado é false.

Pense em uma porta que só abre se você tiver a chave E a senha correta.

Tabela Verdade do &&:

Exemplos:

let idade = 20;
let temCNH = true;
let temCarro = false;

// Condição: É maior de 18 E tem CNH?
let podeDirigir = (idade >= 18) && temCNH;
console.log("Pode dirigir?", podeDirigir); // Saída: Pode dirigir? true (20 >= 18 é true E temCNH é true)

// Condição: É maior de 18 E tem carro?
let podeComprarCarro = (idade >= 18) && temCarro;
console.log("Pode comprar carro?", podeComprarCarro); // Saída: Pode comprar carro? false (temCarro é false)

// Condição: É maior de 18 E tem CNH E tem carro?
let tudoCerto = (idade >= 18) && temCNH && temCarro;
console.log("Tudo certo?", tudoCerto); // Saída: Tudo certo? false (temCarro é false)

2. Operador OR (||) - O "OU" lógico

O operador || retorna true se PELO MENOS UMA das condições for verdadeira. Ele só retorna false se AMBAS as condições forem falsas.

Pense em uma porta que abre se você tiver a chave OU a digital correta.

Tabela Verdade do ||:

Exemplos:

let temDinheiro = false;
let temCartao = true;
let temAmigoComDinheiro = false;

// Condição: Tem dinheiro OU tem cartão?
let podePagar = temDinheiro || temCartao;
console.log("Pode pagar?", podePagar); // Saída: Pode pagar? true (temCartao é true)

// Condição: Tem dinheiro OU tem amigo com dinheiro?
let vaiComer = temDinheiro || temAmigoComDinheiro;
console.log("Vai comer?", vaiComer); // Saída: Vai comer? false (ambos são false)

// Condição: Tem dinheiro OU tem cartão OU tem amigo com dinheiro?
let algumaFormaDePagar = temDinheiro || temCartao || temAmigoComDinheiro;
console.log("Alguma forma de pagar?", algumaFormaDePagar); // Saída: Alguma forma de pagar? true (temCartao é true)

3. Operador NOT (!) - O "NÃO" lógico

O operador ! é um operador unário (opera sobre um único valor) que inverte o valor booleano. Se for true, ele o torna false, e vice-versa.

Pense em "NÃO está chovendo" (se está chovendo é true, então NÃO está chovendo é false).

Tabela Verdade do !:

Exemplos:

let estaChovendo = true;
let temSol = false;

// Condição: NÃO está chovendo?
let naoChovendo = !estaChovendo;
console.log("Não está chovendo?", naoChovendo); // Saída: Não está chovendo? false

// Condição: NÃO tem sol?
let naoTemSol = !temSol;
console.log("Não tem sol?", naoTemSol); // Saída: Não tem sol? true

Combinando operadores lógicos e de comparação

É muito comum usar parênteses para agrupar condições e garantir a ordem correta de avaliação, especialmente quando você mistura && e ||.

Ordem de Precedência: ! (NOT) > && (AND) > || (OR).

let idade = 16;
let temAutorizacao = true;
let temDinheiro = true;

// Condição: (É maior de 18 OU tem autorização) E tem dinheiro?
let podeEntrarNoShow = (idade >= 18 || temAutorizacao) && temDinheiro;
// (16 >= 18 é false || true) && true
// (true) && true
// true
console.log("Pode entrar no show?", podeEntrarNoShow); // Saída: Pode entrar no show? true

let estaLogado = false;
let isAdmin = true;

// Condição: NÃO está logado E é Admin? (Isso seria uma condição estranha, mas serve de exemplo)
let condicaoEstranha = !estaLogado && isAdmin;
// (!false) && true
// true && true
// true
console.log("Condição estranha:", condicaoEstranha); // Saída: Condição estranha: true

Os operadores lógicos são a espinha dorsal da tomada de decisões em qualquer programa. Com eles, você pode criar condições complexas que permitem ao seu código reagir de forma inteligente a diferentes situações.