Как присвоить строку массиву байтов

Я хочу назначить строку в байтовом массиве:

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

Есть другой метод?

Безопасно и просто:

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

Для преобразования строки в фрагмент байта string -> []byte:

[]byte(str)

Для преобразования массива в срез [20]byte -> []byte:

arr[:]

Для копирования строки в массив string -> [20]byte:

copy(arr[:], str)

То же, что и выше, но сначала явно преобразуем строку в фрагмент:

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

• Встроенная copyфункция копирует только в срез, из среза.
• Массивы - это «базовые данные», а срезы - «область просмотра базовых данных».
• Использование [:]делает массив квалифицированным как срез.
• Строка не квалифицируется как срез , который может быть скопирован на , но это квалифицируется как срез , который может быть скопирован из (строки являются неизменными).
• Если строка слишком длинная, copyбудет скопирована только та часть строки, которая подходит.

Этот код:

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

... дает следующий вывод:

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

Я также сделал его доступным на Go Playground

Например,

package main

import "fmt"

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

Вывод:

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]

Кусок пирога:

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

Я думаю, что это лучше ..

package main

import "fmt"

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

Проверьте здесь: http://play.golang.org/p/vpnAWHZZk7

Go, преобразовать строку в байтовый срез

Вам нужен быстрый способ преобразования строки [] в тип байта []. Для использования в ситуациях, таких как сохранение текстовых данных в файле произвольного доступа или другого типа манипулирования данными, который требует, чтобы входные данные имели тип байта [].

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

что полезно при использовании ioutil.WriteFile, который принимает срез байтов в качестве параметра данных:

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

Другой пример

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

Вывод:

[104 101 108 108 111 32 119 111 114 108 100] привет мир

Пожалуйста, проверьте ссылку игровая площадка

Закончилось создание специальных методов для этого. Очень похоже на кодировку / двоичный пакет с конкретными методами для каждого типа int. Например 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)

Вывод:

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

Обратите внимание, как я хотел заполнить слева, а не справа.

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

Помимо методов, упомянутых выше, вы также можете сделать трюк, как

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

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

Вы никогда не должны использовать это :-)

Массивы - это значения ... срезы больше похожи на указатели. Это [n]typeнесовместимо с тем, []typeчто это принципиально две разные вещи. Вы можете получить фрагмент, который указывает на массив, используя arr[:]который возвращает фрагмент, который имеет в arrкачестве резервного хранилища.

Например, один из способов преобразования фрагмента []byteв [20]byte- это фактически выделить то, [20]byteчто вы можете сделать, используя var [20]byte(так как это значение ... не makeнужно), а затем скопировать в него данные:

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

По сути, многие другие ответы не так, что []typeэто не массив.

[n]Tи []Tэто совершенно разные вещи!

При использовании отражение []Tимеет вид не Array, а типа Slice и [n]Tимеет вид Array.

Вы также не можете использовать, map[[]byte]Tно вы можете использовать map[[n]byte]T.

Иногда это может быть громоздким, потому что многие функции работают, например, в []byteто время как некоторые функции возвращают [n]byte(особенно хеш-функции в crypto/*). Например, хэш sha256 - это [32]byteне []byteтак, когда новички пытаются записать его в файл, например:

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

они получат ошибку. Правильный способ заключается в использовании

w.Write(sum[:])

Однако что вы хотите? Просто доступ к строке байтово? Вы можете легко преобразовать stringв []byteиспользование:

bytes := []byte(str)

но это не массив, это кусочек. Также byte! = rune. Если вы хотите оперировать «персонажами», вам нужно использовать rune... нет byte.