Comment attribuer une chaîne à un tableau d'octets

Je veux affecter une chaîne au tableau d'octets:

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

Vous avez une autre méthode?

Sûr et simple:

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

Pour convertir une chaîne en une tranche d'octets string -> []byte:

[]byte(str)

Pour la conversion d' un tableau à une tranche, [20]byte -> []byte:

arr[:]

Pour la copie d' une chaîne à un tableau, string -> [20]byte:

copy(arr[:], str)

Identique à ci-dessus, mais en convertissant explicitement la chaîne en tranche d'abord:

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

• La copyfonction intégrée copie uniquement sur une tranche, à partir de une tranche.
• Les tableaux sont "les données sous-jacentes", tandis que les tranches sont "une fenêtre dans les données sous-jacentes".
• L'utilisation [:]fait qu'un tableau peut être qualifié de tranche.
• Une chaîne ne se qualifie pas comme une tranche qui peut être copié à , mais il est considéré comme une tranche qui peut être copié à partir ( les chaînes sont immuables).
• Si la chaîne est trop longue, copyne copiera que la partie de la chaîne qui convient.

Ce code:

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

... donne la sortie suivante:

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

Je l'ai également rendu disponible sur le Go Playground

Par exemple,

package main

import "fmt"

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

Production:

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]

Part de gâteau:

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

Je pense que c'est mieux..

package main

import "fmt"

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

Vérifiez ici: http://play.golang.org/p/vpnAWHZZk7

Allez, convertissez une chaîne en une tranche d'octets

Vous avez besoin d'un moyen rapide pour convertir une chaîne [] en type [] octets. À utiliser dans des situations telles que le stockage de données texte dans un fichier à accès aléatoire ou tout autre type de manipulation de données qui nécessite que les données d'entrée soient de type [] octet.

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

ce qui est utile lorsque vous utilisez ioutil.WriteFile, qui accepte une tranche d'octets comme paramètre de données:

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

Un autre exemple

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

Production:

[104 101 108 108 111 32 119 111 114 108 100] bonjour le monde

Veuillez vérifier le lien aire de jeux

Nous avons fini par créer des méthodes spécifiques aux tableaux pour ce faire. Tout comme le paquet encodage / binaire avec des méthodes spécifiques pour chaque type int. Par exemple 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)

Production:

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

Remarquez comment je voulais un rembourrage à gauche, pas à droite.

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

Outre les méthodes mentionnées ci-dessus, vous pouvez également faire un tour comme

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

Va jouer: http://play.golang.org/p/xASsiSpQmC

Vous ne devriez jamais utiliser ceci :-)

Les tableaux sont des valeurs ... les tranches sont plus comme des pointeurs. Ce n'est [n]typepas compatible avec []typecar ce sont fondamentalement deux choses différentes. Vous pouvez obtenir une tranche qui pointe vers un tableau en utilisant arr[:]qui renvoie une tranche qui a arrcomme stockage de sauvegarde.

Une façon de convertir une tranche de, par exemple, []byteen [20]byteest d'allouer réellement [20]bytece que vous pouvez faire en utilisant var [20]byte(car c'est une valeur ... pas makenécessaire), puis de copier des données dedans:

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

Essentiellement, ce que beaucoup d'autres réponses se trompent, c'est que ce []typen'est PAS un tableau.

[n]Tet ce []Tsont des choses complètement différentes!

Lors de l'utilisation de la réflexion []Tn'est pas de type Array mais de type Slice et [n]Tde type Array.

Vous ne pouvez pas non plus utiliser map[[]byte]Tmais vous pouvez utilisermap[[n]byte]T .

Cela peut parfois être fastidieux car de nombreuses fonctions fonctionnent par exemple sur []byte tandis que certaines fonctions reviennent [n]byte(notamment les fonctions de hachage dans crypto/*). Un hachage sha256 par exemple l'est [32]byteet ne l' est pas []bytelorsque les débutants essaient de l'écrire dans un fichier par exemple:

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

ils obtiendront une erreur. La bonne façon est d'utiliser

w.Write(sum[:])

Mais que veux-tu? Vous accédez simplement à la chaîne par octet? Vous pouvez facilement convertir un stringen en []byteutilisant:

bytes := []byte(str)

mais ce n'est pas un tableau, c'est une tranche. Aussi byte!! rune. Dans le cas où vous souhaitez opérer sur des "personnages", vous devez utiliser rune... pas byte.