Rust-Enums

Enums in Rust sind nicht so einfach wie das Konzept in anderen Programmiersprachen, aber sie können trotzdem sehr einfach verwendet werden:

Beispiel

#[derive(Debug)]

enum Book {
    Papery, Electronic
}

fn main() {
    let book = Book::Papery;
    println!("{:?}", book);
}

Ausgabe:

Papery

Bücher werden in Papierbücher (Papery book) und E-Books (Electronic book) unterteilt.

Wenn Sie nun ein Bibliotheksverwaltungssystem entwickeln und die unterschiedlichen Attribute der beiden Buchtypen beschreiben müssen (Papierbücher haben eine Signatur, E-Books nur eine URL), können Sie den Enum-Mitgliedern Tupel-Attributbeschreibungen hinzufügen:

enum Book {
    Papery(u32),
    Electronic(String),
}

let book = Book::Papery(1001);
let ebook = Book::Electronic(String::from("url://..."));

Wenn du die Attribute benennen möchtest, kannst du die Struct-Syntax verwenden:

enum Book {
    Papery { index: u32 },
    Electronic { url: String },
}
let book = Book::Papery{index: 1001};

Obwohl du sie so benennen kannst, beachte, dass du nicht auf die Attribute, die an eine Enum-Variante gebunden sind, wie auf Struct-Felder zugreifen kannst. Der Zugriff erfolgt über die match-Syntax.

match-Syntax

Der Zweck von Enums besteht darin, eine bestimmte Art von Dingen zu klassifizieren, und der Zweck der Klassifizierung besteht darin, verschiedene Situationen zu beschreiben. Basierend auf diesem Prinzip werden Enum-Typen oft letztendlich durch Verzweigungsstrukturen (switch in vielen Sprachen) behandelt. Die switch-Syntax ist klassisch, aber sie wird in Rust nicht unterstützt. Der Grund, warum viele Sprachen switch aufgeben, ist, dass switch anfällig für Fall-through-Probleme ist, die durch das Vergessen des Hinzufügens von break verursacht werden. Sprachen wie Java und C# verhindern diese Situation durch Sicherheitsprüfungen.

Rust implementiert Verzweigungsstrukturen durch die match-Anweisung. Schauen wir uns zuerst an, wie man match verwendet, um Enums zu behandeln:

Beispiel

fn main() {
    enum Book {
        Papery {index: u32},
        Electronic {url: String},
    }
   
    let book = Book::Papery{index: 1001};
    let ebook = Book::Electronic{url: String::from("url...")};
   
    match book {
        Book::Papery { index } => {
            println!("Papery book {}", index);
        },
        Book::Electronic { url } => {
            println!("E-book {}", url);
        }
    }
}

Ausgabe:

Papery book 1001

Ein match-Block kann auch als Funktionsausdruck behandelt werden und kann einen Rückgabewert haben:

match 枚举类实例 {
    分类1 => 返回值表达式,
    分类2 => 返回值表达式,
    ...
}

Aber die Typen aller Rückgabewertausdrücke müssen gleich sein!

Wenn die zusätzlichen Attribute eines Enums als Tupel definiert sind, müssen Sie im match-Block vorübergehend einen Namen angeben:

Beispiel

enum Book {
    Papery(u32),
    Electronic {url: String},
}
let book = Book::Papery(1001);

match book {
    Book::Papery(i) => {
        println!("{}", i);
    },
    Book::Electronic { url } => {
        println!("{}", url);
    }
}

Neben der Verzweigung über Enums kann match auch über Daten von Typen wie Ganzzahlen, Gleitkommazahlen, Zeichen und String-Slice-Referenzen (&str) verzweigen. Davon ist die Verzweigung über Gleitkommazahlen zulässig, aber nicht empfehlenswert, da Genauigkeitsprobleme zu Verzweigungsfehlern führen können.

Beim Verzweigen über Nicht-Enum-Typen muss der Catch-all-Fall behandelt werden, auch wenn im Catch-all-Fall nichts zu tun ist..Der Catch-all-Fall verwendet einen Unterstrich_, um Folgendes darzustellen:

Beispiel

fn main() {
    let t = "abc";
    Treffer t {
        "abc" => println!("Yes"),
        _ => {},
    }
}

Option-Enum

Option ist ein Enum in der Rust-Standardbibliothek. Dieser Typ wird verwendet, um die Lücke zu schließen, dass Rust keine Null-Referenzen unterstützt.

Viele Sprachen unterstützen die Existenz von null (C/C++, Java), was praktisch ist, aber auch enorme Probleme verursacht. Der Erfinder von null gab dies ebenfalls zu: "Eine bequeme Idee verursachte kumulierte Verluste von einer Milliarde Dollar."

null versetzt dem Programm oft einen tödlichen Schlag, wenn Entwickler alles als nicht null behandeln: Schließlich muss die Ausführung des Programms vollständig beendet werden, sobald ein solcher Fehler auftritt.

Um dieses Problem zu lösen, erlauben viele Sprachen null standardmäßig nicht, unterstützen aber das Auftreten von null auf Sprachebene (oft mit einem ?-Symbol vor dem Typ gekennzeichnet).

Java unterstützt null standardmäßig, kann aber das Auftreten von null durch die @NotNull-Annotation einschränken. Das ist eine Möglichkeit, damit umzugehen.

Rust verbietet Nullwerte auf Sprachebene vollständig, aber leider kann null eine kleine Anzahl von Problemen effizient lösen, deshalb führte Rust das Option-Enum ein:

enum Option<T> {
    Some(T),
    None,
}

Wenn du einen Typ definieren möchtest, der null sein kann, kannst du das so machen:

let opt = Option::Some("Hello");

Wenn du einige Operationen auf opt ausführen möchtest, musst du zuerst feststellen, ob esOption::None ist:

Beispiel

fn main() {
    let opt = Option::Some("Hello");
    match opt {
        Option::Some(something) => {
            println!("{}", something);
        },
        Option::None => {
            println!("opt ist nichts");
        }
    }
}

Ausgabe:

Hello

Wenn deine Variable anfangs null ist, bedenke den Compiler: Woher weiß er, welchen Typ die Variable hat, wenn der Wert nicht null ist?

Daher muss eine Option mit einem anfänglichen null-Wert einen expliziten Typ haben:

Beispiel

fn main() {
    let opt: Option<&str> = Option::None;
    match opt {
        Option::Some(something) => {
            println!("{}", something);
        },
        Option::None => {
            println!("opt ist nichts");
        }
    }
}

Ausgabe:

opt is nothing

Dieses Design macht die Programmierung mit null-Werten schwieriger, aber genau das ist nötig, um ein stabiles und effizientes System zu erstellen. Da Option im Rust-Compiler standardmäßig eingeführt ist, kannst du Option:: weglassen und bei der Verwendung direkt None oder Some() schreiben.

Option ist ein spezieller Enum-Typ, der Werte für die Verzweigungsauswahl enthalten kann:

Beispiel

fn main() {
        let t = Some(64);
        Treffer t {
                Some(64) => println!("Ja"),
                _ => println!("Nein"),
        }
}

Syntax von if let

Beispiel

let i = 0;
Treffer i {
    0 => println!("zero"),
    _ => {},
}

Füge es in die main-Funktion ein, die Ausgabe ist:

zero

Der Zweck dieses Programms ist es, festzustellen, ob i die Zahl 0 ist, und wenn ja, zero auszugeben.

Verwende jetzt die Syntax von if let, um diesen Code zu verkürzen:

let i = 0;
if let 0 = i {
    println!("zero");
}

Die Syntax von if let lautet wie folgt:

if let 匹配值 = 源变量 {
    语句块
}

Du kannst danach einen else-Block hinzufügen, um den Catch-all-Fall abzudecken.

Die Syntax von if let kann als "syntaktischer Zucker" für eine match-Anweisung betrachtet werden, die nur zwei Fälle unterscheidet (syntaktischer Zucker bezeichnet eine bequeme Alternative mit demselben zugrunde liegenden Prinzip wie eine bestimmte Syntax).

Es ist auch auf Enums anwendbar:

Beispiel

fn main() {
    enum Book {
        Papery(u32),
        Electronic(String)
    }
    let book = Book::Electronic(String::from("url"));
    if let Book::Papery(index) = book {
        println!("Papierartig {}", index);
    } else {
        println!("Kein papierartiges Buch");
    }
}
Andere Erweiterungen