判断在 b（s、r）中能否找到 pattern 所匹配的字符串

func QuoteMeta(s string) string

  • QuoteMeta返回将s中所有正则表达式元字符都进行转义后字符串。

func Match(pattern string, b []byte) (matched bool, err error)
func MatchString(pattern string, s string) (matched bool, err error)
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)

  1. func main() {
  2.     str :="<a>hello,golang</a>"
  3.     reg := "<a>(.*?)</a>"
  4.     res,_:=regexp.MatchString(reg,str)
  5.     fmt.Println(res)//true
  6.     fmt.Println(regexp.QuoteMeta(reg))//<a>\(\.\*\?\)</a>
  7. }

type Regexp

Regexp代表一个编译好的正则表达式。Regexp可以被多线程安全地同时使用。

编译

func Compile(expr string) (*Regexp, error)

  • 将正则表达式编译成一个正则对象（使用 PERL 语法）。
  • 该正则对象会采用“leftmost-first”模式。选择第一个匹配结果。
  • 如果正则表达式语法错误，则返回错误信息。

func CompilePOSIX(expr string) (*Regexp, error)

  • 将正则表达式编译成一个正则对象（正则语法限制在 POSIX ERE 范围内）。
  • 该正则对象会采用“leftmost-longest”模式。选择最长的匹配结果。
  • POSIX 语法不支持 Perl 的语法格式：\d、\D、\s、\S、\w、\W
  • 如果正则表达式语法错误，则返回错误信息。

func MustCompile(str string) *Regexp

  • 同func Compile(expr string) (*Regexp, error)，正则表达式语法错误引发panic

func MustCompilePOSIX(str string) *Regexp

  • 同func CompilePOSIX(expr string) (*Regexp, error)，正则表达式语法错误引发panic

    1. func main() {
    2.   b := []byte("abcdef")
    3.   pat := `abc|abcdef`
    4.   reg1 := regexp.MustCompile(pat)      // 第一匹配
    5.   reg2 := regexp.MustCompilePOSIX(pat) // 最长匹配
    6.   fmt.Printf("%s\n", reg1.Find(b))     // abc
    7.   fmt.Printf("%s\n", reg2.Find(b))     // abc1def
    9.   b = []byte("abc1def1")
    10.   pat = `(abc|abc1def)1`
    11.   reg1 = regexp.MustCompile(pat)      // 第一匹配
    12.   reg2 = regexp.MustCompilePOSIX(pat) // 最长匹配
    13.   fmt.Printf("%s\n", reg1.Find(b))    // abc1
    14.   fmt.Printf("%s\n", reg2.Find(b))    // abc1def1
    15. }

    func (re *Regexp) String() string

  • String返回用于编译成正则表达式的字符串。

func (re *Regexp) Longest()

  • Longest让正则表达式在之后的搜索中都采用”leftmost-longest”模式

func (re *Regexp) NumSubexp() int

  • 返回该正则表达式中捕获分组的数量

func (re *Regexp) SubexpNames() []string

  • 返回正则表达式中分组的名字

  • 第 0 个元素表示整个正则表达式的名字，永远是空字符串。

    1. func main() {
    2.   regStr := `(?P<name1>/d+)(?P<name2>/s+)`
    3.   reg,err :=regexp.Compile(regStr)
    4.   if err!=nil{
    5.       fmt.Println(err)
    6.       return
    7.   }
    8.   fmt.Println(reg.NumSubexp())//2
    9.   fmt.Println(reg.SubexpNames(),len(reg.SubexpNames()))//[ name1 name2] 3
    10. }

    func (re *Regexp) LiteralPrefix() (prefix string, complete bool)

  • 返回正则表达式必须匹配到的字面前缀（不包含可变部分）。

  • 如果整个正则表达式都是字面值，则 complete 返回 true。

    判断在 b（s、r）中能否找到匹配的字符串

    func (re Regexp) Match(b []byte) bool
    func (re     Regexp) MatchString(s string) bool
    func (re *Regexp) MatchReader(r io.RuneReader) bool

    查找

    func (re *Regexp) Find(b []byte) []byte

  • 返回第一个匹配到的结果

func (re *Regexp) FindSubmatch(b []byte) [][]byte

  • 返回第一个匹配到的结果及其分组内容（结果以 b 的切片形式返回）。
  • 返回值中的第 0 个元素是整个正则表达式的匹配结果，后续元素是各个分组的

  • 匹配内容，分组顺序按照“(”的出现次序而定。

    1. func main() {
    2.   pat := `(((abc.)def.)ghi)`
    3.   reg := regexp.MustCompile(pat)
    5.   src := []byte(`abc-def-ghi abc+def+ghi`)
    7.   // 查找第一个匹配结果
    8.   fmt.Printf("%s\n", reg.Find(src)) // abc-def-ghi
    10.   fmt.Println()
    12.   // 查找第一个匹配结果及其分组字符串
    13.   first := reg.FindSubmatch(src)
    14.   for i := 0; i < len(first); i++ {
    15.       fmt.Printf("%d: %s\n", i, first[i])
    16.   }
    17.   // 0: abc-def-ghi
    18.   // 1: abc-def-ghi
    19.   // 2: abc-def-
    20.   // 3: abc-
    21. }

func (re *Regexp) FindIndex(b []byte) (loc []int)

  • 功能同 Find，只不过返回的是匹配结果的首尾下标，通过这些下标可以生成切片。
  • loc[0] 是结果切片的起始下标，loc[1] 是结果切片的结束下标。

func (re *Regexp) FindSubmatchIndex(b []byte) []int

  • 功能同 FindSubmatch，只不过返回的是匹配结果的首尾下标，通过这些下标可以生成切片。
  • loc[0] 是结果切片的起始下标，loc[1] 是结果切片的结束下标。
  • loc[2] 是分组1切片的起始下标，loc[3] 是分组1切片的结束下标。

  • loc[4] 是分组2切片的起始下标，loc[5] 是分组2切片的结束下标。

    1. func main() {
    2.   pat := `(((abc.)def.)ghi)`
    3.   reg := regexp.MustCompile(pat)
    5.   src := []byte(`abc-def-ghi abc+def+ghi`)
    7.   // 查找第一个匹配结果
    8.   matched := reg.FindIndex(src)
    9.   fmt.Printf("%v\n", matched) // [0 11]
    10.   m := matched[0]
    11.   n := matched[1]
    12.   fmt.Printf("%s\n\n", src[m:n]) // abc-def-ghi
    14.   // 查找第一个匹配结果及其分组字符串
    15.   matched = reg.FindSubmatchIndex(src)
    16.   fmt.Printf("%v\n", matched) // [0 11 0 11 0 8 0 4]
    17.   for i := 0; i < len(matched)/2; i++ {
    18.       m := matched[i*2]
    19.       n := matched[i*2+1]
    20.       fmt.Printf("%s\n", src[m:n])
    21.   }
    22.   // abc-def-ghi
    23.   // abc-def-ghi
    24.   // abc-def-
    25.   // abc-
    26. }

    func (re *Regexp) FindAll(b []byte, n int) [][]byte

  • Find返回re在b中的所有不重叠的匹配结果的[][]byte切片。如果没有匹配到，会返回nil。

func (re *Regexp) FindAllIndex(b []byte, n int) [][]int

  • Find返回re在b中的所有不重叠的匹配结果的起止位置的切片。如果没有匹配到，会返回nil。

func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte

  • Find返回re在b中的所有不重叠的匹配结果及其对应的（可能有的）分组匹配的结果的[][][]byte切片。如果没有匹配到，会返回nil。

func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int

  • Find返回re在b中的所有不重叠的匹配结果及其对应的（可能有的）分组匹配的结果的起止位置的切片（第一层表示第几个匹配结果，完整匹配和分组匹配的起止位置对在第二层）。如果没有匹配到，会返回nil。

  • n 是查找次数，负数表示不限次数。

    1. func main() {
    2.   pat := `(((abc.)def.)ghi)`
    3.   reg := regexp.MustCompile(pat)
    5.   s := []byte(`abc-def-ghi abc+def+ghi`)
    7.   // 查找所有匹配结果
    8.   for _, one := range reg.FindAll(s, -1) {
    9.       fmt.Printf("%s\n", one)
    10.   }
    11.   // abc-def-ghi
    12.   // abc+def+ghi
    14.   // 查找所有匹配结果及其分组字符串
    15.   all := reg.FindAllSubmatch(s, -1)
    16.   for i := 0; i < len(all); i++ {
    17.       fmt.Println()
    18.       one := all[i]
    19.       for i := 0; i < len(one); i++ {
    20.           fmt.Printf("%d: %s\n", i, one[i])
    21.       }
    22.   }
    23.   // 0: abc-def-ghi
    24.   // 1: abc-def-ghi
    25.   // 2: abc-def-
    26.   // 3: abc-
    28.   // 0: abc+def+ghi
    29.   // 1: abc+def+ghi
    30.   // 2: abc+def+
    31.   // 3: abc+
    32. }

// 功能同上，只不过在字符串中查找
func (re Regexp) FindString(s string) string
func (re Regexp) FindStringSubmatch(s string) []string
func (re Regexp) FindStringIndex(s string) (loc []int)
func (re Regexp) FindStringSubmatchIndex(s string) []int
func (re Regexp) FindAllString(s string, n int) []string
func (re Regexp) FindAllStringSubmatch(s string, n int) [][]string
func (re Regexp) FindAllStringIndex(s string, n int) [][]int
func (re Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int

// 功能同上，只不过在 io.RuneReader 中查找。
func (re Regexp) FindReaderIndex(r io.RuneReader) (loc []int)
func (re Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int

替换（不会修改参数，结果是参数的副本）

func (re *Regexp) ReplaceAll(src, repl []byte) []byte

  • 将 src 中匹配的内容替换为 repl（repl 中可以使用 $1 $name 等分组引用符）。

func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte

  • 将 src 中匹配的内容经过 repl 函数处理后替换回去。

func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte

  • 将 src 中匹配的内容替换为 repl（repl 为字面值，不解析其中的 $1 $name 等）。

// 功能同上，只不过在字符串中查找。
func (re Regexp) ReplaceAllString(src, repl string) string
func (re Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string
func (re Regexp) ReplaceAllLiteralString(src, repl string) string
func (re Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte

  • Expand 要配合 FindSubmatchIndex 一起使用。FindSubmatchIndex 在 src 中进行
  • 查找，将结果存入 match 中。这样就可以通过 src 和 match 得到匹配的字符串。
  • template 是替换内容，可以使用分组引用符 $1、$2、$name 等。Expane 将其中的分

组引用符替换为前面匹配到的字符串。然后追加到 dst 的尾部（dst 可以为空）。

  • 说白了 Expand 就是一次替换过程，只不过需要 FindSubmatchIndex 的配合。

func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte

  • 同func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte,参数不一样

    切割

    func (re *Regexp) Split(s string, n int) []string

  • 以 s 中的匹配结果作为分割符将 s 分割成字符串列表。

  • n 是分割次数，负数表示不限次数。