Go 语言文件处理

文件处理是 Go 语言中最常见的操作之一——读取配置、写入日志、数据持久化都离不开它。Go 的标准库提供了一套简洁而强大的文件 I/O 接口，覆盖从单次读写到流式处理的各种场景。

与文件处理相关的核心包有 5 个，各有分工：

版本提示：ioutil 包在 Go 1.16 已弃用，其功能已迁移到 os（如 os.ReadFile、os.WriteFile）和 io（如 io.ReadAll）。新代码应直接使用 os 和 io 包。

1. 文件创建

os.Create 创建一个新文件。如果文件已存在，会被截断（清空内容）。返回的文件对象必须关闭以释放系统资源：

实例

package main

import (
"log"
"os"
)

func main() {
// os.Create 创建文件（已存在则清空）
file, err := os.Create("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close() // defer 确保函数结束时关闭文件

// 写入内容验证创建成功
file.WriteString("文件创建成功\n")
log.Println("文件创建成功")
}

defer file.Close() 是 Go 文件操作的最佳实践。defer 会确保即使后续代码出现 panic，文件也会被正确关闭，避免文件描述符泄漏。

2. 文件打开与关闭

os 包提供三种打开文件的方式，适用于不同场景：

函数	模式	说明
`os.Open(name)`	只读	最简单的方式，只读打开
`os.Create(name)`	读写 + 创建/截断	创建新文件或清空已有文件
`os.OpenFile(name, flag, perm)`	自定义	可指定读写、追加、创建等标志

实例

package main

import (
"fmt"
"os"
)

func main() {
// 方式1：只读打开
file, err := os.Open("example.txt")
if err != nil {
fmt.Println("打开失败:", err)
return
}
defer file.Close()
fmt.Println("文件打开成功")

// 方式2：OpenFile 自定义模式
// os.O_WRONLY 只写
// os.O_CREATE 不存在则创建
// os.O_APPEND 追加模式
// os.O_TRUNC 存在则截断
f, err := os.OpenFile("log.txt",
os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
fmt.Println("打开失败:", err)
return
}
defer f.Close()
f.WriteString("追加一行日志\n")
}

OpenFile 标志位说明

标志	说明
`os.O_RDONLY`	只读（默认）
`os.O_WRONLY`	只写
`os.O_RDWR`	读写
`os.O_APPEND`	追加模式，写入内容追加到文件末尾
`os.O_CREATE`	文件不存在时创建
`os.O_TRUNC`	打开时清空文件内容
`os.O_EXCL`	与 CREATE 配合，文件已存在时报错

3. 文件读取

Go 提供了三种主要的文件读取方式，根据文件大小和处理需求选择：

3.1 一次性读取（小文件推荐）

os.ReadFile 是最简洁的方式——自动打开、读取、关闭文件，一步到位：

实例

package main

import (
"fmt"
"log"
"os"
)

func main() {
// 一次性读取整个文件（Go 1.16+）
data, err := os.ReadFile("config.json")
if err != nil {
log.Fatal(err)
}

fmt.Println(string(data))
}

3.2 逐行读取（大文件推荐）

对于大文件，使用 bufio.Scanner 逐行处理，避免一次性加载到内存：

实例

package main

import (
"bufio"
"fmt"
"log"
"os"
)

func main() {
file, err := os.Open("large-file.log")
if err != nil {
log.Fatal(err)
}
defer file.Close()

// 逐行扫描
scanner := bufio.NewScanner(file)
lineNum := 0
for scanner.Scan() {
lineNum++
line := scanner.Text() // 获取当前行内容
fmt.Printf("第 %d 行: %s\n", lineNum, line)
}

// 检查扫描过程中是否出错
if err := scanner.Err(); err != nil {
log.Fatal("读取错误:", err)
}
}

注意：bufio.Scanner 默认最大行长度为 64KB。如果文件中有超长行，需要在调用 Scan() 前设置 scanner.Buffer(make([]byte, 0), maxSize) 来增大缓冲区。

3.3 使用 io.ReadAll 读取

当你已经有一个打开的 io.Reader（如网络响应、已打开的文件），可以使用 io.ReadAll：

实例

package main

import (
"fmt"
"io"
"log"
"os"
)

func main() {
file, err := os.Open("example.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()

// 从 Reader 读取所有数据
data, err := io.ReadAll(file)
if err != nil {
log.Fatal(err)
}

fmt.Println(string(data))
}

4. 文件写入

Go 提供了多种写入方式，从简单的一次性写入到高性能的缓冲写入：

4.1 一次性写入

os.WriteFile 将数据一次性写入文件（覆盖原有内容）：

实例

package main

import (
"log"
"os"
)

func main() {
content := []byte("Hello, Go!\n这是第二行\n")

// 0644: 所有者读写，其他用户只读
err := os.WriteFile("output.txt", content, 0644)
if err != nil {
log.Fatal(err)
}
log.Println("写入成功")
}

4.2 使用 File 对象写入

通过文件对象写入，可以分多次写入内容：

实例

package main

import (
"fmt"
"log"
"os"
)

func main() {
file, err := os.Create("output.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()

// 方式1：写入字符串
file.WriteString("直接写入字符串\n")

// 方式2：写入字节切片
data := []byte("写入字节切片\n")
file.Write(data)

// 方式3：格式化写入
fmt.Fprintf(file, "格式化写入: %d + %d = %d\n", 3, 4, 7)
}

4.3 缓冲写入（大量数据推荐）

bufio.Writer 会先将数据写入内存缓冲区，攒够后再批量写入磁盘，显著减少 I/O 次数。务必在结束前调用 Flush()：

实例

package main

import (
"bufio"
"log"
"os"
)

func main() {
file, err := os.Create("buffered-output.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()

// 创建带缓冲的写入器
writer := bufio.NewWriter(file)

// 写入多行（先进入缓冲区，不会立即写磁盘）
for i := 0; i < 1000; i++ {
writer.WriteString("这是第 " + itoa(i) + " 行\n")
}

// Flush 将缓冲区剩余数据写入文件
if err := writer.Flush(); err != nil {
log.Fatal("刷新缓冲区失败:", err)
}
log.Println("缓冲写入完成")
}

// 简单的 int 转 string 辅助函数
func itoa(n int) string {
return fmt.Sprintf("%d", n)
}

5. 文件追加写入

使用 os.O_APPEND 标志在文件末尾追加内容，而不覆盖已有数据：

实例

package main

import (
"log"
"os"
"time"
)

func main() {
// O_APPEND: 追加模式
// O_CREATE: 不存在则创建
// O_WRONLY: 只写
file, err := os.OpenFile("app.log",
os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()

// 每次运行都会追加，不会覆盖
timestamp := time.Now().Format("2006-01-02 15:04:05")
file.WriteString("[" + timestamp + "] 应用启动\n")
}

对比：os.Create 会清空已有内容；os.OpenFile 配合 O_APPEND 会追加内容。日志场景务必使用追加模式。

6. 文件删除与重命名

实例

package main

import (
"log"
"os"
)

func main() {
// 重命名 / 移动文件
err := os.Rename("old.txt", "new.txt")
if err != nil {
log.Fatal("重命名失败:", err)
}
log.Println("重命名成功")

// 删除文件
err = os.Remove("temp.txt")
if err != nil {
log.Fatal("删除失败:", err)
}
log.Println("删除成功")
}

7. 文件信息与检查

7.1 获取文件信息

实例

package main

import (
"fmt"
"log"
"os"
)

func main() {
info, err := os.Stat("test.txt")
if err != nil {
log.Fatal(err)
}

fmt.Println("文件名: ", info.Name())
fmt.Println("大小: ", info.Size(), "字节")
fmt.Println("权限: ", info.Mode())
fmt.Println("修改时间: ", info.ModTime())
fmt.Println("是目录吗: ", info.IsDir())
}

7.2 检查文件是否存在

Go 没有专门的"文件存在"函数，通过 os.Stat + os.IsNotExist 判断：

实例

package main

import (
"fmt"
"os"
)

// fileExists 检查文件是否存在
func fileExists(path string) bool {
_, err := os.Stat(path)
return !os.IsNotExist(err)
}

func main() {
if fileExists("test.txt") {
fmt.Println("文件存在")
} else {
fmt.Println("文件不存在")
}
}

8. 目录操作

实例

package main

import (
"fmt"
"log"
"os"
)

func main() {
// 创建单个目录
err := os.Mkdir("newdir", 0755)
if err != nil {
log.Fatal(err)
}

// 递归创建多级目录（父目录不存在也会自动创建）
err = os.MkdirAll("path/to/deep/dir", 0755)
if err != nil {
log.Fatal(err)
}

// 读取目录内容
entries, err := os.ReadDir(".")
if err != nil {
log.Fatal(err)
}
for _, entry := range entries {
mark := "📄"
if entry.IsDir() {
mark = "📁"
}
fmt.Printf("%s %s\n", mark, entry.Name())
}

// 删除空目录
os.Remove("newdir")

// 递归删除目录及其所有内容（⚠ 谨慎使用）
os.RemoveAll("path")
}

9. 高级操作

9.1 文件复制

使用 io.Copy 在两个文件之间高效复制数据：

实例

package main

import (
"io"
"log"
"os"
)

// copyFile 复制文件的通用函数
func copyFile(src, dst string) (int64, error) {
srcFile, err := os.Open(src)
if err != nil {
return 0, err
}
defer srcFile.Close()

dstFile, err := os.Create(dst)
if err != nil {
return 0, err
}
defer dstFile.Close()

// io.Copy 自动管理缓冲区，高效复制
return io.Copy(dstFile, srcFile)
}

func main() {
n, err := copyFile("source.txt", "destination.txt")
if err != nil {
log.Fatal(err)
}
log.Printf("复制完成，共 %d 字节", n)
}

9.2 临时文件与目录

实例

package main

import (
"fmt"
"log"
"os"
)

func main() {
// 创建临时文件（自动命名，前缀为 "app-"）
tmpFile, err := os.CreateTemp("", "app-*.txt")
if err != nil {
log.Fatal(err)
}
defer os.Remove(tmpFile.Name()) // 用完后清理
fmt.Println("临时文件:", tmpFile.Name())

// 创建临时目录
tmpDir, err := os.MkdirTemp("", "app-*")
if err != nil {
log.Fatal(err)
}
defer os.RemoveAll(tmpDir) // 用完后清理
fmt.Println("临时目录:", tmpDir)
}

9.3 递归遍历目录

filepath.Walk 可以递归遍历目录树中的所有文件和子目录：

实例

package main

import (
"fmt"
"log"
"os"
"path/filepath"
)

func main() {
root := "." // 从当前目录开始遍历

err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err // 遇到错误时可以选择跳过或返回
}

// 打印路径和大小
size := ""
if !info.IsDir() {
size = fmt.Sprintf(" (%d bytes)", info.Size())
}
fmt.Println(path + size)
return nil
})

if err != nil {
log.Fatal(err)
}
}

9.4 跨平台路径拼接

永远不要用字符串拼接路径（如 dir + "/" + file），使用 filepath.Join 确保跨平台兼容：

// 错误：Windows 上路径分隔符是 \
path := "dir" + "/" + "file.txt"

// 正确：自动适配当前操作系统
path := filepath.Join("dir", "file.txt")

场景速查表

场景	推荐方式	关键代码
读取小文件	`os.ReadFile`	`data, err := os.ReadFile("file.txt")`
逐行读取大文件	`bufio.Scanner`	`scanner := bufio.NewScanner(file)`
写入小文件	`os.WriteFile`	`os.WriteFile("f.txt", data, 0644)`
大量数据写入	`bufio.Writer`	`writer := bufio.NewWriter(file)`
追加日志	`os.OpenFile` + `O_APPEND`	`os.OpenFile("log", os.O_APPEND\|os.O_WRONLY, 0644)`
文件复制	`io.Copy`	`io.Copy(dst, src)`
遍历目录	`filepath.Walk`	`filepath.Walk(".", callback)`
路径拼接	`filepath.Join`	`filepath.Join("dir", "file.txt")`
检查文件存在	`os.Stat` + `os.IsNotExist`	`_, err := os.Stat(path)`
创建临时文件	`os.CreateTemp`	`os.CreateTemp("", "prefix-*.txt")`

文件权限说明：0644 表示所有者可读写（6=4+2），组和其他用户只读（4）。目录通常使用 0755（多了执行权限，否则无法进入目录）。

返回顶部

菜鸟教程