Як призначити рядок до масиву байтів

Я хочу призначити рядок байтовому масиву:

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

Наприклад,

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] привіт, світ

Перевірте посилання на ігровий майданчик

Закінчилося створення специфічних методів для цього масиву. Так само, як кодування / бінарний пакет із конкретними методами для кожного типу 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. Якщо ви хочете оперувати "символами", вам потрібно скористатися rune... ні byte.