Learn Rust Coding · Lekcja

Definiowanie pierwszego enuma

Utworzy Pan/Pani proste typy wyliczeniowe.

Definiowanie pierwszego enuma 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.

What Is an Enum?

Enum (wyliczenie) pozwala zdefiniować typ poprzez wypisanie jego możliwych wartości, zwanych wariantami. Wartość danego typu może być zawsze tylko jednym z tych wariantów.

Typy wyliczeniowe sprawdzają się najlepiej, gdy coś posiada stały zestaw stanów, jak kierunki świata lub kolory w talii kart.

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

Deklarowanie enuma

Enum deklaruje się za pomocą słowa kluczowego enum, nazwy oraz rozdzielonej przecinkami listy wariantów umieszczonej w nawiasach klamrowych.

Zgodnie z konwencją nazwy enumów zapisuje się w notacji PascalCase (na przykład Direction), podobnie jak nazwy wariantów (na przykład North).

enum TrafficLight {
    Red,
    Yellow,
    Green,
}

Tworzenie wartości enuma

Aby utworzyć wartość, proszę napisać nazwę enuma, dwa dwukropki ::, a następnie wariant.

Na przykład Direction::North tworzy wartość typu Direction. Zapis :: wskazuje Rustowi, do którego enuma należy wariant.

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

fn main() {
    let heading = Direction::East;
    println!("Created a direction value!");
}

Enumy są typami

Po zdefiniowaniu enum jest pełnoprawnym typem, podobnie jak i32 czy bool. Jego wartości można przechowywać w zmiennych i przekazywać do funkcji.

Funkcja przyjmująca Direction zaakceptuje dowolny jego wariant, ale nic innego.

enum Direction {
    North,
    South,
}

fn describe(d: Direction) {
    println!("Got a direction");
}

fn main() {
    describe(Direction::North);
}

Dlaczego nie używać po prostu liczb?

Sygnalizację świetlną można reprezentować za pomocą 0, 1 i 2, ale nic nie powstrzyma przed przypadkowym użyciem 7.

Enum sprawia, że nieprawidłowe stany są niemożliwe: kompilator gwarantuje, że wartość zawsze jest jednym z wymienionych wariantów. To bezpieczniejsze i znacznie łatwiejsze do odczytania.

Derive Debug do wyświetlania

Domyślnie Rust nie wie, jak wyświetlać enum. Dodanie #[derive(Debug)] nad enumem pozwala wyświetlać go za pomocą formatera {:?}.

To świetne rozwiązanie do szybkiego debugowania podczas nauki.

#[derive(Debug)]
enum Direction {
    North,
    South,
}

fn main() {
    let d = Direction::South;
    println!("{:?}", d);
}

Porównywanie wartości enuma

Proszę dodać #[derive(PartialEq)], aby móc porównywać warianty za pomocą ==.

Przydaje się to do prostych sprawdzeń, jednak przy bardziej rozbudowanym zachowaniu wyrażenie match (które wkrótce pozna Pan(i)) jest zwykle lepszym narzędziem.

#[derive(PartialEq)]
enum Light {
    Red,
    Green,
}

fn main() {
    let l = Light::Red;
    if l == Light::Red {
        println!("Stop!");
    }
}

Dowolna liczba wariantów

Enum może mieć tyle wariantów, ile potrzeba. Wszystkie należą do tego samego typu.

Umieszczenie powiązanych stanów razem porządkuje kod i od razu pokazuje możliwe opcje.

enum Suit {
    Hearts,
    Diamonds,
    Clubs,
    Spades,
}

Enumy w bibliotece standardowej

Biblioteka standardowa Rust używa enumów wszędzie. Dwa znane przykłady to Option (wartość, która może być obecna lub nieobecna) i Result (sukces albo błąd).

Nauka enumów przygotowuje do późniejszego zrozumienia tych podstawowych typów.

// Option is an enum in std:
// enum Option<T> {
//     Some(T),
//     None,
// }

Kopiowanie prostych enumów

Enumy, których warianty nie przechowują danych, mogą implementować Clone i Copy. Wtedy wartości są automatycznie kopiowane zamiast przenoszone.

Dzięki temu małe enumy reprezentujące stany zachowują się jak proste wartości, na przykład liczby całkowite.

#[derive(Clone, Copy)]
enum Coin {
    Heads,
    Tails,
}

fn main() {
    let a = Coin::Heads;
    let b = a; // a is still usable
}

Połączenie wszystkiego

Oto kompletny program: definiuje enum, tworzy wartość i wyświetla ją za pomocą Debug.

Proszę go uruchomić i spróbować zmienić Green na inny wariant, aby zobaczyć zmianę wyniku.

#[derive(Debug)]
enum TrafficLight {
    Red,
    Yellow,
    Green,
}

fn main() {
    let current = TrafficLight::Green;
    println!("Light is {:?}", current);
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę o podstawach enumów.

Podsumowanie

Nauczył(a) się Pan(i), że enum definiuje typ na podstawie zamkniętej listy wariantów, deklarowanej za pomocą słowa kluczowego enum.

Wartości tworzy się za pomocą EnumName::Variant. Można też wyprowadzić cechy Debug, PartialEq lub Copy, aby je wyświetlać, porównywać i kopiować. Następnie nauczy się Pan(i) reagować na każdy wariant za pomocą match.

Często zadawane pytania

Czy lekcja „Definiowanie pierwszego enuma” jest bezpłatna?

Tak — pełny tekst „Definiowanie pierwszego enuma” 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 „Definiowanie pierwszego enuma”?

Utworzy Pan/Pani proste typy wyliczeniowe. Ć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 „Definiowanie pierwszego enuma”?

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