Regex (Регулярные выражения) в Go

Пакет Regex Go используется для поиска строк. Чтобы найти строку, нам нужно предоставить шаблон строки.

Нам нужно скомпилировать шаблон в объект regex, чтобы мы могли через него вызывать методы.

Для поиска регулярного выражения можно использовать функции compile() и mustcompile(). Теперь мы можем использовать функции для поиска строк, например FindString(), FindStringSubmatch(), FindStringIndex() и т.д.

Пример регулярного выражения 1

Пример

package main
import (
	"fmt"
	"regexp"
)
func　main()　{
	re := regexp.MustCompile(".com")
	fmt.Println(re.FindString("oldtoolbag.com"))
	fmt.Println(re.FindString("abc.org"))
	fmt.Println(re.FindString("fb.com"))
}

Вывод:

.com
.com

Метод FindString() возвращает строку, содержащую наиболее левое совпадение текста. Если совпадение не найдено, то возвращается пустая строка.

Пример регулярного выражения 2

Пример

package main
import (
	"fmt"
	"regexp"
)
func　main()　{
	re := regexp.MustCompile(".com")
	fmt.Println(re.FindStringIndex("google.com"))
	fmt.Println(re.FindStringIndex("abc.org"))
	fmt.Println(re.FindStringIndex("fb.com"))
}

Вывод:

[6 10]
[]
[2 6]

Пример регулярного выражения 3

Мы также можем использовать метод FindStringSubmatch(), который возвращает строку срез, содержащий наиболее левый совпадение и текст совпадения. Если совпадение не найдено, то возвращается пустая строка.

Пример

package main
import (
	"fmt"
	"regexp"
)
func　main()　{
	re := regexp.MustCompile("f([a-z]+)ing")
	fmt.Println(re.FindStringSubmatch("flying"))
	fmt.Println(re.FindStringSubmatch("abcfloatingxyz"))
}

Вывод:

[летающий ly]
[плавающий loat]
Процесс завершен с кодом выхода 0

Часто используемые методы пакета regexp в языке Go

Для выполнения подстановки регулярных выражений в языке Go можно использовать пакет regexp. 　

Правила регулярных выражений в языке Go такие же, как и в других языках, разница только в функции вызова. 　　

Рекомендуется использовать формат `pattern` при создании регулярных выражений.

regexp.Match

// определяет, можно ли найти в b подстроку, соответствующую регулярному выражению pattern
// pattern: регулярное выражение, которое нужно найти
// b: массив байт, в котором нужно выполнить поиск
// matched: возвращает ли найден элемент
// err：返回查找过程中遇到的任何错误
// 此函数通过调用 Regexp 的方法实现
func Match(pattern string, b []byte) (matched bool, err error)

Онлайн пример

package main
　
import (
　　　　"fmt"
　　　　"regexp"
)
　
func　main()　{
　　　　matched, err := regexp.Match("^abc.*z$", []byte("abcdefgz"))
　　　　fmt.Println(matched, err) //true nil
　
　　　　matched, err = regexp.Match("^abc.*z$", []byte("bcdefgz"))
　　　　fmt.Println(matched, err) //false nil
}

regexp.MatchString

// определяет, можно ли найти в s подстроку, соответствующую регулярному выражению pattern
　// pattern: регулярное выражение, которое нужно найти
　// r: строка, в которой нужно выполнить поиск
　// matched: возвращает ли найден элемент
　// err：返回查找过程中遇到的任何错误
　// 此函数通过调用 Regexp 的方法实现
　
　func MatchString(pattern string, s string) (matched bool, err error)

Онлайн пример

package main
　
import (
　　　　"fmt"
　　　　"regexp"
)
　
func　main()　{
　　　　matched, err := regexp.MatchString("^abc.*z$", "abcdefgz")
　　　　fmt.Println(matched, err) //true <nil>
　
　　　　matched, err = regexp.MatchString("^abc.*z$", "bcdefgz")
　　　　fmt.Println(matched, err) //false <nil>
}

regexp.Compile

// Compile используется для проверки корректности регулярного выражения expr, если оно корректно, то возвращается объект Regexp
// Regexp 对象可以在任意文本上执行需要的操作
func Compile(expr string) (*Regexp, error)

Возвращает указатель на объект regexp, который реализует интерфейс regexp и может быть использован для вызова методов, таких как Match, MatchString, find и т.д.

Онлайн пример

//func Compile(expr string) (*Regexp, error)
r, _ := regexp.Compile(`f([a-z]+)`)
　
//func (re *Regexp) Match(b []byte) bool
fmt.Println(r.Match([]byte("foo"))) //true
　
//func (re *Regexp) MatchString(s string) bool
fmt.Println(r.MatchString("foo")) //true
　
//func (re *Regexp) FindString(s string) string
//只匹配一次
fmt.Println(r.FindString("foo　func"))　//foo
　
//func (re *Regexp) FindStringIndex(s string) (loc []int)
fmt.Println(r.FindStringIndex("demo　foo　func"))　//[5 8]
　
//func (re *Regexp) FindStringSubmatch(s string) []string
//只匹配一次，返回的结果中，索引为0的值是整个匹配串的值，第二个值是子表达式的值
fmt.Println(r.FindStringSubmatch("this　foo　func　fan"))　//[foo　oo]
　
//对于FindStringSubmatch，如果表达式中没有子表达式，则不检测子表达式
demo, _ := regexp.Compile(`foo`)
fmt.Println(demo.FindStringSubmatch("foo"))　//[foo]
　
//func (re *Regexp) FindStringSubmatchIndex(s string) []int
fmt.Println(r.FindStringSubmatchIndex("foo　func"))　//[0 3 1 3]
　
//func (re *Regexp) FindAllString(s string, n int) []string
//n为-1时，匹配所有符合条件的字符串，n不为-1时，表示只匹配n次
fmt.Println(r.FindAllString("foo　func　fan", -1))　//[foo　func　fan]
fmt.Println(r.FindAllString("foo　func　fan", 2))　//[foo　func]
　
//func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
//n同样是表示匹配的次数，-1表示匹配所有
fmt.Println(r.FindAllStringSubmatchIndex("foo　func　demo　fan", -1))
// [[0 3 1 3] [4 8 5 8] [14 17 15 17]]
　
// замена
　
// func (re *Regexp) ReplaceAll(src []byte, repl []byte) []byte
fmt.Println(string(r.ReplaceAll([]byte("this　is　foo,　that　is　func,　they　are　fan"), []byte("x"))))
// это x, это x, они x
　
// func (re *Regexp) ReplaceAllString(src string, repl string) string
fmt.Println(r.ReplaceAllString("this　is　foo,　that　is　func,　they　are　fan", "xx"))

regexp.MustCompile и regexp.Compile имеют схожее использование.

Подробное разъяснение пакета регулярных выражений regexp на языке Go

// regexp.go разъяснение
------------------------------------------------------------
1. Установить, можно ли найти подстроку, соответствующую регулярному выражению pattern, в []byte
// pattern: регулярное выражение, которое нужно найти
// b: массив байт, в котором нужно выполнить поиск
// matched: возвращает ли найден элемент
// err：返回查找过程中遇到的任何错误
// 此函数通过调用 Regexp 的方法实现
func Match(pattern string, b []byte) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", []byte("Hello　World!")))
//　true
}
------------------------------------------------------------
2. Установить, можно ли найти подстроку, соответствующую регулярному выражению pattern, в r
// 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
}
------------------------------------------------------------
3. Установить, можно ли найти подстроку, соответствующую регулярному выражению pattern, в s
// 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
}
------------------------------------------------------------
4. QuoteMeta 将字符串 s 中的“特殊字符”转换为其“转义格式”
// 例如，QuoteMeta（`[foo]`）返回`
foo
`。
// 特殊字符有：\.+*?()|[]{}^$
// 这些字符用于实现正则语法，所以当作普通字符使用时需要转换
func QuoteMeta(s string) string
func　main()　{
fmt.Println(regexp.QuoteMeta("(?P:Hello)　[a-z]"))
// \?P:Hello
a−z
}
------------------------------------------------------------
5. Regexp 结构表示一个编译后的正则表达式
// Regexp 的公开接口都是通过方法实现的
// 多个 goroutine 并发使用一个 RegExp 是安全的
type Regexp struct {
// 私有字段
}
// 通过 Complite、CompilePOSIX、MustCompile、MustCompilePOSIX
// 四个函数可以创建一个 Regexp 对象
------------------------------------------------------------
6. 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",
}
------------------------------------------------------------
7. 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"
}
------------------------------------------------------------
8.MustCompile выполняет ту же функцию, что и Compile
// Отличие в том, что когда регулярное выражение str недопустимо, MustCompile бросает исключение
// А Compile возвращает только значение ошибки
func MustCompile(str string) *Regexp
func　main()　{
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　Hello
}
------------------------------------------------------------
9.MustCompilePOSIX выполняет ту же функцию, что и CompilePOSIX
// Отличие в том, что когда регулярное выражение str недопустимо, MustCompilePOSIX бросает исключение
// А CompilePOSIX возвращает только значение ошибки
func MustCompilePOSIX(str string) *Regexp
func　main()　{
reg := regexp.MustCompilePOSIX(`[[:word:]].+ `)
fmt.Printf("%q\n", reg.FindString("Hello　World!"))
// "Hello"
}
------------------------------------------------------------
10. В []byte ищется скомпилированная регулярное выражение re, и возвращается первое соответствующее содержимое
func (re *Regexp) Find(b []byte) []byte
func　main()　{
reg := regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.Find([]byte("Hello　World!")))
// "Hello"
}
------------------------------------------------------------
11. В string ищется скомпилированная регулярное выражение re, и возвращается первое соответствующее содержимое
func (re *Regexp) FindString(s string) string
func　main()　{
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
// "Hello"
}
------------------------------------------------------------
12. В []byte ищется скомпилированная регулярное выражение 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"]
}
------------------------------------------------------------
13. Найти в string всех соответствий компилированного регулярного выражения 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"]
}
------------------------------------------------------------
14. Найти в []byte первое соответствие компилированного регулярного выражения re и вернуть позицию
// {началоposition, конецposition}
func (re *Regexp) FindIndex(b []byte) (loc []int)
func　main()　{
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindIndex([]byte("Hello World!")))
// [0 5]
}
------------------------------------------------------------
15. Найти в string первое соответствие компилированного регулярного выражения re и вернуть позицию
// {началоposition, конецposition}
func (re *Regexp) FindStringIndex(s string) (loc []int)
func　main()　{
reg := regexp.MustCompile(`\w+`)
fmt.Println(reg.FindStringIndex("Hello World!"))
// [0 5]
}
------------------------------------------------------------
16. Найти в r первое соответствие компилированного регулярного выражения re и вернуть позицию
// {началоposition, конецposition}
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]
}
------------------------------------------------------------
17. Найти в []byte всех соответствий компилированного регулярного выражения re и вернуть все позиции
// {{началоposition, конецposition}, {началоposition, конецposition}, ...}
//　只查找前 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]]
}
------------------------------------------------------------
18. Найти в string всех соответствий компилированного регулярного выражения re и вернуть все позиции
// {{началоposition, конецposition}, {началоposition, конецposition}, ...}
//　只查找前 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]]
}
------------------------------------------------------------
19. Найти первое соответствие в []byte, используя компилированный регулярный выражение 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"]
}
------------------------------------------------------------
20. Найти первое соответствие в строке string, используя компилированный регулярный выражение 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"]
}
------------------------------------------------------------
21. Найти все соответствия в []byte, используя компилированный регулярный выражение 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"]]
}
------------------------------------------------------------
22. Найти все соответствия в строке string, используя компилированный регулярный выражение 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"]]
}
------------------------------------------------------------
23.在 []byte 中查找 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]
}
------------------------------------------------------------
24.在 string 中查找 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]
}
------------------------------------------------------------
25.在 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]
}
------------------------------------------------------------
26.在 []byte 中查找 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]]
}
------------------------------------------------------------
27.在 string 中查找 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]]
}
-----------------------------------------------------------
30. Добавить содержимое 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"
}
------------------------------------------------------------
31. Функция аналогична 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"
}
------------------------------------------------------------
32.　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
}
------------------------------------------------------------
33.　Переключение на "жадный" режим
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
}
------------------------------------------------------------
34. Определить, можно ли найти совпадение в 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
}
------------------------------------------------------------
35. Определить, можно ли найти совпадение в 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
}
------------------------------------------------------------
36. Проверка наличия совпадения в 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
}
------------------------------------------------------------
37.　Число групп в регулярном выражении (без "несовпадающих групп")
func　(re　*Regexp)　NumSubexp()　int
func　main()　{
reg　:=　regexp.MustCompile(`(?U)(?:Hello)(\s+)(\w+)`)
fmt.Println(reg.NumSubexp())
//　2
}
------------------------------------------------------------
38. В 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!"
}
------------------------------------------------------------
39. В 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!"
}
-----------------------------------------------------------
40. В 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!"
}
-----------------------------------------------------------
41.在 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!"
}
------------------------------------------------------------
42. 在 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
------------------------------------------------------------
43.在 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!
}
------------------------------------------------------------
43. В поиске в 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"]
}
------------------------------------------------------------
44. Возвращает строку "регулярного выражения" в re
func　(re　*Regexp)　String()　string
func　main()　{
re　:=　regexp.MustCompile("Hello.*$")
fmt.Printf("%s\n",　re.String())
//　Hello.*$
}
------------------------------------------------------------
45. Возвращает список имен групп в 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"　"]
}