Golang学习(12)——regex包

1160636144 · · 1251 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

Golang学习聽-聽regexp聽包

------------------------

// 函数

// 判断在 b(s、r)中能否找到 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

------------------------

// 示例:MatchString、QuoteMeta

func聽main() {聽

聽聽聽聽pat := `(((abc.)def.)ghi)`

聽聽聽聽src := `abc-def-ghi abc+def+ghi`

聽聽聽聽fmt.Println(regexp.MatchString(pat, src)) // true <nil>

聽聽聽聽fmt.Println(regexp.QuoteMeta(pat)) // \(\(\(abc\.\)def\.\)ghi\)}聽

------------------------

// Regexp 代表一个编译好的正则表达式,我们这里称之为正则对象。正则对象可以

// 在文本中查找匹配的内容。

// Regexp 可以安全的在多个例程中并行使用。

type Regexp struct { ... }聽

------------------------

// 编译

// 将正则表达式编译成一个正则对象(使用 PERL 语法)。

// 该正则对象会采用“leftmost-first”模式。选择第一个匹配结果。

// 如果正则表达式语法错误,则返回错误信息。

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

// 将正则表达式编译成一个正则对象(正则语法限制在 POSIX ERE 范围内)。

// 该正则对象会采用“leftmost-longest”模式。选择最长的匹配结果。

// POSIX 语法不支持 Perl 的语法格式:\d、\D、\s、\S、\w、\W

// 如果正则表达式语法错误,则返回错误信息。

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

// 功能同上,但会在解析失败时 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 个元素表示整个正则表达式的名字,永远是空字符串。

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

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

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

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

------------------------

// 示例:第一匹配和最长匹配

func聽main() {聽

聽聽聽聽b := []byte("abc1def1")聽

聽聽聽聽pat := `abc1|abc1def1`

聽聽聽聽reg1 := regexp.MustCompile(pat)聽 聽 聽 // 第一匹配

聽聽聽聽reg2 := regexp.MustCompilePOSIX(pat) // 最长匹配

聽聽聽聽fmt.Printf("%s\n", reg1.Find(b))聽 聽 聽// abc1

聽聽聽聽fmt.Printf("%s\n", reg2.Find(b))聽 聽 聽// abc1def1

聽聽聽聽b = []byte("abc1def1")聽

聽聽聽聽pat = `(abc|abc1def)*1`

聽聽聽聽reg1 = regexp.MustCompile(pat)聽 聽 聽 // 第一匹配

聽聽聽聽reg2 = regexp.MustCompilePOSIX(pat) // 最长匹配

聽聽聽聽fmt.Printf("%s\n", reg1.Find(b))聽 聽 // abc1

聽聽聽聽fmt.Printf("%s\n", reg2.Find(b))聽 聽 // abc1def1

}聽

------------------------

// 示例:正则信息

func聽main() {聽

聽聽聽聽pat := `(abc)(def)(ghi)`

聽聽聽聽reg := regexp.MustCompile(pat) // 获取正则表达式字符串

聽聽聽聽fmt.Println(reg.String())聽 聽 // (abc)(def)(ghi)// 获取分组数量

聽聽聽聽fmt.Println(reg.NumSubexp()) // 3

聽聽聽聽fmt.Println() // 获取分组名称

聽聽聽聽pat = `(?P<Name1>abc)(def)(?P<Name3>ghi)`

聽聽聽聽reg = regexp.MustCompile(pat)

聽聽聽聽for i := 0; i <= reg.NumSubexp(); i++ {

聽聽聽聽聽聽聽聽fmt.Printf("%d: %q\n", i, reg.SubexpNames()[i]) }

聽聽聽聽聽聽聽聽// 0: ""聽

聽聽聽聽聽聽聽聽// 1:"Name1"

聽聽聽聽聽聽聽聽// 2: ""

聽聽聽聽聽聽聽聽// 3: "Name3"

聽聽聽聽聽聽聽聽fmt.Println() // 获取字面前缀

聽聽聽聽聽聽聽聽pat = `(abc1)(abc2)(abc3)`

聽聽聽聽聽聽聽聽reg = regexp.MustCompile(pat)聽

聽聽聽聽聽聽聽聽fmt.Println(reg.LiteralPrefix())聽

聽聽聽聽聽聽聽聽// abc1abc2abc3 true

聽聽聽聽聽聽聽聽pat = `(abc1)|(abc2)|(abc3)`

聽聽聽聽聽聽聽聽reg = regexp.MustCompile(pat)聽

聽聽聽聽聽聽聽聽fmt.Println(reg.LiteralPrefix()) // 聽false

聽聽聽聽聽聽聽聽pat = `abc1|abc2|abc3`

聽聽聽聽聽聽聽聽reg = regexp.MustCompile(pat)聽

聽聽聽聽聽聽聽聽fmt.Println(reg.LiteralPrefix()) // abc false

}

------------------------

// 判断

// 判断在 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

------------------------

// 查找

// 返回第一个匹配到的结果(结果以 b 的切片形式返回)。

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

// 返回第一个匹配到的结果及其分组内容(结果以 b 的切片形式返回)。

// 返回值中的第 0 个元素是整个正则表达式的匹配结果,后续元素是各个分组的

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

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

// 功能同 Find,只不过返回的是匹配结果的首尾下标,通过这些下标可以生成切片。

// loc[0] 是结果切片的起始下标,loc[1] 是结果切片的结束下标。

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

// 功能同 FindSubmatch,只不过返回的是匹配结果的首尾下标,通过这些下标可以生成切片。

// loc[0] 是结果切片的起始下标,loc[1] 是结果切片的结束下标。

// loc[2] 是分组1切片的起始下标,loc[3] 是分组1切片的结束下标。

// loc[4] 是分组2切片的起始下标,loc[5] 是分组2切片的结束下标。以此类推

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

------------------------

// 示例:Find、FindSubmatch

func聽main() {聽

聽聽聽聽pat := `(((abc.)def.)ghi)`

聽聽聽聽reg := regexp.MustCompile(pat)聽

聽聽聽聽src := []byte(`abc-def-ghi abc+def+ghi`) // 查找第一个匹配结果

聽聽聽聽fmt.Printf("%s\n", reg.Find(src)) // abc-def-ghi

聽聽聽聽fmt.Println() // 查找第一个匹配结果及其分组字符串

聽聽聽聽first := reg.FindSubmatch(src)

聽聽聽聽for i := 0; i < len(first); i++ {聽

聽聽聽聽聽聽聽聽fmt.Printf("%d: %s\n", i, first[i])聽

聽聽聽聽}

聽聽聽聽// 0: abc-def-ghi聽

聽聽聽聽// 1: abc-def-ghi

聽聽聽聽// 2: abc-def-

聽聽聽聽// 3: abc-

}

------------------------

// 示例:FindIndex、FindSubmatchIndex

func聽main() {聽

聽聽聽聽pat := `(((abc.)def.)ghi)`

聽聽聽聽reg := regexp.MustCompile(pat)聽

聽聽聽聽src := []byte(`abc-def-ghi abc+def+ghi`)

聽聽聽聽// 查找第一个匹配结果

聽聽聽聽matched := reg.FindIndex(src)聽

聽聽聽聽fmt.Printf("%v\n", matched) // [0 11]

聽聽聽聽m := matched[0]聽

聽聽聽聽n := matched[1]聽

聽聽聽聽fmt.Printf("%s\n\n", src[m:n]) // abc-def-ghi

聽聽聽聽// 查找第一个匹配结果及其分组字符串

聽聽聽聽matched = reg.FindSubmatchIndex(src)聽

聽聽聽聽fmt.Printf("%v\n", matched) // [0 11 0 11 0 8 0 4]

聽聽聽聽for i := 0; i < len(matched)/2; i++ {聽

聽聽聽聽聽聽聽聽m := matched[i*2]聽

聽聽聽聽聽聽聽聽n := matched[i*2+1]聽

聽聽聽聽聽聽聽聽fmt.Printf("%s\n", src[m:n])聽

聽聽聽聽}

聽聽聽聽// abc-def-ghi

聽聽聽聽// abc-def-ghi

聽聽聽聽// abc-def-// abc-

}

------------------------

// 功能同上,只不过返回多个匹配的结果,而不只是第一个。

// n 是查找次数,负数表示不限次数。

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

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

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

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

------------------------

// 示例:FindAll、FindAllSubmatch

func聽main() {聽

聽聽聽聽pat := `(((abc.)def.)ghi)`

聽聽聽聽reg := regexp.MustCompile(pat)聽

聽聽聽聽s := []byte(`abc-def-ghi abc+def+ghi`)

聽聽聽聽// 查找所有匹配结果

聽聽聽聽for _, one := range reg.FindAll(s, -1) {聽

聽聽聽聽聽聽聽聽fmt.Printf("%s\n", one)

聽聽聽聽}

聽聽聽聽// abc-def-ghi

聽聽聽聽// abc+def+ghi

聽聽聽聽// 查找所有匹配结果及其分组字符串

聽聽聽聽all := reg.FindAllSubmatch(s, -1)

聽聽聽聽for i := 0; i < len(all); i++ {聽

聽聽聽聽聽聽聽聽fmt.Println()聽

聽聽聽聽聽聽聽聽one := all[i]

聽聽聽聽聽聽聽聽for i := 0; i < len(one); i++ {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%d: %s\n", i, one[i])

聽聽聽聽聽聽聽聽}

聽聽聽聽}

聽聽聽聽// 0: abc-def-ghi

聽聽聽聽// 1: abc-def-ghi

聽聽聽聽// 2: abc-def-

聽聽聽聽// 3: abc-

聽聽聽聽// 0: abc+def+ghi

聽聽聽聽// 1: abc+def+ghi

聽聽聽聽// 2: abc+def+

聽聽聽聽// 3: abc+

}

------------------------------

// 功能同上,只不过在字符串中查找

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

------------------------------

// 替换(不会修改参数,结果是参数的副本)

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

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

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

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

// 将 src 中匹配的内容替换为 repl(repl 为字面值,不解析其中的 $1 $name 等)。

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

// 功能同上,只不过在字符串中查找。

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 中进行

// 查找,将结果存入 match 中。这样就可以通过 src 和 match 得到匹配的字符串。

// template 是替换内容,可以使用分组引用符 $1、$2、$name 等。Expane 将其中的分

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

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

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

// 功能同上,参数为字符串。

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

------------------------

// 示例:Expand

func聽main() {聽

聽聽聽聽pat := `(((abc.)def.)ghi)`

聽聽聽聽reg := regexp.MustCompile(pat)聽

聽聽聽聽src := []byte(`abc-def-ghi abc+def+ghi`)聽

聽聽聽聽template := []byte(`$0 聽 $1 聽 $2 聽 $3`)

聽聽聽聽// 替换第一次匹配结果

聽聽聽聽match := reg.FindSubmatchIndex(src)聽

聽聽聽聽fmt.Printf("%v\n", match) // [0 11 0 11 0 8 0 4]

聽聽聽聽dst := reg.Expand(nil, template, src, match)聽

聽聽聽聽fmt.Printf("%s\n\n", dst)

聽聽聽聽// abc-def-ghi 聽 abc-def-ghi 聽 abc-def- 聽 abc-

聽聽聽聽// 替换所有匹配结果

聽聽聽聽for _, match := range reg.FindAllSubmatchIndex(src, -1) {聽

聽聽聽聽聽聽聽聽fmt.Printf("%v\n", match)聽

聽聽聽聽聽聽聽聽dst := 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+def+ghi 聽 abc+def+ghi 聽 abc+def+ 聽 abc+

}

------------------------

// 其它

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

// n 是分割次数,负数表示不限次数。

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

// 将当前正则对象复制一份。在多例程中使用同一正则对象时,给每个例程分配一个

// 正则对象的副本,可以避免多例程对单个正则对象的争夺锁定。

func (re *Regexp) Copy() *Regexp聽



有疑问加站长微信联系(非本文作者)

本文来自:51CTO博客

感谢作者:1160636144

查看原文:Golang学习(12)——regex包

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:701969077

1251 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传