匹配包含平衡括号内容的 Go 正则表达式

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《匹配包含平衡括号内容的 Go 正则表达式》，文章讲解的知识点主要包括，如果你对Golang方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

所以我的用例如下：我正在解析一个 sql 查询，试图获取发送到该函数的函数名称和相应参数。这要求我的正则表达式能够找到名称、左括号、内容和右括号。不幸的是，在测试时发现它有时太贪婪，会抓住额外的括号，有时会错过结束括号。

这是我的演示测试代码：

func getregex(name string) string {
    return fmt.sprintf("\\$__%s\\b(?:\\((.*?\\)?)\\))?", name)
}

func main() {
    var rawsql = "(select min(time) from table where $__timefilter(time))"
    rgx, err := regexp.compile(getregex("timefilter"))
    if err != nil {
        fmt.println(err)
    }
    var match = rgx.findallstringsubmatch(rawsql, -1)

    fmt.println(match)
}

使用实例 https://go.dev/play/p/4fpzblia7ks

我正在测试的4个案例如下：

(select min(time) from table where $__timeFilter(time) ) OK
(select min(time) from table where $__timeFilter(time)) NOK
select * from foo where $__timeFilter(cast(sth as timestamp)) OK
select * from foo where $__timeFilter(cast(sth as timestamp) ) NOK

这是一个实时正则表达式版本 https://regexr.com/700oh

我来自 javascript 世界，所以从未使用过递归正则表达式，看起来可能就是这种情况？

正确答案

您的正则表达式似乎有两个主要问题，其中一个比另一个更容易处理：

1. 正则表达式本质上不擅长处理递归匹配，例如对左括号和右括号进行分组，因为它们没有记忆。就您的情况而言，我认为您已尝试通过将自己限制在一些特定情况来解决此问题，但正则表达式的贪婪本质在这里对您不利。
2. 您不匹配右括号前可能有空格的情况。

这两个问题共同导致您的正则表达式在这两种情况下失败，但也会导致您的第一个情况匹配。

要解决此问题，您必须在将字符串发送到正则表达式之前对其进行一些预处理：

if strings.hasprefix(rawsql, "(") {
    rawsql = rawsql[1:len(rawsql) - 1]
}

这将去掉所有外括号，如果没有内存或额外的子句，正则表达式将无法忽略这些括号。

接下来，您需要修改正则表达式以处理内部函数调用和 $__timefilter 调用之间可能存在空格的情况：

func getregex(name string) string {
    return fmt.sprintf("\\$__%s\\b(\\((.*?\\)?)\\s*\\))?", name)
}

完成此操作后，您的正则表达式应该可以工作。您可以在 this playground link 上找到完整的示例。

我选择伍迪的答案作为正确的答案，尽管我最终不得不走另一条路。附加的测试用例不包括某些场景，而且事实证明我还必须能够提取括号内的参数。所以这是我的最终解决方案，我手动解析文本，找到包围括号并提取它们之间的任何内容：

// getMacroMatches extracts macro strings with their respective arguments from the sql input given
// It manually parses the string to find the closing parenthesis of the macro (because regex has no memory)
func getMacroMatches(input string, name string) ([][]string, error) {
    macroName := fmt.Sprintf("\\$__%s\\b", name)
    matchedMacros := [][]string{}
    rgx, err := regexp.Compile(macroName)

    if err != nil {
        return nil, err
    }

    // get all matching macro instances
    matched := rgx.FindAllStringIndex(input, -1)

    if matched == nil {
        return nil, nil
    }

    for matchedIndex := 0; matchedIndex < len(matched); matchedIndex++ {
        var macroEnd = 0
        var argStart = 0
        macroStart := matched[matchedIndex][0]
        inputCopy := input[macroStart:]
        cache := make([]rune, 0)

        // find the opening and closing arguments brackets
        for idx, r := range inputCopy {
            if len(cache) == 0 && macroEnd > 0 {
                break
            }
            switch r {
            case '(':
                cache = append(cache, r)
                if argStart == 0 {
                    argStart = idx + 1
                }
            case ')':
                l := len(cache)
                if l == 0 {
                    break
                }
                cache = cache[:l-1]
                macroEnd = idx + 1
            default:
                continue
            }
        }

        // macroEnd equals to 0 means there are no parentheses, so just set it
        // to the end of the regex match
        if macroEnd == 0 {
            macroEnd = matched[matchedIndex][1] - macroStart
        }
        macroString := inputCopy[0:macroEnd]
        macroMatch := []string{macroString}

        args := ""
        // if opening parenthesis was found, extract contents as arguments
        if argStart > 0 {
            args = inputCopy[argStart : macroEnd-1]
        }
        macroMatch = append(macroMatch, args)
        matchedMacros = append(matchedMacros, macroMatch)
    }
    return matchedMacros, nil
}

前往演示链接：https://go.dev/play/p/-odWKMBLCBv

终于介绍完啦！小伙伴们，这篇关于《匹配包含平衡括号内容的 Go 正则表达式》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！