Come assegnare una stringa all'array di byte

Voglio assegnare una stringa all'array di byte:

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

Hai un altro metodo?

Sicuro e semplice:

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

Per la conversione da una stringa a una fetta di byte, string -> []byte:

[]byte(str)

Per convertire un array in una sezione [20]byte -> []byte:

arr[:]

Per la copia di una stringa in un array, string -> [20]byte:

copy(arr[:], str)

Come sopra, ma prima converti esplicitamente la stringa in una sezione:

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

• La copyfunzione integrata copia solo in una sezione, da una sezione.
• Le matrici sono "i dati sottostanti", mentre le sezioni sono "una finestra nei dati sottostanti".
• L'utilizzo [:]rende un array idoneo come slice.
• Una stringa non si qualifica come una fetta che può essere copiato da , ma si qualifica come una fetta che può essere copiato da (stringhe sono immutabili).
• Se la stringa è troppo lunga, copycopierà solo la parte della stringa adatta.

Questo codice:

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

... fornisce il seguente output:

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

L'ho anche reso disponibile al Go Playground

Per esempio,

package main

import "fmt"

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

Produzione:

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]

Pezzo di torta:

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

Penso che sia meglio ..

package main

import "fmt"

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

Controlla qui: http://play.golang.org/p/vpnAWHZZk7

Vai, converti una stringa in una porzione di byte

È necessario un modo rapido per convertire una stringa [] nel tipo di byte []. Da utilizzare in situazioni come l'archiviazione di dati di testo in un file ad accesso casuale o un altro tipo di manipolazione dei dati che richiede che i dati di input siano nel tipo di byte [].

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

che è utile quando si utilizza ioutil.WriteFile, che accetta una porzione di byte come parametro di dati:

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

Un altro esempio

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

Produzione:

[104 101 108 108 111 32 119 111 114 108 100] ciao mondo

Si prega di controllare il parco giochi di collegamento

Ho finito per creare metodi specifici dell'array per fare questo. Proprio come il pacchetto di codifica / binario con metodi specifici per ogni tipo di int. Per esempio 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)

Produzione:

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

Notate come volevo imbottitura a sinistra, non a destra.

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

Oltre ai metodi sopra menzionati, puoi anche fare un trucco come

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

Vai a giocare: http://play.golang.org/p/xASsiSpQmC

Non dovresti mai usare questo :-)

Le matrici sono valori ... le sezioni sono più simili a puntatori. Ciò [n]typenon è compatibile []typein quanto fondamentalmente sono due cose diverse. È possibile ottenere una sezione che punta a un array utilizzando arr[:]quale restituisce una sezione che haarr come supporto di archiviazione.

Un modo per convertire una fetta di per esempio []byteper [20]byteè quello di allocare in realtà una [20]byteche si può fare utilizzando var [20]byte(come è un valore ... non makenecessario) e poi copiare i dati in esso:

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

In sostanza, molte altre risposte sbagliate []typenon sono un array.

[n]Te []Tsono cose completamente diverse!

Quando si utilizza reflect []Tnon è di tipo Array ma di tipo Slice e[n]T è di tipo Array.

Inoltre non puoi usare map[[]byte]Tma puoi usaremap[[n]byte]T .

Questo a volte può essere ingombrante perché molte funzioni operano ad esempio []bytementre alcune funzioni ritornano [n]byte(in particolare le funzioni hash in crypto/*). Un hash sha256 per esempio è [32]bytee non è []bytecosì quando i principianti provano a scriverlo in un file per esempio:

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

riceveranno un errore. Il modo corretto di è usare

w.Write(sum[:])

Tuttavia, che cosa vuoi? Stai solo accedendo alla stringa in senso byte? Puoi facilmente convertire un stringin []byteusando:

bytes := []byte(str)

ma questo non è un array, è una fetta. Inoltre byte,! = rune. Nel caso tu voglia operare su "personaggi" devi usare rune... no byte.