Conas a dhéanann tú JSON a ionchódú/díchódú i Go?

Question

Accepted Answer

Láimhseálann pacáiste **`encoding/json`** leabharlann chaighdeánach Go an tserialization JSON (marshaling) agus an díserialization (unmarshaling), ag mapáil idir structanna Go agus JSON. Rialaíonn **struct tags** an t-ainmniú réimse, agus is é sin cnámh dromchla an chuid is mó de APIs Ghréine.

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

Aistrítear struct go baictí JSON le `json.Marshal`. **Ní shriailtear ach réimsí onnmhairithe (ceannlitrithe) amháin** — is fágtha réimsí neamhonnmhairithe ar lár.

## Ról na 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
}
```

Gan tags, is é an t-ainm réimse ceannlitrithe ceart an réamhshocrú do na heochracha JSON. Tugann tags duit srian ar an ainm eochrach JSON, fálúntais fholamh a fhágáil ar lár (`omitempty`), agus réimsí a eisiamh go hiomlán (`-`) — riachtanach do chóinbhinsiúin API a mheaitseáil (m.sh. 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"
```

Baineann `json.Unmarshal` JSON i struct — caithfidh tú **pointeoir** a roinnt ionas gur féidir leis an struct a líonadh. Meaitseálann réimsí le tag/ainm (gan idirdheal litreacha móra/beaga).

## Ag obair le JSON anaithnid/dinimiciúil

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

## Sreabhadh le Encoder/Decoder (do 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)
```

Do fhreastalaithe gréine, oibríonn `Encoder`/`Decoder` go díreach le sreabhanna (comhlachtaí iarratas/freagartha) — an patrún coitianta i láimhseálaithe.

## Cén fáth a bhíonn tábhacht ag baint dó

Is bunúsach ionchódú/díchódú JSON do bhraistint go léir práitiúla i bhforbairt Ghréine ar an ngréasán — REST APIs, microservices, agus cumraíochtaí go léir ag brath ar athrú idir structanna Go agus JSON.

Is é an pacáiste `encoding/json` (leabharlann chaighdeánach, gan spleáchas) an uirlis chaighdeánach, agus tá sé ríthábhachtach é a thuiscint go maith — conas a oibríonn marshaling/unmarshaling, an riail ríchriticiúil go **ní shriailtear ach réimsí onnmhairithe amháin**, agus go háirithe **struct tags** (srian ar na heochracha JSON le `json:"
..."`, `omitempty` fálúntais fholamh a fhágáil ar lár, `-` a eisiamh) atá ag teastáil chun coinbhinsiúin API fhíor-dhomhain a mheaitseáil ar nós snake_case.

An bhraistint go bhfuil pointeoir á roinnt agat ar `Unmarshal`, JSON dinimiciúil a láimhseáil trí léarscáileanna/`interface{}` (leis an botún go ndéantar uimhreacha JSON a dhíchódú go `float64`), agus sreabhú `Encoder`/`Decoder` d'úsáid ar chomhlachtaí HTTP a úsáid — cuimsíonn sé sin na riachtanais phraiticiúla atá i ngéim chun APIs a thógáil.

Is páirt seasmhach, phraiticiúil a bhíonn ann de obair backend Go.