基础知识-Golang中的正则表达式------------------------------------------------------------
Golang中的正则表达式
------------------------------------------------------------
⽤法：
------------------------------
单⼀：
.                  匹配任意⼀个字符，如果设置 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类”见后⾯的说明
------------------------------
复合：
xy            匹配 xy（x 后⾯跟随 y）
x|y            匹配 x 或 y (优先匹配 x)
------------------------------
重复：
x*            匹配零个或多个 x，优先匹配更多(贪婪)
x+            匹配⼀个或多个 x，优先匹配更多(贪婪)
x?            匹配零个或⼀个 x，优先匹配⼀个(贪婪)
x{n,m}        匹配 n 到 m 个 x，优先匹配更多(贪婪)
x{n,}          匹配 n 个或多个 x，优先匹配更多(贪婪)
x{n}          只匹配 n 个 x
x*?            匹配零个或多个 x，优先匹配更少(⾮贪婪)
x+?            匹配⼀个或多个 x，优先匹配更少(⾮贪婪)
x??            匹配零个或⼀个 x，优先匹配零个(⾮贪婪)
x{n,m}?        匹配 n 到 m 个 x，优先匹配更少(⾮贪婪)
x{n,}?        匹配 n 个或多个 x，优先匹配更少(⾮贪婪)
x{n}?          只匹配 n 个 x
------------------------------
分组：
(⼦表达式)            被捕获的组，该组被编号 (⼦匹配)
(?P<；命名>⼦表达式)    被捕获的组，该组被编号且被命名 (⼦匹配)
(?:⼦表达式)          ⾮捕获的组 (⼦匹配)
(?标记)              在组内设置标记，⾮捕获，标记影响当前组后的正则表达式
(?标记:⼦表达式)      在组内设置标记，⾮捕获，标记影响当前组内的⼦表达式
标记的语法是：
xyz  (设置 xyz 标记)
-
xyz (清除 xyz 标记)
xy-z (设置 xy 标记, 清除 z 标记)
可以设置的标记有：
i              不区分⼤⼩写 (默认为 false)
m              多⾏模式：让 ^ 和 $ 匹配整个⽂本的开头和结尾，⽽⾮⾏⾸和⾏尾(默认为 false)
s              让 . 匹配 \n (默认为 false)
U              ⾮贪婪模式：交换 x* 和 x*? 等的含义 (默认为 false)
------------------------------
位置标记：
^              如果标记 m=true 则匹配⾏⾸，否则匹配整个⽂本的开头（m 默认为 false）
$              如果标记 m=true 则匹配⾏尾，否则匹配整个⽂本的结尾（m 默认为 false）
\A            匹配整个⽂本的开头，忽略 m 标记
\b            匹配单词边界
\B            匹配⾮单词边界
\z            匹配整个⽂本的结尾，忽略 m 标记
------------------------------
转义序列：
\a            匹配响铃符（相当于 \x07）
注意：正则表达式中不能使⽤ \b 匹配退格符，因为 \b 被⽤来匹配单词边界，
可以使⽤ \x08 表⽰退格符。
\f            匹配换页符（相当于 \x0C）
\t            匹配横向制表符（相当于 \x09）
\n            匹配换⾏符（相当于 \x0A）
\r            匹配回车符（相当于 \x0D）
\v            匹配纵向制表符（相当于 \x0B）
\123          匹配 8  進制编码所代表的字符（必须是 3 位数字）
\x7F          匹配 16 進制编码所代表的字符（必须是 3 位数字）
\x{10FFFF}    匹配 16 進制编码所代表的字符（最⼤值 10FFFF  ）
\Q...\E        匹配 \Q 和 \E 之间的⽂本，忽略⽂本中的正则语法
\\            匹配字符 \
\^            匹配字符 ^
\$            匹配字符 $
\.            匹配字符 .
\*            匹配字符 *
\+            匹配字符 +
\?            匹配字符 ?
\{            匹配字符 {
\}            匹配字符 }
\(            匹配字符 (
\|            匹配字符 |
------------------------------
可以将“命名字符类”作为“字符类”的元素：
[\d]          匹配数字 (相当于 \d)
[^\d]          匹配⾮数字 (相当于 \D)
[\D]          匹配⾮数字 (相当于 \D)
[^\D]          匹配数字 (相当于 \d)
[[:name:]]    命名的“ASCII 类”包含在“字符类”中 (相当于 [:name:])
[^[:name:]]    命名的“ASCII 类”不包含在“字符类”中 (相当于 [:^name:])        [\p{Name}]    命名的“Unicode 类”包含在“字符类”中 (相当于 \p{Name})        [^\p{Name}]    命名的“Unicode 类”不包含在“字符类”中 (相当于 \P{Name})
------------------------------------------------------------
说明：
------------------------------
“字符类”取值如下（“字符类”包含“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                私⼈使⽤区      (private use)
Cs                代理区          (surrogate)
L                -字母-          (letter)
Ll                ⼩写字母        (lowercase letter)
Lm                修饰字母        (modifier letter)
Lo                其它字母        (other letter)
Lt                ⾸字母⼤写字母  (titlecase letter)
Lu                ⼤写字母        (uppercase letter)
M                -标记-          (mark)
Mc                间距标记        (spacing mark)
Me                关闭标记        (enclosing mark)
Mn                ⾮间距标记      (non-spacing mark)
N                -数字-          (number)
Nd                ⼗進制数字      (decimal number)
Nl                字母数字        (letter number)
No                其它数字        (other number)
P                -标点-          (punctuation)
Pc                连接符标点      (connector punctuation)
Pd                破折号标点符号  (dash punctuation)
Pe                关闭的标点符号  (close punctuation)
Pf                最后的标点符号  (final punctuation)
Pi                最初的标点符号  (initial punctuation)
Po                其他标点符号    (other punctuation)
Ps                开放的标点符号  (open punctuation)
S                -符号-          (symbol)
Sc                货币符号        (currency symbol)
Sk                修饰符号        (modifier symbol)
Sm                数学符号        (math symbol)
So                其他符号        (other symbol)
Z                -分隔符-        (separator)
Zl                ⾏分隔符        (line separator)
Zp                段落分隔符      (paragraph separator)
Zs                空⽩分隔符      (space separator)
------------------------------
“Unicode 类”取值如下---脚本类：
Arabic                  阿拉伯⽂
Armenian                亚美尼亚⽂
Balinese                巴厘岛⽂
Bengali                孟加拉⽂
Bopomofo                汉语拼⾳字母
Braille                盲⽂
Buginese                布吉⽂
Buhid                  布希德⽂
Canadian_Aboriginal    加拿⼤⼟著⽂
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_B                B类线形⽂字（古希腊）
Lycian                  利西亚⽂
Lydian                  吕底亚⽂
Malayalam              马拉雅拉姆⽂
Mongolian              蒙古⽂
Myanmar                缅甸⽂
New_Tai_Lue            新傣仂⽂
Nko                    Nko⽂
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                      彝⽂
------------------------------------------------------------
注意：
  对于 [a-z] 这样的正则表达式，如果要在 [] 中匹配 - ，可以将 - 放在 [] 的开头或结尾，例如 [-a-z] 或 [a-z-]
  可以在 [] 中使⽤转义字符：\f、\t、\n、\r、\v、\377、\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 类”之外，其它都⼀样。
------------------------------------------------------------
// ⽰例
func main() {
text := `Hello 世界！123 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" " 世界！123 G" "."]
// 查连续的单词字母
reg = regexp.MustCompile(`[\w]+`)
fmt.Printf("%q\n", reg.FindAllString(text, -1))
// ["Hello" "123" "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 世界" "123 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 " "！123 Go."]
// 查 Hello 或 Go
reg = 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 世界！123 "]
// 查⾏⾸以 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 世界！123 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" " 世界！" "123" " " "Go"]
// 查连续 1 次到 4 次的⾮空格字符，并以 o 结尾的字符串
reg = regexp.MustCompile(`[^ ]{1,4}o`)
fmt.Printf("%q\n", reg.FindAllString(text, -1))
// ["Hello" "Go"]
/
/ 查 Hello 或 Go
reg = regexp.MustCompile(`(?:Hell|G)o`)
fmt.Printf("%q\n", reg.FindAllString(text, -1))
// ["Hello" "Go"]
// 查 Hello 或 Go，替换为 Hellooo、Gooo
reg = regexp.MustCompile(`(?PHell|G)o`)
fmt.Printf("%q\n", reg.ReplaceAllString(text, "${n}ooo"))
// "Hellooo 世界！123 Gooo."
// 交换 Hello 和 Go
reg = regexp.MustCompile(`(Hello)(.*)(Go)`)
fmt.Printf("%q\n", reg.ReplaceAllString(text, "$3$2$1"))
/
/ "Go 世界！123 Hello."
// 特殊字符的查
reg = regexp.MustCompile(`[\f\t\n\r\v\123\x7F\x{10FFFF}\\\^\$\.\*\+\?\{\}\(\)\[\]\|]`)
fmt.Printf("%q\n", reg.ReplaceAllString("\f\t\n\r\v\123\x7F\U0010FFFF\\^$.*+?{}()[]|", "-")) // "----------------------"
}
------------------------------------------------------------

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。