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 नियन्त्रण गर्न, खाली मानहरू छोड्न (`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 गर्छ — तपाईंले **pointer** पास गर्नु पर्छ ताकि यसले struct populate गर्न सक्छ। Fields tag/name द्वारा मेल खुवाइन्छ (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 सँग 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 development को लागि मौलिक छ — REST APIs, microservices, र configuration सबै Go structs र JSON बीचको रूपान्तरणमा निर्भर हुन्छ।

`encoding/json` package (standard library, कुनै dependency छैन) मानक उपकरण हो, र यसलाई राम्रोसँग बुझ्नु आवश्यक हरेक दिनको ज्ञान: कसरी marshaling/unmarshaling काम गर्छ, आलोचनात्मक नियम कि **केवल exported fields नै serialize हुन्छन्**, र विशेष गरी **struct tags** (`json: