Go语言文件读写教程：从基础到高效实践

go语言提供了强大且灵活的文件i/o（输入/输出）能力，通过标准库中的os、io和bufio等包，开发者可以高效地进行文件的读写操作。理解这些包的使用方式对于任何go语言开发者都至关重要。本文将从最基础的文件操作开始，逐步深入到更高级和高效的i/o模式。

1. 基础文件操作：os 包

os包提供了操作系统功能的核心接口，包括文件和目录操作。进行文件读写时，我们通常会使用os.Open打开现有文件进行读取，或使用os.Create创建新文件（或截断现有文件）进行写入。

1.1 打开和创建文件

• os.Open(name string) (*File, error): 打开一个文件进行读取。如果文件不存在或没有权限，将返回错误。
• os.Create(name string) (*File, error): 创建一个文件进行写入。如果文件已存在，其内容将被截断（清空）。
• os.OpenFile(name string, flag int, perm FileMode) (*File, error): 这是更通用的文件打开函数，允许指定打开模式（只读、只写、读写、追加等）和文件权限。os.Open和os.Create都是基于此函数的便捷封装。

1.2 读取和写入数据

一旦文件被打开，就可以使用File类型的方法进行读写。Read和Write方法都接受一个字节切片[]byte作为缓冲区。

• func (f *File) Read(b []byte) (n int, err error): 从文件中读取数据到字节切片b中。n表示实际读取的字节数，err表示读取过程中遇到的错误。当到达文件末尾时，Read会返回io.EOF错误，同时n可能仍包含已读取的数据。
• func (f *File) Write(b []byte) (n int, err error): 将字节切片b中的数据写入文件。n表示实际写入的字节数。

1.3 错误处理与资源释放

文件操作中，错误处理至关重要。同时，打开的文件句柄是系统资源，必须在使用完毕后关闭以避免资源泄露。Go语言的defer语句非常适合处理这类资源释放。

package main

import (
    "io"
    "os"
)

func main() {
    // 1. 打开输入文件
    fi, err := os.Open("input.txt")
    if err != nil {
        panic(err) // 实际应用中应进行更优雅的错误处理
    }
    // 使用defer确保文件在函数退出时关闭，并检查关闭操作的错误
    defer func() {
        if err := fi.Close(); err != nil {
            panic(err)
        }
    }()

    // 2. 创建输出文件
    fo, err := os.Create("output.txt")
    if err != nil {
        panic(err)
    }
    defer func() {
        if err := fo.Close(); err != nil {
            panic(err)
        }
    }()

    // 3. 创建一个缓冲区用于分块读写
    buf := make([]byte, 1024) // 每次读取1KB
    for {
        // 4. 从输入文件读取数据
        n, err := fi.Read(buf)
        if err != nil && err != io.EOF { // 检查是否为非EOF错误
            panic(err)
        }
        if n == 0 { // 如果读取到0字节，表示文件已读完
            break
        }

        // 5. 将读取到的数据写入输出文件
        if _, err := fo.Write(buf[:n]); err != nil { // 只写入实际读取的n个字节
            panic(err)
        }
    }
}

注意事项：

小绿鲸英文文献阅读器

英文文献阅读器，专注提高SCI阅读效率

199

查看详情

立即学习“go语言免费学习笔记（深入）”；

• io.EOF的处理：当Read方法返回io.EOF时，n可能大于0，这意味着在到达文件末尾之前，缓冲区仍被部分填充。后续的Read调用将返回n=0和io.EOF。
• panic的使用：示例代码中使用了panic来简化错误处理。在生产环境中，更推荐返回error或使用自定义错误处理逻辑，以便调用者能够优雅地处理错误。

2. 高效带缓冲I/O：bufio 包

当需要频繁地进行小块数据读写或处理文本文件时，直接使用os.File的Read/Write方法效率可能不高，因为每次操作都可能涉及系统调用。bufio包提供了带缓冲的I/O操作，通过在内存中维护一个缓冲区，减少了实际的系统调用次数，从而提高了I/O效率。

bufio包的核心是Reader和Writer类型：

• bufio.NewReader(r io.Reader) *Reader: 创建一个新的带缓冲的读取器。
• bufio.NewWriter(w io.Writer) *Writer: 创建一个新的带缓冲的写入器。

使用bufio时，写入的数据首先进入缓冲区，直到缓冲区满、调用Flush()方法或关闭写入器时，数据才会被真正写入底层文件。

package main

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

func main() {
    // 1. 打开输入文件并创建带缓冲的读取器
    fi, err := os.Open("input.txt")
    if err != nil {
        panic(err)
    }
    defer func() {
        if err := fi.Close(); err != nil {
            panic(err)
        }
    }()
    r := bufio.NewReader(fi) // 创建带缓冲的读取器

    // 2. 创建输出文件并创建带缓冲的写入器
    fo, err := os.Create("output.txt")
    if err != nil {
        panic(err)
    }
    defer func() {
        if err := fo.Close(); err != nil {
            panic(err)
        }
    }()
    w := bufio.NewWriter(fo) // 创建带缓冲的写入器
    // 确保在函数退出前刷新缓冲区，将所有数据写入文件
    defer func() {
        if err := w.Flush(); err != nil {
            panic(err)
        }
    }()

    // 3. 创建缓冲区并进行读写
    buf := make([]byte, 1024)
    for {
        n, err := r.Read(buf) // 从带缓冲的读取器读取
        if err != nil && err != io.EOF {
            panic(err)
        }
        if n == 0 {
            break
        }

        if _, err := w.Write(buf[:n]); err != nil { // 写入带缓冲的写入器
            panic(err)
        }
    }
    // 在循环结束后，确保所有写入的数据都被刷新到文件中
    // 这里的defer w.Flush() 已经处理了
}

注意事项：

立即学习“go语言免费学习笔记（深入）”；

• Flush()的重要性：对于bufio.Writer，必须显式调用Flush()方法，或者等待其被关闭，才能确保所有缓冲区中的数据被写入底层文件。在defer中调用Flush()是一个好习惯。
• bufio在处理文本文件时尤其有用，它提供了ReadString、ReadLine、Scan等高级方法，方便按行或按特定分隔符读取数据。

3. 简洁的整文件读写：os.ReadFile 和 os.WriteFile (原 io/ioutil)

对于小型文件，如果需要一次性读取整个文件内容到内存，或者将整个字节切片写入文件，os.ReadFile和os.WriteFile提供了非常简洁的API。

历史回顾： 在Go 1.16版本之前，这些功能由io/ioutil包提供，即ioutil.ReadFile和ioutil.WriteFile。从Go 1.16开始，io/ioutil包已被废弃，其功能已迁移到os和io包中。因此，现在应使用os.ReadFile和os.WriteFile。

• os.ReadFile(name string) ([]byte, error): 读取整个文件内容，并返回一个字节切片。
• os.WriteFile(name string, data []byte, perm fs.FileMode) error: 将字节切片data写入指定文件。如果文件不存在则创建，如果存在则截断。perm参数用于设置文件权限。

package main

import (
    "os"
)

func main() {
    // 1. 读取整个输入文件内容
    b, err := os.ReadFile("input.txt")
    if err != nil {
        panic(err)
    }

    // 2. 将内容写入输出文件，并设置文件权限为0644（-rw-r--r--)
    err = os.WriteFile("output.txt", b, 0644)
    if err != nil {
        panic(err)
    }
}

注意事项：

立即学习“go语言免费学习笔记（深入）”；

• 内存消耗：这些函数会将整个文件内容加载到内存中。因此，它们不适用于处理大型文件（几GB甚至更大），否则可能导致内存溢出。
• 便捷性：对于配置文件、小型日志文件或任何已知大小不会过大的文件，这些函数提供了极大的便利性，避免了手动管理文件句柄和缓冲区的复杂性。

总结与选择

Go语言提供了多种文件读写方式，每种方式都有其适用场景：

• os包（分块读写）：适用于需要精细控制I/O流程、处理大文件或进行流式处理的场景。需要手动管理缓冲区和io.EOF。
• bufio包（带缓冲读写）：在os包的基础上提供了缓冲层，提高了I/O效率，特别适合频繁读写小块数据或按行/字符串处理文本文件。
• os.ReadFile / os.WriteFile（整文件读写）：最简洁的方式，适用于一次性读写整个小型文件。但需要注意内存消耗，不适用于大文件。

在实际开发中，应根据文件大小、读写频率和具体需求选择最合适的I/O方法。始终记得使用defer file.Close()来确保文件资源得到及时释放，并妥善处理所有可能返回的错误。

以上就是Go语言文件读写教程：从基础到高效实践的详细内容，更多请关注php中文网其它相关文章！