¿Cómo maneja Go los errores como valores?

Question

Accepted Answer

Go **no tiene excepciones** para errores ordinarios. En su lugar, los errores son **valores** devueltos por funciones (típicamente como el último valor de retorno), y los llamadores los **verifican explícitamente**. Esto hace que el manejo de errores sea visible, deliberado e imposible de ignorar silenciosamente — una filosofía definitoria de Go.

## El tipo de error y el patrón central

```go
// `error` is a built-in interface: anything with an Error() string method
type error interface {
    Error() string
}

// functions return (result, error) — error is nil on success
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")   // create an error
    }
    return a / b, nil    // nil = no error
}

// the ubiquitous calling pattern
result, err := divide(10, 0)
if err != nil {              // CHECK the error explicitly
    fmt.Println("error:", err)
    return
}
fmt.Println(result)
```

La verificación `if err != nil { ... }` aparece constantemente en Go — cada operación que puede fallar va seguida de una verificación de error explícita. Esta verbosidad es deliberada: los errores siempre son visibles y se manejan en el sitio de la llamada.

## Creación de errores

```go
errors.New("something failed")                       // simple error
fmt.Errorf("failed to process %s: %w", name, err)    // formatted, with WRAPPING (%w)
```

## Envolvimiento e inspección de errores

```go
// %w WRAPS an underlying error, preserving the chain
if err != nil {
    return fmt.Errorf("reading config: %w", err)   // adds context, keeps original
}

// unwrap and inspect with errors.Is / errors.As
if errors.Is(err, os.ErrNotExist) { ... }          // check for a specific error
var pathErr *os.PathError
if errors.As(err, &pathErr) { ... }                 // extract a specific error type
```

El envolvimiento (`%w`) agrega contexto a medida que los errores se propagan hacia arriba, mientras que `errors.Is`/`errors.As` te permiten verificar o extraer errores subyacentes específicos — la forma moderna de manejar cadenas de errores.

## Tipos de error personalizados

```go
type ValidationError struct {
    Field string
}
func (e *ValidationError) Error() string {           // implement the error interface
    return "invalid field: " + e.Field
}
return &ValidationError{Field: "email"}
```

## errors vs panic

```text
error (values) → EXPECTED, recoverable conditions (file missing, bad input) — the norm
panic          → UNEXPECTED, programmer errors / unrecoverable (nil deref, out of bounds)
→ Use errors for normal failure handling; reserve panic for truly exceptional cases.
```

## Por qué es importante

El enfoque de Go sobre errores como valores es una de sus características más definitoria y debatida, fundamentalmente diferente de los lenguajes basados en excepciones.

Al devolver errores como valores que los llamadores deben verificar explícitamente (`if err != nil`), Go hace que el manejo de errores sea **visible, local e imposible de ignorar accidentalmente** — ves exactamente dónde se maneja cada error, mejorando la confiabilidad a costa de la verbosidad.

Comprender esta filosofía, el patrón `(result, error)`, el envolvimiento de errores (`%w`) con `errors.Is`/`errors.As` para agregar contexto e inspeccionar cadenas, los tipos de error personalizados y la distinción entre errores (normales, recuperables) y panic (excepcionales, errores del programador) es absolutamente esencial — permea cada programa de Go y representa un cambio mental fundamental para los desarrolladores que vienen de lenguajes basados en excepciones.

También es uno de los temas de entrevista de Go más comunes.