使用缓冲可提升Go文件流操作性能。1. 读取大文件时用bufio.Reader批量读取，减少系统调用；2. 写入文件时用bufio.Writer暂存数据，满后一次性写入；3. 计算哈希时流式读取，避免内存溢出。需合理设置缓冲大小并及时刷新缓冲区。

在 Go 语言中，文件流操作和缓冲策略是处理大文件或高吞吐 I/O 场景的核心。合理使用缓冲可以显著提升性能，避免频繁系统调用带来的开销。下面通过常见场景说明如何高效操作文件流并应用缓冲策略。

读取大文件：使用 bufio.Reader 增加缓冲

直接使用 os.File.Read 会带来大量小块读取的系统调用。借助 bufio.Reader 可以批量读取数据，减少 I/O 次数。

示例：逐行读取大日志文件

package main

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

func readWithBuffer(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    reader := bufio.NewReaderSize(file, 4096) // 设置 4KB 缓冲
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            break // 文件结束或出错
        }
        fmt.Print(line)
    }
}

说明：NewReaderSize 允许自定义缓冲区大小，适合调整为磁盘块大小（如 4KB）以匹配底层存储特性。

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

写入文件：使用 bufio.Writer 减少写操作次数

频繁写入小数据会导致性能下降。使用 bufio.Writer 将内容暂存缓冲区，满后一次性写入磁盘。

示例：批量写入日志条目

func writeWithBuffer(filename string) {
    file, err := os.Create(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    writer := bufio.NewWriterSize(file, 8192)
    defer writer.Flush() // 关键：确保缓冲区内容写入文件

    for i := 0; i < 1000; i++ {
        fmt.Fprintf(writer, "Log entry %d\n", i)
    }
}

注意：必须调用 Flush()，否则最后不满缓冲区的数据可能丢失。

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

高效复制文件：io.Copy 与缓冲机制协同

Go 的 io.Copy 默认会尝试使用内部缓冲，但显式提供缓冲区可进一步优化控制。

示例：带缓冲的文件复制

func copyFile(src, dst string) error {
    srcFile, err := os.Open(src)
    if err != nil {
        return err
    }
    defer srcFile.Close()

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

    buffer := make([]byte, 32768) // 32KB 缓冲
    _, err = io.CopyBuffer(dstFile, srcFile, buffer)
    return err
}

使用 CopyBuffer 可指定缓冲区大小，适用于网络传输或大文件拷贝，比默认 Copy 更可控。

按块处理文件：避免内存溢出

对于超大文件，不能一次性加载进内存。应采用定长块读取方式。

示例：计算文件 SHA256 哈希

func hashFile(filename string) (string, error) {
    file, err := os.Open(filename)
    if err != nil {
        return "", err
    }
    defer file.Close()

    hash := sha256.New()
    buffer := make([]byte, 65536) // 64KB 块读取

    for {
        n, err := file.Read(buffer)
        if n > 0 {
            hash.Write(buffer[:n])
        }
        if err == io.EOF {
            break
        }
        if err != nil {
            return "", err
        }
    }

    return fmt.Sprintf("%x", hash.Sum(nil)), nil
}

这种方式只占用固定内存，适合处理 GB 级以上文件。

基本上就这些。关键是根据场景选择合适的缓冲大小，并记得刷新写入缓冲。不复杂但容易忽略细节。