Kuinka koodata/dekoodata JSON Go-ohjelmointikielessä?

Question

Accepted Answer

Go:n vakiokirjaston **`encoding/json`** paketti käsittelee JSON-sarjoitusta (marshaling) ja sarjoituksen purkamista (unmarshaling), kartoittaen Go:n structien ja JSON:in välillä. **Struct-tagit** hallitsevat kentän nimeämistä, ja se on suurimman osan Go-verkkosovelluksista selkäranka.

## 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` muuntaa structin JSON-tavuiksi. **Vain viedyt (isolla kirjaimella alkavat) kentät sarjoitetaan** — viennit ilman oikeutta ohitetaan.

## Struct-tagien rooli

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

Ilman tageja JSON-avaimet oletuksena käyttävät tarkkaa (isolla kirjaimella alkavaa) kenttänimeä. Tagit antavat sinulle mahdollisuuden hallita JSON-avaimen nimeä, jättää tyhjät arvot pois (`omitempty`), ja sulkea kentät kokonaan (`-`) — olennaista API-konventioiden mukaiselle (esim. snake_case JSON) vastaamiselle.

## 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` jäsentää JSON:ia structiin — sinun on välitettävä **osoitin** jotta se voi täyttää structin. Kentät yhdistetään tagin/nimen mukaan (kirjainkoosta riippumatta).

## Tuntemattoman/dynaamisen JSON:in käsittely

```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 Encoder/Decoder:n kanssa (I/O:ta varten)

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

Verkkosovellimille `Encoder`/`Decoder` toimivat suoraan virtojen kanssa (pyynnön/vastauksen rungot) — yleinen kuvio käsittelijöissä.

## Miksi sillä on merkitystä

JSON-koodaus/dekoodaus on perustavanlaatuista käytännöllisesti kaikelle Go-verkkosovellusten kehitykselle — REST-sovellusliittymiä, mikro-palveluita ja konfiguraatiota varten kaikki luottavat Go:n structien ja JSON:in väliseen muuntamiseen.

`encoding/json` paketti (vakiokirjasto, ei riippuvuutta) on vakiotyökalu, ja sen hyvä ymmärtäminen on olennaista päivittäistä tietoa: kuinka marshaling/unmarshaling toimii, kriittinen sääntö että **vain viedyt kentät sarjoitetaan**, ja erityisesti **struct-tagit** (JSON-avaimen nimien hallinta `json:"..."`:lla, `omitempty` jotta voidaan jättää tyhjät arvot pois, `-` poissulkemiseksi) jotka tarvitaan todellisten API-konventioiden kuten snake_case:n vastaamiseksi.

Tietäminen välittää osoitin `Unmarshal`:ille, käsitellä dynaamista JSON:ia mapien/`interface{}`:n kautta (gotcha kanssa että JSON-numerot dekoodautuvat `float64`:ksi), ja käyttää streaming `Encoder`/`Decoder`:ää HTTP-rungoille kattaa sovellusliittymien rakentamisen käytännölliset tarpeet.

Se on jatkuva, käytännöllinen osa Go:n backend-työtä.