Go में सीरियलाइज़ेशन: JSON, XML, Protobuf

Go (Golang) में ऑब्जेक्ट सीरियलाइज़ेशन: JSON से Protobuf तक

सीरियलाइज़ेशन (मार्शलिंग) डेटा संरचना (ऑब्जेक्ट) को नेटवर्क पर ट्रांसमिशन या डिस्क पर सेव करने के लिए बाइट्स के अनुक्रम में बदलने की प्रक्रिया है। विपरीत प्रक्रिया डीसीरियलाइज़ेशन (अनमार्शलिंग) है। Go में, यह कार्य मानक और तृतीय-पक्ष पैकेजों द्वारा हल किया जाता है। आइए मुख्य दृष्टिकोणों पर नज़र डालें।

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

सबसे लोकप्रिय तरीका। सीरियलाइज़ेशन के लिए encoding/json पैकेज का उपयोग किया जाता है।

बुनियादी उदाहरण

package main

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

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

func main() {    user := User{ID: 1, Name: "Alice", Email: "alice@example.com"}

    // सीरियलाइज़ेशन (Marshal)    jsonData, err := json.Marshal(user)    if err != nil {        log.Fatal(err)    }    fmt.Println(string(jsonData)) // {"id":1,"name":"Alice","email":"alice@example.com"}

    // डीसीरियलाइज़ेशन (Unmarshal)    var decoded User    err = json.Unmarshal(jsonData, &decoded)    if err != nil {        log.Fatal(err)    }    fmt.Printf("%+v", decoded) // {ID:1 Name:Alice Email:alice@example.com}}

महत्वपूर्ण स्ट्रक्चर टैग

json:"field_name" — JSON में फ़ील्ड का नाम सेट करता है
,omitempty — यदि फ़ील्ड खाली है (जैसे, खाली स्ट्रिंग, 0, nil) तो इसे छोड़ देता है
,string — संख्यात्मक फ़ील्ड के लिए स्ट्रिंग प्रतिनिधित्व को बाध्य करता है
- — सीरियलाइज़ेशन के दौरान फ़ील्ड को अनदेखा करता है

2. XML में सीरियलाइज़ेशन: `encoding/xml`

encoding/xml पैकेज समान सिद्धांत पर काम करता है, लेकिन XML टैग का उपयोग करता है।

package main

import (    "encoding/xml"    "fmt")

type Person struct {    XMLName xml.Name `xml:"person"`    Name    string   `xml:"name"`    Age     int      `xml:"age,attr"`}

func main() {    p := Person{Name: "Bob", Age: 30}    xmlData, _ := xml.MarshalIndent(p, "", "  ")    fmt.Println(string(xmlData))    // आउटपुट:    // <person age="30">    //   <name>Bob</name>    // </person>}

यह एट्रीब्यूट (,attr), नेस्टेड एलिमेंट, CDATA और नेमस्पेस को सपोर्ट करता है।

3. बाइनरी सीरियलाइज़ेशन: `encoding/gob`

gob पैकेज बाइनरी सीरियलाइज़ेशन के लिए Go का अपना फ़ॉर्मेट है। यह Go एप्लिकेशन के बीच डेटा आदान-प्रदान के लिए आदर्श है।

package main

import (    "bytes"    "encoding/gob"    "fmt"    "log")

type Data struct {    X, Y int    Label string}

func main() {    var buf bytes.Buffer    enc := gob.NewEncoder(&buf)    data := Data{X: 10, Y: 20, Label: "test"}

    // एन्कोडिंग    if err := enc.Encode(data); err != nil {        log.Fatal(err)    }

    // डिकोडिंग    var decoded Data    dec := gob.NewDecoder(&buf)    if err := dec.Decode(&decoded); err != nil {        log.Fatal(err)    }    fmt.Printf("%+v", decoded) // {X:10 Y:20 Label:test}}

gob की विशेषताएं:

प्रकारों की पूर्व पंजीकरण आवश्यक है (यदि इंटरफ़ेस का उपयोग किया जाता है)
बाइनरी डेटा के लिए JSON से अधिक कॉम्पैक्ट
अन्य भाषाओं द्वारा समर्थित नहीं (केवल Go)

4. Protocol Buffers (protobuf)

कुशल बाइनरी सीरियलाइज़ेशन के लिए Google का प्रोटोकॉल। इसके लिए protoc और protoc-gen-go प्लगइन की स्थापना आवश्यक है।

चरण 1: स्कीमा परिभाषा (`user.proto`)

syntax = "proto3";package main;

message User {  int32 id = 1;  string name = 2;  string email = 3;}

चरण 2: कोड जनरेशन

protoc --go_out=. user.proto
                
    
  पुस्तकालय में भी
  
                
                  
                 C++ कार्य अनुसूचक: TaskFlow, CronCpp, Boost.Asio
      
                
                  
                 PHP में जियोलोकेशन और मैप्स: लाइब्रेरी और टूल्स की समीक्षा
      
                
                  
                 Bull (Node.js के लिए कार्य कतार)
      
                
                  
                 Sequelize JavaScript (Node.js): पूर्ण गाइड उदाहरणों के साथ
      
                
                  
                 Swift में कार्य कतारें: GCD, OperationQueue और Swift Concurrency