Definindo e Implementando Interfaces

Interfaces em Go descrevem comportamento através de conjuntos de métodos satisfeitos implicitamente por tipos concretos.

Defina interfaces pequenas no consumidor, aceite-as em parâmetros de função e retorne structs concretas de construtores.

Resumo

Um valor de interface armazena um par tipo dinâmico e valor dinâmico.

A satisfação é verificada em tempo de compilação na atribuição; não existe palavra-chave implements.

Interfaces pequenas (frequentemente um ou dois métodos) mantêm mocks enxutos e incentivam a composição em vez de abstrações amplas.

Aceite interfaces, retorne structs é a regra principal da API: dependa do comportamento mínimo em parâmetros; exponha tipos concretos de funções New para que os chamadores não fiquem presos atrás de suas definições de interface.

Evite exportar interfaces grandes de pacotes produtores - elas se tornam contratos de compatibilidade problemáticos.

Receita

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

// Pacote consumidor define o que ele precisa.
type Storage interface {
    Get(ctx context.Context, key string) ([]byte, error)
    Put(ctx context.Context, key string, value []byte) error
}
 
// Produtor retorna tipo concreto.
type MemStore struct {
    mu sync.RWMutex
    m  map[string][]byte
}
 
func NewMemStore() *MemStore {
    return &MemStore{m: make(map[string][]byte)}
}
 
func (s *MemStore) Get(ctx context.Context, key string) ([]byte, error) { /* ... */ }
func (s *MemStore) Put(ctx context.Context, key string, value []byte) error { /* ... */ }
 
func LoadConfig(ctx context.Context, store Storage, key string) ([]byte, error) {
    return store.Get(ctx, key)
}

Quando usar isso:

• Trocar implementações em testes (memória vs. fake vs. integração).
• Bibliotecas não devem importar SDKs de nuvem concretos em pontos de chamada.
• Múltiplos tipos compartilham comportamento sobreposto (io.Reader, io.Writer).
• Você define pontos de extensão em frameworks (HTTP Handler, gRPC ServerStream).

Exemplo de Trabalho

package notify
 
import (
    "context"
    "fmt"
)
 
type Sender interface {
    Send(ctx context.Context, to, body string) error
}
 
type Service struct {
    sender Sender
}
 
func New(sender Sender) *Service {
    return &Service{sender: sender}
}
 
type LogSender struct{}
 
func (LogSender) Send(ctx context.Context, to, body string) error {
    fmt.Printf("to=%s body=%q\n", to, body)
    return nil
}
 
type SMTPClient struct {
    host string
}
 
func NewSMTP(host string) *SMTPClient {
    return &SMTPClient{host: host}
}
 
func (c *SMTPClient) Send(ctx context.Context, to, body string) error {
    // dial c.host, send message ...
    return nil
}
 
func (s *Service) Welcome(ctx context.Context, email string) error {
    return s.sender.Send(ctx, email, "welcome")
}

O que isso demonstra:

• Interface Sender vive com o consumidor Service, não com o pacote SMTP.
• Dois remetentes concretos satisfazem a mesma interface sem declaração explícita.
• New aceita Sender para injeção; retorna o tipo concreto *Service.
• Contexto é passado através dos métodos da interface para cancelamento/timeouts.

Mergulho Profundo

Como Funciona

• O tipo de interface com o conjunto de métodos M é satisfeito por qualquer tipo cujo conjunto de métodos inclua M.
• A interface vazia any contém todos os tipos; use apenas em limites de decodificação.
• Nil não de interface é nil não tipado; nil de interface requer que ambos os slots de tipo e valor estejam vazios.
• Embutir interfaces promove métodos - útil para composições do tipo io.ReadCloser.

Regras de Design de Interface

Padrões da Biblioteca Padrão

Notas de Go

// Divida interfaces quando os métodos não estiverem relacionados.
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }
type ReadWriter interface {
    Reader
    Writer
}

Prefira embutir em vez de interfaces únicas inchadas.

Armadilhas

• Mega-interfaces exportadas - Adicionar métodos quebra todos os implementadores. Correção: divida interfaces ou mantenha interfaces não exportadas satisfeitas por structs exportadas.
• Retornar interface do construtor - Oculta o tipo concreto, incentiva bugs de nil tipado. Correção: retorne *Concreto a menos que a abstração seja o produto.
• Satisfação por ponteiro vs. valor - Valor faltando métodos apenas de ponteiro falha na atribuição. Correção: retorne ponteiros de construtores quando necessário.
• Comparar interface com nil incorretamente - Ponteiro nil tipado dentro da interface não é == nil. Correção: retorne tipos concretos ou documente verificações com reflexão/padrões errors.Is.
• Nomes de métodos duplicados em interfaces embutidas - Promoções ambíguas falham na compilação. Correção: renomeie métodos ou embuta apenas uma interface.
• Poluição de interface em caminhos críticos - Pequenas alocações/custo de itable geralmente são aceitáveis; profile antes de remover interfaces. Correção: otimize apenas com evidências.
• Testando com testify/mock em interfaces amplas - Expectativas frágeis. Correção: estreite interfaces ou use fakes escritos à mão.

Alternativas

FAQs

Relacionados

• Funções e Interfaces: O Modelo de Composição do Go - por que interfaces implícitas existem
• Interface Nil vs Ponteiro Nil - nil tipado dentro de valores de interface
• Métodos: Receptores de Valor vs. Ponteiro - conjuntos de métodos e satisfação
• Funções Variádicas e Tipos de Função - quando um tipo func supera uma interface
• Melhores Práticas para Funções, Métodos e Interfaces - dimensionamento de interface e regras de exportação

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