Как int32 добавить в массив из 4 byte?

Добавление int32 в массив из 4 байт в Go

В Go преобразование int32 в массив из 4 байт (тип [4]byte) выполняется через преобразование типов (type conversion) или битовые операции (bit manipulation). Существует несколько основных подходов, каждый с своими особенностями.

1. Использование binary.Write и binary.Read (стандартный подход)

Стандартный пакет encoding/binary предоставляет функции для работы с бинарными данными, включая преобразование целых чисел в последовательности байт.

import "encoding/binary"

func int32ToByteArray(value int32) [4]byte {
    var arr [4]byte
    binary.LittleEndian.PutUint32(arr[:], uint32(value))
    return arr
}

func byteArrayToInt32(arr [4]byte) int32 {
    return int32(binary.LittleEndian.Uint32(arr[:]))
}

Ключевые моменты:

• Используются функции PutUint32 и Uint32 для преобразования
• Необходимо явно указать порядок байт (byte order):
  • LittleEndian: младший байт сначала (используется в x86 архитектуре)
  • BigEndian: старший байт сначала (сетевые протоколы, некоторые процессоры)
• Преобразование через uint32 обеспечивает корректное представление знаковых чисел

2. Прямое преобразование через unsafe (быстрый метод)

Для максимальной скорости можно использовать unsafe-преобразования, но это требует осторожности из-за возможных проблем с безопасностью памяти.

import "unsafe"

func int32ToByteArrayUnsafe(value int32) [4]byte {
    return *(*[4]byte)(unsafe.Pointer(&value))
}

func byteArrayToInt32Unsafe(arr [4]byte) int32 {
    return *(*int32)(unsafe.Pointer(&arr))
}

Преимущества и риски:

• Прямое преобразование без копирования данных
• Может нарушать гарантии безопасности памяти Go
• Не учитывает порядок байт (использует порядок текущей архитектуры)
• Используется только в критически важных по скорости участках кода

3. Битовая маскировка и сдвиги (ручной контроль)

Для полного контроля над процессом можно использовать битовые операции.

func int32ToByteArrayManual(value int32) [4]byte {
    return [4]byte{
        byte(value >> 0),  // Младший байт
        byte(value >> 8),
        byte(value >> 16),
        byte(value >> 24), // Старший байт
    }
}

func byteArrayToInt32Manual(arr [4]byte) int32 {
    return int32(arr[0])<<0 | int32(arr[1])<<8 | 
           int32(arr[2])<<16 | int32(arr[3])<<24
}

Особенности ручного метода:

• Явное указание порядка байт через последовательность операций
• Полный контроль над каждым байтом
• Подходит для специфичных форматов данных
• Менее эффективен по сравнению с другими методами

4. Использование буфера (для потоковой обработки)

При работе с потоками данных удобно использовать bytes.Buffer вместе с binary.Write/binary.Read.

import (
    "bytes"
    "encoding/binary"
)

func int32ToBytesBuffer(value int32) []byte {
    buf := new(bytes.Buffer)
    binary.Write(buf, binary.LittleEndian, value)
    return buf.Bytes()
}

Сравнение методов

Практический пример с тестами

package main

import (
    "encoding/binary"
    "fmt"
)

func main() {
    var num int32 = 0x12345678 // Пример значения
    
    // Метод 1: через binary
    var arr1 [4]byte
    binary.LittleEndian.PutUint32(arr1[:], uint32(num))
    fmt.Printf("binary.LittleEndian: %v\n", arr1)
    
    // Метод 2: ручной сдвиг для BigEndian
    arr2 := [4]byte{
        byte(num >> 24),
        byte(num >> 16),
        byte(num >> 8),
        byte(num >> 0),
    }
    fmt.Printf("Manual BigEndian: %v\n", arr2)
    
    // Восстановление значения
    restored1 := int32(binary.LittleEndian.Uint32(arr1[:]))
    restored2 := int32(arr2[0])<<24 | int32(arr2[1])<<16 |
                 int32(arr2[2])<<8 | int32(arr2[3])<<0
    fmt.Printf("Restored: %d, %d\n", restored1, restored2)
}

Ключевые рекомендации

• Для большинства случаев используйте encoding/binary — это безопасный и стандартизированный подход
• Учитывайте порядок байт — неправильный выбор приводит к ошибкам при передаче данных между системами
• Для межплатформенной совместимости используйте конкретный порядок байт (часто BigEndian для сетевых протоколов)
• Проверяйте границы массива — убедитесь, что массив действительно имеет размер 4 байта
• Избегайте unsafe в обычном коде из-за рисков безопасности памяти и проблем с портируемостью

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