Go语言中高效处理字节切片与数值类型转换

func (packet *Packet) GetInt32Manual(at int) int32 {
    // 这种方法假设数据是大端序（Big Endian），且代码冗长
    return int32(packet.buffer[at]) << 24 +
        int32(packet.buffer[at+1]) << 16 +
        int32(packet.buffer[at+2]) << 8 +
        int32(packet.buffer[at+3])
}

package main

import (
    "encoding/binary"
    "fmt"
    "math" // 用于浮点数转换
)

// Packet 结构体，包含字节缓冲区
type Packet struct {
    buffer []byte
}

// Int32 从字节切片中指定位置读取4字节，并按大端序转换为int32
func (p *Packet) Int32(at int) int32 {
    // 重要的边界检查，防止切片越界
    if at < 0 || at+4 > len(p.buffer) {
        panic(fmt.Sprintf("index out of bounds for int32 conversion: at=%d, buffer length=%d", at, len(p.buffer)))
    }
    // 使用 binary.BigEndian.Uint32 读取4字节并转换为 uint32
    // 然后将其强制转换为 int32
    return int32(binary.BigEndian.Uint32(p.buffer[at : at+4]))
}

// Float32 从字节切片中指定位置读取4字节，并按大端序转换为float32
func (p *Packet) Float32(at int) float32 {
    // 重要的边界检查
    if at < 0 || at+4 > len(p.buffer) {
        panic(fmt.Sprintf("index out of bounds for float32 conversion: at=%d, buffer length=%d", at, len(p.buffer)))
    }
    // 先转换为 uint32，然后使用 math.Float32frombits 将其位模式解释为 float32
    return math.Float32frombits(binary.BigEndian.Uint32(p.buffer[at : at+4]))
}

package main

import (
    "encoding/binary"
    "fmt"
    "math"
)

type Packet struct {
    buffer []byte
}

// Int32 从字节切片中指定位置读取4字节，并按大端序转换为int32
func (p *Packet) Int32(at int) int32 {
    if at < 0 || at+4 > len(p.buffer) {
        // 在实际应用中，建议返回错误而不是panic
        panic(fmt.Sprintf("index out of bounds for int32 conversion: at=%d, buffer length=%d", at, len(p.buffer)))
    }
    return int32(binary.BigEndian.Uint32(p.buffer[at : at+4]))
}

// Float32 从字节切片中指定位置读取4字节，并按大端序转换为float32
func (p *Packet) Float32(at int) float32 {
    if at < 0 || at+4 > len(p.buffer) {
        // 在实际应用中，建议返回错误而不是panic
        panic(fmt.Sprintf("index out of bounds for float32 conversion: at=%d, buffer length=%d", at, len(p.buffer)))
    }
    return math.Float32frombits(binary.BigEndian.Uint32(p.buffer[at : at+4]))
}

func main() {
    // 示例字节切片：
    // buffer: {0x01, 0x02, 0x00, 0x00, 0xFF, 0xFF, 0x07}
    // 从索引2开始的4字节是：0x00, 0x00, 0xFF, 0xFF
    // 大端序表示为 0x0000FFFF，转换为十进制是 65535
    p := &Packet{buffer: []byte{0x01, 0x02, 0x00, 0x00, 0xFF, 0xFF, 0x07}}

    fmt.Println("从索引2开始，读取int32:", p.Int32(2)) // Output: 65535
    // 0x0000FFFF 作为 uint32 的位模式解释为 float32，是一个非常小的数
    fmt.Println("从索引2开始，读取float32:", p.Float32(2)) // Output: 9.1834e-41

    // 另一个 float32 示例：表示 1.0
    // IEEE 754 单精度浮点数 1.0 的十六进制表示是 0x3F800000
    p2 := &Packet{buffer: []byte{0x3F, 0x80, 0x00, 0x00}}
    fmt.Println("从索引0开始，读取float32 (1.0):", p2.Float32(0)) // Output: 1

    // 演示小端序 (Little Endian) 的使用
    // 字节切片 {0xFF, 0xFF, 0x00, 0x00}
    // 如果按小端序读取 uint32，则表示 0x0000FFFF
    // 如果按大端序读取 uint32，则表示 0xFFFFFFFF0000
    p3 := &Packet{buffer: []byte{0xFF, 0xFF, 0x00, 0x00}}
    valLittleEndian := binary.LittleEndian.Uint32(p3.buffer[0:4])
    fmt.Println("小端序读取 uint32 (0x0000FFFF):", valLittleEndian) // Output: 65535

    valBigEndian := binary.BigEndian.Uint32(p3.buffer[0:4])
    fmt.Println("大端序读取 uint32 (0xFFFFFF0000):", valBigEndian) // Output: 4294901760
}