Obsługa błędów w rdzy za pomocą różnych podejść

Błędy są nieuniknione i mogą wystąpić z różnych powodów, od nieprawidłowych danych wprowadzonych przez użytkownika po awarie sieci, awarie sprzętu lub błędy programistyczne. Obsługa błędów to proces wykrywania, zgłaszania i odzyskiwania po takich błędach w celu zapobieżenia awariom programów lub uszkodzeniu danych.

Efektywna obsługa błędów ma kluczowe znaczenie w Rust. Pozwala tworzyć solidne, niezawodne aplikacje, które radzą sobie z nieoczekiwanymi błędami i awariami. Mechanizmy obsługi błędów Rust pozwalają tworzyć odporne, bezpieczne programy, które są łatwiejsze w utrzymaniu.

Rodzaje błędów w Rust

Rust ma bogaty system typów, którego możesz użyć sprawnie radzić sobie z błędami, według ich rodzajów. Nie można przecenić zalet bogatego systemu typów błędów Rusta w porównaniu z tradycyjnym podejściem do obsługi błędów. System typów błędów zapewnia zwiększone bezpieczeństwo typów, komponowalność, ekspresyjność i debuggowalność.

Oto lista typowych typów błędów w Rust:

• The std:: io:: Błąd typ reprezentuje błędy we/wy, takie jak nie znaleziono pliku, odmowa uprawnień lub osiągnięty koniec pliku.
• The std:: num:: ParseIntError typ reprezentuje błędy, które występują podczas operacji analizowania ciągów na liczby całkowite.
• The std:: opcja:: BrakBłąd type reprezentuje błędy z rozpakowywania pustych opcji.
• The std:: wynik:: wynik type jest ogólnym typem Result, którego można użyć do przedstawienia dowolnego błędu.

Każdy typ błędu ma swój własny zestaw metod i cech umożliwiających obsługę go w określony sposób.

Oto przykład obsługi błędów w Rust dla operacji odczytu pliku:

używać std:: fs:: Plik;
używać std:: io:: Odczyt;
przypodczyt_pliku(ścieżka: &ul) -> Wynik<Strunowy, std:: io:: Błąd> {
pozwalaćmut plik = Plik:: otwarty (ścieżka)?;
pozwalaćmut zawartość = Strunowy::nowy();
 plik.read_to_string(&mut zawartość)?;
OK(zawartość)
}

The odczyt_pliku funkcja odczytuje zawartość pliku w określonej ścieżce i zwraca ją jako ciąg znaków. Zwraca std:: io:: Błąd jeśli operacja otwarcia lub odczytu pliku nie powiedzie się. The ? operator propaguje błąd i zwraca błąd jako a Wynik.

Mechanizmy obsługi błędów w Rust

Jedną z kluczowych cech, które przyczyniają się do bezpieczeństwa Rusta, są jego mechanizmy obsługi błędów. Istnieją cztery główne mechanizmy obsługi błędów w Rust: the Wynik Wpisz Opcja Wpisz panika! makro i Błąd cecha.

Typy Result i Option umożliwiają strukturalną obsługę błędów. Możesz użyć paniki! makro do obsługi nieodwracalnych błędów. Cecha Błąd umożliwia definiowanie niestandardowych typów błędów i niestandardowej obsługi błędów.

Typ wyniku

The Wynik type jest wbudowanym typem reprezentującym wynik operacji, która może zakończyć się niepowodzeniem. Ma dwa warianty: tzw OK wariant, który reprezentuje sukces i zawiera wartość, oraz Błądzić, który reprezentuje niepowodzenie i zawiera wartość błędu.

Oto jak możesz użyć typu Result do otwarcia pliku i odczytania jego zawartości:

używać std:: fs:: Plik;
używać std:: io:: preludium::*;
przypodczyt_pliku(ścieżka pliku: &ul) -> Wynik<Strunowy, std:: io:: Błąd> {
pozwalaćmut plik = Plik:: otwarty (ścieżka_pliku)?;
pozwalaćmut zawartość = Strunowy::nowy();
 plik.read_to_string(&mut zawartość)?;
OK(zawartość)
}
przypgłówny() {
pozwalać wynik = odczyt_plik("plik.txt");
mecz wynik {
OK(zawartość) => drukuj!("{}", zawartość),
Błądzić(e) => drukuj!("Błąd: {}", e),
 }
}

The odczyt_pliku funkcja przyjmuje ścieżkę do pliku i zwraca a Wynik błąd. Jeśli operacja odczytu lub otwarcia pliku nie powiedzie się, funkcja zwraca wartość Błądzić wartość. W przeciwnym razie funkcja zwraca OK wartość. w główny funkcja, tzw mecz instrukcja obsługuje Wynik wartość i drukuje wynik w zależności od sytuacji operacji na plikach.

Typ opcji

The Opcja type jest wbudowanym typem reprezentującym obecność lub brak wartości. The Opcja typ ma dwa warianty. Niektóre reprezentuje wartość i Nic oznacza brak wartości.

Oto jak możesz użyć Opcja wpisz, aby pobrać pierwszy element wektora.

przypget_first_elementKlon>(vec: Vec) -> Opcja {
Jeśli vec.is_empty() {
Nic
 } w przeciwnym razie {
Niektóre(vec.first().unwrap().clone())
 }
}
przypgłówny() {
pozwalać vec = vec![1, 2, 3];
pozwalać wynik = get_first_element (vec);
mecz wynik {
Niektóre(element) => drukuj!("{}", element),
Nic => drukuj!(„Wektor jest pusty”.),
 }
}

The get_first_element funkcja zwraca a Opcja typ. Jeśli wektor jest pusty, funkcja zwraca Nic; w przeciwnym razie funkcja zwraca Niektóre zawierający pierwszy element wektora. w główny funkcja, tzw mecz instrukcja obsługuje Opcja wartość. jeśli Opcja ocenia na Niektóre, funkcja drukuje pierwszy element. W przeciwnym razie funkcja wypisze komunikat informujący, że wektor jest pusty.

Panika! Makro

The panika! makro zapewnia funkcjonalność do obsługi nienaprawialnych błędów w Rust. Dzwoniąc do panika! makro, wyświetla komunikat o błędzie i kończy działanie programu.

Oto przykład użycia paniki! makro, aby wskazać, że funkcja ma nieprawidłowe argumenty.

przypdzielić(dywidenda: f64, dzielnik: f64) -> f64 {
Jeśli dzielnik == 0.0 {
panika!(„Dzielnik nie może być zerem”.);
 }
 dywidenda / dzielnik
}
przypgłówny() {
pozwalać wynik = dzielenie(4.0, 0.0);
drukuj!("{}", wynik);
}

The dzielić funkcja sprawdza, czy dzielnik jest równy zero; jeśli dzielnik jest równy zero, funkcja wywołuje panika! makro z komunikatem o błędzie; w przeciwnym razie funkcja oblicza i zwraca wynik

The główny funkcja wywołuje funkcję dzielenia z nieprawidłowymi argumentami, aby wywołać panika! makro.

Oto komunikat o błędzie:

Cecha błędu

The Błąd cecha jest wbudowaną cechą, która definiuje zachowanie typów błędów. The Błąd cecha zapewnia funkcjonalność do definiowania niestandardowych typów błędów i niestandardowej obsługi błędów.

Oto przykład zdefiniowania niestandardowego typu błędu, który reprezentuje błąd, że nie znaleziono pliku.

używać std:: błąd:: Błąd;
używać std:: fmt;
używać std:: io:: Odczyt;
#[pochodna (debugowanie)]
strukturaNie znaleziono pliku(Strunowy);
implik fmt:: Wyświetl Do Nie znaleziono pliku {
przypfmt(&samego siebie, F: &mut fmt:: Formater) -> fmt::Wynik {
pisać!(F, "Nie znaleziono pliku: {}", samego siebie.0)
 }
}
implik Błąd Do Nie znaleziono pliku {}
przypodczyt_pliku(ścieżka pliku: &ul) -> Wynik<Strunowy, Skrzynka<dyn Błąd>> {
pozwalaćmut plik = std:: fs:: Plik:: open (ścieżka_pliku).map_err(|e|FileNotFound(format!("{}", e)))?;
pozwalaćmut zawartość = Strunowy::nowy();
 plik.read_to_string(&mut zawartość)?;
OK(zawartość)
}
przypgłówny() {
pozwalać wynik = odczyt_plik("plik.txt");
mecz wynik {
OK(zawartość) => drukuj!("{}", zawartość),
Błądzić(e) => drukuj!("Błąd: {}", e),
 }
}

Niestandardowy typ błędu to Nie znaleziono pliku struktura. Typ zawiera ścieżkę do pliku, a Nie znaleziono pliku typ implementuje Wyświetlacz, aby zwracać przyjazne dla użytkownika komunikaty o błędach i Błąd cecha wskazująca, że ​​jest to typ błędu.

w odczyt_pliku funkcja, tzw Nie znaleziono pliku typ błędu reprezentuje błąd, że nie znaleziono pliku, a typ błędu map_err metoda konwertuje std:: io:: Error na błąd FileNotFound. Wreszcie, pudełko type pozwala funkcji zwrócić dowolny typ, który implementuje cechę Error.

The główny funkcja wywołuje odczyt_pliku ze ścieżką pliku i, jeśli znajdzie plik, drukuje jego zawartość na konsoli. W przeciwnym razie drukuje komunikat o błędzie.

Oto wynik dla pliku, który nie istnieje:

Możesz polegać na modelu własności Rust dla bezpieczeństwa programu

W połączeniu ze wspaniałym mechanizmem obsługi błędów Rust, Rust wykorzystuje również model własności, który pomaga zapewnić, że twoje programy są bezpieczne dla pamięci.

Rust zapewnia reguły własności za pomocą sprawdzania wypożyczeń w czasie kompilacji przed uruchomieniem programu.