Go:
Gestione degli errori

Come fare:

In Go, la gestione degli errori è gestita esplicitamente utilizzando il tipo error. Le funzioni che possono fallire restituiscono un errore come ultimo valore di ritorno. Controllare se questo valore di errore è nil ti dirà se si è verificato un errore.

package main

import (
    "errors"
    "fmt"
)

func Compute(value int) (int, error) {
    if value > 100 {
        return 0, errors.New("il valore deve essere 100 o meno")
    }
    return value * 2, nil
}

func main() {
    result, err := Compute(150)
    if err != nil {
        fmt.Println("Errore:", err)
    } else {
        fmt.Println("Risultato:", result)
    }
    
    // Gestire un errore con grazia
    anotherResult, anotherErr := Compute(50)
    if anotherErr != nil {
        fmt.Println("Errore:", anotherErr)
    } else {
        fmt.Println("Risultato:", anotherResult)
    }
}

Output di esempio per il codice sopra:

Errore: il valore deve essere 100 o meno
Risultato: 100

In questo esempio, la funzione Compute restituisce o un valore calcolato o un errore. Il chiamante gestisce l’errore controllando se err non è nil.

Approfondimento

L’approccio di Go alla gestione degli errori è deliberatamente semplice e tipizzato in modo sicuro, richiedendo controlli espliciti degli errori. Questo concetto si contrappone alla gestione degli errori basata su eccezioni vista in linguaggi come Java e Python, dove gli errori vengono propagati lungo lo stack di chiamate a meno che non vengano catturati da un gestore di eccezioni. Il team di Go sostiene che la gestione esplicita degli errori porta a codice più chiaro e affidabile, poiché obbliga i programmatori ad affrontare gli errori immediatamente dove si verificano.

Tuttavia, alcune critiche menzionano che questo schema può portare a codice verboso, specialmente in funzioni complesse con molte operazioni soggette a errori. In risposta, le versioni più recenti di Go hanno introdotto funzionalità di gestione degli errori più sofisticate, come l’incapsulamento degli errori, rendendo più facile fornire contesto a un errore senza perdere le informazioni sull’errore originale. La comunità ha visto anche proposte per nuovi meccanismi di gestione degli errori, come check/handle, sebbene queste rimangano in discussione al momento del mio ultimo aggiornamento.

La filosofia di gestione degli errori di Go sottolinea la comprensione e la pianificazione degli errori come parte del flusso normale del programma. Questo approccio incoraggia lo sviluppo di software più resiliente e prevedibile, sebbene con un potenziale aumento del codice boilerplate. Esistono modelli e librerie alternativi per semplificare la gestione degli errori per casi particolarmente complessi, ma il tipo error integrato in Go rimane il fondamento della gestione degli errori nel linguaggio.