Nozioni di base sulla gestione degli errori in Golang

Una delle caratteristiche più utili del linguaggio di programmazione Go è il modo in cui gestisce gli errori. Invece di usare una metodologia Try/Catch come altri linguaggi di programmazione, Go tratta gli errori come normali valori di ritorno.

Con la creazione di semplici moduli e l’applicazione di alcune regole di log, possiamo produrre utili messaggi di errore per catturare tutti i tipi di eccezioni durante il processo di sviluppo.

In questo articolo, copriremo alcuni dei modi più basilari in cui Golang trova e gestisce queste eccezioni.

Golang Basic Error Handling

Possiamo catturare gli errori in Go usando semplici istruzioni if/then che controllano le condizioni in cui i parametri richiesti non sono soddisfatti.

Guardiamo un modulo base che possiamo creare per controllare se una stringa include un valore o meno.

Creiamo un package chiamato “hello” e importiamo i moduli standard “errors” e “fmt” per riconoscere gli errori e il testo formattato:

package helloimport ("errors""fmt")

Poi possiamo creare un modulo che restituisca una stringa di testo per una variabile nominata.

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

Questo controlla se viene restituita una stringa vuota per la variabile “name”, che poi restituisce un nuovo errore con del testo specificato. Questa è la nostra condizione di errore. Una condizione di errore controlla se l’errore stesso esiste.
Se la condizione non è soddisfatta (cioè, non c’è errore), restituiamo il valore che corrisponde alla variabile “name” specificata:

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

Nota che restituisce il messaggio e il valore di “nil”, che significa che non c’è errore. Questo dice al programma chiamante che la funzione è stata processata senza errori.

Ora vedremo come possiamo chiamare questo pacchetto in uno script vero e proprio.

Creiamo un nuovo script, chiamato test.go

Come è normale in Golang, uno script deve iniziare con la definizione del pacchetto “main”. Importiamo quindi i pacchetti “fmt” e “log”, insieme al nostro pacchetto “hello” creato, come mostrato di seguito:

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

Di seguito definiamo la nostra funzione principale, impostiamo alcune proprietà per il nostro logger per creare un prefisso facile da capire, e (per motivi di sicurezza) creiamo un flag per non mostrare l’ora, il file sorgente e il numero di linea.

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

In seguito, specificheremo un messaggio da visualizzare:

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

Infine, cerchiamo di vedere se c’è un errore controllando se “err” non è uguale a “nil”. Se questo è il caso, stampiamo il messaggio nella console ed usciamo.

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

Se non esiste una condizione di errore, stampiamo semplicemente il messaggio che è stato definito nel nostro pacchetto hello.

fmt.Println(message)}

Per verificare questo, possiamo eseguire il codice così com’è. Una volta fatto, dovremmo ottenere un risultato che assomiglia a questo:

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

Se vogliamo modificare il nostro script test.go, inserire qualcosa come questo:

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

Il nostro output dovrebbe quindi assomigliare a questo:

>go run test.goHi, John. Welcome!

Un altro tipo di messaggio di errore che possiamo restituire è:

fmt.Errorf – questo formatta una stringa secondo le regole di Printf.

Gestione degli interi in Golang

Ovviamente, gli errori di stringa sono solo un tipo di errore. Con la gestione degli errori in Golang, ci sono molti altri errori che potete controllare nel vostro codice. Uno in particolare che dovreste conoscere sono gli errori numerici.

Gestire gli interi è semplice per Go. Ecco come funziona:

Supponiamo di avere errori numerici, come se dovessimo dividere per zero. Prima creiamo una funzione “Division”, che divide due variabili x per y. Per la prima parte della nostra condizione if/then, dobbiamo assicurarci che y non sia uguale a zero:

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

Questa è la funzione principale. Ora, potete passargli due variabili. In questo esempio, useremo 12 e 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)}}

Allora riceverete un messaggio che dice qualcosa come:

“Abbiamo un errore: Non dividere per zero!”

Questo è solo un esempio di come potete usare la gestione degli errori di Golang per trovare errori numerici. In realtà, con le giuste funzioni, è possibile trovare diversi errori da soli tramite Golang.

Trovare errori di stato HTTP

Con Golang, è possibile far apparire errori di stato HTTP se un’API che stiamo chiamando ne fornisce uno.

Ecco come:

Primo, importiamo un nuovo pacchetto, “net/http”:

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

Nella nostra funzione principale, chiamiamo un’applicazione (ad esempio un sito web) e registriamo eventuali errori. Sappiamo che le richieste di successo rientrano nell’intervallo 2xx, quindi creiamo un rispettivo stato che trova qualsiasi errore HTTP che non rientra in questo intervallo. Potete farlo nel modo seguente:

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 

Come potete vedere, la nostra funzione principale è impostata su

>= 200 && resp.StatusCode <= 299

che controllerà se le richieste HTTP rientrano nell’intervallo 2xx. Se la richiesta non soddisfa questa condizione, mostrerà un messaggio di errore.

Con un solo modulo, potete raccogliere rapidamente tutte le informazioni necessarie per trovare e correggere il vostro codice Golang.

Sommario

Questa guida graffia solo la superficie di come il linguaggio Go è progettato per gestire gli errori. Tuttavia, nozioni di base come controllare l’esistenza di una stringa, come sollevare una condizione di errore se viene presentata una dichiarazione numerica illogica, e come controllare i codici di stato HTTP di una risposta sono tutti ottimi punti di partenza per il vostro viaggio di monitoraggio degli errori in Golang.

Non avete tempo per controllare e utilizzare queste tecniche di gestione degli errori in Golang manualmente? È qui che strumenti come Airbrake Error Monitoring tornano utili. Con Airbrake Error Monitoring, sarete in grado di trovare rapidamente gli errori senza la necessità di creare moduli individuali. Provate Airbrake Error Monitoring gratuitamente per 30 giorni per un numero illimitato di errori ed eventi di performance.