Enums en Go: Un enfoque alternativo

Introducción

Los programadores de Go a menudo echan de menos los tipos de enumeraciones (enum) integrados que proporcionan lenguajes como Java o C#. En Go, los desarrolladores suelen emular los enums definiendo un nuevo tipo personalizado y un conjunto de constantes relacionadas (a menudo usando el identificador iota).

En este artículo, te mostraré cómo emular los enums en Go usando tipos personalizados y constantes y cómo mejorarlos con métodos y generación de código.

¿Por qué Go no tiene enums?

La filosofía de diseño de Go enfatiza la simplicidad y el minimalismo. Mientras que los enums tradicionales proporcionan seguridad de tipo y un conjunto fijo de valores, Go opta por la flexibilidad de las declaraciones de constantes. Este enfoque se alinea bien con el diseño general del lenguaje y te permite definir un conjunto claro de valores relacionados.

Usar constantes como enums

El patrón más común para emular enums en Go es definir un nuevo tipo personalizado (generalmente basado en int) y un conjunto de constantes relacionadas. El identificador iota se utiliza a menudo para crear una secuencia de valores relacionados.

Aquí tienes un ejemplo de cómo definir un tipo personalizado y constantes para representar un conjunto limitado de lenguajes de programación:

package main

import "fmt"

type Language int

const (
    Unknown Language = iota // 0
    Go                      // 1
    Java                    // 2
    Python                  // 3
    JavaScript              // 4
)

func main() {
    var lang Language = Go
    fmt.Printf("The language is: %v\n", lang) // Output: The language is: 1
}

En este ejemplo, definimos un nuevo tipo personalizado Language basado en int y un conjunto de constantes relacionadas.

Ventajas de usar constantes como enums:

• Seguridad de tipado: El tipo personalizado Language restringe las variables a solo aquellos valores definidos en la enumeración.
• Legibilidad: Las constantes proporcionan nombres descriptivos para cada valor, haciendo que el código sea más legible.
• Unicidad: El identificador iota garantiza que cada constante sea única, evitando la reutilización accidental de valores.
• Mantenibilidad: Las constantes son fáciles de actualizar y mantener, lo que te permite agregar o eliminar valores según sea necesario sin tener que actualizar cada constante individualmente.

Agregar comportamiento a los enums con métodos

Si bien las constantes pueden representar un conjunto fijo de valores relacionados, carecen de la capacidad de definir comportamiento. Una ventaja de declarar un tipo personalizado es que puedes adjuntarle métodos.

Aquí tienes un ejemplo de cómo agregar un método String al tipo Language para devolver el nombre del lenguaje:

func (l Language) String() string {
  return [...]string{"Unknown", "Go", "Java", "Python", "JavaScript"}[l]
}

func main() {
  var lang Language = Go
  fmt.Printf("The language is: %v\n", lang) // Output: The language is: Go
}

Este sencillo enfoque usando el método String() facilita la conversión del tipo Language a una cadena mucho más legible.

Mejorar los enums con generación de código

A medida que tu enumeración crece, mantener la lista de constantes y los métodos asociados puede volverse engorroso y propenso a errores. Si agregas o eliminas valores del enum, debes recordar actualizar la lista de constantes y cualquier método asociado en consecuencia.

Una forma de abordar este problema es mediante el uso de herramientas de generación de código como stringer para generar automáticamente el método String para tu tipo personalizado.

Aquí te muestro cómo puedes usar stringer para generar el método String para el tipo Language:

Comienza instalando la herramienta stringer:

go get golang.org/x/tools/cmd/stringer@latest

A continuación, agrega una directiva //go:generate a tu archivo fuente para ejecutar la herramienta stringer automáticamente con go generate:

package main

import "fmt"

//go:generate stringer -type=Language -linecomment
type Language int

const (
    Unknown Language = iota
    Go                      // Golang
    Java
    Python
    JavaScript
)

func main() {
  var lang Language = Go
  fmt.Printf("The language is: %v\n", lang) // Output: The language is: Golang
}

Al ejecutar go generate ./... en el mismo directorio que tu código fuente, stringer generará el método String para el tipo Language en un nuevo archivo language_string.go.

go generate

Este enfoque facilita el proceso de agregar o eliminar valores de tu enum, ya que el método String se actualiza automáticamente cada vez que ejecutas go generate.

Manejar la serialización JSON con enums

Go representará tu enum como su valor entero subyacente si serializas una estructura que contiene tu enum por defecto. Para personalizar la representación JSON de tu enum, puedes implementar las interfaces json.Marshaler y json.Unmarshaler.

Aquí tienes un ejemplo de cómo implementar las interfaces json.Marshaler y json.Unmarshaler para el tipo Language:

import (
    "encoding/json"
    "fmt"
)

func (l Language) MarshalJSON() ([]byte, error) {
    return json.Marshal(l.String())
}

func (l *Language) UnmarshalJSON(data []byte) error {
    var s string
    if err := json.Unmarshal(data, &s); err != nil {
        return err
    }
    switch s {
    case "Go":
        *l = Go
    case "Java":
        *l = Java
    case "Python":
        *l = Python
    case "JavaScript":
        *l = JavaScript
    default:
        *l = Unknown
    }
    return nil
}

El método MarshalJSON se utiliza para serializar el tipo Language. El método UnmarshalJSON se utiliza para deserializar el tipo Language.

Al implementar estos métodos, puedes controlar cómo se representa tu enum en formato JSON.

Limitaciones y compromisos

Si bien usar constantes como enums es un patrón común en Go, tiene algunas limitaciones:

• Seguridad de tipado: A pesar de tener un tipo distinto, nada impide a un programador convertir un entero arbitrario a tu tipo enum.
• Exhaustividad: No hay una forma integrada de garantizar que una instrucción switch cubra todos los valores del enum.
• Verbosidad: Definir un tipo personalizado y constantes para cada enum puede ser engorroso, especialmente para enums grandes.
• Duplicidad: Cuando se requiere un comportamiento adicional (como el parseo de una cadena), es posible que termines escribiendo un código similar para cada tipo enum. Consulta el método UnmarshalJSON en la sección anterior para ver un ejemplo.

Conclusión

Si bien Go no proporciona enums integrados, puedes emularlos eficazmente utilizando tipos personalizados y constantes. Al añadir métodos a tu tipo personalizado y utilizar herramientas de generación de código como stringer, puedes mejorar tus enums con comportamiento adicional y simplificar el mantenimiento.

Siguiendo estos patrones, puedes incorporar eficazmente la funcionalidad de enum en tus proyectos de Go, proporcionando seguridad de tipo y un conjunto claro de valores relacionados para hacer que tu código sea robusto y legible.