Jak przypisać ciąg do tablicy bajtów

Chcę przypisać ciąg do tablicy bajtów:

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

Masz inną metodę?

Bezpieczny i prosty:

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

Aby przekonwertować ciąg na plasterek bajtowy string -> []byte:

[]byte(str)

Aby przekonwertować tablicę na plasterek [20]byte -> []byte:

arr[:]

Aby skopiować ciąg do tablicy string -> [20]byte:

copy(arr[:], str)

To samo co powyżej, ale najpierw najpierw jawnie konwertuje ciąg na plasterek:

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

• Wbudowana copyfunkcja kopiuje tylko do plasterka, z plasterka.
• Tablice są „danymi bazowymi”, a wycinki są „rzutnią w dane bazowe”.
• Użycie [:]powoduje, że tablica kwalifikuje się jako plasterek.
• Łańcuch nie kwalifikuje się jako plaster, które mogą być kopiowane do , ale kwalifikuje się jako plaster, które mogą być kopiowane z (łańcuchy są niezmienne).
• Jeśli łańcuch jest zbyt długi, copyskopiuje tylko część pasującą do łańcucha.

Ten kod:

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

... daje następujący wynik:

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

Udostępniłem go również na Go Playground

Na przykład,

package main

import "fmt"

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

Wynik:

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]

Bułka z masłem:

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

Myślę że to jest lepsze..

package main

import "fmt"

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

Sprawdź tutaj: http://play.golang.org/p/vpnAWHZZk7

Idź, przekonwertuj ciąg na plasterek bajtów

Potrzebujesz szybkiego sposobu konwersji ciągu [] na typ bajtu []. Do użycia w sytuacjach, takich jak przechowywanie danych tekstowych w pliku o swobodnym dostępie lub innego rodzaju manipulowanie danymi, które wymaga, aby dane wejściowe były typu [] bajtowego.

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

co jest przydatne podczas korzystania z ioutil.WriteFile, który przyjmuje wycinek bajtów jako parametr danych:

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

Inny przykład

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

Wynik:

[104 101 108 108 111 32 119 111 114 108 100] witaj świecie

Proszę sprawdzić link plac zabaw

Skończyło się tworzenie metod specyficznych dla tablicy, aby to zrobić. Podobnie jak pakiet kodowania / binarny z określonymi metodami dla każdego typu int. Na przykład 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)

Wynik:

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

Zwróć uwagę, jak chciałem dopełnienie po lewej, a nie po prawej.

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

Oprócz metod wymienionych powyżej, możesz także zrobić trick

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

Idź Graj: http://play.golang.org/p/xASsiSpQmC

Nigdy nie powinieneś tego używać :-)

Tablice są wartościami ... plasterki bardziej przypominają wskaźniki. To [n]typenie jest zgodne, []typeponieważ są to zasadniczo dwie różne rzeczy. Możesz uzyskać wycinek, który wskazuje tablicę, używając tego, arr[:]który zwraca wycinek, który ma arrjako pamięć zapasową.

Jednym ze sposobów, aby przekształcić plasterek na przykład []bytena [20]byteto, aby rzeczywiście lokować [20]bytektóre można zrobić przy użyciu var [20]byte(jak jest to wartość ... nie makejest to konieczne), a następnie skopiować dane do niego:

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

Zasadniczo błędem jest wiele innych odpowiedzi, że []typeNIE jest to tablica.

[n]Ti []Tsą zupełnie innymi rzeczami!

Podczas używania odbicia []Tnie jest to rodzaj Array, ale rodzaj Slice i [n]Tjest to rodzaj Array.

Ty też nie możesz używać, map[[]byte]Tale możesz używać map[[n]byte]T.

Czasami może to być kłopotliwe, ponieważ wiele funkcji działa na przykład podczas, []bytegdy niektóre funkcje powracają [n]byte(w szczególności funkcje skrótu w crypto/*). Na przykład skrót mieszający sha256 jest [32]bytei nie jest []bytetak, gdy początkujący próbują zapisać go na przykład w pliku:

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

dostaną błąd. Prawidłowym sposobem jest użycie

w.Write(sum[:])

Czego jednak chcesz? Tylko dostęp do łańcucha znaków w inny sposób? Możesz łatwo przekonwertować a stringna []byte:

bytes := []byte(str)

ale to nie jest tablica, to kawałek. Również byte! = rune. Jeśli chcesz operować na „postaciach”, musisz użyć rune… nie byte.