Riešenie chýb v hrdze s rôznymi prístupmi

Chyby sú nevyhnutné a môžu sa vyskytnúť z rôznych dôvodov, od neplatného vstupu používateľa po zlyhania siete, poruchy hardvéru alebo chyby v programovaní. Spracovanie chýb je proces zisťovania, hlásenia a obnovy z takýchto chýb, aby sa zabránilo zlyhaniu programu alebo poškodeniu údajov.

Efektívne spracovanie chýb je v Rust kritické. Umožňuje vám vytvárať robustné a spoľahlivé aplikácie, ktoré dokážu zvládnuť neočakávané chyby a zlyhania. Mechanizmy spracovania chýb spoločnosti Rust vám umožňujú vyvíjať odolné a bezpečné programy, ktoré sa ľahšie udržiavajú.

Typy chýb v hrdze

Rust má bohatý typový systém, ktorý môžete použiť zvládať chyby odborne, podľa ich typov. Výhody bohatého systému chybového typu od spoločnosti Rust v porovnaní s tradičnými prístupmi na riešenie chýb nemožno podceňovať. Systém typu chyby poskytuje zvýšená bezpečnosť typu, skladateľnosť, výraznosť a laditeľnosť.

Tu je zoznam bežných typov chýb v Rust:

• The std:: io:: Chyba typ predstavuje I/O chyby, ako napríklad nenašiel sa súbor, povolenie bolo odmietnuté alebo bol dosiahnutý koniec súboru.
• The std:: num:: ParseIntError typ predstavuje chyby, ktoré sa vyskytujú pri operáciách analýzy reťazca na celé číslo.
• The std:: option:: NoneError typ predstavuje chyby z rozbaľovania prázdnych možností.
• The std:: výsledok:: Výsledok typ je všeobecný typ výsledku, ktorý môžete použiť na vyjadrenie akejkoľvek chyby.

Každý typ chyby má svoju vlastnú množinu metód a vlastností, ako s ňou zaobchádzať špecifickými spôsobmi.

Tu je príklad spracovania chýb v programe Rust pre operáciu čítania súboru:

použitie std:: fs:: Súbor;
použitie std:: io:: Čítať;
fnread_file(cesta: &str) -> Výsledok<Reťazec, std:: io:: Chyba> {
nechmut súbor = Súbor:: otvoriť (cesta)?;
nechmut obsah = Reťazec::Nový();
 file.read_to_string(&mut obsah)?;
Dobre(obsah)
}

The read_file funkcia prečíta obsah súboru v zadanej ceste a vráti ho ako reťazec. Vracia a std:: io:: Chyba ak operácia otvorenia alebo čítania súboru zlyhá. The ? operátor šíri chybu a vráti chybu ako a Výsledok.

Mechanizmy spracovania chýb v hrdze

Jednou z kľúčových funkcií, ktorá prispieva k bezpečnosti spoločnosti Rust, sú jej mechanizmy na odstraňovanie chýb. Rust má štyri hlavné mechanizmy na odstraňovanie chýb: Výsledok typ, Možnosť typ, panika! makro a Chyba vlastnosť.

Typy Result a Option umožňujú štruktúrované spracovanie chýb. Môžete použiť paniku! makro na spracovanie neodstrániteľných chýb. Vlastnosť Error vám umožňuje definovať vlastné typy chýb a vlastné spracovanie chýb.

Typ výsledku

The Výsledok typ je vstavaný typ predstavujúci výsledok operácie, ktorá môže zlyhať. Má dve varianty: Dobre variant, ktorý predstavuje úspech a obsahuje hodnotu, a Err, čo predstavuje zlyhanie a obsahuje chybovú hodnotu.

Tu je návod, ako môžete použiť typ Výsledok na otvorenie súboru a prečítanie jeho obsahu:

použitie std:: fs:: Súbor;
použitie std:: io:: predohra::*;
fnread_file(cesta k súboru: &str) -> Výsledok<Reťazec, std:: io:: Chyba> {
nechmut file = File:: open (file_path)?;
nechmut obsah = Reťazec::Nový();
 file.read_to_string(&mut obsah)?;
Dobre(obsah)
}
fnHlavná() {
nech výsledok = read_file("subor.txt");
zápas výsledok {
Dobre(obsah) => println!("{}", obsah),
Err(e) => println!("Chyba: {}", e),
 }
}

The read_file funkcia prevezme cestu k súboru a vráti a Výsledok chyba. Ak operácia čítania alebo otvorenia súboru zlyhá, funkcia vráti Err hodnotu. V opačnom prípade funkcia vráti Dobre hodnotu. V Hlavná funkcia, zápas vyhlásenie rieši Výsledok hodnotu a vytlačí výsledok v závislosti od situácie operácie so súborom.

Typ možnosti

The Možnosť typ je vstavaný typ reprezentujúci prítomnosť alebo neprítomnosť hodnoty. The Možnosť typ má dve varianty. Niektorí predstavuje hodnotu a žiadne predstavuje absenciu hodnoty.

Tu je návod, ako môžete použiť Možnosť zadajte na získanie prvého prvku vektora.

fnget_first_elementKlonovať>(vec: Vec) -> Možnosť {
ak vec.is_empty() {
žiadne
 } inak {
Niektorí(vec.first().unwrap().clone())
 }
}
fnHlavná() {
nech vec = vec![1, 2, 3];
nech vysledok = get_first_element (vec);
zápas výsledok {
Niektorí(prvok) => println!("{}", element),
žiadne => println!("Vektor je prázdny."),
 }
}

The get_first_element funkcia vracia an Možnosť typu. Ak je vektor prázdny, funkcia sa vráti žiadne; inak sa funkcia vráti Niektorí obsahujúci prvý prvok vektora. V Hlavná funkcia, zápas vyhlásenie rieši Možnosť hodnotu. Ak Možnosť hodnotí na Niektorí, funkcia vypíše prvý prvok. V opačnom prípade funkcia vypíše správu, že vektor je prázdny.

Tá panika! Makro

The panika! makro poskytuje funkcie na spracovanie neodstrániteľných chýb v Rust. Pri volaní na panika! makro, vypíše chybové hlásenie a ukončí program.

Tu je príklad použitia paniky! makro na označenie, že funkcia má neplatné argumenty.

fnrozdeliť(dividenda: f64, deliteľ: f64) -> f64 {
ak deliteľ == 0.0 {
panika!("Deliteľ nemôže byť nula.");
 }
 dividenda / deliteľ
}
fnHlavná() {
nech výsledok = rozdeliť(4.0, 0.0);
println!("{}", výsledok);
}

The rozdeliť funkcia kontroluje, či je deliteľ nula; ak je deliteľ nula, funkcia volá panika! makro s chybovým hlásením; v opačnom prípade funkcia vypočíta a vráti výsledok

The Hlavná funkcia volá funkciu rozdelenia s neplatnými argumentmi na spustenie panika! makro.

Tu je chybové hlásenie:

Chybovosť

The Chyba vlastnosť je vstavaná vlastnosť, ktorá definuje správanie typov chýb. The Chyba vlastnosť poskytuje funkcie na definovanie vlastných typov chýb a vlastné spracovanie chýb.

Tu je príklad definovania vlastného typu chyby, ktorý predstavuje chybu nenájdený súbor.

použitie std:: error:: Error;
použitie std:: fmt;
použitie std:: io:: Čítať;
#[derive (Debug)]
štrukturovaťSúbor nenájdený(Reťazec);
impl fmt:: Displej pre Súbor nenájdený {
fnfmt(&seba, f: &mut fmt:: Formátovač) -> fmt::Výsledok {
píšte!(f, "Súbor nenájdený: {}", seba.0)
 }
}
impl Chyba pre Súbor nenájdený {}
fnread_file(cesta k súboru: &str) -> Výsledok<Reťazec, Box<dyn Chyba >> {
nechmut file = std:: fs:: File:: open (file_path).map_err(|e| FileNotFound(formát!("{}", e)))?;
nechmut obsah = Reťazec::Nový();
 file.read_to_string(&mut obsah)?;
Dobre(obsah)
}
fnHlavná() {
nech výsledok = read_file("subor.txt");
zápas výsledok {
Dobre(obsah) => println!("{}", obsah),
Err(e) => println!("Chyba: {}", e),
 }
}

Vlastný typ chyby je Súbor nenájdený štrukturovať. Typ obsahuje cestu k súboru a Súbor nenájdený typ implementuje Displej vlastnosť vracať užívateľsky prívetivé chybové správy a Chyba vlastnosť, ktorá naznačuje, že ide o typ chyby.

V read_file funkcia, Súbor nenájdený typ chyby predstavuje chybu nenájdený súbor a map_err metóda konvertuje chybu std:: io:: na chybu FileNotFound. nakoniec box type umožňuje funkcii vrátiť akýkoľvek typ, ktorý implementuje vlastnosť Error.

The Hlavná funkcia volá read_file funkciu s cestou k súboru a ak súbor nájde, vytlačí jeho obsah do konzoly. V opačnom prípade vytlačí chybové hlásenie.

Tu je výsledok pre súbor, ktorý neexistuje:

Pre bezpečnosť programu sa môžete spoľahnúť na model vlastníctva Rust

V spojení s úžasným mechanizmom na odstraňovanie chýb od spoločnosti Rust, Rust tiež využíva model vlastníctva, ktorý pomáha zaistiť bezpečnosť vašich programov v pamäti.

Rust zaisťuje pravidlá vlastníctva pomocou kontroly výpožičiek v čase kompilácie pred spustením vášho programu.