Kif tikkodifika/tiddekodifika JSON f'Go?

Question

Accepted Answer

Il-pakkett **`encoding/json`** tal-librerija standard ta' Go jgħaddi s-serializzazzjoni tal-JSON (marshaling) u d-deserializzazzjoni (unmarshaling), li jimmap bejn structs Go u JSON. **Struct tags** jikkontrollawxx l-isem tal-field, u dan huwa l-mogġ tal-biċċa kbira tal-Go web APIs.

## Marshaling: struct Go → 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` jikkonverti struct f'bytes JSON. **Biss il-fields esportati (li jibdew b'ittri kbar) jiġu serializzati** — il-fields mhux esportati jiġu saltatati.

## Il-ħinijiet ta' 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
}
```

Bla tags, il-ċavii JSON jitwaqqfu għall-isem ta' field eżatt (li jibda b'ittri kbar). Tags iħallulok tikkontrolla l-isem tal-ċavii JSON, taħħalli l-valuri vojta (`omitempty`), u teskludi fields għal kollox (`-`) — essenzjali biex taqbel ma' konvenzjonijiet ta' API (pereż. snake_case JSON).

## Unmarshaling: JSON → struct Go

```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` jipparsa JSON f'struct — trid tippassja **pointer** sabiex ikun jista' jmollja l-struct. Il-fields jimmatchjaw bit-tag/isem (insensitiv għall-ittri kbar/żgħar).

## Jaħdem ma' JSON mhux magħruf/dinamiku

```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 b'Encoder/Decoder (għal 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)
```

Għall-web servers, `Encoder`/`Decoder` jaħdmu direttament ma' streams (request/response bodies) — il-mudell komuni fil-handlers.

## Għaliex dan huwa importanti

L-encoding/decoding tal-JSON huwa fundamentali għal praktikament l-iżviluppi web Go kollu — REST APIs, microservices, u konfigurazzjoni huma l-kulħadd jiddependu fuq il-konverżjoni bejn structs Go u JSON.

Il-pakkett `encoding/json` (librerija standard, l-ebda dipendenza) huwa l-għodda standard, u l-fehim tajjib tiegħu huwa għarfien essenzjali ta' kuljum: kif jaħdmu marshaling/unmarshaling, ir-regola kritikal li **biss il-fields esportati jiġu serializzati**, u speċjalment **struct tags** (tikkontrollawxx ismijiet tal-ċavii JSON b' `json:"..."`, `omitempty` biex taħħalli valuri vojta, `-` biex teskludi) li huma meħtieġa biex taqbel ma' konvenzjonijiet ta' API reali bħal snake_case.

Nigħu tippassa pointer għal `Unmarshal`, tġaddi JSON dinamiku permezz ta' mapep/`interface{}` (b'ir-realizzazzjoni li numri JSON jiġu dekodifikati f' `float64`), u tuża l-streaming `Encoder`/`Decoder` għal HTTP bodies jkopru l-ħtiġijiet prattiċi tal-bini ta' APIs.

Dan huwa parti kostanti u prattiċa tal-ħidma backend Go.