Learn Rust Coding · Lektion

Enums für eigene Datentypen

Verwenden Sie Enums, um Typen zu definieren, die eine von mehreren Varianten annehmen können und häufig zugehörige Daten enthalten.

Enums für eigene Datentypen ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Enums: Benutzerdefinierte Typvarianten

Willkommen bei Enums für benutzerdefinierte Typen! In Rust können Sie mit Enums (Aufzählungen) einen Typ definieren, der eine von mehreren möglichen, voneinander verschiedenen Varianten sein kann.

Stellen Sie sich ein Enum als eine Möglichkeit vor zu sagen: „Dieses Element kann A ODER B ODER C sein.“ Das ist äußerst nützlich, um verschiedene Zustände oder Auswahlmöglichkeiten darzustellen.

Ein einfaches Enum definieren

Um ein Enum zu definieren, verwenden Sie das Schlüsselwort enum, gefolgt von seinem Namen und geschweiften Klammern, die seine Varianten enthalten. Jede Variante ist eine eigene Auswahlmöglichkeit.

Hier ist ein einfaches Beispiel für Himmelsrichtungen:

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

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

Enums mit zugehörigen Daten

Im Gegensatz zu einfachen Varianten können Enum-Varianten auch Daten enthalten! Dadurch sind Enums sehr leistungsfähig, da jede Variante ihre eigenen, unterschiedlichen Informationen mitführen kann.

Bei den Daten kann es sich um ein Tupel (wie (i32, String)) oder ein Struct (wie { x: i32, y: i32 }) handeln.

Zugehörige Daten in Aktion

Sehen wir uns ein Enum an, bei dem jede Variante eine andere Nachrichtenart darstellt. Einige Varianten enthalten Daten, andere nicht.

Beachten Sie, dass Move ein Struct verwendet, Write einen String und ChangeColor ein Tupel.

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

Das `Option`-Enum: Abwesenheit behandeln

Eines der grundlegendsten Enums von Rust ist Option<T>. Es wird verwendet, um Werte darzustellen, die möglicherweise vorhanden sind oder nicht, und verhindert dadurch in anderen Sprachen häufige Null-Pointer-Fehler.

Some(T): Die Variante, die einen Wert vom Typ T enthält.
None: Die Variante, die keinen Wert darstellt.

`Option<T>` effektiv verwenden

Option<T> zwingt Sie dazu, sowohl den Fall Some als auch den Fall None ausdrücklich zu behandeln. Dadurch wird Ihr Code sicherer und robuster. Keine unerwarteten null-Abstürze mehr!

So können Sie es verwenden:

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

Kurz erklärt: Das `Result`-Enum

Ein weiteres wichtiges Enum ist Result<T, E>, das zur Fehlerbehandlung verwendet wird. Es hat zwei Varianten:

Ok(T): Zeigt Erfolg an und enthält den erfolgreichen Wert.
Err(E): Zeigt einen Fehler an und enthält einen Fehlerwert.

In einer späteren Lektion werden wir Result ausführlich behandeln. Es ist jedoch gut zu wissen, dass es sich dabei um ein weiteres leistungsfähiges Enum-Muster handelt!

Methoden für Enums

Wie bei Structs können Sie mithilfe eines impl-Blocks Methoden für Enums definieren. Diese Methoden können Aktionen ausführen oder abhängig von der Enum-Variante Werte zurückgeben.

Fügen wir unserem Message-Enum aus dem vorherigen Abschnitt eine call-Methode hinzu:

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

Kurzer Test zu Enums

Welche der folgenden Aussagen über Rust-Enums sind richtig?

Rückblick: Enums für benutzerdefinierte Typen

Großartig! Sie haben gelernt, wie Rust-Enums eine leistungsfähige Möglichkeit bieten, benutzerdefinierte Typen zu definieren, die eine von mehreren Varianten annehmen können.

Mit Enums können Sie Auswahlmöglichkeiten und Zustände klar modellieren.
Varianten können zugehörige Daten enthalten, wodurch sie äußerst flexibel sind.
Das Enum Option<T> ist entscheidend, um das Fehlen eines Werts sicher zu behandeln.
Für Enums können Methoden in impl-Blöcken definiert werden.

Als Nächstes sehen wir uns an, wie Sie mit leistungsfähigem Pattern Matching mit diesen Enum-Varianten arbeiten!

Häufig gestellte Fragen

Ist die Lektion „Enums für eigene Datentypen“ kostenlos?

Ja — der vollständige Text von „Enums für eigene Datentypen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Enums für eigene Datentypen“?

Verwenden Sie Enums, um Typen zu definieren, die eine von mehreren Varianten annehmen können und häufig zugehörige Daten enthalten. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Enums für eigene Datentypen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding