本文讲解如何使用 Go 的 archive/tar 包打包文件时，将原始绝对路径（如 /tmp/xyz/file.txt）转换为相对路径（如 xyz/file.txt），避免解压后出现冗余的根目录层级。

本文讲解如何使用 go 的 `archive/tar` 包打包文件时，将原始绝对路径（如 `/tmp/xyz/file.txt`）转换为相对路径（如 `xyz/file.txt`），避免解压后出现冗余的根目录层级。

在 Go 中使用 tar.Writer 打包文件时，归档内文件的路径完全由 tar.Header.Name 字段决定——它不自动做路径裁剪或标准化。默认直接填入 _path（如 /tmp/xyz/file.go），会导致解压后生成 /tmp/xyz/... 目录结构，这通常不符合预期（尤其在分发或容器化场景中需保持扁平、可移植的路径）。

要实现“去根目录”效果（例如将 /tmp/xyz/a.txt 存为 xyz/a.txt），关键是在构造 tar.Header 时，手动截取原始路径中目标基准目录之后的部分。推荐做法是：以输入的 inPath（即待打包的顶层目录路径）为基准，对每个文件路径执行相对化处理。

以下是优化后的核心逻辑（已整合进原函数并增强健壮性）：

import (
    "strings"
    "path/filepath"
)

func TarGzWrite(filePath string, basePath string, tw *tar.Writer, fi os.FileInfo) error {
    fr, err := os.Open(filePath)
    if err != nil {
        return fmt.Errorf("open %s: %w", filePath, err)
    }
    defer fr.Close()

    // ✅ 关键：计算相对于 basePath 的相对路径
    relPath, err := filepath.Rel(basePath, filePath)
    if err != nil {
        return fmt.Errorf("compute relative path for %s from %s: %w", filePath, basePath, err)
    }

    h := &tar.Header{
        Name:    relPath,              // 如 "xyz/a.txt"，而非 "/tmp/xyz/a.txt"
        Size:    fi.Size(),
        Mode:    int64(fi.Mode()),
        ModTime: fi.ModTime(),
    }

    if err := tw.WriteHeader(h); err != nil {
        return fmt.Errorf("write header for %s: %w", relPath, err)
    }

    if _, err := io.Copy(tw, fr); err != nil {
        return fmt.Errorf("copy content of %s: %w", relPath, err)
    }
    return nil
}

对应地，更新递归遍历函数，传入 basePath 并调用新签名的 TarGzWrite：

func IterDirectory(dirPath string, basePath string, tw *tar.Writer) error {
    dir, err := os.Open(dirPath)
    if err != nil {
        return fmt.Errorf("open dir %s: %w", dirPath, err)
    }
    defer dir.Close()

    fis, err := dir.Readdir(0)
    if err != nil {
        return fmt.Errorf("read dir %s: %w", dirPath, err)
    }

    for _, fi := range fis {
        curPath := filepath.Join(dirPath, fi.Name())
        if fi.IsDir() {
            if err := IterDirectory(curPath, basePath, tw); err != nil {
                return err
            }
        } else {
            fmt.Printf("adding... %s\n", curPath)
            if err := TarGzWrite(curPath, basePath, tw, fi); err != nil {
                return err
            }
        }
    }
    return nil
}

func retarIt(outFilePath, inPath string) error {
    fw, err := os.Create(outFilePath)
    if err != nil {
        return fmt.Errorf("create %s: %w", outFilePath, err)
    }
    defer fw.Close()

    gw := gzip.NewWriter(fw)
    defer gw.Close()

    tw := tar.NewWriter(gw)
    defer tw.Close()

    // ✅ 传入 inPath 作为基准路径，供 filepath.Rel 使用
    if err := IterDirectory(inPath, inPath, tw); err != nil {
        return err
    }

    // 必须显式调用 Close() 以 flush tar trailer 和 gzip footer
    if err := tw.Close(); err != nil {
        return fmt.Errorf("close tar writer: %w", err)
    }
    if err := gw.Close(); err != nil {
        return fmt.Errorf("close gzip writer: %w", err)
    }

    fmt.Println("tar.gz created successfully")
    return nil
}

✅ 关键注意事项：

• 永远使用 filepath.Rel(basePath, fullPath)：它跨平台安全（自动处理 / vs \），比手动 strings.LastIndex 更可靠，且能正确处理符号链接、空路径等边界情况。
• basePath 必须与 inPath 完全一致：确保 filepath.Rel 能精准剥离前缀。若传入 /tmp/xyz/，则 /tmp/xyz/a.txt → a.txt；若传入 /tmp，则结果为 xyz/a.txt。
• 务必显式关闭 tw 和 gw：否则 tar 尾部和 gzip 校验信息可能丢失，导致解压失败。
• 错误处理不可省略：原代码中大量 _ = 会掩盖 I/O 或权限问题，生产环境必须传播错误。

通过以上改造，生成的 tar 包内部路径将严格遵循你指定的相对结构，解压后直接得到干净的 xyz/... 目录树，真正实现路径可控、可移植的归档打包。