Existuje více než jeden způsob, jak ošetřit chyby v Rustu, takže se ujistěte, že jste zvážili všechny možnosti.

Chyby jsou nevyhnutelné a mohou se vyskytnout z různých důvodů, od neplatného vstupu uživatele po selhání sítě, poruchy hardwaru nebo chyby v programování. Zpracování chyb je proces zjišťování, hlášení a obnovy z takových chyb, aby se zabránilo zhroucení programu nebo poškození dat.

Efektivní zpracování chyb je v Rust zásadní. Umožňuje vytvářet robustní a spolehlivé aplikace, které si poradí s neočekávanými chybami a selháními. Mechanismy zpracování chyb společnosti Rust vám umožňují vyvíjet odolné a bezpečné programy, které se snáze udržují.

Typy chyb v rzi

Rust má bohatý typový systém, který můžete použít správně zvládat chyby, podle jejich typů. Výhody bohatého systému chybového typu Rust oproti tradičním přístupům k řešení chyb nelze podceňovat. Systém typu chyby poskytuje vylepšená bezpečnost typu, složitelnost, expresivita a laditelnost.

Zde je seznam běžných typů chyb v Rustu:

instagram viewer
  • The std:: io:: Chyba typ představuje chyby I/O, jako je nenalezen soubor, odepřeno oprávnění nebo dosažen konec souboru.
  • The std:: num:: ParseIntError typ představuje chyby, ke kterým dochází při operacích analýzy řetězce na celé číslo.
  • The std:: option:: NoneError typ představuje chyby z rozbalení prázdných možností.
  • The std:: výsledek:: Výsledek typ je obecný typ výsledku, který můžete použít k vyjádření jakékoli chyby.

Každý typ chyby má svou vlastní sadu metod a vlastností, jak s ní zacházet specifickým způsobem.

Zde je příklad zpracování chyb v programu Rust pro operaci čtení souboru:

použití std:: fs:: Soubor;
použití std:: io:: Read;
fnread_file(cesta: &str) -> Výsledek<Tětiva, std:: io:: Chyba> {
nechatmut soubor = Soubor:: otevřít (cesta)?;
nechatmut obsah = Tětiva::Nový();
 file.read_to_string(&mut obsah)?;
OK(obsah)
}

The read_file funkce přečte obsah souboru v zadané cestě a vrátí jej jako řetězec. Vrací a std:: io:: Chyba pokud operace otevření nebo čtení souboru selže. The ? operátor šíří chybu a vrací chybu jako a Výsledek.

Mechanismy zpracování chyb v Rust

Jednou z klíčových vlastností, která přispívá k bezpečnosti Rust, jsou mechanismy pro řešení chyb. V Rustu jsou čtyři hlavní mechanismy pro řešení chyb: the Výsledek typ, Volba typ, panika! makro a Chyba vlastnost.

Typy Result a Option umožňují strukturované zpracování chyb. Můžete použít paniku! makro pro zpracování neopravitelných chyb. Vlastnost Error umožňuje definovat vlastní typy chyb a vlastní zpracování chyb.

Typ výsledku

The Výsledek typ je vestavěný typ představující výsledek operace, která může selhat. Má dvě varianty: OK varianta, která představuje úspěch a obsahuje hodnotu, a Chybovat, což představuje selhání a obsahuje chybovou hodnotu.

Zde je návod, jak můžete použít typ Výsledek k otevření souboru a čtení jeho obsahu:

použití std:: fs:: Soubor;
použití std:: io:: předehra::*;
fnread_file(cesta_souboru: &str) -> Výsledek<Tětiva, std:: io:: Chyba> {
nechatmut soubor = Soubor:: otevřít (cesta_souboru)?;
nechatmut obsah = Tětiva::Nový();
 file.read_to_string(&mut obsah)?;
OK(obsah)
}


fnhlavní() {
nechat výsledek = read_file("soubor.txt");
zápas výsledek {
OK(obsah) => println!("{}", obsah),
Chybovat(e) => println!("Chyba: {}", e),
 }
}

The read_file funkce převezme cestu k souboru a vrátí a Výsledek chyba. Pokud operace čtení nebo otevření souboru selže, funkce vrátí Chybovat hodnota. V opačném případě funkce vrátí OK hodnota. V hlavní funkce, zápas prohlášení zpracovává Výsledek hodnotu a vytiskne výsledek v závislosti na situaci operace se souborem.

Typ možnosti

The Volba typ je vestavěný typ představující přítomnost nebo nepřítomnost hodnoty. The Volba typ má dvě varianty. Nějaký představuje hodnotu a Žádný představuje nepřítomnost hodnoty.

Zde je návod, jak můžete použít Volba zadejte pro načtení prvního prvku vektoru.

fnget_first_elementKlonovat>(vec: Vec) -> Volba {
-li vec.is_empty() {
Žádný
 } jiný {
Nějaký(vec.first().unwrap().clone())
 }
}
fnhlavní() {
nechat vec = vec![1, 2, 3];
nechat vysledek = get_first_element (vec);
zápas výsledek {
Nějaký(prvek) => println!("{}", prvek),
Žádný => println!("Vektor je prázdný."),
 }
}

The get_first_element funkce vrací an Volba typ. Pokud je vektor prázdný, funkce se vrátí Žádný; jinak se funkce vrátí Nějaký obsahující první prvek vektoru. V hlavní funkce, zápas prohlášení zpracovává Volba hodnota. Pokud Volba hodnotí k Nějaký, funkce vypíše první prvek. V opačném případě funkce vypíše zprávu, že vektor je prázdný.

Ta panika! Makro

The panika! makro poskytuje funkce pro zpracování neopravitelných chyb v Rust. Při volání na panika! makro, vypíše chybovou zprávu a ukončí program.

Zde je příklad použití paniky! makro označující, že funkce má neplatné argumenty.

fnrozdělit(dividenda: f64, dělitel: f64) -> f64 {
-li dělitel == 0.0 {
panika!("Děitel nemůže být nula.");
 }
 dividenda / dělitel
}
fnhlavní() {
nechat výsledek = dělit(4.0, 0.0);
println!("{}", výsledek);
}

The rozdělit funkce kontroluje, zda je dělitel nula; pokud je dělitel nula, funkce volá panika! makro s chybovým hlášením; jinak funkce vypočítá a vrátí výsledek

The hlavní funkce volá funkci rozdělení s neplatnými argumenty, aby se spustila panika! makro.

Zde je chybová zpráva:

Chybový rys

The Chyba vlastnost je vestavěná vlastnost, která definuje chování typů chyb. The Chyba vlastnost poskytuje funkce pro definování vlastních typů chyb a vlastní zpracování chyb.

Zde je příklad definování vlastního typu chyby, který představuje chybu nenalezen soubor.

použití std:: error:: Error;
použití std:: fmt;
použití std:: io:: Read;
#[derive (Debug)]
strukturovatSoubor nenalezen(Tětiva);


impl fmt:: Displej pro Soubor nenalezen {
fnfmt(&já, f: &mut fmt:: Formátovač) -> fmt::Výsledek {
napsat!(F, "Soubor nenalezen: {}", já.0)
 }
}


impl Chyba pro Soubor nenalezen {}


fnread_file(cesta_souboru: &str) -> Výsledek<Tětiva, Box<dyn Chyba >> {
nechatmut soubor = std:: fs:: Soubor:: otevřít (cesta_souboru).map_err(|e| FileNotFound(formát!("{}", e)))?;
nechatmut obsah = Tětiva::Nový();
 file.read_to_string(&mut obsah)?;
OK(obsah)
}


fnhlavní() {
nechat výsledek = read_file("soubor.txt");
zápas výsledek {
OK(obsah) => println!("{}", obsah),
Chybovat(e) => println!("Chyba: {}", e),
 }
}

Vlastní typ chyby je Soubor nenalezen strukturovat. Typ obsahuje cestu k souboru a Soubor nenalezen typ implementuje Zobrazit vlastnost vracet uživatelsky přívětivé chybové zprávy a Chyba vlastnost označující, že se jedná o typ chyby.

V read_file funkce, Soubor nenalezen typ chyby představuje chybu nenalezen soubor a map_err metoda převede chybu std:: io:: na chybu FileNotFound. Konečně, krabice type umožňuje funkci vrátit jakýkoli typ, který implementuje vlastnost Error.

The hlavní funkce volá read_file funkce s cestou k souboru a pokud soubor najde, vytiskne jeho obsah do konzole. V opačném případě vypíše chybovou zprávu.

Zde je výsledek pro soubor, který neexistuje:

Pro bezpečnost programu můžete využít vlastnický model Rust

Ve spojení s úžasným mechanismem pro řešení chyb společnosti Rust využívá Rust také model vlastnictví, který pomáhá zajistit, že vaše programy jsou v bezpečí paměti.

Rust zajišťuje pravidla vlastnictví pomocí kontroly výpůjček v době kompilace před spuštěním vašeho programu.