Det finns mer än ett sätt att hantera fel i Rust, så se till att du överväger alla alternativ.

Fel är oundvikliga och kan uppstå av olika anledningar, från ogiltig användarinmatning till nätverksfel, maskinvarufel eller programmeringsbuggar. Felhantering är processen att upptäcka, rapportera och återställa från sådana fel för att förhindra programkrascher eller datakorruption.

Effektiv felhantering är avgörande i Rust. Det låter dig skapa robusta, pålitliga applikationer som kan hantera oväntade fel och misslyckanden. Rusts felhanteringsmekanismer låter dig utveckla motståndskraftiga, säkra program som är lättare att underhålla.

Typerna av fel i rost

Rust har ett rikt typsystem som du kan använda till hantera fel på ett skickligt sätt, enligt deras typ. Fördelarna med Rusts rika feltypssystem jämfört med traditionella felhanteringsmetoder kan inte underskattas. Feltypssystemet tillhandahåller förbättrad typsäkerhet, komponerbarhet, uttrycksfullhet och felsökningsförmåga.

Här är en lista över vanliga feltyper i Rust:

instagram viewer
  • De std:: io:: Fel typ representerar I/O-fel som att filen inte hittades, tillstånd nekad eller slutet av filen nått.
  • De std:: num:: ParseIntError typ representerar fel som uppstår sträng-till-heltalsanalysoperationer.
  • De std:: option:: NoneError typ representerar fel från att packa upp tomma alternativ.
  • De std:: resultat:: Resultat typ är en generisk resultattyp som du kan använda för att representera alla fel.

Varje feltyp har sin egen uppsättning metoder och egenskaper för att hantera den på specifika sätt.

Här är ett exempel på felhantering i Rust för en filläsningsoperation:

använda sig av std:: fs:: Fil;
använda sig av std:: io:: Läs;
fnläs_fil(sökväg: &str) -> Resultat<Sträng, std:: io:: Fel> {
låtamut fil = Fil:: öppen (sökväg)?;
låtamut innehåll = Sträng::ny();
 file.read_to_string(&mut innehåll)?;
Ok(innehåll)
}

De läs_fil funktionen läser innehållet i filen i den angivna sökvägen och returnerar den som en sträng. Den returnerar en std:: io:: Fel om filen öppnas eller läses misslyckas. De ? operatören sprider felet och returnerar felet som ett Resultat.

Felhanteringsmekanismer i rost

En nyckelfunktion som bidrar till Rusts säkerhet är dess felhanteringsmekanismer. Det finns fyra huvudsakliga felhanteringsmekanismer i Rust: Resultat Skriv Alternativ Skriv panik! makro och Fel drag.

Typerna Resultat och Alternativ möjliggör strukturerad felhantering. Du kan använda paniken! makro för att hantera oåterkalleliga fel. Felegenskapen låter dig definiera anpassade feltyper och anpassad felhantering.

Resultattyp

De Resultat typ är en inbyggd typ som representerar resultatet av en operation som kan misslyckas. Den har två varianter: den Ok variant, som representerar framgång och innehåller ett värde, och Fela, som representerar fel och innehåller ett felvärde.

Så här kan du använda resultattypen för att öppna en fil och läsa dess innehåll:

använda sig av std:: fs:: Fil;
använda sig av std:: io:: prelude::*;
fnläs_fil(sökväg: &str) -> Resultat<Sträng, std:: io:: Fel> {
låtamut fil = Fil:: öppen (filsökväg)?;
låtamut innehåll = Sträng::ny();
 file.read_to_string(&mut innehåll)?;
Ok(innehåll)
}


fnhuvud() {
låta resultat = läs_fil("file.txt");
match resultat {
Ok(innehåll) => println!("{}", innehåll),
Fela(e) => println!("Fel: {}", e),
 }
}

De läs_fil funktionen tar in filsökvägen och returnerar en Resultat fel. Om filläsningen eller öppningsoperationen misslyckas returnerar funktionen Fela värde. Annars returnerar funktionen Ok värde. I den huvud funktion, den match uttalande hanterar Resultat värde och skriver ut resultatet beroende på situationen för filoperationen.

Alternativtyp

De Alternativ typ är en inbyggd typ som representerar ett värdes närvaro eller frånvaro. De Alternativ typ har två varianter. Några representerar ett värde, och Ingen representerar frånvaron av ett värde.

Så här kan du använda Alternativ typ för att hämta det första elementet i en vektor.

fnget_first_elementKlona>(vec: Vec) -> Alternativ {
om vec.is_empty() {
Ingen
 } annan {
Några(vec.first().unwrap().clone())
 }
}
fnhuvud() {
låta vec = vec![1, 2, 3];
låta resultat = get_first_element (vec);
match resultat {
Några(element) => println!("{}", element),
Ingen => println!("Vektorn är tom."),
 }
}

De get_first_element funktion returnerar en Alternativ typ. Om vektorn är tom returnerar funktionen Ingen; annars returnerar funktionen Några som innehåller det första elementet i vektorn. I den huvud funktion, den match uttalande hanterar Alternativ värde. Om Alternativ utvärderar till Några, skriver funktionen ut det första elementet. Annars skriver funktionen ut ett meddelande som indikerar att vektorn är tom.

Paniken! Makro

De panik! makro ger funktionalitet för att hantera oåterkalleliga fel i Rust. På att ringa till panik! makro, skriver den ut ett felmeddelande och avslutar programmet.

Här är ett exempel på hur man använder panik! makro för att indikera att en funktion har ogiltiga argument.

fndela upp(utdelning: f64, divisor: f64) -> f64 {
om divisor == 0.0 {
panik!("Divisorn kan inte vara noll.");
 }
 utdelning / divisor
}
fnhuvud() {
låta resultat = dividera(4.0, 0.0);
println!("{}", resultat);
}

De dela upp funktion kontrollerar om divisorn är noll; om divisorn är noll anropar funktionen panik! makro med ett felmeddelande; annars beräknar funktionen och returnerar resultatet

De huvud funktion anropar divide-funktionen med ogiltiga argument för att trigga panik! makro.

Här är felmeddelandet:

Felegenskapen

De Fel egenskap är en inbyggd egenskap som definierar beteendet hos feltyper. De Fel trait tillhandahåller funktionalitet för att definiera anpassade feltyper och anpassad felhantering.

Här är ett exempel på hur du definierar en anpassad feltyp som representerar en fil som inte hittades.

använda sig av std:: error:: Error;
använda sig av std:: fmt;
använda sig av std:: io:: Läs;
#[härleda (felsöka)]
strukturFilen hittades inte(Sträng);


impl fmt:: Display för Filen hittades inte {
fnfmt(&själv, f: &mut fmt:: Formatterare) -> fmt::Resultat {
skriva!(f, "Filen hittades inte: {}", själv.0)
 }
}


impl Fel för Filen hittades inte {}


fnläs_fil(sökväg: &str) -> Resultat<Sträng, Låda<dyn Fel >> {
låtamut file = std:: fs:: File:: open (file_path).map_err(|e| FileNotFound(formatera!("{}", e)))?;
låtamut innehåll = Sträng::ny();
 file.read_to_string(&mut innehåll)?;
Ok(innehåll)
}


fnhuvud() {
låta resultat = läs_fil("file.txt");
match resultat {
Ok(innehåll) => println!("{}", innehåll),
Fela(e) => println!("Fel: {}", e),
 }
}

Den anpassade feltypen är Filen hittades inte struktur. Typen innehåller en filsökväg och Filen hittades inte typ implementerar Visa egenskap att returnera användarvänliga felmeddelanden och Fel egenskap för att indikera att detta är en feltyp.

I den läs_fil funktion, den Filen hittades inte feltyp representerar ett fel som inte hittades i filen, och map_err metoden konverterar std:: io:: Error till ett FileNotFound-fel. Till sist, lådan typ tillåter funktionen att returnera vilken typ som helst som implementerar felegenskapen.

De huvud funktionen anropar läs_fil funktion med filsökvägen och, om den hittar filen, skriver den ut dess innehåll till konsolen. Annars skrivs felmeddelandet ut.

Här är resultatet för en fil som inte finns:

Du kan lita på Rusts ägarmodell för programsäkerhet

Tillsammans med Rusts magnifika felhanteringsmekanism använder Rust också en ägarmodell som hjälper till att säkerställa att dina program är minnessäkra.

Rust säkerställer ägandereglerna med en lånekontroll vid kompilering innan ditt program körs.