O que fazem defer, panic e recover?

Question

Accepted Answer

Essas três palavras-chave lidam com execução diferida e situações excecionais. **`defer`** agenda limpeza, **`panic`** dispara um crash em tempo de execução (para casos verdadeiramente excepcionais), e **`recover`** pode capturar um panic para impedir que o programa quebre.

## defer — agende uma chamada para quando a função retornar

```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` agenda uma chamada de função para executar quando a função envolvente retorna — não importa como ela retorna (retorno normal, erro ou panic). É a forma idiomática de garantir limpeza: fechar arquivos, desbloquear mutexes, fechar conexões — colocado logo ao lado da aquisição para que você não possa esquecer.

## Múltiplos defers executam em ordem 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 situações verdadeiramente excepcionais e irrecuperáveis

```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` interrompe o fluxo normal e desconstrói a pilha de chamadas (executando funções diferidas pelo caminho), ultimamente quebrando o programa. É para **erros de programador / condições irrecuperáveis** (fora dos limites, desreferência nula, estados impossíveis) — NÃO para erros ordinários (esses usam valores `error` retornados).

## recover — capture um panic (apenas dentro de uma função 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 o controle de uma goroutine em pânico — mas **funciona apenas dentro de uma função diferida**. É usado com moderação, por exemplo, para impedir que um único manipulador de requisição quebre um servidor inteiro.

## O princípio-chave: não use panic/recover para erros normais

```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)
```

## Por que isso importa

`defer` é uma característica essencial e idiomática do Go para **limpeza garantida** — colocando a liberação de recursos logo ao lado da aquisição e garantindo que ele execute em cada caminho de retorno (incluindo panics), o que previne vazamentos de arquivos, locks e conexões de forma muito mais confiável do que limpeza manual.

Compreender sua ordem LIFO também é importante. `panic`/`recover` fornecem um mecanismo semelhante a exceções, mas o **princípio crítico** é que Go os reserva para situações genuinamente excepcionais e irrecuperáveis — erros normais devem sempre ser retornados como valores e verificados.

Mal usar panic/recover como tratamento de exceções geral é não-idiomático e um erro comum para desenvolvedores vindos de linguagens baseadas em exceções.

Saber quando usar `defer` (sempre, para limpeza), retornos de `error` (falhas normais), e `panic`/`recover` (raro, excepcional ou em limites) é fundamental para escrever Go correto e idiomático, e é um tópico frequente em entrevistas.