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

Надежно и просто:

[]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

Пойдите, преобразуйте строку в срез байтов

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

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

Проверьте ссылку детская площадка

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

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

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

Играйте: 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. Если вы хотите работать с «символами», вам нужно использовать _30 _..., а не byte.