Golang Fout afhandeling basis

Eén van de handigere eigenschappen van de Go programmeertaal is de manier waarop het fouten afhandelt. In plaats van een Try/Catch methodologie te gebruiken zoals andere programmeertalen, behandelt Go fouten als normale retourwaarden.

Door eenvoudige modules te maken en een paar logging regels toe te passen, kunnen we nuttige foutmeldingen produceren om allerlei uitzonderingen op te vangen tijdens het ontwikkelproces.

In dit artikel zullen we een aantal van de meest basale manieren behandelen waarop Golang deze uitzonderingen vindt en afhandelt.

Golang Basic Error Handling

We kunnen fouten in Go afvangen door eenvoudige if/then statements te gebruiken die controleren op condities waar niet aan vereiste parameters wordt voldaan.

Laten we eens kijken naar een basis module die we kunnen maken om te controleren of een string een waarde bevat of niet.

Maak een package met de naam “hello” en importeer de standaardmodules “errors” en “fmt” om fouten en opgemaakte tekst te herkennen:

package helloimport ("errors""fmt")

Dan kunnen we een module maken die een tekenreeks met tekst voor een genoemde variabele retourneert.

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

Het bovenstaande controleert of er een lege tekenreeks wordt geretourneerd voor de variabele “name”, die vervolgens een nieuwe fout met wat opgegeven tekst retourneert. Dit is onze foutconditie. Een foutconditie controleert of de fout zelf bestaat.
Als niet aan de conditie wordt voldaan (d.w.z. er is geen fout), geven we de waarde terug die overeenkomt met de opgegeven “name” variabele:

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

Merk op dat het bericht wordt teruggegeven en de waarde “nihil,” wat betekent dat er geen fout is. Dit vertelt het aanroepende programma dat de functie zonder fouten is verwerkt.

Nu gaan we kijken hoe we dit pakket in een echt script kunnen aanroepen.

Laten we een nieuw script maken, genaamd test.go

Zoals normaal is met Golang, moet een script beginnen met het definiëren van het pakket als “main.” We importeren dan de “fmt” en “log” pakketten, samen met ons aangemaakte “hello” pakket, zoals hieronder te zien is:

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

Hieronder definiëren we onze main functie, stellen een paar eigenschappen in voor onze logger om een makkelijk te begrijpen prefix te maken, en (om veiligheidsredenen) maken we een vlag aan zodat we de tijd, het bronbestand en het regelnummer niet laten zien.

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

Volgende, we specificeren een bericht dat moet worden weergegeven:

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

Ten slotte kijken we of er een fout is door te controleren of “err” niet gelijk is aan “nihil.” Als dit het geval is, printen we de boodschap naar de console en sluiten we af.

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

Als er geen foutconditie bestaat, printen we gewoon de boodschap die in ons hello pakket was gedefinieerd.

fmt.Println(message)}

Om dit uit te testen, kunnen we de code uitvoeren zoals hij is. Als we dat doen, zouden we een resultaat moeten krijgen dat er als volgt uitziet:

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

Als we ons test.go script willen aanpassen, voeren we iets als dit in:

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

Onze uitvoer zou er dan zo uit moeten zien:

>go run test.goHi, John. Welcome!

Een ander type foutmelding dat we kunnen retourneren is:

fmt.Errorf – hiermee wordt een string opgemaakt volgens de regels van Printf.

Handling Integers in Golang

Natuurlijk zijn string fouten maar één type fout. Met Golang foutafhandeling, zijn er verschillende andere fouten die je kunt controleren in je code. Een in het bijzonder die je zou moeten kennen is numerieke fouten.

Handelen van gehele getallen is eenvoudig voor Go. Hier is hoe het werkt:

Stel dat we numerieke fouten hebben, bijvoorbeeld als we door nul moeten delen. Eerst maken we een “Division” functie, die twee variabelen x deelt door y. Voor het eerste deel van onze if/then voorwaarde, moeten we ervoor zorgen dat y niet gelijk is aan nul:

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}}

Dit is de hoofdfunctie. Je kunt er twee variabelen aan doorgeven. In dit voorbeeld gebruiken we 12 en 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)}}

U krijgt dan een bericht dat zoiets zegt als:

“Er is een fout opgetreden: Gij zult niet delen door nul!”

Dit is slechts één voorbeeld van hoe je Golang foutafhandeling kunt gebruiken om numerieke fouten te vinden. Echt, met de juiste functies, kun je verschillende fouten zelf vinden via Golang.

Vinden van HTTP Status Fouten

Met Golang, kun je HTTP status fouten opvragen als een API die we aanroepen er een geeft.

Hier volgt hoe:

Eerst, laten we een nieuw pakket importeren, “net/http”:

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

In onze hoofdfunctie, roepen we een app aan (b.v. een website) en loggen eventuele fouten. We weten dat succesvolle verzoeken binnen het 2xx bereik vallen, dus maak een respectievelijke status die alle HTTP fouten vindt die buiten dit bereik vallen. U kunt dit op de volgende manier doen:

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 

Zoals u kunt zien, is onze hoofdfunctie ingesteld op

>= 200 && resp.StatusCode <= 299

die controleert of HTTP-verzoeken binnen het 2xx-bereik vallen. Als het verzoek niet aan deze voorwaarde voldoet, wordt er een foutmelding getoond.

Met slechts een module, kun je snel alle informatie verzamelen die je nodig hebt om je Golang code te vinden en te repareren.

Samenvatting

Deze gids is slechts een tipje van de sluier over hoe de Go taal is ontworpen om met fouten om te gaan. Echter, basics zoals hoe te controleren op het bestaan van een string, hoe een fout conditie op te roepen als een onlogisch numeriek statement wordt gepresenteerd, en hoe de HTTP status codes van een antwoord te controleren zijn allemaal goede plaatsen om te beginnen op je Golang error monitoring reis.

Heb je geen tijd om deze Golang foutafhandeling technieken handmatig te controleren en te gebruiken? Dat is waar tools zoals Airbrake Error Monitoring van pas komen. Met Airbrake Error Monitoring, zul je in staat zijn om snel fouten te vinden zonder de noodzaak om individuele modules te maken. Probeer Airbrake Error Monitoring 30 dagen gratis uit voor een onbeperkt aantal fouten en performance events.