Golang标准库——regexp

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

regexp

regexp包实现了正则表达式搜索。

正则表达式采用RE2语法(除了\c、\C),和Perl、Python等语言的正则基本一致。

参见http://code.google.com/p/re2/wiki/Syntax

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规则计算困难,甚至没有良好定义。

参见http://swtch.com/~rsc/regexp/regexp2.html#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}的字符串,其中name是长度>0的字母、数字和下划线的序列。一个单纯的数字字符名如$1会作为捕获分组的数字索引;其他的名字对应(?P<name>...)语法产生的命名捕获分组的名字。超出范围的数字索引、索引对应的分组未匹配到文本、正则表达式中未出现的分组名,都会被替换为空切片。

name格式的变量名,name会尽可能取最长序列:1x等价于{1x}而非{1}x,10等价于{10}而非{1}0。因此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中的''符号会按照Expand方法的规则进行解释和替换,例如1会被替换为第一个分组匹配结果。

func (*Regexp) ReplaceAllString

func (re *Regexp) ReplaceAllString(src, repl string) string

ReplaceAllLiteral返回src的一个拷贝,将src中所有re的匹配结果都替换为repl。在替换时,repl中的''符号会按照Expand方法的规则进行解释和替换,例如1会被替换为第一个分组匹配结果。

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

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

本文来自:简书

感谢作者:DevilRoshan

查看原文:Golang标准库——regexp

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

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