Go (Golang) में ऑब्जेक्ट सीरियलाइज़ेशन: JSON, XML, Gob और Protocol Buffers

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

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

1. बिल्ट-इन पैकेज encoding/json

Go में सीरियलाइज़ेशन का सबसे लोकप्रिय तरीका। JSON मानव-पठनीय और क्रॉस-प्लेटफ़ॉर्म फॉर्मेट है। encoding/json पैकेज Marshal और Unmarshal फंक्शन प्रदान करता है।

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"}

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

    // डीसीरियलाइज़ेशन
    var decoded User
    err = json.Unmarshal(jsonData, &decoded)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", decoded)
}

खास बातें:

• फ़ील्ड नाम सेट करने के लिए स्ट्रक्चर टैग का सपोर्ट।
• स्लाइस, मैप और नेस्टेड स्ट्रक्चर के साथ काम करता है।
• बाइनरी फॉर्मेट से धीमा, लेकिन डीबगिंग के लिए सुविधाजनक।
• साइक्लिक रेफरेंस को सपोर्ट नहीं करता।

2. encoding/xml — XML सीरियलाइज़ेशन

XML का उपयोग SOAP, RSS और कॉन्फ़िगरेशन फ़ाइलों में होता है। encoding/xml पैकेज JSON की तरह ही काम करता है, लेकिन xml टैग के साथ।

type Book struct {
    Title  string `xml:"title"`
    Author string `xml:"author"`
    Pages  int    `xml:"pages,attr"`
}

func main() {
    book := Book{Title: "Go in Action", Author: "William Kennedy", Pages: 500}
    xmlData, _ := xml.MarshalIndent(book, "", "  ")
    fmt.Println(string(xmlData))
    // <Book pages="500">
    //   <title>Go in Action</title>
    //   <author>William Kennedy</author>
    // </Book>
}

कब उपयोग करें:

• पुराने सिस्टम (legacy) के साथ इंटीग्रेशन।
• सख्त स्कीमा (XSD) की ज़रूरत हो।
• डॉक्यूमेंट-ओरिएंटेड डेटा।

3. encoding/gob — Go का नेटिव बाइनरी फॉर्मेट

encoding/gob पैकेज विशेष रूप से Go के लिए बनाया गया है। यह डेटा को बाइनरी फॉर्मेट में कुशलतापूर्वक एनकोड करता है और जटिल टाइप (इंटरफ़ेस, चैनल, फंक्शन — सीमाओं के साथ) को सपोर्ट करता है।

import "encoding/gob"

type Task struct {
    ID     int
    Status string
}

func main() {
    var network bytes.Buffer
    enc := gob.NewEncoder(&network)
    dec := gob.NewDecoder(&network)

    task := Task{ID: 42, Status: "done"}
    err := enc.Encode(task)
    if err != nil {
        log.Fatal(err)
    }

    var restored Task
    err = dec.Decode(&restored)
    fmt.Println(restored) // {42 done}
}

फायदे:

• तेज़ गति और कॉम्पैक्ट साइज़।
• ऑटोमैटिक टाइप रजिस्ट्रेशन।
• साइक्लिक स्ट्रक्चर का सपोर्ट।

नुकसान: दूसरी भाषाओं के साथ असंगत।

4. Protocol Buffers (protobuf) — तेज़ बाइनरी सीरियलाइज़ेशन

Google द्वारा विकसित। इसमें .proto फ़ाइल में स्कीमा परिभाषित करना और protoc के ज़रिए कोड जनरेट करना होता है। google.golang.org/protobuf लाइब्रेरी आधुनिक मानक है।

// user.proto
// syntax = "proto3";
// message User {
//   int32 id = 1;
//   string name = 2;
//   string email = 3;
// }

// जनरेटेड कोड: user.pb.go

func main() {
    user := &pb.User{Id: 1, Name: "