以下常用方法列表,文档更新可能滞后于代码新特性,更多的方法及示例请参考代码文档: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!")))
    6. // Output:
    7. // true
    8. // false
    9. // false
    10. }

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)
    8. // Output:
    9. // [
    10. // "pageId=1114219",
    11. // "pageId",
    12. // "1114219",
    13. // ]
    14. // <nil>
    15. }

MatchAll/MatchAllString

  • 说明:用来匹配子字符串,MatchAll返回全部的结果。区别于原生的正则方法,gregexMatchAll 是对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)
    7. // Output:
    8. // [
    9. // [
    10. // "pageId=1114219",
    11. // "pageId",
    12. // "1114219",
    13. // ],
    14. // [
    15. // "searchId=8QC5D1D2E",
    16. // "searchId",
    17. // "8QC5D1D2E",
    18. // ],
    19. // ]
    20. // <nil>
    21. }
    22. func ExampleMatchAllString() {
    23. patternStr := `(\w+)=(\w+)`
    24. matchStr := "https://goframe.org/pages/viewpage.action?pageId=1114219&searchId=8QC5D1D2E!"
    25. result, err := gregex.MatchAllString(patternStr, matchStr)
    26. g.Dump(result)
    27. g.Dump(err)
    28. // Output:
    29. // [
    30. // [
    31. // "pageId=1114219",
    32. // "pageId",
    33. // "1114219",
    34. // ],
    35. // [
    36. // "searchId=8QC5D1D2E",
    37. // "searchId",
    38. // "8QC5D1D2E",
    39. // ],
    40. // ]
    41. // <nil>
    42. }

Quote

  • 说明:将指定正则表达式中的特定符号进行转义。
  • 格式:

    1. Quote(s string) string
  • 示例:

    1. func ExampleQuote() {
    2. result := gregex.Quote(`[1-9]\d+`)
    3. g.Dump(result)
    4. // Output:
    5. // "\[1-9\]\\d\+"
    6. }

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)
    10. // Output:
    11. // <nil>
    12. // "hello GoFrame 2021!"
    13. }

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)
    13. // ReplaceStringFunc
    14. resultStr, _ := gregex.ReplaceStringFunc(patternStr, str, func(match string) string {
    15. g.Dump(match)
    16. return strings.Replace(match, "2020", "2023", -1)
    17. })
    18. g.Dump(resultStr)
    19. g.Dump(err)
    20. // Output:
    21. // "2018~2020"
    22. // "hello gf 2018~2023!" // ReplaceFunc result
    23. // <nil>
    24. // "2018~2020"
    25. // "hello gf 2018-2023!" // ReplaceStringFunc result
    26. // <nil>
    27. }

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)
    14. // ReplaceStringFuncMatch
    15. resultStr, err := gregex.ReplaceStringFuncMatch(patternStr, str, func(match []string) string {
    16. g.Dump(match)
    17. match[0] = "Gf"
    18. return match[0]
    19. })
    20. g.Dump(resultStr)
    21. g.Dump(err)
    22. // Output:
    23. // [
    24. // "Golang",
    25. // "G",
    26. // ]
    27. // "hello GoFrame 2018~2021!" // ReplaceFuncMatch result
    28. // <nil>
    29. // [
    30. // "Golang",
    31. // "G",
    32. // ]
    33. // "hello Gf 2018~2021!" // ReplaceStringFuncMatch result
    34. // <nil>
    35. }

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)
    6. // Output:
    7. // [
    8. // "hello",
    9. // "GoFrame",
    10. // ]
    11. }

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+`))
    6. // Output:
    7. // <nil>
    8. // {
    9. // Code: "invalid character class range",
    10. // Expr: "a-9",
    11. // }
    12. }