`ఎన్‌కోడింగ్/json`

encoding/json అనేది గో స్ట్రక్ట్‌లను JSONకి మరియు వెనుకకు సీరియలైజ్ చేయడానికి కానానికల్ ప్యాకేజీ. దాని సంప్రదాయాలు మరియు ఆపదలను తెలుసుకోవడం వలన APIలు మరియు కాన్ఫిగరేషన్ ఫైల్‌లలో మీరు గంటల కొద్దీ డీబగ్గింగ్ చేయడం ఆదా అవుతుంది.

మార్షల్ మరియు అన్మార్షల్

రెండు ప్రధాన విధులు:

data, err := json.Marshal(v)      // Go → []byte JSON
err = json.Unmarshal(data, &v)    // JSON → Go (pass a pointer!)

type User struct {
    Name  string
    Email string
}

u := User{Name: "Ada", Email: "ada@example.com"}
b, _ := json.Marshal(u)
fmt.Println(string(b))
// {"Name":"Ada","Email":"ada@example.com"}

var back User
_ = json.Unmarshal(b, &back)

ఇండెంట్ అవుట్‌పుట్ కోసం (మానవుడు చదవగలిగేది) json.MarshalIndent(v, "", " ")ని ఉపయోగించండి.

ఎగుమతి చేసిన ఫీల్డ్‌లు మాత్రమే

json.Marshal ఎగుమతి చేసిన ఫీల్డ్‌లను మాత్రమే సీరియలైజ్ చేస్తుంది (పెద్ద అక్షరం). ప్రైవేట్ ఫీల్డ్‌లు విస్మరించబడ్డాయి నిశ్శబ్దంగా:

type U struct {
    Name string // exported → serialized
    age  int    // private → ignored
}

నిర్మాణ ట్యాగ్‌లు: పేరు మరియు ఎంపికలను నియంత్రించడం

json:"..." ట్యాగ్‌లు అవుట్‌పుట్‌లో పేరు, మినహాయింపు మరియు రకాలను నియంత్రిస్తాయి:

type User struct {
    Name    string `json:"name"`                    // rename
    Email   string `json:"email,omitempty"`         // omit if zero value
    Private string `json:"-"`                       // never serialized
    ID      int    `json:"id,string"`               // number as string
}

ఎక్కువగా ఉపయోగించే ఎంపికలు:

• ,omitempty — సున్నా విలువ (0, "", నిల్, ఖాళీ స్లైస్/మ్యాప్) అయితే ఫీల్డ్‌ను వదిలివేస్తుంది.
• ,- — ఎప్పుడూ సీరియల్ చేయబడలేదు/డీరియలైజ్ చేయబడలేదు.
• ,string — సంఖ్యలు/బూల్‌లను స్ట్రింగ్‌లుగా చుట్టేస్తుంది (JS IDలకు ఉపయోగపడుతుంది).

స్ట్రీమ్‌ల కోసం డీకోడర్/ఎన్‌కోడర్

io.Reader/io.Writer (HTTP బాడీ, భారీ ఫైల్‌లు)తో పని చేస్తున్నప్పుడు మెమరీలో ఉన్న అన్నింటినీ లోడ్ చేయడానికి బదులుగా Decoder మరియు Encoderని ఉపయోగించండి:

dec := json.NewDecoder(resp.Body)
var users []User
if err := dec.Decode(&users); err != nil {
    return err
}

enc := json.NewEncoder(os.Stdout)
enc.SetIndent("", "  ")
_ = enc.Encode(users)

Decoder కూడా స్ట్రీమింగ్ పీస్-బై-పీస్ పార్సింగ్ కోసం dec.Token()కి మరియు ఊహించని కీలతో JSONని తిరస్కరించడానికి dec.DisallowUnknownFields()కి మద్దతు ఇస్తుంది (ఇన్‌పుట్ ధ్రువీకరణకు ఉపయోగపడుతుంది).

సాధారణ మ్యాప్‌లు మరియు any

మీకు స్కీమా తెలియకుంటే, map[string]anyలోకి డీరియలైజ్ చేయండి:

var v map[string]any
_ = json.Unmarshal(data, &v)
fmt.Println(v["name"])

విలువలు డైనమిక్ రకాలను కలిగి ఉంటాయి (string, float64 సంఖ్యల కోసం, []any, map[string]any, bool, AGY2TOK_IN_LINE_1).

సాధారణ లోపాలు

• మర్చిపోవడం &: json.Unmarshal(data, v) దేనినీ నింపదు; మీకు &v అవసరం.
• నిల్ ఫీల్డ్‌లతో డీకోడింగ్ స్ట్రక్ట్స్: భయాందోళనలను నివారించడానికి, ఫీల్డ్‌లను చదవడానికి ముందు errని తనిఖీ చేయండి.
• అనుకూల రకాలు: సంఖ్యను స్ట్రింగ్‌గా మార్చడం లేదా దానికి విరుద్ధంగా *json.UnmarshalTypeErrorని అందిస్తుంది.

వ్యాయామాలు

type U struct {
  name string
}
b, _ := json.Marshal(U{name: "Ada"})
fmt.Println(string(b))