Как назначить строку байтам массиву

Ответ 1

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

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

Ответ 2

Для преобразования строки в секцию байта 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

Ответ 3

Например,

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]

Ответ 4

Кусок торта:

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

Ответ 5

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

package main

import "fmt"

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

Отметьте здесь: http://play.golang.org/p/vpnAWHZZk7

Ответ 6

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] привет мир

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

Ответ 7

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

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

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

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

Ответ 8

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

Ответ 9

Массивы - это значения... срезы больше похожи на указатели. То есть [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.