Kako kodirate/dekodirate JSON u Go-u?

Question

Accepted Answer

Go-ev standardni paket **`encoding/json`** upravlja JSON serijalizacijom (marshaling) i deserijalizacijom (unmarshaling), mapira između Go struktura i JSON-a. **Struct tagovi** kontroliraju imenovanje polja, i to je osnova većine Go web API-ja.

## 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` pretvara strukturu u JSON bajtove. **Samo izvozna (velika) polja su serijalizirana** — nevozna polja su preskočena.

## Uloga struct tagova

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

Bez tagova, JSON ključevi zadano koriste točno (velik) naziv polja. Tagovi vam omogućuju kontrolu JSON ključa, izostavljanje praznih vrijednosti (`omitempty`) i isključivanje polja sasvim (`-`) — ključno za podudaranje API konvencija (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` parsira JSON u strukturu — morate proslijediti **pokazivač** kako bi mogao populirati strukturu. Polja se podudaraju po tagu/imenu (bez razlike između malih i velikih slova).

## Rad s nepoznatim/dinamičkim 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 Encoder/Decoder (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 web poslužitelje, `Encoder`/`Decoder` rade direktno sa streamovima (zahtjev/odgovor tijela) — česti obrazac u handlersima.

## Zašto je važno

JSON kodiranje/dekodiranje je temeljno za praktički svu Go web razvoj — REST API-je, mikrousluge i konfiguraciju — sve se oslanja na pretvaranje između Go struktura i JSON-a.

Paket `encoding/json` (standardna biblioteka, bez ovisnosti) je standardni alat, i dobro ga razumijevanje je ključno svakodnevno znanje: kako funkcioniraju marshaling/unmarshaling, kritično pravilo da **su samo izvozna polja serijalizirana**, i posebno **struct tagovi** (kontroliranje JSON ključnih imena s `json:"..."`, `omitempty` za preskakanje praznih vrijednosti, `-` za isključivanje) koji su potrebni za podudaranje stvarnih API konvencija poput snake_case.

Znanje da trebate proslijediti pokazivač na `Unmarshal`, rukovati dinamičkim JSON-om preko mapa/`interface{}` (s napomenom da JSON brojevi dekodiraju u `float64`), i koristiti streaming `Encoder`/`Decoder` za HTTP tijela pokriva praktične potrebe izgradnje API-ja.

To je stalan, praktičan dio Go backend rada.