golang 中regexp包用法

原文链接： golang 中regexp包用法

golang 中regexp包用法
本文转自Golove博客：http://www.cnblogs.com/golove/p/3270918.html

regexp 包中的函数和方法
// regexp.go
------------------------------------------------------------
// 判断在 b 中能否找到正则表达式 pattern 所匹配的子串
// pattern：要查找的正则表达式
// b：要在其中进行查找的 \[\]byte
// matched：返回是否找到匹配项
// err：返回查找过程中遇到的任何错误
// 此函数通过调用 Regexp 的方法实现
func Match(pattern string, b \[\]byte) (matched bool, err error)
func main() {
fmt.Println(regexp.Match("H.\* ", \[\]byte("Hello World!")))
// true
}
------------------------------------------------------------
// 判断在 r 中能否找到正则表达式 pattern 所匹配的子串
// pattern：要查找的正则表达式
// r：要在其中进行查找的 RuneReader 接口
// matched：返回是否找到匹配项
// err：返回查找过程中遇到的任何错误
// 此函数通过调用 Regexp 的方法实现
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
func main() {
r := bytes.NewReader(\[\]byte("Hello World!"))
fmt.Println(regexp.MatchReader("H.\* ", r))
// true
}
------------------------------------------------------------
// 判断在 s 中能否找到正则表达式 pattern 所匹配的子串
// pattern：要查找的正则表达式
// r：要在其中进行查找的字符串
// matched：返回是否找到匹配项
// err：返回查找过程中遇到的任何错误
// 此函数通过调用 Regexp 的方法实现
func MatchString(pattern string, s string) (matched bool, err error)
func main() {
fmt.Println(regexp.Match("H.\* ", "Hello World!"))
// true
}
------------------------------------------------------------
// QuoteMeta 将字符串 s 中的“特殊字符”转换为其“转义格式”
// 例如，QuoteMeta（\`\[foo\]\`）返回\`\\\[foo\\\]\`。
// 特殊字符有：\\.+\*?()|\[\]{}^$
// 这些字符用于实现正则语法，所以当作普通字符使用时需要转换
func QuoteMeta(s string) string
func main() {
fmt.Println(regexp.QuoteMeta("(?P:Hello) \[a-z\]"))
// \\(\\?P:Hello\\) \\\[a-z\\\]
}
------------------------------------------------------------
// Regexp 结构表示一个编译后的正则表达式
// Regexp 的公开接口都是通过方法实现的
// 多个 goroutine 并发使用一个 RegExp 是安全的
type Regexp struct {
// 私有字段
}
// 通过 Complite、CompilePOSIX、MustCompile、MustCompilePOSIX
// 四个函数可以创建一个 Regexp 对象
------------------------------------------------------------
// Compile 用来解析正则表达式 expr 是否合法，如果合法，则返回一个 Regexp 对象
// Regexp 对象可以在任意文本上执行需要的操作
func Compile(expr string) (\*Regexp, error)
func main() {
reg, err := regexp.Compile(\`\\w+\`)
fmt.Printf("%q,%v\\n", reg.FindString("Hello World!"), err)
// "Hello",
}
------------------------------------------------------------
// CompilePOSIX 的作用和 Compile 一样
// 不同的是，CompilePOSIX 使用 POSIX 语法，
// 同时，它采用最左最长方式搜索，
// 而 Compile 采用最左最短方式搜索
// POSIX 语法不支持 Perl 的语法格式：\\d、\\D、\\s、\\S、\\w、\\W
func CompilePOSIX(expr string) (\*Regexp, error)
func main() {
reg, err := regexp.CompilePOSIX(\`\[\[:word:\]\]+\`)
fmt.Printf("%q,%v\\n", reg.FindString("Hello World!"), err)
// "Hello"
}
------------------------------------------------------------
// MustCompile 的作用和 Compile 一样
// 不同的是，当正则表达式 str 不合法时，MustCompile 会抛出异常
// 而 Compile 仅返回一个 error 值
func MustCompile(str string) \*Regexp
func main() {
reg := regexp.MustCompile(\`\\w+\`)
fmt.Println(reg.FindString("Hello World!"))
// Hello
}
------------------------------------------------------------
// MustCompilePOSIX 的作用和 CompilePOSIX 一样
// 不同的是，当正则表达式 str 不合法时，MustCompilePOSIX 会抛出异常
// 而 CompilePOSIX 仅返回一个 error 值
func MustCompilePOSIX(str string) \*Regexp
func main() {
reg := regexp.MustCompilePOSIX(\`\[\[:word:\]\].+ \`)
fmt.Printf("%q\\n", reg.FindString("Hello World!"))
// "Hello "
}
------------------------------------------------------------
// 在 b 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
func (re \*Regexp) Find(b \[\]byte) \[\]byte
func main() {
reg := regexp.MustCompile(\`\\w+\`)
fmt.Printf("%q", reg.Find(\[\]byte("Hello World!")))
// "Hello"
}
------------------------------------------------------------
// 在 s 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
func (re \*Regexp) FindString(s string) string
func main() {
reg := regexp.MustCompile(\`\\w+\`)
fmt.Println(reg.FindString("Hello World!"))
// "Hello"
}
------------------------------------------------------------
// 在 b 中查找 re 中编译好的正则表达式，并返回所有匹配的内容
// {{匹配项}, {匹配项}, ...}
// 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
func (re \*Regexp) FindAll(b \[\]byte, n int) \[\]\[\]byte
func main() {
reg := regexp.MustCompile(\`\\w+\`)
fmt.Printf("%q", reg.FindAll(\[\]byte("Hello World!"), -1))
// \["Hello" "World"\]
}
------------------------------------------------------------
// 在 s 中查找 re 中编译好的正则表达式，并返回所有匹配的内容
// {匹配项, 匹配项, ...}
// 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
func (re \*Regexp) FindAllString(s string, n int) \[\]string
func main() {
reg := regexp.MustCompile(\`\\w+\`)
fmt.Printf("%q", reg.FindAllString("Hello World!", -1))
// \["Hello" "World"\]
}
------------------------------------------------------------
// 在 b 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置
// {起始位置, 结束位置}
func (re \*Regexp) FindIndex(b \[\]byte) (loc \[\]int)
func main() {
reg := regexp.MustCompile(\`\\w+\`)
fmt.Println(reg.FindIndex(\[\]byte("Hello World!")))
// \[0 5\]
}
------------------------------------------------------------
// 在 s 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置
// {起始位置, 结束位置}
func (re \*Regexp) FindStringIndex(s string) (loc \[\]int)
func main() {
reg := regexp.MustCompile(\`\\w+\`)
fmt.Println(reg.FindStringIndex("Hello World!"))
// \[0 5\]
}
------------------------------------------------------------
// 在 r 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置
// {起始位置, 结束位置}
func (re \*Regexp) FindReaderIndex(r io.RuneReader) (loc \[\]int)
func main() {
r := bytes.NewReader(\[\]byte("Hello World!"))
reg := regexp.MustCompile(\`\\w+\`)
fmt.Println(reg.FindReaderIndex(r))
// \[0 5\]
}
------------------------------------------------------------
// 在 b 中查找 re 中编译好的正则表达式，并返回所有匹配的位置
// {{起始位置, 结束位置}, {起始位置, 结束位置}, ...}
// 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
func (re \*Regexp) FindAllIndex(b \[\]byte, n int) \[\]\[\]int
func main() {
reg := regexp.MustCompile(\`\\w+\`)
fmt.Println(reg.FindAllIndex(\[\]byte("Hello World!"), -1))
// \[\[0 5\] \[6 11\]\]
}
------------------------------------------------------------
// 在 s 中查找 re 中编译好的正则表达式，并返回所有匹配的位置
// {{起始位置, 结束位置}, {起始位置, 结束位置}, ...}
// 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
func (re \*Regexp) FindAllStringIndex(s string, n int) \[\]\[\]int
func main() {
reg := regexp.MustCompile(\`\\w+\`)
fmt.Println(reg.FindAllStringIndex("Hello World!", -1))
// \[\[0 5\] \[6 11\]\]
}
------------------------------------------------------------
// 在 b 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
// 同时返回子表达式匹配的内容
// {{完整匹配项}, {子匹配项}, {子匹配项}, ...}
func (re \*Regexp) FindSubmatch(b \[\]byte) \[\]\[\]byte
func main() {
reg := regexp.MustCompile(\`(\\w)(\\w)+\`)
fmt.Printf("%q", reg.FindSubmatch(\[\]byte("Hello World!")))
// \["Hello" "H" "o"\]
}
------------------------------------------------------------
// 在 s 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
// 同时返回子表达式匹配的内容
// {完整匹配项, 子匹配项, 子匹配项, ...}
func (re \*Regexp) FindStringSubmatch(s string) \[\]string
func main() {
reg := regexp.MustCompile(\`(\\w)(\\w)+\`)
fmt.Printf("%q", reg.FindStringSubmatch("Hello World!"))
// \["Hello" "H" "o"\]
}
------------------------------------------------------------
// 在 b 中查找 re 中编译好的正则表达式，并返回所有匹配的内容
// 同时返回子表达式匹配的内容
// {
// {{完整匹配项}, {子匹配项}, {子匹配项}, ...},
// {{完整匹配项}, {子匹配项}, {子匹配项}, ...},
// ...
// }
func (re \*Regexp) FindAllSubmatch(b \[\]byte, n int) \[\]\[\]\[\]byte
func main() {
reg := regexp.MustCompile(\`(\\w)(\\w)+\`)
fmt.Printf("%q", reg.FindAllSubmatch(\[\]byte("Hello World!"), -1))
// \[\["Hello" "H" "o"\] \["World" "W" "d"\]\]
}
------------------------------------------------------------
// 在 s 中查找 re 中编译好的正则表达式，并返回所有匹配的内容
// 同时返回子表达式匹配的内容
// {
// {完整匹配项, 子匹配项, 子匹配项, ...},
// {完整匹配项, 子匹配项, 子匹配项, ...},
// ...
// }
// 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
func (re \*Regexp) FindAllStringSubmatch(s string, n int) \[\]\[\]string
func main() {
reg := regexp.MustCompile(\`(\\w)(\\w)+\`)
fmt.Printf("%q", reg.FindAllStringSubmatch("Hello World!", -1))
// \[\["Hello" "H" "o"\] \["World" "W" "d"\]\]
}
------------------------------------------------------------
// 在 b 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置
// 同时返回子表达式匹配的位置
// {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...}
func (re \*Regexp) FindSubmatchIndex(b \[\]byte) \[\]int
func main() {
reg := regexp.MustCompile(\`(\\w)(\\w)+\`)
fmt.Println(reg.FindSubmatchIndex(\[\]byte("Hello World!")))
// \[0 5 0 1 4 5\]
}
------------------------------------------------------------
// 在 s 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置
// 同时返回子表达式匹配的位置
// {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...}
func (re \*Regexp) FindStringSubmatchIndex(s string) \[\]int
func main() {
reg := regexp.MustCompile(\`(\\w)(\\w)+\`)
fmt.Println(reg.FindStringSubmatchIndex("Hello World!"))
// \[0 5 0 1 4 5\]
}
------------------------------------------------------------
// 在 r 中查找 re 中编译好的正则表达式，并返回第一个匹配的位置
// 同时返回子表达式匹配的位置
// {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...}
func (re \*Regexp) FindReaderSubmatchIndex(r io.RuneReader) \[\]int
func main() {
r := bytes.NewReader(\[\]byte("Hello World!"))
reg := regexp.MustCompile(\`(\\w)(\\w)+\`)
fmt.Println(reg.FindReaderSubmatchIndex(r))
// \[0 5 0 1 4 5\]
}
------------------------------------------------------------
// 在 b 中查找 re 中编译好的正则表达式，并返回所有匹配的位置
// 同时返回子表达式匹配的位置
// {
// {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...},
// {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...},
// ...
// }
// 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
func (re \*Regexp) FindAllSubmatchIndex(b \[\]byte, n int) \[\]\[\]int
func main() {
reg := regexp.MustCompile(\`(\\w)(\\w)+\`)
fmt.Println(reg.FindAllSubmatchIndex(\[\]byte("Hello World!"), -1))
// \[\[0 5 0 1 4 5\] \[6 11 6 7 10 11\]\]
}
------------------------------------------------------------
// 在 s 中查找 re 中编译好的正则表达式，并返回所有匹配的位置
// 同时返回子表达式匹配的位置
// {
// {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...},
// {完整项起始, 完整项结束, 子项起始, 子项结束, 子项起始, 子项结束, ...},
// ...
// }
// 只查找前 n 个匹配项，如果 n < 0，则查找所有匹配项
func (re \*Regexp) FindAllStringSubmatchIndex(s string, n int) \[\]\[\]int
func main() {
reg := regexp.MustCompile(\`(\\w)(\\w)+\`)
fmt.Println(reg.FindAllStringSubmatchIndex("Hello World!", -1))
// \[\[0 5 0 1 4 5\] \[6 11 6 7 10 11\]\]
}
------------------------------------------------------------
// 将 template 的内容经过处理后，追加到 dst 的尾部。
// template 中要有 $1、$2、${name1}、${name2} 这样的“分组引用符”
// match 是由 FindSubmatchIndex 方法返回的结果，里面存放了各个分组的位置信息
// 如果 template 中有“分组引用符”，则以 match 为标准，
// 在 src 中取出相应的子串，替换掉 template 中的 $1、$2 等引用符号。
func (re \*Regexp) Expand(dst \[\]byte, template \[\]byte, src \[\]byte, match \[\]int) \[\]byte
func main() {
reg := regexp.MustCompile(\`(\\w+),(\\w+)\`)
src := \[\]byte("Golang,World!") // 源文本
dst := \[\]byte("Say: ") // 目标文本
template := \[\]byte("Hello $1, Hello $2") // 模板
match := reg.FindSubmatchIndex(src) // 解析源文本
// 填写模板，并将模板追加到目标文本中
fmt.Printf("%q", reg.Expand(dst, template, src, match))
// "Say: Hello Golang, Hello World"
}
------------------------------------------------------------
// 功能同 Expand 一样，只不过参数换成了 string 类型
func (re \*Regexp) ExpandString(dst \[\]byte, template string, src string, match \[\]int) \[\]byte
func main() {
reg := regexp.MustCompile(\`(\\w+),(\\w+)\`)
src := "Golang,World!" // 源文本
dst := \[\]byte("Say: ") // 目标文本（可写）
template := "Hello $1, Hello $2" // 模板
match := reg.FindStringSubmatchIndex(src) // 解析源文本
// 填写模板，并将模板追加到目标文本中
fmt.Printf("%q", reg.ExpandString(dst, template, src, match))
// "Say: Hello Golang, Hello World"
}
------------------------------------------------------------
// LiteralPrefix 返回所有匹配项都共同拥有的前缀（去除可变元素）
// prefix：共同拥有的前缀
// complete：如果 prefix 就是正则表达式本身，则返回 true，否则返回 false
func (re \*Regexp) LiteralPrefix() (prefix string, complete bool)
func main() {
reg := regexp.MustCompile(\`Hello\[\\w\\s\]+\`)
fmt.Println(reg.LiteralPrefix())
// Hello false
reg = regexp.MustCompile(\`Hello\`)
fmt.Println(reg.LiteralPrefix())
// Hello true
}
------------------------------------------------------------
// 切换到“贪婪模式”
func (re \*Regexp) Longest()
func main() {
text := \`Hello World, 123 Go!\`
pattern := \`(?U)H\[\\w\\s\]+o\` // 正则标记“非贪婪模式”(?U)
reg := regexp.MustCompile(pattern)
fmt.Printf("%q\\n", reg.FindString(text))
// Hello
reg.Longest() // 切换到“贪婪模式”
fmt.Printf("%q\\n", reg.FindString(text))
// Hello Wo
}
------------------------------------------------------------
// 判断在 b 中能否找到匹配项
func (re \*Regexp) Match(b \[\]byte) bool
func main() {
b := \[\]byte(\`Hello World\`)
reg := regexp.MustCompile(\`Hello\\w+\`)
fmt.Println(reg.Match(b))
// false
reg = regexp.MustCompile(\`Hello\[\\w\\s\]+\`)
fmt.Println(reg.Match(b))
// true
}
------------------------------------------------------------
// 判断在 r 中能否找到匹配项
func (re \*Regexp) MatchReader(r io.RuneReader) bool
func main() {
r := bytes.NewReader(\[\]byte(\`Hello World\`))
reg := regexp.MustCompile(\`Hello\\w+\`)
fmt.Println(reg.MatchReader(r))
// false
r.Seek(0, 0)
reg = regexp.MustCompile(\`Hello\[\\w\\s\]+\`)
fmt.Println(reg.MatchReader(r))
// true
}
------------------------------------------------------------
// 判断在 s 中能否找到匹配项
func (re \*Regexp) MatchString(s string) bool
func main() {
s := \`Hello World\`
reg := regexp.MustCompile(\`Hello\\w+\`)
fmt.Println(reg.MatchString(s))
// false
reg = regexp.MustCompile(\`Hello\[\\w\\s\]+\`)
fmt.Println(reg.MatchString(s))
// true
}
------------------------------------------------------------
// 统计正则表达式中的分组个数（不包括“非捕获的分组”）
func (re \*Regexp) NumSubexp() int
func main() {
reg := regexp.MustCompile(\`(?U)(?:Hello)(\\s+)(\\w+)\`)
fmt.Println(reg.NumSubexp())
// 2
}
------------------------------------------------------------
// 在 src 中搜索匹配项，并替换为 repl 指定的内容
// 全部替换，并返回替换后的结果
func (re \*Regexp) ReplaceAll(src, repl \[\]byte) \[\]byte
func main() {
b := \[\]byte("Hello World, 123 Go!")
reg := regexp.MustCompile(\`(Hell|G)o\`)
rep := \[\]byte("${1}ooo")
fmt.Printf("%q\\n", reg.ReplaceAll(b, rep))
// "Hellooo World, 123 Gooo!"
}
------------------------------------------------------------
// 在 src 中搜索匹配项，并替换为 repl 指定的内容
// 全部替换，并返回替换后的结果
func (re \*Regexp) ReplaceAllString(src, repl string) string
func main() {
s := "Hello World, 123 Go!"
reg := regexp.MustCompile(\`(Hell|G)o\`)
rep := "${1}ooo"
fmt.Printf("%q\\n", reg.ReplaceAllString(s, rep))
// "Hellooo World, 123 Gooo!"
}
------------------------------------------------------------
// 在 src 中搜索匹配项，并替换为 repl 指定的内容
// 如果 repl 中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
// 全部替换，并返回替换后的结果
func (re \*Regexp) ReplaceAllLiteral(src, repl \[\]byte) \[\]byte
func main() {
b := \[\]byte("Hello World, 123 Go!")
reg := regexp.MustCompile(\`(Hell|G)o\`)
rep := \[\]byte("${1}ooo")
fmt.Printf("%q\\n", reg.ReplaceAllLiteral(b, rep))
// "${1}ooo World, 123 ${1}ooo!"
}
------------------------------------------------------------
// 在 src 中搜索匹配项，并替换为 repl 指定的内容
// 如果 repl 中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
// 全部替换，并返回替换后的结果
func (re \*Regexp) ReplaceAllLiteralString(src, repl string) string
func main() {
s := "Hello World, 123 Go!"
reg := regexp.MustCompile(\`(Hell|G)o\`)
rep := "${1}ooo"
fmt.Printf("%q\\n", reg.ReplaceAllLiteralString(s, rep))
// "${1}ooo World, 123 ${1}ooo!"
}
------------------------------------------------------------
// 在 src 中搜索匹配项，然后将匹配的内容经过 repl 处理后，替换 src 中的匹配项
// 如果 repl 的返回值中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
// 全部替换，并返回替换后的结果
func (re \*Regexp) ReplaceAllFunc(src \[\]byte, repl func(\[\]byte) \[\]byte) \[\]byte
func main() {
s := \[\]byte("Hello World!")
reg := regexp.MustCompile("(H)ello")
rep := \[\]byte("$0$1")
fmt.Printf("%s\\n", reg.ReplaceAll(s, rep))
// HelloH World!
fmt.Printf("%s\\n", reg.ReplaceAllFunc(s,
func(b \[\]byte) \[\]byte {
rst := \[\]byte{}
rst = append(rst, b...)
rst = append(rst, "$1"...)
return rst
}))
// Hello$1 World!
}
k
------------------------------------------------------------
// 在 src 中搜索匹配项，然后将匹配的内容经过 repl 处理后，替换 src 中的匹配项
// 如果 repl 的返回值中有“分组引用符”（$1、$name），则将“分组引用符”当普通字符处理
// 全部替换，并返回替换后的结果
func (re \*Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string
func main() {
s := "Hello World!"
reg := regexp.MustCompile("(H)ello")
rep := "$0$1"
fmt.Printf("%s\\n", reg.ReplaceAllString(s, rep))
// HelloH World!
fmt.Printf("%s\\n", reg.ReplaceAllStringFunc(s,
func(b string) string {
return b + "$1"
}))
// Hello$1 World!
}
------------------------------------------------------------
// 在 s 中搜索匹配项，并以匹配项为分割符，将 s 分割成多个子串
// 最多分割出 n 个子串，第 n 个子串不再进行分割
// 如果 n < 0，则分割所有子串
// 返回分割后的子串列表
func (re \*Regexp) Split(s string, n int) \[\]string
func main() {
s := "Hello World\\tHello\\nGolang"
reg := regexp.MustCompile(\`\\s\`)
fmt.Printf("%q\\n", reg.Split(s, -1))
// \["Hello" "World" "Hello" "Golang"\]
}
------------------------------------------------------------
// 返回 re 中的“正则表达式”字符串
func (re \*Regexp) String() string
func main() {
re := regexp.MustCompile("Hello.\*$")
fmt.Printf("%s\\n", re.String())
// Hello.\*$
}
------------------------------------------------------------
// 返回 re 中的分组名称列表，未命名的分组返回空字符串
// 返回值\[0\] 为整个正则表达式的名称
// 返回值\[1\] 是分组 1 的名称
// 返回值\[2\] 是分组 2 的名称
// ……
func (re \*Regexp) SubexpNames() \[\]string
func main() {
re := regexp.MustCompile("(?PHello) (World)")
fmt.Printf("%q\\n", re.SubexpNames())
// \["" "Name1" ""\]
}