Estructuras de salida en Go: de principiante a experto en 10 minutos

¿Por qué "simplemente imprimir una estructura" en Go no es tan sencillo?

Imagina: estás programando en Go, creaste una estructura User bonita, la llenaste con datos y solo quieres echar un vistazo a su interior. Escribes fmt.Println(user) y ves algo como {Alex 25 true}. ¿Informativo? No mucho. ¿Y si tiene 15 campos? ¿Y si uno de ellos es una estructura anidada? ¿Y si es un slice de estructuras?

La pregunta "How to print struct variables in console?" en Stack Overflow acumuló miles de visitas por una razón. Cada principiante (y no solo) en Golang se enfrenta a que la salida estándar de las estructuras es una cadena aburrida sin nombres de campos. Y cuando el proyecto crece, la depuración se convierte en un juego de adivinanzas.

En este artículo, analizaremos todas las formas de imprimir estructuras en la consola de Go: desde las básicas hasta las avanzadas. Aprenderás a imprimir una estructura de forma clara, con nombres de campos, en formato JSON, e incluso cómo escribir tu propio método para imprimir. ¡Allá vamos!

▎1. La forma más simple: fmt.Println y sus limitaciones

Empecemos con lo básico. Tenemos una estructura:

package main\n\nimport "fmt"\n\ntype User struct {\n    Name   string\n    Age    int\n    Active bool\n}\n\nfunc main() {\n    u := User{Name: "Ana", Age: 30, Active: true}\n    fmt.Println(u)\n}\n

Salida:\n

{Ana 30 true}

Funciona, pero no es informativo. No ves qué valor corresponde a qué campo. Si la estructura tiene 10 campos, estarás adivinando qué es qué. Especialmente si el tipo de datos se repite (por ejemplo, dos campos string seguidos).

Conclusión: fmt.Println solo sirve para una verificación rápida, cuando la estructura es pequeña y recuerdas exactamente el orden de los campos.

¿Cuándo es útil?

\n
• Estás escribiendo un script de un solo uso.
\n
• La estructura contiene 2-3 campos de diferentes tipos.
\n
• Usas fmt.Println para registros (logs) donde importa la velocidad, no la legibilidad.
\n

▎2. El salvador %+v: impresión con nombres de campos

Esta es, probablemente, la respuesta más popular en Stack Overflow. El formato %+v en fmt.Printf imprime la estructura con los nombres de los campos:

fmt.Printf("%+v\\n", u)\n

Salida:\n

{Name:Ana Age:30 Active:true}

¡Mucho mejor! Ves claramente dónde está el nombre, la edad y el estado.

¿Qué más hay en el arsenal de fmt?

\n
• %v — representación estándar (como en Println).
\n
• %+v — con nombres de campos.
\n
• %#v — representación completa con el nombre del paquete y el tipo (ver más abajo).
\n
• %T — imprime solo el tipo de la variable.
\n

Ejemplo con %#v:

fmt.Printf("%#v\\n", u)\n// main.User{Name:"Ana", Age:30, Active:true}\n

Este formato es útil cuando quieres copiar la salida y pegarla de nuevo en el código: es una inicialización literal válida de la estructura.

Consejo: recuerda la combinación %+v — es tu pan de cada día al depurar estructuras en Go.

▎3. Belleza y orden: serialización a JSON

Cuando la estructura es grande, anidada o contiene slices, %+v puede volverse ilegible. Aquí es donde JSON viene al rescate. Go puede convertir una estructura a JSON de forma estándar:

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n)\n\ntype Address struct {\n    City  string `json:"city"`\n    Street string `json:"street"`\n}\n\ntype User struct {\n    Name    string  `json:"name"`\n    Age     int     `json:"age"`\n    Active  bool    `json:"active"`\n    Address Address `json:"address"`\n}\n\nfunc main() {\n    u := User{\n        Name:   "Iván",\n        Age:    28,\n        Active: true,\n        Address: Address{\n            City:   "Moscú",\n            Street: "Tverskaya",\n        }