మీరు Go లో JSON ను ఎన్కోడ్/డీకోడ్ చేయడం ఎలా చేస్తారు?

Question

Accepted Answer

Go యొక్క ప్రామాణిక లైబ్ररీ **`encoding/json`** ప్యాకేజ్ JSON సీరియలైজేషన్ (మార్షలింగ్) మరియు డీసీరియలైజేషన్ (అన్‌మార్షలింగ్) ను నిర్వహిస్తుంది, Go structs మరియు JSON మధ్య మ్యాపింగ్ చేస్తుంది. **Struct tags** ఫీల్డ్ నామకరణను నియంత్రిస్తాయి, మరియు ఇది చాలా Go వెబ్ 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 (పెరుగుపెట్టిన) ఫీల్డ్‌లు సీరియలైజ్ చేయబడతాయి** — 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
}
```

Tags లేకుండా, JSON keys డిఫాల్ట్‌గా సరిగ్గా (పెరుగుపెట్టిన) ఫీల్డ్ పేరుకు సెట్ చేయబడతాయి. Tags మీకు 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 లోకి అన్వేషిస్తుంది — మీరు తప్పనిసరిగా **pointer** ను పాస్ చేయాలి కాబట్టి ఇది struct ను పూరించవచ్చు. ఫీల్డ్‌లు tag/name (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)
```

వెబ్ సర్వర్‌ల కోసం, `Encoder`/`Decoder` స్ట్రీమ్‌ల (request/response bodies) తో నేరుగా పనిచేస్తాయి — ఇది హ్యాండ్‌లర్‌లలో సాధారణ నమూనా.

## ఇది ఎందుకు ముఖ్యమైనది

JSON encoding/decoding Go వెబ్ డెవలपमेंट యొక్క ఎక్కువ భాగానికి ఆధారమైనది — REST APIs, microservices, మరియు configuration అన్నీ Go structs మరియు JSON మధ్య మార్పిడిపై ఆధారపడతాయి.

`encoding/json` ప్యాకేజ్ (ప్రామాణిక లైబ్రరీ, ఆధారం లేనిది) ప్రామాణిక సాధనం, మరియు దానిని బాగా అర్థం చేసుకోవడం అవసరం: మార్షలింగ్/అన్‌మార్షలింగ్ ఎలా పనిచేస్తుందో, **కేవలం exported ఫీల్డ్‌లు సీరియలైజ్ చేయబడుతున్నాయని** సమీక్ష నియమం, మరియు ప్రత్యేకించి **struct tags** (`json:"..."` తో JSON కీ పేర్లను నియంత్రించడం, ఖాళీ విలువలను దాటవేయడానికి `omitempty`, మరియు `—` కు除外 చేయడం) అవసరం snake_case వంటి నిజ-ప్రపంచ API సంప్రదాయాలను సరిపోల్చడానికి.

`Unmarshal` కు pointer ను పాస్ చేయాలని తెలుసుకోవడం, maps/`interface{}` ద్వారా dynamic JSON ని నిర్వహించడం (JSON సంఖ్యలు `float64` లోకి డీకోడ్ చేయబడిన gotcha తో), మరియు HTTP bodies కోసం streaming `Encoder`/`Decoder` ను ఉపయోగించడం APIs నిర్మాణం యొక్క ప్రకృతి అవసరాలను కవర్ చేస్తుంది.

ఇది Go backend పనిలో స్థిరమైన, ఆచరణాత్మక భాగం.