Feilhåndtering i rust

Feilhåndtering er praktisk talt den nest vanligste tingen for en programmerer, bortsett fra å gjøre feil, selvfølgelig. Som utvikler vil du møte scenarier der du trenger å forvente en feil og lage handling hvis det skjer.

Selv om kompilatoren vil implementere standardfeilhåndtering, er det godt å forstå hvordan man håndterer feil for tilpasset logikk. Feilhåndtering vil forhindre at programmet ditt returnerer uønsket output eller avslutter unormalt.

La oss utforske hvordan vi kan håndtere feil i rustprogrammeringsspråket.

Rustfeiltyper

Det er to typer feil i rust:

1. Gjenvinnbare feil
2. Uopprettelige feil

Uopprettelige feil

Uopprettelige feil refererer til hvilke typer feil som får et program til å dø eller avslutte unormalt. Et eksempel vil være å få tilgang til en utenforbundet indeks i en matrise.

Rust bruker panikken! makro for å håndtere uopprettelige feil. Anta at kompilatoren møter panikken! Makro i koden din. Den skriver ut de spesifiserte meldingene, renser opp stabelen og avslutter programmet.

Panikken! Makro er veldig nyttig når du møter feil som programmet ikke kan komme seg.

Ta et enkelt program gitt nedenfor som illustrerer hvordan du bruker panikkmakroen:

fn main ()
panikk!("Jeg er død!!");

Når du har utført den forrige koden, bør du få en utdata som vist nedenfor:

Ringer panikk! får programmet til å avslutte og skrive ut panikkmetoden som er spesifisert.

Bakstryning av panikk

Rust lar oss bake tilbake feilkilden ved å bruke Rust_BackTrace miljøvariabelen. Backstrekk refererer til en liste over funksjoner som er blitt kalt før feilen oppstod.

Ta eksemplet gitt nedenfor:

fn main ()
La VEC = VEC![1,2,3,4,5];
Println!(“”, Vec [5]);

I forrige eksempel prøver vi å lese en array-indeks utenfor grensen. Dette bør føre til at programmet får panikk og avslutte.

Et utgangseksempelutgang er gitt nedenfor:

Som du ser fra utdataene, forteller kompilatoren oss at vi kan bruke Rust_backTrace Environment Variable for å få backtrace i feilen.

Vi kan gjøre dette ved hjelp av følgende kommando:

$ Rust_backTrace = 1 lastekjøring

Dette skal returnere backtrace -utgangen som:

Dette bør returnere en detaljert utdata av hvordan feilen skjedde i koden din. For et helt ordentlig alternativ kan du bruke rust_backTrace = fullt.

Gjenvinnbare feil

Vanligvis trenger du sjelden å håndtere uopprettelige feil. For å håndtere gjenvinnbare feil i rust, bruker vi resultatet enum, som har to varianter: OK og feil.

La oss ta følgende enkle program som prøver å åpne en fil:

usestd :: fs :: fil;
fnMain ()
La fil = fil :: Åpne ("Hei.tekst");
Println!(":? ", fil);

Den forrige koden prøver å åpne en ikke-eksisterende fil. Å kjøre programmet som er gitt ovenfor, bør returnere som:

Err (OS Code: 2, Kind: Notfound, Melding: "Systemet kan ikke finne filen som er spesifisert.")

Vi kan imidlertid definere handlingen vi ønsker hvis filen ikke eksisterer. Et eksempel er vist nedenfor:

usestd :: fs :: fil;
fnMain ()
La fil = fil :: Åpne ("Hei.tekst");
match fil
Ok (fil) =>
Println!("Fil funnet: :? ", fil)
,
Feil (_error) =>
Println!("fil ikke funnet")

Her bruker vi kampoperatøren for å sjekke om filen returnerte en feil eller OK. Deretter tar vi handlingene for hvert tilfelle.

Vi kan også bruke forventningsmetoden for å lage tilpassede feilhåndtering av spesifikasjoner.

For eksempel:

usestd :: fs :: fil;
fnMain ()
La fil = fil :: Åpne ("Hei.tekst")
.Forvent ("feil oppstod når du leser filen");

Forventsmetoden, som vil kalle panikkmakroen i en feil, blir oppstått når du åpner filen.

Lukking

Denne opplæringen dekket grunnleggende feilhåndtering på rustprogrammeringsspråket. I tillegg diskuterte denne guiden de to typene feil: utvinnbare feil og uopprettelige feil. Vi håper du fant denne artikkelen nyttig. Sjekk de andre Linux -hint -artiklene for flere tips og informasjon.