Go的Regexp

https://my.oschina.net/kuerant/blog/199146 

Golang学习 - regexp 包------------------------------------------------------------// 函数// 判断在 b&＃xff08;s、r&＃xff09;中能否找到 pattern 所匹配的字符串
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)// 将 s 中的正则表达式元字符转义成普通字符。
func QuoteMeta(s string) string------------------------------// 示例&＃xff1a;MatchString、QuoteMeta
func main() {pat :&＃61; &＃96;(((abc.)def.)ghi)&＃96;src :&＃61; &＃96;abc-def-ghi abc&＃43;def&＃43;ghi&＃96;fmt.Println(regexp.MatchString(pat, src))// true fmt.Println(regexp.QuoteMeta(pat))// \(\(\(abc\.\)def\.\)ghi\)
}------------------------------------------------------------// Regexp 代表一个编译好的正则表达式&＃xff0c;我们这里称之为正则对象。正则对象可以
// 在文本中查找匹配的内容。
//
// Regexp 可以安全的在多个例程中并行使用。
type Regexp struct { ... }------------------------------// 编译// 将正则表达式编译成一个正则对象&＃xff08;使用 PERL 语法&＃xff09;。
// 该正则对象会采用“leftmost-first”模式。选择第一个匹配结果。
// 如果正则表达式语法错误&＃xff0c;则返回错误信息。
func Compile(expr string) (*Regexp, error)// 将正则表达式编译成一个正则对象&＃xff08;正则语法限制在 POSIX ERE 范围内&＃xff09;。
// 该正则对象会采用“leftmost-longest”模式。选择最长的匹配结果。
// POSIX 语法不支持 Perl 的语法格式&＃xff1a;\d、\D、\s、\S、\w、\W
// 如果正则表达式语法错误&＃xff0c;则返回错误信息。
func CompilePOSIX(expr string) (*Regexp, error)// 功能同上&＃xff0c;但会在解析失败时 panic
func MustCompile(str string) *Regexp
func MustCompilePOSIX(str string) *Regexp// 让正则表达式在之后的搜索中都采用“leftmost-longest”模式。
func (re *Regexp) Longest()// 返回编译时使用的正则表达式字符串
func (re *Regexp) String() string// 返回正则表达式中分组的数量
func (re *Regexp) NumSubexp() int// 返回正则表达式中分组的名字
// 第 0 个元素表示整个正则表达式的名字&＃xff0c;永远是空字符串。
func (re *Regexp) SubexpNames() []string// 返回正则表达式必须匹配到的字面前缀&＃xff08;不包含可变部分&＃xff09;。
// 如果整个正则表达式都是字面值&＃xff0c;则 complete 返回 true。
func (re *Regexp) LiteralPrefix() (prefix string, complete bool)------------------------------// 示例&＃xff1a;第一匹配和最长匹配
func main() {b :&＃61; []byte("abc1def1")pat :&＃61; &＃96;abc1|abc1def1&＃96;reg1 :&＃61; regexp.MustCompile(pat) // 第一匹配reg2 :&＃61; regexp.MustCompilePOSIX(pat) // 最长匹配fmt.Printf("%s\n", reg1.Find(b)) // abc1fmt.Printf("%s\n", reg2.Find(b)) // abc1def1b &＃61; []byte("abc1def1")pat &＃61; &＃96;(abc|abc1def)*1&＃96;reg1 &＃61; regexp.MustCompile(pat) // 第一匹配reg2 &＃61; regexp.MustCompilePOSIX(pat) // 最长匹配fmt.Printf("%s\n", reg1.Find(b)) // abc1fmt.Printf("%s\n", reg2.Find(b)) // abc1def1
}------------------------------// 示例&＃xff1a;正则信息
func main() {pat :&＃61; &＃96;(abc)(def)(ghi)&＃96;reg :&＃61; regexp.MustCompile(pat)// 获取正则表达式字符串fmt.Println(reg.String()) // (abc)(def)(ghi)// 获取分组数量fmt.Println(reg.NumSubexp()) // 3fmt.Println()// 获取分组名称pat &＃61; &＃96;(?Pabc)(def)(?Pghi)&＃96;reg &＃61; regexp.MustCompile(pat)for i :&＃61; 0; i <&＃61; reg.NumSubexp(); i&＃43;&＃43; {fmt.Printf("%d: %q\n", i, reg.SubexpNames()[i])}// 0: ""// 1: "Name1"// 2: ""// 3: "Name3"fmt.Println()// 获取字面前缀pat &＃61; &＃96;(abc1)(abc2)(abc3)&＃96;reg &＃61; regexp.MustCompile(pat)fmt.Println(reg.LiteralPrefix()) // abc1abc2abc3 truepat &＃61; &＃96;(abc1)|(abc2)|(abc3)&＃96;reg &＃61; regexp.MustCompile(pat)fmt.Println(reg.LiteralPrefix()) // falsepat &＃61; &＃96;abc1|abc2|abc3&＃96;reg &＃61; regexp.MustCompile(pat)fmt.Println(reg.LiteralPrefix()) // abc false
}------------------------------// 判断// 判断在 b&＃xff08;s、r&＃xff09;中能否找到匹配的字符串
func (re *Regexp) Match(b []byte) bool
func (re *Regexp) MatchString(s string) bool
func (re *Regexp) MatchReader(r io.RuneReader) bool------------------------------// 查找// 返回第一个匹配到的结果&＃xff08;结果以 b 的切片形式返回&＃xff09;。
func (re *Regexp) Find(b []byte) []byte// 返回第一个匹配到的结果及其分组内容&＃xff08;结果以 b 的切片形式返回&＃xff09;。
// 返回值中的第 0 个元素是整个正则表达式的匹配结果&＃xff0c;后续元素是各个分组的
// 匹配内容&＃xff0c;分组顺序按照“(”的出现次序而定。
func (re *Regexp) FindSubmatch(b []byte) [][]byte// 功能同 Find&＃xff0c;只不过返回的是匹配结果的首尾下标&＃xff0c;通过这些下标可以生成切片。
// loc[0] 是结果切片的起始下标&＃xff0c;loc[1] 是结果切片的结束下标。
func (re *Regexp) FindIndex(b []byte) (loc []int)// 功能同 FindSubmatch&＃xff0c;只不过返回的是匹配结果的首尾下标&＃xff0c;通过这些下标可以生成切片。
// loc[0] 是结果切片的起始下标&＃xff0c;loc[1] 是结果切片的结束下标。
// loc[2] 是分组1切片的起始下标&＃xff0c;loc[3] 是分组1切片的结束下标。
// loc[4] 是分组2切片的起始下标&＃xff0c;loc[5] 是分组2切片的结束下标。
// 以此类推
func (re *Regexp) FindSubmatchIndex(b []byte) (loc []int)------------------------------// 示例&＃xff1a;Find、FindSubmatch
func main() {pat :&＃61; &＃96;(((abc.)def.)ghi)&＃96;reg :&＃61; regexp.MustCompile(pat)src :&＃61; []byte(&＃96;abc-def-ghi abc&＃43;def&＃43;ghi&＃96;)// 查找第一个匹配结果fmt.Printf("%s\n", reg.Find(src)) // abc-def-ghifmt.Println()// 查找第一个匹配结果及其分组字符串first :&＃61; reg.FindSubmatch(src)for i :&＃61; 0; i }------------------------------// 示例&＃xff1a;FindIndex、FindSubmatchIndex
func main() {pat :&＃61; &＃96;(((abc.)def.)ghi)&＃96;reg :&＃61; regexp.MustCompile(pat)src :&＃61; []byte(&＃96;abc-def-ghi abc&＃43;def&＃43;ghi&＃96;)// 查找第一个匹配结果matched :&＃61; reg.FindIndex(src)fmt.Printf("%v\n", matched) // [0 11]m :&＃61; matched[0]n :&＃61; matched[1]fmt.Printf("%s\n\n", src[m:n]) // abc-def-ghi// 查找第一个匹配结果及其分组字符串matched &＃61; reg.FindSubmatchIndex(src)fmt.Printf("%v\n", matched) // [0 11 0 11 0 8 0 4]for i :&＃61; 0; i }------------------------------// 功能同上&＃xff0c;只不过返回多个匹配的结果&＃xff0c;而不只是第一个。
// n 是查找次数&＃xff0c;负数表示不限次数。
func (re *Regexp) FindAll(b []byte, n int) [][]byte
func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]bytefunc (re *Regexp) FindAllIndex(b []byte, n int) [][]int
func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int------------------------------// 示例&＃xff1a;FindAll、FindAllSubmatch
func main() {pat :&＃61; &＃96;(((abc.)def.)ghi)&＃96;reg :&＃61; regexp.MustCompile(pat)s :&＃61; []byte(&＃96;abc-def-ghi abc&＃43;def&＃43;ghi&＃96;)// 查找所有匹配结果for _, one :&＃61; range reg.FindAll(s, -1) {fmt.Printf("%s\n", one)}// abc-def-ghi// abc&＃43;def&＃43;ghi// 查找所有匹配结果及其分组字符串all :&＃61; reg.FindAllSubmatch(s, -1)for i :&＃61; 0; i }------------------------------// 功能同上&＃xff0c;只不过在字符串中查找
func (re *Regexp) FindString(s string) string
func (re *Regexp) FindStringSubmatch(s string) []stringfunc (re *Regexp) FindStringIndex(s string) (loc []int)
func (re *Regexp) FindStringSubmatchIndex(s string) []intfunc (re *Regexp) FindAllString(s string, n int) []string
func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]stringfunc (re *Regexp) FindAllStringIndex(s string, n int) [][]int
func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int// 功能同上&＃xff0c;只不过在 io.RuneReader 中查找。
func (re *Regexp) FindReaderIndex(r io.RuneReader) (loc []int)
func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int------------------------------// 替换&＃xff08;不会修改参数&＃xff0c;结果是参数的副本&＃xff09;// 将 src 中匹配的内容替换为 repl&＃xff08;repl 中可以使用 $1 $name 等分组引用符&＃xff09;。
func (re *Regexp) ReplaceAll(src, repl []byte) []byte// 将 src 中匹配的内容经过 repl 函数处理后替换回去。
func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte// 将 src 中匹配的内容替换为 repl&＃xff08;repl 为字面值&＃xff0c;不解析其中的 $1 $name 等&＃xff09;。
func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte// 功能同上&＃xff0c;只不过在字符串中查找。
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// Expand 要配合 FindSubmatchIndex 一起使用。FindSubmatchIndex 在 src 中进行
// 查找&＃xff0c;将结果存入 match 中。这样就可以通过 src 和 match 得到匹配的字符串。
// template 是替换内容&＃xff0c;可以使用分组引用符 $1、$2、$name 等。Expane 将其中的分
// 组引用符替换为前面匹配到的字符串。然后追加到 dst 的尾部&＃xff08;dst 可以为空&＃xff09;。
// 说白了 Expand 就是一次替换过程&＃xff0c;只不过需要 FindSubmatchIndex 的配合。
func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte// 功能同上&＃xff0c;参数为字符串。
func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte------------------------------// 示例&＃xff1a;Expand
func main() {pat :&＃61; &＃96;(((abc.)def.)ghi)&＃96;reg :&＃61; regexp.MustCompile(pat)src :&＃61; []byte(&＃96;abc-def-ghi abc&＃43;def&＃43;ghi&＃96;)template :&＃61; []byte(&＃96;$0 $1 $2 $3&＃96;)// 替换第一次匹配结果match :&＃61; reg.FindSubmatchIndex(src)fmt.Printf("%v\n", match) // [0 11 0 11 0 8 0 4]dst :&＃61; reg.Expand(nil, template, src, match)fmt.Printf("%s\n\n", dst)// abc-def-ghi abc-def-ghi abc-def- abc-// 替换所有匹配结果for _, match :&＃61; range reg.FindAllSubmatchIndex(src, -1) {fmt.Printf("%v\n", match)dst :&＃61; reg.Expand(nil, template, src, match)fmt.Printf("%s\n", dst)}// [0 11 0 11 0 8 0 4]// abc-def-ghi abc-def-ghi abc-def- abc-// [12 23 12 23 12 20 12 16]// abc&＃43;def&＃43;ghi abc&＃43;def&＃43;ghi abc&＃43;def&＃43; abc&＃43;
}------------------------------// 其它// 以 s 中的匹配结果作为分割符将 s 分割成字符串列表。
// n 是分割次数&＃xff0c;负数表示不限次数。
func (re *Regexp) Split(s string, n int) []string// 将当前正则对象复制一份。在多例程中使用同一正则对象时&＃xff0c;给每个例程分配一个
// 正则对象的副本&＃xff0c;可以避免多例程对单个正则对象的争夺锁定。
func (re *Regexp) Copy() *Regexp------------------------------------------------------------