Literais de Função e Closures

Um literal de função é uma expressão de função anônima que você pode definir e invocar inline.

Quando ele referencia variáveis de escopos circundantes, torna-se um closure que carrega esses vínculos para execuções posteriores - incluindo goroutines e chamadas adiadas.

Resumo

Literais de função permitem callbacks locais, middleware e fábricas sem declarar funções de nível superior nomeadas.

Closures capturam variáveis por referência, não por snapshot, a menos que você copie variáveis de loop ou passe parâmetros explicitamente.

O bug clássico de goroutine lança múltiplos closures compartilhando uma variável de loop.

Fábricas retornam closures configurados (limitadores de taxa, validadores) enquanto ocultam o estado mutável na função externa.

Use literais para comportamento curto e local; promova para funções nomeadas quando a lógica crescer ou precisar de testes isolados.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

func withTimeout(parent context.Context, d time.Duration) (context.Context, context.CancelFunc) {
    return context.WithTimeout(parent, d)
}
 
func middleware(log func(string)) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            log(r.Method + " " + r.URL.Path)
            next.ServeHTTP(w, r)
        })
    }
}
 
// Spawn seguro de goroutine em um loop.
for _, id := range ids {
    id := id
    go func() {
        process(id)
    }()
}

Quando usar isso:

• Middleware HTTP/gRPC envolvendo handlers.
• defer precisa de uma função local ajustando o comportamento de limpeza.
• Ordenação com comparadores slices.SortFunc / sort.Slice.
• Testes fornecem stubs inline implementando pequenas interfaces.

Exemplo de Trabalho

package ratelimit
 
import (
    "context"
    "sync"
    "time"
)
 
type Limiter func(ctx context.Context) error
 
func New(interval time.Duration) Limiter {
    var mu sync.Mutex
    var last time.Time
    return func(ctx context.Context) error {
        mu.Lock()
        defer mu.Unlock()
        now := time.Now()
        wait := interval - now.Sub(last)
        if wait > 0 {
            timer := time.NewTimer(wait)
            defer timer.Stop()
            select {
            case <-ctx.Done():
                return ctx.Err()
            case <-timer.C:
            }
        }
        last = time.Now()
        return nil
    }
}
 
func Example(ctx context.Context) error {
    wait := New(100 * time.Millisecond)
    for i := 0; i < 3; i++ {
        if err := wait(ctx); err != nil {
            return err
        }
    }
    return nil
}

O que isso demonstra:

• Fábrica New retorna um closure que oculta mu e last.
• Estado capturado serializa chamadores sem exportar uma struct.
• Contexto respeitado durante esperas dentro do closure.
• Mutex protege variáveis compartilhadas entre goroutines invocando o mesmo Limiter.

Mergulho Profundo

Como Funciona

• Literais de função compilam para valores de função alocados no heap quando escapam (armazenados, retornados, enviados para goroutines).
• Variáveis livres são capturadas por referência através de ponteiros ocultos na struct do closure.
• Funções nomeadas podem fechar sobre variáveis de nível de pacote; literais comumente fecham sobre locais na função envolvente.
• A instrução go agenda o closure - as semânticas de captura importam no momento do agendamento, não apenas no momento da definição.

Armadilhas e Correções de Captura

Fábrica vs Struct

Notas Go

sort.Slice(items, func(i, j int) bool {
    return items[i].Priority < items[j].Priority
})

Literais se destacam para comparadores e filtros de uso único.

Extraia quando reutilizado entre pacotes.

Armadilhas

• Captura de variável de loop em goroutines - Corrida de dados clássica no índice/item do loop. Correção: sombreie com v := v ou passe como parâmetro.
• Defer em loop sem wrapper de closure - Todos os defers são executados no final da função externa, não por iteração. Correção: func(){ defer cleanup(); work() }().
• Invocação de closure nil - Atribuir func() não inicializado causa pânico. Correção: proteja ou exija construtor.
• Captura de ponteiros para variáveis de loop - &v em um loop compartilha um endereço. Correção: copie o valor dentro do corpo do loop antes de obter o endereço.
• Closure retém objetos grandes - Impede a coleta de lixo de mapas/slices capturados por mais tempo do que o necessário. Correção: restrinja a captura a IDs ou interfaces.
• Testando lógica anônima - Difícil de direcionar sem exportar. Correção: nomeie a função ou injete a interface quando a complexidade aumentar.
• sync.WaitGroup + closure de goroutine - Esquecer Add antes de go causa corrida. Correção: chame Add antes do lançamento; use defer Done() dentro da goroutine.

Alternativas

FAQs

Relacionados

• Funções Variádicas e Tipos de Função - nomeando tipos de função e middleware
• Noções Básicas de Funções e Métodos - exemplo seguro de captura de loop
• Métodos: Receivers de Valor vs Ponteiro - padrão de método HandlerFunc
• Funções e Interfaces: O Modelo de Composição de Go - compondo comportamento com funções
• Boas Práticas de Funções, Métodos e Interfaces - orientação sobre goroutines e middleware

Versões da Pilha: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, go fix modernizers - verifique o patch na compilação), chi (mais recente - verifique na compilação), gin (mais recente - verifique na compilação), echo (mais recente - verifique na compilação), google.golang.org/grpc (mais recente - verifique na compilação), sigs.k8s.io/controller-runtime (mais recente - verifique na compilação), kubebuilder (mais recente - verifique na compilação), tinygo (mais recente - verifique os alvos de placa na compilação), wazero (mais recente - verifique na compilação) e golangci-lint (mais recente - verifique o conjunto de linters na compilação).