Håndtering av feil i rust med ulike tilnærminger

Feil er uunngåelige og kan oppstå av ulike årsaker, fra ugyldig brukerinndata til nettverksfeil, maskinvarefeil eller programmeringsfeil. Feilhåndtering er prosessen med å oppdage, rapportere og gjenopprette fra slike feil for å forhindre programkrasj eller datakorrupsjon.

Effektiv feilhåndtering er kritisk i Rust. Den lar deg lage robuste, pålitelige applikasjoner som kan håndtere uventede feil og feil. Rusts feilhåndteringsmekanismer lar deg utvikle spenstige, sikre programmer som er enklere å vedlikeholde.

Typer av feil i rust

Rust har en rik type system som du kan bruke til håndtere feil på en dyktig måte, i henhold til deres typer. Fordelene med Rusts rike feiltypesystem fremfor tradisjonelle feilhåndteringsmetoder kan ikke undervurderes. Feiltypesystemet gir forbedret typesikkerhet, komponerbarhet, uttrykksevne og feilsøkbarhet.

Her er en liste over vanlige feiltyper i Rust:

• De std:: io:: Feil
  instagram viewer
  type representerer I/O-feil som fil ikke funnet, tillatelse nektet eller slutten av filen nådd.
• De std:: num:: ParseIntError type representerer feil som oppstår streng-til-heltall-parsingsoperasjoner.
• De std:: option:: NoneError type representerer feil fra utpakking av tomme alternativer.
• De std:: resultat:: Resultat type er en generisk resultattype som du kan bruke til å representere enhver feil.

Hver feiltype har sitt eget sett med metoder og egenskaper for å håndtere den på bestemte måter.

Her er et eksempel på feilhåndtering i Rust for en fillesingsoperasjon:

bruk std:: fs:: Fil;
bruk std:: io:: Les;
fnlese_fil(bane: &str) -> Resultat<String, std:: io:: Feil> {
lamut fil = Fil:: åpen (bane)?;
lamut innhold = String::ny();
 file.read_to_string(&mut innhold)?;
Ok(innhold)
}

De lese_fil funksjonen leser innholdet i filen i den angitte banen og returnerer den som en streng. Den returnerer en std:: io:: Feil hvis filen åpnes eller leseoperasjonen mislykkes. De ? operatør forplanter feilen og returnerer feilen som en Resultat.

Feilhåndteringsmekanismer i rust

En nøkkelfunksjon som bidrar til Rusts sikkerhet er feilhåndteringsmekanismene. Det er fire hovedfeilhåndteringsmekanismer i Rust: Resultat type, den Alternativ type, den panikk! makro, og Feil trekk.

Resultat- og Alternativ-typene tillater strukturert feilhåndtering. Du kan bruke panikken! makro for å håndtere uopprettelige feil. Feiltrekket lar deg definere egendefinerte feiltyper og tilpasset feilhåndtering.

Resultattype

De Resultat type er en innebygd type som representerer utfallet av en operasjon som kan mislykkes. Den har to varianter: den Ok variant, som representerer suksess og inneholder en verdi, og Err, som representerer feil og inneholder en feilverdi.

Slik kan du bruke resultattypen til å åpne en fil og lese innholdet:

bruk std:: fs:: Fil;
bruk std:: io:: preludium::*;
fnlese_fil(filbane: &str) -> Resultat<String, std:: io:: Feil> {
lamut fil = Fil:: åpen (filbane)?;
lamut innhold = String::ny();
 file.read_to_string(&mut innhold)?;
Ok(innhold)
}
fnhoved-() {
la resultat = lese_fil("file.txt");
kamp resultat {
Ok(innhold) => println!("{}", innhold),
Err(e) => println!("Feil: {}", e),
 }
}

De lese_fil funksjonen tar inn filbanen og returnerer en Resultat feil. Hvis fillesingen eller åpningsoperasjonen mislykkes, returnerer funksjonen Err verdi. Ellers returnerer funksjonen Ok verdi. I hoved- funksjon, den kamp uttalelse håndterer Resultat verdi og skriver ut resultatet avhengig av situasjonen for filoperasjonen.

Alternativtypen

De Alternativ type er en innebygd type som representerer en verdis tilstedeværelse eller fravær. De Alternativ typen har to varianter. Noen representerer en verdi, og Ingen representerer fraværet av en verdi.

Her er hvordan du kan bruke Alternativ type for å hente det første elementet i en vektor.

fnget_first_elementKlone>(vec: Vec) -> Alternativ {
hvis vec.is_empty() {
Ingen
 } ellers {
Noen(vec.first().unwrap().clone())
 }
}
fnhoved-() {
la vec = vec![1, 2, 3];
la resultat = get_first_element (vec);
kamp resultat {
Noen(element) => println!("{}", element),
Ingen => println!("Vektoren er tom."),
 }
}

De get_first_element funksjonen returnerer en Alternativ type. Hvis vektoren er tom, returnerer funksjonen Ingen; ellers returnerer funksjonen Noen som inneholder det første elementet i vektoren. I hoved- funksjon, den kamp uttalelse håndterer Alternativ verdi. Hvis Alternativ vurderer til Noen, skriver funksjonen ut det første elementet. Ellers skriver funksjonen ut en melding som indikerer at vektoren er tom.

Panikken! Makro

De panikk! makro gir funksjonalitet for håndtering av uopprettelige feil i Rust. Ved å ringe til panikk! makro, skriver den ut en feilmelding og avslutter programmet.

Her er et eksempel på bruk av panikk! makro for å indikere at en funksjon har ugyldige argumenter.

fndele opp(utbytte: f64, deler: f64) -> f64 {
hvis divisor == 0.0 {
panikk!("Divisor kan ikke være null.");
 }
 utbytte / deler
}
fnhoved-() {
la resultat = dele(4.0, 0.0);
println!("{}", resultat);
}

De dele opp funksjon sjekker om divisor er null; hvis divisor er null, kaller funksjonen panikk! makro med en feilmelding; ellers beregner funksjonen og returnerer resultatet

De hoved- funksjon kaller delefunksjonen med ugyldige argumenter for å utløse panikk! makro.

Her er feilmeldingen:

Feiltrekket

De Feil egenskap er en innebygd egenskap som definerer oppførselen til feiltyper. De Feil trait gir funksjonalitet for å definere tilpassede feiltyper og tilpasset feilhåndtering.

Her er et eksempel på å definere en egendefinert feiltype som representerer en fil som ikke ble funnet.

bruk std:: error:: Feil;
bruk std:: fmt;
bruk std:: io:: Les;
#[avlede (feilsøke)]
strukturFil ikke funnet(String);
impl fmt:: Display til Fil ikke funnet {
fnfmt(&selv-, f: &mut fmt:: Formatter) -> fmt::Resultat {
skrive!(f, "Fil ikke funnet: {}", selv-.0)
 }
}
impl Feil til Fil ikke funnet {}
fnlese_fil(filbane: &str) -> Resultat<String, Eske<dyn Feil >> {
lamut file = std:: fs:: File:: open (file_path).map_err(|e| FileNotFound(format!("{}", e)))?;
lamut innhold = String::ny();
 file.read_to_string(&mut innhold)?;
Ok(innhold)
}
fnhoved-() {
la resultat = lese_fil("file.txt");
kamp resultat {
Ok(innhold) => println!("{}", innhold),
Err(e) => println!("Feil: {}", e),
 }
}

Den tilpassede feiltypen er Fil ikke funnet struktur. Typen inneholder en filbane, og Fil ikke funnet type implementerer Vise egenskap å returnere brukervennlige feilmeldinger og Feil egenskap for å indikere at dette er en feiltype.

I lese_fil funksjon, den Fil ikke funnet feiltype representerer en fil ikke funnet feil, og map_err metoden konverterer std:: io::-feilen til en FileNotFound-feil. Endelig, boksen type lar funksjonen returnere alle typer som implementerer Feil-egenskapen.

De hoved- funksjonen kaller lese_fil funksjon med filbanen og, hvis den finner filen, skriver den ut innholdet til konsollen. Ellers skriver den ut feilmeldingen.

Her er resultatet for en fil som ikke eksisterer:

Du kan stole på Rusts eierskapsmodell for programsikkerhet

Sammen med Rusts fantastiske feilhåndteringsmekanisme, bruker Rust også en eierskapsmodell som bidrar til å sikre at programmene dine er minnesikre.

Rust sikrer eierskapsreglene med en lånekontroll på kompileringstidspunktet før programmet kjører.