Regex بلغة Go

استخدام حزمة Regex لبحث النصوص. لبحث النصوص، يجب تقديم نموذج النص.

نحتاج إلى تمرير النمط إلى كائن 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"))
}

الإخراج:

[مطيعة]
[متناهية الزمن]
العملية انتهت بناءً على رمز الخروج 0

الأساليب الشائعة في حزمة regexp بلغة Go

يمكن استخدام حزمة regexp بلغة go للتوافق مع تعبيرات النصوص العادية. 　

قواعد تعبيرات النصوص العادية بلغة go هي نفسها مثل قواعد تعبيرات النصوص العادية بلغات أخرى، ولكن يختلف الدالة المستخدمة فقط. 　　

يُنصح باستخدام نموذج `pattern` عند بناء تعبيرات النصوص العادية.

regexp.Match

//判断在 b 中能否找到正则表达式 pattern 所匹配的子串
// pattern: النمط العادي الذي سيتم البحث عنه
// b: نص []byte الذي سيتم البحث فيه
// 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 对象可以在任意文本上执行需要的操作
func Compile(expr string) (*Regexp, error)

يستخدم هذا الكائن للتحقق من صحة تعبير النمط، إذا كان صحيحًا، فإنه يعود كائن من النوع Regexp

النموذج المتاح

//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"))))
// this is x, that is x, they are 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

تفصيل مكتبة Go للنماذج العادية regexp

// regexp.go تفصيل
------------------------------------------------------------
1.判断 في []byte هل يمكن العثور على النمط العادي pattern الذي تم تطابق
// pattern: النمط العادي الذي سيتم البحث عنه
// b: نص []byte الذي سيتم البحث فيه
// 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.判断 في r هل يمكن العثور على النمط العادي pattern الذي تم تطابق
// 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.�断 في s هل يمكن العثور على النمط العادي pattern الذي تم تطابق
// 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 中编译好的正则表达式，并返回第一个匹配的位置
// {起始位置, 结束位置}
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 中编译好的正则表达式，并返回第一个匹配的位置
// {起始位置, 结束位置}
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 中编译好的正则表达式，并返回第一个匹配的位置
// {起始位置, 结束位置}
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 中编译好的正则表达式，并返回所有匹配的位置
// {{起始位置, 结束位置}, {起始位置, 结束位置}, ...}
// فقط جوئد اولین 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 中编译好的正则表达式，并返回所有匹配的位置
// {{起始位置, 结束位置}, {起始位置, 结束位置}, ...}
// فقط جوئد اولین 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))
[]
}
------------------------------------------------------------
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))
[]
}
------------------------------------------------------------
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 البحث عن التطابق والمساعدة في تبديلها بمحتوى مسبقًا
// 全部替换，并返回替换后的结果
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 البحث عن التطابق والمساعدة في تبديلها بمحتوى مسبقًا
// 全部替换，并返回替换后的结果
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 中有“分组引用符”（$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")

//　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"　"]
}