Wie codierst/decodierst du JSON in Go?

Question

Accepted Answer

Das **`encoding/json`**-Paket der Go-Standardbibliothek handhabt JSON-Serialisierung (Marshaling) und Deserialisierung (Unmarshaling) und bildet eine Verbindung zwischen Go-Strukturen und JSON. **Struct-Tags** kontrollieren die Feldnamengebung und sind das Rückgrat der meisten Go-Web-APIs.

## 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` konvertiert eine Struktur in JSON-Bytes. **Nur exportierte (kapitalisierte) Felder werden serialisiert** — nicht exportierte Felder werden übersprungen.

## Die Rolle von 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
}
```

Ohne Tags entsprechen JSON-Schlüssel standardmäßig dem exakten (kapitalisierten) Feldnamen. Tags lassen dich den JSON-Schlüsselnamen kontrollieren, leere Werte auslassen (`omitempty`) und Felder vollständig ausschließen (`-`) — unverzichtbar, um API-Konventionen zu erfüllen (z. B. 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` analysiert JSON in eine Struktur — du musst einen **Zeiger** übergeben, damit es die Struktur füllen kann. Felder werden nach Tag/Name (case-insensitiv) abgeglichen.

## Arbeiten mit unbekanntem/dynamischem 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 mit Encoder/Decoder (für E/A)

```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 Webserver arbeiten `Encoder`/`Decoder` direkt mit Streams (Request-/Response-Bodies) — das häufige Muster in Handlern.

## Warum es wichtig ist

JSON-Codierung/Decodierung ist grundlegend für praktisch die gesamte Go-Webentwicklung — REST-APIs, Microservices und Konfiguration beruhen alle darauf, zwischen Go-Strukturen und JSON zu konvertieren.

Das `encoding/json`-Paket (Standardbibliothek, keine Abhängigkeit) ist das Standard-Tool, und ein gutes Verständnis dafür ist unverzichtliches Alltagswissen: wie Marshaling/Unmarshaling funktionieren, die kritische Regel, dass **nur exportierte Felder serialisiert werden**, und besonders **Struct-Tags** (die JSON-Schlüsselnamen mit `json:"..."` kontrollieren, `omitempty` um leere Werte zu überspringen, `-` zum Ausschließen), die erforderlich sind, um reale API-Konventionen wie snake_case zu erfüllen.

Zu wissen, dass man einen Zeiger an `Unmarshal` übergibt, dynamisches JSON über Maps/`interface{}` handhabt (mit der Eigenheit, dass JSON-Zahlen zu `float64` dekodiert werden) und Streaming `Encoder`/`Decoder` für HTTP-Bodies nutzt, deckt die praktischen Anforderungen beim Erstellen von APIs ab.

Es ist ein ständiger, praktischer Teil der Go-Backend-Arbeit.