Hvordan håndterer man fejl i Golang?

Hvordan Handterer Man Fejl I Golang



Go er et vellidt programmeringssprog, der er vokset i popularitet på grund af dets effektivitet, hastighed og effektivitet. Der kan dog ske fejl under udviklings- og udførelsesfaserne, ligesom med ethvert andet programmeringssprog. Effektiv håndtering af fejl er afgørende for at sikre pålideligheden og stabiliteten af ​​dine Go-programmer.

Denne artikel vil undersøge flere metoder og anbefalede procedurer til håndtering af fejl i Go.







Håndter fejl i Golang

I Go kan du håndtere fejl gennem nedenstående metoder:



1: Ny() funktion

Go-sproget giver Ny() funktion til at håndtere fejl. Denne funktion, tilgængelig i den indbyggede fejlpakke, gør det muligt for udviklere at oprette brugerdefinerede fejlmeddelelser til deres programmer. Ved at bruge Ny() funktion, kan udviklere håndtere fejl effektivt og give meningsfulde fejlmeddelelser til brugerne.



hovedpakke

importere 'fejl'
importere 'fmt'

funktionstjek ( navnestreng ) fejl {
nFejl := fejl.Ny ( 'Ugyldigt navn' )
hvis navn ! = 'Linux' {
Vend tilbage nFejl
}
Vend tilbage nul
}
func hoved ( ) {
navn := 'Linux'
fejl := check ( navn )
hvis fejl ! = nul {
fmt.Println ( fejl )
} andet {
fmt.Println ( 'Gyldigt navn' )
}
}





Ovenstående kode bruger Ny() checkName funktion for at se, om strengen Linux matcher det angivne navn. Funktionen giver en fejl med meddelelsen Ugyldigt navn hvis navnet ikke er det Linux . Funktionen returnerer nul for at vise, at der ikke var nogen fejl, hvis navnet er lig med Linux .

Navnevariablen er sat til Linux i hovedfunktionens opkald til checkName funktion, som også tager navnevariablen som et argument. Hovedfunktionen udskriver fejlmeddelelsen, hvis checkName funktion returnerer en fejl. Hovedfunktionen udskriver Gyldigt navn hvis checkName funktion returnerer nul.



Produktion

2: Errorf() Funktion

Det Fejl() funktion i Go giver os mulighed for også at håndtere fejl. Fejl() giver os mulighed for at formatere fejlmeddelelsen. Ved at importere fmt-pakken kan udviklere bruge den til at tilpasse fejlmeddelelser, så de passer til deres behov. Fejl() strømliner og forbedrer effektiviteten af ​​styring og formidling af fejl i Go.

hovedpakke
importere 'fmt'

func div ( n1, n2 dig ) fejl {

hvis n2 == 0 {
Vend tilbage fmt.Fejl ( '%d / %d \n Kan ikke dividere et tal med nul' n1, n2 )
}
Vend tilbage nul
}
func hoved ( ) {
fejl := div ( 42 , 0 )
hvis fejl ! = nul {
fmt.Printf ( 'fejl: %s' , fejl )
} andet {
fmt.Println ( 'Gyldig division' )
}
}

I ovenstående kode er div Funktionen accepterer to heltals input, n1 og n2, og hvis n2 er nul, producerer den en fejl. Funktionen producerer en fejl med en meddelelse, der indeholder værdierne af n1 og n2, hvis n2 er nul. Funktionen returnerer nul for at vise, at der ikke var nogen fejl, hvis n2 ikke er nul.

Fejlen som div returnerer gemmes i err-variablen når hovedfunktionen kører div med værdierne 42 og 0. Hovedfunktionen bruger fmt.Printf til at vise fejlmeddelelsen hvis div-funktionen returnerer en fejl. Hovedfunktionen udskriver Gyldig division hvis div-funktionen returnerer nul.

Produktion

3: Eksplicit fejlhåndtering

Go tilskynder til eksplicit fejlhåndtering sammenlignet med andre programmeringssprog, som ofte er afhængige af undtagelser. Denne tilgang opfordrer udviklere til at bruge if-sætninger til eksplicit at tjekke for fejl, i stedet for at stole på try-catch-blokke. Ved at gøre dette er der større sandsynlighed for, at fejl bliver fundet og afhjulpet korrekt. For at lette dette tilbyder Go hvis fejl != nul sætning, som giver udviklere mulighed for at tjekke for fejl efter at have udført en funktion, og tage passende handlinger baseret på resultatet. Med eksplicit fejlhåndtering tilbyder Go en mere struktureret og pålidelig tilgang til fejlhåndtering.

hovedpakke
importere 'fmt'

funktionsdeling ( a, b float64 ) ( float64, fejl ) {
hvis b == 0 {
Vend tilbage 0 , fmt.Fejl ( 'kan ikke dividere med nul' )
}
Vend tilbage -en / b, intet
}
func hoved ( ) {
resultat, fejl := dividere ( 13 , 3 )
hvis fejl ! = nul {
fmt.Printf ( 'Fejl: %v \n ' , fejl )
} andet {
fmt.Printf ( 'Resultat: %f \n ' , resultat )
}
resultat, fejl = dividere ( 23 , 0 )
hvis fejl ! = nul {
fmt.Printf ( 'Fejl: %v \n ' , fejl )
} andet {
fmt.Printf ( 'Resultat: %f \n ' , resultat )
}
}

I denne illustration bruges dividerfunktionen til at dividere to værdier. Outputtet er resultatet af at gøre det. Hvis det andet tal er 0, producerer funktionen en fejl med en tydelig fejlmeddelelse.

Divide kaldes to gange i hovedfunktionen: én gang med gyldige input og én gang med ugyldige input. Den, hvis fejl != nul sætning bruges til at bestemme, om der er sket en fejl, hver gang divisionsfunktionen bruges. Der udskrives en fejlmeddelelse, hvis en sådan opstår. Hvis ikke, udskrives resultatet.

Produktion

4: Udskyd, panik og restituér

Golang giver også udsætte sætning, som bruges til at udføre en funktion efter afslutningen af ​​et program eller en specifik kodeblok. Det udsætte statement bruges ofte i forbindelse med gendanne funktion til at fange og gendanne fra runtime panikfejl. Når der opstår en runtime panikfejl, vil gendanne funktion bruges til at gendanne fejltilstanden og forhindre programmet i at gå ned. Dette er nyttigt til oprydningsopgaver såsom lukning af filer, lukning af netværksforbindelser eller frigivelse af ressourcer. Ved at udskyde disse opgaver sikrer du, at de bliver udført, selvom der opstår en fejl.

Det panik bruges til at stoppe den normale afvikling af programmet, når der opstår en uventet fejl, mens gendanne bruges til at håndtere panikken og fortsætte afviklingen af ​​programmet.

hovedpakke

importere 'fmt'

func recoverFromPanic ( ) {
hvis r := komme sig ( ) ; r ! = nul {
fmt.Println ( 'Restitueret fra panik:' , r )
}
}
funktionsdeling ( x,y float64 ) flyde 64 {
udskyd recoverFromPanic ( )

hvis og == 0 {
panik ( 'kan ikke dividere med nul' )
}
Vend tilbage x / og
}
func hoved ( ) {
fmt.Println ( dele ( 13 , 3 ) )
fmt.Println ( dele ( 23 , 0 ) )
}

I ovenstående kode bruges divide-funktionen til at dividere to flydende kommaværdier. Outputtet er resultatet af at gøre det. En tilpasset fejlmeddelelse udsendes af funktionen, hvis det andet tal er nul. Udsættelseserklæringen bruges til at påberåbe sig recoverFromPanic fungere. Det recoverFromPanic funktionen vil registrere en panik, der skete inde i divisionsfunktionen, og udskrive en fejl, hvis det skete.

Divide kaldes to gange i hovedfunktionen: én gang med gyldige input og én gang med ugyldige input. Det fmt.Println funktion udskriver funktionens output, hver gang divisionsfunktionen køres. Det recoverFromPanic funktionen vil opdage panik, hvis det sker, og udskrive en fejl, hvis det sker.

Produktion

Efter at have opdaget fejlen, kom programmet over panikken og fortsatte med at køre. Koden gik dog i panik og returnerede ikke en værdi ved det andet opkald om at dividere, hvorfor den returnerede nul.

5: Fejl ved indpakning

Go indeholder også en funktion kendt som Fejl ved indpakning , som giver dig mulighed for at tilføje yderligere kontekst til en fejlmeddelelse. Dette er nyttigt til at registrere problemer eller give yderligere detaljer i fejlmeddelelser. Dette kan opnås ved at oprette en fejltype, der integrerer den oprindelige fejl og yderligere kontekst.

hovedpakke

importere 'fejl'
importere 'fmt'

func hoved ( ) {
hvis fejl := bar ( ) ; fejl ! = nul {
fmt.Println ( fejl )
}
}
funktionsdeling ( a, b float64 ) ( float64, fejl ) {
hvis b == 0 {
Vend tilbage 0 , fejl.Ny ( 'division med nul' )
}
Vend tilbage -en / b, intet
}
func bar ( ) ( fejl fejl ) {
_, fejl = dividere ( 42 , 0 )
hvis fejl ! = nul {
Vend tilbage fmt.Fejl ( 'ikke kunne beregne: %w' , fejl )
}
Vend tilbage nul
}

I ovenstående kode beregner divide-funktionen forholdet mellem to tal i dette eksempel og kaster en fejl, hvis den anden værdi er nul. Barfunktionen kalder dividerfunktionen og ombryder derefter fejlen, der dele returnerer i en ny fejl med en meddelelse, der inkluderer den originale fejlmeddelelse ved hjælp af fmt.Errrorf-funktionen. Søjlefunktionen kaldes af hovedfunktionen, som også udskriver eventuelle fejl, den returnerer.

Produktion

Konklusion

Softwareudvikling skal omfatte fejlhåndtering , og Golang har forskellige indbyggede funktioner og metoder til at gøre det med ynde. Disse mekanismer giver udviklere mulighed for at fange og gendanne fejl, forhindre programnedbrud og give informative fejlmeddelelser til slutbrugere. Ved at bruge disse fejlhåndteringsmekanismer effektivt kan udviklere bygge robuste, pålidelige og effektive softwareapplikationer.