Errores: el patrón `if err != nil`

En Go, los errores son valores, no excepciones. Una función que puede fail devuelve el error como último valor y la persona que llama lo verifica explícitamente. Es explícito, predecible, fácil de probar; el precio es un poco más de verbosidad.

La interfaz error

error es una pequeña interfaz integrada en el lenguaje:

type error interface {
    Error() string
}

Cualquier tipo que implemente Error() string es error.

El patrón fundamental

v, err := operazione()
if err != nil {
    // gestisci o propaga
    return err
}
// usa v

Verás esto miles de veces: es el código idiomático de cada llamada falible. No te sientas culpable por la repetición: es una característica, no un error.

Errores de construcción: errors.New y fmt.Errorf

import (
    "errors"
    "fmt"
)

err1 := errors.New("file mancante")
err2 := fmt.Errorf("apertura %q fallita: permesso negato", path)

fmt.Errorf es perfecto cuando quieres incluir variables en el mensaje.

Envolviendo con %w

Para propagar un error agregando contexto SIN perder el original:

f, err := os.Open(path)
if err != nil {
    return fmt.Errorf("config: %w", err)
}

%w "envuelve" el error original, recuperable más tarde con errors.Is (igualdad para centinelas) o errors.As (para tipo concreto):

if errors.Is(err, os.ErrNotExist) {
    // file inesistente, gestione speciale
}

Errores centinela

Estos son errores exportados como variables, utilizados para comparaciones con errors.Is:

var ErrNotFound = errors.New("non trovato")

func find(id int) (Item, error) {
    // ...
    return Item{}, ErrNotFound
}

// chiamante:
if errors.Is(err, ErrNotFound) { ... }

panic y recover (vista previa)

panic existe en Go pero está reservado para errores irrecuperables (por ejemplo, errores, invariantes violadas), no para el flujo de control normal. Profundizaremos en el módulo de Funciones con defer/recover. Por ahora: no lo use en su lugar del patrón if err != nil.

Pruébalo

v, err := f()
// poi?

Resumen

• error es una interfaz con un método Error() string.
• Patrón canónico: v, err := f(); if err != nil { return err }.
• Errores de compilación con errors.New(msg) o fmt.Errorf("ctx: %w", err).
• Utilice %w para enrollar y errors.Is / errors.As para inspeccionar la cadena.
• panic sólo para errores irrecuperables, NO para flujo de control normal.