Afficher les structures en Go : du débutant au pro en 10 minutes

Pourquoi « simplement afficher une structure » en Go n'est-il pas si simple ?

Imaginez : vous codez en Go, vous avez créé une belle structure User, vous l'avez remplie de données, et vous voulez simplement jeter un œil à l'intérieur. Vous écrivez fmt.Println(user) et vous voyez quelque chose comme {Alex 25 true}. Informatif ? Pas vraiment. Et s'il y a 15 champs ? Et si l'un d'eux est une structure imbriquée ? Et s'il s'agit d'un slice de structures ?

La question "How to print struct variables in console?" sur Stack Overflow a accumulé des milliers de vues pour une bonne raison. Chaque débutant (et pas seulement) en Golang rencontre le fait que l'affichage standard des structures est une chaîne terne sans noms de champs. Et quand le projet grandit, le débogage devient un jeu de devinettes.

Dans cet article, nous allons passer en revue toutes les façons d'afficher les structures dans la console Go : des méthodes de base aux plus avancées. Vous apprendrez à afficher une structure joliment, avec les noms des champs, au format JSON, et même à écrire votre propre méthode d'impression. C'est parti !

▎1. La méthode la plus simple : fmt.Println et ses limites

Commençons par les bases. Nous avons une structure :

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: "Anna", Age: 30, Active: true}\n    fmt.Println(u)\n}\n

Sortie :\n

{Anna 30 true}

Ça fonctionne, mais c'est peu informatif. Vous ne voyez pas quelle valeur correspond à quel champ. Si la structure a 10 champs, vous devrez deviner ce qui est quoi. Surtout si le type de données se répète (par exemple, deux champs string à la suite).

Conclusion : fmt.Println ne convient que pour une vérification rapide, lorsque la structure est petite et que vous vous souvenez exactement de l'ordre des champs.

Quand est-ce utile ?

\n
• Vous écrivez un script à usage unique.
\n
• La structure contient 2-3 champs de types différents.
\n
• Vous utilisez fmt.Println pour des logs où la vitesse prime sur la lisibilité.
\n

▎2. Le sauveur %+v : impression avec les noms des champs

C'est sans doute la réponse la plus populaire sur Stack Overflow. Le format %+v dans fmt.Printf affiche la structure avec les noms des champs :

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

Sortie :\n

{Name:Anna Age:30 Active:true}

Beaucoup mieux ! Vous voyez clairement où se trouvent le nom, l'âge et le statut.

Quoi d'autre dans l'arsenal de fmt ?

\n
• %v — représentation standard (comme dans Println).
\n
• %+v — avec les noms des champs.
\n
• %#v — représentation complète avec le nom du package et le type (voir ci-dessous).
\n
• %T — affiche uniquement le type de la variable.
\n

Exemple avec %#v :

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

Ce format est utile lorsque vous voulez copier la sortie et la coller dans votre code — c'est une initialisation littérale valide de la structure.

Conseil : retenez la combinaison %+v — c'est votre outil de base pour le débogage des structures en Go.

▎3. Beauté et ordre : sérialisation en JSON

Lorsque la structure est grande, imbriquée ou contient des slices, %+v peut devenir illisible. C'est là que JSON vient à la rescousse. Go sait nativement transformer une structure en JSON :

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:   "Ivan",\n        Age:    28,\n        Active: true,\n        Address: Address{\n            City:   "Moscou",\n            Street: "Tverskaïa",\n        }