A Golang hibakezelésének alapjai

A Go programozási nyelv egyik leghasznosabb tulajdonsága a hibakezelés. Ahelyett, hogy Try/Catch módszertant használna, mint más programozási nyelvek, a Go a hibákat normál visszatérési értékként kezeli.

Egyszerű modulok létrehozásával és néhány naplózási szabály alkalmazásával hasznos hibaüzeneteket állíthatunk elő, amelyekkel mindenféle kivételt elkaphatunk a fejlesztési folyamat során.

Ebben a cikkben a Golang néhány legalapvetőbb módját mutatjuk be a kivételek megtalálásának és kezelésének.

Golang alapvető hibakezelés

A hibákat a Go-ban egyszerű if/then utasításokkal tudjuk rögzíteni, amelyek olyan feltételeket ellenőriznek, ahol a szükséges paraméterek nem teljesülnek.

Nézzünk meg egy alapvető modult, amelyet létrehozhatunk annak ellenőrzésére, hogy egy karakterlánc tartalmaz-e értéket vagy sem.

Hozzunk létre egy “hello” nevű csomagot, és importáljuk a standard “errors” és “fmt” modulokat a hibák és a formázott szövegek felismeréséhez:

package helloimport ("errors""fmt")

Ezután létrehozhatunk egy olyan modult, amely egy megnevezett változóhoz egy szöveges karakterláncot ad vissza.

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

A fenti modul ellenőrzi, hogy a “name” változóhoz üres karakterláncot kapunk-e vissza, majd egy új hibát ad vissza valamilyen megadott szöveggel. Ez a mi hibaállapotunk. A hibafeltétel azt ellenőrzi, hogy létezik-e maga a hiba.
Ha a feltétel nem teljesül (azaz nincs hiba), akkor a megadott “name” változónak megfelelő értéket adjuk vissza:

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

Megjegyezzük, hogy az üzenetet és a “nil” értéket adja vissza, ami azt jelenti, hogy nincs hiba. Ez azt üzeni a hívó programnak, hogy a függvény hiba nélkül dolgozta fel.

Most megnézzük, hogyan hívhatjuk meg ezt a csomagot egy tényleges szkriptben.

Létrehozunk egy új szkriptet, melynek neve test.go

A Golangban szokásos módon egy szkriptnek a csomag “main” definiálásával kell kezdődnie. Ezután importáljuk az “fmt” és “log” csomagokat, valamint az általunk létrehozott “hello” csomagot, ahogy az alábbiakban látható:

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

A továbbiakban definiáljuk a main függvényünket, beállítunk néhány tulajdonságot a loggerünknek, hogy könnyen érthető előtagot hozzunk létre, és (biztonsági okokból) létrehozunk egy flaget, hogy ne jelenjen meg az idő, a forrásfájl és a sorszám.

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

A következőkben megadjuk a megjelenítendő üzenetet:

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

Végül megnézzük, hogy van-e hiba, ellenőrizve, hogy az “err” nem egyenlő-e “nil”-el. Ha ez a helyzet, akkor kiírjuk az üzenetet a konzolra és kilépünk.

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

Ha nincs hibaállapot, akkor egyszerűen kiírjuk a hello csomagunkban definiált üzenetet.

fmt.Println(message)}

A teszteléshez futtathatjuk a kódot úgy, ahogy van. Ha ezt megtesszük, egy ilyen eredményt kell kapnunk:

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

Ha módosítani szeretnénk a test.go szkriptünket, írjunk be valami ilyesmit:

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

A kimenetünknek ekkor így kell kinéznie:

>go run test.goHi, John. Welcome!

Egy másik típusú hibaüzenet, amit visszaadhatunk, a következő:

fmt.Errorf – ez a Printf szabályai szerint formáz egy karakterláncot.

Egész számok kezelése a Golangban

A string hibák természetesen csak az egyik hibatípus. A Golang hibakezelésével számos más hibát is ellenőrizhetsz a kódodban. Az egyik, amiről különösen érdemes tudnod, a numerikus hibák.

A Go esetében az egész számok kezelése egyszerű. A következőképpen működik:

Tegyük fel, hogy numerikus hibáink vannak, például ha nullával osztanánk. Először is létrehozunk egy “Division” függvényt, amely két változót, x-et oszt el y-nal. Az if/then feltételünk első részében meg kell győződnünk arról, hogy y nem egyenlő nullával:

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

Ez a fő függvény. Most már átadhatunk neki két változót. Ebben a példában 12-t és 0-t fogunk használni.

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

Ezután egy üzenetet fogsz kapni, ami valami ilyesmit mond:

“Hibát kaptunk: Thou shalt not divide by zero!”

Ez csak egy példa arra, hogyan használhatod a Golang hibakezelést a numerikus hibák megtalálására. Valójában a megfelelő függvényekkel számos hibát megtalálhatunk magunk is a Golangon keresztül.

A HTTP státusz hibák megtalálása

A Golanggal előhívhatjuk a HTTP státusz hibákat, ha egy általunk hívott API hibát szolgáltat.

Íme, hogyan:

Először is importáljunk egy új csomagot, a “net/http”-t:

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

Főfüggvényünkben hívjunk meg egy alkalmazást (pl. egy weboldalt), és naplózzuk az esetleges hibákat. Tudjuk, hogy a sikeres kérések a 2xx tartományba esnek, ezért hozzunk létre egy megfelelő állapotot, amely megtalálja az ezen a tartományon kívül eső HTTP hibákat. Ezt a következő módon teheti meg:

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 

Amint láthatjuk, a fő függvényünk a

>= 200 && resp.StatusCode <= 299

azt fogja ellenőrizni, hogy a HTTP-kérések a 2xx tartományba esnek-e. Ha a kérés nem felel meg ennek a feltételnek, hibaüzenetet jelenít meg.

Egyetlen modullal gyorsan összegyűjthet minden információt, amire szüksége van a Golang-kód megtalálásához és javításához.

Összefoglaló

Ez az útmutató csak a felszínt karcolja, hogy a Go nyelv hogyan kezeli a hibákat. Azonban az olyan alapvető dolgok, mint például, hogy hogyan ellenőrizze egy karakterlánc létezését, hogyan állítson be hibaállapotot, ha egy logikátlan numerikus utasítás jelenik meg, és hogyan ellenőrizze a válasz HTTP státuszkódjait, mind remek kiindulópontok a Golang hibafigyelési útjára.

Nincs ideje kézzel ellenőrizni és használni ezeket a Golang hibakezelési technikákat? Itt jönnek jól az olyan eszközök, mint az Airbrake Error Monitoring. Az Airbrake Error Monitoring segítségével gyorsan megtalálhatja a hibákat anélkül, hogy egyedi modulokat kellene létrehoznia. Próbálja ki az Airbrake Error Monitoringot 30 napig ingyenesen, korlátlan számú hiba és teljesítményesemény esetén.