Funções Variádicas e Tipos de Função

Go trata funções como valores que você pode nomear, passar e retornar - e permite que o último parâmetro absorva uma lista de argumentos variável com ...T.

Juntos, assinaturas variádicas e tipos de função potencializam middleware, opções e pequenos pontos de extensão sem a verbosidade de interfaces.

Resumo

Um parâmetro variádico (args ...int) é açúcar sintático para um slice dentro da função.

Chamadores passam zero ou mais argumentos, ou expandem um slice existente com fn(slice...).

Um tipo de função (type Handler func(...)) documenta contratos chamáveis e habilita funções de ordem superior que aceitam comportamento como dados.

Use variádicas para construtores como fmt.Sprintf, auxiliares de log e opções funcionais.

Use tipos de função para middleware HTTP, wrappers de retentativa e predicados.

Prefira interfaces pequenas quando precisar de múltiplos métodos relacionados ou mocking entre pacotes.

Receita

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

type Option func(*Server)
 
func WithPort(p int) Option {
    return func(s *Server) { s.port = p }
}
 
func New(opts ...Option) *Server {
    s := &Server{port: 8080}
    for _, opt := range opts {
        opt(&s)
    }
    return s
}
 
type Middleware func(http.Handler) http.Handler
 
func Logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

Quando usar isso:

• Botões de configuração opcionais se acumulam (WithTimeout, WithLogger, ...).
• Um único ponto de hook precisa de injeção de comportamento (Retry, Authorize).
• Você envolve handlers ou interceptadores RPC em uma cadeia.
• Utilitários agregam contagens de argumentos desconhecidas (sum, concat).

Exemplo de Trabalho

package retry
 
import (
    "context"
    "errors"
    "time"
)
 
type AttemptFunc func(ctx context.Context) error
 
func Do(ctx context.Context, attempts int, backoff time.Duration, fn AttemptFunc) error {
    var err error
    for i := 0; i < attempts; i++ {
        if err = fn(ctx); err == nil {
            return nil
        }
        if ctx.Err() != nil {
            return ctx.Err()
        }
        time.Sleep(backoff)
        backoff *= 2
    }
    return err
}
 
func ExampleUsage(ctx context.Context, call func(context.Context) error) error {
    return Do(ctx, 3, 100*time.Millisecond, func(ctx context.Context) error {
        if err := call(ctx); err != nil {
            return err
        }
        return nil
    })
}
 
var ErrPermanent = errors.New("retry: permanent failure")

O que isso demonstra:

• AttemptFunc nomeia o contrato chamável em vez de repetir func(context.Context) error.
• Do de ordem superior aceita comportamento e gerencia a política de loop/backoff.
• Cancelamento de contexto verificado entre tentativas - valores de função ainda respeitam limites.
• Closure em ExampleUsage adapta um call mais simples para AttemptFunc.

Mergulho Profundo

Como Funciona

• Parâmetros variádicos compilam para parâmetros de slice; ... no local da chamada "espalha" um slice em argumentos discretos.
• Valores de função são ponteiros para código mais o ambiente capturado para closures.
• Tipos de função nomeados são distintos de sua assinatura subjacente para conjuntos de métodos - você não pode atribuir func(int) int a type Op func(int) int sem conversão, mas a conversão é permitida quando as assinaturas coincidem.
• Valores de função nil devem ser verificados antes da chamada - invocar nil causa pânico como uma chamada de método de interface nil.

Regras Variádicas de Relance

Tipos de Função vs Interfaces

Notas de Go

var fn func()
if fn != nil {
    fn()
}

Sempre proteja callbacks opcionais.

Cadeias de middleware devem tratar nil como identidade: if mw == nil { return next }.

Armadilhas

• Chamar valor de função nil - Causa pânico em tempo de execução. Correção: verifique if fn != nil antes de invocar, ou exija não-nil na documentação da API.
• Variádico com slice vazio vs nil - Dentro da função, args == nil é falso para chamada de zero argumentos (slice vazio não-nil). Correção: use len(args) == 0 quando distinguir ausente vs vazio for importante.
• Espalhar tipo de slice errado - []byte não pode ser "espalhado" para ...int. Correção: converta ou altere a assinatura.
• Capturar estado mutável em opções - Opções são executadas em ordem; opções posteriores podem observar mutações anteriores inesperadamente. Correção: documente a dependência de ordem ou valide em New.
• Surpresas na conversão de tipo de função - Tipos nomeados diferem de tipos de função subjacentes idênticos. Correção: conversão explícita Op(fn) quando necessário.
• Estabilidade da API pública com variádicos - Adicionar parâmetros não-variádicos quebra chamadores; adicionar novo comportamento opcional via opções funcionais não quebra. Correção: prefira opções para construtores em evolução.
• Passar funções variádicas para reflect - Fácil de invocar incorretamente sem CallSlice. Correção: atenha-se a chamadas tipadas, a menos que esteja construindo ferramentas genéricas.

pbqrthvqrf.vb|ptvb492|202607

Alternativas

FAQs

Relacionados

• Literais de Função e Closures - capturando variáveis em valores de função
• Noções Básicas de Funções e Métodos - primeiros exemplos de variádicos e tipos de função
• Definindo e Implementando Interfaces - quando interfaces superam tipos de função
• Métodos: Receptores de Valor vs Ponteiro - métodos em tipos de função (HandlerFunc)
• Boas Práticas de Funções, Métodos e Interfaces - convenções de middleware e opções

Versões de Stack: 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 (última - verifique na compilação), gin (última - verifique na compilação), echo (última - verifique na compilação), google.golang.org/grpc (última - verifique na compilação), sigs.k8s.io/controller-runtime (última - verifique na compilação), kubebuilder (última - verifique na compilação), tinygo (última - verifique os alvos de placa na compilação), wazero (última - verifique na compilação) e golangci-lint (última - verifique o conjunto de linters na compilação).