Go path.Match 为什么双星号不能匹配多级目录

如果你把其他 glob 工具里的 ** 直接搬到 Go 的 path.Match，多级目录通常不会按预期匹配。原因很简单：path.Match 里的每个 * 都只匹配“不包含斜杠的字符序列”，连续写两个星号也只是两个相邻的普通通配符，并没有“跨越任意层目录”的特殊语义。

官方文档：https://pkg.go.dev/path#Match

因此，**/*.go 对 cmd/main.go 可能匹配成功，但对 cmd/api/main.go 会失败。前者只有一个目录分隔层，后者在模式已经消费掉一个斜杠后还剩一个斜杠，最后的 *.go 无法越过它。

先确认 path.Match 的匹配边界

path.Match(pattern, name) 比较的是整个 name，不是任意子串。常用语法可以压缩成三条：

• *：匹配任意长度的非斜杠字符，可以匹配空字符串。
• ?：匹配一个非斜杠字符。
• /：是字面意义上的路径分隔符，会把匹配范围隔开。

也就是说，星号的“任意”只覆盖一个路径片段，而不是整棵目录树。下面这张图把输入、模式和边界放在一起看：

用最小示例拆开双星号

先不要把两个星号想成一个新运算符，直接把它看成两个相邻的 *。模式中间的斜杠仍然只有一个，末尾的 *.go 仍然不能跨越斜杠。

package main

import (
    "fmt"
    "path"
)

func main() {
    // 双星号只是两个相邻的 *，每个 * 都不能跨过斜杠。
    cases := []struct {
        pattern string
        name    string
    }{
        {"**/*.go", "cmd/main.go"},
        {"**/*.go", "cmd/api/main.go"},
        {"*.go", "main.go"},
        {"*.go", "cmd/main.go"},
    }

    for _, item := range cases {
        matched, err := path.Match(item.pattern, item.name)
        // 先保留 err，再根据 matched 判断是否真正命中。
        fmt.Printf("pattern=%q name=%q matched=%v err=%v\n", item.pattern, item.name, matched, err)
    }
}

这段示例的关键不在于“多写一个星号”，而在于路径分段：

• cmd/main.go 只有一个斜杠，前面的 ** 可以覆盖 cmd，后面的 *.go 可以覆盖 main.go。
• cmd/api/main.go 有两个斜杠，后面的 *.go 需要从 api/main.go 中跨过一个斜杠，这是 path.Match 不允许的。

把匹配结果和 ErrBadPattern 分开处理

“返回 false”和“模式写错了”不是一回事。官方定义中，模式格式错误时才返回 path.ErrBadPattern；语法合法但名称不匹配时，返回值通常是 false, nil。

package main

import (
    "errors"
    "fmt"
    "path"
)

func check(pattern, name string) {
    matched, err := path.Match(pattern, name)
    switch {
    case err != nil:
        // ErrBadPattern 说明模式语法错误，不应当按普通未匹配处理。
        fmt.Printf("模式错误：%q -> %v\n", pattern, errors.Is(err, path.ErrBadPattern))
    case matched:
        // matched 为 true 表示整个 name 都符合模式。
        fmt.Printf("匹配：%q -> %q\n", pattern, name)
    default:
        // false、nil 表示语法合法，但整个 name 没有命中。
        fmt.Printf("未匹配：%q -> %q\n", pattern, name)
    }
}

func main() {
    check("*.go", "main.go")
    check("*.go", "cmd/main.go")
    check("[", "main.go")
}

这里还要注意一个容易忽略的点：path.Match("*.go", "x/main.go") 不会做“文件名后缀搜索”，而是要求整个名称满足模式。若业务要从完整路径中提取文件名后再匹配，需要先明确拆分路径，而不是继续增加星号。

需要多级目录时选择合适的流程

修复方式取决于你手里的数据是什么。不要先假设 ** 一定存在，再用更多星号试错。

逻辑路径：按片段匹配

如果输入是 URL、对象键或模块路径这类“用斜杠分隔的逻辑路径”，可以先按 / 切分，再让每个片段使用 path.Match。这种做法的优点是规则清楚：普通 * 匹配一段，是否允许任意层级由你自己的代码决定。

package main

import (
    "fmt"
    "path"
    "strings"
)

func matchOneLevel(pattern, name string) bool {
    // 逐段匹配，避免让单个 * 意外跨过路径分隔符。
    patternParts := strings.Split(pattern, "/")
    nameParts := strings.Split(name, "/")
    if len(patternParts) != len(nameParts) {
        return false
    }
    for i := range patternParts {
        matched, err := path.Match(patternParts[i], nameParts[i])
        // 任一片段出现语法错误或未匹配，整条路径就不命中。
        if err != nil || !matched {
            return false
        }
    }
    return true
}

func main() {
    fmt.Println(matchOneLevel("*/api/*.go", "cmd/api/main.go"))
}

上面的函数适合“层级数量固定”的模式。如果模式本身还要表达任意层级，就需要额外设计 ** 的递归或动态规划语义，或者选用明确支持多级 glob 的实现；不要把两个普通星号误认为已经完成了这层设计。

真实文件系统：先遍历，再决定是否匹配

path.Match 只负责比较字符串，不负责遍历目录，也不会替你读取文件系统。真实文件查找可以先用文件系统遍历 API 得到相对路径，再把相对路径交给匹配函数；这样“发现文件”和“判断路径模式”是两个可独立测试的阶段。

如果只是处理单层目录，直接使用 path.Match 足够；如果是跨平台的本地文件路径，优先确认是否应使用 path/filepath；如果需求明确包含任意层级通配，则应采用有清晰多级语义的实现，并把它的规则写进测试。

常见误区与速查表

相关问题

• path.Match 能匹配任意子串吗？不能，它要求模式覆盖整个名称。
• 为什么 * 不能匹配斜杠？这是该 API 的模式语法边界，星号只覆盖非斜杠字符。
• 什么时候应该换成逐段匹配？当业务把路径层级当作独立字段，或需要明确控制每一层的规则时。
• 真实目录递归搜索能直接交给 path.Match 吗？不能，遍历文件系统与匹配字符串是两个步骤。

总结一下：path.Match 没有把 ** 定义成多级目录通配符。连续星号仍受“不能匹配斜杠”的规则限制；看到多层路径时，应按片段拆分、先遍历再匹配，或使用明确支持多级语义的实现。把 matched 与 err 一起处理，才能区分未命中和模式写错。