Booleans in Rust

Ein Boolean ist der einfachste Typ überhaupt: Er kann nur true (wahr) oder false (falsch) sein. In Rust heißt er bool, und du brauchst ihn überall dort, wo dein Code eine Entscheidung treffen muss.

Einen Boolean deklarieren

fn main() {
    let is_active = true;
    let has_error: bool = false;
    println!("aktiv: {is_active}, Fehler: {has_error}");
}

▶ Selbst ausprobieren

Rust erkennt bool bei true/false fast immer selbst. Den Typ musst du also nur selten ausschreiben.

Booleans entstehen meistens durch Vergleiche

In echtem Code schreibst du true oder false selten direkt hin. Meistens entstehen sie, wenn du etwas vergleichst:

fn main() {
    let age = 20;
    let can_vote = age >= 18;
    println!("Darf wählen: {can_vote}");
}

Ausgabe:

Darf wählen: true

▶ Selbst ausprobieren

Booleans in Bedingungen

Die Hauptaufgabe eines bool ist es zu entscheiden, welcher Zweig eines if ausgeführt wird:

fn main() {
    let is_raining = true;

    if is_raining {
        println!("Nimm einen Regenschirm mit");
    } else {
        println!("Lass ihn zu Hause");
    }
}

if behandeln wir ausführlich auf der Seite If…Else. Das hier ist nur ein Vorgeschmack, warum Booleans so wichtig sind.

Hinweis

Anders als manche Sprachen behandelt Rust 0, einen leeren String oder null nicht als „falsy“ (also wie false). Eine Bedingung muss ein echtes bool sein – etwas anderes ist dort nicht erlaubt. So fängt der Compiler eine ganze Klasse von Bugs schon beim Kompilieren ab.

Booleans kombinieren und Kurzschlussauswertung

&& (und), || (oder) und ! (nicht) kennst du schon von der Seite Operatoren. Eine Sache solltest du darüber aber noch wissen: Sie hören früh auf, sobald das Ergebnis feststeht. Das nennt man Kurzschlussauswertung (Short-Circuit Evaluation).

• Bei a && b: Ist a gleich false, muss das Ganze false sein. Rust schaut sich b also gar nicht mehr an.
• Bei a || b: Ist a gleich true, muss das Ganze true sein. Rust schaut sich b also gar nicht mehr an.

Das ist mehr als ein Trick für mehr Tempo. Die linke Seite kann so die rechte Seite schützen:

fn main() {
    let count = 0;
    let total = 50;

    // count ist 0, also hört Rust nach `count != 0` auf und teilt nie.
    let big_average = count != 0 && total / count > 10;
    println!("großer Durchschnitt: {big_average}");

    let is_weekend = true;
    let has_homework = true;
    // is_weekend ist true, also wird `!has_homework` nie geprüft.
    let can_relax = is_weekend || !has_homework;
    println!("kann entspannen: {can_relax}");
}

Ausgabe:

großer Durchschnitt: false
kann entspannen: true

▶ Selbst ausprobieren

Eine Division durch null würde das Programm abstürzen lassen. Weil count != 0 zuerst kommt und false ist, wird die Division einfach nie ausgeführt. Vertauschst du die beiden Seiten (total / count > 10 && count != 0), käme die Division zuerst. Hier erkennt das sogar der Compiler und weigert sich, das Programm zu bauen („this operation will panic at runtime“, also: Diese Operation löst zur Laufzeit eine Panic aus). Bei einem Wert, der erst während des Programms ankommt, würde es stattdessen abstürzen. Setz die „Sicherheitsprüfung“ deshalb nach links.

Tipp

Bei einem Boolean brauchst du nie == true oder == false. Schreib if is_ready statt if is_ready == true und if !is_ready statt if is_ready == false. Das bedeutet genau dasselbe und liest sich natürlicher.

Übungen

1. Darf das Kind mitfahren?

Bei einem Fahrgeschäft im Freizeitpark darfst du mitfahren, wenn du mindestens 120 cm groß bist – oder wenn du mindestens 8 Jahre alt bist und mit einem Erwachsenen fährst. Speichere eine Größe von 115, ein Alter von 9 und with_adult = true. Gib dann aus, ob dieses Kind mitfahren darf. Tipp: Fasse den Teil „Alter und Erwachsener“ mit Klammern zusammen.

Lösung anzeigen

fn main() {
    let height_cm = 115;
    let age = 9;
    let with_adult = true;

    let tall_enough = height_cm >= 120;
    let can_ride = tall_enough || (age >= 8 && with_adult);

    println!("groß genug: {tall_enough}");
    println!("darf mitfahren: {can_ride}");
}

Ausgabe:

groß genug: false
darf mitfahren: true

▶ Selbst ausprobieren

2. Schaltjahre

Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist, aber nicht durch 100 – oder wenn es durch 400 teilbar ist. Berechne ein Boolean is_leap für 2024, gib es aus und mach dasselbe für 1900. Tipp: „durch 4 teilbar“ ist year % 4 == 0, und du kannst year und is_leap mit einem zweiten let verschatten (Shadowing).

Lösung anzeigen

fn main() {
    let year = 2024;
    let is_leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    println!("{year} ist ein Schaltjahr: {is_leap}");

    let year = 1900;
    let is_leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    println!("{year} ist ein Schaltjahr: {is_leap}");
}

Ausgabe:

2024 ist ein Schaltjahr: true
1900 ist ein Schaltjahr: false

▶ Selbst ausprobieren

Zusammenfassung

• bool hat genau zwei Werte: true oder false.
• Vergleiche (==, <, >=, …) liefern Booleans.
• Bedingungen in if müssen ein echtes bool sein – keine automatische Umwandlung von Zahlen oder Strings.
• && und || werten kurzschlussartig aus: Sie überspringen die rechte Seite, sobald das Ergebnis feststeht. Setz Sicherheitsprüfungen also nach links.

Kurzer Check

Kurzer Check

1. Welchen Typ liefert ein Vergleich wie age >= 18?

Ein bool Eine Ganzzahl Einen String

2. Kannst du in Rust eine Ganzzahl wie 0 direkt als Bedingung in einem if verwenden, so wie in manchen anderen Sprachen?

Ja, 0 gilt als false Nein – die Bedingung muss ein echtes bool sein Ja, aber nur bei i32

3. Was passiert bei count != 0 && total / count > 10, wenn count gleich 0 ist?

Das Programm stürzt wegen Division durch null ab Rust hört nach count != 0 auf, und der ganze Ausdruck ist false Es lässt sich nicht kompilieren

Punkte: 0 / 3

Weiterlesen

• Der boolesche Typ – Die Programmiersprache Rust: die kurze offizielle Einführung in bool, zusammen mit den anderen Grundtypen.
• bool – Doku der Standardbibliothek (auf Englisch): alle Methoden von bool, etwa then und then_some – für später, wenn du so weit bist.
• Lazy boolean operators – The Rust Reference (auf Englisch): die genauen Regeln, wie && und || ihre rechte Seite überspringen.
• Primitives – Rust by Example (auf Englisch): bool neben den anderen eingebauten Typen von Rust, mit einem lauffähigen Beispiel.