Atajos secretos de Go: qué son los struct tags y para qué sirven

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Introducción: las comillas mágicas en el código Go

Si alguna vez has escrito en Go estructuras para trabajar con JSON, seguramente has visto construcciones extrañas como estas:

type User struct {    Name string `json:"name"`    Age  int    `json:"age,omitempty"`}

Estas misteriosas comillas invertidas (`json:"name"`) se llaman struct tags (etiquetas de estructuras). Para un principiante parecen magia o ruido innecesario. Pero en realidad son una de las características más potentes y elegantes de Go, que permite meta-programar sin macros complejas.

En este artículo analizaremos qué son los struct tags en Go, para qué sirven, qué tipos existen y cómo usarlos en proyectos reales. Dejarás de temer estas «cadenas mágicas» y empezarás a usarlas con conciencia.

¿Qué son los struct tags? Explicación sencilla

Struct tags son literales de cadena que se escriben después del tipo de campo en una estructura. Están encerrados entre comillas invertidas (`) y representan pares clave:"valor".

Desde el punto de vista del lenguaje, las etiquetas de estructuras en Go son solo texto. El compilador de Go no las analiza ni las verifica. Su significado aparece solo cuando tú (o una biblioteca) las lees a través del paquete reflect.

En pocas palabras: las etiquetas son metadatos que adjuntas a los campos de una estructura. Otras partes de tu programa pueden leer estos metadatos y cambiar su comportamiento.

¿Para qué sirven los struct tags? 3 escenarios principales

1. Serialización/deserialización (JSON, XML, YAML)

Este es el caso de uso más común y comprensible. Imagina que tienes una estructura Go y quieres convertirla a JSON (o viceversa).

type User struct {    ID        int    `json:"id"`    FirstName string `json:"first_name"`    LastName  string `json:"last_name"`    Password  string `json:"-"`}

func main() {    user := User{ID: 1, FirstName: "Iván", LastName: "Pérez", Password: "secreto"}    jsonData, _ := json.Marshal(user)    fmt.Println(string(jsonData))    // Salida: {"id":1,"first_name":"Iván","last_name":"Pérez"}    // La contraseña no aparece en JSON porque tiene la etiqueta json:"-"}

Sin etiquetas, los campos se llamarían ID, FirstName, etc., lo que no coincide con el estilo JSON (camelCase vs snake_case). Las etiquetas Golang struct para JSON permiten controlar:

El nombre del campo en JSON
Omitir campos vacíos (omitempty)
Excluir un campo de la salida (-)
Opciones anidadas

2. Validación de datos

Bibliotecas populares como go-playground/validator utilizan etiquetas de estructuras Go para validación. Simplemente escribes las reglas directamente en la estructura:

type SignUpRequest struct {    Email    string `validate:"required,email"`    Password string `validate:"required,min=8,max=32"`    Age      int    `validate:"gte=18,lte=120"`}

func validateUser(user SignUpRequest) error {    validate := validator.New()    err := validate.Struct(user)    return err}

Esto es increíblemente práctico: las reglas de validación están junto a los datos, no dispersas por el código. Las etiquetas struct para validación hacen que el código sea autodocumentado.

3. Trabajo con bases de datos (ORM)

Las bibliotecas ORM (GORM, Ent, SQLBoiler) utilizan activamente etiquetas struct para ORM. Por ejemplo, en GORM:

type Product struct {    gorm.Model    Code  string `gorm:"uniqueIndex;not null"`    Price uint   `gorm:"default:0"`    UserID uint  `gorm:"foreignKey:UserID"`}

Las etiquetas gorm definen índices, restricciones, claves foráneas y otras configuraciones de tabla. Esto evita tener que escribir migraciones por separado.