Go 语言中整数与二进制的转换、字符串操作及字节序列化实践

// FormatInt(i int64, base int) string
// 将 int64 类型的整数 i 转换为 base 进制的字符串。
// 对于二进制，base 应设为 2。
package main

import (
    "fmt"
    "strconv"
)

func main() {
    num := 12
    binaryString := strconv.FormatInt(int64(num), 2)
    fmt.Printf("整数 %d 转换为二进制字符串: %s\n", num, binaryString) // 输出: 1100
}

// reverseString 函数用于反转给定的字符串
func reverseString(s string) string {
    runes := []rune(s) // 将字符串转换为 rune 切片以处理 Unicode 字符，虽然这里不是必须的，但这是一个好习惯
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

// ParseInt(s string, base int, bitSize int) (i int64, err error)
// 将 s 字符串解析为 base 进制的整数。
// bitSize 指定结果的位数（如 0、8、16、32、64），0 表示根据字符串自动推断或使用 int 类型。
// 对于二进制字符串，base 应设为 2。
package main

import (
    "fmt"
    "strconv"
)

func main() {
    reversedBinaryString := "0011"
    // ParseInt 返回 int64 类型和错误
    parsedInt, err := strconv.ParseInt(reversedBinaryString, 2, 64)
    if err != nil {
        fmt.Printf("解析错误: %v\n", err)
        return
    }
    fmt.Printf("反转的二进制字符串 %s 转换为整数: %d\n", reversedBinaryString, parsedInt) // 输出: 3
}

package main

import (
    "fmt"
    "strconv"
)

// reverseString 函数用于反转给定的字符串
func reverseString(s string) string {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

func main() {
    inputNum := 12
    fmt.Printf("原始整数: %d\n", inputNum)

    // 1. 整数转换为二进制字符串
    binaryStr := strconv.FormatInt(int64(inputNum), 2)
    fmt.Printf("转换为二进制字符串: %s\n", binaryStr) // 输出: 1100

    // 2. 反转二进制字符串
    reversedBinaryStr := reverseString(binaryStr)
    fmt.Printf("反转后的二进制字符串: %s\n", reversedBinaryStr) // 输出: 0011

    // 3. 反转后的二进制字符串转换为整数
    outputNum, err := strconv.ParseInt(reversedBinaryStr, 2, 64)
    if err != nil {
        fmt.Printf("转换错误: %v\n", err)
        return
    }
    fmt.Printf("反转后转换为整数: %d\n", outputNum) // 输出: 3
}

package main

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

func main() {
    // 原始整数
    originalInt := int32(5247)
    fmt.Printf("原始整数: %d (类型: %T)\n", originalInt, originalInt)

    // 创建一个 bytes.Buffer 作为缓冲区
    buf := new(bytes.Buffer)

    // 1. 将整数写入缓冲区 (序列化)
    // 使用 BigEndian 字节序
    err := binary.Write(buf, binary.BigEndian, originalInt)
    if err != nil {
        fmt.Println("写入错误:", err)
        return
    }
    fmt.Printf("写入缓冲区后的字节表示 (BigEndian): %x\n", buf.Bytes())

    // 2. 从缓冲区读取整数 (反序列化)
    var readInt int32 // 声明一个变量来存储读取的整数
    err = binary.Read(buf, binary.BigEndian, &readInt) // 注意这里需要传入指针
    if err != nil {
        fmt.Println("读取错误:", err)
        return
    }
    fmt.Printf("从缓冲区读取的整数: %d (类型: %T)\n", readInt, readInt)

    // 验证结果
    if originalInt == readInt {
        fmt.Println("序列化和反序列化成功，结果一致。")
    } else {
        fmt.Println("序列化和反序列化失败，结果不一致。")
    }

    // 尝试使用 LittleEndian 写入和读取
    fmt.Println("\n--- 使用 LittleEndian ---")
    buf = new(bytes.Buffer) // 重置缓冲区
    err = binary.Write(buf, binary.LittleEndian, originalInt)
    if err != nil {
        fmt.Println("写入错误:", err)
        return
    }
    fmt.Printf("写入缓冲区后的字节表示 (LittleEndian): %x\n", buf.Bytes())

    var readIntLE int32
    err = binary.Read(buf, binary.LittleEndian, &readIntLE)
    if err != nil {
        fmt.Println("读取错误:", err)
        return
    }
    fmt.Printf("从缓冲区读取的整数: %d (类型: %T)\n", readIntLE, readIntLE)
}