Håndtering af fejl i rust med forskellige tilgange

Fejl er uundgåelige og kan opstå af forskellige årsager, fra ugyldigt brugerinput til netværksfejl, hardwarefejl eller programmeringsfejl. Fejlhåndtering er processen med at opdage, rapportere og gendanne sådanne fejl for at forhindre programnedbrud eller datakorruption.

Effektiv fejlhåndtering er kritisk i Rust. Det lader dig skabe robuste, pålidelige applikationer, der kan håndtere uventede fejl og fejl. Rusts fejlhåndteringsmekanismer lader dig udvikle robuste, sikre programmer, der er nemmere at vedligeholde.

Typerne af fejl i rust

Rust har et rigt type system, som du kan bruge til håndtere fejl dygtigt, i henhold til deres typer. Fordelene ved Rusts rige fejltypesystem i forhold til traditionelle fejlhåndteringsmetoder kan ikke undervurderes. Fejltypesystemet giver forbedret typesikkerhed, komponerbarhed, udtryksevne og fejlfindbarhed.

Her er en liste over almindelige fejltyper i Rust:

• Det std:: io:: Fejl
  instagram viewer
  type repræsenterer I/O-fejl såsom fil ikke fundet, tilladelse nægtet eller slutningen af ​​filen nået.
• Det std:: num:: ParseIntError type repræsenterer fejl, der forekommer streng til heltal-parsingsoperationer.
• Det std:: option:: IngenFejl type repræsenterer fejl fra udpakning af tomme indstillinger.
• Det std:: resultat:: Resultat type er en generisk resultattype, som du kan bruge til at repræsentere enhver fejl.

Hver fejltype har sit eget sæt metoder og egenskaber til at håndtere den på bestemte måder.

Her er et eksempel på fejlhåndtering i Rust for en fillæsningsoperation:

brug std:: fs:: Fil;
brug std:: io:: Læs;
fnlæs_fil(sti: &str) -> Resultat<Snor, std:: io:: Fejl> {
lademut fil = Fil:: åben (sti)?;
lademut indhold = Snor::ny();
 file.read_to_string(&mut indhold)?;
Okay(indhold)
}

Det læs_fil funktionen læser indholdet af filen i den angivne sti og returnerer den som en streng. Det returnerer en std:: io:: Fejl hvis filen åbner eller læser fejl. Det ? operatør udbreder fejlen og returnerer fejlen som en Resultat.

Fejlhåndteringsmekanismer i rust

En nøglefunktion, der bidrager til Rusts sikkerhed, er dens fejlhåndteringsmekanismer. Der er fire hovedfejlhåndteringsmekanismer i Rust: Resultat type, den Mulighed type, den panik! makro og Fejl egenskab.

Typerne Resultat og Option giver mulighed for struktureret fejlhåndtering. Du kan bruge panikken! makro til at håndtere uoprettelige fejl. Fejlegenskaben lader dig definere brugerdefinerede fejltyper og tilpasset fejlhåndtering.

Resultattype

Det Resultat type er en indbygget type, der repræsenterer resultatet af en operation, der kan mislykkes. Den har to varianter: den Okay variant, som repræsenterer succes og indeholder en værdi, og Err, som repræsenterer fejl og indeholder en fejlværdi.

Sådan kan du bruge resultattypen til at åbne en fil og læse dens indhold:

brug std:: fs:: Fil;
brug std:: io:: præludium::*;
fnlæs_fil(filsti: &str) -> Resultat<Snor, std:: io:: Fejl> {
lademut fil = Fil:: åben (filsti)?;
lademut indhold = Snor::ny();
 file.read_to_string(&mut indhold)?;
Okay(indhold)
}
fnvigtigste() {
lade resultat = læse_fil("fil.txt");
match resultat {
Okay(indhold) => println!("{}", indhold),
Err(e) => println!("Fejl: {}", e),
 }
}

Det læs_fil funktionen tager filstien ind og returnerer en Resultat fejl. Hvis fillæsningen eller åbningshandlingen mislykkes, returnerer funktionen Err værdi. Ellers returnerer funktionen Okay værdi. I den vigtigste funktion, den match erklæring håndterer Resultat værdi og udskriver resultatet afhængigt af situationen for filhandlingen.

Indstillingstypen

Det Mulighed type er en indbygget type, der repræsenterer en værdis tilstedeværelse eller fravær. Det Mulighed typen har to varianter. Nogle repræsenterer en værdi, og Ingen repræsenterer fraværet af en værdi.

Her er, hvordan du kan bruge Mulighed type for at hente det første element i en vektor.

fnfå_første_elementKlon>(vec: Vec) -> Mulighed {
hvis vec.is_empty() {
Ingen
 } andet {
Nogle(vec.first().unwrap().clone())
 }
}
fnvigtigste() {
lade vec = vec![1, 2, 3];
lade resultat = get_first_element (vec);
match resultat {
Nogle(element) => println!("{}", element),
Ingen => println!("Vektoren er tom."),
 }
}

Det få_første_element funktion returnerer en Mulighed type. Hvis vektoren er tom, returnerer funktionen Ingen; ellers vender funktionen tilbage Nogle indeholdende det første element i vektoren. I den vigtigste funktion, den match erklæring håndterer Mulighed værdi. Hvis Mulighed vurderer til Nogle, udskriver funktionen det første element. Ellers udskriver funktionen en meddelelse, der angiver, at vektoren er tom.

Panikken! Makro

Det panik! makro giver funktionalitet til håndtering af uoprettelige fejl i Rust. Ved at ringe til panik! makro, udskriver den en fejlmeddelelse og afslutter programmet.

Her er et eksempel på brug af panik! makro for at angive, at en funktion har ugyldige argumenter.

fndele(udbytte: f64, divisor: f64) -> f64 {
hvis divisor == 0.0 {
panik!("Divisor kan ikke være nul.");
 }
 udbytte / divisor
}
fnvigtigste() {
lade resultat = divider(4.0, 0.0);
println!("{}", resultat);
}

Det dele funktion kontrollerer om divisor er nul; hvis divisor er nul, kalder funktionen den panik! makro med en fejlmeddelelse; ellers beregner og returnerer funktionen resultatet

Det vigtigste funktion kalder opdelingsfunktionen med ugyldige argumenter for at udløse panik! makro.

Her er fejlmeddelelsen:

Fejlegenskaben

Det Fejl egenskab er en indbygget egenskab, der definerer adfærden af ​​fejltyper. Det Fejl egenskab giver funktionalitet til at definere brugerdefinerede fejltyper og tilpasset fejlhåndtering.

Her er et eksempel på at definere en brugerdefineret fejltype, der repræsenterer en fil ikke fundet fejl.

brug std:: fejl:: Fejl;
brug std:: fmt;
brug std:: io:: Læs;
#[aflede (debug)]
strukturFil ikke fundet(Snor);
impl fmt:: Display til Fil ikke fundet {
fnfmt(&selv, f: &mut fmt:: Formatter) -> fmt::Resultat {
skrive!(f, "Fil ikke fundet: {}", selv.0)
 }
}
impl Fejl til Fil ikke fundet {}
fnlæs_fil(filsti: &str) -> Resultat<Snor, Boks<dyn Fejl >> {
lademut file = std:: fs:: File:: open (file_path).map_err(|e| FileNotFound(format!("{}", e)))?;
lademut indhold = Snor::ny();
 file.read_to_string(&mut indhold)?;
Okay(indhold)
}
fnvigtigste() {
lade resultat = læse_fil("fil.txt");
match resultat {
Okay(indhold) => println!("{}", indhold),
Err(e) => println!("Fejl: {}", e),
 }
}

Den tilpassede fejltype er Fil ikke fundet struktur. Typen indeholder en filsti, og Fil ikke fundet type implementerer Skærm egenskab til at returnere brugervenlige fejlmeddelelser og Fejl egenskab for at indikere, at dette er en fejltype.

I den læs_fil funktion, den Fil ikke fundet fejltype repræsenterer en fil ikke fundet fejl, og map_err metoden konverterer std:: io::-fejlen til en FileNotFound-fejl. Endelig, kassen type tillader funktionen at returnere enhver type, der implementerer fejlegenskaben.

Det vigtigste funktionen kalder læs_fil funktion med filstien og, hvis den finder filen, udskriver dens indhold til konsollen. Ellers udskriver den fejlmeddelelsen.

Her er resultatet for en fil, der ikke eksisterer:

Du kan stole på Rusts ejerskabsmodel for programsikkerhed

Sammen med Rusts storslåede fejlhåndteringsmekanisme bruger Rust også en ejerskabsmodel, der hjælper med at sikre, at dine programmer er hukommelsessikre.

Rust sikrer ejerskabsreglerne med en lånekontrol på kompileringstidspunktet, før dit program kører.