Go 文件操作：os 与 io/ioutil 包

Go 语言提供了强大的标准库来处理文件输入输出（I/O）。在实际开发中，最常用的两个包是 os 和 io/ioutil（注：Go 1.16 及以后版本推荐使用 io 和 os 替代 ioutil，但为了兼容性和理解核心逻辑，本文仍以 ioutil 为主进行讲解，并涵盖现代用法）。os 包提供了类似操作系统的底层接口，功能全面但代码量稍多；io/ioutil 则提供了封装好的便捷方法，适合简单的文件读写任务。

掌握这两个包的区别和使用场景，能让你在处理文件时更加得心应手。

第一部分：使用 os 包进行基础文件操作

os 包是 Go 语言文件操作的基石。它允许你以更细粒度的方式控制文件，包括打开、创建、读写、关闭以及设置权限。当你需要处理大文件或需要精确控制读写位置时，应优先选择 os 包。

1. 创建与写入文件

打开终端或编辑器，创建一个名为 main.go 的文件。我们将从最基础的创建文件并写入字符串开始。

1. 引用 os 包。
2. 使用 os.Create 函数。如果文件已存在，该操作会截断文件（即清空原内容）；如果不存在，则创建新文件。
3. 调用 file.WriteString 方法将数据写入文件。
4. 使用 defer 关键字延迟关闭文件句柄。这是防止资源泄漏的关键步骤。

package main

import (
    "fmt"
    "os"
)

func main() {
    // 创建文件，返回文件对象和可能的错误
    file, err := os.Create("example.txt")
    if err != nil {
        // 如果创建失败，打印错误并退出
        fmt.Println("文件创建失败:", err)
        return
    }
    // 确保函数退出时关闭文件
    defer file.Close()

    // 写入字符串
    content := "Hello, Go File Operations!\n这是第二行内容。"
    _, err = file.WriteString(content)
    if err != nil {
        fmt.Println("写入失败:", err)
        return
    }

    fmt.Println("文件写入成功")
}

2. 读取文件内容

读取文件通常涉及三个步骤：打开文件、分配缓冲区（字节数组）、读取数据。

1. 使用 os.Open 函数以只读模式打开文件。该函数不会清空文件，只是获取文件句柄。
2. 定义一个字节切片 []byte 作为容器，用于存储从文件中读取的数据。
3. 调用 file.Read 方法。该方法会读取数据到切片中，并返回读取的字节数 n 和可能的错误 err。
4. 处理读取到的数据。注意 file.Read 遇到文件末尾（EOF）时会返回 io.EOF 错误，这是正常的结束信号。

package main

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

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

    // 创建一个字节切片来存储读取的内容，假设文件大小不超过 1024 字节
    buf := make([]byte, 1024)

    // 读取文件内容
    n, err := file.Read(buf)
    if err != nil && err != io.EOF {
        fmt.Println("读取失败:", err)
        return
    }

    // 打印读取到的内容（将字节切片转换为字符串）
    fmt.Printf("读取了 %d 字节:\n%s\n", n, buf[:n])
}

第二部分：使用 io/ioutil 包进行快速操作

io/ioutil 包（或 Go 1.16+ 的 io 和 os 包）提供了更高层的抽象，能够用一行代码完成读取或写入整个文件的操作。它适合处理配置文件、JSON 数据等小文件，但不适合处理几 GB 的大文件，因为它会一次性将所有内容加载到内存中。

1. 一键读写文件

如果你不想处理 Open、Close、Buffer 等细节，ioutil 是最佳选择。

1. 使用 ioutil.ReadFile 直接读取文件。它会自动处理打开、读取和关闭。
2. 使用 ioutil.WriteFile 直接写入文件。它会自动创建文件（如果需要）、写入数据并关闭。

package main

import (
    "fmt"
    "io/ioutil" // Go 1.16+ 建议使用 "io" 和 "os"
    "log"
)

func main() {
    fileName := "quick_data.txt"

    // 写入文件
    // 参数：文件名、字节数组内容、文件权限(0644表示所有者可读写，其他只读)
    content := []byte("这是使用 ioutil 写入的快速内容。")
    err := ioutil.WriteFile(fileName, content, 0644)
    if err != nil {
        log.Fatal(err)
    }

    // 读取文件
    // 直接返回文件内容的字节数组
    data, err := ioutil.ReadFile(fileName)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("读取到的内容:", string(data))
}

2. 读取目录内容

除了文件操作，ioutil 还能快速列出目录下的所有文件信息。

1. 调用 ioutil.ReadDir 并传入目录路径（例如 . 代表当前目录）。
2. 遍历返回的文件信息切片。你可以获取每个文件的名称、大小、模式（权限）和修改时间。

package main

import (
    "fmt"
    "io/ioutil"
    "log"
)

func main() {
    // 读取当前目录
    files, err := ioutil.ReadDir(".")
    if err != nil {
        log.Fatal(err)
    }

    for _, f := range files {
        fmt.Printf("文件名: %s, 是否为目录: %v, 大小: %d 字节\n", f.Name(), f.IsDir(), f.Size())
    }
}

第三部分：核心差异与选择指南

os 和 io/ioutil 各有千秋，选择哪一个取决于你的具体场景。下表总结了它们的主要区别，帮助你快速决策。

第四部分：进阶操作流程与判断

在实际工程中，如何选择正确的包不仅取决于代码简洁性，更取决于文件的大小和类型。为了更直观地展示决策逻辑，我们可以参考以下流程图。请根据你的文件特征，按图索骥选择合适的方法。

第五部分：实战中的文件权限与标志位

在使用 os.OpenFile 时，你可能会遇到文件权限（如 0644）和标志位（如 os.O_RDONLY）。理解这些参数对于安全的文件操作至关重要。

1. 理解文件权限

在 Linux/Unix 系统中，文件权限是一个八进制数，例如 0644。

• 第一位（0）：八进制前缀。
• 第二位（6 - 所有者）：4(读) + 2(写) = 6。表示文件所有者可读可写。
• 第三位（4 - 组）：4(读)。表示文件所属组用户可读。
• 第四位（4 - 其他人）：4(读)。表示其他用户可读。

如果需要设置为可执行脚本（如 shell 脚本），权限通常设为 0755（所有者可读可写可执行，其他人可读可执行）。

2. 掌握常用标志位

当简单的 os.Create（等同于 os.O_RDWR|os.O_CREATE|os.O_TRUNC）或 os.Open（等同于 os.O_RDONLY）无法满足需求时，你需要使用 os.OpenFile 并组合标志位。

以下是最常用的标志位及其含义：

3. 实战示例：以追加模式写入日志

假设你需要向一个日志文件不断添加新内容，而不是覆盖旧内容。

1. 使用 os.OpenFile。
2. 组合标志位：os.O_WRONLY|os.O_CREATE|os.O_APPEND。这表示：以只写方式打开，如果文件不存在则创建，写入时将光标移至文件末尾。
3. 设置权限为 0644。

package main

import (
    "fmt"
    "os"
)

func main() {
    logFile := "app.log"

    // 以追加模式打开文件
    file, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        fmt.Println("无法打开日志文件:", err)
        return
    }
    defer file.Close()

    logMsg := "新的日志记录：系统启动成功。\n"

    // 写入日志
    if _, err := file.WriteString(logMsg); err != nil {
        fmt.Println("写入日志失败:", err)
    } else {
        fmt.Println("日志已追加")
    }
}

第六部分：大文件处理与内存优化

当处理几百 MB 甚至 GB 级别的文件时，严禁使用 ioutil.ReadFile，因为它会尝试一次性将整个文件读入内存，导致程序崩溃（OOM）。此时必须使用 os 包配合 bufio 进行缓冲读取。

1. 使用 bufio.Reader 逐行读取

bufio 通过在内存中维护一个缓冲区（默认 4KB），减少了直接从磁盘读取 I/O 的次数，极大提高了读取效率。

1. 创建 os.File 对象。
2. 包装该对象创建 bufio.Reader。
3. 循环调用 reader.ReadString('\n') 直到遇到错误（通常是 io.EOF）。

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)

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

    // 创建带缓冲的读取器
    reader := bufio.NewReader(file)
    lineCount := 0

    for {
        // 读取直到遇到换行符
        line, err := reader.ReadString('\n')
        if err != nil {
            // 如果是文件结束错误，说明正常读完
            if err == io.EOF {
                break
            }
            panic(err)
        }

        lineCount++
        // 处理每一行的数据
        // fmt.Print(line) 
    }

    fmt.Printf("文件读取完毕，共 %d 行\n", lineCount)
}

2. 使用 bufio.Scanner 分词读取

除了按行读取，bufio.Scanner 还提供了灵活的分词功能，默认是按行分割，也可以自定义分割函数。

1. 创建 bufio.Scanner 对象。
2. 循环调用 scanner.Scan()，该方法会返回 false 当读取结束或出错。
3. 使用 scanner.Text() 获取当前扫描到的内容。
4. 检查 scanner.Err() 确认没有发生错误。

package main

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

func main() {
    file, _ := os.Open("data.txt")
    defer file.Close()

    scanner := bufio.NewScanner(file)

    // 可选：设置自定义缓冲区大小（针对超长行）
    // buf := make([]byte, 0, 64*1024*1024)
    // scanner.Buffer(buf, 1024*1024*1024)

    for scanner.Scan() {
        line := scanner.Text()
        // 处理逻辑
        fmt.Println("处理行:", line)
    }

    if err := scanner.Err(); err != nil {
        fmt.Println("读取错误:", err)
    }
}