GO语言基础教程（224）Go文件处理之二进制文件的写入、读取操作：Go语言文件撩妹术：如何与二进制数据“深情对话”？-优快云博客

嘿，程序员伙计们！今天咱们不聊那些花里胡哨的Web框架，也不扯高并发的华山论剑。我们来点更“底层”、更“硬核”的活儿——跟二进制文件打交道。

想象一下，你心爱的Go程序，每天处理着各种数据：用户信息、游戏存档、配置文件……这些数据在内存里活蹦乱跳，但程序一关，它们就“灰飞烟灭”了。怎么办呢？你得给它们找个“家”，一个稳定、持久、不会丢的“家”。这个家，就是文件。

而二进制文件，就是这个家里的 “保险柜” 。它不像文本文件（比如.txt）那样谁都能打开瞅两眼，它结构紧凑、读写高效、保密性也好那么一丢丢。今天，咱们就化身“数据保险柜管理员”，学习如何用Go语言，把数据稳稳当当地存进去，再毫发无损地取出来。

第一幕：准备工作——认识你的“工具人”

在开始“撩”二进制数据之前，你得先认识三位核心“工具人”：

os包：你的“钥匙串”。负责创建（Create）和打开（Open）文件，给你一个通往文件世界的通道。
encoding/binary包：你的“翻译官”。数据在内存里是一种样子，要存到文件里就得转换成字节流（序列化），读回来的时候再还原（反序列化）。binary包就干这个，确保信息传递“信达雅”。
bytes.Buffer：你的“临时中转站”。有时候数据不是直接写文件，而是在内存里先拼装好，它在这方面是一把好手。

记住一个黄金法则： 在二进制世界里，“你怎么写进去，就必须怎么读出来”。顺序、格式、数据类型，错一点都会导致“读心术”失败，读出来的全是乱码。这就好比你存钱时存的是美元，取的时候却想按人民币取，银行可不答应！

第二幕：写入篇——把数据“塞”进保险柜

光说不练假把式，直接上代码！我们的目标是：把一个整数（比如你的游戏得分5201314）和一个浮点数（比如圆周率3.14）写入文件。

package main

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

func main() {
    // 1. 创建文件，拿到“保险柜钥匙”
    file, err := os.Create("data.bin")
    if err != nil {
        panic(err) // 如果钥匙没拿到，那就崩溃吧（实际项目别这么糙）
    }
    defer file.Close() // 记住，用完钥匙要收好（延迟关闭文件）

    // 2. 准备要“藏”起来的数据
    var score int32 = 5201314
    var pi float64 = 3.14

    // 3. 请出“翻译官”，开始写入！
    // 注意顺序：先写score，再写pi
    err = binary.Write(file, binary.LittleEndian, score)
    if err != nil {
        panic(err)
    }

    err = binary.Write(file, binary.LittleEndian, pi)
    if err != nil {
        panic(err)
    }

    fmt.Println("数据写入成功！快去目录下看看data.bin文件吧！")
}

代码“笑点”解析：

os.Create("data.bin")：这行代码就像你对着系统喊了一声：“给我一个新保险柜，名字叫data.bin！” 如果这个柜子已经存在，那对不起，旧柜子会被直接清空替换，里面的东西可就没了哦！
defer file.Close()：这是Go语言的精华，一个“延迟执行”的咒语。意思是：“等老子这个函数干完所有活儿，无论如何都要记得把文件关上！” 防止你忘性大，导致资源泄露。
binary.LittleEndian：哎呦，这是个重点！“字节序”，也叫“端序”。你可以把它理解为数据在内存中的“排队方向”。

- 小端序（Little Endian）：像我们写地址一样，“小家子气”，先写小单位（字节）。比如数字0x12345678，在文件里会按照 78 56 34 12 的顺序存放。这是x86/ARM等大多数CPU的默认方式，所以咱们常用它。
- 大端序（Big Endian）：“大佬做派”，先写大单位。同样的数字，它会按 12 34 56 78 存放。网络传输中常用。
  你只要保证**读和写的时候用同一种“排队规矩”**就行。

现在，运行程序。你会得到一个data.bin文件。用文本编辑器打开它？哈哈，你会看到一堆乱码，这就是二进制文件的“神秘感”！

第三幕：读取篇——从保险柜“取”回宝贝

存进去不是目的，能完整地取出来才是本事。现在，我们来写一个“读取器”。

package main

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

func main() {
    // 1. 打开文件，拿出“保险柜钥匙”
    file, err := os.Open("data.bin")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 2. 准备好空变量，用来接住读出来的数据
    // 类型必须和写入时一模一样！
    var scoreFromFile int32
    var piFromFile float64

    // 3. 请出“翻译官”，开始读取！
    // 顺序必须和写入时一模一样！
    err = binary.Read(file, binary.LittleEndian, &scoreFromFile)
    if err != nil {
        panic(err)
    }

    err = binary.Read(file, binary.LittleEndian, &piFromFile)
    if err != nil {
        panic(err)
    }

    // 4. 亮宝！
    fmt.Printf("读取到的游戏得分: %d\n", scoreFromFile)
    fmt.Printf("读取到的圆周率: %.2f\n", piFromFile)
}

代码“笑点”解析：

os.Open("data.bin")：这次是打开已有的“保险柜”，只读模式，不会清空内容。
binary.Read(..., &scoreFromFile)：关键来了！ 第二个参数必须是一个指针（&符号就是在取地址）。为什么呢？因为Read函数需要知道你把数据读出来之后，该往哪个内存地址里塞。你光给个变量名，它不知道放哪儿，必须用“地址”告诉它“放我家！”。不给地址，它就懵了。

运行这个读取程序，你会看到控制台完美地输出了：

读取到的游戏得分: 5201314
读取到的圆周率: 3.14

恭喜你！第一次与二进制数据的“深情对话”圆满成功！

第四幕：进阶玩法——处理“结构体”这个大家庭

单个变量太简单了？现实中的数据往往是成群结队的，比如一个Player结构体。直接对它用binary.Write行不行？有时候行，但极度不推荐！因为结构体可能会有内存对齐等“隐形的坑”，导致写进去的字节包含不可控的“垃圾数据”。

正确的姿势是：“打包”再存。

package main

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

type Player struct {
    ID     int32
    Level  int16
    Name   [10]byte // 使用固定长度的字节数组，避免字符串的复杂处理
    Health float32
}

func main() {
    // --- 写入部分 ---
    player1 := Player{
        ID:     1,
        Level:  99,
        Name:   [10]byte{'G', 'o', 'P', 'l', 'a', 'y', 'e', 'r'}, // 剩余字节是0
        Health: 100.0,
    }

    // 方法：使用 bytes.Buffer 作为中转站
    var buf bytes.Buffer

    // 按字段逐个写入Buffer
    binary.Write(&buf, binary.LittleEndian, player1.ID)
    binary.Write(&buf, binary.LittleEndian, player1.Level)
    binary.Write(&buf, binary.LittleEndian, player1.Name)
    binary.Write(&buf, binary.LittleEndian, player1.Health)

    // 将Buffer里的完整字节流一次性写入文件
    err := os.WriteFile("player.bin", buf.Bytes(), 0644)
    if err != nil {
        panic(err)
    }
    fmt.Println("玩家数据已打包写入！")

    // --- 读取部分 ---
    // 直接从文件读回字节流
    data, err := os.ReadFile("player.bin")
    if err != nil {
        panic(err)
    }

    // 将字节流转换成一个可读的Buffer
    reader := bytes.NewReader(data)
    var player2 Player

    // 按同样的顺序，从Buffer中逐个字段读取
    binary.Read(reader, binary.LittleEndian, &player2.ID)
    binary.Read(reader, binary.LittleEndian, &player2.Level)
    binary.Read(reader, binary.LittleEndian, &player2.Name)
    binary.Read(reader, binary.LittleEndian, &player2.Health)

    fmt.Printf("读取到的玩家: ID=%d, Level=%d, Name=%s, Health=%.1f\n",
        player2.ID, player2.Level, string(player2.Name[:]), player2.Health) // 注意Name数组转字符串的写法
}

为什么这么麻烦？
这样做保证了我们对每一个字节的绝对控制。我们知道写进去了什么，也知道该读什么回来，完全避免了结构体内存布局的干扰。bytes.Buffer在这里扮演了一个完美的“打包箱”和“拆包器”角色。