Come si codificano/decodificano i JSON in Go?

Question

Accepted Answer

Il package **`encoding/json`** della standard library di Go gestisce la serializzazione (marshaling) e la deserializzazione (unmarshaling) del JSON, mappando tra struct Go e JSON. I **struct tags** controllano la denominazione dei campi ed è la spina dorsale della maggior parte delle 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` converte uno struct in byte JSON. **Solo i campi esportati (con lettera maiuscola) vengono serializzati** — i campi non esportati vengono saltati.

## Il ruolo dei 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
}
```

Senza tag, le chiavi JSON assumono per default il nome esatto del campo (con maiuscola). I tag ti permettono di controllare il nome della chiave JSON, omettere valori vuoti (`omitempty`), ed escludere completamente i campi (`-`) — essenziale per rispettare le convenzioni API (ad es. snake_case per JSON).

## 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` analizza JSON in uno struct — devi passare un **puntatore** in modo che possa popolarlo. I campi vengono abbinati per tag/nome (insensibile alle maiuscole/minuscole).

## Lavorare con JSON sconosciuto/dinamico

```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 con Encoder/Decoder (per 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)
```

Per i web server, `Encoder`/`Decoder` funzionano direttamente con stream (corpi di richiesta/risposta) — il pattern comune nei handler.

## Perché è importante

La codifica/decodifica del JSON è fondamentale per praticamente tutto lo sviluppo web Go — API REST, microservizi e configurazioni si basano tutti sulla conversione tra struct Go e JSON.

Il package `encoding/json` (standard library, nessuna dipendenza) è lo strumento standard, e comprenderlo bene è conoscenza essenziale quotidiana: come funzionano marshaling/unmarshaling, la regola critica che **solo i campi esportati vengono serializzati**, e soprattutto i **struct tags** (controllare i nomi delle chiavi JSON con `json:"..."`, `omitempty` per saltare valori vuoti, `-` per escludere) che sono necessari per rispettare le convenzioni reali dell'API come snake_case.

Sapere che devi passare un puntatore a `Unmarshal`, gestire JSON dinamico tramite mappe/`interface{}` (con il cavallo che i numeri JSON decodificano a `float64`), e utilizzare lo streaming `Encoder`/`Decoder` per i corpi HTTP copre le esigenze pratiche della costruzione di API.

È una parte costante e pratica del lavoro backend in Go.