regexp
regexp包实现了正则表达式搜索。
正则表达式采用RE2语法（除了\c、\C），和Perl、Python等语言的正则基本一致。
Syntax
本包采用的正则表达式语法，默认采用perl标志。某些语法可以通过切换解析时的标志来关闭。
单字符：
. 任意字符（标志s==true时还包括换行符）
[xyz] 字符族
[^xyz] 反向字符族
\d Perl预定义字符族
\D 反向Perl预定义字符族
[:alpha:] ASCII字符族
[:^alpha:] 反向ASCII字符族
\pN Unicode字符族（单字符名），参见unicode包
\PN 反向Unicode字符族（单字符名）
\p{Greek} Unicode字符族（完整字符名）
\P{Greek} 反向Unicode字符族（完整字符名）
结合：
xy 匹配x后接着匹配y
x|y 匹配x或y（优先匹配x）
重复：
x* 重复>=0次匹配x，越多越好（优先重复匹配x）
x+ 重复>=1次匹配x，越多越好（优先重复匹配x）
x? 0或1次匹配x，优先1次
x{n,m} n到m次匹配x，越多越好（优先重复匹配x）
x{n,} 重复>=n次匹配x，越多越好（优先重复匹配x）
x{n} 重复n次匹配x
x*? 重复>=0次匹配x，越少越好（优先跳出重复）
x+? 重复>=1次匹配x，越少越好（优先跳出重复）
x?? 0或1次匹配x，优先0次
x{n,m}? n到m次匹配x，越少越好（优先跳出重复）
x{n,}? 重复>=n次匹配x，越少越好（优先跳出重复）
x{n}? 重复n次匹配x
实现的限制：计数格式x{n}等（不包括x*等格式）中n最大值1000。负数或者显式出现的过大的值会导致解析错误，返回ErrInvalidRepeatSize。
分组：
(re) 编号的捕获分组
(?P<name>re) 命名并编号的捕获分组
(?:re) 不捕获的分组
(?flags) 设置当前所在分组的标志，不捕获也不匹配
(?flags:re) 设置re段的标志，不捕获的分组
标志的语法为xyz（设置）、-xyz（清楚）、xy-z（设置xy，清楚z），标志如下：
I 大小写敏感（默认关闭）
m ^和$在匹配文本开始和结尾之外，还可以匹配行首和行尾（默认开启）
s 让.可以匹配\n（默认关闭）
U 非贪婪的：交换x*和x*?、x+和x+?……的含义（默认关闭）
边界匹配：
^ 匹配文本开始，标志m为真时，还匹配行首
$ 匹配文本结尾，标志m为真时，还匹配行尾
\A 匹配文本开始
\b 单词边界（一边字符属于\w，另一边为文首、文尾、行首、行尾或属于\W）
\B 非单词边界
\z 匹配文本结尾
转义序列：
\a 响铃符（\007）
\f 换纸符（\014）
\t 水平制表符（\011）
\n 换行符（\012）
\r 回车符（\015）
\v 垂直制表符（\013）
\123 八进制表示的字符码（最多三个数字）
\x7F 十六进制表示的字符码（必须两个数字）
\x{10FFFF} 十六进制表示的字符码
\* 字面值'*'
\Q...\E 反斜线后面的字符的字面值
字符族（预定义字符族之外，方括号内部）的语法：
x 单个字符
A-Z 字符范围（方括号内部才可以用）
\d Perl字符族
[:foo:] ASCII字符族
\pF 单字符名的Unicode字符族
\p{Foo} 完整字符名的Unicode字符族
预定义字符族作为字符族的元素：
[\d] == \d
[^\d] == \D
[\D] == \D
[^\D] == \d
[[:name:]] == [:name:]
[^[:name:]] == [:^name:]
[\p{Name}] == \p{Name}
[^\p{Name}] == \P{Name}
Perl字符族：
\d == [0-9]
\D == [^0-9]
\s == [\t\n\f\r ]
\S == [^\t\n\f\r ]
\w == [0-9A-Za-z_]
\W == [^0-9A-Za-z_]
ASCII字符族：
[:alnum:] == [0-9A-Za-z]
[:alpha:] == [A-Za-z]
[:ascii:] == [\x00-\x7F]
[:blank:] == [\t ]
[:cntrl:] == [\x00-\x1F\x7F]
[:digit:] == [0-9]
[:graph:] == [!-~] == [A-Za-z0-9!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]
[:lower:] == [a-z]
[:print:] == [ -~] == [ [:graph:]]
[:punct:] == [!-/:-@[-`{-~]
[:space:] == [\t\n\v\f\r ]
[:upper:] == [A-Z]
[:word:] == [0-9A-Za-z_]
[:xdigit:] == [0-9A-Fa-f]
本包的正则表达式保证搜索复杂度为O(n)，其中n为输入的长度。这一点很多其他开源实现是无法保证的。参见：
http://swtch.com/~rsc/regexp/regexp1.html
或其他关于自动机理论的书籍。
所有的字符都被视为utf-8编码的码值。
Regexp类型提供了多达16个方法，用于匹配正则表达式并获取匹配的结果。它们的名字满足如下正则表达式：
Find(All)?(String)?(Submatch)?(Index)?
如果'All'出现了，该方法会返回输入中所有互不重叠的匹配结果。如果一个匹配结果的前后（没有间隔字符）存在长度为0的成功匹配，该空匹配会被忽略。包含All的方法会要求一个额外的整数参数n，如果n>=0，方法会返回最多前n个匹配结果。
如果'String'出现了，匹配对象为字符串，否则应该是[]byte类型，返回值和匹配对象的类型是对应的。
如果'Submatch'出现了，返回值是表示正则表达式中成功的组匹配（子匹配/次级匹配）的切片。组匹配是正则表达式内部的括号包围的次级表达式（也被称为“捕获分组”），从左到右按左括号的顺序编号。，索引0的组匹配为完整表达式的匹配结果，1为第一个分组的匹配结果，依次类推。
如果'Index'出现了，匹配/分组匹配会用输入流的字节索引对表示result[2n:2n+1]表示第n个分组匹配的的匹配结果。如果没有'Index'，匹配结果表示为匹配到的文本。如果索引为负数，表示分组匹配没有匹配到输入流中的文本。
方法集也有一个用于从RuneReader中读取文本进行匹配的子集：
MatchReader, FindReaderIndex, FindReaderSubmatchIndex
该子集可能会增加。注意正则表达式匹配可能需要检验匹配结果前后的文本，因此从RuneReader匹配文本的方法很可能会读取到远远超出返回的结果所在的位置。
（另有几个其他方法不满足该方法模式的）
func main() {
var validID = regexp.MustCompile(`^[a-z]+\[[0-9]+\]$`)
fmt.Println(validID.MatchString("adam[23]"))
fmt.Println(validID.MatchString("eve[7]"))
fmt.Println(validID.MatchString("Job[48]"))
fmt.Println(validID.MatchString("snakey"))
}
// true
// true
// false
// false
func QuoteMeta
func QuoteMeta(s string) string
QuoteMeta返回将s中所有正则表达式元字符都进行转义后字符串。该字符串可以用在正则表达式中匹配字面值s。例如，QuoteMeta(
[foo])会返回\[foo\]。
func Match
func Match(pattern string, b []byte) (matched bool, err error)
Match检查b中是否存在匹配pattern的子序列。更复杂的用法请使用Compile函数和Regexp对象。
func MatchString
func MatchString(pattern string, s string) (matched bool, err error)
MatchString类似Match，但匹配对象是字符串。
func main() {
matched, err := regexp.MatchString("foo.*", "seafood")
fmt.Println(matched, err)
matched, err = regexp.MatchString("bar.*", "seafood")
fmt.Println(matched, err)
matched, err = regexp.MatchString("a(b", "seafood")
fmt.Println(matched, err)
}
// true <nil>
// false <nil>
// false error parsing regexp: missing closing ): `a(b`
func MatchReader
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
MatchReader类似Match，但匹配对象是io.RuneReader。
type Regexp
type Regexp struct {
expr string // as passed to Compile
prog *syntax.Prog // compiled program
onepass *onePassProg // onepass program or nil
numSubexp int
maxBitStateLen int
subexpNames []string
prefix string // required prefix in unanchored matches
prefixBytes []byte // prefix, as a []byte
prefixRune rune // first rune in prefix
prefixEnd uint32 // pc for last rune in prefix
mpool int // pool for machines
matchcap int // size of recorded match lengths
prefixComplete bool // prefix is the entire regexp
cond syntax.EmptyOp // empty-width conditions required at start of match
minInputLen int // minimum length of the input in bytes
// This field can be modified by the Longest method,
// but it is otherwise read-only.
longest bool // whether regexp prefers leftmost-longest match
}
Regexp代表一个编译好的正则表达式。Regexp可以被多线程安全地同时使用。
func Compile
func Compile(expr string) (*Regexp, error)
Compile解析并返回一个正则表达式。如果成功返回，该Regexp就可用于匹配文本。
在匹配文本时，该正则表达式会尽可能早的开始匹配，并且在匹配过程中选择回溯搜索到的第一个匹配结果。这种模式被称为“leftmost-first”，Perl、Python和其他实现都采用了这种模式，但本包的实现没有回溯的损耗。对POSIX的“leftmost-longest”模式，参见CompilePOSIX。
func CompilePOSIX
func CompilePOSIX(expr string) (*Regexp, error)
类似Compile但会将语法约束到POSIX ERE（egrep）语法，并将匹配模式设置为leftmost-longest。
在匹配文本时，该正则表达式会尽可能早的开始匹配，并且在匹配过程中选择搜索到的最长的匹配结果。这种模式被称为“leftmost-longest”，POSIX采用了这种模式（早期正则的DFA自动机模式）。
然而，可能会有多个“leftmost-longest”匹配，每个都有不同的组匹配状态，本包在这里和POSIX不同。在所有可能的“leftmost-longest”匹配里，本包选择回溯搜索时第一个找到的，而POSIX会选择候选结果中第一个组匹配最长的（可能有多个），然后再从中选出第二个组匹配最长的，依次类推。POSIX规则计算困难，甚至没有良好定义。
func MustCompile
func MustCompile(str string) *Regexp
MustCompile类似Compile但会在解析失败时panic，主要用于全局正则表达式变量的安全初始化。
func MustCompilePOSIX
func MustCompilePOSIX(str string) *Regexp
MustCompilePOSIX类似CompilePOSIX但会在解析失败时panic，主要用于全局正则表达式变量的安全初始化。
func (*Regexp) String
func (re *Regexp) String() string
String返回用于编译成正则表达式的字符串。
func (*Regexp) LiteralPrefix
func (re *Regexp) LiteralPrefix() (prefix string, complete bool)
LiteralPrefix返回一个字符串字面值prefix，任何匹配本正则表达式的字符串都会以prefix起始。 如果该字符串字面值包含整个正则表达式，返回值complete会设为真。
func (*Regexp) NumSubexp
func (re *Regexp) NumSubexp() int
NumSubexp返回该正则表达式中捕获分组的数量。
func main() {
re := regexp.MustCompile("(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)")
fmt.Println(re.MatchString("Alan Turing"))
fmt.Printf("%q\n", re.SubexpNames())
reversed := fmt.Sprintf("${%s} ${%s}", re.SubexpNames()[2], re.SubexpNames()[1])
fmt.Println(reversed)
fmt.Println(re.ReplaceAllString("Alan Turing", reversed))
}
// true
// ["" "first" "last"]
// ${last} ${first}
// Turing Alan
func (*Regexp) SubexpNames
func (re *Regexp) SubexpNames() []string
SubexpNames返回该正则表达式中捕获分组的名字。第一个分组的名字是names[1]，因此，如果m是一个组匹配切片，m[i]的名字是SubexpNames()[i]。因为整个正则表达式是无法被命名的，names[0]必然是空字符串。该切片不应被修改。
func (*Regexp) Longest
func (re *Regexp) Longest()
Longest让正则表达式在之后的搜索中都采用"leftmost-longest"模式。在匹配文本时，该正则表达式会尽可能早的开始匹配，并且在匹配过程中选择搜索到的最长的匹配结果。
func (*Regexp) Match
func (re *Regexp) Match(b []byte) bool
Match检查b中是否存在匹配pattern的子序列。
func (*Regexp) MatchString
func (re *Regexp) MatchString(s string) bool
MatchString类似Match，但匹配对象是字符串。
func (*Regexp) MatchReader
func (re *Regexp) MatchReader(r io.RuneReader) bool
MatchReader类似Match，但匹配对象是io.RuneReader。
func (*Regexp) Find
func (re *Regexp) Find(b []byte) []byte
Find返回保管正则表达式re在b中的最左侧的一个匹配结果的[]byte切片。如果没有匹配到，会返回nil。
func (*Regexp) FindString
func (re *Regexp) FindString(s string) string
Find返回保管正则表达式re在b中的最左侧的一个匹配结果的字符串。如果没有匹配到，会返回""；但如果正则表达式成功匹配了一个空字符串，也会返回""。如果需要区分这种情况，请使用FindStringIndex 或FindStringSubmatch。
func main() {
re := regexp.MustCompile("fo.?")
fmt.Printf("%q\n", re.FindString("seafood"))
fmt.Printf("%q\n", re.FindString("meat"))
}
// "foo"
// ""
func (*Regexp) FindIndex
func (re *Regexp) FindIndex(b []byte) (loc []int)
Find返回保管正则表达式re在b中的最左侧的一个匹配结果的起止位置的切片（显然len(loc)==2）。匹配结果可以通过起止位置对b做切片操作得到：b[loc[0]:loc[1]]。如果没有匹配到，会返回nil。
func main() {
re := regexp.MustCompile("ab?")
fmt.Println(re.FindStringIndex("tablett"))
fmt.Println(re.FindStringIndex("foo") == nil)
}
// [1 3]
// true
func (*Regexp) FindStringIndex
func (re *Regexp) FindStringIndex(s string) (loc []int)
Find返回保管正则表达式re在b中的最左侧的一个匹配结果的起止位置的切片（显然len(loc)==2）。匹配结果可以通过起止位置对b做切片操作得到：b[loc[0]:loc[1]]。如果没有匹配到，会返回nil。
func (*Regexp) FindReaderIndex
Find返回保管正则表达式re在b中的最左侧的一个匹配结果的起止位置的切片（显然len(loc)==2）。匹配结果可以在输入流r的字节偏移量loc[0]到loc[1]-1（包括二者）位置找到。如果没有匹配到，会返回nil。
func (*Regexp) FindSubmatch
func (re *Regexp) FindSubmatch(b []byte) [][]byte
Find返回一个保管正则表达式re在b中的最左侧的一个匹配结果以及（可能有的）分组匹配的结果的[][]byte切片。如果没有匹配到，会返回nil。
func main() {
re := regexp.MustCompile("a(x*)b(y|z)c")
fmt.Printf("%q\n", re.FindStringSubmatch("-axxxbyc-"))
fmt.Printf("%q\n", re.FindStringSubmatch("-abzc-"))
}
// ["axxxbyc" "xxx" "y"]
// ["abzc" "" "z"]
func (*Regexp) FindStringSubmatch
func (re *Regexp) FindStringSubmatch(s string) []string
Find返回一个保管正则表达式re在b中的最左侧的一个匹配结果以及（可能有的）分组匹配的结果的[]string切片。如果没有匹配到，会返回nil。
func (*Regexp) FindSubmatchIndex
func (re *Regexp) FindSubmatchIndex(b []byte) []int
Find返回一个保管正则表达式re在b中的最左侧的一个匹配结果以及（可能有的）分组匹配的结果的起止位置的切片。匹配结果和分组匹配结果可以通过起止位置对b做切片操作得到：b[loc[2n]:loc[2n+1]]。如果没有匹配到，会返回nil。
func (*Regexp) FindStringSubmatchIndex
func (re *Regexp) FindStringSubmatchIndex(s string) []int
Find返回一个保管正则表达式re在b中的最左侧的一个匹配结果以及（可能有的）分组匹配的结果的起止位置的切片。匹配结果和分组匹配结果可以通过起止位置对b做切片操作得到：b[loc[2n]:loc[2n+1]]。如果没有匹配到，会返回nil。
func (*Regexp) FindReaderSubmatchIndex
func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int
Find返回一个保管正则表达式re在b中的最左侧的一个匹配结果以及（可能有的）分组匹配的结果的起止位置的切片。匹配结果和分组匹配结果可以在输入流r的字节偏移量loc[0]到loc[1]-1（包括二者）位置找到。如果没有匹配到，会返回nil。
func (*Regexp) FindAll
func (re *Regexp) FindAll(b []byte, n int) [][]byte
Find返回保管正则表达式re在b中的所有不重叠的匹配结果的[][]byte切片。如果没有匹配到，会返回nil。
func (*Regexp) FindAllString
func (re *Regexp) FindAllString(s string, n int) []string
Find返回保管正则表达式re在b中的所有不重叠的匹配结果的[]string切片。如果没有匹配到，会返回nil。
func main() {
re := regexp.MustCompile("a.")
fmt.Println(re.FindAllString("paranormal", -1))
fmt.Println(re.FindAllString("paranormal", 2))
fmt.Println(re.FindAllString("graal", -1))
fmt.Println(re.FindAllString("none", -1))
}
// [ar an al]
// [ar an]
// [aa]
// []
func (*Regexp) FindAllIndex
func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
Find返回保管正则表达式re在b中的所有不重叠的匹配结果的起止位置的切片。如果没有匹配到，会返回nil。
func (*Regexp) FindAllStringIndex
func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
Find返回保管正则表达式re在b中的所有不重叠的匹配结果的起止位置的切片。如果没有匹配到，会返回nil。
func (*Regexp) FindAllSubmatch
func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
Find返回一个保管正则表达式re在b中的所有不重叠的匹配结果及其对应的（可能有的）分组匹配的结果的[][][]byte切片。如果没有匹配到，会返回nil。
func (*Regexp) FindAllStringSubmatch
func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string
Find返回一个保管正则表达式re在b中的所有不重叠的匹配结果及其对应的（可能有的）分组匹配的结果的[][]string切片。如果没有匹配到，会返回nil。
func main() {
re := regexp.MustCompile("a(x*)b")
fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-", -1))
fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-", -1))
fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-axb-", -1))
fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-ab-", -1))
}
// [["ab" ""]]
// [["axxb" "xx"]]
// [["ab" ""] ["axb" "x"]]
// [["axxb" "xx"] ["ab" ""]]
func (*Regexp) FindAllSubmatchIndex
func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
Find返回一个保管正则表达式re在b中的所有不重叠的匹配结果及其对应的（可能有的）分组匹配的结果的起止位置的切片（第一层表示第几个匹配结果，完整匹配和分组匹配的起止位置对在第二层）。如果没有匹配到，会返回nil。
func (*Regexp) FindAllStringSubmatchIndex
func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
Find返回一个保管正则表达式re在b中的所有不重叠的匹配结果及其对应的（可能有的）分组匹配的结果的起止位置的切片（第一层表示第几个匹配结果，完整匹配和分组匹配的起止位置对在第二层）。如果没有匹配到，会返回nil。
re := regexp.MustCompile("a(x*)b")
// Indices:
// 01234567 012345678
// -ab-axb- -axxb-ab-
fmt.Println(re.FindAllStringSubmatchIndex("-ab-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-axxb-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-ab-axb-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-axxb-ab-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-foo-", -1))
// [[1 3 2 2]]
// [[1 5 2 4]]
// [[1 3 2 2] [4 7 5 6]]
// [[1 5 2 4] [6 8 7 7]]
// []
func (*Regexp) Split
func (re *Regexp) Split(s string, n int) []string
Split将re在s中匹配到的结果作为分隔符将s分割成多个字符串，并返回这些正则匹配结果之间的字符串的切片。
返回的切片不会包含正则匹配的结果，只包含匹配结果之间的片段。当正则表达式re中不含正则元字符时，本方法等价于strings.SplitN。
举例：
s := regexp.MustCompile("a*").Split("abaabaccadaaae", 5)
// s: ["", "b", "b", "c", "cadaaae"]
参数n绝对返回的子字符串的数量：
n > 0 : 返回最多n个子字符串，最后一个子字符串是剩余未进行分割的部分。
n == 0: 返回nil (zero substrings)
n < 0 : 返回所有子字符串
func (*Regexp) Expand
func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
Expand返回新生成的将template添加到dst后面的切片。在添加时，Expand会将template中的变量替换为从src匹配的结果。match应该是被FindSubmatchIndex返回的匹配结果起止位置索引。（通常就是匹配src，除非你要将匹配得到的位置用于另一个[]byte）
在template参数里，一个变量表示为格式如：
{name}的字符串，其中name是长度>0的字母、数字和下划线的序列。一个单纯的数字字符名如$1会作为捕获分组的数字索引；其他的名字对应(?P<name>...)语法产生的命名捕获分组的名字。超出范围的数字索引、索引对应的分组未匹配到文本、正则表达式中未出现的分组名，都会被替换为空切片。
1x等价于
{1}x，
{10}而非
name适用在后跟空格/换行等字符的情况，${name}适用所有情况。
如果要在输出中插入一个字面值'$'，在template里可以使用$$。
func (*Regexp) ExpandString
func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte
ExpandString类似Expand，但template和src参数为字符串。它将替换结果添加到切片并返回切片，以便让调用代码控制内存申请。
func (*Regexp) ReplaceAllLiteral
func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte
ReplaceAllLiteral返回src的一个拷贝，将src中所有re的匹配结果都替换为repl。repl参数被直接使用，不会使用Expand进行扩展。
func main() {
re := regexp.MustCompile("a(x*)b")
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "T"))
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "$1"))
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "${1}"))
}
// -T-T-
// -$1-$1-
// -${1}-${1}-
func (*Regexp) ReplaceAllLiteralString
func (re *Regexp) ReplaceAllLiteralString(src, repl string) string
ReplaceAllLiteralString返回src的一个拷贝，将src中所有re的匹配结果都替换为repl。repl参数被直接使用，不会使用Expand进行扩展。
func (*Regexp) ReplaceAll
func (re *Regexp) ReplaceAll(src, repl []byte) []byte
ReplaceAllLiteral返回src的一个拷贝，将src中所有re的匹配结果都替换为repl。在替换时，repl中的'
1会被替换为第一个分组匹配结果。
func (*Regexp) ReplaceAllString
func (re *Regexp) ReplaceAllString(src, repl string) string
ReplaceAllLiteral返回src的一个拷贝，将src中所有re的匹配结果都替换为repl。在替换时，repl中的'
func main() {
re := regexp.MustCompile("a(x*)b")
fmt.Println(re.ReplaceAllString("-ab-axxb-", "T"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1W"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "${1}W"))
}
// -T-T-
// --xx-
// ---
// -W-xxW-
func (*Regexp) ReplaceAllFunc
func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
ReplaceAllLiteral返回src的一个拷贝，将src中所有re的匹配结果（设为matched）都替换为repl(matched)。repl返回的切片被直接使用，不会使用Expand进行扩展。
func (*Regexp) ReplaceAllStringFunc
func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string
ReplaceAllLiteral返回src的一个拷贝，将src中所有re的匹配结果（设为matched）都替换为repl(matched)。repl返回的字符串被直接使用，不会使用Expand进行扩展。
- syntax
syntax
syntax包将正则表达式解析为解析树，并将解析树编译为程序。 大多数正则表达式客户端将使用软件包regexp的功能（例如Compile and Match）而不是此软件包。
Syntax
使用Perl标志进行解析时，此程序包可以理解的正则表达式语法如下。 通过将替代标志传递给Parse，可以禁用语法的某些部分。
单个字符：
. any character, possibly including newline (flag s=true)
[xyz] character class
[^xyz] negated character class
\d Perl character class
\D negated Perl character class
[[:alpha:]] ASCII character class
[[:^alpha:]] negated ASCII character class
\pN Unicode character class (one-letter name)
\p{Greek} Unicode character class
\PN negated Unicode character class (one-letter name)
\P{Greek} negated Unicode character class
复合型:
xy x followed by y
x|y x or y (prefer x)
重复:
x* zero or more x, prefer more
x+ one or more x, prefer more
x? zero or one x, prefer one
x{n,m} n or n+1 or ... or m x, prefer more
x{n,} n or more x, prefer more
x{n} exactly n x
x*? zero or more x, prefer fewer
x+? one or more x, prefer fewer
x?? zero or one x, prefer zero
x{n,m}? n or n+1 or ... or m x, prefer fewer
x{n,}? n or more x, prefer fewer
x{n}? exactly n x
实现限制：计数形式x {n，m}，x {n，}和x {n}拒绝创建重复次数超过1000的最小或最大重复形式。无限制重复不受此限制。
组合:
(re) numbered capturing group (submatch)
(?P<name>re) named & numbered capturing group (submatch)
(?:re) non-capturing group
(?flags) set flags within current group; non-capturing
(?flags:re) set flags during re; non-capturing
Flag syntax is xyz (set) or -xyz (clear) or xy-z (set xy, clear z). The flags are:
i case-insensitive (default false)
m multi-line mode: ^ and $ match begin/end line in addition to begin/end text (default false)
s let . match \n (default false)
U ungreedy: swap meaning of x* and x*?, x+ and x+?, etc (default false)
空字符串:
^ at beginning of text or line (flag m=true)
$ at end of text (like \z not Perl's \Z) or line (flag m=true)
\A at beginning of text
\b at ASCII word boundary (\w on one side and \W, \A, or \z on the other)
\B not at ASCII word boundary
\z at end of text
转义序列：
\a bell (== \007)
\f form feed (== \014)
\t horizontal tab (== \011)
\n newline (== \012)
\r carriage return (== \015)
\v vertical tab character (== \013)
\* literal *, for any punctuation character *
\123 octal character code (up to three digits)
\x7F hex character code (exactly two digits)
\x{10FFFF} hex character code
\Q...\E literal text ... even if ... has punctuation
角色类元素：
x single character
A-Z character range (inclusive)
\d Perl character class
[:foo:] ASCII character class foo
\p{Foo} Unicode character class Foo
\pF Unicode character class F (one-letter name)
将字符类命名为字符类元素：
[\d] digits (== \d)
[^\d] not digits (== \D)
[\D] not digits (== \D)
[^\D] not not digits (== \d)
[[:name:]] named ASCII class inside character class (== [:name:])
[^[:name:]] named ASCII class inside negated character class (== [:^name:])
[\p{Name}] named Unicode property inside character class (== \p{Name})
[^\p{Name}] named Unicode property inside negated character class (== \P{Name})
Perl字符类（所有仅ASCII）：
\d digits (== [0-9])
\D not digits (== [^0-9])
\s whitespace (== [\t\n\f\r ])
\S not whitespace (== [^\t\n\f\r ])
\w word characters (== [0-9A-Za-z_])
\W not word characters (== [^0-9A-Za-z_])
ASCII字符类：
[[:alnum:]] alphanumeric (== [0-9A-Za-z])
[[:alpha:]] alphabetic (== [A-Za-z])
[[:ascii:]] ASCII (== [\x00-\x7F])
[[:blank:]] blank (== [\t ])
[[:cntrl:]] control (== [\x00-\x1F\x7F])
[[:digit:]] digits (== [0-9])
[[:graph:]] graphical (== [!-~] == [A-Za-z0-9!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])
[[:lower:]] lower case (== [a-z])
[[:print:]] printable (== [ -~] == [ [:graph:]])
[[:punct:]] punctuation (== [!-/:-@[-`{-~])
[[:space:]] whitespace (== [\t\n\v\f\r ])
[[:upper:]] upper case (== [A-Z])
[[:word:]] word characters (== [0-9A-Za-z_])
[[:xdigit:]] hex digit (== [0-9A-Fa-f])
func IsWordChar
func IsWordChar(r rune) bool
IsWordChar报告在\ b和\ B零宽度断言的评估期间r是否被视为“单词字符”。 这些断言仅是ASCII：字字符为[A-Za-z0-9_]。
type EmptyOp
type EmptyOp uint8
EmptyOp指定零宽度断言的一种或混合形式。
const (
EmptyBeginLine EmptyOp = 1 << iota
EmptyEndLine
EmptyBeginText
EmptyEndText
EmptyWordBoundary
EmptyNoWordBoundary
)
func EmptyOpContext
func EmptyOpContext(r1, r2 rune) EmptyOp
EmptyOpContext返回在符文r1和r2之间的位置处满足的零宽度断言。 传递r1 == -1表示该位置位于文本的开头。 传递r2 == -1表示该位置在文本的结尾。
type Error
type Error struct {
Code ErrorCode
Expr string
}
Error描述了无法解析正则表达式并给出有问题的表达式。
func (*Error) Error
func (e *Error) Error() string
type ErrorCode
type ErrorCode string
ErrorCode描述了解析正则表达式的失败。
const (
// Unexpected error
ErrInternalError ErrorCode = "regexp/syntax: internal error"
// Parse errors
ErrInvalidCharClass ErrorCode = "invalid character class"
ErrInvalidCharRange ErrorCode = "invalid character class range"
ErrInvalidEscape ErrorCode = "invalid escape sequence"
ErrInvalidNamedCapture ErrorCode = "invalid named capture"
ErrInvalidPerlOp ErrorCode = "invalid or unsupported Perl syntax"
ErrInvalidRepeatOp ErrorCode = "invalid nested repetition operator"
ErrInvalidRepeatSize ErrorCode = "invalid repeat count"
ErrInvalidUTF8 ErrorCode = "invalid UTF-8"
ErrMissingBracket ErrorCode = "missing closing ]"
ErrMissingParen ErrorCode = "missing closing )"
ErrMissingRepeatArgument ErrorCode = "missing argument to repetition operator"
ErrTrailingBackslash ErrorCode = "trailing backslash at end of expression"
ErrUnexpectedParen ErrorCode = "unexpected )"
)
func (ErrorCode) String
func (e ErrorCode) String() string
type Flags
type Flags uint16
Flags控制解析器的行为并记录有关regexp上下文的信息。
const (
FoldCase Flags = 1 << iota // case-insensitive match
Literal // treat pattern as literal string
ClassNL // allow character classes like [^a-z] and [[:space:]] to match newline
DotNL // allow . to match newline
OneLine // treat ^ and $ as only matching at beginning and end of text
NonGreedy // make repetition operators default to non-greedy
PerlX // allow Perl extensions
UnicodeGroups // allow \p{Han}, \P{Han} for Unicode group and negation
WasDollar // regexp OpEndText was $, not \z
Simple // regexp contains no counted repetition
MatchNL = ClassNL | DotNL
Perl = ClassNL | OneLine | PerlX | UnicodeGroups // as close to Perl as possible
POSIX Flags = 0 // POSIX syntax
)
type Inst
type Inst struct {
Op InstOp
Out uint32 // all but InstMatch, InstFail
Arg uint32 // InstAlt, InstAltMatch, InstCapture, InstEmptyWidth
Rune []rune
}
Inst是正则表达式程序中的一条指令。
func (*Inst) MatchEmptyWidth
func (i *Inst) MatchEmptyWidth(before rune, after rune) bool
MatchEmptyWidth报告指令在前后符文之间是否匹配空字符串。 仅当i.Op == InstEmptyWidth时才应调用它。
func (*Inst) MatchRune
func (i *Inst) MatchRune(r rune) bool
MatchRune报告指令是否匹配（并消耗）r。 仅当i.Op == InstRune时才应调用它。
func (*Inst) MatchRunePos
func (i *Inst) MatchRunePos(r rune) int
MatchRunePos检查指令是否匹配（并使用）r。 如果是这样，则MatchRunePos返回匹配的符文对的索引（或者，当len（i.Rune）== 1时，符文单例）。 如果不是，则MatchRunePos返回-1。 仅当i.Op == InstRune时才调用MatchRunePos。
func (*Inst) String
func (i *Inst) String() string
type InstOp
type InstOp uint8
InstOp是指令操作码。
const (
InstAlt InstOp = iota
InstAltMatch
InstCapture
InstEmptyWidth
InstMatch
InstFail
InstNop
InstRune
InstRune1
InstRuneAny
InstRuneAnyNotNL
)
func (InstOp) String
func (i InstOp) String() string
type Op
type Op uint8
Op是单个正则表达式运算符。
const (
OpNoMatch Op = 1 + iota // matches no strings
OpEmptyMatch // matches empty string
OpLiteral // matches Runes sequence
OpCharClass // matches Runes interpreted as range pair list
OpAnyCharNotNL // matches any character except newline
OpAnyChar // matches any character
OpBeginLine // matches empty string at beginning of line
OpEndLine // matches empty string at end of line
OpBeginText // matches empty string at beginning of text
OpEndText // matches empty string at end of text
OpWordBoundary // matches word boundary `\b`
OpNoWordBoundary // matches word non-boundary `\B`
OpCapture // capturing subexpression with index Cap, optional name Name
OpStar // matches Sub[0] zero or more times
OpPlus // matches Sub[0] one or more times
OpQuest // matches Sub[0] zero or one times
OpRepeat // matches Sub[0] at least Min times, at most Max (Max == -1 is no limit)
OpConcat // matches concatenation of Subs
OpAlternate // matches alternation of Subs
)
type Prog
type Prog struct {
Inst []Inst
Start int // index of start instruction
NumCap int // number of InstCapture insts in re
}
Prog是已编译的正则表达式程序。
func Compile
func Compile(re *Regexp) (*Prog, error)
Compile将正则表达式编译为要执行的程序。 regexp应该已经被简化了（从re.Simplify返回）。
func (*Prog) Prefix
func (p *Prog) Prefix() (prefix string, complete bool)
前缀返回一个文字字符串，所有与regexp匹配的内容都必须以该字符串开头。 如果前缀是整个匹配项，则Complete为true。
func (*Prog) StartCond
func (p *Prog) StartCond() EmptyOp
StartCond返回任何匹配项中必须为true的前导空白宽度条件。 如果没有匹配项，则返回^ EmptyOp（0）。
func (*Prog) String
func (p *Prog) String() string
type Regexp
type Regexp struct {
Op Op // operator
Flags Flags
Sub []*Regexp // subexpressions, if any
Sub0 [1]*Regexp // storage for short Sub
Rune []rune // matched runes, for OpLiteral, OpCharClass
Rune0 [2]rune // storage for short Rune
Min, Max int // min, max for OpRepeat
Cap int // capturing index, for OpCapture
Name string // capturing name, for OpCapture
}
Regexp是正则表达式语法树中的一个节点。
func Parse
func Parse(s string, flags Flags) (*Regexp, error)
Parse解析由指定的Flags控制的正则表达式字符串s，并返回一个正则表达式解析树。 语法在顶级注释中描述。
func (*Regexp) CapNames
func (re *Regexp) CapNames() []string
CapNames使用正则表达式查找捕获组的名称。
func (*Regexp) Equal
func (x *Regexp) Equal(y *Regexp) bool
如果x和y具有相同的结构，则Equal返回true。
func (*Regexp) MaxCap
func (re *Regexp) MaxCap() int
MaxCap使用正则表达式查找最大捕获索引。
func (*Regexp) Simplify
func (re *Regexp) Simplify() *Regexp
Simplify返回与re等效的正则表达式，但不计算重复次数，并具有各种其他简化形式，例如将/(?:a+)+/重写为/a+/。 生成的正则表达式将正确执行，但是其字符串表示形式将不会产生相同的解析树，因为捕获括号可能已被复制或删除。 例如，/(x){1,2}/的简化形式为 /(x)(x)?/，但是两个括号都捕获为$1。 返回的正则表达式可以与原始结构共享或为原始结构。
func (*Regexp) String
func (re *Regexp) String() string
网友评论