Respostas:
Seguro e simples:
[]byte("Here is a string....")
[]byte
e não uma matriz definida de bytes [20]byte
ao converter uma string em bytes ... Não acredita em mim? Confira a resposta de Rob Pike neste tópico
[]byte("one", "two")
?
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))
copy
função interna copia apenas para uma fatia, de uma fatia.[:]
faz com que uma matriz seja qualificada como uma fatia.copy
copia 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
b[i] = []byte("A")[0]
funciona, mas b[i] = 'A'
acaba sendo muito mais limpo.
b[1] = '本'
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]
s
, A função de cópia `não é burra. Anexando e copiando fatias : "O número de elementos copiados é o mínimo de len (src) e len (dst)."
Pedaco de bolo:
arr := []byte("That's all folks!!")
[]byte
é preferível às matrizes [20]byte
. A resposta está correta com base nas melhores práticas; se as especificações ou o código exigirem matrizes, use-o copy
(consulte exemplos em outras partes deste encadeamento).
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
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.
byte16PutString
é uma espécie de reimplementação da copy
função embutida, que apenas suporta a criação de novas matrizes em vez de usar uma existente. copy
possui suporte especial ao compilador, para que ele possa lidar com diferentes tipos de argumentos e provavelmente possui uma implementação de alto desempenho oculta. Além disso, a pergunta do OP perguntou sobre a escrita de uma string para uma matriz existente, em vez de alocar um novo, embora a maioria das outras respostas parecem estar ignorando isso também ...
answer
está correto cada corpo está aqui para aprender e encorajar outros
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 :-)
[]byte
objeto adequado usando sua "conversão" - falha muito quando tenta alterar p
, consulte: play.golang.org/p/WHGl756ucj . No seu caso, não saiba por que você prefere o dobro do risco ao b := []byte(s)
método.
cap()
de tamanho arbitrário, o que significa que está lendo na memória desconhecida. Para que isso seja correto, acho que você precisará alocar o reflect.SliceHeader
tamanho completo e definir manualmente o cap
. Algo assim: play.golang.org/p/fBK4dZM-qD
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 arr
ao fazer backup do armazenamento.
Uma maneira de converter uma fatia de, por exemplo, []byte
a [20]byte
é realmente alocar um [20]byte
que 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, []byte
enquanto algumas funções retornam [n]byte
(principalmente as funções hash crypto/*
). Um hash sha256, por exemplo, é [32]byte
e não é []byte
assim 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 string
em []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
.
str
for maior que o comprimento dearr
, você receberá um erro "índice fora do intervalo".