正则表达式-方法介绍 - 图1提示

以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档： https://pkg.go.dev/github.com/gogf/gf/v2/text/gregex

当函数名中有 All 的时候,它会继续查找非重叠的后续并返回 slice

当函数名中有 String 的时候,参数及返回值都是 string，否则为 []byte

IsMatch/IsMatchString

  • 说明： IsMatch() 方法可以测试字符串，判断是否匹配正则表达式的模式。如果发现一次匹配，该方法返回 true，否则返回 false。
  • 格式：
  1. IsMatch(pattern string, src []byte) bool
  2. IsMatchString(pattern string, src string) bool
  • Tip: regexp 已经在底层处理并缓存了 Regex 对象，以极大地提高执行效率，无需每次显式重新创建，下同。
  • 示例：
  1. func ExampleIsMatch() {
  2.       patternStr := `\d+`
  3.       g.Dump(gregex.IsMatch(patternStr, []byte("hello 2022! hello GoFrame!")))
  4.       g.Dump(gregex.IsMatch(patternStr, nil))
  5.       g.Dump(gregex.IsMatch(patternStr, []byte("hello GoFrame!")))
  7.       // Output:
  8.       // true
  9.       // false
  10.       // false
  11. }

Match/MatchString

  • 说明：用来匹配子字符串， Match 只返回第一个匹配的结果。区别于原生的正则方法， gregex 是对 FindSubmatch 进行封装，直接返回第一个包括子模式结果的 slice。
  • 格式
  1. Match(pattern string, src []byte) ([][]byte, error)
  2. MatchString(pattern string, src string) ([]string, error)
  • 示例：匹配 url 中的参数。
  1. func ExampleMatch() {
  2.       patternStr := `(\w+)=(\w+)`
  3.       matchStr := "https://goframe.org/pages/viewpage.action?pageId=1114219&searchId=8QC5D1D2E!"
  4.       // This method looks for the first match index
  5.       result, err := gregex.Match(patternStr, []byte(matchStr))
  6.       g.Dump(result)
  7.       g.Dump(err)
  9.       // Output:
  10.       // [
  11.       //     "pageId=1114219",
  12.       //     "pageId",
  13.       //     "1114219",
  14.       // ]
  15.       // <nil>
  16. }

MatchAll/MatchAllString

  • 说明：用来匹配子字符串， MatchAll 返回全部的结果。区别于原生的正则方法， gregex的 MatchAll 是对 FindAllSubmatch 方法进行封装，返回所有结果集的 slice，包括结果集中的子模式的结果。
  • 格式：
  1. MatchAllString(pattern string, src string) ([][]string, error)
  2. MatchAll(pattern string, src []byte) ([][][]byte, error)
  • 示例：下面这个例子是匹配 url 中的参数。
  1. func ExampleMatchAll() {
  2.       patternStr := `(\w+)=(\w+)`
  3.       matchStr := "https://goframe.org/pages/viewpage.action?pageId=1114219&searchId=8QC5D1D2E!"
  4.       result, err := gregex.MatchAll(patternStr, []byte(matchStr))
  5.       g.Dump(result)
  6.       g.Dump(err)
  8.       // Output:
  9.       //  [
  10.       //     [
  11.       //         "pageId=1114219",
  12.       //         "pageId",
  13.       //         "1114219",
  14.       //     ],
  15.       //     [
  16.       //         "searchId=8QC5D1D2E",
  17.       //         "searchId",
  18.       //         "8QC5D1D2E",
  19.       //     ],
  20.       // ]
  21.       // <nil>
  22. }
  24. func ExampleMatchAllString() {
  25.       patternStr := `(\w+)=(\w+)`
  26.       matchStr := "https://goframe.org/pages/viewpage.action?pageId=1114219&searchId=8QC5D1D2E!"
  27.       result, err := gregex.MatchAllString(patternStr, matchStr)
  28.       g.Dump(result)
  29.       g.Dump(err)
  31.       // Output:
  32.       // [
  33.       //     [
  34.       //         "pageId=1114219",
  35.       //         "pageId",
  36.       //         "1114219",
  37.       //     ],
  38.       //     [
  39.       //         "searchId=8QC5D1D2E",
  40.       //         "searchId",
  41.       //         "8QC5D1D2E",
  42.       //     ],
  43.       // ]
  44.       // <nil>
  45. }

Quote

  • 说明：将指定正则表达式中的特定符号进行转义。
  • 格式：
  1. Quote(s string) string
  • 示例：
  1. func ExampleQuote() {
  2.       result := gregex.Quote(`[1-9]\d+`)
  3.       g.Dump(result)
  5.       // Output:
  6.       // "\[1-9\]\\d\+"
  7. }

Replace/ReplaceString

  • 说明：用来替换所有匹配的字符串并返回一个源字符串的拷贝。
  • 格式:
  1. Replace(pattern string, replace, src []byte) ([]byte, error)
  2. ReplaceString(pattern, replace, src string) (string, error)
  • 示例
  1. func ExampleReplace() {
  2.       var (
  3.           patternStr  = `\d+`
  4.           str         = "hello GoFrame 2020!"
  5.           repStr      = "2021"
  6.           result, err = gregex.Replace(patternStr, []byte(repStr), []byte(str))
  7.       )
  8.       g.Dump(err)
  9.       g.Dump(result)
  11.       // Output:
  12.       // <nil>
  13.       // "hello GoFrame 2021!"
  14. }

ReplaceFunc/ReplaceStringFunc

  • 说明：用来替换所有匹配的字符串，返回一个源字符串的拷贝。与 Replace 方法的区别在于，该方法可以在闭包中对查询进行二次判断或处理，而非简单的替换。
  • 格式：
  1. ReplaceFunc(pattern string, src []byte, replaceFunc func(b []byte) []byte) ([]byte, error)
  2. ReplaceStringFunc(pattern string, src string, replaceFunc func(s string) string) (string, error)
  • 示例：
  1. func ExampleReplaceFunc() {
  2.       var (
  3.           patternStr = `(\d+)~(\d+)`
  4.           str        = "hello GoFrame 2018~2020!"
  5.       )
  6.       // In contrast to [ExampleReplace]
  7.       result, err := gregex.ReplaceFunc(patternStr, []byte(str), func(match []byte) []byte {
  8.           g.Dump(match)
  9.           return bytes.Replace(match, []byte("2020"), []byte("2023"), -1)
  10.       })
  11.       g.Dump(result)
  12.       g.Dump(err)
  14.       // ReplaceStringFunc
  15.       resultStr, _ := gregex.ReplaceStringFunc(patternStr, str, func(match string) string {
  16.           g.Dump(match)
  17.           return strings.Replace(match, "2020", "2023", -1)
  18.       })
  19.       g.Dump(resultStr)
  20.       g.Dump(err)
  22.          // Output:
  23.       // "2018~2020"
  24.       // "hello gf 2018~2023!" // ReplaceFunc result
  25.       // <nil>
  26.       // "2018~2020"
  27.       // "hello gf 2018-2023!" // ReplaceStringFunc result
  28.       // <nil>
  29. }

ReplaceFuncMatch/ReplaceStringFuncMatch

ReplaceFuncMatch 返回 src 的拷贝，其中 regexp 的所有匹配都被应用于匹配字节切片的函数的返回值替换。 返回的替换直接替换。

  • 说明：用来替换所有匹配的字符串，返回一个源字符串的拷贝。该方法的强大之处在于可以在闭包中对查询进行二次判断或处理，且 MatchString 函数包含了所有子模式的查询结果，而非简单的替换。
  • 格式：
  1. ReplaceFuncMatch(pattern string, src []byte, replaceFunc func(match [][]byte) []byte) ([]byte, error)
  2. ReplaceStringFuncMatch(pattern string, src string, replaceFunc func(match []string) string) (string, error)
  • 示例：
  1. func ExampleReplaceStringFuncMatch() {
  2.        var (
  3.           patternStr = `([A-Z])\w+`
  4.           str        = "hello Golang 2018~2021!"
  5.       )
  6.       // In contrast to [ExampleReplaceFunc]
  7.       // the result contains the `pattern' of all subpatterns that use the matching function
  8.       result, err := gregex.ReplaceFuncMatch(patternStr, []byte(str), func(match [][]byte) []byte {
  9.           g.Dump(match)
  10.           return []byte("GoFrame")
  11.       })
  12.       g.Dump(result)
  13.       g.Dump(err)
  15.       // ReplaceStringFuncMatch
  16.       resultStr, err := gregex.ReplaceStringFuncMatch(patternStr, str, func(match []string) string {
  17.           g.Dump(match)
  18.           match[0] = "Gf"
  19.           return match[0]
  20.       })
  21.       g.Dump(resultStr)
  22.       g.Dump(err)
  24.       // Output:
  25.       // [
  26.       //     "Golang",
  27.       //     "G",
  28.       // ]
  29.       // "hello GoFrame 2018~2021!" // ReplaceFuncMatch result
  30.       // <nil>
  31.       // [
  32.       //     "Golang",
  33.       //     "G",
  34.       // ]
  35.       // "hello Gf 2018~2021!" // ReplaceStringFuncMatch result
  36.       // <nil>
  37. }

Split

  • 说明：将文本内容由指定的正则表达式进行切割。不包含元字符，相当于 strings.SplitN。
  • 格式：
  1. Split(pattern string, src string) []string
  • 示例：
  1. func ExampleSplit() {
  2.       patternStr := `\d+`
  3.       str := "hello2020GoFrame"
  4.       result := gregex.Split(patternStr, str)
  5.       g.Dump(result)
  7.       // Output:
  8.       // [
  9.       //     "hello",
  10.       //     "GoFrame",
  11.       // ]
  12. }

Validate

  • 说明：基于原生方法 compile 封装，检查给定的正则表达式是否有效
  • 格式：
  1. Validate(pattern string) error
  • 示例：
  1. func ExampleValidate() {
  2.       // Valid match statement
  3.       g.Dump(gregex.Validate(`\d+`))
  4.       // Mismatched statement
  5.       g.Dump(gregex.Validate(`[a-9]\d+`))
  7.       // Output:
  8.       // <nil>
  9.       // {
  10.       //     Code: "invalid character class range",
  11.       //     Expr: "a-9",
  12.       // }
  13. }