Hogyan kódolja/dekódolja a JSON-t Go-ban?

Question

Accepted Answer

A Go standard library **`encoding/json`** csomagja kezeli a JSON szerializációt (marshaling) és deszerializációt (unmarshaling), leképezve a Go struktok és a JSON közötti kapcsolatot. **Struct tag-ek** vezérlik a mezőneveket, és ez a legtöbb Go webes API gerince.

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

A `json.Marshal` egy strukturát JSON byte-okká konvertál. **Csak az exportált (nagybetűvel kezdődő) mezők szerializálódnak** — a nem exportált mezők kihagyódnak.

## A struct tag-ek szerepe

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

Tag-ek nélkül a JSON kulcsok alapértelmezésben az exakt (nagybetűvel kezdődő) mezőnévre vannak állítva. A tag-ek lehetővé teszik a JSON kulcsnév vezérlését, az üres értékek kihagyását (`omitempty`), és a mezők teljes kizárását (`-`) — elengedhetetlen az API konvenciók megfeleltetéséhez (pl. 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"
```

A `json.Unmarshal` JSON-t értelmez egy strukturává — **pointerként** kell átadni, hogy feltöltse a strukturát. A mezők tag/név alapján egyeztetődnek (nem érzékenyek a nagybetűkre).

## Ismeretlen/dinamikus JSON kezelése

```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 az Encoder/Decoder-rel (I/O-hoz)

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

Webes szerverek esetén az `Encoder`/`Decoder` közvetlenül a streamekkel (request/response body-kkal) működik — ez a gyakori minta a handler-ekben.

## Miért fontos ez

A JSON kódolás/dekódolás alapvetően szinte minden Go webes fejlesztéshez szükséges — REST API-k, mikroszolgáltatások és konfigurációk mind a Go struktok és a JSON közötti konverzión alapulnak.

Az `encoding/json` csomag (standard library, nincs függőség) a standard eszköz, és jól érteni elengedhetetlen mindennapi tudás: hogyan működik a marshaling/unmarshaling, a kritikus szabály, hogy **csak az exportált mezők szerializálódnak**, és különösen a **struct tag-ek** (`json:"..."`, `omitempty` az üres értékek kihagyásához, `-` a kizáráshoz) melyek szükségesek a valós API konvenciók, mint a snake_case megfeleltetéséhez.

Annak tudása, hogy pointert kell átadni az `Unmarshal`-nek, kezelni a dinamikus JSON-t map-okon/`interface{}`-en keresztül (azzal a csapdával, hogy a JSON számok `float64`-ként dekódolódnak), és streaming `Encoder`/`Decoder` használata HTTP body-khoz az API-k építésének gyakorlati szükségleteit lefedi.

Ez a Go backend munka állandó, gyakorlati része.