Logiska operatörer är grundläggande byggstenar vid programmering, så att du kan kombinera och manipulera booleska värden (sant eller falskt) för att skapa komplexa förhållanden. Här är några vanliga exempel på logiska operatörer, tillsammans med deras symboler och förklaringar:
1. Och (konjunktion)
* symbol: `&&` (C ++, Java, JavaScript, PHP, C#, Go, Rust), `och` (Python, Ruby),` &'(Pascal, VBA)
* Syfte: Returnerar `sant` om båda operander är "sant". Annars returnerar den "falsk".
* Sanningstabell:
| Operand 1 | Operand 2 | Resultat |
| ---------- | ---------- | -------- |
| `sant` | `sant` | `sant` |
| `sant` | `False '| `False '|
| `False '| `sant` | `False '|
| `False '| `False '| `False '|
* Exempel (JavaScript):
`` `JavaScript
Låt ålder =25;
låt haslicense =true;
if (ålder> =16 &&haslicense) {
console.log ("kan lagligt köra");
} annat {
console.log ("kan inte lagligt köra");
}
`` `
I det här fallet är villkoret "ålder> =16 &&haslicense" bara "sant" om personen är minst 16 * och * har en licens.
2. Eller (disjunktion)
* symbol: `||` (C ++, Java, JavaScript, PHP, C#, Go, Rust), `eller` (Python, Ruby),` | `(Pascal, VBA)
* Syfte: Returnerar `sant` om minst en av operanderna är "sant". Det returnerar "falskt" endast om båda operander är "falska".
* Sanningstabell:
| Operand 1 | Operand 2 | Resultat |
| ---------- | ---------- | -------- |
| `sant` | `sant` | `sant` |
| `sant` | `False '| `sant` |
| `False '| `sant` | `sant` |
| `False '| `False '| `False '|
* Exempel (Python):
`` `python
temperatur =20
israining =falsk
Om temperatur <0 eller israining:
tryck ("stanna inne")
annan:
tryck ("njut av vädret")
`` `
Meddelandet "Stay inuti" kommer att skrivas ut om temperaturen är under 0 * eller * det regnar (eller båda).
3. Inte (negation)
* symbol: `!` (C ++, Java, JavaScript, PHP, C#, Go, Rust), `inte '(Python, Ruby),' inte '(Pascal),' inte '(VBA)
* Syfte: Inverterar operandens booleska värde. Om operanden är "sant" gör det inte "falskt" och vice versa.
* Sanningstabell:
| Operand | Resultat |
| ---------- | -------- |
| `sant` | `False '|
| `False '| `sant` |
* Exempel (C ++):
`` `C ++
bool isLoggedin =falsk;
if (! isLoggedin) {
cout <<"Logga in" <
} annat {
cout <<"Välkommen" <
}
`` `
Koden kontrollerar om användaren är * inte * inloggad (`! IsLoggedin ').
4. Xor (exklusiv eller)
* symbol: `^` (C ++, Java, JavaScript, php, c#, go, rost), `xor` (Pascal),` xor` (VBA). Python kräver att du använder `! =` För att emulera xor för booleans.
* Syfte: Returnerar `sant` om exakt en av operanderna är "sant". Det returnerar "falskt" om båda operander är "sanna" eller båda operander är "falska". Med andra ord måste operanderna vara annorlunda.
* Sanningstabell:
| Operand 1 | Operand 2 | Resultat |
| ---------- | ---------- | -------- |
| `sant` | `sant` | `False '|
| `sant` | `False '| `sant` |
| `False '| `sant` | `sant` |
| `False '| `False '| `False '|
* Exempel (PHP):
`` `php
$ isadult =true;
$ hasStudentDiscount =falsk;
if ($ isadult ^ $ hasStudentDiscount) {
echo "berättigad till en delvis rabatt.";
} annat {
echo "inte berättigad till en partiell rabatt.";
}
`` `
Detta exempel illustrerar ett scenario där antingen att vara vuxen *eller *att ha en studentrabatt kvalificerar sig för en *partiell *rabatt, men inte *båda *.
5. Kortslutande
Många programmeringsspråk implementerar "kortslutande" utvärdering för "och" eller "eller". Denna optimering kan förbättra prestanda och förhindra fel:
* `och` (` &&`eller` och`): Om den första operanden är "falsk" är hela uttrycket "falskt", så den andra operanden är * inte * utvärderad.
* `eller` (` || `eller` eller`): Om den första operanden är "sant", är hela uttrycket "sant", så den andra operanden är * inte * utvärderad.
Exempel på kortslutning (JavaScript):
`` `JavaScript
Låt x =5;
Låt isValId =falsk;
if (isValid &&x ++> 0) {// x ++ utvärderas endast om isValid är sant
console.log ("tillstånd Met");
}
console.log (x); // utgång:5 (x ökades inte)
`` `
I det här fallet, eftersom `isValid 'är" falsk ", utvärderas aldrig," 0 "aldrig, så" x "förblir 5. Detta är viktigt om den andra operationen har biverkningar (som att öka en variabel) eller om utvärdering kan leda till ett fel (t.ex. delning med noll).
Viktiga överväganden:
* Operatörens företräde: Logiska operatörer har en specifik prioritet i förhållande till andra operatörer (aritmetik, jämförelse etc.). Använd parenteser `()` för att säkerställa att uttryck utvärderas i den ordning du tänker.
* Datatyper: Logiska operatörer arbetar vanligtvis med booleska värden (sant eller falskt). Många språk konverterar automatiskt andra datatyper till booleska värden baserat på vissa regler (t.ex. 0 är falskt, icke-noll är sant; tom sträng är falsk, icke-tom sträng är sant). Var medveten om hur ditt språk hanterar dessa omvandlingar.
* bitvis operatörer kontra logiska operatörer: Vissa språk har bitvis operatörer (t.ex. `&`, `|`, `^`, `~` i C/C ++/Java) som liknar logiska operatörer. Bitvisa operatörer utför operationer på enskilda bitar av heltal, medan logiska operatörer arbetar med booleska värden och returnerar booleska resultat. Förvirra dem inte!
Genom att förstå och effektivt använda logiska operatörer kan du skapa komplexa och robusta program som svarar intelligent på olika förhållanden.
