Clean Code em Go: princípios e exemplos para iniciantes — parte 1

Código limpo não é apenas um termo da moda, mas a base da programação profissional. Se você está estudando Go (Golang) e quer escrever programas fáceis de ler, manter e expandir, os princípios do Clean Code serão sua melhor ferramenta. Neste artigo, vamos abordar os conceitos básicos de código limpo em Go, adequados até mesmo para iniciantes.

Por que o Clean Code é importante em Go?

Go foi originalmente projetado como uma linguagem para criar soluções simples e eficientes. No entanto, sem seguir as regras de código limpo, até mesmo um projeto simples pode se transformar em um "spaghetti". Código limpo ajuda a:

• Reduzir o número de erros durante a programação;
• Simplificar o trabalho em equipe;
• Reduzir o tempo de aprendizado de novos desenvolvedores;
• Aumentar a legibilidade e a manutenibilidade do código.

Princípio 1: Nomenclatura correta

Os nomes de variáveis, funções e pacotes devem refletir sua finalidade. Em Go, é comum usar nomes curtos, mas isso não significa que eles devam ser sem sentido.

Exemplo ruim:

func f(a int, b int) int {    r := a + b    return r}

Exemplo bom (Clean Code):

func AddNumbers(first int, second int) int {    result := first + second    return result}

Observe: o nome da função AddNumbers já diz imediatamente o que ela faz. As variáveis first, second, result também não geram dúvidas. Isso é especialmente importante para Go para iniciantes, pois nomes claros aceleram a compreensão do código.

Princípio 2: Minimizar o escopo

Em Golang, existem identificadores exportados (com letra maiúscula) e não exportados (com letra minúscula). Use isso para ocultar detalhes internos de implementação.

Exemplo:

package calculator

// Função exportadatype Calculator struct {    result int}

func (c *Calculator) Add(value int) {    c.result += value}

func (c *Calculator) GetResult() int {    return c.result}

// Função não exportada — oculta do mundo externofunc (c *Calculator) reset() {    c.result = 0}

Aqui, reset não está acessível a partir de outros pacotes, o que protege o estado interno do objeto. Este é um dos principais princípios do Clean Code — encapsulamento.

Princípio 3: Funções devem ser pequenas

Uma função — uma tarefa. Se uma função faz mais de uma coisa, ela deve ser dividida em várias. Isso melhora a legibilidade e simplifica os testes.

Exemplo ruim:

func ProcessUser(name string, age int) string {    if age < 18 {        return "Acesso negado"    }    result := "Olá, " + name    return result}

Exemplo bom (Clean Code):

func IsAdult(age int) bool {    return age >= 18}

func GreetUser(name string) string {    return "Olá, " + name}

func ProcessUser(name string, age int) string {    if !IsAdult(age) {        return "Acesso negado"    }    return GreetUser(name)}

Agora cada função é responsável por sua parte. Isso facilita o aprendizado e a manutenção do código.

Princípio 4: Tratamento de erros

Em Go, não há exceções — os erros são retornados como valores. Código limpo exige tratamento explícito de erros, e não sua ignorância.

Exemplo ruim:

func ReadFile(path string) string {    data, _ := os.ReadFile(path)    return string(data)}

Exemplo bom: