Kako kodirate/dekodirate JSON v Go-u?

Question

Accepted Answer

Go-ov paket standardne knjižnice **`encoding/json`** upravlja s serijalizacijo JSON-a (marshaling) in deserijalizacijo (unmarshaling), preslikavami med Go strukturami in JSON-om. **Oznamki struktur** nadzirajo poimenovanje polj in predstavljajo osnovo večine Go spletnih API-jev.

## Marshaling: Go struktura → 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` pretvori strukturo v JSON bajte. **Samo izvožena (velika črka) polja se serijalizirajo** — neivožena polja se preskočijo.

## Vloga oznamkov struktur

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

Brez oznamkov so JSON ključi privzeto natanko (velika črka) ime polja. Oznamki vam omogočajo nadzor imena JSON ključa, izpustitev praznih vrednosti (`omitempty`) in izključitev polj v celoti (`-`) — bistveno za ujemanje s konvencijami API-ja (npr. snake_case JSON).

## Unmarshaling: JSON → Go struktura

```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` razčleni JSON v strukturo — morate biti **kazalec** prosljeđen, da lahko zapolni strukturo. Polja so usklađena po oznakah/imenih (ne glede na velikost črk).

## Delo z neznanim/dinamičnim JSON-om

```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 s kodniki/dekodniki (za 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)
```

Za spletne strežnike `Encoder`/`Decoder` delujejo neposredno s tokovi (telesa zahtev/odgovorov) — običajni vzorec v upraviteljih.

## Zakaj je to pomembno

Kodiranje/dekodiranje JSON-a je temeljno za praktično vso Go spletno razvoj — REST API-ji, mikroservisi in konfiguracija se vsi zanašajo na pretvarjanje med Go strukturami in JSON-om.

Paket `encoding/json` (standardna knjižnica, brez odvisnosti) je standardno orodje, in dobro razumevanje je bistveno vsakodnevno znanje: kako deluje marshaling/unmarshaling, kritično pravilo, da se **serijalizirajo samo izvožena polja**, in zlasti **oznamki struktur** (nadzor imena JSON ključa z `json:"..."`, `omitempty` za izpustitev praznih vrednosti, `-` za izključitev) ki so potrebni za ujemanje z konvencijami resničnih API-jev, kot je snake_case.

Znanje, kako prosljeđiti kazalec na `Unmarshal`, obravnavati dinamični JSON preko map/`interface{}` (s pasti, da se JSON številke dekodirajo v `float64`), in uporabiti streaming `Encoder`/`Decoder` za HTTP telesa pokriva praktične potrebe gradnje API-jev.

To je konstanten, praktičen del Go backend dela.