EMZETT.
Login

Emzett Wiki

Rust: Bedingungen, Schleifen und match

Properties1
tagsprogrammiersprachen, rust

4 Min. Lesezeit

Kurz: // if liefert einen Wert (kein ?: nötig) let status = if punkte >= 50 { “bestanden” } else { “durchgefallen” }; println!(“{status}”);

Teil des Kurses Rust

Kapitel 3 von 13 im Kurs Rust (Abschnitt „Programmablauf“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

if ist ein Ausdruck

fn main() {
    let punkte = 73;
    if punkte >= 90 {
        println!("sehr gut");
    } else if punkte >= 50 {
        println!("bestanden");
    } else {
        println!("nicht bestanden");
    }
 
    // if liefert einen Wert (kein ?: nötig)
    let status = if punkte >= 50 { "bestanden" } else { "durchgefallen" };
    println!("{status}");
 
    let zahl = 7;
    let art = if zahl % 2 == 0 { "gerade" } else { "ungerade" };
    println!("{zahl} ist {art}");
}

Ausgabe:

bestanden
bestanden
7 ist ungerade

Die Bedingung muss ein bool sein (kein “truthy”), und sie steht ohne Klammern.

Schleifen

fn main() {
    for i in 1..=5 {                  // 1 bis 5 (inklusive); 1..5 wäre ohne 5
        print!("{i} ");
    }
    println!();
 
    for i in (1..=10).rev().step_by(3) {
        print!("{i} ");
    }
    println!();
 
    let farben = ["rot", "grün", "blau"];
    for farbe in farben { print!("{farbe} "); }
    println!();
    for (i, farbe) in farben.iter().enumerate() { print!("{i}={farbe} "); }
    println!();
 
    let mut n = 1;
    while n < 100 { n *= 2; }
    println!("{n}");
 
    let mut zaehler = 0;
    let ergebnis = loop {             // loop: endlos, break kann einen Wert liefern
        zaehler += 1;
        if zaehler == 5 { break zaehler * 10; }
    };
    println!("{ergebnis}");
 
    for i in 1..=10 {
        if i % 2 == 0 { continue; }
        if i > 7 { break; }
        print!("{i} ");
    }
    println!();
 
    'aussen: for a in 1..10 {         // Marken für verschachtelte Schleifen
        for b in 1..10 {
            if a * b == 42 { println!("{a} * {b}"); break 'aussen; }
        }
    }
}

Ausgabe:

1 2 3 4 5
10 7 4 1
rot grün blau
0=rot 1=grün 2=blau
128
50
1 3 5 7
6 * 7

match: Muster vergleichen

match ist eines der mächtigsten Werkzeuge in Rust. Es prüft einen Wert gegen Muster und der Compiler stellt sicher, dass alle Fälle abgedeckt sind:

fn beschreibe(n: i32) -> &'static str {
    match n {
        0 => "null",
        1 | 2 | 3 => "klein",
        4..=9 => "mittel",
        x if x < 0 => "negativ",         // Guard: zusätzliche Bedingung
        _ => "groß",                      // _ = alles andere
    }
}
 
fn main() {
    for n in [0, 2, 7, -5, 100] {
        println!("{n}: {}", beschreibe(n));
    }
    let tag = 6;
    let art = match tag {
        1..=5 => "Werktag",
        6 | 7 => "Wochenende",
        _ => "ungültig",
    };
    println!("{art}");
 
    let paar = (3, -3);
    match paar {
        (x, y) if x + y == 0 => println!("Summe null"),
        (x, _) if x % 2 == 1 => println!("x ist ungerade"),
        _ => println!("sonst"),
    }
}

Ausgabe:

0: null
2: klein
7: mittel
-5: negativ
100: groß
Wochenende
Summe null

Vergisst du einen Fall, meldet der Compiler einen Fehler. Dadurch wird match besonders sicher, wenn du später neue Varianten ergänzt.

if let und let else

Wenn dich nur ein Muster interessiert:

fn main() {
    let eingabe = Some(5);
    if let Some(n) = eingabe {
        println!("Wert: {n}");
    } else {
        println!("nichts");
    }
 
    let text = "42";
    let Ok(zahl) = text.parse::<i32>() else {     // let else: früh verlassen
        println!("keine Zahl");
        return;
    };
    println!("{}", zahl + 1);
 
    let mut stapel = vec![1, 2, 3];
    while let Some(oben) = stapel.pop() {          // while let: solange es etwas gibt
        print!("{oben} ");
    }
    println!();
 
    let wert = 8;
    println!("{}", matches!(wert, 5..=10));
}

Ausgabe:

Wert: 5
43
3 2 1
true

Merke

  • if und match sind Ausdrücke und liefern Werte
  • Bedingungen müssen bool sein, ohne Klammern
  • Schleifen: for x in iterator, while, loop (mit break wert)
  • Bereiche: 1..5 (ohne Ende), 1..=5 (mit Ende)
  • match prüft Muster und erzwingt Vollständigkeit; _ fängt den Rest
  • if let, while let, let else, matches! für Einzelmuster

Übungsaufgabe

Schreibe FizzBuzz für 1 bis 20 mit match (i % 3, i % 5).

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Variablen, Typen und Ausgabe

Weiter: Funktionen und Closures

Alle Kapitel: Rust im Überblick

Graphansicht

Backlinks