Go-வில் JSON-ஐ எவ்வாறு encode/decode செய்வீர்கள்?

Question

Accepted Answer

Go-வின் standard library **`encoding/json`** package ஆனது JSON serialization (marshaling) மற்றும் deserialization (unmarshaling)-ஐ கையாளுகிறது, Go structs மற்றும் JSON-க்கு இடையே வரைபடமாக்குகிறது. **Struct tags** ஆனவை field naming-ஐ கட்டுப்படுத்துகின்றன, மேலும் இது பெரும்பாலான Go web APIs-இன் முதுகெலும்பாகும்.

## 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` ஆனது ஒரு struct-ஐ JSON bytes-ஆக மாற்றுகிறது. **exported (capitalized) fields மட்டுமே serialize செய்யப்படுகின்றன** — unexported fields தவிர்க்கப்படுகின்றன.

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

tags இல்லாமல், JSON keys ஆனவை சரியான (capitalized) field name-க்கு default ஆகும். Tags ஆனவை JSON key name-ஐ கட்டுப்படுத்தவும், empty values-ஐ தவிர்க்கவும் (`omitempty`), மற்றும் fields-ஐ முழுவதுமாக விலக்கவும் (`-`) உங்களை அனுமதிக்கின்றன — API conventions-ஐ பொருத்துவதற்கு அத்தியாவசியம் (எ.கா. 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` ஆனது JSON-ஐ ஒரு struct-ஆக parse செய்கிறது — அதை populate செய்ய நீங்கள் ஒரு **pointer**-ஐ pass செய்ய வேண்டும். Fields ஆனவை tag/name மூலம் பொருத்தப்படுகின்றன (case-insensitive ஆக).

## அறியப்படாத/dynamic JSON-உடன் வேலை செய்தல்

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

## Encoder/Decoder உடன் streaming (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)
```

web servers-க்கு, `Encoder`/`Decoder` ஆனவை நேரடியாக streams-உடன் (request/response bodies) வேலை செய்கின்றன — handlers-இல் பொதுவான pattern.

## இது ஏன் முக்கியம்

JSON encoding/decoding ஆனது கிட்டத்தட்ட அனைத்து Go web development-க்கும் அடிப்படையானது — REST APIs, microservices, மற்றும் configuration அனைத்தும் Go structs மற்றும் JSON-க்கு இடையே மாற்றுவதை நம்பியுள்ளன.

`encoding/json` package (standard library, dependency இல்லை) ஆனது நிலையான கருவியாகும், மேலும் அதை நன்கு புரிந்துகொள்வது அத்தியாவசிய அன்றாட அறிவாகும்: marshaling/unmarshaling எவ்வாறு வேலை செய்கின்றன, **exported fields மட்டுமே serialize செய்யப்படுகின்றன** என்ற முக்கிய விதி, மற்றும் குறிப்பாக **struct tags** (`json:"..."` மூலம் JSON key names-ஐ கட்டுப்படுத்துதல், empty values-ஐ தவிர்க்க `omitempty`, விலக்க `-`) ஆனவை snake_case போன்ற நிஜ-உலக API conventions-ஐ பொருத்த தேவைப்படுகின்றன.

`Unmarshal`-க்கு ஒரு pointer-ஐ pass செய்ய வேண்டும் என்பதையும், dynamic JSON-ஐ maps/`interface{}` வழியாக கையாள வேண்டும் என்பதையும் (JSON numbers ஆனவை `float64`-ஆக decode ஆகின்றன என்ற gotcha-உடன்), மற்றும் HTTP bodies-க்கு streaming `Encoder`/`Decoder`-ஐ பயன்படுத்த வேண்டும் என்பதையும் அறிவது, APIs உருவாக்குவதற்கான நடைமுறை தேவைகளை உள்ளடக்கியது.

இது Go backend வேலையின் ஒரு நிலையான, நடைமுறை பகுதியாகும்.