golang2021函数与包71正则
1.正则表达式
1.1单一字符
.匹配任意一个字符，如果设置s=true，则可以匹配换行符
[字符类]匹配“字符类”中的一个字符，“字符类”见后面的说明[^字符类]匹配“字符类”外的一个字符，“字符类”见后面的说明
\小写Perl标记匹配“Perl类”中的一个字符，“Perl类”见后面的说明\大写Perl标记匹配“Perl类”外的一个字符，“Perl类”见后面的说明
[:ASCII类名:]匹配“ASCII类”中的一个字符，“ASCII类”见后面的说明[:^ASCII类名:]匹配“ASCII类”外的一个字符，“ASCII类”见后面的说明
\pUnicode普通类名匹配“Unicode类”中的一个字符(仅普通类)，“Unicode类”见后面的说明\PUnicode普通类名匹配“Unicode类”外的一个字符(仅普通类)，“Unicode类”见后面的说明
\p{Unicode类名}匹配“Unicode类”中的一个字符，“Unicode类”见后面的说明\P{Unicode类名}匹配“Unicode类”外的一个字符，“Unicode类”见后面的说明
1.2复合
1.2复合
xy匹配xy（x后面跟随y）x
y匹配x或y(优先匹配x)
1.3重复
x*匹配零个或多个x，优先匹配更多(贪婪)x+匹配一个或多个x，优先匹配更多(贪婪)x?匹配零个或一个x，优先匹配一个(贪婪)x{n,m}匹配n到m个x，优先匹配更多(贪婪)x{n,}匹配n个或多个x，优先匹配更多(贪婪)x{n}只匹配n个xx*?匹配零个或多个x，优先匹配更少(非贪婪)x+?匹配一个或多个x，优先匹配更少(非贪婪)x??匹配零个或一个x，优先匹配零个(非贪婪)x{n,m}?匹配n到m个x，优先匹配更少(非贪婪)x{n,}?匹配n个或多个x，优先匹配更少(非贪婪)x{n}?只匹配n个x
1.4分组
(子表达式)被捕获的组，该组被编号(子匹配)(?P命名子表达式)被捕获的组，该组被编号且被命名(子匹配)(?:子表达式)非捕获的组(子匹配)(?标记)在组内设置标记，非捕获，标记影响当前组后的正则表达式(?标记:子表达式)在组内设置标记，非捕获，标记影响当前组内的子表达式
标记的语法是：xyz(设置xyz标记)-xyz(清除xyz标记)xy-z(设置xy标记,清除z标记)
可以设置的标记有：i不区分大小写(默认为false)m多行模式：让^和匹配整个文本的开头和结尾，而非行首和行尾(默认为false)s让.匹配\n(默认为false)U非贪婪模式：交换x*和x*?等的含义(默认为false)
1.5位置标记
^如果标记m=true则匹配行首，否则匹配整个文本的开头（m默认为false）如果标记m=true则匹配行尾，否则匹配整个文本的结尾（m默认为false）\A匹配整个文本的开头，忽略m标记\b匹配单词边界\B匹配非单词边界\z匹配整个文本的结尾，忽略m标记
1.6转义序列
\a匹配响铃符（相当于\x07）注意：正则表达式中不能使用\b匹配退格符，因为\b被用来匹配单词边界，可以使用\x08表示退格符。\f匹配换页符（相当于\x0C）\t匹配横向制表符（相当于\x09）\n匹配换行符（相当于\x0A）\r匹配回车符（相当于\x0D）\v匹配纵向制表符（相当于\x0B）\匹配8進制编码所代表的字符（必须是3位数字）\x7F匹配16進制编码所代表的字符（必须是3位数字）\x{10FFFF}匹配16進制编码所代表的字符（最大值10FFFF）\Q...\E匹配\Q和\E之间的文本，忽略文本中的正则语法
\\匹配字符\\^匹配字符^\匹配字符\.匹配字符.\*匹配字符*\+匹配字符+\?匹配字符?\{匹配字符{\}匹配字符}\(匹配字符(\)匹配字符)\[匹配字符[\]匹配字符]\
匹配字符
1.7将“命名字符类”作为“字符类”的元素
[\d]匹配数字(相当于\d)[^\d]匹配非数字(相当于\D)[\D]匹配非数字(相当于\D)[^\D]匹配数字(相当于\d)[[:name:]]命名的“ASCII类”包含在“字符类”中(相当于[:name:])[^[:name:]]命名的“ASCII类”不包含在“字符类”中(相当于[:^name:])[\p{Name}]命名的“Unicode类”包含在“字符类”中(相当于\p{Name})[^\p{Name}]命名的“Unicode类”不包含在“字符类”中(相当于\P{Name})
1.7.1说明
“字符类”取值如下（“字符类”包含“Perl类”、“ASCII类”、“Unicode类”）：x单个字符A-Z字符范围(包含首尾字符)\小写字母Perl类[:ASCII类名:]ASCII类\p{Unicode脚本类名}Unicode类(脚本类)\pUnicode普通类名Unicode类(普通类)
------------------------------
“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:]ASCII字符集(相当于[\x00-\x7F])[:blank:]空白占位符(相当于[\t])[:cntrl:]控制字符(相当于[\x00-\x1F\x7F])[:digit:]数字(相当于[0-9])[:graph:]图形字符(相当于[!-~])[:lower:]小写字母(相当于[a-z])[:print:]可打印字符(相当于[-~]相当于[[:graph:]])[:punct:]标点符号(相当于[!-/:-
[-反引号{-~])[:space:]空白字符(相当于[\t\n\v\f\r])[:upper:]大写字母(相当于[A-Z])[:word:]单词字符(相当于[0-9A-Za-z_])[:xdigit:]16進制字符集(相当于[0-9A-Fa-f])------------------------------
“Unicode类”取值如下---普通类：
C-其他-(other)Cc控制字符(control)Cf格式(format)Co私人使用区(privateuse)Cs代理区(surrogate)L-字母-(letter)Ll小写字母(lowercaseletter)Lm修饰字母(modifierletter)Lo其它字母(otherletter)Lt首字母大写字母(titlecaseletter)Lu大写字母(uppercaseletter)M-标记-(mark)Mc间距标记(spacingmark)Me关闭标记(enclosingmark)Mn非间距标记(non-spacingmark)N-数字-(number)Nd十進制数字(decimalnumber)Nl字母数字(letternumber)No其它数字(othernumber)P-标点-(punctuation)Pc连接符标点(connectorpunctuation)Pd破折号标点符号(dashpunctuation)Pe关闭的标点符号(closepunctuation)Pf最后的标点符号(finalpunctuation)Pi最初的标点符号(initialpunctuation)Po其他标点符号(otherpunctuation)Ps开放的标点符号(openpunctuation)S-符号-(symbol)Sc货币符号(currencysymbol)Sk修饰符号(modifiersymbol)Sm数学符号(mathsymbol)So其他符号(othersymbol)Z-分隔符-(separator)Zl行分隔符(lineseparator)Zp段落分隔符(paragraphseparator)Zs空白分隔符(spaceseparator)
------------------------------
“Unicode类”取值如下---脚本类：
Arabic阿拉伯文Armenian亚美尼亚文Balinese巴厘岛文Bengali孟加拉文Bopomofo汉语拼音字母Braille盲文Buginese布吉文Buhid布希德文Canadian_Aboriginal加拿大土著文Carian卡里亚文Cham占族文Cherokee切诺基文Common普通的，字符不是特定于一个脚本Coptic科普特文Cuneiform楔形文字Cypriot塞浦路斯文Cyrillic斯拉夫文Deseret犹他州文Devanagari梵文Ethiopic衣索比亚文Georgian格鲁吉亚文Glagolitic格拉哥里文Gothic哥特文Greek希腊Gujarati古吉拉特文Gurmukhi果鲁穆奇文Han汉文Hangul韩文Hanunoo哈鲁喏文Hebrew希伯来文Hiragana平假名（日语）Inherited继承前一个字符的脚本Kannada坎那达文Katakana片假名（日语）Kayah_Li克耶字母Kharoshthi卡罗须提文Khmer高棉文Lao老挝文Latin拉丁文Lepcha雷布查文Limbu林布文Linear_BB类线形文字（古希腊）Lycian利西亚文Lydian吕底亚文Malayalam马拉雅拉姆文Mongolian蒙古文Myanmar缅甸文New_Tai_Lue新傣仂文NkoNko文Ogham欧甘文Ol_Chiki桑塔利文Old_Italic古意大利文Old_Persian古波斯文Oriya奥里亚文Osmanya奥斯曼亚文Phags_Pa八思巴文Phoenician腓尼基文Rejang拉让文Runic古代北欧文字Saurashtra索拉什特拉文（印度县城）Shavian萧伯纳文Sinhala僧伽罗文Sundanese巽他文Syloti_Nagri锡尔赫特文Syriac叙利亚文Tagalog塔加拉文Tagbanwa塔格巴努亚文Tai_Le德宏傣文Tamil泰米尔文Telugu泰卢固文Thaana塔安那文Thai泰文Tibetan藏文Tifinagh提非纳文Ugaritic乌加里特文Vai瓦伊文Yi彝文
1.8注意
对于[a-z]这样的正则表达式，如果要在[]中匹配-，可以将-放在[]的开头或结尾，例如[-a-z]或[a-z-]
可以在[]中使用转义字符：\f、\t、\n、\r、\v、\、\xFF、\x{10FFFF}、\\、\^、\、\.、\*、\+、\?、\{、\}、\(、\)、\[、\]、\
（具体含义见上面的说明）
如果在正则表达式中使用了分组，则在执行正则替换的时候，“替换内容”中可以使用1、{1}、name、{name}这样的“分组引用符”获取相应的分组内容。其中0代表整个匹配项，1代表第1个分组，2代表第2个分组
如果“分组引用符”是name的形式，则在解析的时候，name是取尽可能长的字符串，比如：1x相当于{1x}，而不是{1}x，再比如：10相当于{10}，而不是{1}0
由于字符会被转义，所以要在“替换内容”中使用字符，可以用\代替
上面介绍的正则表达式语法是”Perl语法“，除了“Perl语法”外，Go语言中还有另一种”POSIX语法“，”POSIX语法“除了不能使用“Perl类”之外，其它都一样
1.9示例
//示例funcmain(){text:=`Hello世界！Go.`
//查找连续的小写字母reg:=regexp.MustCompile(`[a-z]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["ello""o"]
//查找连续的非小写字母reg=regexp.MustCompile(`[^a-z]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["H""世界！G""."]
//查找连续的单词字母reg=regexp.MustCompile(`[\w]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello""""Go"]
//查找连续的非单词字母、非空白字符reg=regexp.MustCompile(`[^\w\s]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["世界！""."]
//查找连续的大写字母reg=regexp.MustCompile(`[[:upper:]]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["H""G"]
//查找连续的非ASCII字符reg=regexp.MustCompile(`[[:^ascii:]]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["世界！"]
//查找连续的标点符号reg=regexp.MustCompile(`[\pP]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["！""."]
//查找连续的非标点符号字符reg=regexp.MustCompile(`[\PP]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello世界""Go"]
//查找连续的汉字reg=regexp.MustCompile(`[\p{Han}]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["世界"]
//查找连续的非汉字字符reg=regexp.MustCompile(`[\P{Han}]+`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello""！Go."]
//查找Hello或Goreg=regexp.MustCompile(`Hello
Go`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello""Go"]
//查找行首以H开头，以空格结尾的字符串reg=regexp.MustCompile(`^H.*\s`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello世界！"]
//查找行首以H开头，以空白结尾的字符串（非贪婪模式）reg=regexp.MustCompile(`(?U)^H.*\s`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello"]
//查找以hello开头（忽略大小写），以Go结尾的字符串reg=regexp.MustCompile(`(?i:^hello).*Go`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello世界！Go"]
//查找Go.reg=regexp.MustCompile(`\QGo.\E`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Go."]
//查找从行首开始，以空格结尾的字符串（非贪婪模式）reg=regexp.MustCompile(`(?U)^.*`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello"]
//查找以空格开头，到行尾结束，中间不包含空格字符串reg=regexp.MustCompile(`[^]*`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Go."]
//查找“单词边界”之间的字符串reg=regexp.MustCompile(`(?U)\b.+\b`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello""世界！""""""Go"]
//查找连续1次到4次的非空格字符，并以o结尾的字符串reg=regexp.MustCompile(`[^]{1,4}o`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello""Go"]
//查找Hello或Goreg=regexp.MustCompile(`(?:Hell
G)o`)fmt.Printf("%q\n",reg.FindAllString(text,-1))//["Hello""Go"]
//查找Hello或Go，替换为Hellooo、Goooreg=regexp.MustCompile(`(?PHell
G)o`)fmt.Printf("%q\n",reg.ReplaceAllString(text,"{n}ooo"))//"Hellooo世界！Gooo."
//交换Hello和Goreg=regexp.MustCompile(`(Hello)(.*)(Go)`)fmt.Printf("%q\n",reg.ReplaceAllString(text,"321"))//"Go世界！Hello."
//特殊字符的查找reg=regexp.MustCompile(`[\f\t\n\r\v\\x7F\x{10FFFF}\\\^\\.\*\+\?\{\}\(\)\[\]\
]`)fmt.Printf("%q\n",reg.ReplaceAllString("\f\t\n\r\v\\x7F\UFFFF\\^.*+?{}()[]
","-"))//"----------------------"}
2.Regexp使用
------------------------------------------------------------
//判断在b中能否找到正则表达式pattern所匹配的子串//pattern：要查找的正则表达式//b：要在其中进行查找的[]byte//matched：返回是否找到匹配项//err：返回查找过程中遇到的任何错误//此函数通过调用Regexp的方法实现funcMatch(patternstring,b[]byte)(matchedbool,errerror)
funcmain(){fmt.Println(regexp.Match("H.*",[]byte("HelloWorld!")))//true}
------------------------------------------------------------
//判断在r中能否找到正则表达式pattern所匹配的子串//pattern：要查找的正则表达式//r：要在其中进行查找的RuneReader接口//matched：返回是否找到匹配项//err：返回查找过程中遇到的任何错误//此函数通过调用Regexp的方法实现funcMatchReader(patternstring,rio.RuneReader)(matchedbool,errerror)
funcmain(){r:=bytes.NewReader([]byte("HelloWorld!"))fmt.Println(regexp.MatchReader("H.*",r))//true}
------------------------------------------------------------
//判断在s中能否找到正则表达式pattern所匹配的子串//pattern：要查找的正则表达式//r：要在其中进行查找的字符串//matched：返回是否找到匹配项//err：返回查找过程中遇到的任何错误//此函数通过调用Regexp的方法实现funcMatchString(patternstring,sstring)(matchedbool,errerror)
funcmain(){fmt.Println(regexp.Match("H.*","HelloWorld!"))//true}
------------------------------------------------------------
//QuoteMeta将字符串s中的“特殊字符”转换为其“转义格式”//例如，QuoteMeta（`[foo]`）返回`\[foo\]`。//特殊字符有：\.+*?()
[]{}^//这些字符用于实现正则语法，所以当作普通字符使用时需要转换funcQuoteMeta(sstring)string
funcmain(){fmt.Println(regexp.QuoteMeta("(?P:Hello)[a-z]"))//\(\?P:Hello\)\[a-z\]}
------------------------------------------------------------
//Regexp结构表示一个编译后的正则表达式//Regexp的公开接口都是通过方法实现的//多个goroutine并发使用一个RegExp是安全的typeRegexpstruct{//私有字段}
//通过Complite、CompilePOSIX、MustCompile、MustCompilePOSIX//四个函数可以创建一个Regexp对象
------------------------------------------------------------
//Compile用来解析正则表达式expr是否合法，如果合法，则返回一个Regexp对象//Regexp对象可以在任意文本上执行需要的操作funcCompile(exprstring)(*Regexp,error)
funcmain(){reg,err:=regexp.Compile(`\w+`)fmt.Printf("%q,%v\n",reg.FindString("HelloWorld!"),err)//"Hello",}
------------------------------------------------------------
//CompilePOSIX的作用和Compile一样//不同的是，CompilePOSIX使用POSIX语法，//同时，它采用最左最长方式搜索，//而Compile采用最左最短方式搜索//POSIX语法不支持Perl的语法格式：\d、\D、\s、\S、\w、\WfuncCompilePOSIX(exprstring)(*Regexp,error)
funcmain(){reg,err:=regexp.CompilePOSIX(`[[:word:]]+`)fmt.Printf("%q,%v\n",reg.FindString("HelloWorld!"),err)//"Hello"}
------------------------------------------------------------
//MustCompile的作用和Compile一样//不同的是，当正则表达式str不合法时，MustCompile会抛出异常//而Compile仅返回一个error值funcMustCompile(strstring)*Regexp
funcmain(){reg:=regexp.MustCompile(`\w+`)fmt.Println(reg.FindString("HelloWorld!"))//Hello}
------------------------------------------------------------
//MustCompilePOSIX的作用和CompilePOSIX一样//不同的是，当正则表达式str不合法时，MustCompilePOSIX会抛出异常//而CompilePOSIX仅返回一个error值funcMustCompilePOSIX(strstring)*Regexp
funcmain(){reg:=regexp.MustCompilePOSIX(`[[:word:]].+`)fmt.Printf("%q\n",reg.FindString("HelloWorld!"))//"Hello"}
------------------------------------------------------------
//在b中查找re中编译好的正则表达式，并返回第一个匹配的内容func(re*Regexp)Find(b[]byte)[]byte
funcmain(){reg:=regexp.MustCompile(`\w+`)fmt.Printf("%q",reg.Find([]byte("HelloWorld!")))//"Hello"}
------------------------------------------------------------
//在s中查找re中编译好的正则表达式，并返回第一个匹配的内容func(re*Regexp)FindString(sstring)string
funcmain(){reg:=regexp.MustCompile(`\w+`)fmt.Println(reg.FindString("HelloWorld!"))//"Hello"}
------------------------------------------------------------
//在b中查找re中编译好的正则表达式，并返回所有匹配的内容//{{匹配项},{匹配项},...}//只查找前n个匹配项，如果n0，则查找所有匹配项func(re*Regexp)FindAll(b[]byte,nint)[][]byte
funcmain(){reg:=regexp.MustCompile(`\w+`)fmt.Printf("%q",reg.FindAll([]byte("HelloWorld!"),-1))//["Hello""World"]}
------------------------------------------------------------
//在s中查找re中编译好的正则表达式，并返回所有匹配的内容//{匹配项,匹配项,...}//只查找前n个匹配项，如果n0，则查找所有匹配项func(re*Regexp)FindAllString(sstring,nint)[]string
funcmain(){reg:=regexp.MustCompile(`\w+`)fmt.Printf("%q",reg.FindAllString("HelloWorld!",-1))//["Hello""World"]}
------------------------------------------------------------
//在b中查找re中编译好的正则表达式，并返回第一个匹配的位置//{起始位置,结束位置}func(re*Regexp)FindIndex(b[]byte)(loc[]int)
funcmain(){reg:=regexp.MustCompile(`\w+`)fmt.Println(reg.FindIndex([]byte("HelloWorld!")))//[05]}
------------------------------------------------------------
//在s中查找re中编译好的正则表达式，并返回第一个匹配的位置//{起始位置,结束位置}func(re*Regexp)FindStringIndex(sstring)(loc[]int)
funcmain(){reg:=regexp.MustCompile(`\w+`)fmt.Println(reg.FindStringIndex("HelloWorld!"))//[05]}
------------------------------------------------------------
//在r中查找re中编译好的正则表达式，并返回第一个匹配的位置//{起始位置,结束位置}func(re*Regexp)FindReaderIndex(rio.RuneReader)(loc[]int)
funcmain(){r:=bytes.NewReader([]byte("HelloWorld!"))reg:=regexp.MustCompile(`\w+`)fmt.Println(reg.FindReaderIndex(r))//[05]}
------------------------------------------------------------
//在b中查找re中编译好的正则表达式，并返回所有匹配的位置//{{起始位置,结束位置},{起始位置,结束位置},...}//只查找前n个匹配项，如果n0，则查找所有匹配项func(re*Regexp)FindAllIndex(b[]byte,nint)[][]int
funcmain(){reg:=regexp.MustCompile(`\w+`)fmt.Println(reg.FindAllIndex([]byte("HelloWorld!"),-1))//[[05][]]}
------------------------------------------------------------
//在s中查找re中编译好的正则表达式，并返回所有匹配的位置//{{起始位置,结束位置},{起始位置,结束位置},...}//只查找前n个匹配项，如果n0，则查找所有匹配项func(re*Regexp)FindAllStringIndex(sstring,nint)[][]int
funcmain(){reg:=regexp.MustCompile(`\w+`)fmt.Println(reg.FindAllStringIndex("HelloWorld!",-1))//[[05][]]}
------------------------------------------------------------
//在b中查找re中编译好的正则表达式，并返回第一个匹配的内容//同时返回子表达式匹配的内容//{{完整匹配项},{子匹配项},{子匹配项},...}func(re*Regexp)FindSubmatch(b[]byte)[][]byte
funcmain(){reg:=regexp.MustCompile(`(\w)(\w)+`)fmt.Printf("%q",reg.FindSubmatch([]byte("HelloWorld!")))//["Hello""H""o"]}
------------------------------------------------------------
//在s中查找re中编译好的正则表达式，并返回第一个匹配的内容//同时返回子表达式匹配的内容//{完整匹配项,子匹配项,子匹配项,...}func(re*Regexp)FindStringSubmatch(sstring)[]string
funcmain(){reg:=regexp.MustCompile(`(\w)(\w)+`)fmt.Printf("%q",reg.FindStringSubmatch("HelloWorld!"))//["Hello""H""o"]}
------------------------------------------------------------
//在b中查找re中编译好的正则表达式，并返回所有匹配的内容//同时返回子表达式匹配的内容//{//{{完整匹配项},{子匹配项},{子匹配项},...},//{{完整匹配项},{子匹配项},{子匹配项},...},//...//}func(re*Regexp)FindAllSubmatch(b[]byte,nint)[][][]byte
funcmain(){reg:=regexp.MustCompile(`(\w)(\w)+`)fmt.Printf("%q",reg.FindAllSubmatch([]byte("HelloWorld!"),-1))//[["Hello""H""o"]["World""W""d"]]}
------------------------------------------------------------
//在s中查找re中编译好的正则表达式，并返回所有匹配的内容//同时返回子表达式匹配的内容//{//{完整匹配项,子匹配项,子匹配项,...},//{完整匹配项,子匹配项,子匹配项,...},//...//}//只查找前n个匹配项，如果n0，则查找所有匹配项func(re*Regexp)FindAllStringSubmatch(sstring,nint)[][]string
funcmain(){reg:=regexp.MustCompile(`(\w)(\w)+`)fmt.Printf("%q",reg.FindAllStringSubmatch("HelloWorld!",-1))//[["Hello""H""o"]["World""W""d"]]}
------------------------------------------------------------
//在b中查找re中编译好的正则表达式，并返回第一个匹配的位置//同时返回子表达式匹配的位置//{完整项起始,完整项结束,子项起始,子项结束,子项起始,子项结束,...}func(re*Regexp)FindSubmatchIndex(b[]byte)[]int
funcmain(){reg:=regexp.MustCompile(`(\w)(\w)+`)fmt.Println(reg.FindSubmatchIndex([]byte("HelloWorld!")))//[]}
------------------------------------------------------------
//在s中查找re中编译好的正则表达式，并返回第一个匹配的位置//同时返回子表达式匹配的位置//{完整项起始,完整项结束,子项起始,子项结束,子项起始,子项结束,...}func(re*Regexp)FindStringSubmatchIndex(sstring)[]int
funcmain(){reg:=regexp.MustCompile(`(\w)(\w)+`)fmt.Println(reg.FindStringSubmatchIndex("HelloWorld!"))//[]}
------------------------------------------------------------
//在r中查找re中编译好的正则表达式，并返回第一个匹配的位置//同时返回子表达式匹配的位置//{完整项起始,完整项结束,子项起始,子项结束,子项起始,子项结束,...}func(re*Regexp)FindReaderSubmatchIndex(rio.RuneReader)[]int
funcmain(){r:=bytes.NewReader([]byte("HelloWorld!"))reg:=regexp.MustCompile(`(\w)(\w)+`)fmt.Println(reg.FindReaderSubmatchIndex(r))//[]}
------------------------------------------------------------
//在b中查找re中编译好的正则表达式，并返回所有匹配的位置//同时返回子表达式匹配的位置//{//{完整项起始,完整项结束,子项起始,子项结束,子项起始,子项结束,...},//{完整项起始,完整项结束,子项起始,子项结束,子项起始,子项结束,...},//...//}//只查找前n个匹配项，如果n0，则查找所有匹配项func(re*Regexp)FindAllSubmatchIndex(b[]byte,nint)[][]int
funcmain(){reg:=regexp.MustCompile(`(\w)(\w)+`)fmt.Println(reg.FindAllSubmatchIndex([]byte("HelloWorld!"),-1))//[[][671011]]}
------------------------------------------------------------
//在s中查找re中编译好的正则表达式，并返回所有匹配的位置//同时返回子表达式匹配的位置//{//{完整项起始,完整项结束,子项起始,子项结束,子项起始,子项结束,...},//{完整项起始,完整项结束,子项起始,子项结束,子项起始,子项结束,...},//...//}//只查找前n个匹配项，如果n0，则查找所有匹配项func(re*Regexp)FindAllStringSubmatchIndex(sstring,nint)[][]int
funcmain(){reg:=regexp.MustCompile(`(\w)(\w)+`)fmt.Println(reg.FindAllStringSubmatchIndex("HelloWorld!",-1))//[[][671011]]}
------------------------------------------------------------
//将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
funcmain(){reg:=regexp.MustCompile(`(\w+),(\w+)`)src:=[]byte("Golang,World!")//源文本dst:=[]byte("Say:")//目标文本template:=[]byte("Hello1,Hello2")//模板match:=reg.FindSubmatchIndex(src)//解析源文本//填写模板，并将模板追加到目标文本中fmt.Printf("%q",reg.Expand(dst,template,src,match))//"Say:HelloGolang,HelloWorld"}
------------------------------------------------------------
//功能同Expand一样，只不过参数换成了string类型func(re*Regexp)ExpandString(dst[]byte,templatestring,srcstring,match[]int)[]byte
funcmain(){reg:=regexp.MustCompile(`(\w+),(\w+)`)src:="Golang,World!"//源文本dst:=[]byte("Say:")//目标文本（可写）template:="Hello1,Hello2"//模板match:=reg.FindStringSubmatchIndex(src)//解析源文本//填写模板，并将模板追加到目标文本中fmt.Printf("%q",reg.ExpandString(dst,template,src,match))//"Say:HelloGolang,HelloWorld"}
------------------------------------------------------------
//LiteralPrefix返回所有匹配项都共同拥有的前缀（去除可变元素）//prefix：共同拥有的前缀//
转载请注明：http://www.abuoumao.com/hyfw/3444.html
