Padrões e Idiomas Essenciais do Go: Melhores Práticas
Um resumo condensado das 25 práticas mais importantes de padrões e idiomas do Go, extraídas de todas as páginas desta seção.
//
Busque em todas as páginas da documentação
Um resumo condensado das 25 práticas mais importantes de padrões e idiomas do Go, extraídas de todas as páginas desta seção.
Composição em primeiro lugar: Modele o comportamento com structs, métodos, embedding e funções em vez de hierarquias de subclasses copiadas de Java ou C#.
Interfaces definidas pelo consumidor: Declare interfaces onde o comportamento é usado (pacote de serviço), não ao lado de cada implementação concreta.
Mantenha interfaces pequenas: Uma ou duas funções por limite (Store, Clock, Publisher) tornam os fakes triviais e as APIs estáveis.
Aceite interfaces, retorne structs: Parâmetros de construtores dependem de comportamento mínimo; New retorna *Concrete para que os chamadores não fiquem presos à sua forma de interface.
Estado não exportado: Tipos de biblioteca ocultam campos atrás de métodos e opções para que os invariantes não possam ser quebrados após a construção.
Nomenclatura idiomática de construtores: Use New para valores novos, Open/Dial para recursos e combine com Close/Shutdown quando a limpeza for necessária.
Documente a política de valor zero: Declare claramente se var T é utilizável (bytes.Buffer) ou requer New() (Store com mapas privados).
Opções funcionais para crescimento: Aplique o padrão de opções quando os construtores, de outra forma, se espalhariam por muitos parâmetros ortogonais.
Valide em New: Retorne erros de construtores e opções quando a configuração puder falhar; evite panics adiados no primeiro uso.
Padrões dentro de New: Defina padrões sensatos antes de aplicar opções, para que os chamadores substituam apenas o que precisam.
Handlers HTTP enxutos: Analise o transporte, chame um método de serviço, mapeie erros para códigos de status - sem SQL ou regras de negócios com ramificações.
Serviços detêm as regras: Política de cancelamento, autorização, idempotência e fluxos de trabalho de várias etapas residem em métodos de serviço.
Repositórios detêm I/O: Chamadas SQL, SDK e mapeamento de linhas permanecem atrás de interfaces do tipo OrderRepo em pacotes de armazenamento internos.
Contexto em todo I/O: Passe context.Context como o primeiro parâmetro em handlers, serviços e métodos de repositório que podem bloquear.
Middleware apenas para preocupações transversais: Logging, IDs de requisição, recuperação e análise de credenciais de autenticação pertencem ao middleware - não à lógica de precificação.
Chaves de contexto tipadas: Use constantes privadas type ctxKey int em vez de chaves de string para evitar colisões entre pacotes de middleware.
Chame next no middleware: Invoque next.ServeHTTP a menos que o middleware tenha escrito completamente a resposta; documente a ordem do middleware em main.
sync.Once para configuração única: Proteja inicializações lentas caras (regex compilados, registro padrão) quando a injeção de dependência for impraticável.
Evite I/O em init(): Não conecte bancos de dados, leia segredos ou analise configurações em init() - conecte recursos em main ou construtores explícitos.
Limite globais de pacotes: Prefira injetar *sql.DB, loggers e registradores de métricas de main em vez de singletons Default().
Incorpore deliberadamente: Incorpore para promover métodos em decoradores enxutos (http.Handler), não para simular árvores de herança.
Erros, não pânico: Retorne error para validação e falhas esperadas; reserve panic para bugs de programador e helpers Must* de inicialização.
Mapeie erros na borda: Serviços retornam erros de domínio; adaptadores HTTP/gRPC traduzem com errors.Is e errors.As.
Teste com fakes: Implemente interfaces de consumidor em _test.go para exercitar serviços sem Docker ou credenciais de nuvem.
O padrão menos engenhoso vence: Alcance opções, repositórios ou middleware quando um segundo eixo de mudança aparecer - não antes.
Mantenha handlers enxutos e empurre as regras para serviços por trás de interfaces pequenas - a maioria das outras práticas suporta essa fronteira.
Quando mais de um construtor exportado em seu módulo precisar de configurações opcionais que, de outra forma, quebrariam os chamadores a cada novo campo.
Aplique regras de importação na revisão: pacotes de domínio não devem importar drivers SQL ou roteadores HTTP; conecte em cmd/ e internal/.
Raramente em código de aplicação; prefira injeção.
Caches imutáveis lentos em nível de biblioteca com sync.Once são a principal exceção.
Middleware e composição de handler aqui se aplicam diretamente a servidores stdlib e chi; gin/echo seguem as mesmas ideias com tipos diferentes.
Versões de Stack: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, 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 na compilação).
Revisado por Chris St. John·Última atualização: 16 de jul. de 2026