3.5 GO 正则表达式

Go内置了（regexp包）对正则表达式的支持，这里是一般的正则表达式常规用法的例子。

示例：

  1.     package main
  3. import (
  4.     "bytes"
  5.     "fmt"
  6.     "regexp"
  7. )
  9. func main() {
  10.     //是否匹配字符串
  11.     // .匹配任意一个字符 ，*匹配零个或多个 ，优先匹配更多(贪婪)
  12.     match, _ := regexp.MatchString("H(.*)d!", "Hello World!")
  13.     fmt.Println(match) //true
  14.     //或
  15.     match, _ = regexp.Match("H(.*)d!", []byte("Hello World!"))
  16.     fmt.Println(match) //true
  17.     //或通过`Compile`来使用一个优化过的正则对象
  18.     r, _ := regexp.Compile("H(.*)d!")
  19.     fmt.Println(r.MatchString("Hello World!")) //true
  21.     // 这个方法返回匹配的子串
  22.     fmt.Println(r.FindString("Hello World! world")) //Hello World!
  23.     //同上
  24.     fmt.Println(string(r.Find([]byte("Hello World!")))) //Hello World!
  26.     // 这个方法查找第一次匹配的索引
  27.     // 的起始索引和结束索引，而不是匹配的字符串
  28.     fmt.Println(r.FindStringIndex("Hello World! world")) //[0 12]
  30.     // 这个方法返回全局匹配的字符串和局部匹配的字符，匹配最大的子字符串一次。
  31.     // 它和r.FindAllStringSubmatch("Hello World! world"，1) 等价。  比如
  32.     // 这里会返回匹配`H(.*)d!`的字符串
  33.     // 和匹配`(.*)`的字符串
  34.     fmt.Println(r.FindStringSubmatch("Hello World! world")) //[Hello World! ello Worl]
  36.     // 和上面的方法一样，不同的是返回全局匹配和局部匹配的
  37.     // 起始索引和结束索引
  38.     fmt.Println(r.FindStringSubmatchIndex("Hello World! world")) //[0 12 1 10]
  39.     // 这个方法返回所有正则匹配的字符，不仅仅是第一个
  40.     fmt.Println(r.FindAllString("Hello World! Held! world", -1)) //[Hello World! Held!]
  42.     // 这个方法返回所有全局匹配和局部匹配的字符串起始索引,只匹配最大的串
  43.     // 和结束索引
  44.     fmt.Println(r.FindAllStringSubmatchIndex("Hello World! world", -1))       //[[0 12 1 10]]
  45.     fmt.Println(r.FindAllStringSubmatchIndex("Hello World! Held! world", -1)) //[[0 18 1 16]]
  47.     // 为这个方法提供一个正整数参数来限制匹配数量
  48.     res, _ := regexp.Compile("H([a-z]+)d!")
  49.     fmt.Println(res.FindAllString("Hello World! Held! Hellowrld! world", 2)) //[Held! Hellowrld!]
  51.     fmt.Println(r.FindAllString("Hello World! Held! world", 2)) //[Hello World! Held!]
  52.     //注意上面两个不同，第二参数是一最大子串为单位计算。
  54.     // regexp包也可以用来将字符串的一部分替换为其他的值
  55.     fmt.Println(r.ReplaceAllString("Hello World! Held! world", "html")) //html world
  57.     // `Func`变量可以让你将所有匹配的字符串都经过该函数处理
  58.     // 转变为所需要的值
  59.     in := []byte("Hello World! Held! world")
  60.     out := r.ReplaceAllFunc(in, bytes.ToUpper)
  61.     fmt.Println(string(out))
  63.     // 在 b 中查找 reg 中编译好的正则表达式，并返回第一个匹配的位置
  64.     // {起始位置, 结束位置}
  65.     b := bytes.NewReader([]byte("Hello World!"))
  66.     reg := regexp.MustCompile(`\w+`)
  67.     fmt.Println(reg.FindReaderIndex(b)) //[0 5]
  69.     // 在 字符串 中查找 r 中编译好的正则表达式，并返回所有匹配的位置
  70.     // {{起始位置, 结束位置}, {起始位置, 结束位置}, ...}
  71.     // 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
  73.     fmt.Println(r.FindAllIndex([]byte("Hello World!"), -1)) //[[0 12]]
  74.     //同上
  75.     fmt.Println(r.FindAllStringIndex("Hello World!", -1)) //[[0 12]]
  77.     // 在 s 中查找 re 中编译好的正则表达式，并返回所有匹配的内容
  78.     // 同时返回子表达式匹配的内容
  79.     // {
  80.     //     {完整匹配项, 子匹配项, 子匹配项, ...},
  81.     //     {完整匹配项, 子匹配项, 子匹配项, ...},
  82.     //     ...
  83.     // }
  84.     // 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
  85.     reg = regexp.MustCompile(`(\w)(\w)+`)                      //[[Hello H o] [World W d]]
  86.     fmt.Println(reg.FindAllStringSubmatch("Hello World!", -1)) //[[Hello H o] [World W d]]
  88.     // 将 template 的内容经过处理后，追加到 dst 的尾部。
  89.     // template 中要有 $1、$2、${name1}、${name2} 这样的“分组引用符”
  90.     // match 是由 FindSubmatchIndex 方法返回的结果，里面存放了各个分组的位置信息
  91.     // 如果 template 中有“分组引用符”，则以 match 为标准，
  92.     // 在 src 中取出相应的子串，替换掉 template 中的 $1、$2 等引用符号。
  93.     reg = regexp.MustCompile(`(\w+),(\w+)`)
  94.     src := []byte("Golang,World!")           // 源文本
  95.     dst := []byte("Say: ")                   // 目标文本
  96.     template := []byte("Hello $1, Hello $2") // 模板
  97.     m := reg.FindSubmatchIndex(src)          // 解析源文本
  98.     // 填写模板，并将模板追加到目标文本中
  99.     fmt.Printf("%q", reg.Expand(dst, template, src, m))
  100.     // "Say: Hello Golang, Hello World"
  102.     // LiteralPrefix 返回所有匹配项都共同拥有的前缀（去除可变元素）
  103.     // prefix：共同拥有的前缀
  104.     // complete：如果 prefix 就是正则表达式本身，则返回 true，否则返回 false
  105.     reg = regexp.MustCompile(`Hello[\w\s]+`)
  106.     fmt.Println(reg.LiteralPrefix())
  107.     // Hello false
  108.     reg = regexp.MustCompile(`Hello`)
  109.     fmt.Println(reg.LiteralPrefix())
  110.     // Hello true
  112.     text := `Hello World! hello world`
  113.     // 正则标记“非贪婪模式”(?U)
  114.     reg = regexp.MustCompile(`(?U)H[\w\s]+o`)
  115.     fmt.Printf("%q\n", reg.FindString(text)) // Hello
  116.     // 切换到“贪婪模式”
  117.     reg.Longest()
  118.     fmt.Printf("%q\n", reg.FindString(text)) // Hello Wo
  120.     // 统计正则表达式中的分组个数（不包括“非捕获的分组”）
  121.     fmt.Println(r.NumSubexp()) //1
  123.     //返回 r 中的“正则表达式”字符串
  124.     fmt.Printf("%s\n", r.String())
  126.     // 在 字符串 中搜索匹配项，并以匹配项为分割符，将 字符串 分割成多个子串
  127.     // 最多分割出 n 个子串，第 n 个子串不再进行分割
  128.     // 如果 n < 0，则分割所有子串
  129.     // 返回分割后的子串列表
  130.     fmt.Printf("%q\n", r.Split("Hello World! Helld! hello", -1)) //["" " hello"]
  132.     // 在 字符串 中搜索匹配项，并替换为 repl 指定的内容
  133.     // 如果 rep 中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
  134.     // 全部替换，并返回替换后的结果
  135.     s := "Hello World, hello!"
  136.     reg = regexp.MustCompile(`(Hell|h)o`)
  137.     rep := "${1}"
  138.     fmt.Printf("%q\n", reg.ReplaceAllLiteralString(s, rep)) //"${1} World, hello!"
  140.     // 在 字符串 中搜索匹配项，然后将匹配的内容经过 repl 处理后，替换 字符串 中的匹配项
  141.     // 如果 repb 的返回值中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
  142.     // 全部替换，并返回替换后的结果
  143.     ss := []byte("Hello World!")
  144.     reg = regexp.MustCompile("(H)ello")
  145.     repb := []byte("$0$1")
  146.     fmt.Printf("%s\n", reg.ReplaceAll(ss, repb))
  147.     // HelloH World!
  149.     fmt.Printf("%s\n", reg.ReplaceAllFunc(ss,
  150.         func(b []byte) []byte {
  151.             rst := []byte{}
  152.             rst = append(rst, b...)
  153.             rst = append(rst, "$1"...)
  154.             return rst
  155.         }))
  156.     // Hello$1 World!
  158. }

小结：

1、

  1. r, _ := regexp.Compile("H(.*)d!")

可用一下代替

  1. r := regexp.MustCompile("H(.*)d!")

两者区别 MustCompile 少一个返回值err

看源码

  1. // Compile parses a regular expression and returns, if successful,
  2. // a Regexp object that can be used to match against text.
  3. //...
  4. // For POSIX leftmost-longest matching, see CompilePOSIX.
  5. func Compile(expr string) (*Regexp, error) {
  6.     return compile(expr, syntax.Perl, false)
  7. }
  9. // MustCompile is like Compile but panics if the expression cannot be parsed.
  10. // It simplifies safe initialization of global variables holding compiled regular
  11. // expressions.
  12. func MustCompile(str string) *Regexp {
  13.    regexp, err := Compile(str)
  14.    if err != nil {
  15.       panic(`regexp: Compile(` + quote(str) + `): ` + err.Error())
  16.    }
  17.    return regexp
  18. }

2、regexp的处理byte的方法都有个string方法对应，两者功能一样。

例如：

  1. regexp.Match()
  2. 和
  3. regexp.MatchString()

links