regex - 使用函数替换正则表达式子匹配

Question

假设我有像

这样的字符串

input := `bla bla b:foo="hop" blablabla b:bar="hu?"`

我想使用函数替换 b:foo="hop" 或 b:bar="hu?" 中引号之间的部分。

很容易构建一个正则表达式来获取匹配和子匹配，例如

r := regexp.MustCompile(`\bb:\w+="([^"]+)"`)

然后调用 ReplaceAllStringFunc 但问题是回调接收整个匹配而不是子匹配:

fmt.Println(r.ReplaceAllStringFunc(input, func(m string) string {
    // m is the whole match here. Damn.
}))

如何替换子匹配？

目前，我没有找到比使用正则表达式在回调中分解自己的 m 并在处理完子匹配后重建字符串更好的解决方案。

如果它们在 Go 中可用，我会使用另一种方法并积极看待它们，但事实并非如此(无论如何它们不应该是必需的)。

我可以在这里做什么？

---

编辑:这是我想简化的当前解决方案:

func complexFunc(s string) string {
   return "dbvalue("+s+")" // this could be more complex
}
func main() {
        input := `bla bla b:foo="hop" blablabla b:bar="hu?"`
        r := regexp.MustCompile(`(\bb:\w+=")([^"]+)`)
        fmt.Println(r.ReplaceAllStringFunc(input, func(m string) string {
                parts := r.FindStringSubmatch(m)
                return parts[1] + complexFunc(parts[2])
        }))
}

(playground link)

困扰我的是我必须应用正则表达式两次。这听起来不对。

Answer 1

我不喜欢下面的代码，但它似乎做了你希望它做的事情:

package main

import (
        "fmt"
        "regexp"
)

func main() {
        input := `bla bla b:foo="hop" blablabla b:bar="hu?"`
        r := regexp.MustCompile(`\bb:\w+="([^"]+)"`)
        r2 := regexp.MustCompile(`"([^"]+)"`)
        fmt.Println(r.ReplaceAllStringFunc(input, func(m string) string {
                return r2.ReplaceAllString(m, `"${2}whatever"`)
        }))
}

Playground

---

输出

bla bla b:foo="whatever" blablabla b:bar="whatever"

---

编辑:采取 II。

---

package main

import (
        "fmt"
        "regexp"
)

func computedFrom(s string) string {
        return fmt.Sprintf("computedFrom(%s)", s)
}

func main() {
        input := `bla bla b:foo="hop" blablabla b:bar="hu?"`
        r := regexp.MustCompile(`\bb:\w+="([^"]+)"`)
        r2 := regexp.MustCompile(`"([^"]+)"`)
        fmt.Println(r.ReplaceAllStringFunc(input, func(m string) string {
                match := string(r2.Find([]byte(m)))
                return r2.ReplaceAllString(m, computedFrom(match))
        }))
}

Playground

---

输出:

bla bla b:foo=computedFrom("hop") blablabla b:bar=computedFrom("hu?")