Hvordan håndtere feil i Golang?

Hvordan Handtere Feil I Golang



Go er et godt likt programmeringsspråk som har vokst i popularitet på grunn av sin effektivitet, hastighet og effektivitet. Imidlertid kan feil skje under utviklings- og utførelsesfasene, akkurat som med alle andre programmeringsspråk. Å håndtere feil effektivt er avgjørende for å sikre påliteligheten og stabiliteten til Go-programmene dine.

Denne artikkelen vil undersøke flere metoder og anbefalte prosedyrer for å håndtere feil i Go.







Håndter feil i Golang

I Go kan du håndtere feil gjennom de nevnte metodene:



1: Ny() funksjon

Go-språket gir Ny() funksjon for å håndtere feil. Denne funksjonen, tilgjengelig i den innebygde feilpakken, gjør det mulig for utviklere å lage tilpassede feilmeldinger for programmene sine. Ved å bruke Ny() funksjon, kan utviklere håndtere feil effektivt og gi meningsfulle feilmeldinger til brukere.



hovedpakke

import 'feil'
import 'fmt'

funksjonssjekk ( navnestreng ) feil {
nFeil := feil.Ny ( 'Ugyldig navn' )
hvis Navn ! = 'Linux' {
komme tilbake nFeil
}
komme tilbake null
}
func main ( ) {
navn := 'Linux'
feil := sjekk ( Navn )
hvis feil ! = null {
fmt.Println ( feil )
} ellers {
fmt.Println ( 'Gyldig navn' )
}
}





Koden ovenfor bruker Ny() sjekkNavn funksjon for å se om strengen Linux samsvarer med navnet som er gitt. Funksjonen produserer en feil med meldingen Ugyldig navn hvis navnet ikke er det Linux . Funksjonen returnerer null for å vise at det ikke var noen feil hvis navnet er lik Linux .

Navnevariabelen er satt til Linux i hovedfunksjonens kall til sjekkNavn funksjon, som også tar navnvariabelen som et argument. Hovedfunksjonen skriver ut feilmeldingen hvis sjekkNavn funksjonen returnerer en feil. Hovedfunksjonen skriver ut Gyldig navn hvis sjekkNavn funksjonen returnerer null.



Produksjon

2: Errorf() funksjon

De Errorf() funksjonen i Go lar oss også håndtere feil. Errorf() gir oss muligheten til å formatere feilmeldingen. Ved å importere fmt-pakken kan utviklere bruke den til å tilpasse feilmeldinger for å passe deres behov. Errorf() effektiviserer og forbedrer effektiviteten ved håndtering og formidling av feil i Go.

hovedpakke
import 'fmt'

func div ( n1, n2 du ) feil {

hvis n2 == 0 {
komme tilbake fmt.Feil ( '%d / %d \n Kan ikke dele et tall med null' , n1, n2 )
}
komme tilbake null
}
func main ( ) {
feil := div ( 42 , 0 )
hvis feil ! = null {
fmt.Printf ( 'feil: %s' , feil )
} ellers {
fmt.Println ( 'Gyldig divisjon' )
}
}

I koden ovenfor er det div funksjonen aksepterer to heltallsinnganger, n1 og n2, og hvis n2 er null, gir den en feil. Funksjonen gir en feil med en melding som inneholder verdiene til n1 og n2 hvis n2 er null. Funksjonen returnerer null for å vise at det ikke var noen feil hvis n2 ikke er null.

Feilen som div returnerer lagres i err-variabelen når hovedfunksjonen kjører div med verdiene 42 og 0. Hovedfunksjonen bruker fmt.Printf for å vise feilmeldingen hvis div-funksjonen returnerer en feil. Hovedfunksjonen skriver ut Gyldig avdeling hvis div-funksjonen returnerer null.

Produksjon

3: Eksplisitt feilhåndtering

Go oppfordrer til eksplisitt feilhåndtering sammenlignet med andre programmeringsspråk, som ofte er avhengige av unntak. Denne tilnærmingen oppfordrer utviklere til å bruke if-setninger for å eksplisitt se etter feil, i stedet for å stole på try-catch-blokker. Ved å gjøre dette er det mer sannsynlig at feil blir funnet og utbedret på riktig måte. For å lette dette tilbyr Go hvis feil != null setning, som lar utviklere se etter feil etter å ha utført en funksjon, og iverksette passende handlinger basert på resultatet. Med eksplisitt feilhåndtering tilbyr Go en mer strukturert og pålitelig tilnærming til feilhåndtering.

hovedpakke
import 'fmt'

funksjonsskille ( a, b flyte64 ) ( float64, feil ) {
hvis b == 0 {
komme tilbake 0 , fmt.Feil ( 'kan ikke dele på null' )
}
komme tilbake en / b, null
}
func main ( ) {
resultat, feil := dividere ( 1. 3 , 3 )
hvis feil ! = null {
fmt.Printf ( 'Feil: %v \n ' , feil )
} ellers {
fmt.Printf ( 'Resultat: %f \n ' , resultat )
}
resultat, feil = dividere ( 23 , 0 )
hvis feil ! = null {
fmt.Printf ( 'Feil: %v \n ' , feil )
} ellers {
fmt.Printf ( 'Resultat: %f \n ' , resultat )
}
}

I denne illustrasjonen brukes delefunksjonen til å dele to verdier. Utgangen er resultatet av å gjøre det. Hvis det andre tallet er 0, gir funksjonen en feil med en tydelig feilmelding.

Divide kalles to ganger i hovedfunksjonen: én gang med gyldige innganger og én gang med ugyldige input. Den, hvis feil != null setning brukes til å bestemme om en feil har funnet sted hver gang divisjonsfunksjonen brukes. En feilmelding skrives ut hvis en oppstår. Hvis ikke, skrives resultatet ut.

Produksjon

4: Utsett, panikk og gjenopprett

Golang gir også utsette setning, som brukes til å utføre en funksjon etter fullføring av et program eller en spesifikk kodeblokk. De utsette uttalelse brukes ofte i forbindelse med gjenopprette funksjon for å fange opp og gjenopprette fra runtime panikkfeil. Når en kjøretidspanikkfeil oppstår, gjenopprette funksjonen brukes til å gjenopprette fra feiltilstanden og forhindre at programmet krasjer. Dette er nyttig for oppryddingsoppgaver som å lukke filer, lukke nettverkstilkoblinger eller frigjøre ressurser. Ved å utsette disse oppgavene sikrer du at de blir utført selv om det oppstår en feil.

De panikk brukes til å stoppe normal kjøring av programmet når en uventet feil oppstår, mens gjenopprette brukes til å håndtere panikken og fortsette kjøringen av programmet.

hovedpakke

import 'fmt'

func recoverFromPanic ( ) {
hvis r := komme seg ( ) ; r ! = null {
fmt.Println ( 'Kommet seg etter panikk:' , r )
}
}
funksjonsskille ( x,y flyte64 ) flyte64 {
utsett recoverFromPanic ( )

hvis og == 0 {
panikk ( 'kan ikke dele på null' )
}
komme tilbake x / og
}
func main ( ) {
fmt.Println ( dele opp ( 1. 3 , 3 ) )
fmt.Println ( dele opp ( 23 , 0 ) )
}

I koden ovenfor brukes delefunksjonen til å dele to flyttallsverdier. Utgangen er resultatet av å gjøre det. En tilpasset feilmelding sendes ut av funksjonen hvis det andre tallet er null. Utsettelseserklæringen brukes til å påkalle recoverFromPanic funksjon. De recoverFromPanic funksjonen vil oppdage en panikk som skjedde inne i divisjonsfunksjonen og skrive ut en feil hvis det skjedde.

Divide kalles to ganger i hovedfunksjonen: én gang med gyldige innganger og én gang med ugyldige input. De fmt.Println funksjonen skriver ut funksjonens utdata hver gang divisjonsfunksjonen kjøres. De recoverFromPanic funksjonen vil oppdage panikk hvis det skjer og skrive ut en feil hvis den gjør det.

Produksjon

Etter å ha oppdaget feilen, kom programmet fra panikken og fortsatte å kjøre. Koden fikk imidlertid panikk og returnerte ikke en verdi ved det andre kallet om å dele, og det er grunnen til at den returnerte null.

5: Feil ved innpakning

Go inkluderer også en funksjon kjent som Feil ved innpakning , som lar deg legge til ekstra kontekst til en feilmelding. Dette er nyttig for å registrere problemer eller gi ytterligere detaljer i feilmeldinger. Dette kan oppnås ved å opprette en feiltype som bygger inn den opprinnelige feilen og tilleggskonteksten.

hovedpakke

import 'feil'
import 'fmt'

func main ( ) {
hvis feil := bar ( ) ; feil ! = null {
fmt.Println ( feil )
}
}
funksjonsskille ( a, b flyte64 ) ( float64, feil ) {
hvis b == 0 {
komme tilbake 0 , feil.Ny ( 'divisjon med null' )
}
komme tilbake en / b, null
}
func bar ( ) ( feil feil ) {
_, feile = dele ( 42 , 0 )
hvis feil ! = null {
komme tilbake fmt.Feil ( 'mislyktes i å beregne: %w' , feil )
}
komme tilbake null
}

I koden ovenfor beregner delefunksjonen forholdet mellom to tall i dette eksemplet og gir en feil hvis den andre verdien er null. Bar-funksjonen kaller delefunksjonen og bryter deretter feilen som dele opp returnerer i en ny feil med en melding som inkluderer den opprinnelige feilmeldingen ved å bruke funksjonen fmt.Errorf. Søylefunksjonen kalles opp av hovedfunksjonen, som også skriver ut eventuelle feil den returnerer.

Produksjon

Konklusjon

Programvareutvikling skal inkludere feilhåndtering , og Golang har forskjellige innebygde funksjoner og metoder for å gjøre det elegant. Disse mekanismene lar utviklere fange opp og gjenopprette feil, forhindre programkrasj og gi informative feilmeldinger til sluttbrukere. Ved å bruke disse feilhåndteringsmekanismene effektivt, kan utviklere bygge robuste, pålitelige og effektive programvareapplikasjoner.