Umgang mit Fehlern in Rust mit verschiedenen Ansätzen

Fehler sind unvermeidlich und können aus verschiedenen Gründen auftreten, von ungültigen Benutzereingaben bis hin zu Netzwerkausfällen, Hardwarefehlern oder Programmierfehlern. Die Fehlerbehandlung ist der Prozess des Erkennens, Meldens und Behebens solcher Fehler, um Programmabstürze oder Datenbeschädigungen zu verhindern.

Eine effektive Fehlerbehandlung ist in Rust von entscheidender Bedeutung. Damit können Sie robuste, zuverlässige Anwendungen erstellen, die mit unerwarteten Fehlern und Ausfällen umgehen können. Mit den Fehlerbehandlungsmechanismen von Rust können Sie belastbare, sichere Programme entwickeln, die einfacher zu warten sind.

Die Arten von Fehlern in Rust

Rust hat ein reichhaltiges Typsystem, das Sie verwenden können mit Fehlern kompetent umgehen, nach ihren Typen. Die Vorteile des reichhaltigen Fehlertypsystems von Rust gegenüber herkömmlichen Fehlerbehandlungsansätzen können nicht unterschätzt werden. Das Fehlertypsystem bietet

verbesserte Typsicherheit, Zusammensetzbarkeit, Ausdrucksstärke und Debuggbarkeit.

Hier ist eine Liste häufiger Fehlertypen in Rust:

• Der std:: io:: Fehler Typ steht für E/A-Fehler wie Datei nicht gefunden, Zugriff verweigert oder Dateiende erreicht.
• Der std:: num:: ParseIntError type stellt Fehler dar, die bei String-to-Integer-Parsing-Operationen auftreten.
• Der std:: option:: NoneError Typ repräsentiert Fehler beim Auspacken leerer Optionen.
• Der std:: result:: Ergebnis Typ ist ein generischer Ergebnistyp, den Sie verwenden können, um jeden Fehler darzustellen.

Jeder Fehlertyp hat seine eigenen Methoden und Eigenschaften, um ihn auf bestimmte Weise zu behandeln.

Hier ist ein Beispiel für die Fehlerbehandlung in Rust für einen Dateilesevorgang:

verwenden std:: fs:: Datei;
verwenden std:: io:: Lesen;
fnread_file(Weg: &Str) -> Ergebnis<Schnur, std:: io:: Fehler> {
lassenmut file = Datei:: öffnen (Pfad)?;
lassenmut Inhalt = Schnur::neu();
 file.read_to_string(&mut Inhalt)?;
OK(Inhalt)
}

Der read_file Die Funktion liest den Inhalt der Datei im angegebenen Pfad und gibt ihn als Zeichenfolge zurück. Es gibt a zurück std:: io:: Fehler wenn der Dateiöffnungs- oder Lesevorgang fehlschlägt. Der ? -Operator gibt den Fehler weiter und gibt den Fehler als a zurück Ergebnis.

Fehlerbehandlungsmechanismen in Rust

Ein Schlüsselmerkmal, das zur Sicherheit von Rust beiträgt, sind seine Fehlerbehandlungsmechanismen. Es gibt vier Hauptfehlerbehandlungsmechanismen in Rust: die Ergebnis Schreib die Möglichkeit Schreib die Panik! Makro und die Fehler Merkmal.

Die Typen Ergebnis und Option ermöglichen eine strukturierte Fehlerbehandlung. Du kannst die Panik gebrauchen! Makro zur Behandlung nicht behebbarer Fehler. Mit der Fehlereigenschaft können Sie benutzerdefinierte Fehlertypen und eine benutzerdefinierte Fehlerbehandlung definieren.

Der Ergebnistyp

Der Ergebnis type ist ein integrierter Typ, der das Ergebnis eines Vorgangs darstellt, der fehlschlagen kann. Es gibt zwei Varianten: die OK Variante, die Erfolg darstellt und einen Wert enthält, und Irren, das einen Fehler darstellt und einen Fehlerwert enthält.

So können Sie den Ergebnistyp verwenden, um eine Datei zu öffnen und ihren Inhalt zu lesen:

verwenden std:: fs:: Datei;
verwenden std:: io:: Vorspiel::*;
fnread_file(Dateipfad: &Str) -> Ergebnis<Schnur, std:: io:: Fehler> {
lassenmut file = Datei:: öffnen (Dateipfad)?;
lassenmut Inhalt = Schnur::neu();
 file.read_to_string(&mut Inhalt)?;
OK(Inhalt)
}
fnhauptsächlich() {
lassen result = read_file("Datei.txt");
passen Ergebnis {
OK(Inhalt) => drucken!("{}", Inhalt),
Irren(e) => drucken!("Fehler: {}", e),
 }
}

Der read_file Die Funktion übernimmt den Dateipfad und gibt a zurück Ergebnis Fehler. Wenn das Lesen oder Öffnen der Datei fehlschlägt, gibt die Funktion die Irren Wert. Andernfalls gibt die Funktion die zurück OK Wert. Im hauptsächlich Funktion, die passen Anweisung behandelt die Ergebnis Wert und druckt das Ergebnis abhängig von der Situation der Dateioperation.

Der Optionstyp

Der Möglichkeit type ist ein integrierter Typ, der das Vorhandensein oder Fehlen eines Werts darstellt. Der Möglichkeit Typ hat zwei Varianten. Manche stellt einen Wert dar, und Keiner stellt das Fehlen eines Wertes dar.

So können Sie die verwenden Möglichkeit Typ, um das erste Element eines Vektors abzurufen.

fnget_first_elementKlon>(vec: Vek) -> Möglichkeit {
Wenn vec.is_empty() {
Keiner
 } anders {
Manche(vec.first().unwrap().clone())
 }
}
fnhauptsächlich() {
lassen vec = vec![1, 2, 3];
lassen result = get_first_element (vec);
passen Ergebnis {
Manche(Element) => drucken!("{}", Element),
Keiner => drucken!("Der Vektor ist leer."),
 }
}

Der get_first_element Funktion gibt ein zurück Möglichkeit Typ. Wenn der Vektor leer ist, kehrt die Funktion zurück Keiner; andernfalls kehrt die Funktion zurück Manche enthält das erste Element des Vektors. Im hauptsächlich Funktion, die passen Anweisung behandelt die Möglichkeit Wert. Wenn die Möglichkeit wertet zu Manche, gibt die Funktion das erste Element aus. Andernfalls gibt die Funktion eine Meldung aus, die angibt, dass der Vektor leer ist.

Die Panik! Makro

Der Panik! Das Makro bietet Funktionen zur Behandlung nicht behebbarer Fehler in Rust. Beim Aufrufen der Panik! Makro, es gibt eine Fehlermeldung aus und beendet das Programm.

Hier ist ein Beispiel für die Verwendung von Panik! Makro, um anzuzeigen, dass eine Funktion ungültige Argumente hat.

fnteilen(Dividende: f64, Teiler: f64) -> f64 {
Wenn Teiler == 0.0 {
Panik!("Der Divisor darf nicht Null sein.");
 }
 Dividende / Divisor
}
fnhauptsächlich() {
lassen Ergebnis = teilen (4.0, 0.0);
drucken!("{}", Ergebnis);
}

Der teilen Funktion prüft, ob der Divisor Null ist; Wenn der Divisor Null ist, ruft die Funktion die auf Panik! Makro mit Fehlermeldung; andernfalls berechnet die Funktion das Ergebnis und gibt es zurück

Der hauptsächlich Funktion ruft die Funktion divide mit ungültigen Argumenten auf, um die Panik! Makro.

Hier ist die Fehlermeldung:

Die Fehlereigenschaft

Der Fehler trait ist eine eingebaute Eigenschaft, die das Verhalten von Fehlertypen definiert. Der Fehler trait bietet Funktionen zum Definieren benutzerdefinierter Fehlertypen und benutzerdefinierter Fehlerbehandlung.

Hier ist ein Beispiel für die Definition eines benutzerdefinierten Fehlertyps, der den Fehler „Datei nicht gefunden“ darstellt.

verwenden std:: error:: Fehler;
verwenden std:: fmt;
verwenden std:: io:: Lesen;
#[ableiten (Debuggen)]
StrukturDatei nicht gefunden(Schnur);
impl fmt:: Anzeige für Datei nicht gefunden {
fnfmt(&selbst, F: &mut fmt:: Formatierer) -> fmt::Ergebnis {
schreiben!(F, "Datei nicht gefunden: {}", selbst.0)
 }
}
impl Fehler für Datei nicht gefunden {}
fnread_file(Dateipfad: &Str) -> Ergebnis<Schnur, Kasten<dyn Fehler >> {
lassenmut file = std:: fs:: File:: open (Dateipfad).map_err(|e| FileNotFound(Format!("{}", e)))?;
lassenmut Inhalt = Schnur::neu();
 file.read_to_string(&mut Inhalt)?;
OK(Inhalt)
}
fnhauptsächlich() {
lassen result = read_file("Datei.txt");
passen Ergebnis {
OK(Inhalt) => drucken!("{}", Inhalt),
Irren(e) => drucken!("Fehler: {}", e),
 }
}

Der benutzerdefinierte Fehlertyp ist der Datei nicht gefunden Struktur. Der Typ enthält einen Dateipfad und die Datei nicht gefunden Typ implementiert die Anzeige Eigenschaft, um benutzerfreundliche Fehlermeldungen zurückzugeben und die Fehler Eigenschaft, um anzugeben, dass es sich um einen Fehlertyp handelt.

Im read_file Funktion, die Datei nicht gefunden Der Fehlertyp stellt einen Fehler "Datei nicht gefunden" dar, und die map_err -Methode konvertiert den std:: io:: Error in einen FileNotFound-Fehler. Endlich, die Kiste type ermöglicht es der Funktion, jeden Typ zurückzugeben, der das Error-Merkmal implementiert.

Der hauptsächlich Funktion ruft die auf read_file Funktion mit dem Dateipfad und gibt, wenn sie die Datei findet, ihren Inhalt auf der Konsole aus. Andernfalls wird die Fehlermeldung ausgegeben.

Hier ist das Ergebnis für eine Datei, die nicht existiert:

Sie können sich auf das Eigentumsmodell von Rust für die Programmsicherheit verlassen

In Verbindung mit dem großartigen Fehlerbehandlungsmechanismus von Rust verwendet Rust auch ein Eigentumsmodell, das hilft sicherzustellen, dass Ihre Programme speichersicher sind.

Rust stellt die Eigentumsregeln mit einem Borrow-Checker zur Kompilierzeit sicher, bevor Ihr Programm ausgeführt wird.