Bayt dizisine dize atama

Bayt dizisine dize atamak istiyorum:

var arr [20]byte
str := "abc"
for k, v := range []byte(str) {
  arr[k] = byte(v)
}

Başka bir yönteminiz mi var?

Güvenli ve basit:

[]byte("Here is a string....")

Bir dizeden bayt dilimine dönüştürmek için string -> []byte:

[]byte(str)

Bir diziyi bir dilime dönüştürmek için [20]byte -> []byte:

arr[:]

Bir dizeyi diziye kopyalamak için string -> [20]byte:

copy(arr[:], str)

Yukarıdaki ile aynı, ancak dizeyi açıkça bir dilime dönüştürüyoruz:

copy(arr[:], []byte(str))

• Yerleşik copyişlevi yalnızca kopyaları için bir dilim, gelen bir dilim.
• Diziler "temel veriler", dilimler ise "temel veriler için bir görünüm" dür.
• Kullanmak [:], bir diziyi dilim olarak nitelendirir.
• Bir dize kopyalanabilir dilim olarak nitelemek gelmez etmek , ancak kopyalanabilir dilim olarak nitelendirir dan (dizeleri iletmenin).
• Dize çok uzunsa, copydizenin yalnızca uygun olan kısmını kopyalar.

Bu kod:

var arr [20]byte
copy(arr[:], "abc")
fmt.Printf("array: %v (%T)\n", arr, arr)

... şu çıktıyı verir:

array: [97 98 99 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] ([20]uint8)

Ben ayrıca bu hazır Git Playground

Örneğin,

package main

import "fmt"

func main() {
    s := "abc"
    var a [20]byte
    copy(a[:], s)
    fmt.Println("s:", []byte(s), "a:", a)
}

Çıktı:

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]

Kekin parçası:

arr := []byte("That's all folks!!")

Bence bu daha iyi..

package main

import "fmt"

func main() {
    str := "abc"
    mySlice := []byte(str)
    fmt.Printf("%v -> '%s'",mySlice,mySlice )
}

Buraya bakın: http://play.golang.org/p/vpnAWHZZk7

Git, bir dizeyi bayt dilimine dönüştür

[] Dizesini [] bayt türüne dönüştürmenin hızlı bir yoluna ihtiyacınız vardır. Metin verilerinin rasgele erişim dosyasına veya giriş verilerinin [] bayt tipinde olmasını gerektiren başka bir veri işleme türü gibi durumlarda kullanmak için.

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

veri parametresi olarak bir bayt dilimini kabul eden ioutil.WriteFile kullanılırken yararlıdır:

WriteFile func(filename string, data []byte, perm os.FileMode) error

Başka bir örnek

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

Çıktı:

[104101108101111 3211111111410100] Merhaba dünya

Lütfen bağlantı oyun alanını kontrol edin

Bunu yapmak için diziye özgü yöntemler oluşturma sona erdi. Her int türü için özel yöntemlerle kodlama / ikili pakete çok benzer . Örneğin 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)

Çıktı:

[0 0 0 0 0 0 0 0 0 0 0 0 0 97 98 99]

Solda nasıl doldurmak istediğime dikkat edin, sağda değil.

http://play.golang.org/p/7tNumnJaiN

Yukarıda belirtilen yöntemlerin yanı sıra,

s := "hello"
b := *(*[]byte)(unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(&s))))

Git oyna: http://play.golang.org/p/xASsiSpQmC

Bunu asla kullanmamalısınız :-)

Diziler değerdir ... dilimler daha çok işaretçiler gibidir. Yani [n]typeuyumlu değil []typetemelden farklı şeylerdir olarak. Yedekleme depolama alanı arr[:]olan bir dilim döndüren bir diziyi işaret eden bir dilim alabilirsiniz arr.

Örneğin bir dilim dönüştürmek için bir yolu []byteiçin [20]byteaslında bir tahsis etmektir [20]bytekullanarak yapabileceğiniz hangi var [20]byte(bir değer olarak ... hayır makegerekli) ve daha sonra içine veri kopyalamak:

buf := make([]byte, 10)
var arr [10]byte
copy(arr[:], buf)

Aslında diğer cevapların bir çok yanlış yaptığı []typebir dizi DEĞİLDİR.

[n]Tve []Ttamamen farklı şeyler!

Yansıtmayı kullanırken []Ttür Array değil, Dilim tür ve [n]TArray türündedir.

Ayrıca kullanamazsınız map[[]byte]Tama kullanabilirsiniz map[[n]byte]T.

Bu bazen hantal olabilir çünkü birçok işlev örneğin üzerinde []byteçalışırken, bazı işlevler geri döner [n]byte(en önemlisi hash işlevleri crypto/*). Örneğin bir sha256 karması , yeni başlayanlar örneğin bir dosyaya yazmaya çalıştığında [32]bytedeğildir []byte:

sum := sha256.Sum256(data)
w.Write(sum)

bir hata alırlar. Doğru yolu kullanmak

w.Write(sum[:])

Ancak, ne istiyorsunuz? Sadece dizeye yavaş yavaş mı erişiyorsunuz? Kolayca bir dönüştürebilirsiniz stringiçin []bytekullanıyor:

bytes := []byte(str)

ama bu bir dizi değil, bir dilim. Ayrıca byte,! = rune. "Karakterler" üzerinde çalışmak istemeniz durumunda rune... kullanmanız gerekmiyor byte.