Learn Rust Coding · Lekcja

Enumy z danymi

Dołączy Pan/Pani wartości do wariantów.

Lekcja 3 z 413 kroki

Enumy z danymi to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 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.

Warianty mogą przechowywać dane

Do tej pory nasze warianty były tylko nazwami. W Rust wariant może również przechowywać dane w nawiasach.

Dzięki temu jeden enum może opisywać zarówno rodzaj wartości, jak i samą wartość.

enum Message {
    Quit,
    Move(i32, i32),
    Write(String),
}

Wariant z jedną wartością

Proszę umieścić typ w nawiasach, aby dołączyć jedną daną do wariantu.

W tym przypadku Celsius(f64) oznacza, że wariant Celsius przechowuje liczbę typu f64. Liczbę tę podaje się podczas tworzenia wartości.

enum Temperature {
    Celsius(f64),
    Fahrenheit(f64),
}

fn main() {
    let t = Temperature::Celsius(21.5);
    println!("Created a temperature");
}

Warianty z wieloma wartościami

Wariant może przechowywać wiele wartości rozdzielonych przecinkami.

Move(i32, i32) przechowuje dwie liczby całkowite, na przykład współrzędne x i y. Podaje się obie wartości podczas jego tworzenia.

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

fn main() {
    let r = Shape::Rectangle(3.0, 4.0);
    println!("Made a rectangle");
}

Wyodrębnianie danych za pomocą match

Aby odczytać dane znajdujące się w wariancie, proszę nazwać je we wzorcu. Nazwy stają się zmiennymi, których można używać w danej gałęzi.

W tym przypadku Shape::Circle(r) wiąże przechowywany promień ze zmienną r.

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

fn main() {
    let s = Shape::Circle(2.0);
    match s {
        Shape::Circle(r) => println!("radius {}", r),
        Shape::Rectangle(w, h) => println!("{} x {}", w, h),
    }
}

Używanie powiązanych wartości

Po powiązaniu danych z nazwą można wykonywać na nich obliczenia tak jak na każdej zmiennej.

Ten program dopasowuje kształt i oblicza jego pole, zwracając wynik z wyrażenia match.

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

fn main() {
    let s = Shape::Rectangle(3.0, 4.0);
    let area = match s {
        Shape::Circle(r) => 3.14 * r * r,
        Shape::Rectangle(w, h) => w * h,
    };
    println!("area = {}", area);
}

Różne dane w poszczególnych wariantach

Każdy wariant może przechowywać dane o innym kształcie, a niektóre warianty mogą nie przechowywać ich wcale.

Ta elastyczność sprawia, że enumy są tak wyraziste: jeden typ może modelować wiele różnych przypadków.

enum Message {
    Quit,
    Move(i32, i32),
    Write(String),
}

Warianty przypominające struktury

Wariant może używać nazwanych pól w nawiasach klamrowych, podobnie jak struktura. Dzięki temu znaczenie każdego pola jest jasne.

Tworzy się go, nadając nazwę każdemu polu, a następnie dopasowuje w ten sam sposób.

enum Event {
    Click { x: i32, y: i32 },
    KeyPress(char),
}

fn main() {
    let e = Event::Click { x: 10, y: 20 };
    match e {
        Event::Click { x, y } => println!("click at {},{}", x, y),
        Event::KeyPress(c) => println!("key {}", c),
    }
}

Napisy w wariantach

Warianty mogą przechowywać dane będące własnością, takie jak String. Dopasowanie zapewnia dostęp do tekstu.

Uwaga: dopasowanie przez wartość przenosi dane na zewnątrz, co jest tutaj odpowiednie, ponieważ używamy ich od razu.

enum Message {
    Write(String),
    Quit,
}

fn main() {
    let m = Message::Write(String::from("hello"));
    match m {
        Message::Write(text) => println!("text: {}", text),
        Message::Quit => println!("bye"),
    }
}

Standardowy enum Option

Wbudowany w Rust typ Option<T> to enum zawierający dane: Some(T) przechowuje wartość, a None nie przechowuje nic.

W ten sposób Rust reprezentuje „być może wartość” bez używania null. Dopasowuje się go tak samo jak własne enumy.

fn main() {
    let maybe: Option<i32> = Some(5);
    match maybe {
        Some(n) => println!("got {}", n),
        None => println!("nothing"),
    }
}

Połączenie wszystkich elementów

Ten kompletny program modeluje temperatury, a następnie konwertuje odczyt w stopniach Celsjusza na stopnie Fahrenheita wewnątrz instrukcji match.

Proszę zmienić wariant lub jego wartość i uruchomić program ponownie.

enum Temperature {
    Celsius(f64),
    Fahrenheit(f64),
}

fn main() {
    let t = Temperature::Celsius(25.0);
    let f = match t {
        Temperature::Celsius(c) => c * 9.0 / 5.0 + 32.0,
        Temperature::Fahrenheit(f) => f,
    };
    println!("{} F", f);
}

Kiedy używać wariantów z danymi

Warto używać wariantów przenoszących dane, gdy każdy przypadek wiąże się w naturalny sposób z dodatkowymi informacjami.

Element Circle potrzebuje promienia.
Komunikat Write potrzebuje tekstu.
Element Move potrzebuje współrzędnych.

Powiązanie danych z wariantem utrzymuje powiązane informacje razem i zapewnia bezpieczeństwo typów.

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat enumów przenoszących dane.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Dowiedziałeś się, że warianty enumów mogą przechowywać dane: pojedynczą wartość, kilka wartości, nazwane pola podobne do pól struktury albo nic.

Dane odczytuje się, nazywając je we wzorcu match, na przykład Circle(r). Standardowy typ Option działa tak samo. Następnie doprecyzujesz dopasowania za pomocą strażników i wiązań.

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 „Enumy z danymi” jest bezpłatna?

Tak — pełny tekst „Enumy z danymi” 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 „Enumy z danymi”?

Dołączy Pan/Pani wartości do wariantów. Ć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 4.

Ile czasu zajmuje lekcja „Enumy z danymi”?

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