Go मध्ये JSON कोड/डीकोड कसे करायचे?

Question

Accepted Answer

Go च्या मानक लायब्ररीचे **`encoding/json`** पॅकेज JSON सीरिअलायজेशन (marshaling) आणि डीसीरिअलायजेशन (unmarshaling) हाताळते, Go structs आणि JSON मधील मॅपिंग करते. **Struct tags** फील्डच्या नामकरणावर नियंत्रण ठेवतात आणि हे बहुतेक 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 मध्ये रूपांतरित करते. **फक्त एक्सपोर्ट केलेली (बड़े अक्षरात सुरु होणारी) फील्ड सीरिअलाइज केली जातात** — अनएक्सपोर्ट केलेली फील्ड वगळली जातात.

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

टॅग्स न करता, JSON कीज डिफॉल्टरूपे अचूक (बड़े अक्षरात सुरु होणारी) फील्ड नाव असतात. टॅग्स आपल्याला JSON की नाव नियंत्रित करू देतात, रिक्त मूल्ये वगळू देतात (`omitempty`), आणि फील्ड पूर्णपणे वगळू देतात (`-`) — 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 मध्ये पार्स करते — तुम्ही **पॉइंटर** पास करणे आवश्यक आहे जेणेकरून तो struct भरू शकेल. फील्ड्स टॅग/नावानुसार जुळवले जातात (case-insensitively).

## अज्ञात/डायनामिक 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 सह स्ट्रिमिंग (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)
```

वेब सर्व्हर्ससाठी, `Encoder`/`Decoder` स्ट्रीम्स (request/response bodies) सह थेट कार्य करते — हँडलर्समध्ये सामान्य पॅटर्न.

## हे महत्वाचे का आहे

JSON encoding/decoding हे व्यावहारिकपणे सर्व Go web development साठी मूलभूत आहे — REST APIs, microservices, आणि configuration सर्व Go structs आणि JSON मध्ये रूपांतरण करण्यावर अवलंबून आहेत.

`encoding/json` पॅकेज (मानक लायब्ररी, कोणताही अवलंबित्व नाही) मानक साधन आहे, आणि ते चांगल्या प्रकारे समजून घेणे अपरिहार्य दैनंदिन ज्ञान आहे: marshaling/unmarshaling कसे कार्य करते, महत्वाचा नियम की **फक्त एक्सपोर्ट केलेली फील्ड सीरिअलाइज केली जातात**, आणि विशेषत: **struct tags** (JSON की नाव `json:"..."` सह नियंत्रित करणे, रिक्त मूल्ये वगळणे `omitempty`, वगळण्यासाठी `-`) जे वास्तविक API कन्वेंशन्स (उदा. snake_case) जुळवण्यासाठी आवश्यक आहेत.

`Unmarshal` ला पॉइंटर पास करणे आवश्यक आहे हे जाणून घेणे, maps/`interface{}` द्वारे डायनामिक JSON हाताळणे (JSON संख्या `float64` मध्ये डीकोड होतात या समस्यासह), आणि HTTP bodies साठी स्ट्रिमिंग `Encoder`/`Decoder` वापरणे API बांधण्याच्या व्यावहारिक गरजा पूर्ण करते.

हे Go backend कार्याचा सतत, व्यावहारिक भाग आहे.