Unafanyaje encode/decode ya JSON katika Go?

Question

Accepted Answer

Package ya standard library ya Go **`encoding/json`** hushughulikia serialization ya JSON (marshaling) na deserialization (unmarshaling), ikiramba kati ya Go structs na JSON. **Struct tags** hudhibiti uitaji wa field, na ndio uti wa mgongo wa APIs nyingi za web za Go.

## 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` hubadilisha struct kuwa JSON bytes. **Fields zilizo exported (zenye herufi kubwa) tu ndizo zinazo-serialize** — fields zisizo exported huachwa.

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

Bila tags, JSON keys hupewa chaguo-msingi la jina kamili la field (lenye herufi kubwa). Tags hukuwezesha kudhibiti jina la JSON key, kuacha maadili tupu (`omitempty`), na kuondoa fields kabisa (`-`) — muhimu kwa kuendana na kanuni za API (mfano, 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"
```

`json.Unmarshal` huchanganua JSON kuwa struct — lazima upitishe **pointer** ili iweze kujaza struct. Fields hulinganishwa kwa tag/jina (bila kujali herufi kubwa/ndogo).

## Kufanya kazi na JSON isiyojulikana/dynamic

```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 kwa Encoder/Decoder (kwa 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)
```

Kwa web servers, `Encoder`/`Decoder` hufanya kazi moja kwa moja na streams (request/response bodies) — mfumo wa kawaida katika handlers.

## Kwa nini ni muhimu

JSON encoding/decoding ni ya msingi kwa karibu utengenezaji wote wa web wa Go — REST APIs, microservices, na configuration zote hutegemea kubadilisha kati ya Go structs na JSON.

Package ya `encoding/json` (standard library, hakuna dependency) ndio zana ya kawaida, na kuielewa vizuri ni maarifa muhimu ya kila siku: jinsi marshaling/unmarshaling hufanya kazi, kanuni muhimu kwamba **fields zilizo exported tu ndizo zinazo-serialize**, na hasa **struct tags** (kudhibiti majina ya JSON key kwa `json:"..."`, `omitempty` kuacha maadili tupu, `-` kuondoa) ambazo zinahitajika kuendana na kanuni halisi za API kama snake_case.

Kujua kupitisha pointer kwa `Unmarshal`, kushughulikia dynamic JSON kupitia maps/`interface{}` (na tatizo kwamba JSON numbers hu-decode kuwa `float64`), na kutumia streaming `Encoder`/`Decoder` kwa HTTP bodies hufunika mahitaji ya vitendo ya kujenga APIs.

Ni sehemu ya kudumu, ya vitendo ya kazi ya backend ya Go.