Como atribuir string à matriz de bytes

Eu quero atribuir seqüência de caracteres à matriz de bytes:

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

Tem outro método?

Seguro e simples:

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

Para converter de uma sequência de caracteres em uma fatia de bytes string -> []byte:

[]byte(str)

Para converter uma matriz em uma fatia [20]byte -> []byte:

arr[:]

Para copiar uma string para uma matriz string -> [20]byte:

copy(arr[:], str)

O mesmo que acima, mas convertendo explicitamente a string em uma fatia primeiro:

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

• A copyfunção interna copia apenas para uma fatia, de uma fatia.
• Matrizes são "os dados subjacentes", enquanto as fatias são "uma janela de visualização para dados subjacentes".
• Usar [:]faz com que uma matriz seja qualificada como uma fatia.
• Uma corda não se qualifica como uma fatia que pode ser copiado para , mas ela se qualifica como uma fatia que pode ser copiado a partir de (strings são imutáveis).
• Se a sequência for muito longa, copycopia apenas a parte da sequência que se encaixa.

Este código:

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

... fornece a seguinte saída:

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

Também disponibilizei no Go Playground

Por exemplo,

package main

import "fmt"

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

Resultado:

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]

Pedaco de bolo:

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

Eu acho melhor..

package main

import "fmt"

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

Verifique aqui: http://play.golang.org/p/vpnAWHZZk7

Vá, converta uma string em uma fatia de bytes

Você precisa de uma maneira rápida de converter uma string [] para o tipo de byte []. Para usar em situações como armazenar dados de texto em um arquivo de acesso aleatório ou outro tipo de manipulação de dados que exija que os dados de entrada sejam do tipo [] byte.

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

o que é útil ao usar o ioutil.WriteFile, que aceita uma fatia de bytes como parâmetro de dados:

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

Outro exemplo

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

Resultado:

[104 101 108 108 111 32 119 111 114 108 100] olá mundo

Por favor, verifique o link playground

Acabou criando métodos específicos de matriz para fazer isso. Muito parecido com o pacote de codificação / binário com métodos específicos para cada tipo int. Por exemplo 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)

Resultado:

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

Observe como eu queria estofar à esquerda, não à direita.

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

Além dos métodos mencionados acima, você também pode fazer um truque como

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

Go Play: http://play.golang.org/p/xASsiSpQmC

Você nunca deve usar isso :-)

Matrizes são valores ... fatias são mais como ponteiros. Isso é[n]type não é compatível []type, pois são fundamentalmente duas coisas diferentes. Você pode obter uma fatia que aponta para uma matriz usando o arr[:]que retorna uma fatia que possui arrao fazer backup do armazenamento.

Uma maneira de converter uma fatia de, por exemplo, []bytea [20]byteé realmente alocar um [20]byteque você pode fazer usando var [20]byte(como é um valor ... nãomake necessário) e, em seguida, copiar os dados para ele:

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

Essencialmente, o que muitas outras respostas dão errado é que []type NÃO é uma matriz.

[n]T e []T são coisas completamente diferentes!

Ao usar refletir []T não é do tipo Array, mas do tipo Slice e [n]Té do tipo Array.

Você também não pode usar map[[]byte]T mas pode usar map[[n]byte]T.

Às vezes, isso pode ser complicado porque muitas funções operam, por exemplo, []byteenquanto algumas funções retornam [n]byte(principalmente as funções hash crypto/*). Um hash sha256, por exemplo, é [32]bytee não é []byteassim quando os iniciantes tentam gravá-lo em um arquivo, por exemplo:

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

eles receberão um erro. A maneira correta de usar é

w.Write(sum[:])

No entanto, o que você quer? Apenas acessando a string bytewise? Você pode facilmente converter um stringem []byte:

bytes := []byte(str)

mas isso não é uma matriz, é uma fatia. Além disso byte,! = rune. Caso você queira operar com "caracteres", você precisa usar rune... não byte.