ਤੁਸੀਂ 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 ਵਿੱਚ convert ਕਰਦਾ ਹੈ। **ਸਿਰਫ਼ 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 ਤੌਰ 'ਤੇ exact (capitalized) field name ਹੁੰਦਾ ਹੈ। Tags ਤੁਹਾਨੂੰ JSON key name ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਦਿੰਦੇ ਹਨ, empty values ਨੂੰ omit ਕਰਨ ਦਿੰਦੇ ਹਨ (`omitempty`), ਅਤੇ fields ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ exclude ਕਰਨ ਦਿੰਦੇ ਹਨ (`-`) — API conventions ਨਾਲ match ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ (ਜਿਵੇਂ 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** pass ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਤਾਂਜੋ ਇਹ struct ਨੂੰ populate ਕਰ ਸਕੇ। Fields ਨੂੰ tag/name ਦੁਆਰਾ match ਕੀਤਾ ਜਾਂਦਾ ਹੈ (case-insensitively)।

## Unknown/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!)
```

## Streaming ਨਾਲ 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)
```

Web servers ਲਈ, `Encoder`/`Decoder` streams (request/response bodies) ਦੇ ਨਾਲ directly ਕੰਮ ਕਰਦੇ ਹਨ — handlers ਵਿੱਚ common pattern ਹੈ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

JSON encoding/decoding ਲਗਭਗ ਸਾਰੀ Go web development ਲਈ fundamental ਹੈ — REST APIs, microservices, ਅਤੇ configuration ਸਾਰੇ Go structs ਅਤੇ JSON ਦੇ ਵਿਚਕਾਰ convert ਕਰਨ 'ਤੇ depend ਕਰਦੇ ਹਨ।

`encoding/json` package (standard library, ਕੋਈ dependency ਨਹੀਂ) standard tool ਹੈ, ਅਤੇ ਇਸਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ: marshaling/unmarshaling ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ, ਅਹਮ ਨਿਯਮ ਕਿ **ਸਿਰਫ਼ exported fields ਨੂੰ serialize ਕੀਤਾ ਜਾਂਦਾ ਹੈ**, ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ **struct tags** (JSON key names ਨੂੰ `json:"..."` ਦੇ ਨਾਲ ਕੰਟਰੋਲ ਕਰਨਾ, `omitempty` ਨਾਲ empty values ਨੂੰ skip ਕਰਨਾ, `-` ਨਾਲ exclude ਕਰਨਾ) ਜੋ real-world API conventions ਨਾਲ match ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹਨ ਜਿਵੇਂ snake_case।

`Unmarshal` ਲਈ ਇੱਕ pointer pass ਕਰਨਾ ਜਾਣਨਾ, dynamic JSON ਨੂੰ maps/`interface{}` ਦੁਆਰਾ handle ਕਰਨਾ (ਇਸ gotcha ਨਾਲ ਕਿ JSON numbers `float64` ਵਿੱਚ decode ਹੁੰਦੇ ਹਨ), ਅਤੇ streaming `Encoder`/`Decoder` ਨੂੰ HTTP bodies ਲਈ ਵਰਤਣਾ APIs ਨਿਰਮਾਣ ਦੀ practical ਲੋੜ ਨੂੰ cover ਕਰਦਾ ਹੈ।

ਇਹ Go backend ਕਾਰਜ ਦਾ ਨਿਰੰਤਰ, practical ਹਿੱਸਾ ਹੈ।