¿Qué hacen defer, panic y recover?

Question

Accepted Answer

Estas tres palabras clave manejan la ejecución diferida y situaciones excepcionales. **`defer`** programa una limpieza, **`panic`** desencadena un colapso en tiempo de ejecución (para casos verdaderamente excepcionales), y **`recover`** puede capturar un panic para evitar que el programa se bloquee.

## Por qué es importante

```go
func readFile() error {
    f, err := os.Open("file.txt")
    if err != nil { return err }
    defer f.Close()        // GUARANTEED to run when readFile returns (any path)

// ... use f, with multiple return points ...
    return nil             // f.Close() runs here automatically
}
```

`defer` programa una llamada a función para que se ejecute cuando la función que la rodea retorna — sin importar cómo retorna (retorno normal, error o panic). Es la forma idiomática de garantizar limpieza: cerrar archivos, desbloquear mutexes, cerrar conexiones — colocado justo al lado de la adquisición para que no puedas olvidarlo.

## Los múltiples defers se ejecutan en orden LIFO

```go
defer fmt.Println("1")
defer fmt.Println("2")
defer fmt.Println("3")
// prints: 3, 2, 1 — last deferred, first executed (stack order)
```

## panic — para situaciones verdaderamente excepcionales e irrecuperables

```go
func mustPositive(n int) {
    if n < 0 {
        panic("negative not allowed")   // stops normal execution, unwinds the stack
    }
}
// panic runs deferred functions as it unwinds, then crashes the program (with a stack trace)
```

`panic` detiene el flujo normal y desenvuelve la pila de llamadas (ejecutando funciones diferidas en el camino), finalmente causando el colapso del programa. Es para **errores de programador / condiciones irrecuperables** (fuera de límites, desreferencia nula, estados imposibles) — NO para errores ordinarios (aquellos usan valores `error` retornados).

## recover — capturar un panic (solo dentro de una función diferida)

```go
func safeProcess() {
    defer func() {
        if r := recover(); r != nil {        // recover() returns the panic value
            fmt.Println("recovered from:", r)  // handle it; program continues
        }
    }()
    panic("something broke")    // this panic is caught by the recover above
}
// safeProcess returns normally instead of crashing
```

`recover` recupera el control de una goroutine en pánico — pero **solo funciona dentro de una función diferida**. Se usa raramente, p. ej. para evitar que un único manejador de solicitud bloquee un servidor completo.

## El principio clave: no uses panic/recover para errores normales

```text
Normal/expected failures (file missing, bad input, validation) → return an error value
panic/recover → reserve for TRULY exceptional cases (bugs, unrecoverable states)
  and boundaries (e.g. a server recovering so one bad request doesn't kill the process)
```

`defer` es una característica esencial e idiomática de Go para **garantizar limpieza** — colocando la liberación de recursos justo al lado de la adquisición y asegurando que se ejecute en cada ruta de retorno (incluyendo panics), lo que previene fugas de archivos, locks y conexiones de manera mucho más confiable que la limpieza manual.

Comprender su ordenamiento LIFO también es importante. `panic`/`recover` proporcionan un mecanismo similar a excepciones, pero el **principio crítico** es que Go los reserva para situaciones genuinamente excepcionales e irrecuperables — los errores normales siempre deben ser retornados como valores y verificados.

Malinterpretar panic/recover como manejo general de excepciones no es idiomático y es un error común para desarrolladores que vienen de lenguajes basados en excepciones.

Saber cuándo usar `defer` (siempre, para limpieza), retorno de `error` (fallos normales), y `panic`/`recover` (raro, excepcional, o en límites) es fundamental para escribir Go correcto e idiomático y es un tema frecuente en entrevistas.