Match-Guards und Bindings
Fügen Sie Bedingungen hinzu und erfassen Sie Werte.
Match-Guards und Bindings ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 4 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.
Was ist ein Match-Guard?
Ein Match-Guard ist eine zusätzliche if-Bedingung, die zu einem Match-Arm hinzugefügt wird. Der Arm wird nur ausgeführt, wenn das Muster übereinstimmt und die Bedingung wahr ist.
Damit können Sie eine Variante anhand ihrer Daten in feinere Fälle aufteilen.
match number {
Some(n) if n > 0 => println!("positive"),
Some(n) => println!("zero or negative"),
None => println!("no number"),
}Syntax eines Guards
Schreiben Sie zuerst das Muster, dann if condition und anschließend =>. Die Bedingung kann alle Variablen verwenden, an die das Muster Werte gebunden hat.
Wenn der Guard falsch ist, versucht Rust den nächsten Arm.
fn main() {
let n = 4;
match n {
x if x % 2 == 0 => println!("even"),
_ => println!("odd"),
}
}Guards mit Enum-Daten
Guards sind besonders nützlich bei Enums, die Daten enthalten. Sie binden den inneren Wert und prüfen ihn anschließend.
Hier erhalten ein positives und ein negatives Guthaben unterschiedliche Nachrichten, obwohl beide zur selben Variante gehören.
enum Account {
Balance(i32),
Closed,
}
fn main() {
let a = Account::Balance(-5);
match a {
Account::Balance(b) if b < 0 => println!("overdrawn"),
Account::Balance(b) => println!("balance {}", b),
Account::Closed => println!("closed"),
}
}Die Reihenfolge ist weiterhin wichtig
Da die Arme von oben nach unten ausprobiert werden, setzen Sie den spezifischeren Arm mit Guard vor den allgemeinen.
Wenn der einfache Balance(b)-Arm zuerst käme, würde er auf alles passen und der Arm mit Guard würde nie ausgeführt.
Abgleich mit Literalwerten
Sie können im Muster auch direkt auf bestimmte Literale abgleichen, ohne einen Guard zu verwenden.
Hier werden 0 und 1 exakt abgeglichen, während _ den Rest übernimmt.
fn main() {
let n = 1;
match n {
0 => println!("zero"),
1 => println!("one"),
_ => println!("many"),
}
}Abgleich von Bereichen
Muster können mit ..= auf einen Wertebereich abgleichen, der beide Grenzen einschließt.
Das ist eine übersichtliche Alternative zu mehreren Vergleichs-Guards.
fn main() {
let score = 85;
match score {
0..=59 => println!("fail"),
60..=100 => println!("pass"),
_ => println!("out of range"),
}
}Binden mit dem @-Operator
Mit dem @-Operator können Sie einen Wert auf ein Muster prüfen und ihn gleichzeitig an einen Namen binden.
Hier prüft id @ 1..=5 den Bereich und speichert den tatsächlichen Wert in id, damit Sie ihn ausgeben können.
fn main() {
let n = 3;
match n {
id @ 1..=5 => println!("small id {}", id),
other => println!("other {}", other),
}
}Den gesamten Wert binden
Ein einfacher Name in einem Muster, wie das obige other, bindet den gesamten Wert. Er dient als Auffangmuster, das Sie trotzdem verwenden können.
Verwenden Sie _, wenn Sie den Wert ignorieren möchten, und einen Namen, wenn Sie ihn benötigen.
fn main() {
let n = 99;
match n {
0 => println!("zero"),
value => println!("got {}", value),
}
}Guards und Bindings gemeinsam verwenden
Sie können ein Binding mit einem Guard kombinieren, um eine präzise Kontrolle zu erhalten: Binden Sie die Daten und fügen Sie anschließend eine Bedingung hinzu.
Dieses Programm kennzeichnet große gerade Guthaben besonders.
enum Account {
Balance(i32),
}
fn main() {
let a = Account::Balance(200);
match a {
Account::Balance(b) if b > 100 && b % 2 == 0 => println!("big even {}", b),
Account::Balance(b) => println!("normal {}", b),
}
}Guards für mehrere Muster
Ein Guard gilt für den gesamten Arm, auch wenn der Arm Muster mit | kombiniert.
Die Bedingung wird geprüft, nachdem eines der aufgeführten Muster übereinstimmt.
fn main() {
let n = 6;
match n {
2 | 4 | 6 if n > 3 => println!("big even"),
_ => println!("other"),
}
}Alles zusammenführen
Dieses abschließende Programm kombiniert Varianten mit Daten, ein Binding, einen Guard und ein Auffangmuster, um einen Temperaturwert zu klassifizieren.
Ändern Sie den Wert und führen Sie das Programm erneut aus, um zu sehen, welche Arme ausgelöst werden.
enum Reading {
Temp(i32),
Missing,
}
fn main() {
let r = Reading::Temp(38);
match r {
Reading::Temp(t) if t >= 38 => println!("fever: {}", t),
Reading::Temp(t) => println!("normal: {}", t),
Reading::Missing => println!("no reading"),
}
}Kurze Überprüfung
Überprüfen Sie Ihr Verständnis von Guards und Bindings.
Zusammenfassung
Sie haben gelernt, Abgleiche mit Guards (pattern if condition) zu verfeinern, auf Literale und Bereiche (..=) abzugleichen und mit Namen oder dem @-Operator Bindings zu erstellen.
Zusammen mit allem zuvor Gelernten können Sie nun feste Zustandsmengen modellieren, ihnen Daten zuordnen und präzise auf jeden Fall reagieren. Gute Arbeit mit Enums und match!
Häufig gestellte Fragen
Ist die Lektion „Match-Guards und Bindings“ kostenlos?
Ja — der vollständige Text von „Match-Guards und Bindings“ 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-Guards und Bindings“?
Fügen Sie Bedingungen hinzu und erfassen Sie Werte. 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 4 von 4.
Wie lange dauert die Lektion „Match-Guards und Bindings“?
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
- Ihr erstes Enum definieren
- Auf Enum-Varianten matchen
- Enums mit Daten
- Match-Guards und Bindings