मैं दो [] बाइट स्लाइस या सरणी के साथ गो एपेंड का उपयोग कैसे कर सकता हूं?

Question

मैंने हाल ही में गो में दो बाइट सरणी स्लाइस जोड़ने की कोशिश की और कुछ अजीब त्रुटियों में आया। मेरे कोड है:

one:=make([]byte, 2) 
two:=make([]byte, 2) 
one[0]=0x00 
one[1]=0x01 
two[0]=0x02 
two[1]=0x03 

log.Printf("%X", append(one[:], two[:])) 

three:=[]byte{0, 1} 
four:=[]byte{2, 3} 

five:=append(three, four) 

और त्रुटियाँ हैं:

cannot use four (type []uint8) as type uint8 in append 
cannot use two[:] (type []uint8) as type uint8 in append 

कौन सा ध्यान में जाओ के स्लाइस के कथित मजबूती लिया एक समस्या नहीं होनी चाहिए:

http://code.google.com/p/go-wiki/wiki/SliceTricks

क्या क्या मैं गलत कर रहा हूं, और मुझे दो बाइट एरे जोड़ने के बारे में कैसे जाना चाहिए?

Answer 1

Appending to and copying slices

variadic समारोह append शून्य या अधिक मान x संलग्न कर देता है प्रकार S की s है, जो एक टुकड़ा प्रकार होना चाहिए की तरह दिखना चाहिए , और परिणामी टुकड़ा, प्रकारप्रकार देता है। x मान ...T के पैरामीटर पर पास किए गए हैं, जहां TS का तत्व प्रकार है और संबंधित पैरामीटर नियम लागू होते हैं।

append(s S, x ...T) S // T is the element type of S

Passing arguments to ... parameters

तो अंतिम तर्क एक टुकड़ा प्रकार []T को आबंटित है, यह एक ...T पैरामीटर के लिए मूल्य के रूप में पारित अपरिवर्तित अगर तर्क ... द्वारा पीछा किया है हो सकता है।

अंतिम तर्क के लिए आपको []T... का उपयोग करने की आवश्यकता है।

उदाहरण के लिए

,

package main 

import "fmt" 

func main() { 
    one := make([]byte, 2) 
    two := make([]byte, 2) 
    one[0] = 0x00 
    one[1] = 0x01 
    two[0] = 0x02 
    two[1] = 0x03 
    fmt.Println(append(one[:], two[:]...)) 
    three := []byte{0, 1} 
    four := []byte{2, 3} 
    five := append(three, four...) 
    fmt.Println(five) 
} 

Answer 2

append()[]T प्रकार का एक टुकड़ा लेता है, और उसके बाद स्लाइस सदस्य T के प्रकार के मानों की एक चर संख्या है। दूसरे शब्दों में, यदि आप []uint8 को append() पर स्लाइस के रूप में पास करते हैं तो यह प्रत्येक आगामी तर्क uint8 होना चाहता है।

इसका समाधान slice... सिंटैक्स का उपयोग एक varargs तर्क के स्थान पर एक टुकड़ा पारित करने के लिए है। आपका कोड

log.Printf("%X", append(one[:], two[:]...)) 

और

five:=append(three, four...)