Hoe codeer/decodeer je JSON in Go?

Question

Accepted Answer

Go's standaard bibliotheek **`encoding/json`** pakket verzorgt JSON-serialisatie (marshaling) en deserialisatie (unmarshaling), waarbij tussen Go structs en JSON wordt gemapped. **Struct tags** controleren de veldnaamgeving, en het is de ruggengraat van de meeste Go web-API's.

## Marshaling: Go struct → 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` converteert een struct naar JSON bytes. **Alleen geëxporteerde (gecapitaliseerde) velden worden geserialiseerd** — niet-geëxporteerde velden worden overgeslagen.

## De rol van 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
}
```

Zonder tags krijgen JSON keys standaard de exacte (gecapitaliseerde) veldnaam. Tags laten je de JSON-sleutelnaam controleren, lege waarden weglaten (`omitempty`), en velden volledig uitsluiten (`-`) — essentieel om API-conventies overeen te komen (bijv. snake_case JSON).

## Unmarshaling: JSON → Go struct

```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` parseert JSON in een struct — je moet een **pointer** doorgeven zodat het de struct kan vullen. Velden worden gematcht op tag/naam (onafhankelijk van hoofdlettergebruik).

## Werken met onbekende/dynamische JSON

```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 met Encoder/Decoder (voor 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)
```

Voor webservers werken `Encoder`/`Decoder` direct met streams (request/response bodies) — het veelgebruikte patroon in handlers.

## Waarom het belangrijk is

JSON-codering/decodering is fundamenteel voor vrijwel alle Go web-ontwikkeling — REST-API's, microservices en configuraties vertrouwen allemaal op het converteren tussen Go structs en JSON.

Het `encoding/json` pakket (standaard bibliotheek, geen afhankelijkheid) is de standaardtool, en het goed begrijpen is essentiële dagelijkse kennis: hoe marshaling/unmarshaling werkt, de kritieke regel dat **alleen geëxporteerde velden worden geserialiseerd**, en vooral **struct tags** (controleren van JSON-sleutelnamen met `json:"..."`, `omitempty` om lege waarden over te slaan, `-` om uit te sluiten) die nodig zijn om echt-wereldse API-conventies aan te passen zoals snake_case.

Weten dat je een pointer naar `Unmarshal` moet doorgeven, dynamische JSON via maps/`interface{}` moet aanpakken (met het voorbehoud dat JSON-nummers naar `float64` decoderen), en streaming `Encoder`/`Decoder` voor HTTP-bodies moet gebruiken, dekt de praktische behoeften van het bouwen van API's.

Het is een constant, praktisch onderdeel van Go backend-werk.