io.Reader和io.Writer是Go语言中处理I/O的核心接口，分别定义了Read(p []byte) (n int, err error)和Write(p []byte) (n int, err error)方法，实现它们的类型可统一进行数据读写操作。通过接口抽象，Go程序能以一致方式处理文件、网络、内存等不同来源的数据。典型应用场景包括使用os.File进行文件复制、利用io.Copy简化读写流程、通过http.Response.Body读取网络数据以及在函数间传递io.Reader实现解耦。借助bufio可提升性能，io.MultiWriter支持多目标写入，io.LimitReader限制读取长度，还可自定义类型实现Reader或Writer接口以满足特殊需求。掌握这些机制有助于编写高效、通用的I/O代码。
在Go语言中，io.Reader 和 io.Writer 是处理数据输入输出的核心接口。它们不关心数据来源或目的地，只关注“读”和“写”的行为，这种抽象让代码更加灵活、可复用。掌握这两个接口的使用，是编写高效、通用Go程序的关键。
理解 io.Reader 与 io.Writer 接口
Go标准库中的 io.Reader 和 io.Writer 定义非常简洁：
io.Reader 的定义是：
type Reader interface {
Read(p []byte) (n int, err error)
}
它从数据源读取数据到字节切片 p 中，返回读取的字节数 n 和可能的错误。当读取到数据末尾时，通常返回 io.EOF。
立即学习“go语言免费学习笔记（深入）”；
io.Writer 的定义是：
type Writer interface {
Write(p []byte) (n int, err error)
}
它将字节切片 p 中的数据写入目标，返回成功写入的字节数和错误。
只要一个类型实现了这两个方法，就可以作为 Reader 或 Writer 使用。比如 *os.File、*bytes.Buffer、http.ResponseWriter 都实现了这些接口。
常见使用场景与实践示例
通过具体例子理解如何在实际开发中使用这两个接口。
1. 从文件读取并写入另一个文件
file, _ := os.Open("input.txt")
defer file.Close()
dest, _ := os.Create("output.txt")
defer dest.Close()
buffer := make([]byte, 1024)
for {
n, err := file.Read(buffer)
if n > 0 {
dest.Write(buffer[:n])
}
if err == io.EOF {
break
}
if err != nil {
log.Fatal(err)
}
}
这是最基础的读写循环。但更推荐使用 io.Copy 简化操作。
2. 使用 io.Copy 提升效率
file, _ := os.Open("input.txt")
defer file.Close()
dest, _ := os.Create("output.txt")
defer dest.Close()
_, err := io.Copy(dest, file)
if err != nil {
log.Fatal(err)
}
io.Copy(dst Writer, src Reader) 自动处理缓冲和循环，代码更简洁且性能更好。
3. 处理网络响应体
resp, _ := http.Get("https://example.com/data")
defer resp.Body.Close()
var buf bytes.Buffer
_, err := io.Copy(&buf, resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(buf.String())
这里 resp.Body 是 io.ReadCloser（实现了 Reader），bytes.Buffer 实现了 Writer，可以直接传给 io.Copy。
4. 在函数间传递 Reader/Writer 实现解耦
func process(r io.Reader) error {
scanner := bufio.NewScanner(r)
for scanner.Scan() {
fmt.Println("Line:", scanner.Text())
}
return scanner.Err()
}
这个函数可以接受文件、字符串、网络流等任何实现 io.Reader 的类型：
// 从字符串读
reader := strings.NewReader("line1\nline2")
process(reader)
// 从文件读
file, _ := os.Open("data.txt")
process(file)
组合与转换：增强数据处理能力
Go提供了多种工具来增强 Reader 和 Writer 的能力。
1. 使用 bufio 添加缓冲
直接调用 Read/Write 可能频繁进行系统调用。使用 bufio.Reader 和 bufio.Writer 可减少开销：
w := bufio.NewWriter(destFile)
w.WriteString("hello")
w.WriteString("world")
w.Flush() // 别忘了刷新
2. 多个 Writer 同时写入（io.MultiWriter）
w1 := &bytes.Buffer{}
w2, _ := os.Create("log.txt")
mw := io.MultiWriter(w1, w2)
fmt.Fprintf(mw, "Log message") // 同时写入 buffer 和文件
3. 限制读取长度（io.LimitReader）
limited := io.LimitReader(reader, 100) // 最多读100字节 io.Copy(os.Stdout, limited)
自定义 Reader 和 Writer
你可以创建自己的类型来实现这些接口。例如，一个生成重复字符的 Writer：
type CharWriter struct {
ch byte
}
func (w *CharWriter) Write(p []byte) (int, error) {
for i := range p {
p[i] = w.ch
}
return len(p), nil
}
// 使用
writer := &CharWriter{ch: 'A'}
buffer := make([]byte, 5)
writer.Write(buffer)
fmt.Printf("%s\n", buffer) // 输出 AAAAA
或者一个不断返回固定数据的 Reader：
type CycleReader struct {
data []byte
index int
}
func (r *CycleReader) Read(p []byte) (int, error) {
for i := range p {
p[i] = r.data[r.index]
r.index = (r.index + 1) % len(r.data)
}
return len(p), nil
}
基本上就这些。熟练运用 io.Reader 和 io.Writer 能让你写出更通用、更简洁的IO代码。关键是理解它们的抽象意义：不关心数据在哪，只关心能不能读和写。配合 io.Copy、bufio 等工具，大多数IO任务都能优雅解决。
