Comment coder/décoder JSON en Go ?

Question

Accepted Answer

Le package **`encoding/json`** de la librairie standard de Go gère la sérialisation (marshaling) et la désérialisation (unmarshaling) du JSON, en mappant entre les structs Go et le JSON. Les **struct tags** contrôlent le nommage des champs, et c'est l'épine dorsale de la plupart des API web Go.

## Marshaling : struct Go → JSON

```go
type User struct {
    Name    string `json:"name"`              // tag maps the field to a JSON key
    Email   string `json:"email"`
    Age     int    `json:"age,omitempty"`     // omitempty → skip if zero/empty
    private string                             // unexported → NOT serialized (lowercase)
}

u := User{Name: "Ann", Email: "ann@x.com", Age: 30}
data, err := json.Marshal(u)
fmt.Println(string(data))   // {"name":"Ann","email":"ann@x.com","age":30}
```

`json.Marshal` convertit un struct en bytes JSON. **Seuls les champs exportés (en majuscule) sont sérialisés** — les champs non exportés sont ignorés.

## Le rôle des struct tags

```go
type Product struct {
    ID    int    `json:"id"`                  // → "id"
    Name  string `json:"product_name"`        // → "product_name" (rename)
    Price float64 `json:"price,omitempty"`     // omit if 0
    Notes string `json:"-"`                    // "-" → NEVER serialize this field
}
```

Sans tags, les clés JSON utilisent par défaut le nom exact du champ (en majuscule). Les tags vous permettent de contrôler le nom de la clé JSON, d'omettre les valeurs vides (`omitempty`), et d'exclure complètement des champs (`-`) — essentiel pour correspondre aux conventions d'API (par exemple, JSON en snake_case).

## Unmarshaling : JSON → struct Go

```go
jsonData := []byte(`{"name":"Bob","email":"bob@x.com","age":25}`)

var user User
err := json.Unmarshal(jsonData, &user)   // pass a POINTER to populate it
if err != nil { log.Fatal(err) }
fmt.Println(user.Name)   // "Bob"
```

`json.Unmarshal` analyse le JSON dans un struct — vous devez passer un **pointeur** pour qu'il puisse remplir le struct. Les champs sont appairés par tag/nom (insensible à la casse).

## Travailler avec du JSON inconnu/dynamique

```go
// when the structure is unknown, unmarshal into a map or interface{}
var result map[string]interface{}
json.Unmarshal(data, &result)
name := result["name"].(string)        // type-assert the value (JSON numbers → float64!)
```

## Streaming avec Encoder/Decoder (pour les I/O)

```go
// encode directly to an io.Writer (e.g. an HTTP response) — efficient, no intermediate buffer
json.NewEncoder(w).Encode(user)

// decode directly from an io.Reader (e.g. an HTTP request body)
json.NewDecoder(r.Body).Decode(&user)
```

Pour les serveurs web, `Encoder`/`Decoder` fonctionnent directement avec les flux (corps de requête/réponse) — le pattern courant dans les handlers.

## Pourquoi c'est important

Le codage/décodage JSON est fondamental pour pratiquement tout développement web en Go — les APIs REST, les microservices, et la configuration dépendent tous de la conversion entre les structs Go et le JSON.

Le package `encoding/json` (librairie standard, pas de dépendance) est l'outil standard, et le comprendre bien est une connaissance essentielle au quotidien : comment fonctionnent le marshaling/unmarshaling, la règle critique que **seuls les champs exportés sont sérialisés**, et surtout les **struct tags** (contrôlant les noms de clé JSON avec `json:"..."`, `omitempty` pour ignorer les valeurs vides, `-` pour exclure) qui sont nécessaires pour correspondre aux conventions d'API réelles comme le snake_case.

Savoir passer un pointeur à `Unmarshal`, traiter du JSON dynamique via des maps/`interface{}` (avec le piège que les nombres JSON se décodent en `float64`), et utiliser le streaming `Encoder`/`Decoder` pour les corps HTTP couvre les besoins pratiques de la construction d'APIs.

C'est une partie constante et pratique du travail backend en Go.