Go Academy · Lezione

L'interfaccia error

Restituire e controllare gli errori in modo idiomatico

L'interfaccia error è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

La filosofia degli errori in Go

Go gestisce gli errori come valori, non come eccezioni. Le funzioni restituiscono un error come ultimo valore restituito. Il chiamante deve verificarlo esplicitamente:

package main
import ("fmt"; "strconv")

func main() {
    n, err := strconv.Atoi("abc")
    if err != nil {
        fmt.Println("error:", err)  // handle it
        return
    }
    fmt.Println(n)
}

L'interfaccia error

Il tipo predefinito error è una semplice interfaccia:

// Built into Go — no import needed
type error interface {
    Error() string
}

// Any type with Error() string satisfies it
// nil means no error

Restituire gli errori

Le funzioni che possono fallire restituiscono (value, error). Restituisca nil quando non si è verificato alcun errore:

package main
import ("fmt"; "errors")

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Println(result)
}

Il pattern if err != nil

Il controllo if err != nil è l'idioma Go più comune. Gestisca sempre gli errori: non li ignori:

package main
import ("fmt"; "os")

func main() {
    f, err := os.Open("config.json")
    if err != nil {
        fmt.Println("open error:", err)
        return
    }
    defer f.Close()
    // use f...
    _ = f
}

errors.New — Valori di errore semplici

errors.New crea un errore semplice con un messaggio fisso:

package main
import ("fmt"; "errors")

var ErrNotFound = errors.New("not found")

func findByID(id int) (string, error) {
    data := map[int]string{1: "Alice"}
    v, ok := data[id]
    if !ok {
        return "", ErrNotFound
    }
    return v, nil
}

func main() {
    _, err := findByID(99)
    fmt.Println(err) // not found
}

fmt.Errorf — Messaggi di errore formattati

fmt.Errorf crea errori con informazioni di contesto ottenute da stringhe formattate:

package main
import "fmt"

func openConfig(path string) error {
    // Add context to the error message
    return fmt.Errorf("openConfig %s: file not found", path)
}

func main() {
    err := openConfig("/etc/app/config.yaml")
    fmt.Println(err)
    // openConfig /etc/app/config.yaml: file not found
}

Errori sentinella

Gli errori sentinella sono valori di errore a livello di pacchetto utilizzati per i confronti di identità:

package main
import ("fmt"; "errors")

var (
    ErrTimeout    = errors.New("timeout")
    ErrPermission = errors.New("permission denied")
)

func doRequest() error { return ErrTimeout }

func main() {
    err := doRequest()
    if errors.Is(err, ErrTimeout) {
        fmt.Println("request timed out — retrying")
    }
}

Ignorare gli errori è un bug

Go richiede di utilizzare ogni variabile dichiarata, ma ignorare gli errori con _ viene compilato senza problemi ed è un errore comune da evitare:

package main
import "os"

func bad() {
    os.Remove("temp.txt") // silently ignores error — bad practice
}

func good() error {
    if err := os.Remove("temp.txt"); err != nil {
        return err  // propagate
    }
    return nil
}

Contesto degli errori: aggiungere informazioni

Quando propaga gli errori lungo lo stack delle chiamate, aggiunga il contesto che descrive quale operazione ha avuto esito negativo:

package main
import "fmt"

func readConfig(path string) ([]byte, error) {
    return nil, fmt.Errorf("readConfig: %w", fmt.Errorf("file %s not found", path))
}

func setup() error {
    _, err := readConfig("/etc/app.cfg")
    if err != nil {
        return fmt.Errorf("setup: %w", err) // wrap with context
    }
    return nil
}

func main() {
    err := setup()
    fmt.Println(err) // setup: readConfig: file /etc/app.cfg not found
}

Restituzioni multiple di errori

Le funzioni possono restituire errori da più punti di errore. Verifichi ciascuno di essi:

package main
import ("fmt"; "strconv")

func parseRange(minStr, maxStr string) (int, int, error) {
    min, err := strconv.Atoi(minStr)
    if err != nil { return 0, 0, fmt.Errorf("min: %w", err) }
    max, err := strconv.Atoi(maxStr)
    if err != nil { return 0, 0, fmt.Errorf("max: %w", err) }
    if min > max { return 0, 0, fmt.Errorf("min %d > max %d", min, max) }
    return min, max, nil
}

func main() {
    lo, hi, err := parseRange("1", "10")
    if err != nil { fmt.Println(err); return }
    fmt.Println(lo, hi)
}

Verifica rapida

Che cosa indica un valore di errore nil restituito in Go?

Riepilogo: l'interfaccia error

Concetti chiave della gestione degli errori:

Error è un'interfaccia predefinita: Error() string
Restituisca (value, error): nil indica il successo
errors.New per errori semplici, fmt.Errorf per errori formattati
Verifichi sempre if err != nil
Aggiunga il contesto quando propaga gli errori lungo lo stack
Non ignori mai gli errori in modo silenzioso

Domande Frequenti

La lezione «L'interfaccia error» è gratuita?

Sì — il testo completo di «L'interfaccia error» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «L'interfaccia error»?

Restituire e controllare gli errori in modo idiomatico Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «L'interfaccia error»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy