Bạn encode/decode JSON trong Go như thế nào?

Question

Accepted Answer

Package **`encoding/json`** của thư viện chuẩn Go xử lý việc serialize (marshaling) và deserialize (unmarshaling) JSON, ánh xạ giữa các struct Go và JSON. **Struct tag** kiểm soát việc đặt tên trường, và nó là xương sống của hầu hết các web API Go.

## Marshaling: struct Go → JSON

```go
type User struct {
    Name    string `json:"name"`              // tag ánh xạ trường tới một key JSON
    Email   string `json:"email"`
    Age     int    `json:"age,omitempty"`     // omitempty → bỏ qua nếu zero/rỗng
    private string                             // unexported → KHÔNG serialize (viết thường)
}

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` chuyển một struct thành các byte JSON. **Chỉ các trường exported (viết hoa) được serialize** — các trường unexported bị bỏ qua.

## Vai trò của struct tag

```go
type Product struct {
    ID    int    `json:"id"`                  // → "id"
    Name  string `json:"product_name"`        // → "product_name" (đổi tên)
    Price float64 `json:"price,omitempty"`     // bỏ qua nếu 0
    Notes string `json:"-"`                    // "-" → KHÔNG BAO GIỜ serialize trường này
}
```

Không có tag, các key JSON mặc định theo đúng tên trường (viết hoa). Tag cho phép bạn kiểm soát tên key JSON, bỏ qua các giá trị rỗng (`omitempty`), và loại trừ các trường hoàn toàn (`-`) — thiết yếu để khớp các quy ước API (ví dụ JSON snake_case).

## Unmarshaling: JSON → struct Go

```go
jsonData := []byte(`{"name":"Bob","email":"bob@x.com","age":25}`)

var user User
err := json.Unmarshal(jsonData, &user)   // truyền một CON TRỎ để điền vào nó
if err != nil { log.Fatal(err) }
fmt.Println(user.Name)   // "Bob"
```

`json.Unmarshal` parse JSON vào một struct — bạn phải truyền một **con trỏ** để nó có thể điền vào struct. Các trường được khớp theo tag/tên (không phân biệt hoa thường).

## Làm việc với JSON không biết/động

```go
// khi cấu trúc không biết, unmarshal vào một map hoặc interface{}
var result map[string]interface{}
json.Unmarshal(data, &result)
name := result["name"].(string)        // type-assert giá trị (số JSON → float64!)
```

## Streaming với Encoder/Decoder (cho I/O)

```go
// encode trực tiếp tới một io.Writer (ví dụ một HTTP response) — hiệu quả, không buffer trung gian
json.NewEncoder(w).Encode(user)

// decode trực tiếp từ một io.Reader (ví dụ một HTTP request body)
json.NewDecoder(r.Body).Decode(&user)
```

Với các web server, `Encoder`/`Decoder` làm việc trực tiếp với các stream (request/response body) — pattern phổ biến trong các handler.

## Tại sao điều này quan trọng

Encode/decode JSON là nền tảng cho hầu hết mọi phát triển web Go — REST API, microservice, và cấu hình đều dựa vào việc chuyển đổi giữa các struct Go và JSON.

Package `encoding/json` (thư viện chuẩn, không phụ thuộc) là công cụ chuẩn, và hiểu nó tốt là kiến thức hàng ngày thiết yếu: cách marshaling/unmarshaling hoạt động, quy tắc then chốt rằng **chỉ các trường exported được serialize**, và đặc biệt là **struct tag** (kiểm soát tên key JSON với `json:"..."`, `omitempty` để bỏ qua các giá trị rỗng, `-` để loại trừ) vốn cần thiết để khớp các quy ước API thực tế như snake_case.

Biết phải truyền một con trỏ cho `Unmarshal`, xử lý JSON động qua map/`interface{}` (với cạm bẫy rằng số JSON decode thành `float64`), và dùng `Encoder`/`Decoder` streaming cho các HTTP body bao quát các nhu cầu thực tế khi xây dựng API.

Đây là một phần thực tế, thường trực của công việc backend Go.