Go में JSON के साथ काम करना: डेटा पार्सिंग और सीरियलाइज़ेशन

Go में JSON के साथ काम करने का परिचय

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

सीरियलाइजेशन और डिसीरियलाइजेशन की मूल बातें

सीरियलाइजेशन Go डेटा स्ट्रक्चर (जैसे, स्ट्रक्ट या स्लाइस) को JSON स्ट्रिंग में बदलने की प्रक्रिया है। डिसीरियलाइजेशन उल्टी प्रक्रिया है — JSON को Go स्ट्रक्चर में बदलना।

सीरियलाइजेशन (मार्शल)

सीरियलाइजेशन के लिए, फंक्शन json.Marshal() का उपयोग किया जाता है। यह एक Go वैल्यू लेता है और JSON प्रतिनिधित्व के साथ एक बाइट स्लाइस ([]byte) लौटाता है।

package main

import (    "encoding/json"    "fmt")

type User struct {    Name  string `json:"name"`    Age   int    `json:"age"`    Email string `json:"email,omitempty"`}

func main() {    user := User{Name: "Alexey", Age: 30, Email: "alex@example.com"}    jsonData, err := json.Marshal(user)    if err != nil {        fmt.Println("Serialization error:", err)        return    }    fmt.Println(string(jsonData))    // Output: {"name":"Alexey","age":30,"email":"alex@example.com"}

टैग json:"field_name" पर ध्यान दें। वे आपको JSON में कुंजी नामों को नियंत्रित करने की अनुमति देते हैं, साथ ही omitempty जैसे विकल्प जोड़ सकते हैं (यदि फील्ड खाली है तो इसे छोड़ दें)।

डिसीरियलाइजेशन (अनमार्शल)

JSON को Go स्ट्रक्चर में पार्स करने के लिए, फंक्शन json.Unmarshal() का उपयोग किया जाता है। यह एक बाइट स्लाइस और उस स्ट्रक्चर का पॉइंटर लेता है जिसमें डेटा लिखा जाना चाहिए।

func main() {    jsonString := `{"name":"Maria","age":25,"email":"maria@example.com"}`    var user User    err := json.Unmarshal([]byte(jsonString), &user)    if err != nil {        fmt.Println("Parsing error:", err)        return    }    fmt.Printf("Name: %s, Age: %d, Email: %s", user.Name, user.Age, user.Email)}

महत्वपूर्ण: स्ट्रक्चर पूर्व-निर्धारित होना चाहिए, और इसके फील्ड्स JSON कुंजियों (टैग को ध्यान में रखते हुए) के अनुरूप होने चाहिए।

मनमाने JSON ऑब्जेक्ट्स के साथ काम करना

कभी-कभी JSON संरचना पहले से ज्ञात नहीं होती या बहुत जटिल होती है। ऐसे मामलों में, आप map[string]interface{} या interface{} का उपयोग कर सकते हैं।

map[string]interface{} का उपयोग करना

func main() {    jsonString := `{"name":"Ivan","age":35,"address":{"city":"Moscow","street":"Lenina"}}`    var result map[string]interface{}    err := json.Unmarshal([]byte(jsonString), &result)    if err != nil {        fmt.Println("Error:", err)        return    }    fmt.Println(result["name"]) // Ivan    fmt.Println(result["age"])  // 35 (type float64)    // For nested objects, type assertion is needed    address := result["address"].(map[string]interface{})    fmt.Println(address["city"]) // Moscow}

इस दृष्टिकोण का नुकसान मैन्युअल टाइप एशर्शन (.(map[string]interface{})) की आवश्यकता है, जो टाइप मेल न खाने पर पैनिक का कारण बन सकता है।

json.RawMessage का उपयोग करना

यदि आपको JSON के कुछ भाग के पार्सिंग को स्थगित करने की आवश्यकता है, तो json.RawMessage का उपयोग करें। यह आपको पहले मुख्य संरचना को पार्स करने और फिर नेस्टेड डेटा को अलग से प्रोसेस करने की अनुमति देता है।

type Response struct {    Status string          `json:"status"`    Data   json.RawMessage `json:"data"`}

func main() {    jsonString := `{"status":"ok","data":{"user":"Peter","score":100}}`    var resp Response    json.Unmarshal([]byte(jsonString), &resp)

    // Now Data can be parsed separately    var userData map[string]interface{}    json.Unm
```

**Note:** The code block in the original input was incomplete (cut off at `json.Unm`). I have preserved it exactly as it was in the source.