जवाबों:
सुरक्षित और सरल:
[]byte("Here is a string....")[]byte("one", "two")?
स्ट्रिंग से बाइट स्लाइस में परिवर्तित करने के लिए string -> []byte:
[]byte(str)किसी सरणी को एक स्लाइस में बदलने के लिए [20]byte -> []byte:
arr[:]किसी स्ट्रिंग को एक सरणी में कॉपी करने के लिए string -> [20]byte:
copy(arr[:], str)ऊपर के समान, लेकिन पहले स्पष्ट रूप से एक स्लाइस को स्ट्रिंग में परिवर्तित करना:
copy(arr[:], []byte(str))copyसमारोह केवल प्रतियां करने के लिए एक टुकड़ा, से एक टुकड़ा।[:]एक सरणी का उपयोग स्लाइस के रूप में अर्हता प्राप्त करता है।copyतो केवल फिट होने वाले स्ट्रिंग के हिस्से को कॉपी करेगा।यह कोड:
var arr [20]byte
copy(arr[:], "abc")
fmt.Printf("array: %v (%T)\n", arr, arr)... निम्नलिखित उत्पादन देता है:
array: [97 98 99 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] ([20]uint8)मैंने इसे गो प्लेग्राउंड में भी उपलब्ध कराया
b[i] = []byte("A")[0]काम करता हूं , लेकिन यह b[i] = 'A'बहुत साफ है।
b[1] = '本'
उदाहरण के लिए,
package main
import "fmt"
func main() {
s := "abc"
var a [20]byte
copy(a[:], s)
fmt.Println("s:", []byte(s), "a:", a)
}आउटपुट:
s: [97 98 99] a: [97 98 99 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]s, `कॉपी फ़ंक्शन गूंगा नहीं है। स्लाइस को कॉपी और कॉपी करना : "कॉपी किए गए तत्वों की संख्या लेन (src) और लेन (dst) की न्यूनतम है।"
केक का टुकड़ा:
arr := []byte("That's all folks!!")[]byteका उपयोग सरणियों पर पसंद किया जाता है [20]byte। सर्वोत्तम प्रथाओं के आधार पर उत्तर सही है; यदि विनिर्देशों या कोड सरणियों की आवश्यकता होती है, तो copyइसके बजाय का उपयोग करें (इस थ्रेड में अन्यत्र उदाहरण देखें)।
मेरे विचार में बेहतर होगा कि..
package main
import "fmt"
func main() {
str := "abc"
mySlice := []byte(str)
fmt.Printf("%v -> '%s'",mySlice,mySlice )
}यहां देखें: http://play.golang.org/p/vpnAWHZZk7
[] स्ट्रिंग को [] बाइट प्रकार में बदलने के लिए आपको एक तेज़ तरीका चाहिए। टेक्स्ट डेटा को रैंडम एक्सेस फ़ाइल या अन्य प्रकार के डेटा हेरफेर में संग्रहीत करने जैसी स्थितियों में उपयोग करने के लिए इनपुट डेटा को [] बाइट प्रकार में रखने की आवश्यकता होती है।
package main
func main() {
var s string
//...
b := []byte(s)
//...
}जो ioutil.WriteFile का उपयोग करते समय उपयोगी है, जो बाइट्स स्लाइस को अपने डेटा पैरामीटर के रूप में स्वीकार करता है:
WriteFile func(filename string, data []byte, perm os.FileMode) errorएक और उदाहरण
package main
import (
"fmt"
"strings"
)
func main() {
stringSlice := []string{"hello", "world"}
stringByte := strings.Join(stringSlice, " ")
// Byte array value
fmt.Println([]byte(stringByte))
// Corresponding string value
fmt.Println(string([]byte(stringByte)))
}आउटपुट:
[१०४ १०] १० hel १० 104 १२१ ११ ९ १११ ११४ १० 100 १०० १०] हैलो दुनिया
कृपया लिंक खेल के मैदान की जाँच करें
इसे करने के लिए ऐरे विशिष्ट तरीकों का निर्माण किया। बहुत पसंद एन्कोडिंग / बाइनरी प्रत्येक पूर्णांक प्रकार के लिए विशिष्ट तरीकों के साथ पैकेज। उदाहरण के लिए binary.BigEndian.PutUint16([]byte, uint16)।
func byte16PutString(s string) [16]byte {
var a [16]byte
if len(s) > 16 {
copy(a[:], s)
} else {
copy(a[16-len(s):], s)
}
return a
}
var b [16]byte
b = byte16PutString("abc")
fmt.Printf("%v\n", b)आउटपुट:
[0 0 0 0 0 0 0 0 0 0 0 0 0 97 98 99]ध्यान दें कि मैं बाईं ओर कैसे पैडिंग चाहता था, न कि दाएं।
byte16PutStringयह बिल्टइन copyफ़ंक्शन के पुन: क्रियान्वयन का एक प्रकार है , जो केवल एक मौजूदा का उपयोग करने के बजाय नए सरणियों का निर्माण करने का समर्थन करता है। copyइसमें विशेष संकलक समर्थन है, इसलिए यह विभिन्न प्रकार के तर्कों को संभाल सकता है, और संभवतः इसमें कवर्स के तहत वास्तव में उच्च-प्रदर्शन कार्यान्वयन है। इसके अलावा, ओपी के सवाल ने एक नए को आवंटित करने के बजाय एक मौजूदा सरणी को एक स्ट्रिंग लिखने के बारे में पूछा, हालांकि अन्य जवाबों में से अधिकांश इसे भी अनदेखा करते प्रतीत होते हैं ...
answerसही है हर शरीर दूसरों को सीखने और प्रोत्साहित करने के लिए यहाँ है
ऊपर बताए गए तरीकों के अलावा, आप एक ट्रिक भी कर सकते हैं
s := "hello"
b := *(*[]byte)(unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(&s))))गो प्ले: http://play.golang.org/p/xASsiSpQmC
आप इस का उपयोग कभी नहीं करना चाहिए :-)
[]byteअपने "रूपांतरण" का उपयोग करके एक उचित ऑब्जेक्ट नहीं मिलता है - जब आप संशोधन करने की कोशिश करते हैं तो यह बुरी तरह से विफल होता है p, देखें: play.golang.org/p/WHGl756ucj । आपके मामले में, यह निश्चित नहीं है कि आप इस b := []byte(s)पद्धति पर दोहरा-असुरक्षित क्यों पसंद करेंगे ।
cap()मनमाना आकार होता है, जिसका अर्थ है कि यह अज्ञात मेमोरी में पढ़ रहा है। इसके लिए सही होने के लिए, मुझे लगता है कि आपको यह सुनिश्चित करने की आवश्यकता होगी कि आप पूर्ण reflect.SliceHeaderआकार आवंटित करें और मैन्युअल रूप से सेट करें cap। कुछ इस तरह: play.golang.org/p/fBK4dZM-qD
Arrays मान हैं ... स्लाइस पॉइंटर्स की तरह अधिक हैं। यह [n]typeसंगत नहीं है []typeक्योंकि वे मूलभूत रूप से दो अलग चीजें हैं। आप एक स्लाइस प्राप्त कर सकते हैं जो एक सरणी को इंगित करता है arr[:]जिसके द्वारा एक स्लाइस देता है जिसमें arrबैकिंग स्टोरेज है।
एक तरह से उदाहरण के लिए का एक टुकड़ा में परिवर्तित करने []byteके लिए [20]byteवास्तव में एक आवंटित करने के लिए है [20]byteका उपयोग करके जो आप कर सकते हैं var [20]byte(क्योंकि यह एक मूल्य है ... कोई makeजरूरत) और फिर इसे में डेटा की प्रतिलिपि:
buf := make([]byte, 10)
var arr [10]byte
copy(arr[:], buf)अनिवार्य रूप से जो बहुत से अन्य उत्तर गलत मिलते हैं, वह []typeयह नहीं है कि एक सरणी है।
[n]Tऔर []Tपूरी तरह से अलग चीजें हैं!
जब []Tपरावर्तक प्रकार के ऐरे का नहीं होता है, लेकिन स्लाइस का [n]Tहोता है और दयालु एरे का होता है।
आप भी उपयोग map[[]byte]Tनहीं कर सकते, लेकिन आप उपयोग कर सकते हैंmap[[n]byte]T ।
यह कभी-कभी बोझिल हो सकता है क्योंकि बहुत सारे फ़ंक्शंस उदाहरण के लिए काम करते हैं []byteजबकि कुछ फ़ंक्शंस वापस [n]byte(सबसे विशेष रूप से हैश फ़ंक्शंस में crypto/*)। उदाहरण के लिए एक sha256 हैश है [32]byteऔर []byteऐसा नहीं है जब शुरुआती उदाहरण के लिए इसे एक फ़ाइल में लिखने की कोशिश करते हैं:
sum := sha256.Sum256(data)
w.Write(sum)उन्हें एक त्रुटि मिलेगी। उपयोग करने का सही तरीका है
w.Write(sum[:])हालाँकि, यह क्या है जो आप चाहते हैं? बस स्ट्रिंग तक पहुँचने? आप आसानी से एक stringका []byteउपयोग करने के लिए परिवर्तित कर सकते हैं :
bytes := []byte(str)लेकिन यह एक सरणी नहीं है, यह एक टुकड़ा है। इसके अलावा; byte= rune। यदि आप "वर्ण" पर काम करना चाहते हैं, तो आपको उपयोग करने की आवश्यकता है rune... नहीं byte।
strअधिक हैarrतो आपको "इंडेक्स आउट ऑफ रेंज" त्रुटि मिलेगी।