Hur kodar/avkodar du JSON i Go?

Question

Accepted Answer

Gos standardbibliotek **`encoding/json`** hanterar JSON-serialisering (marshaling) och deserialisering (unmarshaling), och mappar mellan Go-strukturer och JSON. **Struct-taggar** styr fältnamngivningen, och det är ryggraden i de flesta Go-webb-API:er.

## Marshaling: Go-struktur → 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` konverterar en struktur till JSON-bytes. **Endast exporterade (stora bokstäver) fält serialiseras** — icke-exporterade fält hoppas över.

## Struct-taggarnas roll

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

Utan taggar får JSON-nycklar som standard exakt (stora bokstäver) fältnamnet. Taggar låter dig styra JSON-nyckelnamnet, utelämna tomma värden (`omitempty`) och utesluta fält helt (`-`) — väsentligt för att matcha API-konventioner (t.ex. snake_case JSON).

## Unmarshaling: JSON → Go-struktur

```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` tolkar JSON in i en struktur — du måste skicka en **pekare** så att den kan fylla i strukturen. Fält matchas efter tagg/namn (skiftlägesokänsligt).

## Arbeta med okänd/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 (för 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)
```

För webbservrar fungerar `Encoder`/`Decoder` direkt med strömmar (request/response-bodies) — det vanliga mönstret i hanterare.

## Varför det spelar roll

JSON-kodning/avkodning är grundläggande för praktiskt taget all Go-webbutveckling — REST-API:er, mikrotjänster och konfiguration förlitar sig alla på att konvertera mellan Go-strukturer och JSON.

`encoding/json`-paketet (standardbibliotek, inget beroende) är standardverktyget, och att förstå det väl är väsentlig vardaglig kunskap: hur marshaling/unmarshaling fungerar, den kritiska regeln att **endast exporterade fält serialiseras**, och särskilt **struct-taggar** (som styr JSON-nyckelnamn med `json:"..."`, `omitempty` för att hoppa över tomma värden, `-` för att utesluta) som är nödvändiga för att matcha verklig API-konventioner som snake_case.

Att veta att man ska skicka en pekare till `Unmarshal`, hantera dynamisk JSON via maps/`interface{}` (med fallet att JSON-tal avkodas till `float64`), och använd streaming `Encoder`/`Decoder` för HTTP-bodies täcker de praktiska behoven för att bygga API:er.

Det är en konstant, praktisk del av Go-backend-arbete.