Go-09-输入输出与文件处理

2026-08-24

字数统计: 1.6k字 | 阅读时长≈ 8分

Go-09-输入输出与文件处理

本节目标：掌握 Go 的 io.Reader / io.Writer 接口体系、文件操作、bufio 缓冲、encoding/* 包，能独立写文件读写工具。

1. io.Reader / io.Writer 接口

Go 的 I/O 抽象：

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

所有 I/O 都实现这两个接口：

os.File（文件）
net.Conn（网络连接）
bytes.Buffer（内存缓冲区）
strings.Reader（字符串）
http.Request.Body、http.ResponseWriter
os.Stdin、os.Stdout、os.Stderr

2. 文件读取

2.1 一次性读完（小文件）

import "os"

data, err := os.ReadFile("config.json")
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))

2.2 流式读取（大文件）

f, err := os.Open("big.log")
if err != nil {
    log.Fatal(err)
}
defer f.Close()

// 用 32KB 缓冲分块读
buf := make([]byte, 32*1024)
for {
    n, err := f.Read(buf)
    if err == io.EOF {
        break
    }
    if err != nil {
        log.Fatal(err)
    }
    process(buf[:n])
}

2.3 用 bufio.Scanner 按行读

import "bufio"

f, _ := os.Open("access.log")
defer f.Close()

scanner := bufio.NewScanner(f)
for scanner.Scan() {
    line := scanner.Text()
    // 处理每一行
    if strings.HasPrefix(line, "ERROR") {
        log.Println(line)
    }
}

if err := scanner.Err(); err != nil {
    log.Fatal(err)
}

Scanner 默认缓冲区 64KB，单行太长需要调大：

1 2	scanner := bufio.NewScanner(f) scanner.Buffer(make([]byte, 10241024), 101024*1024) // max 10MB

2.4 用 bufio.Reader 灵活读

f, _ := os.Open("data.txt")
defer f.Close()

reader := bufio.NewReader(f)

// 读一行
line, err := reader.ReadString('\n')

// 读 N 字节
buf := make([]byte, 100)
n, _ := reader.Read(buf)

// 读直到分隔符
data, _ := reader.ReadSlice(',')

// Peek（不移动指针）
peeked, _ := reader.Peek(5)
fmt.Println(string(peeked))

3. 文件写入

3.1 一次性写

1	err := os.WriteFile("out.txt", []byte("hello\n"), 0644)

3.2 流式写

f, err := os.Create("out.log")
if err != nil {
    log.Fatal(err)
}
defer f.Close()

f.WriteString("Hello\n")
f.Write([]byte("World\n"))

3.3 bufio.Writer 缓冲写入

直接 f.Write 是系统调用，每次都触发，用 bufio.Writer 批量写入：

f, _ := os.Create("big.txt")
defer f.Close()

w := bufio.NewWriter(f)
defer w.Flush()  // 重要！要把缓冲刷到磁盘

for i := 0; i < 1000; i++ {
    fmt.Fprintf(w, "line %d\n", i)
}
// Fprintf 直接写到 bufio，不需要再 fmt.Fprintln

4. 完整文件操作

import "os"

// 打开
f, err := os.Open("file")        // 只读
f, err := os.OpenFile("file", os.O_RDWR|os.O_CREATE, 0644)  // 灵活

// 创建
f, err := os.Create("file")      // 等价 O_RDWR|O_CREATE|O_TRUNC, 0666

// 读
data, _ := os.ReadFile("file")
data, _ := os.ReadDir("dir")     // 读目录

// 写
os.WriteFile("file", data, 0644)

// 删除/重命名
os.Remove("file")
os.Rename("old", "new")

// 目录操作
os.Mkdir("dir", 0755)
os.MkdirAll("path/to/dir", 0755)  // 递归创建
os.RemoveAll("dir")                // 递归删除

// 文件信息
info, _ := os.Stat("file")
fmt.Println(info.Size(), info.Mode(), info.ModTime())

// 权限
os.Chmod("file", 0644)
os.Chown("file", uid, gid)

// 临时文件
f, _ := os.CreateTemp("", "prefix-")  // /tmp/prefix-123456
f, _ = os.MkdirTemp("", "dir-")       // /tmp/dir-123456

// 路径操作（用 path/filepath 而非 string 操作）
import "path/filepath"
filepath.Join("dir", "sub", "file.txt")     // "dir/sub/file.txt"
filepath.Base("/path/to/file.txt")          // "file.txt"
filepath.Dir("/path/to/file.txt")           // "/path/to"
filepath.Ext("file.txt")                    // ".txt"
filepath.IsAbs("/path/to/file")             // true
filepath.Rel("a/b", "a/b/c/d.txt")          // "c/d.txt"
filepath.Walk("dir", func(path string, info os.FileInfo, err error) error {
    // 遍历目录
    return nil
})

5. io.Copy：最常用的复制

// 把 src 复制到 dst
io.Copy(dst, src)

// 例：把文件内容输出到标准输出
io.Copy(os.Stdout, f)

// 例：HTTP response body 写到文件
io.Copy(outFile, resp.Body)

// 限制大小（防止 OOM）
io.CopyN(dst, src, 1024*1024)  // 最多 1MB

6. io.MultiReader / io.MultiWriter

// 多个 Reader 串起来
r := io.MultiReader(r1, r2, r3)  // 顺序读 r1 → r2 → r3

// 多个 Writer 并联
w := io.MultiWriter(os.Stdout, f, logFile)  // 同时写多个目标
fmt.Fprintln(w, "hello")

7. io.Pipe：内存管道

pr, pw := io.Pipe()

go func() {
    defer pw.Close()
    pw.Write([]byte("hello "))
    pw.Write([]byte("pipe"))
}()

data, _ := io.ReadAll(pr)
fmt.Println(string(data))  // "hello pipe"

8. 编码/解码（encoding/*）

8.1 JSON

import "encoding/json"

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// 编码
u := User{"Alice", 25}
data, _ := json.Marshal(u)                    // []byte, 无缩进
data, _ = json.MarshalIndent(u, "", "  ")     // 缩进

// 解码
var u2 User
json.Unmarshal(data, &u2)

// 流式编码（适合大对象）
enc := json.NewEncoder(os.Stdout)
enc.Encode(u)

// 流式解码
dec := json.NewDecoder(os.Stdin)
var u3 User
dec.Decode(&u3)

struct tag 控制 JSON 字段名：

type User struct {
    Name     string `json:"name"`              // 小写
    Password string `json:"-"`                 // 忽略
    Email    string `json:"email,omitempty"`   // 空值省略
    Age      int    `json:"age,string"`        // 数字转字符串
}

8.2 XML

类似 JSON：

type Note struct {
    XMLName xml.Name `xml:"note"`
    To      string   `xml:"to"`
    From    string   `xml:"from"`
    Body    string   `xml:"body"`
}

n := Note{To: "Alice", From: "Bob", Body: "Hello"}
data, _ := xml.MarshalIndent(n, "", "  ")
fmt.Println(string(data))
// <note>
//   <to>Alice</to>
//   <from>Bob</from>
//   <body>Hello</body>
// </note>

8.3 CSV

import "encoding/csv"

// 读
f, _ := os.Open("data.csv")
r := csv.NewReader(f)
records, _ := r.ReadAll()  // [][]string

// 写
w := csv.NewWriter(os.Stdout)
w.Write([]string{"name", "age"})
w.Write([]string{"Alice", "25"})
w.Flush()

9. 实战：日志文件轮转

func logWithRotate(logFile string) error {
    f, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    if err != nil {
        return err
    }

    // 检查文件大小，超过 10MB 就轮转
    info, _ := f.Stat()
    if info.Size() > 10*1024*1024 {
        f.Close()
        os.Rename(logFile, logFile+"."+time.Now().Format("20060102"))
        f, _ = os.Create(logFile)
    }

    logger := log.New(f, "", log.LstdFlags)
    logger.Println("application started")
    return nil
}

生产用第三方：gopkg.in/natefinch/lumberjack.v2 提供完整的轮转、压缩、保留策略。

10. 实战：读取配置文件

type Config struct {
    Server   ServerConfig   `yaml:"server"`
    Database DatabaseConfig `yaml:"database"`
    Log      LogConfig      `yaml:"log"`
}

type ServerConfig struct {
    Port int    `yaml:"port"`
    Host string `yaml:"host"`
}

// ...

data, _ := os.ReadFile("config.yaml")
var cfg Config
yaml.Unmarshal(data, &cfg)

需要 gopkg.in/yaml.v3。

小结

包	用途
`os`	文件/目录/权限
`io`	`Reader`/`Writer` 接口、`Copy`
`bufio`	带缓冲的读写、Scanner
`io/ioutil`	已被废弃（用 `os.ReadFile` 等）
`path/filepath`	跨平台路径
`encoding/json`	JSON
`encoding/xml`	XML
`encoding/csv`	CSV
`encoding/gob`	Go 二进制

黄金法则：

永远用 defer f.Close()
大文件用 bufio 缓冲
小文件用 os.ReadFile/os.WriteFile
跨平台用 filepath.Join，不用 + "/"
结构体 tag 控制序列化字段

下一节讲 goroutine、channel 和 Go 的并发模型。

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/08/24/Go-09-IO与文件处理/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！