Go语言中解析命名捕获组的挑战与递归下降解析器的应用

package main

import (
    "fmt"
    "regexp"
)

func main() {
    regexString := `/(?P<country>m((a|b).+)n)/(?P<city>.+)/(?P<street>(5|6). .+)`

    // 用户尝试的正则表达式（为简化演示，此处只展示核心模式）
    // 试图匹配 (?P<name>...) 结构，但内部的括号匹配是难点
    // var capturingGroupNameRegex *regexp.RichRegexp = regexp.MustCompile(
    //     `(?U)` +
    //     `(?P<.+>` +
    //     `(` +   prefixedSubGroups + `|` + postfixedSubGroups + `|` + surroundedSubGroups + `)` +
    //     `)`)
    // 简化为一个更直接但仍有问题的尝试：
    // `(?P<([a-zA-Z0-9_]+)>(.*))` 这样的模式无法正确处理内部嵌套的括号

    // 一个简单的尝试，但无法处理嵌套括号：
    re := regexp.MustCompile(`(?P<([a-zA-Z0-9_]+)>(.*?))`)
    matches := re.FindAllStringSubmatch(regexString, -1)

    fmt.Println("尝试用简单正则匹配结果:")
    for _, match := range matches {
        if len(match) > 2 {
            fmt.Printf("  组名: %s, 内容: %s
", match[1], match[2])
        }
    }
    // 预期输出是 country: m((a|b).+)n, city: .+, street: (5|6). .+
    // 但实际上，对于 country 组，其内容 m((a|b).+)n 内部的括号会导致匹配提前结束或错误。
    // 例如，如果使用 (.*?)，它会在第一个 ) 处停止，而不是匹配到平衡的括号。
}

package main

import (
    "fmt"
    "regexp"
    "strings"
)

// NamedGroup 结构体用于存储解析出的命名捕获组信息
type NamedGroup struct {
    Name    string
    Content string // 包含括号的完整内容
}

// findNamedCapturingGroups 概念性函数，用于解析正则表达式字符串并提取命名捕获组
func findNamedCapturingGroups(regexString string) []NamedGroup {
    var groups []NamedGroup

    // 用于查找 (?P<name> 模式的正则表达式
    // 注意：这个正则只用于找到组名的起始，不负责匹配整个组的内容
    namePattern := regexp.MustCompile(`(?P<([a-zA-Z0-9_]+)>`)

    currentIndex := 0
    for currentIndex < len(regexString) {
        // 查找下一个命名捕获组的起始
        loc := namePattern.FindStringIndex(regexString[currentIndex:])
        if loc == nil {
            break // 没有找到更多命名捕获组
        }

        matchStart := currentIndex + loc[0]
        nameMatchEnd := currentIndex + loc[1]

        // 提取组名
        nameSubmatch := namePattern.FindStringSubmatch(regexString[currentIndex+loc[0]:])
        groupName := nameSubmatch[1]

        // 捕获组内容从组名结束后的第一个 '(' 开始
        contentStart := nameMatchEnd

        // 查找匹配的闭合括号 ')'
        depth := 0
        contentEnd := -1

        // 从内容起始位置开始遍历，处理括号平衡
        for i := contentStart; i < len(regexString); i++ {
            char := regexString[i]

            // 检查是否是转义字符
            if char == '\' && i+1 < len(regexString) {
                i++ // 跳过下一个字符，因为它是被转义的
                continue
            }

            if char == '(' {
                depth++
            } else if char == ')' {
                depth--
            }

            if depth == 0 {
                contentEnd = i // 找到了匹配的闭合括号
                break
            }
        }

        if contentEnd != -1 {
            // 提取完整的捕获组内容，包括外层括号
            groupContent := regexString[contentStart : contentEnd+1]
            groups = append(groups, NamedGroup{
                Name:    groupName,
                Content: groupContent,
            })
            currentIndex = contentEnd + 1 // 从当前组结束位置继续
        } else {
            // 如果没有找到匹配的闭合括号，说明格式有误或未完成，跳出
            fmt.Printf("警告: 无法为组 '%s' 找到匹配的闭合括号。
", groupName)
            break 
        }
    }

    return groups
}

func main() {
    regexString := `/(?P<country>m((a|b).+)n)/(?P<city>.+)/(?P<street>(5|6). .+)`

    parsedGroups := findNamedCapturingGroups(regexString)

    fmt.Println("
使用递归下降解析器概念匹配结果:")
    for _, group := range parsedGroups {
        fmt.Printf("  组名: %s, 内容: %s
", group.Name, group.Content)
    }
    // 预期输出:
    //   组名: country, 内容: m((a|b).+)n
    //   组名: city, 内容: .+
    //   组名: street, 内容: (5|6). .+
}