Cómo escribir código limpio en Go: 7 reglas para profesionales

Introducción: por qué el código limpio en Go no es un lujo, sino una necesidad

Go (o Golang) es un lenguaje que a primera vista parece simple e incluso aburrido. No tiene genéricos (hasta la versión 1.18), no tiene clases, no tiene máquina virtual. Pero es precisamente este minimalismo lo que lo convierte en el campo de batalla ideal para el código limpio. Si escribes en Go y tu proyecto comienza a parecerse a un espagueti de goroutine y switch ilegibles, estás perdiendo la principal ventaja del lenguaje: velocidad de desarrollo y facilidad de mantenimiento.

En este artículo, analizaremos 7 reglas prácticas que te ayudarán a escribir código Go idiomático que sea comprensible no solo para el compilador, sino también para tus colegas (y para ti mismo dentro de un mes). ¡Allá vamos!

1. Nombres de variables correctos: cortos y claros

En Go, se acostumbra usar nombres cortos pero significativos. A diferencia de Java, donde ListOfUserOrders es normal, en Go verás orders o incluso os. ¿Por qué? Porque Go es un lenguaje para leer código, no para escribirlo.

Reglas básicas de nomenclatura en Go

\n
• Variables locales: 1-2 letras para cosas obvias (i — contador, s — cadena).
\n
• Paquetes: una palabra, minúsculas, sin guiones bajos (http, fmt).
\n
• Identificadores exportados: comienzan con mayúscula (GetUser).
\n
• Acrónimos: se escriben en un mismo caso (HTTP, URL, no Http ni Url).
\n

// Mal\nfunc GetUserDataFromDatabaseByID(userID string) (UserData, error) {\n    var userDataFromDb UserData\n    // ...\n    return userDataFromDb, nil\n}\n\n// Bien\nfunc GetUser(id string) (User, error) {\n    var u User\n    // ...\n    return u, nil\n}

Consejo: si el nombre de una variable ocupa más de 2 palabras, probablemente estás complicando algo.

2. Formateo: confía en gofmt

En Go no hay «guerras de estilo». El comando gofmtgofmt, no estás escribiendo en Go, sino en un «dialecto de Go».

¿Qué hace gofmt?

\n
• Coloca sangrías (tabulaciones, no espacios).
\n
• Elimina saltos de línea innecesarios.
\n
• Alinea comentarios.
\n
• Elimina importaciones no utilizadas (con la bandera -s).
\n

// Antes de gofmt\nfunc  add (a int,b int) int{\nreturn a+b\n}\n\n// Después de gofmt\nfunc add(a, b int) int {\n    return a + b\n}

En cualquier editor moderno (VS Code, GoLand), gofmt se ejecuta automáticamente al guardar. Si no es así, configúralo. Esto ahorrará horas de revisión de código.

3. Manejo de errores: no ignores, no entres en pánico

En Go no hay excepciones (try-catch). Los errores son simplemente valores que deben verificarse. Esta es una de las mayores fortalezas del lenguaje, si la usas correctamente.

Reglas para trabajar limpiamente con errores

\n
• Siempre verifica error. Nada de _ para omitir.
\n
• No uses panic en código de biblioteca. Solo si el programa no puede continuar (por ejemplo, no se abre un archivo de configuración).
\n
• Envuelve los errores con fmt.Errorf("context: %w", err) (Go 1.13+).
\n

// Mal\nfunc ReadConfig(path string) *Config {\n    data, _ := ioutil.ReadFile(path) // ignoramos el error\n    var cfg Config\n    json.Unmarshal(data, &cfg)\n    return &cfg\n}\n\n// Bien\nfunc ReadConfig(path string) (*Config, error) {\n    data, err := ioutil.ReadFile(path)\n    if err != nil {\n        return nil, fmt.Errorf("read config: %w", err)\n    }\n    var cfg Config\n    if err := json.Unma