`एन्कोडिंग/जेसन`

encoding/json गो स्ट्रक्चर को JSON और वापस क्रमबद्ध करने के लिए विहित पैकेज है। इसकी परंपराओं और नुकसानों को जानने से आपको एपीआई और कॉन्फ़िगरेशन फ़ाइलों पर डिबगिंग के घंटों की बचत होती है।

मार्शल और अनमर्शल

दो मुख्य कार्य:

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 - संख्याओं/बूल को स्ट्रिंग के रूप में लपेटता है (जेएस आईडी के लिए उपयोगी)।

स्ट्रीम के लिए डिकोडर/एनकोडर

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, nil)।

आम त्रुटियों

• & को भूलना: json.Unmarshal(data, v) कुछ भी नहीं भरता; आपको &v की आवश्यकता है।
• शून्य फ़ील्ड के साथ डिकोडिंग संरचनाएं: घबराहट से बचने के लिए, फ़ील्ड पढ़ने से पहले err जांचें।
• असंगत प्रकार: किसी संख्या को एक स्ट्रिंग में डिसेरिएलाइज़ करना या इसके विपरीत *json.UnmarshalTypeError लौटाता है।

अभ्यास

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