Grunderna för felhantering i Golang

En av de mest användbara funktionerna i programmeringsspråket Go är hur det hanterar fel. Istället för att använda en Try/Catch-metodik som andra programmeringsspråk behandlar Go fel som normala returvärden.

Genom att skapa enkla moduler och tillämpa några loggningsregler kan vi producera användbara felmeddelanden för att fånga upp alla typer av undantag under utvecklingsprocessen.

I den här artikeln kommer vi att täcka några av de mest grundläggande sätten som Golang hittar och hanterar dessa undantag.

Golang grundläggande felhantering

Vi kan fånga upp fel i Go genom att använda enkla if/then-anvisningar som kontrollerar villkor där nödvändiga parametrar inte är uppfyllda.

Låt oss titta på en grundläggande modul som vi kan skapa för att kontrollera om en sträng innehåller ett värde eller inte.

Skapa ett paket som heter ”hello” och importera standardmodulerna ”errors” och ”fmt” för att känna igen fel och formaterad text:

package helloimport ("errors""fmt")

Därefter kan vi skapa en modul som returnerar en textsträng för en namngiven variabel.

func Hello(name string) (string, error) {if name == "" {return "", errors.New("No name was given")}

Ovanstående kontrollerar om en tom sträng returneras för variabeln ”name”, som sedan returnerar ett nytt fel med viss angiven text. Detta är vårt feltillstånd. Ett felvillkor kontrollerar om själva felet finns.
Om villkoret inte uppfylls (dvs. det finns inget fel) returnerar vi det värde som matchar den angivna variabeln ”name”:

message := fmt.Sprintf("Hi, %v. Welcome!", name)return message, nil}

Bemärk att det returnerar meddelandet och värdet ”nil”, vilket betyder att det inte finns något fel. Detta talar om för det anropande programmet att funktionen bearbetades utan fel.

Nu ska vi titta på hur vi kan anropa det här paketet i ett riktigt skript.

Låt oss skapa ett nytt skript som heter test.go

Som vanligt med Golang måste ett skript börja med att definiera paketet som ”main”. Vi importerar sedan paketen ”fmt” och ”log”, tillsammans med vårt skapade paket ”hello”, enligt nedan:

package mainimport ("fmt""log""yoursite.com/hello")

Nedan definierar vi vår huvudfunktion, ställer in några egenskaper för vår loggare för att skapa ett lättförståeligt prefix och (av säkerhetsskäl) skapar vi en flagga så att vi inte visar tid, källfil och radnummer.

func main() {log.SetPrefix("Hello: ")log.SetFlags(0)

Nästan anger vi ett meddelande som ska visas:

message, err := hello.Hello("")

Slutligt tittar vi för att se om det finns ett fel genom att kontrollera om ”err” inte är lika med ”nil”. Om så är fallet skriver vi ut meddelandet till konsolen och avslutar.

if err != nil {log.Fatal(err)}

Om inget feltillstånd föreligger skriver vi helt enkelt ut det meddelande som definierades i vårt hello-paket.

fmt.Println(message)}

För att testa detta kan vi köra koden som den är. När vi gör det bör vi få ett resultat som ser ut så här:

>go run test.gogreetings: No name was givenexit status 1

Om vi vill ändra vårt skript test.go skriver vi in något liknande:

message, err := hello.Hello("John")

Vår utdata bör då se ut så här:

>go run test.goHi, John. Welcome!

En annan typ av felmeddelande som vi kan returnera är:

fmt.Errorf – detta kommer att formatera en sträng enligt Printfs regler.

Hantering av heltal i Golang

Självklart är strängfel bara en typ av fel. Med Golangs felhantering finns det flera andra fel som du kan kontrollera i din kod. Ett särskilt fel som du bör känna till är numeriska fel.

Hantering av heltal är enkelt för Go. Så här fungerar det:

Säg att vi har numeriska fel, till exempel om vi skulle dividera med noll. Först skapar vi en funktion ”Division” som dividerar två variabler x med y. För den första delen av vårt if/then-villkor måste vi se till att y inte är lika med noll:

func Division(x int, y int) (int, error) {if y == 0 {return 0, errors.New("Thou shalt not divide by zero!")} else {return (x / y), nil}}

Detta är huvudfunktionen. Nu kan du ge den två variabler. I det här exemplet använder vi 12 och 0.

func main() {if result, err := Division(12, 0); err != nil {fmt.Println("We got an error: ", err)} else {fmt.Println("The answer is", result)}}

Du får då ett meddelande som lyder ungefär som:

”Vi fick ett fel: Detta är bara ett exempel på hur du kan använda Golangs felhantering för att hitta numeriska fel. Egentligen kan du med rätt funktioner hitta flera fel på egen hand via Golang.

Finnande av HTTP-statusfel

Med Golang kan du ta fram HTTP-statusfel om ett API som vi anropar levererar ett sådant.

Här är hur:

Först importerar vi ett nytt paket, ”net/http”:

import ( "fmt" "log" "net/http")

I vår huvudfunktion anropar vi en app (t.ex. en webbplats) och loggar eventuella fel. Vi vet att framgångsrika förfrågningar faller inom intervallet 2xx, så skapa en respektive status som hittar alla HTTP-fel som faller utanför detta intervall. Du kan göra detta på följande sätt:

func main() { resp, err := http.Get("https://example.com") if err != nil { log.Fatal(err) } fmt.Println("HTTP Response Status:", resp.StatusCode, http.StatusText(resp.StatusCode)) if resp.StatusCode >= 200 && resp.StatusCode 

Som du kan se är vår huvudfunktion inställd på

>= 200 && resp.StatusCode <= 299

som kommer att kontrollera om några HTTP-begäranden faller inom intervallet 2xx. Om begäran inte uppfyller detta villkor kommer den att visa ett felmeddelande.

Med bara en modul kan du snabbt samla all information du behöver för att hitta och åtgärda din Golang-kod.

Sammanfattning

Denna guide skrapar bara på ytan när det gäller hur Go-språket är utformat för att hantera fel. Grundläggande saker som hur man kontrollerar att en sträng existerar, hur man utlöser ett feltillstånd om ett ologiskt numeriskt uttalande presenteras och hur man kontrollerar HTTP-statuskoderna för ett svar är dock bra platser att börja på din Golang-felövervakningsresa.

Har du inte tid att kontrollera och använda de här Golang-felhanteringsmetoderna manuellt? Det är där verktyg som Airbrake Error Monitoring kommer väl till pass. Med Airbrake Error Monitoring kan du snabbt hitta fel utan att behöva skapa enskilda moduler. Prova Airbrake Error Monitoring gratis i 30 dagar för obegränsat antal fel och prestandahändelser.