正则表达式 | regexp

• import "regexp"

• 概述

• 索引

• Examples

• 子目录

概述

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

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

go doc regexp/syntax

这个包提供的正则表达式实现保证在输入大小的时间线性运行。（这是一个不受大多数​​正则表达式的开源实现保证的属性。）有关此属性的更多信息，请参阅

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

或任何有关自动化理论的书。

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

有16种 Regexp 方法匹配正则表达式并识别匹配的文本。他们的名字与这个正则表达式相匹配：

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

如果存在“全部”，则该例程匹配整个表达式的连续的非重叠匹配。忽略与先前匹配相邻的空匹配。返回值是一个包含相应的非“全部”例程的连续返回值的片段。这些例程需要一个额外的整数参数 n ；如果 n>= 0 ，该函数最多返回 n 个匹配/子匹配。

如果'String'存在，则参数是一个字符串; 否则它是一个字节片； 返回值会根据情况进行调整。

如果存在“Submatch”，则返回值是标识表达式的连续子匹配的片。子匹配是正则表达式内的带圆括号的子表达式（也称为捕获组）的匹配项，按左括号顺序从左到右编号。Submatch 0是整个表达式的匹配，submatch 1是第一个加括号的子表达式的匹配，依此类推。

如果存在'索引'，匹配和子匹配由输入字符串内的字节索引对标识：result2 * n：2 * n + 1标识第 n 个子匹配的索引。n == 0的对表示整个表达式的匹配。如果'索引'不存在，则匹配由匹配/子匹配的文本识别。如果索引是负数，则意味着子表达式与输入中的任何字符串都不匹配。

还有一些方法可以应用于从 RuneReader 中读取文本：

MatchReader, FindReaderIndex, FindReaderSubmatchIndex

这个集合可能会增长。请注意，正则表达式匹配可能需要检查文本超出匹配返回的文本，因此符合 RuneReader 的文本的方法可能会在返回之前任意读入输入。

（还有一些其他方法与此模式不匹配。）

例

package main

import (
	"fmt"
	"regexp"
)

func main() {
	// Compile the expression once, usually at init time.
	// Use raw strings to avoid having to quote the backslashes.
	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"))
}

索引

• 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

MatchString

Regexp.FindAllString

Regexp.FindAllStringSubmatch

Regexp.FindAllStringSubmatchIndex

Regexp.FindString

Regexp.FindStringIndex

Regexp.FindStringSubmatch

Regexp.MatchString

Regexp.ReplaceAllLiteralString

Regexp.ReplaceAllString

Regexp.Split

Regexp.SubexpNames

文件包

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

func Match（显示源文件）

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

匹配检查文本正则表达式是否与字节片匹配。更复杂的查询需要使用 Compile 和完整的 Regexp 接口。

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 检查文本正则表达式是否匹配字符串。更复杂的查询需要使用 Compile 和完整的 Regexp 接口。

例

package main

import (
	"fmt"
	"regexp"
)

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)
}

func QuoteMeta（显示源文件）

func QuoteMeta(s string) string

QuoteMeta 返回一个字符串，它引用参数文本中的所有正则表达式元字符； 返回的字符串是一个匹配文本文本的正则表达式。例如，QuoteMeta（[foo]）返回\[foo\]。

type Regexp（显示源文件）

正则表达式是已编译正则表达式的表示形式。除了配置方法（如Longest）之外，Regexp 可以安全地用于多个 goroutine 的并发使用。

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） 语法，并将匹配语义更改为最长。

也就是说，当匹配文本时，正则表达式会返回一个尽可能早在输入中开始的匹配（最左边），并且在它们之间选择尽可能长的匹配。这种所谓的最左边最长匹配与早期正则表达式实现使用和 POSIX 指定的语义相同。

但是，可以有多个最左边最长的匹配，具有不同的匹配选项，并且此包与 POSIX 不同。在可能的最左边最长的匹配中，这个包选择一个回溯搜索首先找到的那个，而 POSIX 指定匹配被选择为最大化第一个子表达的长度，然后第二个等等从左到右。POSIX 规则在计算上是禁止的，甚至没有明确定义。有关详细信息，请参阅http://swtch.com/~rsc/regexp/regexp2.html#posix。

func MustCompile（显示源文件）

func MustCompile(str string) *Regexp

MustCompile 就像编译，但如果表达式不能被解析就会发生混乱。它简化了保存已编译正则表达式的全局变量的安全初始化。

func MustCompilePOSIX（显示源文件）

func MustCompilePOSIX(str string) *Regexp

MustCompilePOSIX 与 CompilePOSIX 类似，但如果表达式无法解析，则会发生混乱。它简化了保存已编译正则表达式的全局变量的安全初始化。

func (*Regexp) Copy（显示源文件）

func (re *Regexp) Copy() *Regexp

复制返回从 re 复制的新 Regexp 对象。

在多个 goroutine 中使用正则表达式时，给每个 goroutine 自己的副本有助于避免锁定争用。

func (*Regexp) Expand（显示源文件）

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

展开将模板附加到 dst 并返回结果; 在追加期间，Expand 使用从 src 中抽取的相应匹配替换模板中的变量。匹配切片应该由 FindSubmatchIndex 返回。

在模板中，变量由 $ name 或 $ {name} 形式的子字符串表示，其中 name 是字母，数字和下划线的非空序列。像 $ 1 这样的纯数字名称指的是具有相应索引的子匹配; 其他名称指的是捕获用（？P <name> ...）语法命名的括号。对超出范围或不匹配的索引或正则表达式中不存在的名称的引用将替换为空片段。

在 $ name 表单中，姓名应尽可能长：$ 1x等同于$ {1x}，而不是$ {1} x，而$ 10等同于$ {10}，而不是$ {1} 0 。

要在输出中插入文字$，请在模板中使用$$。

func (*Regexp) ExpandString（显示源文件）

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

ExpandString 与 Expand 类似，但模板和源代码都是字符串。它附加并返回一个字节片段，以便调用代码控制分配。

func (*Regexp) Find（显示源文件）

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

查找返回一个片段，其中包含正则表达式b中最左边匹配的文本。返回值 nil 表示不匹配。

func (*Regexp) FindAll（显示源文件）

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

FindAll 是 Find 的所有版本；它返回表达式的所有连续匹配的一部分，如包注释中的 'All' 描述所定义。返回值 nil 表示不匹配。

func (*Regexp) FindAllIndex（显示源文件）

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

FindAllIndex 是 FindIndex 的 'All' 版本; 它返回表达式的所有连续匹配的一部分，如包注释中的 'All' 描述所定义。返回值 nil 表示不匹配。

func (*Regexp) FindAllString（显示源文件）

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

FindAllString 是 FindString 的 'All'版本；它返回表达式的所有连续匹配的一部分，如包注释中的 'All' 描述所定义。返回值 nil 表示不匹配。

例

package main

import (
	"fmt"
	"regexp"
)

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))
}

func (*Regexp) FindAllStringIndex（显示源文件）

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

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

func (*Regexp) FindAllStringSubmatch（显示源文件）

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

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

例

package main

import (
	"fmt"
	"regexp"
)

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))
}

func (*Regexp) FindAllStringSubmatchIndex（显示源文件）

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

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

例

package main

import (
	"fmt"
	"regexp"
)

func main() {
	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))
}

func (*Regexp) FindAllSubmatch（显示源文件）

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

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

func (*Regexp) FindAllSubmatchIndex（显示源文件）

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

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

func (*Regexp) FindIndex（显示源文件）

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

FindIndex 返回一个两个元素的整数切片，用于定义正则表达式 b 中最左边匹配的位置。匹配本身在 b [loc0：loc1]。返回值 nil 表示不匹配。

func (*Regexp) FindReaderIndex（显示源文件）

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

FindReaderIndex 返回一个由元素组成的双元素切片，用于定义从 RuneReader 读取的文本中正则表达式最左边匹配的位置。在字节偏移量 loc0 到 loc1-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 。

例

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile("foo.?")
	fmt.Printf("%q\n", re.FindString("seafood fool"))
	fmt.Printf("%q\n", re.FindString("meat"))
}

func (*Regexp) FindStringIndex（显示源文件）

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

FindStringIndex 返回一个整数的两个元素切片，用于定义正则表达式的 s 中最左边匹配的位置。匹配本身在 s [loc0：loc1] 。返回值 nil 表示不匹配。

例

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile("ab?")
	fmt.Println(re.FindStringIndex("tablett"))
	fmt.Println(re.FindStringIndex("foo") == nil)
}

func (*Regexp) FindStringSubmatch（显示源文件）

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

FindStringSubmatch 返回一段字符串，其中包含 s 中正则表达式最左边匹配的文本以及其子表达式的匹配（如果有），如反馈中的 'Submatch' 描述所定义。返回值 nil 表示不匹配。

例

package main

import (
	"fmt"
	"regexp"
)

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-"))
}

func (*Regexp) FindStringSubmatchIndex（显示源文件）

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

FindStringSubmatchIndex 返回一个片段，它持有标识 s 中正则表达式的最左边匹配的索引对，以及它的子表达式的匹配（如果有的话），如包注释中的 'Submatch' 和 'Index' 描述所定义的。返回值 nil 表示不匹配。

func (*Regexp) FindSubmatch（显示源文件）

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

FindSubmatch 返回一片切片，其中包含 b 中正则表达式最左边匹配的文本以及其子表达式的匹配（如果有），如包注释中的 'Submatch' 描述所定义。返回值 nil 表示不匹配。

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 的任何匹配。如果文字字符串包含整个正则表达式，它将返回 boolean 值 true 。

func (*Regexp) Longest（显示源文件）

func (re *Regexp) Longest()

最长使得未来的搜索更喜欢最左边最长的匹配。也就是说，当匹配文本时，正则表达式会返回一个尽可能早在输入中开始的匹配（最左边），并且在它们之间选择尽可能长的匹配。此方法修改正则表达式，可能不会与任何其他方法同时调用。

func (*Regexp) Match（显示源文件）

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

匹配报告正则表达式匹配字节片段 b 。

func (*Regexp) MatchReader（显示源文件）

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

MatchReader 报告正则表达式是否匹配由符文阅读器读取的文本。

func (*Regexp) MatchString（显示源文件）

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

MatchString 报告 Regexp 是否匹配字符串 s 。

例

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile("(gopher){2}")
	fmt.Println(re.MatchString("gopher"))
	fmt.Println(re.MatchString("gophergopher"))
	fmt.Println(re.MatchString("gophergophergopher"))
}

func (*Regexp) NumSubexp（显示源文件）

func (re *Regexp) NumSubexp() int

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

func (*Regexp) ReplaceAll（显示源文件）

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

ReplaceAll 返回 src 的一个副本，用替换文本 repl 替换正则表达式的匹配。在内部 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 的一个副本，将 Regexp 的匹配替换为替换字节 repl 。替换 repl 被直接替换，而不使用 Expand 。

func (*Regexp) ReplaceAllLiteralString（显示源文件）

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

ReplaceAllLiteralString 返回 src 的副本，用替换字符串 repl 替换 Regexp 的匹配项。替换 repl 被直接替换，而不使用 Expand 。

例

package main

import (
	"fmt"
	"regexp"
)

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}"))
}

func (*Regexp) ReplaceAllString（显示源文件）

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

ReplaceAllString 返回 src 的副本，用替换字符串 repl 替换正则表达式的匹配项。在内部 repl 中，$ 符号被解释为在 Expand 中，因此例如 $ 1 代表第一个子匹配的文本。

例

package main

import (
	"fmt"
	"regexp"
)

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"))
}

func (*Regexp) ReplaceAllStringFunc（显示源文件）

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

ReplaceAllStringFunc 返回一个 src 的副本，其中 Regexp 的所有匹配已被替换为应用于匹配子字符串的函数 repl 的返回值。由 repl 返回的替换被直接替换，而不使用 Expand 。

func (*Regexp) Split（显示源文件）

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

将切片 s 分割成由表达式分隔的子字符串，并在这些表达式匹配之间返回一个子字符串片段。

此方法返回的片包含所有没有包含在由 FindAllString 返回的片中的子串。当调用一个不包含元字符的表达式时，它相当于 strings.SplitN 。

例：

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

例

package main

import (
	"fmt"
	"regexp"
)

func main() {
	a := regexp.MustCompile("a")
	fmt.Println(a.Split("banana", -1))
	fmt.Println(a.Split("banana", 0))
	fmt.Println(a.Split("banana", 1))
	fmt.Println(a.Split("banana", 2))
	zp := regexp.MustCompile("z+")
	fmt.Println(zp.Split("pizza", -1))
	fmt.Println(zp.Split("pizza", 0))
	fmt.Println(zp.Split("pizza", 1))
	fmt.Println(zp.Split("pizza", 2))
}

func (*Regexp) String（显示源文件）

func (re *Regexp) String() string

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

func (*Regexp) SubexpNames（显示源文件）

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

SubexpNames 返回此 Regexp 中带括号的子表达式的名称。第一个子表达式的名称是 names1 ，因此如果 m 是匹配片，则 mi 的名称是 SubexpNames（）i 。由于整个正则表达式不能被命名，names0 总是空字符串。slice 不应该被修改。

例

package main

import (
	"fmt"
	"regexp"
)

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))
}

子目录

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

	正则表达式 | regexp
	正则表达式 | regexp	详细
	regexp/syntax	详细