Learn Rust Coding · Lekcja

match — szczegółowe omówienie

Wzorce i strażnicy

match — szczegółowe omówienie to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 z 4. 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 4 lekcji w sumie.

Wyrażenie match

match porównuje wartość z szeregiem wzorców i wykonuje ramię pierwszego pasującego wzorca. Jest wyrażeniem, więc zwraca wartość.

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

Kompletność

Instrukcja match musi obejmować każdą możliwą wartość. Symbol wieloznaczny _ przechwytuje wszystko, do czego nie pasowały wcześniejsze ramiona, zapewniając kompletność.

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

Dopasowywanie wielu wartości

Użyj |, aby dopasować kilka wzorców w jednym ramieniu.

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

Wzorce zakresów

Dopasuj zakres wartości za pomocą ..= (zakres domknięty). Jest to świetne rozwiązanie do grupowania liczb lub znaków.

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

Strażnicy dopasowania

Strażnik to dodatkowy warunek if w ramieniu. Ramię pasuje tylko wtedy, gdy wzorzec pasuje i strażnik ma wartość true.

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

Wiązanie w wzorcach

Wzorce mogą wiązać dopasowane części ze zmiennymi, aby można było używać ich w treści ramienia.

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

Dopasowywanie enumów

match szczególnie dobrze sprawdza się w przypadku enumów, zwłaszcza gdy warianty przechowują dane.

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

Pomijanie za pomocą _ i ..

Użyj _, aby zignorować pojedynczą wartość, a .., aby zignorować resztę krotki lub struktury.

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

Zwracanie z match

Ponieważ match jest wyrażeniem, można przypisać jego wynik do zmiennej lub zwrócić go bezpośrednio. Każde ramię musi zwracać ten sam typ.

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

Kolejność ramion ma znaczenie

Ramiona są sprawdzane od góry do dołu; wygrywa pierwsze pasujące. Wzorce szczegółowe należy umieszczać przed ogólnymi, a symbol wieloznaczny na końcu.

Wiązanie zakresów za pomocą @

Połącz zakres z operatorem @, aby sprawdzić wartość i zachować jej dokładną zawartość w tym samym ramieniu.

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

Szybkie sprawdzenie

Jaki jest cel strażnika dopasowania, takiego jak (x, y) if x > y?

Podsumowanie

Dogłębnie poznano match:

Jest kompletnym wyrażeniem zwracającym wartość
| dopasowuje wiele wzorców, a ..= dopasowuje zakresy
Strażnicy dodają dodatkowe warunki if
Wzorce wiążą dane, a _ i .. pomijają części
Kolejność ramion ma znaczenie — wygrywa pierwsze dopasowanie

Często zadawane pytania

Czy lekcja „match — szczegółowe omówienie” jest bezpłatna?

Tak — pełny tekst „match — szczegółowe omówienie” 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 4 lekcji w sumie.

Co nauczysz się w „match — szczegółowe omówienie”?

Wzorce i strażnicy Ć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 1 z 4.

Ile czasu zajmuje lekcja „match — szczegółowe omówienie”?

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