Os operadores lógicos são blocos fundamentais de construção na programação, permitindo que você combine e manipule valores booleanos (verdadeiros ou falsos) para criar condições complexas. Aqui estão alguns exemplos comuns de operadores lógicos, juntamente com seus símbolos e explicações:
1. E (conjunção) *
Símbolo: `&&` (C ++, Java, JavaScript, Php, C#, Go, Rust), `e` (Python, Ruby),` &`(Pascal, VBA)
*
Objetivo: Retorna `true` se
ambos operando são `true`. Caso contrário, ele retorna `false`.
*
Tabela de verdade: | Operando 1 | Operando 2 | Resultado |
| ---------- | ---------- | -------- |
| `true` | `true` | `true` |
| `true` | `false` | `false` |
| `false` | `true` | `false` |
| `false` | `false` | `false` |
*
Exemplo (JavaScript): `` `JavaScript
deixe a idade =25;
deixe haslicense =true;
if (idade> =16 &&haslicense) {
console.log ("pode dirigir legalmente");
} outro {
console.log ("Não é possível dirigir legalmente");
}
`` `
Nesse caso, a condição `idade> =16 &&haslicense` será apenas` true` se a pessoa tiver pelo menos 16 * e * tiver uma licença.
2. Ou (disjunção) *
Símbolo: `||` (c ++, java, javascript, php, c#, go, ferrugem), `ou '(python, ruby),` | `(Pascal, vba)
*
Objetivo: Retorna `true` se
pelo menos um dos operandos é `true`. Ele retorna `false` apenas se ambos os operando forem` false`.
*
Tabela de verdade: | Operando 1 | Operando 2 | Resultado |
| ---------- | ---------- | -------- |
| `true` | `true` | `true` |
| `true` | `false` | `true` |
| `false` | `true` | `true` |
| `false` | `false` | `false` |
*
Exemplo (Python): `` `Python
Temperatura =20
isrening =false
Se temperatura <0 ou isrening:
Imprimir ("Fique dentro")
outro:
Imprima ("Aproveite o tempo")
`` `
A mensagem "Stay dentro" será impressa se a temperatura estiver abaixo de 0 * ou * está chovendo (ou ambos).
3. Não (negação) *
Símbolo: `!` (C ++, java, javascript, php, c#, go, ferrugem), `não '(python, ruby),` não' (Pascal), `não '(vba)
*
Objetivo: Inverte o valor booleano do operando. Se o operando for `true`,` não 'o fará `falso' e vice -versa.
*
Tabela de verdade: | Operando | Resultado |
| ---------- | -------- |
| `true` | `false` |
| `false` | `true` |
*
Exemplo (C ++): `` `c ++
bool isLoggedin =false;
if (! isloggedin) {
cout <<"Por favor, faça o login" <
} outro {
cout <<"Welcome" < }
`` `
O código verifica se o usuário não está * logado (`! Isloggedin`).
4. Xor (exclusivo ou)
* Símbolo: `^` (C ++, java, javascript, php, c#, go, ferrugem), `xor` (Pascal),` xor` (vba). O Python requer o uso de `! =` Para emular o XOR para booleanos.
* Objetivo: Retorna `true` se exatamente um dos operandos é `true`. Ele retorna `falso` se ambos os operando forem` true` ou ambos os operando forem `false`. Em outras palavras, os operando devem ser diferentes.
* Tabela de verdade:
| Operando 1 | Operando 2 | Resultado |
| ---------- | ---------- | -------- |
| `true` | `true` | `false` |
| `true` | `false` | `true` |
| `false` | `true` | `true` |
| `false` | `false` | `false` |
* Exemplo (php):
`` `php
$ isadult =true;
$ hasstudentDiscount =false;
if ($ isadult ^ $ hasstudentDiscount) {
eco "elegível para um desconto parcial";
} outro {
eco "não é elegível para um desconto parcial";
}
`` `
Este exemplo ilustra um cenário em que ser adulto *ou *ter um desconto de estudante se qualifica para um desconto *parcial *, mas não *ambos *.
5. Curto-circuito
Muitas linguagens de programação implementam avaliação de "curto-circuito" para os operadores `e` ou `ou '. Esta otimização pode melhorar o desempenho e impedir erros:
* `e` (` &&`ou` e`): Se o primeiro operando for `falso`, toda a expressão será` falsa`, então o segundo operando não é * avaliado.
* `ou` (` || `ou` ou`): Se o primeiro operando for "true", toda a expressão é "true", então o segundo operando não é * avaliado.
Exemplo de curto-circuito (JavaScript):
`` `JavaScript
Seja x =5;
Vamos IsValid =false;
if (isValid &&x ++> 0) {// x ++ é avaliado apenas se o isValid for verdadeiro
console.log ("Condição Met");
}
console.log (x); // saída:5 (x não foi incrementado)
`` `
Nesse caso, como o `isValid` é` falso`, `x ++> 0` nunca é avaliado, então` x` permanece 5. Isso é importante se o segundo operando tiver efeitos colaterais (como incrementar uma variável) ou se avaliar isso, pode levar a um erro (por exemplo, dividir por zero).
Considerações importantes:
* Precedência do operador: Os operadores lógicos têm uma precedência específica em relação a outros operadores (aritmética, comparação, etc.). Use parênteses `()` para garantir que as expressões sejam avaliadas na ordem que você pretende.
* Tipos de dados: Os operadores lógicos geralmente operam com os valores booleanos (verdadeiros ou falsos). Muitos idiomas converterão automaticamente outros tipos de dados em valores booleanos com base em certas regras (por exemplo, 0 é falso, o diferente de zero é verdadeiro; a string vazia é falsa, a sequência não vazia é verdadeira). Esteja ciente de como seu idioma lida com essas conversões.
* Operadores bitwise vs. operadores lógicos: Alguns idiomas possuem operadores bit (por exemplo, `&`, `|`, `^`, `` `em c/c ++/java) que se parecem com os operadores lógicos. Os operadores bitwise executam operações em bits individuais de valores inteiros, enquanto os operadores lógicos trabalham com os valores booleanos e retornam resultados booleanos. Não os confunda!
Ao entender e usar efetivamente os operadores lógicos, você pode criar programas complexos e robustos que respondam de maneira inteligente a diferentes condições.
