Logische Operatoren Teil 1

Teil des Abschnitts Fundamentals der Rust-Journey von Coddy — Lektion 20 von 75.

Logische Operatoren werden verwendet, um Kombinationen von Vergleichen zu prüfen, die true oder false zurückgeben.

Zum Beispiel enthält die folgende Anweisung zwei Vergleiche:

Ist 5 größer als 3 und kleiner als 6?

Operator	Bedeutung	Beispiel
`&&`	Und - `true`, wenn alle Operanden `true` sind	`a && b`
`\|\|`	Oder - `true`, wenn mindestens ein Operand `true` ist	`a \|\| b`
`!`	Nicht - `true`, wenn der Operand `false` ist	`!a`

Schauen wir uns einige Beispiele an,

5 ist größer als 3 und 1 ist gleich 1,

let b1: bool = (5 > 3) && (1 == 1); // ergibt true

Erklärung: Alle Operanden sind true, daher wird b1 den Wert true enthalten (die and-Operation ist true, wenn beide Operanden true sind).

5 ist nicht gleich 4 oder 5 ist gleich 2,

let b2: bool = !(5 == 4) || (5 == 2); // holds true

Erklärung: Der erste Operand (5 != 4) ist true, daher ist b2 ebenfalls true (die or-Operation ist true, wenn einer der Operanden true ist)

1 ist nicht gleich 1 oder false,

let b3: bool = !(1 == 1) || false; // enthält false

Erklärung: Alle Operanden sind false, daher enthält b3 den Wert false (or-Operation).

nicht (3 ist größer als 4),

let b4: bool = !(3 > 4); // ist wahr

Erklärung: Der Operand ist false, daher wird b4 den Wert true enthalten (not-Operation).

nicht (5 ist größer als 10 oder 5 ist größer als 1),

let b5: bool = !(5 > 10 || 5 > 1); // enthält false

Erklärung: 5 > 10 || 5 > 1 ist true (einer der Operanden ist true), insgesamt ist b5 also false (not-Operation).

Aufgabe

Anfänger

Dir wird Code zur Verfügung gestellt. Ersetze die Fragezeichen der Variablen b1 und b2 durch boolesche Werte, so dass b3 den Wert true enthält.

Es gibt mehr als eine richtige Lösung.

Spickzettel

Logische Operatoren werden verwendet, um Kombinationen von Vergleichen zu prüfen, die true oder false zurückgeben.

Operator	Bedeutung	Beispiel
`&&`	Und - `true`, wenn alle Operanden `true` sind	`a && b`
`\|\|`	Oder - `true`, wenn irgendein Operand `true` ist	`a \|\| b`
`!`	Nicht - `true`, wenn der Operand `false` ist	`!a`

Beispiele:

let b1: bool = (5 > 3) && (1 == 1); // true (beide Operanden sind true)
let b2: bool = !(5 == 4) || (5 == 2); // true (der erste Operand ist true)
let b3: bool = !(1 == 1) || false; // false (beide Operanden sind false)
let b4: bool = !(3 > 4); // true (Operand ist false, daher gibt die Not-Operation true zurück)
let b5: bool = !(5 > 10 || 5 > 1); // false (der Ausdruck im Inneren ist true, daher gibt die Not-Operation false zurück)

Probier es selbst

fn main() {
    // Gib deinen Code unten ein
    let b1: bool = ?;
    let b2: bool = ?;
    let b3: bool = b1 || b2;
    
    // Ändere die folgende Zeile nicht
    println!("b3 = {}", b3);
}