5 minutos de leitura
Autor(a)
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
Como organizar o código Go de forma clara, eficiente e fácil de manter? Neste artigo, vamos conhecer as armadilhas comuns e como evitá-las, além das boas práticas para estruturar projetos e usar recursos como interfaces, funções init e pacotes utilitários.
Muitas pessoas programam em Go de forma ineficiente porque aplicam padrões de outras linguagens sem considerar as particularidades do Go.
É comum que pessoas desenvolvedoras de linguagens orientadas a objetos exagerem no uso de interfaces e abstrações desnecessárias, deixando o código mais complexo do que deveria.
Outra armadilha comum é não seguir a organização idiomática de pacotes, misturando responsabilidades ou criando uma estrutura excessivamente fragmentada, dificultando a manutenção e a escalabilidade do projeto.
Continue lendo o artigo para descobrir como evitar os erros mais comuns e aprender a adotar práticas que vão tornar seu desenvolvimento mais ágil e melhorar seu código Go.
Declarar uma variável com o mesmo nome em um bloco interno esconde a variável do bloco externo. Isso pode causar confusão e bugs difíceis de encontrar.
nome := "João" // Nome externo
{
nome := "Maria" // Nome interno, sombreia o externo
fmt.Println(nome) // Imprime "Maria"
}
fmt.Println(nome) // Imprime "João" - o nome externo não foi alterado
Solução: Use nomes diferentes para variáveis em blocos internos.
package main
import "fmt"
func main() {
nomeExterno := "João" // Nome externo
{
nomeInterno := "Maria" // Nome interno, não sombreia o externo
fmt.Println(nomeInterno) // Imprime "Maria"
}
fmt.Println(nomeExterno) // Imprime "João" - o nome externo não foi alterado
}
Muitos níveis de if/else dificultam a leitura e compreensão do código.
func process(n int) {
if n > 0 {
if n%2 == 0 {
fmt.Println("Número positivo e par")
} else {
fmt.Println("Número positivo e ímpar")
}
} else {
fmt.Println("Número não é positivo")
}
}
Solução: Simplifique as condições, retorne antecipadamente, quando possível, e alinhe o caminho principal (o código que executa na maioria das vezes) à esquerda, como no exemplo abaixo:
func process(n int) {
if n <= 0 {
fmt.Println("Número não é positivo")
return
}
if n%2 == 0 {
fmt.Println("Número positivo e par")
return
}
fmt.Println("Número positivo e ímpar")
}
Funções init são executadas automaticamente ao iniciar um pacote. Evite usá-las para tarefas complexas ou que possam falhar, pois o tratamento de erros é limitado.
var config Config
func init() {
config = loadConfig() // Pode falhar e não tem tratamento de erro adequado
}
Solução: Prefira funções normais para inicializações.
var config Config
func initialize() error {
var err error
config, err = loadConfig()
return err
}
Em Go, não é idiomático usar getters e setters para todos os campos de uma struct, como no exemplo abaixo:
type User struct {
name string
}
func (u *User) GetName() string {
return u.name
}
func (u *User) SetName(name string) {
u.name = name
}
Solução: Acesse os campos diretamente, a menos que haja uma lógica específica para encapsular.
type User struct {
Name string // Campos exportados (maiúscula inicial) são acessíveis externamente
}
Criar interfaces desnecessárias torna o código mais complexo. Interfaces devem ser descobertas conforme a necessidade, e não criadas antecipadamente.
type Database interface {
Save(data string)
}
type SQLDatabase struct{}
func (s SQLDatabase) Save(data string) {
fmt.Println("Salvando no banco")
}
Solução: Prefira interfaces pequenas e com propósito claro.
type SQLDatabase struct{}
func (s SQLDatabase) Save(data string) {
fmt.Println("Salvando no banco")
}
Quando a interface é definida no pacote produtor, qualquer mudança na interface pode exigir alterações em todos os pacotes que a utilizam. Isso cria um acoplamento desnecessário entre o produtor e os consumidores.
package storage
type Storage interface {
Save(data string)
}
Solução: Defina interfaces no pacote que as utiliza (consumidor), não no pacote que implementa os tipos concretos (produtor). Isso dá mais flexibilidade ao consumidor.
package service
type Storage interface {
Save(data string)
}
any não diz nada
Em Go, any é um alias para interface{} e representa qualquer tipo.
Ele foi introduzido no Go 1.18 para tornar o código mais legível e intuitivo, substituindo o uso explícito de interface{} para indicar valores de qualquer tipo.
Entretanto, any pode receber qualquer tipo, mas isso torna o código menos expressivo.
func PrintValue(value any) {
fmt.Println(value)
}
Solução: Use tipos concretos sempre que possível.
func PrintValue(value string) {
fmt.Println(value)
}
Genéricos permitem escrever código que funciona com diferentes tipos. Use-os com cautela, apenas quando necessário para evitar repetição de código com tipos diferentes.
func Print[T any](value T) {
fmt.Println(value)
}
Solução: Não use genéricos quando tornar o código mais complexo.
package main
import "fmt"
func PrintInt(value int) {
fmt.Println(value)
}
func PrintString(value string) {
fmt.Println(value)
}
func main() {
PrintInt(42)
PrintString("Olá, mundo!")
}
Organize o projeto em pacotes com nomes claros e concisos.
package main
type User struct{}
func saveUser() {}
func main() { ………
Evite pacotes muito pequenos ou muito grandes. Separe código público de código privado.
/project
/cmd
/internal
/pkg
/service
/repository
Evite nomes de variáveis que colidam com nomes de pacotes.
package utils
func ConvertToUpper(s string) string {
return strings.ToUpper(s)
}
Solução: Use nomes diferentes ou aliases para pacotes.
package stringutil
func ToUpper(s string) string {
return strings.ToUpper(s)
}
Linters são ferramentas que analisam o código em busca de erros e problemas de estilo.
go run main.go
Solução: Use linters para garantir a qualidade do código.
golangci-lint run
Escreva código Go simples, claro e bem organizado. Evite abstrações desnecessárias e use as ferramentas disponíveis para garantir a qualidade do código.
Lembre-se que a consistência é fundamental para facilitar a manutenção do projeto.
Quer aprofundar ainda nessa linguagem? Aprenda a programar em Go com boas práticas na Alura! Conheça as formações Linguagem Go e Aprenda a programar em Go.
Avalie este artigo
