Go os 怎样在根对象中打开同一目录下多个文件

同一目录有多个文件需要读取时，先用 os.OpenRoot(dir) 取得一个根对象，再对各个相对名称调用 root.Open(name)。每次取得的文件都要独立关闭，批次结束后再关闭根对象。不要把文件的 defer 全部放在外层循环所在函数里，否则它们会积累到整个函数返回时才释放。

官方地址：https://go.dev/

只有一个文件与整批文件，选择不同入口

单个文件可以使用 os.OpenInRoot(dir, name)。当任务是同一根目录下的多个文件，显式保留 Root 更容易表达整个批次的资源归属。OpenRoot、Root.Open 与 OpenInRoot 的基础接口从 Go 1.24 提供，不是 Go 1.27 新增。

触发这次改写的典型信号，是批处理反复打开同一目录、文件句柄随批量增长，或相对名称与进程工作目录混用。不要据此虚构已经发生句柄泄漏：应先区分打开文件数量、并发数与关闭位置。以下示例是原创参考，没有在本任务运行。

同一目录的名称规则，与 Root 边界分开处理

Root 的能力是把路径解析限制在根目录树中，并不是业务文件白名单。本文任务只允许直接子文件，所以额外用 fs.ValidPath 和斜杠检查拒绝子目录名称、点路径与空名称；再拒绝反斜杠，避免跨平台名称解释差异。这是示例的业务约束，不是替代 Root 的防护措施。

文件名检查无法证明符号链接指向的文件仍在同一层。Root 会处理根目录边界，但“只允许普通文件、禁止符号链接、只允许某扩展名”等要求需要另行设计。更不能把 Root 当作完整沙箱：它不负责租户授权、内容格式正确性或限制所有特殊文件的行为。官方说明见 Go 的 Root 文件访问设计。

最小实现：根对象复用，文件每轮释放

下例顺序读取，单文件最多接收 1 MiB，总名称数量最多 32 个；数量与大小是示例预算，不是 os 包限制。批次内某个文件失败仍继续后续条目，返回结果保留输入顺序。辅助函数保证每轮返回时就关闭文件，并保留读取和关闭错误。

package rootbatch

import (
    "errors"
    "fmt"
    "io"
    "io/fs"
    "os"
    "strings"
)

type Result struct {
    Name string
    Data []byte
    Err  error
}

func ReadBatch(dir string, names []string) (results []Result, err error) {
    // 预算在打开根对象之前检查，避免无界批次。
    if len(names) > 32 {
        return nil, fmt.Errorf("单批最多32个文件")
    }
    root, err := os.OpenRoot(dir)
    if err != nil {
        return nil, fmt.Errorf("打开根目录: %w", err)
    }
    defer func() { err = errors.Join(err, root.Close()) }()

    results = make([]Result, 0, len(names))
    for _, name := range names {
        if !fs.ValidPath(name) || name == "." || strings.ContainsAny(name, "/\\") {
            results = append(results, Result{Name: name, Err: fmt.Errorf("只允许直接子文件名")})
            continue
        }
        data, readErr := readOne(root, name)
        // 单文件失败保存在结果中，不伪装成空文件读取成功。
        results = append(results, Result{Name: name, Data: data, Err: readErr})
    }
    return results, nil
}

func readOne(root *os.Root, name string) (data []byte, err error) {
    f, err := root.Open(name)
    if err != nil {
        return nil, fmt.Errorf("打开文件: %w", err)
    }
    // 此函数每轮结束即释放文件，不等待整个批次完成。
    defer func() { err = errors.Join(err, f.Close()) }()
    info, err := f.Stat()
    if err != nil {
        return nil, err
    }
    if !info.Mode().IsRegular() {
        return nil, fmt.Errorf("不是普通文件")
    }
    const maxBytes = 1  maxBytes {
        return nil, fmt.Errorf("文件超过读取预算")
    }
    return data, nil
}

Data 与 Err 应一起看：关闭失败时可能仍保留已读 Data，但应由调用方决定是否接收；不能只判断 Data 非空。该函数的顶层 err 负责根对象初始化与关闭错误，逐项 Err 负责名称、打开、读取与关闭。顶层返回 nil 不代表所有条目都成功。

普通文件检查发生在打开之后，不能把它当作对任意不可信特殊文件的无阻塞保证。这个例子面向受控目录中的普通文件，不承诺阻止所有特殊设备、挂载点或硬链接相关风险，也没有实现内容快照。文件在批次期间被其他进程改写时，不同文件可能来自不同时间状态。

失败后不要回退到普通路径拼接

若 root.Open 返回越界、权限或不存在错误，应把该条目标记失败；不要为了“兼容”再调用 os.Open(filepath.Join(dir, name)) 绕开根对象。这样会改变安全与解析语义，让错误处理路径成为另一套访问方式。

只读批次没有需要撤销的文件写入。这里的恢复动作是停止接收有问题条目的数据，修复目录、权限或名称来源，再开启新的批次；是否重试及次数由业务明确指定。不要把权限失败自动改为更高权限执行，也不要默默忽略未读条目。

用资源归属确认完成，而不是只数成功条目

读者在自己的受控目录运行时，应准备几个小普通文件及一个不存在的名称，分别观察逐项结果与顶层错误；确认失败条目没有被当作空内容成功，批次结束后不再使用 Root。本文不运行这些检查，也不提供虚构输出。

复盘只需问清四件事：Root 谁创建、每个 File 谁关闭、部分失败谁决定继续、整批结果谁负责消费。若改为并发读取，应先等待全部使用者退出，再关闭 Root，并设定并发与内存上限；本文示例保持顺序，不假定并发一定更快。

关闭 Root 可以代替关闭所有 File 吗？

不要这样设计。每个成功打开的 File 都有独立关闭责任，本例明确逐文件关闭，最后才释放 Root。

复用 Root 会得到同目录内容的快照吗？

不会。它限制访问边界，不提供跨文件的一致性事务或不可变内容保证。

为什么不用 Root.ReadFile 简化？

小而可信的文件可以考虑对应接口；本文使用 Open 与 LimitReader，是为了明确表达读取预算与每个文件句柄的释放位置。

官方参考：OpenRoot、Root.Open、OpenInRoot。两张图均为原创结构说明图，不是代码运行证据。