Go语言中实现健壮且高效的文件复制策略

package main

import (
    "fmt"
    "os"
)

func createHardLink(src, dst string) error {
    err := os.Link(src, dst)
    if err != nil {
        return fmt.Errorf("创建硬链接失败: %w", err)
    }
    return nil
}

func main() {
    // 假设存在一个名为 "source.txt" 的文件
    // err := os.WriteFile("source.txt", []byte("Hello, Go hard link!"), 0644)
    // if err != nil {
    //  fmt.Println("创建源文件失败:", err)
    //  return
    // }

    // fmt.Println("尝试创建硬链接...")
    // if err := createHardLink("source.txt", "hardlink.txt"); err != nil {
    //  fmt.Println(err)
    // } else {
    //  fmt.Println("硬链接创建成功: source.txt -> hardlink.txt")
    // }
}

package main

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

// CopyFile copies a file from src to dst. If src and dst files exist, and are
// the same, then return success. Otherise, attempt to create a hard link
// between the two files. If that fail, copy the file contents from src to dst.
func CopyFile(src, dst string) (err error) {
    // 1. 获取源文件信息并进行检查
    sfi, err := os.Stat(src)
    if err != nil {
        return fmt.Errorf("获取源文件信息失败: %w", err)
    }
    if !sfi.Mode().IsRegular() {
        return fmt.Errorf("CopyFile: 源文件 %s (%q) 不是常规文件", sfi.Name(), sfi.Mode().String())
    }

    // 2. 获取目标文件信息并进行检查
    dfi, err := os.Stat(dst)
    if err != nil {
        if !os.IsNotExist(err) { // 如果错误不是文件不存在，则直接返回
            return fmt.Errorf("获取目标文件信息失败: %w", err)
        }
        // 目标文件不存在，err为os.IsNotExist，继续执行
    } else {
        if !dfi.Mode().IsRegular() {
            return fmt.Errorf("CopyFile: 目标文件 %s (%q) 不是常规文件", dfi.Name(), dfi.Mode().String())
        }
        if os.SameFile(sfi, dfi) { // 如果源文件和目标文件是同一个文件，直接返回成功
            return nil
        }
    }

    // 3. 尝试创建硬链接 (作为优化)
    if err = os.Link(src, dst); err == nil {
        return nil // 硬链接成功，返回
    }
    // 如果硬链接失败，回退到内容复制

    // 4. 执行文件内容复制
    err = copyFileContents(src, dst)
    return err
}

// copyFileContents copies the contents of the file named src to the file named
// by dst. The file will be created if it does not already exist. If the
// destination file exists, all it's contents will be replaced by the contents
// of the source file.
func copyFileContents(src, dst string) (err error) {
    in, err := os.Open(src)
    if err != nil {
        return fmt.Errorf("打开源文件失败: %w", err)
    }
    defer in.Close() // 确保源文件关闭

    out, err := os.Create(dst) // 创建或截断目标文件
    if err != nil {
        return fmt.Errorf("创建目标文件失败: %w", err)
    }
    defer func() {
        cerr := out.Close() // 确保目标文件关闭
        if err == nil {     // 如果在io.Copy期间没有错误，则将关闭错误赋值
            err = cerr
        }
    }()

    // 使用 io.Copy 进行内容复制
    if _, err = io.Copy(out, in); err != nil {
        return fmt.Errorf("复制文件内容失败: %w", err)
    }

    // 同步文件内容到磁盘，确保持久性
    err = out.Sync()
    if err != nil {
        return fmt.Errorf("同步目标文件到磁盘失败: %w", err)
    }
    return nil
}

func main() {
    if len(os.Args) < 3 {
        fmt.Println("用法: go run your_program.go <源文件> <目标文件>")
        return
    }

    srcFile := os.Args[1]
    dstFile := os.Args[2]

    fmt.Printf("正在复制 %s 到 %s\n", srcFile, dstFile)
    err := CopyFile(srcFile, dstFile)
    if err != nil {
        fmt.Printf("文件复制失败: %q\n", err)
    } else {
        fmt.Printf("文件复制成功\n")
    }
}

// 示例：异步复制函数签名
// func CopyFileAsync(src, dst string) (<-chan error, error) {
//     resultChan := make(chan error, 1) // 带缓冲的channel
//     go func() {
//         err := CopyFile(src, dst)
//         resultChan <- err
//         close(resultChan) // 关闭channel通知发送完成
//     }()
//     return resultChan, nil
// }

// 调用者可以通过 select 语句或阻塞读取 resultChan 来获取复制结果。