Learn Rust Coding · Lekcja

Potężne dopasowywanie wzorców

Opanują Państwo wyrażenia `match` i inne konstrukcje dopasowywania wzorców, aby zwięźle i wyczerpująco obsługiwać warianty danych.

Lekcja 3 z 311 kroki

Potężne dopasowywanie wzorców to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 3 lekcji w sumie.

Odkrywanie dopasowywania wzorców

Witamy w świecie dopasowywania wzorców w Rust! Ta zaawansowana funkcja pozwala sterować przebiegiem programu na podstawie struktury danych.

Zamiast tylko sprawdzać równość, można rozkładać wartości na części, wyodrębniać ich elementy i wykonywać określony kod dla różnych kształtów danych.

To coś w rodzaju rozbudowanej instrukcji if/else lub switch.
Zapewnia kompletność: trzeba obsłużyć wszystkie możliwe wzorce.
Sprawia, że kod jest czytelniejszy i bardziej niezawodny.

Podstawy wyrażenia `match`

Podstawą dopasowywania wzorców jest wyrażenie match. Przyjmuje ono wartość i porównuje ją z szeregiem wzorców. Wygrywa pierwszy pasujący wzorzec!

Każde „ramię” wyrażenia match składa się ze wzorca i kodu wykonywanego, jeśli wzorzec pasuje.

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!"),
  }
}

Dopasowywanie literałów i zakresów

Można dopasowywać konkretne wartości literałowe (liczby, znaki, wartości logiczne) albo definiować zakresy za pomocą ..=. Operator | pozwala dopasować wiele wzorców w jednym ramieniu.

Proszę pamiętać, że wzorce są sprawdzane w kolejności, a używane jest pierwsze dopasowanie.

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"),
  }
}

Rozkładanie struktur na części

Dopasowywanie wzorców szczególnie dobrze sprawdza się podczas rozkładania złożonych typów danych, takich jak struktury. Poszczególne pola można bezpośrednio przypisać do zmiennych w ramach ramienia match.

Ułatwia to przejrzysty i zwięzły dostęp do danych struktury, zwłaszcza podczas dopasowywania konkretnych wartości pól.

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),
  }
}

Rozkładanie enumów zawierających dane

Enumy w Rust mogą przechowywać powiązane dane. Dopasowywanie wzorców jest podstawowym sposobem wyodrębniania tych danych z wariantu enuma.

Dane można rozłożyć bezpośrednio na nowe zmienne, co ułatwia pracę z zawartością każdego wariantu.

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!")));
}

Wzorzec wieloznaczny `_`

Specjalny wzorzec _ (podkreślnik) działa jako wartość domyślna. Dopasowuje dowolną wartość, ale nie wiąże jej z żadną zmienną.

Jest przydatny, gdy trzeba uwzględnić wszystkie możliwości, aby zapewnić kompletność, ale konkretna wartość pasująca do danego ramienia nie ma znaczenia.

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` dla pojedynczych wzorców

Czasami interesuje Pana tylko dopasowanie jednego konkretnego wzorca, a pozostałe chce Pan pominąć. W takich przypadkach if let jest zwięźlejszą alternatywą dla pełnego wyrażenia match.

W praktyce oznacza to: „jeśli ten wzorzec pasuje, wykonaj to; w przeciwnym razie nic nie rób (lub wykonaj opcjonalny blok else)”.

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` dla pętli warunkowych

Podobnie jak if let, while let pozwala wykonywać pętlę tak długo, jak długo wzorzec pasuje.

Jest to niezwykle przydatne podczas przetwarzania elementów kolekcji, takich jak Vec, gdy pętla ma trwać do momentu, aż nie pozostaną już żadne pasujące elementy (np. do chwili, gdy pop() zwróci None).

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

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

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

Strażniki dopasowania: dodawanie warunków

Do ramienia match można dodać dodatkowy warunek if, nazywany strażnikiem dopasowania. Aby dane ramię zostało wykonane, wzorzec musi pasować, a warunek strażnika musi być prawdziwy.

Pozwala to precyzyjniej sterować działaniem wzorca bez konieczności tworzenia kolejnych wariantów enuma.

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"),
  }
}

Wyzwanie: dopasowywanie wzorców

Proszę przeanalizować poniższy fragment kodu Rust. Które z poniższych stwierdzeń dotyczących wyrażenia match i jego wyniku są PRAWDZIWE?

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));
}

Odpowiedz w interaktywnej lekcji

Powtórzenie: opanowanie wzorców

Poznał Pan niezwykłe możliwości dopasowywania wzorców w Rust! To podstawowe zagadnienie przy pisaniu czytelnego, zwięzłego i bezpiecznego kodu.

Wyrażenia match zapewniają kompletną kontrolę przepływu na podstawie struktury danych.
Można dopasowywać literały i zakresy oraz używać wzorców wieloznacznych (_).
Rozkładanie na części umożliwia bezpośrednie wyodrębnianie wartości ze struktur i enumów.
if let i while let oferują zwięzłe sposoby dopasowywania pojedynczych wzorców.
Strażniki dopasowania dodają logikę warunkową do ramion match.

Proszę ćwiczyć te wzorce — są niezbędne do pisania idiomatycznego kodu w Rust!

Bezpłatny start

Ucz się Rust dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 39
Lekcje: 144

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Potężne dopasowywanie wzorców” jest bezpłatna?

Tak — pełny tekst „Potężne dopasowywanie wzorców” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 3 lekcji w sumie.

Co nauczysz się w „Potężne dopasowywanie wzorców”?

Opanują Państwo wyrażenia `match` i inne konstrukcje dopasowywania wzorców, aby zwięźle i wyczerpująco obsługiwać warianty danych. Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.

Ile czasu zajmuje lekcja „Potężne dopasowywanie wzorców”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding