एक संरचना

Question

एन्कोडिंग/बेस 64 और एन्कोडिंग/हेक्स दोनों कार्यों के समान सेट का समर्थन करते हैं, लेकिन base64 कक्षा-आधारित एन्कोडर का उपयोग करता है, जबकि हेक्स शीर्ष स्तर पर विधियों का निर्यात करता है। क्या हेक्स के चारों ओर एक रैपर बनाने का कोई आसान तरीका है ताकि आप एक सारणीबद्ध एन्कोडिंग इंटरफ़ेस के साथ काम कर सकें? अधिक आम तौर पर, क्या संरचना के लिए एक विधि को बाध्य करने के बराबर करने का कोई तरीका है? (उदाहरण के लिए, SomeStruct.Encode = hex.Encode)

अब तक, मुझे फ़ंक्शंस के समान हस्ताक्षर वाले hexEncoder संरचना पर फ़ंक्शंस को परिभाषित करना पड़ा था। मैं इस तरह एक अंतरफलक बनाया:

type Encoding interface { 
    Decode(dst, src []byte) (n int, err error) 
    DecodedLen(n int) int 
    Encode(dst, src []byte) // base64 returns nothing, hex returns int 
    EncodedLen(n int) int 
} 

जो base64.StdEncoding साथ एकदम काम करती है, लेकिन मैं कैसे हेक्स तरीकों रैप करने के लिए स्पष्ट नहीं था। मैं हेक्स के लिए एक खाली struct बनाया:

// wrap hex encoding/decoding so that it can be used interchangeably with base64 encoding 
type hexEncoder struct {} 

func (h hexEncoder) Decode(dst, src []byte) (n int, err error) { 
    return hex.Decode(dst, src) 
} 
func (h hexEncoder) DecodedLen(n int) int { 
    return hex.DecodedLen(n) 
} 
func (h hexEncoder) Encode(dst, src []byte) { 
    hex.Encode(dst, src) // don't return the int to match Encoding 
} 
func (h hexEncoder) EncodedLen(n int) int { 
    return hex.EncodedLen(n) 
} 

यह काम करता है, लेकिन यह बायलर अतिरिक्त प्लेट (जहां सभी कि वास्तव में लिपटे होने की जरूरत है hex.Encode है) का एक समूह है। क्या ऐसा करने के लिए इससे अच्छा तरीका है?

func convert(src []byte, decoder Encoding, encoder Encoding) ([]byte, error) { 
    temp := make([]byte, decoder.DecodedLen(len(src))) 
    n, err := decoder.Decode(temp, src) 
    if err != nil { 
     return temp, err 
    } 
    dst := make([]byte, encoder.EncodedLen(len(src))) 
    encoder.Encode(dst, temp[:n]) 
    return dst, nil 
} 

Answer 1

नहीं, एक अंतरफलक है कि एक और पैकेज में कार्यों के लिए डिस्पैच लागू करने के लिए कोई बेहतर तरीका है: अंत में, लक्ष्य हेक्स और base64 कुछ इस तरह में एन्कोडिंग/डिकोडिंग के लिए भी उपयोग करने के लिए, की तरह सक्षम होने के लिए है , और ईमानदार होने के लिए मैं वास्तव में कल्पना नहीं कर सकता कि एक बेहतर तरीका कैसा दिखता है।

क्या आपको लगता है कि आवरण में कह रहे है:

type myType struct{} 

func (myType) WhenCalledLikeThis() { DoThat() } 

कौन सा इष्टतम लगती है। इसे किसी भी बैकिंग मेमोरी की आवश्यकता नहीं है, नामकरण में मामूली परिवर्तन की अनुमति देता है और मान वापस लौटाता है (जैसा कि आपने Encode के लिए किया है), और एक कॉल के साथ प्रेषण करता है।