Em linguagens de programação, enums (abreviação de enumerations) são amplamente utilizados para representar conjuntos de valores nomeados. No Go, embora não exista um tipo enum nativo, podemos alcançar um comportamento similar usando constantes tipadas.

Embora já haja um post aqui no blog sobre esse tema, resolvi criar uma versão atualizada dele onde iremos, além de explorar como implementar enums em Go, veremos as diferenças em relação a outras linguagens, e as melhores práticas na hora de utilizá-los.

ENUM em Go vs Outras Linguagens

Linguagens como Java e C# oferecem suporte nativo a enums, permitindo a criação de tipos enumerados com validação e métodos associados, como podemos ver no exemplo abaixo:

public enum Color {
    RED, GREEN, BLUE;
}

Esses enums em Java são mais do que simples listas de valores; eles possuem um tipo específico, podendo incluir métodos e comportamentos.

Já no Go, diferente do Java e C#, enums não são um tipo de dado nativo. Para alcançar o mesmo resultado, precisamos utilizar constantes tipadas:

type Color int

const (
    Red Color = iota
    Green
    Blue
)

Aqui, Color é definido como um tipo base int, e as constantes Red, Green e Blue são valores desse tipo.

Melhores Práticas

Ao trabalhar com enums em Go, algumas práticas são recomendadas para melhorar a manutenção do código e evitar erros:

Use tipos nomeados: Sempre associe enums a tipos nomeados para garantir que os valores sejam restritos ao contexto esperado.

type Status int

const (
    Pending Status = iota
    Approved
    Rejected
)

Adicione métodos para melhorar a legibilidade: Implementar métodos para o tipo enum facilita a conversão de valores para string e vice-versa. No exemplo abaixo, implementamos o “método mágico” String para retornar o texto referente ao valor do enum.

func (s Status) String() string {
    switch s {
    case Pending:
        return "Pending"
    case Approved:
        return "Approved"
    case Rejected:
        return "Rejected"
    default:
        return "Unknown"
    }
}

Validação de valores: Para evitar valores inválidos, crie funções que validem se o valor fornecido é um membro válido do enum.

func IsValidStatus(s Status) bool {
    switch s {
    case Pending, Approved, Rejected:
        return true
    }
    return false
}

Mapeamento de strings para enums: Para facilitar o tratamento na entrada de dados, é útil ter um mapeamento reverso, como no exemplo abaixo.

var statusMap = map[string]Status{
    "Pending":  Pending,
    "Approved": Approved,
    "Rejected": Rejected,
}

func ParseStatus(s string) (Status, bool) {
    val, ok := statusMap[s]
    return val, ok
}

O que é iota?

O identificador iota é uma ferramenta poderosa em Go para definir séries incrementais de constantes. Sempre que uma constante é definida com iota, seu valor começa em zero e incrementa automaticamente em cada nova linha dentro do bloco const.

const (
    First  = iota // 0
    Second        // 1
    Third         // 2
)

Ele é especialmente útil para criar enums, já que elimina a necessidade de definir manualmente valores inteiros para cada constante. iota também pode ser usado em combinações mais complexas, como no exemplo abaixo:

const (
    _  = iota             // Ignora o valor zero
    KB = 1 << (10 * iota) // 1024
    MB                   // 1048576
    GB                   // 1073741824
)

Conclusão

Enums são ferramentas essenciais para organizar e validar conjuntos de valores no código.

Apesar de Go não oferecer suporte nativo a enums, a combinação de constantes tipadas e iota permite criar soluções eficazes. Seguindo as práticas apresentadas, você poderá garantir que suas implementações sejam legíveis, robustas e fáceis de manter.

Com essas técnicas, você estará pronto para aproveitar ao máximo as capacidades do Go na representação de enums.

Até a próxima!

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.