Omgaan met fouten in roest met verschillende benaderingen

Fouten zijn onvermijdelijk en kunnen om verschillende redenen optreden, van ongeldige gebruikersinvoer tot netwerkstoringen, hardwarestoringen of programmeerfouten. Foutafhandeling is het proces van het detecteren, rapporteren en herstellen van dergelijke fouten om programmacrashes of gegevensbeschadiging te voorkomen.

Effectieve foutafhandeling is van cruciaal belang in Rust. Hiermee kunt u robuuste, betrouwbare toepassingen maken die onverwachte fouten en storingen aankunnen. Met de foutafhandelingsmechanismen van Rust kunt u veerkrachtige, veilige programma's ontwikkelen die gemakkelijker te onderhouden zijn.

De soorten fouten in roest

Rust heeft een rijk type systeem dat je kunt gebruiken vakkundig omgaan met fouten, volgens hun typen. De voordelen van het rijke foutensysteem van Rust ten opzichte van traditionele benaderingen voor foutafhandeling kunnen niet worden onderschat. Het fouttype-systeem biedt verbeterde typeveiligheid, composability, expressiviteit en foutopsporing.

Hier is een lijst met veelvoorkomende soorten fouten in Rust:

• De std:: io:: Fout type staat voor I/O-fouten zoals bestand niet gevonden, toestemming geweigerd of einde van bestand bereikt.
• De std:: num:: ParseIntError type staat voor fouten die optreden bij het parseren van tekenreeksen naar gehele getallen.
• De std:: option:: GeenFout type staat voor fouten bij het uitpakken van lege opties.
• De std:: resultaat:: Resultaat type is een generiek resultaattype dat u kunt gebruiken om elke fout weer te geven.

Elk fouttype heeft zijn eigen set methoden en kenmerken om er op specifieke manieren mee om te gaan.

Hier is een voorbeeld van foutafhandeling in Rust voor het lezen van bestanden:

gebruik std:: fs:: Bestand;
gebruik std:: io:: Lezen;
fnlees_bestand(pad: &str) -> Resultaat<Snaar, std:: io:: Fout> {
latenmuts bestand = Bestand:: openen (pad)?;
latenmuts inhoud = Snaar::nieuw();
 bestand.read_to_string(&muts inhoud)?;
OK(inhoud)
}

De lees_bestand functie leest de inhoud van het bestand in het opgegeven pad en retourneert het als een tekenreeks. Het retourneert een std:: io:: Fout als het openen of lezen van het bestand mislukt. De ? operator propageert de fout en retourneert de fout als een Resultaat.

Foutafhandelingsmechanismen in roest

Een belangrijk kenmerk dat bijdraagt ​​aan de veiligheid van Rust zijn de mechanismen voor foutafhandeling. Er zijn vier belangrijke foutafhandelingsmechanismen in Rust: de Resultaat typ de Keuze typ de paniek! macro, en de Fout karaktereigenschap.

De typen Resultaat en Optie maken een gestructureerde foutafhandeling mogelijk. Je kunt de paniek gebruiken! macro om onherstelbare fouten af ​​te handelen. Met de eigenschap Error kunt u aangepaste fouttypen en aangepaste foutafhandeling definiëren.

Het resultaattype

De Resultaat type is een ingebouwd type dat het resultaat vertegenwoordigt van een bewerking die kan mislukken. Het heeft twee varianten: de OK variant, die succes vertegenwoordigt en een waarde bevat, en Err, wat een fout vertegenwoordigt en een foutwaarde bevat.

Zo kunt u het resultaattype gebruiken om een ​​bestand te openen en de inhoud ervan te lezen:

gebruik std:: fs:: Bestand;
gebruik std:: io:: prelude::*;
fnlees_bestand(bestandspad: &str) -> Resultaat<Snaar, std:: io:: Fout> {
latenmuts bestand = Bestand:: openen (bestandspad)?;
latenmuts inhoud = Snaar::nieuw();
 bestand.read_to_string(&muts inhoud)?;
OK(inhoud)
}
fnvoornaamst() {
laten resultaat = read_file("bestand.txt");
overeenkomst resultaat {
OK(inhoud) => println!("{}", inhoud),
Err(e) => println!("Fout: {}", e),
 }
}

De lees_bestand functie neemt het bestandspad in en retourneert a Resultaat fout. Als het lezen of openen van het bestand mislukt, retourneert de functie de Err waarde. Anders retourneert de functie de OK waarde. In de voornaamst functie, de overeenkomst verklaring behandelt de Resultaat waarde en drukt het resultaat af afhankelijk van de situatie van de bestandsbewerking.

Het optietype

De Keuze type is een ingebouwd type dat de aan- of afwezigheid van een waarde vertegenwoordigt. De Keuze type heeft twee varianten. Sommige vertegenwoordigt een waarde, en Geen vertegenwoordigt de afwezigheid van een waarde.

Hier ziet u hoe u de Keuze type om het eerste element van een vector op te halen.

fnget_first_elementKloon>(vek: Vec) -> Keuze {
als vec.is_empty() {
Geen
 } anders {
Sommige(vec.first().unwrap().clone())
 }
}
fnvoornaamst() {
laten vec = vec![1, 2, 3];
laten resultaat = get_first_element (vec);
overeenkomst resultaat {
Sommige(element) => println!("{}", element),
Geen => println!("De vector is leeg."),
 }
}

De get_first_element functie retourneert een Keuze type. Als de vector leeg is, keert de functie terug Geen; anders keert de functie terug Sommige met daarin het eerste element van de vector. In de voornaamst functie, de overeenkomst verklaring behandelt de Keuze waarde. Als de Keuze evalueert naar Sommige, drukt de functie het eerste element af. Anders drukt de functie een bericht af dat aangeeft dat de vector leeg is.

De paniek! Makro

De paniek! macro biedt functionaliteit voor het afhandelen van onherstelbare fouten in Rust. Bij het bellen naar de paniek! macro, drukt het een foutmelding af en beëindigt het programma.

Hier is een voorbeeld van het gebruik van paniek! macro om aan te geven dat een functie ongeldige argumenten heeft.

fnverdeling(dividend: f64, deler: f64) -> f64 {
als deler == 0.0 {
paniek!("De deler kan niet nul zijn.");
 }
 dividend / deler
}
fnvoornaamst() {
laten resultaat = delen(4.0, 0.0);
println!("{}", resultaat);
}

De verdeling functie controleert of de deler nul is; als de deler nul is, roept de functie de paniek! macro met een foutmelding; anders berekent de functie het resultaat en retourneert het

De voornaamst functie roept de functie delen aan met ongeldige argumenten om de paniek! macro.

Dit is de foutmelding:

De fouteigenschap

De Fout eigenschap is een ingebouwde eigenschap die het gedrag van fouttypen definieert. De Fout trait biedt functionaliteit voor het definiëren van aangepaste fouttypen en aangepaste foutafhandeling.

Hier is een voorbeeld van het definiëren van een aangepast fouttype dat een fout bestand niet gevonden vertegenwoordigt.

gebruik std:: fout:: Fout;
gebruik standaard:: fmt;
gebruik std:: io:: Lezen;
#[afleiden (Debug)]
structuurBestand niet gevonden(Snaar);
impl fmt:: weergeven voor Bestand niet gevonden {
fnfmt(&zelf, F: &muts fmt:: Formatter) -> fmt::Resultaat {
schrijven!(F, "Bestand niet gevonden: {}", zelf.0)
 }
}
impl Fout voor Bestand niet gevonden {}
fnlees_bestand(bestandspad: &str) -> Resultaat<Snaar, Doos<dyn Fout>> {
latenmuts file = std:: fs:: File:: open (file_path).map_err(|e| FileNotFound(formaat!("{}", e)))?;
latenmuts inhoud = Snaar::nieuw();
 bestand.read_to_string(&muts inhoud)?;
OK(inhoud)
}
fnvoornaamst() {
laten resultaat = read_file("bestand.txt");
overeenkomst resultaat {
OK(inhoud) => println!("{}", inhoud),
Err(e) => println!("Fout: {}", e),
 }
}

Het aangepaste fouttype is de Bestand niet gevonden structuur. Het type bevat een bestandspad en de Bestand niet gevonden type implementeert de Weergave eigenschap om gebruiksvriendelijke foutmeldingen te retourneren en de Fout eigenschap om aan te geven dat dit een type fout is.

In de lees_bestand functie, de Bestand niet gevonden fouttype vertegenwoordigt een fout bestand niet gevonden, en de map_err methode converteert de std:: io:: Error naar een FileNotFound-fout. Eindelijk, de doos type stelt de functie in staat om elk type terug te geven dat de eigenschap Error implementeert.

De voornaamst functie roept de lees_bestand functie met het bestandspad en, als het het bestand vindt, drukt het de inhoud af naar de console. Anders wordt het foutbericht afgedrukt.

Dit is het resultaat voor een bestand dat niet bestaat:

U kunt vertrouwen op het eigendomsmodel van Rust voor programmaveiligheid

In combinatie met het geweldige mechanisme voor foutafhandeling van Rust, maakt Rust ook gebruik van een eigendomsmodel dat ervoor zorgt dat uw programma's geheugenveilig zijn.

Rust zorgt voor de eigendomsregels met een leencontrole tijdens het compileren voordat uw programma wordt uitgevoerd.