JSON vers Go Struct

Qu'est-ce que la conversion JSON vers Go ?

La conversion JSON vers Go transforme des données JSON brutes en définitions de types Go compatibles avec le package encoding/json de la bibliothèque standard. Go est un langage statiquement typé, ce qui signifie que chaque champ JSON doit avoir un champ de struct correspondant avec le type correct et une struct tag qui indique au sérialiseur quelle clé JSON mapper. Écrire ces définitions à la main pour des réponses d'API volumineuses ou profondément imbriquées est lent et source d'erreurs.

Le package encoding/json, disponible depuis Go 1.0, utilise la réflexion pour faire correspondre les clés JSON aux champs exportés des structs. La correspondance est insensible à la casse par défaut, mais les json struct tags explicites sont la pratique standard : elles suppriment l'ambiguïté et permettent d'utiliser la convention PascalCase de Go pendant que le JSON reste en camelCase ou snake_case. Un convertisseur automatise tout cela : il lit votre JSON, infère les types Go à partir des valeurs et produit les définitions de structs avec les tags corrects.

Le système de types de Go s'adapte naturellement à JSON. Les chaînes deviennent string, les booléens bool, les entiers int et les nombres à virgule flottante float64. Les objets JSON imbriqués deviennent des structs nommés distincts, et les tableaux deviennent des slices. Le seul cas particulier est null : Go n'a pas de type nullable universel, donc les valeurs null deviennent généralement des types pointeur (*string, *int) ou interface{}. Un générateur gère tout cela en quelques millisecondes.

Pourquoi utiliser un convertisseur JSON vers Go ?

Définir des structs Go à partir de JSON à la main signifie compter les accolades, deviner les types et réécrire les tags à chaque modification d'API. Un convertisseur élimine cette friction.

Cas d'utilisation JSON vers Go

Correspondance des types JSON vers Go

Le package encoding/json suit des règles précises pour mapper les valeurs JSON aux types Go. Le tableau ci-dessous montre la correspondance par défaut et les alternatives courantes. La colonne « Défaut » correspond à ce que la plupart des générateurs produisent. La colonne « Alternative » montre les types que vous pourriez choisir selon vos besoins, comme int64 pour les grands identifiants ou les types pointeur pour les champs nullables.

Référence des struct tags JSON en Go

Les struct tags contrôlent la façon dont encoding/json sérialise et désérialise les champs. La tag json est de loin la plus courante, mais vous pouvez la combiner avec d'autres tags (db, yaml, xml) sur le même champ. La syntaxe des tags est une chaîne délimitée par des backticks après le type du champ. Voici les options de la tag json supportées par encoding/json.

json.Unmarshal vs json.NewDecoder

Go propose deux façons de décoder du JSON : json.Unmarshal pour les slices d'octets et json.NewDecoder pour les flux io.Reader. Les deux utilisent les mêmes règles de struct tags, mais diffèrent selon le contexte d'utilisation.

Exemples de code

Ces exemples montrent comment utiliser des structs Go générés depuis JSON dans de vrais programmes, ainsi que comment les générer depuis d'autres langages. Les exemples Go utilisent encoding/json de la bibliothèque standard.

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	ID       int      `json:"id"`
	Name     string   `json:"name"`
	Email    string   `json:"email"`
	IsActive bool     `json:"is_active"`
	Tags     []string `json:"tags"`
}

func main() {
	data := []byte(`{"id":1,"name":"Alice","email":"alice@example.com","is_active":true,"tags":["admin","editor"]}`)

	var user User
	if err := json.Unmarshal(data, &user); err != nil {
		panic(err)
	}
	fmt.Println(user.Name)  // → Alice
	fmt.Println(user.Tags)  // → [admin editor]
}

// JSON response from API — this is the shape you'd convert to Go:
const res = await fetch("https://api.example.com/users/1");
const user = await res.json();
// user → { "id": 1, "name": "Alice", "email": "alice@example.com" }

// Equivalent Go struct:
// type User struct {
//     ID    int    `json:"id"`
//     Name  string `json:"name"`
//     Email string `json:"email"`
// }

import json

def json_to_go(data: dict, name: str = "Root") -> str:
    lines = [f"type {name} struct {{"]
    type_map = {str: "string", int: "int", float: "float64", bool: "bool"}

    for key, value in data.items():
        go_type = type_map.get(type(value), "interface{}")
        field = key.title().replace("_", "")  # snake_case → PascalCase
        lines.append(f'\t{field} {go_type} `json:"{key}"`')
    lines.append("}")
    return "\n".join(lines)

data = json.loads('{"user_name": "Alice", "age": 30, "verified": true}')
print(json_to_go(data))
# type Root struct {
#     UserName string `json:"user_name"`
#     Age      int    `json:"age"`
#     Verified bool   `json:"verified"`
# }

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Event struct {
	Type    string `json:"type"`
	Payload string `json:"payload"`
}

func main() {
	stream := strings.NewReader(`{"type":"click","payload":"btn-1"}
{"type":"scroll","payload":"page-2"}`)

	dec := json.NewDecoder(stream)
	for dec.More() {
		var ev Event
		if err := dec.Decode(&ev); err != nil {
			break
		}
		fmt.Printf("%s: %s\n", ev.Type, ev.Payload)
	}
	// → click: btn-1
	// → scroll: page-2
}

Questions fréquentes