Enums und Mustererkennung in Rust

Rust bietet verschiedene Datentypen zum Ausführen von Operationen, von grundlegenden Datentypen wie Strings, Integers und Floating Punktzahlen zu zusammengesetzten Datentypen wie Vektoren und Arrays zu zusammengesetzten Datentypen wie Strukturen und Aufzählungen.

Enums (Aufzählungen) ist ein Datentyp, der die Darstellung einer festen Menge von Werten ermöglicht, wie z. B. die Wochentage und die Farbe des Regenbogens. Aufzählungen sind praktisch, wenn die möglichen Werte für eine Variable begrenzt und bekannt sind.

Enums in Rust definieren

Das Deklarieren von Aufzählungen in Rust ist ähnlich wie Aufzählungen in C# deklarieren. Sie verwenden die Aufzählung Schlüsselwort nach dem Namen und eine Reihe von geschweiften Klammern, um Aufzählungen zu definieren. Die möglichen Varianten (Entitäten) können Sie innerhalb der geschweiften Klammern mit einem Komma als Trennzeichen definieren.

Hier ist eine Aufzählung für die Wochentage:

AufzählungWochentag {
 Montag,
 Dienstag,
 Mittwoch,
 Donnerstag,
 Freitag,
 Samstag,
 Sonntag,
}

Der Wochentag enum steht für die Wochentage. Der Varianten sind die Namen des Tages und haben keine zugehörigen Werte. Außerdem können die Varianten Ihrer Aufzählung beliebig sein Rust-Datentyp.

Sie können auf Varianten zugreifen, indem Sie den Variantennamen mit dem Pfadtrennzeichen (::)-Operator für die Aufzählung angeben.

lassen Tag = Wochentag:: Montag;
// statisch typisierte Version der Variablen `day`
lassen Tag: Wochentag = Wochentag:: Montag;

Der Code gibt an, dass Sie auf die zugreifen möchten Montag Variante der Wochentagsaufzählung.

Varianten und Diskriminanten von Aufzählungen

Die Varianten einer Aufzählung werden mit ganzzahligen Werten bezeichnet diskriminierend. Standardmäßig beginnen die Diskriminanzwerte bei Null und werden für nachfolgende Varianten um 1 erhöht; Es ist jedoch möglich, benutzerdefinierte Diskriminanzwerte für jede Variante anzugeben.

Hier ist ein Beispiel für die Weekday-Enumeration mit wertzugewiesenen Varianten.

AufzählungWochentag {
 Montag = 1,
 Dienstag = 2,
 Mittwoch = 3,
 Donnerstag = 4,
 Freitag = 5,
 Samstag = 6,
 Sonntag = 7,
}

Die Aufzählung Weekday hat sieben Varianten, die jeden Wochentag darstellen, und jedem Tag ist ein Wert (die so genannte Diskriminante) zugewiesen. Die Varianten sind in der Reihenfolge vom ersten bis zum letzten Wochentag.

Über den Variantennamen können Sie auf den Diskriminanzwert zugreifen.

fnhauptsächlich() {
drucken!("Montag: {}", Wochentag:: Montag alsi32);
drucken!("Dienstag: {}", Wochentag:: Dienstag alsi32);
drucken!("Mittwoch: {}", Wochentag:: Mittwoch alsi32);
drucken!("Donnerstag: {}", Wochentag:: Donnerstag alsi32);
drucken!("Freitag: {}", Wochentag:: Freitag alsi32);
drucken!("Samstag: {}", Wochentag:: Samstag alsi32);
drucken!("Sonntag: {}", Wochentag:: Sonntag alsi32);
}

Der drucken! Makro wird verwendet, um die Diskriminanten zu drucken. Jeder Druck! Der Makroaufruf benötigt zwei Argumente: eine Formatzeichenfolge und einen Wert. Die Formatzeichenfolge gibt an, wie die Ausgabe formatiert wird; Der Wert ist der tatsächliche Wert, der gedruckt wird.

In diesem Fall ist der Format-String ein String-Literal, das den Namen des Wochentags enthält, und der Wert ist die Enum-Variante mit einem expliziten Cast auf den i32 ganzzahliger Typ.

Die explizite Umwandlung in i32 ist notwendig, da Rust-Enums als Ganzzahlen dargestellt werden, der spezifische Integer-Typ jedoch von der Größe der Aufzählung abhängt. Standardmäßig weist Rust den kleinsten ganzzahligen Typ zu, der alle Diskriminanten in der Aufzählung darstellen kann. Aber in diesem Fall möchten Sie die Werte als i32-Integer ausgeben, also müssen Sie sie explizit umwandeln.

Hier ist das Ergebnis der Ausführung von hauptsächlich Funktion:

Passende Muster in Rost

Der Musterabgleich ist ein Rust-Kontrollstrukturkonstrukt, das zum Identifizieren von Datenmustern nützlich ist. Der Musterabgleich ermöglicht das Schreiben von prägnantem und effizientem Code während der Arbeit mit fortgeschrittene Datenstrukturen oder komplexe Operationen ausführen.

Sie verwenden die passen Schlüsselwort gefolgt von der => Trennzeichen für das Muster bzw. die Operation für das Muster. Das Muster kann ein beliebiger Rust-Ausdruck sein, einschließlich Literale, Variablen und Funktionsaufrufe.

Hier ist ein Beispiel für eine Match-Anweisung:

fnhauptsächlich(){
lassen x= 5;
passen X {
1 => drucken!("eins"),
2 => drucken!("zwei"),
3 => drucken!("drei"),
// wird ausgeführt, wenn keines der Muster übereinstimmt
 _ => drucken!("etwas anderes"),
 }
}

Der hauptsächlich Funktion passt X gegen mehrere Muster und druckt dann den Wert basierend auf dem Wert von x. Das Unterstrichmuster (_) ist ein Platzhaltermuster, das als Sammelpunkt für Fälle verwendet wird, die nicht explizit behandelt werden.

Aufzählungen und Musterabgleich

Aufzählungen und Mustervergleich sind nützlich, um erweiterte Datenstrukturen typsicher und effizient auszudrücken und damit zu arbeiten. Sie können Aufzählungen verwenden, um einen festen Satz von Werten zu definieren, und den Musterabgleich, um mit diesen Werten zu arbeiten.

Hier ist eine Aufzählung für die Farben in einem Regenbogen:

AufzählungRegenbogen {
 Rot,
 Orange,
 Gelb,
 Grün,
 Blau,
 Indigo,
 Violett,
}

Jede Variante der Regenbogen enum repräsentiert eine Farbe des Regenbogens. Sie können den Musterabgleich mit der match-Anweisung verwenden, um Muster mit der Variante abzugleichen, um den Programmfluss basierend auf der Farbe des Regenbogens zu steuern.

Hier ist eine Funktion, die die Farbvariante aus der Rainbow-Enumeration aufnimmt und eine Nachricht basierend auf der Farbe druckt.

fnDruckfarbe(Farbe: Regenbogen) {
passen Farbe {
 Regenbogen:: Rot => drucken!("Die Farbe ist rot!"),
 Regenbogen:: Orange => drucken!("Die Farbe ist orange!"),
 Regenbogen:: Gelb => drucken!("Die Farbe ist gelb!"),
 Regenbogen:: Grün => drucken!("Die Farbe ist grün!"),
 Regenbogen:: Blau => drucken!("Die Farbe ist blau!"),
 Regenbogen:: Indigo => drucken!("Die Farbe ist Indigo!"),
 Regenbogen:: Violett => drucken!("Die Farbe ist violett!"),
 }
}
fnhauptsächlich() {
lassen Farbe = Regenbogen:: Blau;
 print_color (Farbe);
}

Sie können bekommen Varianten werden nie konstruiert oder ähnliche Warnungen, wenn Sie versuchen, den obigen Code auszuführen, da die anderen Varianten außer der Blue-Variante nie in diesem Code konstruiert wurden. In diesem Fall können Sie diese Warnungen also getrost ignorieren, da sie beabsichtigt sind.

Der Druckfarbe Die Funktion übernimmt einen Farbparameter vom Typ Rainbow-Enumeration. Die Match-Anweisung gleicht die Farbe aus einer Reihe von Farben ab, auf die über die Variantennamen zugegriffen wird. Und schließlich wird die Nachricht basierend auf der abgestimmten Farbe gedruckt.

Sie können den Musterabgleich für komplexe Vorgänge wie mehrere Rückgabewerte basierend auf einer Bedingung verwenden.

fnberechnen_wellenlänge(Farbe: Regenbogen) -> u32 {
passen Farbe {
 Regenbogen:: Rot => 700,
 Regenbogen:: Orange => 590,
 Regenbogen:: Gelb => 570,
 Regenbogen:: Grün => 510,
 Regenbogen:: Blau => 475,
 Regenbogen:: Indigo => 445,
 Regenbogen:: Violett => 400,
 }
}

Der berechnen_wellenlänge -Funktion übernimmt eine Farbvariante des Aufzählungstyps Rainbow als Parameter und gibt eine vorzeichenlose 32-Bit-Ganzzahl zurück, die die Wellenlänge der Farbe ist, die mit dem Muster übereinstimmt.

Rust bietet auch Strukturen zum Erstellen benutzerdefinierter Typen

Enums sind praktisch, um benutzerdefinierte Typen für mehrere Operationen zu definieren, insbesondere in Fällen, in denen die Felder bekannt und eindeutig sind.

Rust bietet auch Strukturen, die Sie verwenden können, um benutzerdefinierte Typen mit benannten Feldern zu erstellen. Im Gegensatz zu Enumerationen können Sie mit Strukturen Felder unterschiedlicher Typen definieren, auf die Sie zugreifen und die Sie einzeln ändern können.