Learn Rust Coding · Lektion

match im Detail

Patterns und Guards

match im Detail ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Der match-Ausdruck

match vergleicht einen Wert mit einer Reihe von Mustern und führt den Arm des ersten passenden Musters aus. Da es sich um einen Ausdruck handelt, gibt er einen Wert zurück.

fn main() {
    let n = 3;
    let label = match n {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "many",
    };
    println!("{label}");
}

Vollständigkeit

Ein match muss jeden möglichen Wert abdecken. Der Platzhalter _ fängt alles ab, was von vorherigen Armen nicht erfasst wurde, und stellt so die Vollständigkeit sicher.

fn main() {
    let x = 42;
    match x {
        0 => println!("zero"),
        _ => println!("nonzero"),
    }
}

Mehrere Werte abgleichen

Verwenden Sie |, um mehrere Muster in einem Arm abzugleichen.

fn main() {
    let c = 'e';
    match c {
        'a' | 'e' | 'i' | 'o' | 'u' => println!("vowel"),
        _ => println!("consonant"),
    }
}

Bereichsmuster

Gleichen Sie mit ..= einen Wertebereich ab (einschließlich der Grenzen). Das eignet sich hervorragend, um Zahlen oder Zeichen zu gruppieren.

fn main() {
    let score = 85;
    let grade = match score {
        90..=100 => 'A',
        80..=89 => 'B',
        70..=79 => 'C',
        _ => 'F',
    };
    println!("Grade: {grade}");
}

Match-Guards

Ein Guard ist eine zusätzliche if-Bedingung für einen Arm. Der Arm passt nur, wenn das Muster übereinstimmt und der Guard wahr ist.

fn main() {
    let pair = (2, -2);
    match pair {
        (x, y) if x + y == 0 => println!("sum is zero"),
        (x, _) if x % 2 == 0 => println!("first is even"),
        _ => println!("no rule"),
    }
}

Binden in Mustern

Muster können die abgeglichenen Teile an Variablen binden, damit diese im Body des Arms verwendet werden können.

fn main() {
    let msg = Some(7);
    match msg {
        Some(n) => println!("got {n}"),
        None => println!("nothing"),
    }
}

Enums abgleichen

match spielt seine Stärken bei Enums aus, insbesondere wenn Varianten Daten enthalten.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn area(s: Shape) -> f64 {
    match s {
        Shape::Circle(r) => 3.14159 * r * r,
        Shape::Rectangle(w, h) => w * h,
    }
}

fn main() {
    println!("{}", area(Shape::Rectangle(3.0, 4.0)));
}

Mit _ und .. ignorieren

Verwenden Sie _, um einen einzelnen Wert zu ignorieren, und .., um den Rest eines Tupels oder einer Struktur zu ignorieren.

fn main() {
    let triple = (1, 2, 3);
    match triple {
        (first, ..) => println!("first is {first}"),
    }
}

Aus match zurückgeben

Da match ein Ausdruck ist, können Sie sein Ergebnis zuweisen oder direkt zurückgeben. Jeder Arm muss denselben Typ liefern.

fn describe(n: i32) -> &'static str {
    match n.cmp(&0) {
        std::cmp::Ordering::Less => "negative",
        std::cmp::Ordering::Equal => "zero",
        std::cmp::Ordering::Greater => "positive",
    }
}

fn main() {
    println!("{}", describe(-5));
}

Die Reihenfolge der Arme ist wichtig

Die Arme werden von oben nach unten geprüft; der erste passende Arm gewinnt. Stellen Sie spezifische Muster vor allgemeine und den Platzhalter an die letzte Stelle.

Bereiche mit @ binden

Kombinieren Sie einen Bereich mit dem Operator @, um einen Wert zu prüfen und gleichzeitig seinen genauen Inhalt im selben Arm zu behalten.

fn main() {
    let n = 42;
    match n {
        small @ 0..=9 => println!("single digit: {small}"),
        big @ 10..=99 => println!("two digits: {big}"),
        _ => println!("large"),
    }
}

Schnelltest

Welchen Zweck hat ein Match-Guard wie (x, y) if x > y?

Zusammenfassung

Sie haben match ausführlich kennengelernt:

Es ist ein vollständiger Ausdruck, der einen Wert zurückgibt
| gleicht mehrere Muster ab; ..= gleicht Bereiche ab
Guards fügen zusätzliche if-Bedingungen hinzu
Muster binden Daten; _ und .. ignorieren Teile
Die Reihenfolge der Arme ist wichtig – der erste Treffer gewinnt

Häufig gestellte Fragen

Ist die Lektion „match im Detail“ kostenlos?

Ja — der vollständige Text von „match im Detail“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „match im Detail“?

Patterns und Guards Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „match im Detail“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding