Go (Golang) में JSON प्रोसेसिंग: encoding/json और विकल्प

Go (Golang) में JSON प्रोसेसिंग: बुनियादी से उन्नत तकनीकों तक

Go (Golang) JSON के साथ काम करने के लिए एक शक्तिशाली और सहज टूलसेट प्रदान करता है। मानक लाइब्रेरी encoding/json 95% कार्यों को कवर करती है, और उच्च-लोड परियोजनाओं के लिए अधिक प्रदर्शनकारी विकल्प मौजूद हैं। इस लेख में, हम Go में JSON प्रोसेसिंग के सभी पहलुओं को कवर करेंगे: बुनियादी सीरियलाइज़ेशन से लेकर कस्टम पार्सर और ऑप्टिमाइज़ेशन तक।

1. मूल बातें: मानक लाइब्रेरी encoding/json

Go में, JSON को encoding/json पैकेज के माध्यम से संसाधित किया जाता है। मुख्य संचालन हैं मार्शलिंग (JSON में सीरियलाइज़ेशन) और अनमार्शलिंग (JSON से डीसीरियलाइज़ेशन)।

1.1. मार्शलिंग (struct → JSON)

Go स्ट्रक्चर को JSON में बदलने के लिए json.Marshal() फ़ंक्शन का उपयोग किया जाता है:

package main

import (    "encoding/json"    "fmt"    "log")

type User struct {    Name  string `json:"name"`    Age   int    `json:"age"`    Email string `json:"email,omitempty"` // omitempty - खाली होने पर छोड़ें}

func main() {    user := User{        Name:  "इवान पेत्रोव",        Age:   30,        Email: "ivan@example.com",    }

    jsonData, err := json.Marshal(user)    if err != nil {        log.Fatal(err)    }

    fmt.Println(string(jsonData))    // {"name":"इवान पेत्रोव","age":30,"email":"ivan@example.com"}}

महत्वपूर्ण: स्ट्रक्चर फ़ील्ड एक्सपोर्ट करने योग्य होने चाहिए (बड़े अक्षर से शुरू)। json:"fieldname" टैग JSON में फ़ील्ड के नामकरण को नियंत्रित करते हैं।

1.2. अनमार्शलिंग (JSON → struct)

रिवर्स रूपांतरण के लिए json.Unmarshal() का उपयोग किया जाता है:

func main() {    jsonString := `{"name":"अन्ना","age":25,"email":"anna@mail.com"}`        var user User    err := json.Unmarshal([]byte(jsonString), &user)    if err != nil {        log.Fatal(err)    }

    fmt.Printf("नाम: %s, आयु: %d", user.Name, user.Age)    // नाम: अन्ना, आयु: 25}

2. नेस्टेड स्ट्रक्चर और ऐरे के साथ काम करना

JSON में अक्सर नेस्टेड ऑब्जेक्ट और ऐरे होते हैं। Go में, यह नेस्टेड स्ट्रक्चर और स्लाइस में मैप होता है:

type Address struct {    City    string `json:"city"`    Street  string `json:"street"`    ZipCode string `json:"zip_code"`}

type Company struct {    Name      string    `json:"name"`    Employees []User    `json:"employees"`    Address   Address   `json:"address"`}

func main() {    companyJSON := `{        "name": "TechCorp",        "employees": [            {"name":"ओलेग","age":28,"email":"oleg@tech.com"},            {"name":"मारिया","age":32,"email":"maria@tech.com"}        ],        "address": {            "city": "मॉस्को",            "street": "टावर्सकाया, 10",            "zip_code": "101000"        }    }`

    var company Company    json.Unmarshal([]byte(companyJSON), &company)    fmt.Printf("कंपनी: %s, शहर: %s, कर्मचारी: %d",        company.Name, company.Address.City, len(company.Employees))}

3. उन्नत तकनीकें

3.1. कस्टम सीरियलाइज़ेशन (Marshaler/Unmarshaler इंटरफ़ेस)

कभी-कभी यह नियंत्रित करने की आवश्यकता होती है कि कोई प्रकार JSON में कैसे रूपांतरित होता है। इसके लिए json.Marshaler और json.Unmarshaler इंटरफ़ेस लागू किए जाते हैं:

type CustomTime struct {    time.Time}

const layout = "2006-01-02T15:04:05Z"

func (ct CustomTime) MarshalJSON() ([]byte, error) {    return json.Marshal(ct.Format(layout))}

func (ct *CustomTime) UnmarshalJSON(data []byte) error {    var s string    if err := json.Unmarshal(data, &s); err != nil {        return err    }    t, err := time.Parse(layout, s)    if err != nil {        return err    }    ct.Time = t    return nil}

type Event struct {    Title string     `json:"title"`    Date  CustomTime `js