Как преобразовать строку (string) в срез байтов ([]byte) в Go?

Правильный способ преобразования string в []byte

В Go для преобразования строки в срез байтов используется простое приведение типа: []byte("строка"). Это стандартный и идиоматичный способ, который используют все опытные разработчики. Ваша вторая попытка с copy() тоже работает, но она избыточна и менее эффективна.

package main

import "fmt"

func main() {
    s := "Hello, Go!"
    b := []byte(s) // Простое приведение типа

    fmt.Printf("Срез байтов: %v\n", b)       // [72 101 108 108 111 44 32 71 111 33]
    fmt.Printf("Как строка: %s\n", string(b)) // Обратное преобразование

    // Теперь b — изменяемый срез, можно менять элементы
    b[0] = 'h'
    fmt.Println(string(b)) // "hello, Go!"
}

Почему нельзя просто присвоить b = s?

В Go string и []byte — это разные типы с разной семантикой:

• string — неизменяемая (immutable) структура, которая гарантирует, что содержимое строки никогда не изменится. Это позволяет безопасно использовать строки в качестве ключей map или в конкурентном доступе.
• []byte — изменяемый срез (slice), который можно модифицировать, добавлять элементы и т.д.

Прямое присваивание запрещено, потому что это нарушило бы гарантию неизменности строки. Если бы вы могли присвоить строку срезу, то могли бы изменить её содержимое, что привело бы к неопределённому поведению.

Что происходит при []byte(s)?

При приведении типа []byte(s) компилятор Go создаёт новый срез и копирует все байты строки в его память. Это необходимо, потому что срез должен быть независимым и изменяемым. Важно понимать, что:

• Если строка маленькая (до 32 байт), то копирование происходит на стеке, что очень быстро.
• Если строка большая, копирование выделяет память в куче (heap).
• Обратное преобразование string(b) также создаёт новую строку и копирует данные.

Когда использовать copy()?

Метод copy() полезен, когда у вас уже есть выделенный срез и вы хотите скопировать в него данные из строки. Например:

buf := make([]byte, 1024)
n := copy(buf, "Hello") // копирует "Hello" в начало buf
// buf теперь содержит [72 101 108 108 111 0 0 ...]

Но для простого преобразования строки в срез используйте []byte(s) — это короче, понятнее и производительнее.

Важное предостережение

В Go строки хранятся в кодировке UTF-8, поэтому []byte(s) даёт вам именно байты UTF-8, а не руны (runes). Если вам нужно работать с символами Unicode, используйте []rune(s).

s := "Привет, мир!"
b := []byte(s)
r := []rune(s)

fmt.Println(len(b)) // 20 (байтов)
fmt.Println(len(r)) // 12 (рун)

В итоге: для преобразования строки в срез байтов пишите []byte(s). Это просто, эффективно и является стандартом в Go-сообществе.

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buf bytes.Buffer
    buf.WriteString("Hello, ")
    buf.WriteString("Go!")

    // Получаем срез байтов из буфера
    b := buf.Bytes()
    fmt.Println(string(b)) // "Hello, Go!"

    // Буфер можно безопасно модифицировать
    buf.WriteByte(' ')
    buf.Write([]byte("World"))
    fmt.Println(buf.String()) // "Hello, Go! World"
}