Go में आप JSON को encode/decode कैसे करते हैं?

Question

Accepted Answer

Go की standard library का **`encoding/json`** package JSON serialization (marshaling) और deserialization (unmarshaling) को संभालता है, जो Go structs और JSON के बीच mapping करता है। **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 default रूप से सटीक (capitalized) field नाम होती हैं। Tags आपको JSON key नाम नियंत्रित करने, empty values को छोड़ने (`omitempty`), और fields को पूरी तरह बाहर रखने (`-`) देते हैं — API परंपराओं से मेल खाने के लिए आवश्यक (जैसे 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 करता है — आपको एक **pointer** पास करना होगा ताकि यह struct को populate कर सके। Fields tag/नाम द्वारा मिलाए जाते हैं (case-insensitively)।

## अज्ञात/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 में आम पैटर्न।

## यह क्यों महत्वपूर्ण है

JSON encoding/decoding वस्तुतः सभी Go web विकास के लिए बुनियादी है — REST APIs, microservices, और configuration सभी Go structs और JSON के बीच रूपांतरण पर निर्भर करते हैं।

`encoding/json` package (standard library, कोई dependency नहीं) मानक उपकरण है, और इसे अच्छी तरह समझना आवश्यक रोज़मर्रा का ज्ञान है: marshaling/unmarshaling कैसे काम करते हैं, महत्वपूर्ण नियम कि **केवल exported fields serialize होते हैं**, और खासकर **struct tags** (`json:"..."` के साथ JSON key नाम नियंत्रित करना, empty values छोड़ने के लिए `omitempty`, बाहर रखने के लिए `-`) जो snake_case जैसी वास्तविक-दुनिया की API परंपराओं से मेल खाने के लिए आवश्यक हैं।

`Unmarshal` को एक pointer पास करना, maps/`interface{}` के माध्यम से dynamic JSON संभालना (इस gotcha के साथ कि JSON numbers `float64` में decode होते हैं), और HTTP bodies के लिए streaming `Encoder`/`Decoder` का उपयोग करना जानना APIs बनाने की व्यावहारिक ज़रूरतों को कवर करता है।

यह Go backend काम का एक निरंतर, व्यावहारिक हिस्सा है।