Cómo mostrar JSON de forma bonita en Go: guía completa con ejemplos

¿Por qué el JSON en Go parece un desastre y cómo solucionarlo?

¿Alguna vez ha escrito un programa en Go que imprime JSON y ha obtenido en la terminal algo como esto?

{"name":"PythonLib","year":2025,"tags":["go","json","tutorial"],"active":true}

De acuerdo, leer esto sin herramientas especiales no es nada agradable. Especialmente cuando la estructura de datos es compleja y el anidamiento tiene varios niveles. Los ojos empiezan a perderse y encontrar el campo deseado se convierte en una verdadera odisea.

La buena noticia: en Go existen herramientas integradas que convierten ese «desastre» en un documento ordenado y estructurado. Y hoy analizaremos todas las formas de formatear JSON de forma bonita, desde el uso simple de la biblioteca estándar hasta la creación de su propia herramienta de pretty-print.

Este material se basa en una pregunta real de Stack Overflow (más de 50 000 visitas), por lo que el tema es realmente demandado. ¡Allá vamos!

¿Qué es pretty-print y para qué sirve?

Pretty-print (o «impresión bonita») es el formateo de datos con sangrías, saltos de línea y alineación para que sean fáciles de leer para una persona. En el contexto de JSON, esto significa:

\n
• Añadir espacios o tabulaciones para elementos anidados
\n
• Colocar cada par «clave-valor» en una nueva línea
\n
• Alinear los valores para mayor claridad
\n

¿Para qué sirve esto en Go? Imagine que está depurando una respuesta de API, escribiendo un logger o simplemente mostrando una configuración. El JSON sin formatear ocupa menos espacio, pero es completamente ilegible. Pretty-print resuelve este problema con un par de líneas de código.

Método 1: json.MarshalIndent — la solución estándar

La forma más sencilla y recomendada es usar la función json.MarshalIndent del paquete estándar encoding/json. Hace exactamente lo que se necesita: toma los datos y devuelve JSON formateado con sangrías.

Aquí hay un ejemplo básico:

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n    "log"\n)\n\ntype Site struct {\n    Name   string   `json:"name"`\n    Year   int      `json:"year"`\n    Tags   []string `json:"tags"`\n    Active bool     `json:"active"`\n}\n\nfunc main() {\n    site := Site{\n        Name:   "PythonLib",\n        Year:   2025,\n        Tags:   []string{"go", "json", "tutorial"},\n        Active: true,\n    }\n\n    // Prefijo — "", sangría — "  " (dos espacios)\n    prettyJSON, err := json.MarshalIndent(site, "", "  ")\n    if err != nil {\n        log.Fatalf("Error de marshaling: %v", err)\n    }\n\n    fmt.Println(string(prettyJSON))\n}

Resultado:

{\n  "name": "PythonLib",\n  "year": 2025,\n  "tags": [\n    "go",\n    "json",\n    "tutorial"\n  ],\n  "active": true\n}

Bonito, ¿verdad? Observe el segundo y tercer parámetro de MarshalIndent:

\n
• Prefijo — cadena que se añade al inicio de cada línea. Normalmente una cadena vacía "".
\n
• Sangría — cadena para cada nivel de anidamiento. Lo más común es usar dos espacios " " o tabulación "\\t".
\n

Configuración de sangrías: espacios vs tabulación

Puede cambiar fácilmente el estilo de sangría. Por ejemplo, con tabulación:

prettyJSON, _ := json.MarshalIndent(site, "", "\\t")\nfmt.Println(string(prettyJSON))

Resultado:

{\n\t"name": "PythonLib",\n\t"year": 2025,\n\t"tags": [\n\t\t"go",\n\t\t"json",\n\t\t"tutorial"\n\t],\n\t"active": true\n}

¿Qué opción elegir? Si su proyecto sigue los estándares de Go (que recomiendan tabulación para el código), use "\\t". Si trabaja en un equipo donde se usan espacios, dos espacios serán más apropiados. Lo importante es la consistencia.

Método 2: Pretty-print para cadenas JSON sin procesar

¿Y si ya tiene una cadena con JSON sin formato?