0Pricing
Learn Rust Coding · Lektion

Leistungsfähiges Pattern Matching

Beherrschen Sie `match`-Ausdrücke und weitere Pattern-Matching-Konstrukte, um Datenvarianten prägnant und vollständig zu verarbeiten.

Leistungsfähiges Pattern Matching ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. 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 3 Lektionen.

Pattern Matching entfesselt seine Möglichkeiten

Willkommen in der Welt des Pattern Matchings in Rust! Mit dieser leistungsfähigen Funktion können Sie den Programmfluss anhand der Struktur von Daten steuern.

Statt lediglich auf Gleichheit zu prüfen, können Sie Werte dekonstruieren, Bestandteile extrahieren und für verschiedene Datenstrukturen bestimmten Code ausführen.

  • Es ähnelt einer besonders leistungsfähigen if/else- oder switch-Anweisung.
  • Es gewährleistet Vollständigkeit: Sie müssen alle möglichen Muster behandeln.
  • Dadurch wird der Code lesbarer und robuster.

Grundlagen des Ausdrucks `match`

Das Herzstück des Pattern Matchings ist der match-Ausdruck. Er nimmt einen Wert entgegen und vergleicht ihn mit einer Reihe von Mustern. Das erste passende Muster gewinnt!

Jeder „Arm“ eines match-Ausdrucks besteht aus einem Muster und dem Code, der ausgeführt wird, wenn dieses Muster passt.

enum Direction {
  North,
  East,
  South,
  West,
}

fn main() {
  let my_direction = Direction::North;

  match my_direction {
    Direction::North => println!("Going up!"),
    Direction::East => println!("Going right!"),
    Direction::South => println!("Going down!"),
    Direction::West => println!("Going left!"),
  }
}

Literale und Bereiche abgleichen

Sie können bestimmte Literale (Zahlen, Zeichen und boolesche Werte) abgleichen oder mithilfe von ..= Bereiche definieren. Mit dem Operator | können Sie mehrere Muster mit einem einzigen Arm abgleichen.

Denken Sie daran: Muster werden der Reihe nach geprüft, und der erste Treffer wird verwendet.

fn main() {
  let x = 7;

  match x {
    1 => println!("It's one!"),
    2 | 3 => println!("It's two or three!"),
    4..=8 => println!("It's between four and eight!"),
    _ => println!("It's something else!"), // Catch-all
  }

  let character = 'b';
  match character {
    'a'..='e' => println!("Early letter"),
    _ => println!("Other letter"),
  }
}

Structs dekonstruieren

Beim Dekonstruieren komplexer Datentypen wie Structs kommt Pattern Matching besonders gut zur Geltung. Sie können einzelne Felder direkt innerhalb des match-Arms in Variablen übernehmen.

Dadurch lassen sich Struct-Daten sauber und kompakt nutzen, insbesondere wenn bestimmte Feldwerte abgeglichen werden.

struct Point {
  x: i32,
  y: i32,
}

fn main() {
  let p = Point { x: 0, y: 7 };

  match p {
    Point { x, y: 0 } => println!("On the X axis at {}", x),
    Point { x: 0, y } => println!("On the Y axis at {}", y),
    Point { x, y } => println!("Not on an axis: ({}, {})", x, y),
  }
}

Enums mit Daten dekonstruieren

Enums in Rust können zugehörige Daten enthalten. Pattern Matching ist die wichtigste Möglichkeit, diese Daten aus einer Enum-Variante zu extrahieren.

Sie können die Daten direkt in neue Variablen dekonstruieren, sodass Sie einfach mit dem Inhalt jeder Variante arbeiten können.

enum Message {
  Quit,
  Move { x: i32, y: i32 },
  Write(String),
  ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
  match msg {
    Message::Quit => println!("Quit message."),
    Message::Move { x, y } => {
      println!("Move to x: {}, y: {}", x, y);
    }
    Message::Write(text) => println!("Text message: {}", text),
    Message::ChangeColor(r, g, b) => {
      println!("Color: R:{}, G:{}, B:{}", r, g, b);
    }
  }
}

fn main() {
  process_message(Message::Move { x: 10, y: 20 });
  process_message(Message::Write(String::from("Hello!")));
}

Das Platzhaltermuster `_`

Das spezielle Muster _ (Unterstrich) fungiert als Fang-all-Muster. Es passt auf jeden Wert, bindet diesen Wert jedoch nicht.

Es ist nützlich, wenn Sie für die Vollständigkeit alle Möglichkeiten abdecken müssen, der konkrete Wert für einen bestimmten Arm jedoch nicht relevant ist.

fn main() {
  let some_value = Some(5);
  let absent_value: Option<i32> = None;

  match some_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("Something else!"), // Matches None too
  }

  match absent_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("No value here!"),
  }
}

`if let` für einzelne Muster

Manchmal möchten Sie nur ein bestimmtes Muster abgleichen und alle anderen ignorieren. Für solche Fälle ist if let eine kompaktere Alternative zu einem vollständigen match-Ausdruck.

Im Wesentlichen bedeutet es: „Wenn dieses Muster passt, führe dies aus; andernfalls tue nichts (oder führe einen optionalen else-Block aus).“.

fn main() {
  let config_max = Some(3u8);
  let none_value: Option<u8> = None;

  if let Some(max) = config_max {
    println!("Max configured to be: {}", max);
  }

  if let Some(val) = none_value {
    println!("This won't print: {}", val);
  } else {
    println!("No value found!");
  }
}

`while let` für bedingte Schleifen

Ähnlich wie if let ermöglicht while let eine Schleife, solange ein Muster weiterhin passt.

Das ist äußerst nützlich, um Elemente aus Collections wie Vecs zu verarbeiten, wenn Sie fortfahren möchten, bis keine passenden Elemente mehr vorhanden sind (z. B. bis pop() None zurückgibt).

fn main() {
  let mut stack = vec![1, 2, 3];

  while let Some(top) = stack.pop() {
    println!("Popped: {}", top);
  }

  println!("Stack is empty now.");
}

Match Guards: Bedingungen hinzufügen

Sie können einem match-Arm eine zusätzliche if-Bedingung hinzufügen, die als Match Guard bezeichnet wird. Das Muster muss passen UND die Guard-Bedingung muss wahr sein, damit dieser Arm ausgeführt wird.

So können Sie innerhalb eines Musters eine feinere Steuerung erreichen, ohne weitere Enum-Varianten anlegen zu müssen.

fn main() {
  let num = Some(4);

  match num {
    Some(x) if x % 2 == 0 => println!("Even number: {}", x),
    Some(x) if x < 5 => println!("Small odd number: {}", x),
    Some(x) => println!("Any other number: {}", x),
    None => println!("No number"),
  }
}

Herausforderung zum Pattern Matching

Betrachten Sie den folgenden Rust-Codeausschnitt. Welche der folgenden Aussagen über den match-Ausdruck und seine Ausgabe sind RICHTIG?

enum Status {
  Loading,
  Success(u32),
  Error(String),
}

fn process_status(s: Status) {
  match s {
    Status::Success(code) if code > 200 => println!("Success with high code: {}", code),
    Status::Success(code) => println!("Success with code: {}", code),
    Status::Error(msg) => println!("Failed: {}", msg),
    _ => println!("Status unknown or loading..."),
  }
}

fn main() {
  process_status(Status::Success(201));
  process_status(Status::Error(String::from("Network issue")));
  process_status(Status::Loading);
  process_status(Status::Success(200));
}

Rückblick: Muster meistern

Sie haben die beeindruckende Leistungsfähigkeit von Pattern Matching in Rust kennengelernt! Es ist ein grundlegendes Konzept, um klaren, kompakten und sicheren Code zu schreiben.

  • match-Ausdrücke ermöglichen eine vollständige Ablaufsteuerung auf Grundlage der Datenstruktur.
  • Sie können Literale und Bereiche abgleichen und Platzhalter (_) verwenden.
  • Mit der Dekonstruktion können Sie Werte direkt aus Structs und Enums extrahieren.
  • if let und while let bieten kompakte Möglichkeiten, einzelne Muster abzugleichen.
  • Match Guards fügen match-Armen bedingte Logik hinzu.

Üben Sie diese Muster weiter – sie sind für idiomatischen Rust-Code unverzichtbar!

Häufig gestellte Fragen

Ist die Lektion „Leistungsfähiges Pattern Matching“ kostenlos?

Ja — der vollständige Text von „Leistungsfähiges Pattern Matching“ 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 3 Lektionen.

Was lerne ich in „Leistungsfähiges Pattern Matching“?

Beherrschen Sie `match`-Ausdrücke und weitere Pattern-Matching-Konstrukte, um Datenvarianten prägnant und vollständig zu verarbeiten. 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 3 von 3.

Wie lange dauert die Lektion „Leistungsfähiges Pattern Matching“?

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

  1. Structs definieren und verwenden
  2. Enums für eigene Datentypen
  3. Leistungsfähiges Pattern Matching
← Zurück zu Learn Rust Coding