以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：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. }