जाओ, मैं एक संरचना को बाइट सरणी में कैसे परिवर्तित कर सकता हूं?

Question

मेरे पास एक संरचना का एक उदाहरण है जिसे मैंने परिभाषित किया है और मैं इसे बाइट्स की सरणी में परिवर्तित करना चाहता हूं। मैंने कोशिश की [] बाइट (my_struct), लेकिन यह काम नहीं किया। इसके अलावा, मुझे binary package पर इशारा किया गया था, लेकिन मुझे यकीन नहीं है कि मुझे किस फ़ंक्शन का उपयोग करना चाहिए और मुझे इसका उपयोग कैसे करना चाहिए। एक उदाहरण की सराहना की जाएगी।

Answer 1

मुझे लगता है कि आप सी को इस तरह से संभालने की तरह कुछ चाहते हैं। ऐसा करने के लिए कोई रास्ता नहीं बनाया गया है। आपको अपनी संरचना के लिए बाइट्स से और अपने स्वयं के क्रमिकरण और deserialization को परिभाषित करना होगा। बाइनरी पैकेज आपको एन्कोड को आपके स्ट्रक्चर में फ़ील्ड बाइट्स में एन्कोड करने में मदद करेगा, जिसे आप बाइट सरणी में जोड़ सकते हैं लेकिन बाइट सरणी में लम्बाई और ऑफसेट निर्दिष्ट करने के लिए आप जिम्मेदार होंगे जो आपके स्ट्रक्चर से फ़ील्ड रखेंगे।

आपके अन्य विकल्प एन्कोडिंग पैकेजों में से एक का उपयोग करना है: http://golang.org/pkg/encoding/ जैसे गोब या जेसन।

संपादित करें:

आप एक हैश बनाने के लिए इस चाहते हैं के बाद से के रूप में आप अपनी टिप्पणी में कहते हैं कि ऐसा करने के लिए सबसे आसान तरीका है बात तो की तरह []byte(fmt.Sprintf("%v", struct)) उपयोग करते हैं: http://play.golang.org/p/yY8mSdZ_kf

Answer 2

आप इसे bson को serializing माना जाता है? http://labix.org/gobson

Answer 3

आप एक स्ट्रिंग के बजाय एक बाइट बफर का उपयोग करना चाहिए, अन्य सुझाव दिया तरीकों चर लंबाई की एक SHA1 बनाने के लिए, SHA1 मानक लंबाई 20 बाइट (160 बिट)

package main 

import (
    "crypto/sha1" 
    "fmt" 
    "encoding/binary" 
    "bytes" 
) 

type myStruct struct { 
    ID string 
    Data string 
} 

func main() { 
    var bin_buf bytes.Buffer 
    x := myStruct{"1", "Hello"} 
    binary.Write(&bin_buf, binary.BigEndian, x) 
    fmt.Printf("% x", sha1.Sum(bin_buf.Bytes())) 
} 

होना चाहिए यह अपने आप का प्रयास करें: http://play.golang.org/p/8YuM6VIlLV

यह वास्तव में एक आसान तरीका है और यह बहुत अच्छा काम करता है।

Answer 4

एक संभावित समाधान "encoding/gob" मानक पैकेज है। गोब पैकेज एक एन्कोडर/डिकोडर बनाता है जो बाइट्स की सरणी में किसी भी स्ट्रक्चर को एन्कोड कर सकता है और उसके बाद उस सरणी को स्ट्रक्चर में डीकोड कर सकता है। एक महान पोस्ट है, here।

जैसा कि अन्य ने इंगित किया है, इस तरह के पैकेज का उपयोग करना आवश्यक है क्योंकि उनके प्रकृति से structs अज्ञात आकार हैं और बाइट्स के सरणी में परिवर्तित नहीं किए जा सकते हैं।

मैंने कुछ कोड और play शामिल किया है।

package main 

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

type P struct { 
    X, Y, Z int 
    Name string 
} 

type Q struct { 
    X, Y *int32 
    Name string 
} 

func main() { 
    // Initialize the encoder and decoder. Normally enc and dec would be 
    // bound to network connections and the encoder and decoder would 
    // run in different processes. 
    var network bytes.Buffer  // Stand-in for a network connection 
    enc := gob.NewEncoder(&network) // Will write to network. 
    dec := gob.NewDecoder(&network) // Will read from network. 
    // Encode (send) the value. 
    err := enc.Encode(P{3, 4, 5, "Pythagoras"}) 
    if err != nil { 
     log.Fatal("encode error:", err) 
    } 

    // HERE ARE YOUR BYTES!!!! 
    fmt.Println(network.Bytes()) 

    // Decode (receive) the value. 
    var q Q 
    err = dec.Decode(&q) 
    if err != nil { 
     log.Fatal("decode error:", err) 
    } 
    fmt.Printf("%q: {%d,%d}\n", q.Name, *q.X, *q.Y) 
}