大家好，我是极客老墨。

在很多语言里，文件操作和网络操作是两套完全不同的 API。但在 Go 语言里，无论你是读文件、读网络请求，还是读一段内存字符串，你面对的通常都是同一个东西：io.Reader。

这种**“万物皆 Reader”**的设计哲学，是 Go 语言简洁高效的灵魂所在。这篇我们就来深度拆解 Go 的 IO 体系，让你不仅会用，还能写出高性能的 IO 代码。

1. 核心基石：Reader 与 Writer 接口

Go 的 IO 体系建立在两个极简的接口之上：

1type Reader interface {
2    Read(p []byte) (n int, err error)
3}
4
5type Writer interface {
6    Write(p []byte) (n int, err error)
7}

为什么这两个接口牛逼？ 因为它屏蔽了底层实现。只要一个类型实现了 Read 方法，它就是 Reader。你可以把一个“读取文件”的 Reader 直接传给一个“处理 HTTP 响应”的函数。

老墨避坑指南： Read 方法里有个细节——io.EOF。它表示“文件结束”，虽然它是一个 error 类型，但在逻辑处理中，它通常标志着读取成功的终点，而不是程序出错了。所以处理时要先看 n > 0 处理数据，再看 err == io.EOF 退出循环。

2. 基础操作：从一次性到流式

2.1 小文件：一键读写

如果你处理的是几 MB 以内的配置文件，os.ReadFile 和 os.WriteFile 是最爽的：

1data, err := os.ReadFile("config.yaml") // 一次性进内存
2if err != nil { /* 处理错误 */ }
3
4err = os.WriteFile("backup.yaml", data, 0644)

2.2 大文件：流式读取（避开 OOM）

处理 GB 级别的日志，你绝不能一次性读取。得用“流”的方式：

 1file, _ := os.Open("big.log")
 2defer file.Close()
 3
 4// 方式 A：自定义 Buffer 块读
 5buf := make([]byte, 4096)
 6for {
 7    n, err := file.Read(buf)
 8    if n > 0 { process(buf[:n]) }
 9    if err == io.EOF { break }
10}
11
12// 方式 B：Scanner 逐行读（推荐）
13scanner := bufio.NewScanner(file)
14for scanner.Scan() {
15    process(scanner.Text())
16}

老墨避坑指南： bufio.Scanner 有个默认限制：单行不能超过 64KB。如果要处理超长行（比如大 JSON），Scanner 会报错 bufio: token too long。这时候你得用 scanner.Buffer 手动调大缓冲区，或者直接回归 file.Read。

3. 进阶神技：IO 组合与抽象

Go 标准库提供了很多像“乐高积木”一样的组合工具：

  • io.Copy：把 Reader 的内容直接倒给 Writer，全自动流转，性能极高。
  • io.TeeReader：读取的同时“分叉”写出一份，类似 Linux 的 tee 命令。
  • io.MultiReader：把多个 Reader 串联起来，像读一个文件一样读它们。
  • io.LimitReader：限制读取的字节数，防止恶意超大文件攻击。
1// 示例：边下载边存盘，同时统计进度
2resp, _ := http.Get("http://example.com/bigfile")
3defer resp.Body.Close()
4
5file, _ := os.Create("download.zip")
6tee := io.TeeReader(resp.Body, file) // 读 tee 就会自动写到 file
7
8io.Copy(os.Stdout, tee) // 还可以直接打印输出到屏幕

4. 内存 IO：玩转 Buffer 和 Strings

有些场景下，你并不想真的写磁盘，而是想在内存里模拟 IO（比如单元测试）：

  • bytes.Buffer：既是 Reader 又是 Writer，内存里的临时仓库。
  • strings.Reader：把字符串包装成 Reader。
1var buf bytes.Buffer
2buf.Write([]byte("hello "))
3fmt.Fprint(&buf, "world") // fmt.Fprint 只要是 Writer 就能写
4
5reader := strings.NewReader("some data")
6io.Copy(&buf, reader)

5. 路径处理：告别“/”还是“\”的烦恼

跨平台开发最忌讳手动拼路径（"dir/" + "file"）。必须用 path/filepath：

1// 自动根据系统选分隔符
2p := filepath.Join("home", "user", "config.ini") 
3
4// 获取扩展名
5ext := filepath.Ext(p) // ".ini"
6
7// 批量搜索文件
8files, _ := filepath.Glob("*.log")

6. 高级姿势：Go 1.16+ 的 io/fs

如果你想写一个通用的文件处理函数，它既能读本地磁盘，又能读解压后的 Zip 包，甚至读静态资源嵌入（go:embed），那么你应该面向 fs.FS 接口编程。

1// 只要实现了 fs.FS，管你文件在哪，我都能读
2func ReadAppConfig(f sys fs.FS) {
3    data, _ := fs.ReadFile(f, "config.json")
4    // ...
5}

7. 性能杀手锏：bufio 缓冲区

为什么直接读写 os.File 慢？因为每次读写都是一次昂贵的“用户态”到“内核态”的系统调用。 bufio.Reader 和 bufio.Writer 在内存里开辟了一块 4KB（默认）的缓冲区，凑够了再一起交回给内核，性能天差地别。

老墨避坑指南： 用 bufio.Writer 写完后，千万记得调用 Flush()！否则最后那一块还没凑够 4KB 的数据会死活写不进磁盘。

8. 老墨总结

Go 的 IO 学习路径：

  1. 入门：学会 os.ReadFile 和 os.WriteFile 处理小文件。
  2. 进阶：掌握 io.Reader 和 io.Writer 接口，学会用 bufio 优化性能。
  3. 老鸟：熟练运用 io.Copy、TeeReader 等工具进行流式组合，理解 io/fs 的抽象力量。

记住老墨一句话：如果你在 Go 里发现自己写了很复杂的 IO 逻辑，回头看看 io 包，大概率已经有现成的积木在那等着你了。

练习题

  1. 基础题：实现一个简单的文件复制工具（要求支持 GB 级大文件）。
  2. 进阶题：编写一个程序，读取一个文件，将其中的所有大写字母转为小写，并同时保存到新文件和打印到控制台（提示：使用 io.TeeReader）。
  3. 挑战题：利用 bufio.Scanner 实现一个简单的词频统计工具。

欢迎评论区秀出你的代码，大家一起讨论！

极客老墨，继续折腾！

如果有任何问题，欢迎在评论区留言或关注公众号「极客老墨」交流。

本文示例代码在 go-tutorial-code/17-file-io。

相关阅读