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

Преобразование строки в массив байтов в Go

Преобразование строки в массив байтов в Go — одна из фундаментальных операций, которая имеет несколько нюансов из-за особенностей внутреннего представления строк и байтовых срезов. Рассмотрим основные способы.

Прямое преобразование с помощью []byte()

Самый простой и распространённый способ — использование явного приведения типа:

package main

import "fmt"

func main() {
    str := "Привет, Go!"
    byteArray := []byte(str)
    
    fmt.Printf("Исходная строка: %s\n", str)
    fmt.Printf("Массив байтов: %v\n", byteArray)
    fmt.Printf("Длина: %d байт\n", len(byteArray))
    // Для строки с кириллицей длина в байтах будет больше, чем количество символов
}

Важно понимать: при таком преобразовании создаётся новая копия данных. Строки в Go иммутабельны (неизменяемы), а байтовые срезы — мутабельны. После преобразования изменения в байтовом срезе не влияют на исходную строку.

str := "Hello"
bytes := []byte(str)
bytes[0] = 'h' // Меняем первый байт
fmt.Println(str)    // "Hello" - строка не изменилась
fmt.Println(string(bytes)) // "hello" - изменился байтовый срез

Особенности кодировки UTF-8

Go использует UTF-8 для кодирования строк по умолчанию. Это важно учитывать при работе с многобайтовыми символами:

package main

import "fmt"

func main() {
    str := "世界" // Китайские иероглифы
    bytes := []byte(str)
    
    fmt.Printf("Символов: %d\n", len(str)) // 2 символа
    fmt.Printf("Байтов: %d\n", len(bytes)) // 6 байт (по 3 на каждый символ UTF-8)
    
    // Итерация по байтам
    for i, b := range bytes {
        fmt.Printf("Байт [%d]: %02x\n", i, b)
    }
}

Альтернативные подходы

Хотя []byte(str) является основным способом, существуют и другие варианты:

1. Использование copy() для предварительно выделенного массива:

str := "example"
bytes := make([]byte, len(str))
copy(bytes, str) // Копирование строки в байтовый срез

1. Преобразование через strings.Builder (в некоторых сценариях):

import "strings"

var builder strings.Builder
builder.WriteString("test")
bytes := []byte(builder.String())

1. Использование unsafe (только для особых случаев!):

import "unsafe"

str := "unsafe example"
// Прямое преобразование без копирования
bytes := *(*[]byte)(unsafe.Pointer(&str))
// ВНИМАНИЕ: изменять такой срез нельзя, это приведёт к неопределённому поведению

Производительность и выделение памяти

При использовании []byte(str) происходит аллокация памяти под новый байтовый срез и копирование данных. Для оптимизации в критически важных участках кода можно использовать следующие подходы:

// Бенчмарк стандартного подхода
func StringToBytes(s string) []byte {
    return []byte(s)
}

// Использование unsafe для избежания копирования (с осторожностью!)
func StringToBytesUnsafe(s string) []byte {
    return *(*[]byte)(unsafe.Pointer(&struct {
        string
        Cap int
    }{s, len(s)}))
}

Практические рекомендации

1. Для большинства случаев используйте стандартное преобразование []byte(str). Оно безопасно и понятно.
2. Для строк, содержащих ASCII-символы, длина в байтах равна количеству символов.
3. Для многобайтовых UTF-8 символов помните, что индексация байтового массива не соответствует индексации символов.
4. Если нужен доступ к байтам без изменения — рассмотрите использование unsafe, но только с полным пониманием последствий.
5. Для обратного преобразования используйте string(bytes), который также создаёт копию данных.

Пример комплексного использования

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    str := "Go语言编程"
    
    // Преобразование в байты
    bytes := []byte(str)
    
    fmt.Printf("Строка: %s\n", str)
    fmt.Printf("Байты (hex): %x\n", bytes)
    fmt.Printf("Длина строки в символах: %d\n", utf8.RuneCountInString(str))
    fmt.Printf("Длина в байтах: %d\n", len(bytes))
    
    // Работа с отдельными символами
    for i, r := range str {
        fmt.Printf("Символ %d: %c (код: %U)\n", i, r, r)
    }
}

Выбор метода преобразования зависит от конкретной задачи: требуется ли модификация данных, важна ли производительность, работаете ли вы только с ASCII или с Unicode. В 95% случаев стандартного []byte(str) достаточно и является наиболее идиоматичным решением.