Cum codifici/decodifici JSON în Go?

Question

Accepted Answer

Pachetul **`encoding/json`** din biblioteca standard a Go gestionează serializarea JSON (marshaling) și deserializarea (unmarshaling), mapând între structurile Go și JSON. **Etichetele struct** controlează denumirea câmpurilor, iar acesta este baza majorității API-urilor web din Go.

## 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` convertește o structură în bytes JSON. **Doar câmpurile exportate (capitalizate) sunt serializate** — câmpurile neexportate sunt omise.

## Rolul etichetelor struct

```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
}
```

Fără etichete, cheile JSON implicite sunt exact denumirea câmpului (capitalizat). Etichetele vă permit să controlați numele cheii JSON, să omiteți valorile goale (`omitempty`), și să excludeți câmpuri complet (`-`) — esențial pentru a respecta convențiile API (de ex. JSON în snake_case).

## 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` parseaza JSON într-o structură — trebuie să transmiteți un **pointer** pentru ca aceasta să populeze structura. Câmpurile sunt potrivite după etichetă/nume (fără sensibilitate la majuscule/minuscule).

## Lucrul cu JSON necunoscut/dinamic

```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 cu Encoder/Decoder (pentru 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)
```

Pentru servere web, `Encoder`/`Decoder` funcționează direct cu fluxuri (corpuri de cereri/răspunsuri) — modelul obișnuit în handlere.

## De ce conteaza

Codificarea/decodificarea JSON este fundamentală pentru practic toate dezvoltarea web Go — API-urile REST, microserviciile și configurația depind toate de conversia între structurile Go și JSON.

Pachetul `encoding/json` (biblioteca standard, fără dependențe) este instrumentul standard, iar înțelegerea sa aprofundată este cunoștință esențială zilnică: cum funcționează marshaling/unmarshaling, regula critică că **doar câmpurile exportate sunt serializate**, și în special **etichetele struct** (controlând numele cheii JSON cu `json:"..."`, `omitempty` pentru a sări peste valorile goale, `-` pentru a exclude) care sunt necesare pentru a respecta convențiile API din lumea reală, cum ar fi snake_case.

A ști să transmiteți un pointer la `Unmarshal`, să gestionați JSON dinamic prin maps/`interface{}` (cu observația că numerele JSON se decodifică în `float64`), și a utiliza streaming `Encoder`/`Decoder` pentru corpurile HTTP acoperă nevoile practice ale construirii API-urilor.

Este o parte constantă și practică a muncii backend Go.