五岁博客
所有文章 标签 分类 留言板 友情链接 关于我
五岁博客

目录

Golang 文件复制的 3 种实现方式：io.Copy、缓冲读写与 os.Link 详解

五岁博客 收录于 编程开发
   约 2432 字   预计阅读 5 分钟    次阅读  

为什么需要在 Go 中复制文件

在日常开发中，文件复制是一个非常基础但又容易踩坑的操作。比如做日志归档、配置文件备份、用户上传文件的临时存储等场景，都需要把一个文件完整地拷贝到另一个路径。Go 语言的标准库提供了简洁而强大的文件操作接口，不需要依赖任何第三方包就能轻松实现文件复制。

这篇文章会带你从最基础的 io.Copy 开始，逐步深入到带缓冲区的分块读写，再到利用硬链接实现"零拷贝"的思路，帮你在不同场景下选择最合适的方案。

方法一：使用 io.Copy 实现标准文件复制

这是最常见也是最推荐的做法。Go 标准库中的 io.Copy 函数会自动处理数据从源文件到目标文件的传输，内部默认使用 32KB 的缓冲区，对于绝大多数场景来说已经足够高效。

package main

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

// CopyFile 使用 io.Copy 复制文件
func CopyFile(srcFile, dstFile string) (int64, error) {
    sourceFileStat, err := os.Stat(srcFile)
    if err != nil {
        return 0, err
    }

    if !sourceFileStat.Mode().IsRegular() {
        return 0, fmt.Errorf("%s 不是一个常规文件", srcFile)
    }

    source, err := os.Open(srcFile)
    if err != nil {
        return 0, err
    }
    defer source.Close()

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

    nBytes, err := io.Copy(destination, source)
    return nBytes, err
}

func main() {
    bytesCopied, err := CopyFile("source.txt", "dest.txt")
    if err != nil {
        fmt.Println("复制失败:", err)
        return
    }
    fmt.Printf("复制成功，共写入 %d 字节\n", bytesCopied)
}

代码解析

  1. os.Stat 检查源文件：在打开文件之前先确认文件是否存在，以及是否是常规文件（排除目录、设备文件等）。
  2. os.Open 打开源文件：以只读模式打开，配合 defer 确保函数退出时自动关闭文件句柄。
  3. os.Create 创建目标文件：如果目标文件已存在会被截断清空，如果不存在则新建。
  4. io.Copy 执行复制：将源文件内容写入目标文件，返回实际写入的字节数。

这种方式的优点是代码简洁，而且 io.Copy 底层会根据操作系统特性自动选择高效的传输方式。

方法二：使用缓冲区分块读写

如果你需要对复制过程有更精细的控制——比如显示进度、限制内存占用或者在复制过程中做数据校验——可以手动用缓冲区来分块读写。

package main

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

// CopyFileWithBuffer 使用自定义缓冲区复制文件
func CopyFileWithBuffer(srcFile, dstFile string, bufferSize int) (int64, error) {
    source, err := os.Open(srcFile)
    if err != nil {
        return 0, err
    }
    defer source.Close()

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

    buf := make([]byte, bufferSize)
    var totalBytes int64

    for {
        n, err := source.Read(buf)
        if n > 0 {
            written, writeErr := destination.Write(buf[:n])
            if writeErr != nil {
                return totalBytes, writeErr
            }
            totalBytes += int64(written)
        }
        if err == io.EOF {
            break
        }
        if err != nil {
            return totalBytes, err
        }
    }

    return totalBytes, nil
}

func main() {
    // 使用 4KB 缓冲区
    bytesCopied, err := CopyFileWithBuffer("source.txt", "dest.txt", 4096)
    if err != nil {
        fmt.Println("复制失败:", err)
        return
    }
    fmt.Printf("复制成功，共写入 %d 字节\n", bytesCopied)
}

代码解析

这段代码的核心在于循环调用 Read 和 Write：

  • 每次从源文件读取 bufferSize 大小的数据块到缓冲区
  • 然后将实际读到的字节写入目标文件
  • 遇到 io.EOF 表示文件读完，退出循环

你可以根据实际需求调整 bufferSize 的大小。对于大文件，适当增大缓冲区（比如 64KB 或 1MB）可以减少系统调用次数从而提升性能；对于内存受限的环境，可以使用较小的缓冲区。

严格来说这不算"复制"，而是在文件系统层面创建了一个指向相同数据块的新路径。两个文件名共享同一份磁盘数据，不会产生额外的存储开销。

package main

import (
    "fmt"
    "os"
)

func LinkFile(srcFile, dstFile string) error {
    return os.Link(srcFile, dstFile)
}

func main() {
    err := LinkFile("source.txt", "link_dest.txt")
    if err != nil {
        fmt.Println("创建硬链接失败:", err)
        return
    }
    fmt.Println("硬链接创建成功")
}

使用注意事项

  • 硬链接只能在同一个文件系统（同一块磁盘分区）内创建
  • 不能对目录创建硬链接
  • 修改任意一个链接文件的内容，另一个也会同步变化
  • 如果你的目的是创建一份独立的副本，那硬链接并不适合

这种方式最大的优势是速度极快且不占额外磁盘空间，非常适合只读场景下的文件"复制"。

三种方式的对比

特性 io.Copy 缓冲区分块读写 os.Link 硬链接
实现复杂度 低 中 低
可控性 一般 高（可控进度/校验） 无
大文件性能 好 可调优 极快
是否独立副本 是 是 否（共享数据）
跨分区支持 是 是 否

建议：大多数场景直接用 io.Copy 就够了。需要进度条或数据校验时用缓冲区方式。只读且同分区的场景可以考虑硬链接。

实际开发中的几点建议

1. 别忘了处理文件权限

os.Create 默认的权限是 0666（受 umask 影响）。如果你需要保留源文件的权限，可以在复制完成后用 os.Chmod 手动设置：

info, _ := os.Stat(srcFile)
os.Chmod(dstFile, info.Mode())

2. 大文件复制考虑使用 io.CopyBuffer

如果你希望指定缓冲区大小但又不想自己写循环，io.CopyBuffer 是个不错的折中选择：

buf := make([]byte, 1024*1024) // 1MB 缓冲区
io.CopyBuffer(destination, source, buf)

3. 注意错误处理

在 defer destination.Close() 之后，如果写入过程中发生错误，目标文件可能只包含部分数据。在生产环境中，建议先写入临时文件，完成后再通过 os.Rename 原子性地替换目标路径。

常见问题

Q1：io.Copy 复制大文件会不会把整个文件加载到内存？

不会。io.Copy 内部使用固定大小的缓冲区（默认 32KB）分块传输数据，内存占用是恒定的，跟文件大小无关。

Q2：复制后的文件和源文件内容一定完全一致吗？

在正常情况下是一致的。如果你需要严格校验，可以在复制完成后分别计算源文件和目标文件的 MD5 或 SHA256 哈希值进行比对。

Q3：os.Create 如果目标文件已存在会怎样？

os.Create 会把已存在的文件截断为空文件，然后重新写入。如果你不想覆盖已有文件，应该先用 os.Stat 检查目标路径是否已存在。

Q4：Go 中有没有类似 cp 命令的现成函数？

标准库没有直接提供一个 cp 函数，但用 io.Copy 配合 os.Open 和 os.Create 几行代码就能实现，上面的方法一就是最佳实践。

Q5：跨平台复制文件需要注意什么？

Go 的文件操作接口是跨平台的，在 Windows、Linux、macOS 上行为基本一致。但要注意文件路径分隔符的差异，建议使用 filepath.Join 来拼接路径，避免硬编码 / 或 \。

总结

这篇文章介绍了 Go 语言中三种实现文件复制的方式：

  • io.Copy：最简洁实用，适合绝大多数场景，推荐作为首选方案
  • 缓冲区分块读写：提供更细粒度的控制，适合需要进度监控或数据校验的场景
  • os.Link 硬链接：速度快、零存储开销，但只适用于同分区且不需要独立副本的情况

在实际项目中，根据文件大小、是否需要进度回调、是否需要保留文件权限等因素来选择合适的方案就好。Go 标准库在文件操作方面设计得相当优雅，几乎不需要引入第三方依赖就能满足各类文件复制需求。

如果大家在 Go 文件复制方面还有什么疑问，或者你在项目中遇到了什么有趣的文件操作场景，欢迎在评论区一起交流讨论～～～

版权声明

未经授权，禁止转载本文章。
如需转载请保留原文链接并注明出处。即视为默认获得授权。
未保留原文链接未注明出处或删除链接将视为侵权，必追究法律责任！

本文原文链接： https://fiveyoboy.com/articles/golang-copy-file/

备用原文链接： https://blog.fiveyoboy.com/articles/golang-copy-file/

更新于 2026-04-15
 Golang, Go 文件操作, Io.Copy, 文件复制, Go 标准库
返回 | 主页