So weisen Sie dem Byte-Array eine Zeichenfolge zu

Ich möchte dem Bytes-Array einen String zuweisen:

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

Haben Sie eine andere Methode?

Sicher und einfach:

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

Zum Konvertieren von einer Zeichenfolge in ein Byte-Slice string -> []byte:

[]byte(str)

Zum Konvertieren eines Arrays in ein Slice [20]byte -> []byte:

arr[:]

Zum Kopieren einer Zeichenfolge in ein Array string -> [20]byte:

copy(arr[:], str)

Wie oben, jedoch wird die Zeichenfolge zuerst explizit in ein Slice konvertiert:

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

• Die Einbau- copyFunktion nur Kopien auf eine Scheibe, aus einem Stück.
• Arrays sind "die zugrunde liegenden Daten", während Slices "ein Ansichtsfenster für zugrunde liegende Daten" sind.
• Durch [:]die Verwendung wird ein Array als Slice qualifiziert.
• Eine Zeichenfolge nicht als Scheibe zu qualifizieren , die kopiert werden können , um , aber es gilt als eine Scheibe , die kopiert werden können , aus (Strings sind unveränderlich).
• Wenn die Zeichenfolge zu lang ist, copywird nur der Teil der Zeichenfolge kopiert, der passt.

Dieser Code:

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

... gibt folgende Ausgabe:

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

Ich habe es auch auf dem Go Playground zur Verfügung gestellt

Zum Beispiel,

package main

import "fmt"

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

Ausgabe:

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]

Stück Kuchen:

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

Ich denke es ist besser..

package main

import "fmt"

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

Überprüfen Sie hier: http://play.golang.org/p/vpnAWHZZk7

Konvertieren Sie eine Zeichenfolge in ein Byte-Slice

Sie benötigen eine schnelle Möglichkeit, eine [] Zeichenfolge in einen [] Bytetyp zu konvertieren. Zur Verwendung in Situationen wie dem Speichern von Textdaten in einer Direktzugriffsdatei oder einer anderen Art der Datenmanipulation, bei der die Eingabedaten vom Typ [] Byte sein müssen.

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

Dies ist nützlich, wenn ioutil.WriteFile verwendet wird, das einen Byte-Slice als Datenparameter akzeptiert:

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

Ein anderes Beispiel

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

Ausgabe:

[104 101 108 108 111 32 119 111 114 108 100] Hallo Welt

Bitte überprüfen Sie den Link Spielplatz

Am Ende wurden Array-spezifische Methoden erstellt, um dies zu tun. Ähnlich wie das Codierungs- / Binärpaket mit spezifischen Methoden für jeden int-Typ. Zum Beispiel 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)

Ausgabe:

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

Beachten Sie, wie ich links und nicht rechts auffüllen wollte.

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

Neben den oben genannten Methoden können Sie auch einen Trick ausführen

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

Geh spielen: http://play.golang.org/p/xASsiSpQmC

Du solltest das niemals benutzen :-)

Arrays sind Werte ... Slices ähneln eher Zeigern. Das ist [n]typenicht kompatibel, []typeda es sich grundsätzlich um zwei verschiedene Dinge handelt. Sie können ein Slice erhalten, das auf ein Array verweist, indem Sie arr[:]ein Slice zurückgeben, das arrals Backup-Speicher dient.

Eine Möglichkeit, ein Slice von beispielsweise []bytein zu konvertieren, besteht darin, ein Slice [20]bytezuzuweisen, [20]bytedas Sie mithilfe von verwenden können var [20]byte(da es sich um einen Wert handelt ... nicht makeerforderlich), und dann Daten darin zu kopieren:

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

Was viele andere Antworten falsch machen, ist, dass []typees sich NICHT um ein Array handelt.

[n]Tund []Tsind ganz andere Dinge!

Bei Verwendung von Reflect []Thandelt es sich nicht um ein Array, sondern um ein Slice und ein [n]TArray.

Sie können auch nicht verwenden, map[[]byte]Taber Sie können verwendenmap[[n]byte]T .

Dies kann manchmal umständlich sein, da beispielsweise viele Funktionen ausgeführt werden, []bytewährend einige Funktionen zurückkehren [n]byte(insbesondere die Hash-Funktionen in crypto/*). Ein sha256-Hash zum Beispiel ist [32]byteund nicht []byte, wenn Anfänger versuchen, ihn in eine Datei zu schreiben, zum Beispiel:

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

Sie erhalten einen Fehler. Die richtige Art zu verwenden ist

w.Write(sum[:])

Was möchten Sie jedoch? Nur byteweise auf die Zeichenfolge zugreifen? Sie können ganz einfach ein konvertieren stringzu []byteverwenden:

bytes := []byte(str)

Aber dies ist kein Array, es ist ein Slice. Auch byte! = rune. Wenn Sie mit "Zeichen" arbeiten möchten, müssen Sie rune... nicht verwenden byte.