Package regexp

Overview ▾

软件包regexp实现了正则表达式搜索.

接受的正则表达式的语法与Perl,Python和其他语言使用的常规语法相同. 更确切地说,它是RE2接受的语法,并在https://golang.org/s/re2syntax中进行了描述,除了\ C. 有关语法的概述,请运行

go doc regexp/syntax

此包提供的regexp实现保证在输入大小的时间上线性运行. (这是大多数正则表达式的开源实现不能保证的属性.)有关此属性的更多信息,请参见

https://swtch.com/~rsc/regexp/regexp1.html

或有关自动机理论的任何书籍.

所有字符都是UTF-8编码的代码点.

有16种正则表达式匹配正则表达式并标识匹配文本的方法. 它们的名称与此正则表达式匹配:

Find(All)?(String)?(Submatch)?(Index)?

如果存在"全部",则例程将匹配整个表达式的连续不重叠匹配. 与之前的比赛相邻的空比赛将被忽略. 返回值是一个切片,其中包含相应的非" All"例程的连续返回值. 这些例程使用一个额外的整数参数n. 如果n> = 0,则该函数最多返回n个匹配项/子匹配项; 否则,将返回所有这些.

如果存在"字符串",则参数为字符串; 否则,它是一个字节的片段; 返回值会适当调整.

如果存在"子匹配",则返回值是一个片,用于标识表达式的连续子匹配. 子匹配是正则表达式中带括号的子表达式(也称为捕获组)的匹配,按左括号的顺序从左到右编号. 子匹配0是整个表达式的匹配项,子匹配1是第一个带括号的子表达式的匹配项,依此类推.

如果存在'Index',则匹配项和子匹配项由输入字符串中的字节索引对标识:result [2 * n:2 * n + 1]标识第n个子匹配项的索引. n == 0的对表示整个表达式的匹配. 如果不存在"索引",则通过匹配/子匹配的文本识别匹配. 如果索引为负或文本为nil,则意味着子表达式与输入中的任何字符串都不匹配. 对于"字符串"版本,空字符串表示不匹配或空匹配.

还有一些方法的子集可应用于从RuneReader读取的文本:

MatchReader, FindReaderIndex, FindReaderSubmatchIndex

这个集合可能会增长. 请注意,正则表达式匹配可能需要检查匹配返回的文本之外的文本,因此匹配来自RuneReader的文本的方法可能会在返回之前任意读取输入内容.

(还有一些其他方法与此模式不匹配.)

Example

true
true
false
false

Index ▾

func Match(pattern string, b []byte) (matched bool, err error)
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
func MatchString(pattern string, s string) (matched bool, err error)
func QuoteMeta(s string) string
type Regexp
    func Compile(expr string) (*Regexp, error)
    func CompilePOSIX(expr string) (*Regexp, error)
    func MustCompile(str string) *Regexp
    func MustCompilePOSIX(str string) *Regexp
    func (re *Regexp) Copy() *Regexp
    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
    func (re *Regexp) Find(b []byte) []byte
    func (re *Regexp) FindAll(b []byte, n int) [][]byte
    func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
    func (re *Regexp) FindAllString(s string, n int) []string
    func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
    func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string
    func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
    func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
    func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
    func (re *Regexp) FindIndex(b []byte) (loc []int)
    func (re *Regexp) FindReaderIndex(r io.RuneReader) (loc []int)
    func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int
    func (re *Regexp) FindString(s string) string
    func (re *Regexp) FindStringIndex(s string) (loc []int)
    func (re *Regexp) FindStringSubmatch(s string) []string
    func (re *Regexp) FindStringSubmatchIndex(s string) []int
    func (re *Regexp) FindSubmatch(b []byte) [][]byte
    func (re *Regexp) FindSubmatchIndex(b []byte) []int
    func (re *Regexp) LiteralPrefix() (prefix string, complete bool)
    func (re *Regexp) Longest()
    func (re *Regexp) Match(b []byte) bool
    func (re *Regexp) MatchReader(r io.RuneReader) bool
    func (re *Regexp) MatchString(s string) bool
    func (re *Regexp) NumSubexp() int
    func (re *Regexp) ReplaceAll(src, repl []byte) []byte
    func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
    func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte
    func (re *Regexp) ReplaceAllLiteralString(src, repl string) string
    func (re *Regexp) ReplaceAllString(src, repl string) string
    func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string
    func (re *Regexp) Split(s string, n int) []string
    func (re *Regexp) String() string
    func (re *Regexp) SubexpNames() []string

Package files

backtrack.go exec.go onepass.go regexp.go

func Match

func Match(pattern string, b []byte) (matched bool, err error)

匹配报告字节切片b是否包含正则表达式模式的任何匹配. 更复杂的查询需要使用Compile和完整的Regexp接口.

Example

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报告RuneReader返回的文本是否包含正则表达式模式的任何匹配项. 更复杂的查询需要使用Compile和完整的Regexp接口.

func MatchString

func MatchString(pattern string, s string) (matched bool, err error)

MatchString报告字符串s是否包含任何正则表达式模式的匹配项. 更复杂的查询需要使用Compile和完整的Regexp接口.

Example

true <nil>
false <nil>
false error parsing regexp: missing closing ): `a(b`

func QuoteMeta

func QuoteMeta(s string) string

QuoteMeta返回一个字符串,该字符串对参数文本内的所有正则表达式元字符进行转义. 返回的字符串是与文字文本匹配的正则表达式.

Example

Escaping symbols like: \.\+\*\?\(\)\|\[\]\{\}\^\$

type Regexp

Regexp是已编译正则表达式的表示. Regexp可安全地供多个goroutine并发使用,但配置方法(例如Longest)除外.

type Regexp struct {
    // contains filtered or unexported fields
}

func Compile

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

编译将解析正则表达式,如果成功,则返回可用于与文本匹配的Regexp对象.

当与文本匹配时,正则表达式会返回一个匹配项,该匹配项应尽早在输入中(最左侧)开始,并且在匹配项中,它选择一个回溯搜索将首先找到的匹配项. 这种所谓的"最左边优先匹配"与Perl,Python和其他实现使用的语义相同,尽管此程序包实现了它而没有回溯的代价. 有关POSIX最左最长的匹配,请参见CompilePOSIX.

func CompilePOSIX

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

CompilePOSIX与Compile类似,但将正则表达式限制为POSIX ERE(egrep)语法,并将匹配语义更改为最左最长.

也就是说,当与文本进行匹配时,regexp返回一个匹配项,该匹配项尽早在输入中(最左侧)开始,并且在其中选择一个尽可能长的匹配项. 所谓的最左最长匹配与POSIX指定的早期正则表达式实现所使用的语义相同.

但是,可以有多个最左最长的匹配项,具有不同的子匹配项选择,并且此程序包与POSIX不同. 在可能的最左最长的匹配项中,此程序包选择一个将首先找到回溯搜索的匹配项,而POSIX指定选择该匹配项以最大化第一个子表达式的长度,然后最大化第二个子表达式的长度,依此类推,从左到右. POSIX规则在计算上是禁止的,甚至定义不明确. 有关详细信息,请参见https://swtch.com/~rsc/regexp/regexp2.html#posix .

func MustCompile

func MustCompile(str string) *Regexp

MustCompile类似于Compile,但如果无法解析该表达式,则会发生恐慌. 它简化了保存已编译正则表达式的全局变量的安全初始化.

func MustCompilePOSIX

func MustCompilePOSIX(str string) *Regexp

MustCompilePOSIX类似于CompilePOSIX,但是如果无法解析该表达式,则会出现混乱. 它简化了保存已编译正则表达式的全局变量的安全初始化.

func (*Regexp) Copy 1.6

func (re *Regexp) Copy() *Regexp

Copy返回从re复制的新Regexp对象. 在一个副本上调用最长不会影响另一副本.

不推荐使用:在早期版本中,当在多个goroutine中使用Regexp时,为每个goroutine提供自己的副本有助于避免锁争用. 从Go 1.12开始,不再需要使用Copy来避免锁争用. 如果使用复印件的原因是要使用不同的最长设置制作两份复印件,则该复印件仍然适用.

func (*Regexp) Expand

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

展开将模板附加到dst并返回结果; 在追加过程中,Expand将模板中的变量替换为从src提取的匹配项. 匹配片应该已经由FindSubmatchIndex返回.

In the template, a variable is denoted by a substring of the form $name or ${name}, where name is a non-empty sequence of letters, digits, and underscores. A purely numeric name like $1 refers to the submatch with the corresponding index; other names refer to capturing parentheses named with the (?P<name>...) syntax. A reference to an out of range or unmatched index or a name that is not present in the regular expression is replaced with an empty slice.

在$ name形式中,名称被认为是尽可能长的:$ 1x等效于$ {1x},而不是$ {1} x,并且$ 10等效于$ {10},而不是$ {1} 0 .

要在输出中插入文字$,请在模板中使用$$.

Example

option1=value1
option2=value2
option3=value3

func (*Regexp) ExpandString

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

ExpandString类似于Expand,但是模板和源是字符串. 它附加并返回一个字节片,以便给予调用代码对分配的控制.

Example

option1=value1
option2=value2
option3=value3

func (*Regexp) Find

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

Find返回一个切片,该切片包含正则表达式b中最左边匹配的文本. 返回值nil表示不匹配.

Example

"food"

func (*Regexp) FindAll

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

FindAll是Find的"全部"版本; 它返回表达式的所有连续匹配的一部分,如包注释中的"全部"描述所定义. 返回值nil表示不匹配.

Example

["food" "fool"]

func (*Regexp) FindAllIndex

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

FindAllIndex is the 'All' version of FindIndex; it returns a slice of all successive matches of the expression, as defined by the 'All' description in the package comment. A return value of nil indicates no match.

func (*Regexp) FindAllString

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

FindAllString是FindString的"全部"版本; 它返回表达式的所有连续匹配的一部分,如包注释中的"全部"描述所定义. 返回值nil表示不匹配.

Example

[ar an al]
[ar an]
[aa]
[]

func (*Regexp) FindAllStringIndex

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

FindAllStringIndex是FindStringIndex的"全部"版本; 它返回表达式的所有连续匹配的一部分,如包注释中的"全部"描述所定义. 返回值nil表示不匹配.

func (*Regexp) FindAllStringSubmatch

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

FindAllStringSubmatch是FindStringSubmatch的"全部"版本; 它返回表达式的所有连续匹配的一部分,如包注释中的"全部"描述所定义. 返回值nil表示不匹配.

Example

[["ab" ""]]
[["axxb" "xx"]]
[["ab" ""] ["axb" "x"]]
[["axxb" "xx"] ["ab" ""]]

func (*Regexp) FindAllStringSubmatchIndex

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

FindAllStringSubmatchIndex是FindStringSubmatchIndex的"全部"版本; 它返回表达式的所有连续匹配的一部分,如包注释中的"全部"描述所定义. 返回值nil表示不匹配.

Example

[[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) FindAllSubmatch

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

FindAllSubmatch是FindSubmatch的"全部"版本; 它返回表达式的所有连续匹配的一部分,如包注释中的"全部"描述所定义. 返回值nil表示不匹配.

Example

[["food" "d"] ["fool" "l"]]

func (*Regexp) FindAllSubmatchIndex

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

FindAllSubmatchIndex是FindSubmatchIndex的"全部"版本; 它返回表达式的所有连续匹配的一部分,如包注释中的"全部"描述所定义. 返回值nil表示不匹配.

Example

[18 33 18 25 27 33]
option1: value1
option1
value1
[35 50 35 42 44 50]
option2: value2
option2
value2

func (*Regexp) FindIndex

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

FindIndex返回一个由两个元素组成的整数切片,用于定义正则表达式b中最左边的匹配项的位置. 匹配项本身位于b [loc [0]:loc [1]]. 返回值nil表示不匹配.

Example

[18 33]
option1: value1

func (*Regexp) FindReaderIndex

func (re *Regexp) FindReaderIndex(r io.RuneReader) (loc []int)

FindReaderIndex返回一个由两个元素组成的整数切片,用于定义从RuneReader读取的文本中正则表达式最左侧匹配的位置. 在输入流中的字节偏移量loc [0]至loc [1] -1处找到匹配文本. 返回值nil表示不匹配.

func (*Regexp) FindReaderSubmatchIndex

func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int

FindReaderSubmatchIndex返回一个包含索引对的切片,该索引对标识RuneReader读取的文本正则表达式的最左匹配项,以及其子表达式(如果有的话)的匹配项(由包注释中的" Submatch"和" Index"描述定义) . 返回值nil表示不匹配.

func (*Regexp) FindString

func (re *Regexp) FindString(s string) string

FindString返回一个字符串,其中包含正则表达式s中最左边匹配的文本. 如果不匹配,则返回值为空字符串,但是如果正则表达式成功匹配空字符串,则返回值也为空. 如果有必要区分这些情况,请使用FindStringIndex或FindStringSubmatch.

Example

"food"
""

func (*Regexp) FindStringIndex

func (re *Regexp) FindStringIndex(s string) (loc []int)

FindStringIndex返回一个由两个元素组成的整数切片,用于定义正则表达式s中最左侧匹配项的位置. 匹配项本身位于s [loc [0]:loc [1]]. 返回值nil表示不匹配.

Example

[1 3]
true

func (*Regexp) FindStringSubmatch

func (re *Regexp) FindStringSubmatch(s string) []string

FindStringSubmatch返回一个字符串切片,其中包含s中正则表达式最左侧匹配的文本以及其子表达式的匹配项(如果有),如包注释中的" Submatch"描述所定义. 返回值nil表示不匹配.

Example

["axxxbyc" "xxx" "y"]
["abzc" "" "z"]

func (*Regexp) FindStringSubmatchIndex

func (re *Regexp) FindStringSubmatchIndex(s string) []int

FindStringSubmatchIndex returns a slice holding the index pairs identifying the leftmost match of the regular expression in s and the matches, if any, of its subexpressions, as defined by the 'Submatch' and 'Index' descriptions in the package comment. A return value of nil indicates no match.

func (*Regexp) FindSubmatch

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

FindSubmatch返回一个切片的切片,该切片包含b中正则表达式最左边匹配的文本以及其子表达式的匹配项(如果有),这由包注释中的" Submatch"描述定义. 返回值nil表示不匹配.

Example

["food" "d"]

func (*Regexp) FindSubmatchIndex

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

FindSubmatchIndex返回一个切片,该切片包含索引对,该索引对标识b中正则表达式的最左匹配及其子表达式的匹配项(如果有),这由包注释中的" Submatch"和" Index"描述定义. 返回值nil表示不匹配.

func (*Regexp) LiteralPrefix

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

LiteralPrefix返回一个文字字符串,该字符串必须以正则表达式re的任何匹配开头. 如果文字字符串包含整个正则表达式,则返回布尔值true.

func (*Regexp) Longest 1.1

func (re *Regexp) Longest()

最长使得将来的搜索更喜欢最长的匹配. 也就是说,当与文本进行匹配时,regexp返回一个匹配项,该匹配项尽早在输入中(最左侧)开始,并且在其中选择一个尽可能长的匹配项. 此方法修改了Regexp,不得与其他任何方法同时调用.

func (*Regexp) Match

func (re *Regexp) Match(b []byte) bool

匹配报告字节切片b是否包含正则表达式re的任何匹配.

Example

true

func (*Regexp) MatchReader

func (re *Regexp) MatchReader(r io.RuneReader) bool

MatchReader reports whether the text returned by the RuneReader contains any match of the regular expression re.

func (*Regexp) MatchString

func (re *Regexp) MatchString(s string) bool

MatchString报告字符串s是否包含正则表达式re的任何匹配项.

Example

false
true
true

func (*Regexp) NumSubexp

func (re *Regexp) NumSubexp() int

NumSubexp返回此正则表达式中带括号的子表达式的数量.

func (*Regexp) ReplaceAll

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

ReplaceAll返回src的副本,用替换文本repl替换Regexp的匹配项. 在repl内部,$符号的解释方式与Expand相同,例如$ 1表示第一个子匹配项的文本.

func (*Regexp) ReplaceAllFunc

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

ReplaceAllFunc返回src的副本,其中已将Regexp的所有匹配项替换为应用于匹配的字节片的函数repl的返回值. 由repl返回的替换将直接替换,而无需使用Expand.

func (*Regexp) ReplaceAllLiteral

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

ReplaceAllLiteral返回src的副本,用替换字节repl替换Regexp的匹配项. 替换repl被直接替换,而无需使用Expand.

func (*Regexp) ReplaceAllLiteralString

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

ReplaceAllLiteralString返回src的副本,用替换字符串repl替换Regexp的匹配项. 替换repl被直接替换,而无需使用Expand.

Example

-T-T-
-$1-$1-
-${1}-${1}-

func (*Regexp) ReplaceAllString

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

ReplaceAllString返回src的副本,用替换字符串repl替换Regexp的匹配项. 在repl内部,$符号的解释方式与Expand相同,例如$ 1表示第一个子匹配项的文本.

Example

-T-T-
--xx-
---
-W-xxW-

func (*Regexp) ReplaceAllStringFunc

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

ReplaceAllStringFunc返回src的副本,其中Regexp的所有匹配项都已替换为应用于匹配的子字符串的函数repl的返回值. 由repl返回的替换将直接替换,而无需使用Expand.

Example

SeaFooD FooL

func (*Regexp) Split 1.1

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

将片段s分割成由表达式分隔的子字符串,并返回这些表达式匹配之间的子字符串的片段.

此方法返回的切片由FindAllString返回的切片中未包含的s的所有子字符串组成. 在不包含任何元字符的表达式上调用时,它等效于strings.SplitN.

Example:

s := regexp.MustCompile("a*").Split("abaabaccadaaae", 5)
// s: ["", "b", "b", "c", "cadaaae"]

该计数确定要返回的子字符串的数量:

n > 0: at most n substrings; the last substring will be the unsplit remainder.
n == 0: the result is nil (zero substrings)
n < 0: all substrings

Example

[b n n ]
[]
[banana]
[b nana]
[pi a]
[]
[pizza]
[pi a]

func (*Regexp) String

func (re *Regexp) String() string

字符串返回用于编译正则表达式的源文本.

func (*Regexp) SubexpNames

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

SubexpNames返回此正则表达式中带括号的子表达式的名称. 第一个子表达式的名称为names [1],因此,如果m是匹配片,则m [i]的名称为SubexpNames()[i]. 由于不能对整个Regexp进行命名,所以names [0]始终是空字符串. 该切片不应修改.

Example

true
["" "first" "last"]
${last} ${first}
Turing Alan

Subdirectories

Name Synopsis
..
syntax 包语法将正则表达式解析为解析树,并将解析树编译为程序.

by  ICOPY.SITE