87

我正在将一个库从 Ruby 移植到 Go,并且刚刚发现 Ruby 中的正则表达式与 Go (google RE2) 不兼容。我注意到 Ruby 和 Java(加上其他语言使用 PCRE 正则表达式(perl 兼容,支持捕获组)),所以我需要重新编写我的表达式,以便它们在 Go 中编译好。

例如,我有以下正则表达式:

`(?<Year>\d{4})-(?<Month>\d{2})-(?<Day>\d{2})`

这应该接受输入,例如:

2001-01-20

捕获组允许将年、月和日捕获到变量中。要得到每个组的值,很容易;您只需使用组名索引返回的匹配数据,然后返回值。因此,例如要获取年份,类似于以下伪代码:

m=expression.Match("2001-01-20")
year = m["Year"]

这是我在表达中经常使用的一种模式,所以我有很多重写工作要做。

那么,有没有办法在 Go 正则表达式中获得这种功能?我应该如何重写这些表达式?

4

8 回答 8

109

我应该如何重写这些表达式?

添加一些 Ps ,定义如下:

(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})

使用 .交叉引用捕获组名称re.SubexpNames()

并使用如下

package main

import (
    "fmt"
    "regexp"
)

func main() {
    r := regexp.MustCompile(`(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})`)
    fmt.Printf("%#v\n", r.FindStringSubmatch(`2015-05-27`))
    fmt.Printf("%#v\n", r.SubexpNames())
}
于 2015-05-27T13:27:11.090 回答
32

我创建了一个用于处理 url 表达式的函数,但它也适合您的需求。您可以检查代码段,但它的工作原理如下:

/**
 * Parses url with the given regular expression and returns the 
 * group values defined in the expression.
 *
 */
func getParams(regEx, url string) (paramsMap map[string]string) {

    var compRegEx = regexp.MustCompile(regEx)
    match := compRegEx.FindStringSubmatch(url)

    paramsMap = make(map[string]string)
    for i, name := range compRegEx.SubexpNames() {
        if i > 0 && i <= len(match) {
            paramsMap[name] = match[i]
        }
    }
    return paramsMap
}

您可以像这样使用此功能:

params := getParams(`(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})`, `2015-05-27`)
fmt.Println(params)

输出将是:

map[Year:2015 Month:05 Day:27]
于 2016-09-22T09:28:06.327 回答
19

要提高 RAM 和 CPU 使用率,而无需在循环内调用匿名函数,也无需使用“append”函数在循环内复制内存中的数组,请参见下一个示例:

您可以使用多行文本存储多个子组,无需在字符串中附加“+”,也无需在 for 循环中使用 for 循环(如此处发布的其他示例)。

txt := `2001-01-20
2009-03-22
2018-02-25
2018-06-07`

regex := *regexp.MustCompile(`(?s)(\d{4})-(\d{2})-(\d{2})`)
res := regex.FindAllStringSubmatch(txt, -1)
for i := range res {
    //like Java: match.group(1), match.gropu(2), etc
    fmt.Printf("year: %s, month: %s, day: %s\n", res[i][1], res[i][2], res[i][3])
}

输出:

year: 2001, month: 01, day: 20
year: 2009, month: 03, day: 22
year: 2018, month: 02, day: 25
year: 2018, month: 06, day: 07

注意: res[i][0] =~ match.group(0) Java

如果要存储此信息,请使用结构类型:

type date struct {
  y,m,d int
}
...
func main() {
   ...
   dates := make([]date, 0, len(res))
   for ... {
      dates[index] = date{y: res[index][1], m: res[index][2], d: res[index][3]}
   }
}

最好使用匿名组(性能提升)

使用在 Github 上发布的“ReplaceAllGroupFunc”是个坏主意,因为:

  1. 正在使用循环内循环
  2. 在循环内使用匿名函数调用
  3. 有很多代码
  4. 在循环内使用“追加”函数,这很糟糕。每次调用“附加”函数时,都会将数组复制到新的内存位置
于 2018-06-07T12:02:20.963 回答
10

从 GO 1.15 开始,您可以使用Regexp.SubexpIndex. 您可以在https://golang.org/doc/go1.15#regexp查看发行说明。

根据您的示例,您将拥有以下内容:

re := regexp.MustCompile(`(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})`)
matches := re.FindStringSubmatch("Some random date: 2001-01-20")
yearIndex := re.SubexpIndex("Year")
fmt.Println(matches[yearIndex])

您可以在https://play.golang.org/p/ImJ7i_ZQ3Hu检查并执行此示例。

于 2021-02-04T20:12:39.340 回答
7

根据@VasileM 答案确定组名的简单方法。

免责声明:这与内存/cpu/时间优化无关

package main

import (
    "fmt"
    "regexp"
)

func main() {
    r := regexp.MustCompile(`^(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})$`)

    res := r.FindStringSubmatch(`2015-05-27`)
    names := r.SubexpNames()
    for i, _ := range res {
        if i != 0 {
            fmt.Println(names[i], res[i])
        }
    }
}

https://play.golang.org/p/Y9cIVhMa2pU

于 2019-06-22T13:58:29.250 回答
2

如果在捕获组时需要基于函数进行替换,可以使用:

import "regexp"

func ReplaceAllGroupFunc(re *regexp.Regexp, str string, repl func([]string) string) string {
    result := ""
    lastIndex := 0

    for _, v := range re.FindAllSubmatchIndex([]byte(str), -1) {
        groups := []string{}
        for i := 0; i < len(v); i += 2 {
            groups = append(groups, str[v[i]:v[i+1]])
        }

        result += str[lastIndex:v[0]] + repl(groups)
        lastIndex = v[1]
    }

    return result + str[lastIndex:]
}

例子:

str := "abc foo:bar def baz:qux ghi"
re := regexp.MustCompile("([a-z]+):([a-z]+)")
result := ReplaceAllGroupFunc(re, str, func(groups []string) string {
    return groups[1] + "." + groups[2]
})
fmt.Printf("'%s'\n", result)

https://gist.github.com/elliotchance/d419395aa776d632d897

于 2016-02-06T22:21:49.097 回答
1

您可以使用regroup该库 https://github.com/oriser/regroup

例子:

package main

import (
    "fmt"
    "github.com/oriser/regroup"
)

func main() {
    r := regroup.MustCompile(`(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})`)
    mathces, err := r.Groups("2015-05-27")
    if err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", mathces)
}

将打印:map[Year:2015 Month:05 Day:27]

或者,您可以像这样使用它:

package main

import (
    "fmt"
    "github.com/oriser/regroup"
)

type Date struct {
    Year   int `regroup:"Year"`
    Month  int `regroup:"Month"`
    Day    int `regroup:"Day"`
}

func main() {
    date := &Date{}
    r := regroup.MustCompile(`(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})`)
    if err := r.MatchToTarget("2015-05-27", date); err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", date)
}

将打印:&{Year:2015 Month:5 Day:27}

于 2021-01-12T14:46:28.340 回答
-1

用于获取正则表达式参数和零指针检查的函数。如果发生错误,则返回 map[]

// GetRxParams - Get all regexp params from string with provided regular expression
func GetRxParams(rx *regexp.Regexp, str string) (pm map[string]string) {
    if !rx.MatchString(str) {
        return nil
    }
    p := rx.FindStringSubmatch(str)
    n := rx.SubexpNames()
    pm = map[string]string{}
    for i := range n {
        if i == 0 {
            continue
        }

        if n[i] != "" && p[i] != "" {
            pm[n[i]] = p[i]
        }
    }
    return
}
于 2021-04-15T18:55:40.847 回答