Comment afficher joliment du JSON en Go : guide complet avec exemples

Pourquoi le JSON en Go ressemble-t-il à un fouillis et comment y remédier ?

Avez-vous déjà écrit un programme en Go qui affiche du JSON et obtenu dans le terminal quelque chose comme ceci ?

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

Admettez-le, lire cela sans outils spéciaux n'est pas vraiment un plaisir. Surtout lorsque la structure des données est complexe et que l'imbrication s'étend sur plusieurs niveaux. Les yeux commencent à s'égarer et trouver le champ souhaité devient une véritable quête.

Bonne nouvelle : Go dispose d'outils intégrés qui transforment ce « fouillis » en un document soigné et structuré. Et aujourd'hui, nous allons passer en revue toutes les façons de formater joliment du JSON — de l'utilisation simple de la bibliothèque standard à la création de votre propre outil de pretty-print.

Ce contenu est basé sur une question réelle de Stack Overflow (plus de 50 000 vues), donc le sujet est vraiment demandé. C'est parti !

Qu'est-ce que le pretty-print et pourquoi en a-t-on besoin ?

Pretty-print (ou « belle impression ») est le formatage des données avec des indentations, des sauts de ligne et un alignement pour les rendre faciles à lire par un humain. Dans le contexte du JSON, cela signifie :

\n
• Ajout d'espaces ou de tabulations pour les éléments imbriqués
\n
• Déplacement de chaque paire « clé-valeur » sur une nouvelle ligne
\n
• Alignement des valeurs pour plus de clarté
\n

Pourquoi en a-t-on besoin en Go ? Imaginez que vous déboguez une réponse d'API, écrivez un logger ou affichez simplement une configuration. Le JSON non formaté prend moins de place, mais est totalement illisible. Le pretty-print résout ce problème en quelques lignes de code.

Méthode 1 : json.MarshalIndent — la solution standard

La façon la plus simple et recommandée est d'utiliser la fonction json.MarshalIndent du package standard encoding/json. Elle fait exactement ce qu'il faut : prend des données et retourne du JSON formaté avec des indentations.

Voici un exemple de base :

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    // Préfixe — "", indentation — "  " (deux espaces)\n    prettyJSON, err := json.MarshalIndent(site, "", "  ")\n    if err != nil {\n        log.Fatalf("Erreur de marshaling : %v", err)\n    }\n\n    fmt.Println(string(prettyJSON))\n}

Résultat :

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

Joli, n'est-ce pas ? Notez les deuxième et troisième paramètres de MarshalIndent :

\n
• Préfixe — une chaîne ajoutée au début de chaque ligne. Généralement une chaîne vide "".
\n
• Indentation — une chaîne pour chaque niveau d'imbrication. On utilise le plus souvent deux espaces " " ou une tabulation "\\t".
\n

Configuration des indentations : espaces vs tabulation

Vous pouvez facilement changer le style d'indentation. Par exemple, avec une tabulation :

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

Résultat :

{\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}

Quelle option choisir ? Si votre projet suit les standards Go (qui recommandent la tabulation pour le code), utilisez "\\t". Si vous travaillez dans une équipe où les espaces sont la norme, deux espaces seront plus appropriés. L'essentiel est la cohérence.

Méthode 2 : Pretty-print pour les chaînes JSON brutes

Et si vous avez déjà une chaîne JSON non formatée