Cómo asignar una cadena a una matriz de bytes

Quiero asignar una cadena a la matriz de bytes:

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

¿Tienes otro método?

Seguro y simple:

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

Para la conversión de una cadena a una rebanada de bytes, string -> []byte:

[]byte(str)

Para convertir una matriz en un segmento [20]byte -> []byte:

arr[:]

Para copiar una cadena a una matriz string -> [20]byte:

copy(arr[:], str)

Igual que el anterior, pero primero convierte explícitamente la cadena en un segmento:

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

• La copyfunción incorporada solo copia en un segmento, desde un segmento.
• Las matrices son "los datos subyacentes", mientras que los segmentos son "una ventana gráfica a los datos subyacentes".
• El uso [:]hace que una matriz califique como un segmento.
• Una cadena no califica como una rebanada que se puede copiar a , pero califica como una rebanada que se puede copiar a partir de (las cadenas son inmutables).
• Si la cadena es demasiado larga, copysolo copiará la parte de la cadena que se ajuste.

Este código:

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

... da el siguiente resultado:

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

También lo hice disponible en Go Playground

Por ejemplo,

package main

import "fmt"

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

Salida:

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]

Pedazo de pastel:

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

Yo pienso que es mejor..

package main

import "fmt"

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

Consulta aquí: http://play.golang.org/p/vpnAWHZZk7

Ir, convertir una cadena en un segmento de bytes

Necesita una forma rápida de convertir una cadena [] a un tipo de byte. Para usar en situaciones como el almacenamiento de datos de texto en un archivo de acceso aleatorio u otro tipo de manipulación de datos que requiera que los datos de entrada estén en tipo [] byte.

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

que es útil cuando se usa ioutil.WriteFile, que acepta un segmento de bytes como parámetro de datos:

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

Otro ejemplo

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

Salida:

[104 101 108 108 111 32 119 111 114 108 100] hola mundo

Por favor revise el enlace del patio de recreo

Terminé creando métodos específicos de matriz para hacer esto. Al igual que el paquete de codificación / binario con métodos específicos para cada tipo int. Por ejemplo 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)

Salida:

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

Observe cómo quería relleno a la izquierda, no a la derecha.

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

Además de los métodos mencionados anteriormente, también puedes hacer un truco como

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

Ir a jugar: http://play.golang.org/p/xASsiSpQmC

Nunca deberías usar esto :-)

Las matrices son valores ... las rebanadas son más como punteros. Eso [n]typeno es compatible, []typeya que son fundamentalmente dos cosas diferentes. Puede obtener un segmento que apunte a una matriz mediante el uso arr[:]que devuelve un segmento que tiene arrcomo respaldo de almacenamiento.

Una forma de convertir un trozo de, por ejemplo, []bytea [20]bytees asignar en realidad una [20]byteque se puede hacer mediante el uso var [20]byte(ya que es un valor ... no makees necesario) y luego copiar datos en él:

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

Esencialmente, lo que muchas otras respuestas se equivocan es que []typeNO es una matriz.

[n]Ty []Tson cosas completamente diferentes!

Cuando se utiliza el reflejo, []Tno es de tipo Array sino de tipo Slice y [n]Tes de tipo Array.

Tampoco puedes usar map[[]byte]Tpero puedes usarmap[[n]byte]T .

Esto a veces puede ser engorroso porque muchas funciones funcionan, por ejemplo, []bytemientras que algunas funciones regresan [n]byte(más notablemente las funciones hash en crypto/*). Un hash sha256, por ejemplo, es [32]bytey no es []byteasí cuando los principiantes intentan escribirlo en un archivo, por ejemplo:

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

obtendrán un error. La forma correcta de usar

w.Write(sum[:])

Sin embargo, ¿qué es lo que quieres? ¿Solo accediendo a la cadena bytewise? Puede convertir fácilmente un stringa []byteusando:

bytes := []byte(str)

pero esto no es una matriz, es un segmento. Además byte,! = rune. En caso de que desee operar con "personajes", debe usar rune... no byte.