Hvordan koder/dekoder du JSON i Go?

Question

Accepted Answer

Gos standardbibliotek **`encoding/json`** -pakken håndterer JSON-serialisering (marshaling) og deserialisering (unmarshaling), og kartlegger mellom Go structs og JSON. **Struct tags** kontrollerer feltnavngiving, og det er ryggraden i de fleste Go web-APIer.

## 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` konverterer en struct til JSON-bytes. **Bare eksporterte (store bokstaver) felt blir serialisert** — ikke-eksporterte felt hoppes over.

## Rollen til 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
}
```

Uten tags blir JSON-nøkler som standard det eksakte (kapitaliserte) feltnavnet. Tags lar deg kontrollere JSON-nøkkelnavn, utelate tomme verdier (`omitempty`), og ekskludere felt helt (`-`) — essensielt for å matche API-konvensjoner (f.eks. 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` analyserer JSON inn i en struct — du må sende en **pointer** slik at den kan populere structen. Felt blir matchet etter tag/navn (ikke case-sensitiv).

## Arbeiding med ukjent/dynamisk 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 med Encoder/Decoder (for 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)
```

For webservere fungerer `Encoder`/`Decoder` direkte med strømmer (request/response bodies) — det vanlige mønsteret i handlere.

## Hvorfor det betyr noe

JSON-koding/dekoding er fundamental for praktisk talt all Go web-utvikling — REST-APIer, mikrotjenester og konfigurasjoner er alle avhengige av konvertering mellom Go structs og JSON.

`encoding/json` -pakken (standardbibliotek, ingen avhengigheter) er standardverktøyet, og å forstå det godt er essensielt daglig kunnskap: hvordan marshaling/unmarshaling fungerer, den kritiske regelen at **bare eksporterte felt blir serialisert**, og spesielt **struct tags** (som kontrollerer JSON-nøkkelnavn med `json:"..."`, `omitempty` for å hoppe over tomme verdier, `-` for å ekskludere) som er nødvendig for å matche virkelige API-konvensjoner som snake_case.

Å vite at du må sende en pointer til `Unmarshal`, håndtere dynamisk JSON via maps/`interface{}` (med gotchaen at JSON-tall dekodes til `float64`), og bruke streaming `Encoder`/`Decoder` for HTTP-bodies dekker de praktiske behovene for å bygge APIer.

Det er en konstant, praktisk del av Go backend-arbeid.