Learn Rust Coding · Lekcja

Enumny dla własnych typów

Nauczą się Państwo używać enumnów do definiowania typów, które mogą przyjmować jedną z kilku wariantów, często przechowujących powiązane dane.

Enumny dla własnych typów to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 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.

Wyliczenia: warianty niestandardowych typów

Witaj w sekcji Wyliczenia dla niestandardowych typów! W Rust wyliczenia (enumeracje) pozwalają definiować typ, który może przyjmować jedną z kilku możliwych, odrębnych postaci zwanych wariantami.

Wyliczenie pozwala powiedzieć: "Ten element może być A, LUB B, LUB C". Jest niezwykle przydatne do reprezentowania różnych stanów lub możliwości wyboru.

Definiowanie prostego wyliczenia

Aby zdefiniować wyliczenie, używa się słowa kluczowego enum, po którym następuje jego nazwa i nawiasy klamrowe zawierające warianty. Każdy wariant jest odrębną możliwością wyboru.

Oto prosty przykład przedstawiający kierunki świata:

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

fn main() {
  let my_direction = Direction::North;
  println!("My direction is {:?}", my_direction);
}

Wyliczenia z powiązanymi danymi

W przeciwieństwie do prostych wariantów warianty wyliczenia mogą również przechowywać dane! Dzięki temu wyliczenia są bardzo elastyczne, ponieważ każdy wariant może zawierać własny, odrębny zestaw informacji.

Dane mogą mieć postać krotki (np. (i32, String)) lub struktury (np. { x: i32, y: i32 }).

Powiązane dane w praktyce

Zobaczmy wyliczenie, w którym każdy wariant reprezentuje inny rodzaj komunikatu, a niektóre warianty przechowują dane, a inne nie.

Zwróć uwagę, że Move używa struktury, Write używa typu String, a ChangeColor używa krotki.

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

fn main() {
  let m1 = Message::Quit;
  let m2 = Message::Move { x: 10, y: 20 };
  let m3 = Message::Write(String::from("hello"));
  let m4 = Message::ChangeColor(255, 0, 128);

  // We can't directly print enums with associated data using {:?}
  // without deriving Debug, which we'll cover later.
  // For now, just know these instances are created.
  println!("Messages created!");
}

Wyliczenie `Option`: obsługa braku wartości

Jednym z najbardziej podstawowych wyliczeń w Rust jest Option<T>. Służy do reprezentowania wartości, które mogą istnieć lub nie, zapobiegając błędom związanym z pustymi wskaźnikami, częstym w innych językach.

Some(T): wariant przechowujący wartość typu T.
None: wariant reprezentujący brak wartości.

Efektywne używanie `Option<T>`

Option<T> wymusza jawne obsłużenie zarówno przypadku Some, jak i None, dzięki czemu kod jest bezpieczniejszy i bardziej odporny. Koniec z nieoczekiwanymi awariami z powodu null!

Oto przykład użycia:

fn find_item(id: i32) -> Option<String> {
  if id == 7 {
    Some(String::from("Found item 7!"))
  } else {
    None
  }
}

fn main() {
  let item1 = find_item(7);
  let item2 = find_item(5);

  println!("Item 1: {:?}", item1);
  println!("Item 2: {:?}", item2);
}

W skrócie: wyliczenie `Result`

Innym ważnym wyliczeniem jest Result<T, E>, używane do obsługi błędów. Ma ono dwa warianty:

Ok(T): oznacza powodzenie i zawiera pomyślnie uzyskaną wartość.
Err(E): oznacza niepowodzenie i zawiera wartość błędu.

Do Result wrócimy dokładniej w późniejszej lekcji, ale warto wiedzieć, że jest to kolejny potężny wzorzec wyliczenia!

Metody wyliczeń

Podobnie jak w przypadku struktur, można definiować metody dla wyliczeń za pomocą bloku impl. Metody te mogą wykonywać działania lub zwracać wartości zależnie od wariantu wyliczenia.

Dodajmy metodę call do naszego wcześniejszego wyliczenia Message:

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

impl Message {
  fn call(&self) {
    println!("A message was called!");
  }
}

fn main() {
  let m = Message::Write(String::from("hello"));
  m.call();
}

Szybki test z wyliczeń

Które z poniższych stwierdzeń dotyczących enumów w Rust są prawdziwe?

Powtórzenie: enumy dla typów niestandardowych

Świetna praca! Dowiedział się Pan, jak enumy w Rust pozwalają definiować niestandardowe typy, które mogą przyjmować jedną z kilku wariantów.

Enumy umożliwiają czytelne modelowanie wyborów i stanów.
Warianty mogą przechowywać powiązane dane, dzięki czemu są bardzo elastyczne.
Enum Option<T> ma kluczowe znaczenie dla bezpiecznej obsługi braku wartości.
Enumy mogą mieć metody definiowane w blokach impl.

Następnie dowie się Pan, jak pracować z tymi wariantami enumów za pomocą zaawansowanego dopasowywania wzorców!

Często zadawane pytania

Czy lekcja „Enumny dla własnych typów” jest bezpłatna?

Tak — pełny tekst „Enumny dla własnych typó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 „Enumny dla własnych typów”?

Nauczą się Państwo używać enumnów do definiowania typów, które mogą przyjmować jedną z kilku wariantów, często przechowujących powiązane dane. Ć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 2 z 3.

Ile czasu zajmuje lekcja „Enumny dla własnych typó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