go - byte to string c#

Cómo asignar cadena a la matriz de bytes

Question

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?

Answer 1

Vaya, convierta una cadena a un segmento de bytes

Necesita una forma rápida de convertir una cadena [] a 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 el tipo de 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 su 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 revisa el link de playground

Answer 2

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

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

Nunca debes usar esto :-)

Answer 3

Las matrices son valores ... las rebanadas son más como punteros. Es decir [n]type no es compatible con el []type ya que son fundamentalmente dos cosas diferentes. Puede obtener una porción que apunta a una matriz usando arr[:] que devuelve una porción que tiene arr cuando está respaldando el almacenamiento.

Una forma de convertir una porción de, por ejemplo, []byte a [20]byte es realmente asignar un [20]byte que puede hacer usando el var [20]byte (ya que es un valor ... no make falta make ninguna make ) y luego copia los datos en él:

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

Esencialmente, lo que muchas otras respuestas se equivocan es que el []type NO es una matriz.

[n]T y []T son cosas completamente diferentes!

Cuando se utiliza reflect []T no es de tipo Array, sino de tipo Slice y [n]T es de tipo Array.

Tampoco puede usar el map[[]byte]T pero puede usar el map[[n]byte]T

A veces esto puede ser engorroso porque muchas funciones operan, por ejemplo, en el []byte mientras que algunas funciones devuelven el [n]byte (más notablemente las funciones hash en crypto/* ). Un hash sha256, por ejemplo, es el [32]byte y no el [32]byte []byte así que 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 es usar

w.Write(sum[:])

Sin embargo, ¿qué es lo que quieres? ¿Solo accediendo a la cadena bytewise? Puede convertir fácilmente una string a []byte usando:

bytes := []byte(str)

Pero esto no es una matriz, es una rebanada. Además, byte ! = rune . En caso de que quiera operar con "caracteres", debe usar la rune ... no el byte .

Answer 4

Para convertir de una cadena a un segmento 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 sector:

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

• La función de copy incorporada solo copia en un sector de un sector.
• Las matrices son "los datos subyacentes", mientras que los segmentos son "una ventana gráfica de datos subyacentes".
• Usando [:] hace que una matriz califique como una porción.
• Una cadena califica como una porción.
• Si la cadena es demasiado larga, copy solo copiará la parte de la cadena que se ajuste.

Este codigo

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

... da la siguiente salida:

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 el Go Playground.

Answer 5

Pedazo de pastel:

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

Answer 6

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]

Answer 7

Seguro y sencillo:

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

Answer 8

Terminé creando métodos específicos para hacer esto. Al igual que el paquete de encoding/binary 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]

Fíjate en cómo quería relleno a la izquierda, no a la derecha.

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

Answer 9

Yo pienso que es mejor..

package main

import "fmt"

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

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