1. E (congiunzione)
* Simbolo: `&&` (C ++, Java, JavaScript, Php, C#, Go, Rust), `e` (Python, Ruby),` &`(Pascal, VBA)
* Scopo: Restituisce `vero` se entrambi Gli operandi sono `Vero`. Altrimenti, restituisce "false".
* Tabella della verità:
| OPERAND 1 | Operand 2 | Risultato |
| ---------- | ---------- | -------- |
| `vero` `vero` `vero`
| `vero` `False`. `False`.
| `False`. `vero` `False`.
| `False`. `False`. `False`.
* Esempio (JavaScript):
`` `JavaScript
Lascia l'età =25;
Lascia che haslicense =true;
if (age> =16 &&haslicense) {
console.log ("può guidare legalmente");
} altro {
Console.log ("Impossibile guidare legalmente");
}
`` `
In questo caso, la condizione `età> =16 &&haslicense` sarà` vera` solo se la persona ha almeno 16 * e * ha una licenza.
2. O (disgiunzione)
* Simbolo: `||` (C ++, Java, JavaScript, Php, C#, Go, Rust), `Or` (Python, Ruby),` | `(Pascal, VBA)
* Scopo: Restituisce `vero` se almeno uno degli operandi è "vero". Restituisce "Falso" solo se entrambi gli operandi sono "falsi".
* Tabella della verità:
| OPERAND 1 | Operand 2 | Risultato |
| ---------- | ---------- | -------- |
| `vero` `vero` `vero`
| `vero` `False`. `vero`
| `False`. `vero` `vero`
| `False`. `False`. `False`.
* Esempio (Python):
`` `Python
temperatura =20
israining =false
Se temperatura <0 o israining:
Stampa ("Resta dentro")
altro:
Stampa ("Goditi il tempo")
`` `
Il messaggio "Stay Inside" verrà stampato se la temperatura è inferiore a 0 * o * piove (o entrambi).
3. NOT (negazione)
* Simbolo: `!` (C ++, Java, JavaScript, Php, C#, Go, Rust), `Not` (Python, Ruby),` Not` (Pascal), `Not` (VBA)
* Scopo: Inverte il valore booleano dell'operando. Se l'operando è `True`,` not` lo rende `false` e viceversa.
* Tabella della verità:
| Operand | Risultato |
| ---------- | -------- |
| `vero` `False`.
| `False`. `vero`
* Esempio (C ++):
`` `C ++
bool isloggedIn =false;
if (! isloggedin) {
cout <<"Accedi" <
cout <<"benvenuto" <
`` `
Il codice controlla se l'utente non è * effettuato l'accesso (`! Isloggedin`).
4. XOR (esclusivo o)
* Simbolo: `^` (C ++, Java, JavaScript, Php, C#, Go, Rust), `Xor` (Pascal),` Xor` (VBA). Python richiede l'uso di `! =` Per emulare XOR per Boolean.
* Scopo: Restituisce `vero` se esattamente uno degli operandi è "vero". Restituisce `false` se entrambi gli operandi sono` veri o entrambi gli operandi sono `falsi '. In altre parole, gli operandi devono essere diversi.
* Tabella della verità:
| OPERAND 1 | Operand 2 | Risultato |
| ---------- | ---------- | -------- |
| `vero` `vero` `False`.
| `vero` `False`. `vero`
| `False`. `vero` `vero`
| `False`. `False`. `False`.
* Esempio (PHP):
`` `php
$ ISADULT =TRUE;
$ hastudentdiscount =false;
if ($ ISADULT ^ $ HASStudentDiscount) {
echo "idoneo per uno sconto parziale";
} altro {
eco "non idoneo per uno sconto parziale.";
}
`` `
Questo esempio illustra uno scenario in cui essere un adulto *o *avere uno sconto per studenti si qualifica per uno sconto *parziale *, ma non *entrambi *.
5. Corto circuito
Molti linguaggi di programmazione implementano una valutazione "corta circuiting" per gli operatori `e` o 'o`. Questa ottimizzazione può migliorare le prestazioni e prevenire gli errori:
* `e` (` &&`o` e`): Se il primo operando è `false`, l'intera espressione è` false`, quindi il secondo operando non viene * valutato.
* `o` (` || `o` o`): Se il primo operando è `vero`, l'intera espressione è` vera`, quindi il secondo operando è * non * valutato.
Esempio di corto circuito (JavaScript):
`` `JavaScript
Sia x =5;
lascia isvalid =false;
if (isvalid &&x ++> 0) {// x ++ viene valutato solo se isvalid è vero
console.log ("condizione Met");
}
console.log (x); // output:5 (x non è stato incrementato)
`` `
In questo caso, poiché `isvalid` è` false`, `x ++> 0` non viene mai valutato, quindi` x` rimane 5. Questo è importante se il secondo operando ha effetti collaterali (come l'incremento di una variabile) o se valutarlo potrebbe portare a un errore (ad esempio, dividere per zero).
Considerazioni importanti:
* Precedenza dell'operatore: Gli operatori logici hanno una precedenza specifica rispetto ad altri operatori (aritmetica, confronto, ecc.). Usa le parentesi `()` per garantire che le espressioni siano valutate nell'ordine che si intende.
* Tipi di dati: Gli operatori logici in genere operano con valori booleani (vero o falso). Molte lingue convertiranno automaticamente altri tipi di dati in valori booleani in base a determinate regole (ad esempio, 0 è falso, il diverso da zero è vero; la stringa vuota è falsa, la stringa non vuota è vera). Sii consapevole di come la tua lingua gestisce queste conversioni.
* Operatori bitwise contro operatori logici: Alcune lingue hanno operatori bitwise (ad esempio, `&`, `|`, `^`, `~` in C/C ++/Java) che sembrano simili agli operatori logici. Gli operatori bitwise eseguono operazioni su singoli bit di valori interi, mentre gli operatori logici lavorano sui valori booleani e restituiscono risultati booleani. Non confonderli!
Comprendendo e utilizzando efficacemente gli operatori logici, è possibile creare programmi complessi e robusti che rispondono in modo intelligente a condizioni diverse.
Informazioni correlate
Programmazione © www.354353.com