go - array - convert[] byte to string



Como atribuir uma string a um array de bytes (6)

Vá, converta uma string para uma fatia de bytes

Você precisa de uma maneira rápida de converter uma string [] para o tipo de byte []. 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 estejam no tipo de byte [].

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

que é útil ao usar o ioutil.WriteFile, que aceita uma fatia de bytes como seu 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)))
}

Saída:

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

Por favor, verifique o link playground

Eu quero atribuir string à matriz de bytes:

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

Tem outro método?


Acabou criando métodos específicos de array para fazer isso. Muito parecido com o pacote de encoding/binary 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)

Saída:

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

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

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


Eu acho melhor..

package main

import "fmt"

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

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


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

Uma maneira de converter uma fatia de por exemplo []byte para [20]byte é realmente alocar um [20]byte que você pode fazer usando var [20]byte (porque é um valor ... não make necessário) e copie os dados para ele:

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

Essencialmente, o que muitas outras respostas erram é que o []type NÃO é um array.

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

Quando usar reflect []T não é do tipo Array mas do tipo Slice e [n]T é do tipo Array.

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

Às vezes, isso pode ser complicado porque muitas funções operam, por exemplo, no []byte enquanto algumas funções retornam [n]byte (mais notavelmente as funções hash em crypto/* ). Um hash sha256, por exemplo, é de [32]byte e não []byte portanto, quando os iniciantes tentam escrevê-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 converter facilmente uma string em []byte usando:

bytes := []byte(str)

mas isso não é uma matriz, é uma fatia. Além disso, byte ! = rune . No caso de você querer operar em "personagens" você precisa usar rune ... não byte .


Para converter de uma string em uma fatia de byte, string -> []byte :

[]byte(str)

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

arr[:]

Para copiar uma string para um array, string -> [20]byte :

copy(arr[:], str)

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

copy(arr[:], []byte(str))
  • A função de copy incorporada apenas copia para uma fatia, a partir de uma fatia.
  • Os arrays são "os dados subjacentes", enquanto os slices são "um viewport para os dados subjacentes".
  • Usando [:] faz uma matriz qualificar como uma fatia.
  • Uma string não se qualifica como uma fatia que pode ser copiada, mas qualifica como uma fatia da qual pode ser copiada.
  • Se a string for muito longa, a copy apenas a parte da string que se encaixa.

Este código:

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

... dá 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)

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

Saída:

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]




go