તમે Go માં JSON એનકોડ/ડીકોડ કેવી રીતે કરો છો?

Question

Accepted Answer

Go ની સ્ટાન્ડર્ડ લાઇબ્રેરી **`encoding/json`** પેકેજ JSON સીરિયલાઇઝેશન (માર્શલિંગ) અને ડીસીરિયલાઇઝેશન (અનમાર્શલિંગ) ને હેન્ડલ કરે છે, Go structs અને JSON વચ્ચે મેપિંગ કરે છે. **Struct tags** ફીલ્ડ નેમિંગ નિયંત્રણ કરે છે, અને તે મોટાભાગના Go વેબ APIs ની મેરુદંડ છે।

## માર્શલિંગ: 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 (કેપિટલાઇઝ્ડ) ફીલ્ડ્સ સીરિયલાઇઝ થાય છે** — unexported ફીલ્ડ્સ છોડી દેવામાં આવે છે।

## 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 કીז ડિફોલ્ટ રીતે બરાબર (કેપિટલાઇઝ્ડ) ફીલ્ડ નામ છે। Tags તમને JSON કી નામ નિયંત્રણ કરવા, ખાલી મૂલ્યો છોડવા (`omitempty`), અને ફીલ્ડ્સ સંપૂર્ણ રીતે બાકાત રાખવા (`-`) દે છે — API કન્વેંશન્સ સાથે મેળ લાવવા માટે આવશ્યક છે (દા. ત., snake_case JSON)।

## અનમાર્શલિંગ: 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 ને પોપ્યુલેટ કરી શકે। ફીલ્ડ્સ 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 (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 એનકોડિંગ/ડીકોડિંગ ફક્ત તમામ Go વેબ ડેવલપમેન્ટ માટે મૌલિક છે — REST APIs, માઈક્રોસર્વિસેસ, અને કૉન્ફિગરેશન તમામ Go structs અને JSON વચ્ચે કન્વર્ટ કરવા પર આધાર રાખે છે।

ધ `encoding/json` પેકેજ (સ્ટાન્ડર્ડ લાઈબ્રેરી, કોઈ ડિપેન્ડન્સી નથી) સ્ટાન્ડર્ડ ટૂલ છે, અને તેને સારી રીતે સમજવું આવશ્યક અમલીકરણ જ્ઞાન છે: માર્શલિંગ/અનમાર્શલિંગ કેવી રીતે કામ કરે છે, નિર્ણાયક નિયમ કે **માત્ર exported ફીલ્ડ્સ સીરિયલાઇઝ થાય છે**, અને ખાસ કરીને **struct tags** (JSON કી નામ નિયંત્રણ કરવું `json:"..."` સાથે, `omitempty` ખાલી મૂલ્યો છોડવા માટે, `-` બાકાત રાખવા માટે) જે વાસ્તવિક-વિશ્વ API કન્વેંશન્સ જેમ snake_case સાથે મેળ લાવવા માટે જરૂરી છે।

`Unmarshal` માટે pointer પાસ કરવું જાણવું, `interface{}` અને maps દ્વારા ડાયનામિક JSON હેન્ડલ કરવું (JSON નંબર્સ `float64` માં ડીકોડ કરવાની gotcha સાથે), અને HTTP bodies માટે સ્ટ્રીમિંગ `Encoder`/`Decoder` ને વાપરવું APIs બનાવવાની વ્યવહારિક જરૂરિયાતોને આવરી લે છે।

તે Go બેકેન્ડ કાર્યનો સતત, વ્યવહારિક ભાગ છે।