正则表达式_字符匹配/可选字符集

正则表达式（Regular Expression）也叫匹配模式(Pattern)，用来检验字符串是否满足特定规则，或从字符串中捕获满足特定规则的子串。

字符匹配

最简单的正则表达式由“普通字符”和“通配符”组成。比如“Room\d\d\d”就这样的正则表达式。这些位置是普通字符 R o o m \d \d \d 20 这 3 个位置各匹配一个数字其中“Room”是普通字符，而“\d”是通配符，表示该位置上有一个数字。该表达式共占用了 7 个位置，第一个位置上是字母“R”，第二个位置和第三个位置上都是字母“o”，第四个位置上是字母“m”，而第五到第七个位置上是三个数字。所以正则表达式 “Room\d\d\d”代表着“以Room开头，以三个数字结尾”的那一类字符串。比如字符串 “Room101”、“Room415”、“Room888”等都与“Room\d\d\d”匹配① 。

用于正则表达式的通配符如下所示，每个通配符都代表一类字符

.NET 提供了一批与正则表达式相关的类，它们都位于 System.Text.RegularExpressions 命名空间，现在我们来学习最主要的 Regex 类，并用它来匹配正则表达式。 Regex 类的部分方法如表 20-2 所示

现在假设某份文件里包含着 Kitty 的房间号码(格式为 RoomXXX)，档案很长，人工查阅很耗时间，那么如何通过计算机帮我们找到房间号码呢？

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
//注意在文件头引用命名空间 System.Text.RegularExpressions。namespace Pattern202405
{internal class Program{static void Main(string[] args){string text = "The Colony is a beautiful town...Kitty lives in Room415...";//正则表达式Regex expression = new Regex(@"Room\d\d\d");//找出所有匹配的字符串，放入集合中MatchCollection matches = expression.Matches(text);//输出匹配的字符串foreach (Match match in matches){Console.WriteLine("She lives in {0}", match);Console.ReadKey();}}}
}

---------------------------------------

可选字符集

除了通配符外，我们还可以把某个位置上允许出现的字符写在方括号[]内，组成可选字符集，比如

[abc]表示该位置可以出现字母 a、b、c
[A-D]表示该位置可以出现字母 A、B、C、D
[A-DM-P]表示该位置可以出现字母 A 到 D 或 M 到 P
[A-Da-d]表示该位置可以出现字母 A 到 D 或 a 到 d
[12] 表示该位置可以出现数字 1 或数字 2
[1-5]表示该位置可以出现数字 1 到 5
[0-57-9]表示该位置可以出现除 6 外的所有数字
[\s\S]表示该位置可以出现任何字符,包括任何可见字符和不可见字符（如空格、制表符、换行等）

如果想从字符串中找出名字以 V 或 R 开头，出生于 80~90 年代的男孩，可以用下面
的正则表达式：
[VR] [a-z] [a-z] [a-z] [a-z] - 1 9 [89] [0-9]

它匹配的字符串包含 10 个字符，第 1 个字符为“V 或 R”，第 2~5 个字符为“a 到 z 的某个小写字母”，第 6~8 个字符为“-19”，第 9 个字符为“数字 8 或 9”，第 10 个字符为“0 到 9 之间的某个数字”。注意，不管中括号看起来有多长，它都只代表一个字符。表达式中的[VR]、[a-z]、[89]、 [0-9]都是一个字符，不能看作多个字符。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;namespace Pattern202405_2
{internal class Program{static void Main(string[] args){string boys = "Vitor-1979 Verne-1982 Regan-1998 Robin-2008";//string text = "Vitor-1970 Verne-1982 Regan-1998 Robin2008";//正则表达式Regex expression = new Regex(@"[VR][a-z][a-z][a-z][a-z]-19[89][0-9]");//获取并输出匹配的字符串foreach (Match match in expression.Matches(boys)){Console.WriteLine(match);}Console.ReadKey();}}
}

启动程序：

反向字符集

在中括号表达式中用符号“^”表示“非”。比如

[^x] 匹配除 x 以外的所有字符
[^abc] 匹配除 a、b、c 以外的所有字符
[^0-9] 匹配除 0 到 9 以外的所有字符
[^#] 匹配除#以外的所有字符
[^\n] 匹配除换行符\n 以外的所有字符

string sentence = "bog dog fog hog log";
//正则表达式
Regex expression = new Regex(@"[^bd]og");
//输出匹配的字符串
foreach (Match match in expression.Matches(sentence ))
{
Console.WriteLine(match);
}

正则表达式“[^bd]og”匹配的字符串包含三个字符，第一个字符是除 b 和 d 以外的字符，后两个字符为 og

或匹配

数量限定符

假设我们要从一串人名中找出以 V 开头的人名，因为人名的长度不是固定的，所以用一一对应的方法就无法实现，这时需要使用数量限定符

数量限定符“*”将前面的字符重复 0 次或多次。

string words = "lg log loog looog loooog looooog";
//正则表达式
Regex expression = new Regex("lo*g");
//获取并输出匹配的字符串
foreach (Match match in expression.Matches(words))
{
Console.WriteLine(match);
}
正则表达式“lo*g”表示字符串的第一个字符为 l，最后一个字符为 g，中间有零个或
多个字母 o。运行结果如图所示

数量限定符“+”将前面的字符重复 1 次或多次
//正则表达式 Regex expression = new Regex("lo+g");

数量限定符“？”将前面的字符重复 0 次或 1 次。
//正则表达式 Regex expression = new Regex("lo?g");

数量限定符{n,}表示把它前面的字符至少重复 n 遍
//正则表达式 Regex expression = new Regex("lo{3}g");
正则表达式“lo{3}g”表示字符串的第一个字符为 l，最后一个字符为 g，中间有 3 个字母 o。

数量限定符{n,m}把前面的字符重复 n 至 m 遍
//正则表达式 Regex expression = new Regex("lo{2,4}g");
正则表达式“lo{2,4}g”表示字符串的第一个字符为 l，最后一个字符为 g，中间有 2 到 4 个字母 o。

正则表达式“l(eo)+g”表示字符串的第一个字符为 l，最后一个字符为 g，中间有一个或多个 eo。

最奇妙的是这些数量限定符还可以与通配符组合。比如通配符“\w”匹配任意单词字符，限定符“*”表示把前面的字符重复 0 次或多次，所以正则表达式“\w*”匹配由任意单词字符组成的任意长度的字符串。

string girls = @"Van is 16; Vicky is 18; Vivien is 19; Vinvcent is 22";
Regex expression = new Regex(@"V\w* is \d\d");
foreach (Match match in expression.Matches(girls))
{
Console.WriteLine(match);
}

贪婪和懒惰的限定符

“贪婪的”(Greedy)，它们会匹配尽可能多的文本。如果在限定符后加上？号，它就会变成“懒惰的”(Lazy)，会匹配尽可能少的文本。

限定符“<.*>”和“<.*?>”都表示以“<”开头，以“>”结尾，中间是若干个字符的字符串，

贪婪限定符尽量找到一个最长（保留中间可能的匹配）的结果，而懒惰限定符尽量找最短的结果（忽略中间可能的匹配）。在匹配以特定字符为首尾的字符串时，懒惰的限定符往往能轻松的达到目的。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;namespace 贪婪和懒惰
{internal class Program{static void Main(string[] args){string words = "ab<H1>Hello World</H1>c";//贪婪的限定符Regex expression1 = new Regex("<.*>");MatchCollection matchs1 = expression1.Matches(words);Console.WriteLine("There is {0} match with greedy quantifier:", matchs1.Count);foreach (Match match in matchs1){Console.WriteLine(match);}//懒惰的限定符Regex expression2 = new Regex("<.*?>");MatchCollection matchs2 = expression2.Matches(words);Console.WriteLine("There are {0} matchs with lazy quantifier:", matchs2.Count);foreach (Match match in matchs2){Console.WriteLine(match);}Console.ReadKey();}}
}

懒惰限定符，有两个匹配模式值得注意。一个是“{n}?”，它实际上与“{n}”是等价的，因为不管是贪婪还是懒惰，都已经限定死了，只能重复 n 次。

另一个匹配模式是“??”，我们知道“?”表示把前面的字符重复 0 到 1 次，而“??”又是什么意思呢？

string sentence = "Where bee is, there is honey.";
//用?限定
Regex expression1 = new Regex("be?");
foreach (Match match in expression1.Matches(sentence))
{
Console.WriteLine("be? = {0}", match);
}
//用??限定
Regex expression2 = new Regex("be??");
foreach (Match match in expression2.Matches(sentence))
{
Console.WriteLine("be?? = {0}", match);
}

运行结果如图

在正则表达式“be?”中，“?”并不是把整个单词 be 重复 0 到 1 次，而是把“?”前面字母“e”重复 0 到 1 次。因为“be?”是贪婪的，能重复 1 次就不重复 0 次，所以结果中 e 出现了 1 次；

而“be?？”是懒惰的，重复次数要尽量少，所以它选择把 e 重复 0 次

所有限定符都可以和“?”组合

定位符

通过定位符可以在指定位置寻找匹配的子串。若正则表达式中使用了定位符“^”，则在整个字符串的头部寻找匹配的子串。

string words = "year1998 year2008 year2018";
//正则表达式
Regex expression = new Regex(@"^year\d\d\d\d");
//获取并输出匹配的字符串
foreach (Match match in expression.Matches(words))
{
Console.WriteLine(match);
}

“^”匹配字符串的开头位置，所以“^year\d\d\d\d”表示要从字符串的开头位置开始寻找。运行结果如图

若正则表达式中使用了定位符“$”，则在整个字符串的尾部寻找匹配的子串
//正则表达式 Regex expression = new Regex(@"year\d\d\d\d$");
“$”匹配字符串的结尾位置，所以“year\d\d\d\d$”表示匹配的子串紧邻字符串的结尾位置。运行结果如图所示

若正则表达式中使用了定位符“\b”，则在字符串中每个“单词”的边界①寻找匹配的子串。

string words = "formfordfork";
Console.Write("None anchors：");
Regex expression = new Regex(@"for\w");
foreach (Match match in expression.Matches(words))
{
Console.Write(match + "\t");
}
Console.Write("\nAnchor start：");
expression = new Regex(@"\bfor\w");
foreach (Match match in expression.Matches(words))
{
Console.Write(match + "\t");
}
Console.Write("\n Anchor end：");
expression = new Regex(@"for\w\b");
foreach (Match match in expression.Matches(words))
{
Console.Write(match + "\t");
}

“\b”匹配单词的边界位置。运行结果如图所示。由结果可以看出，当没有定位符时，匹配单词中所有符合要求的子串；当定位符\b 在前面时，在单词的头部寻找匹配的子串；当定位符\b 在后面时，在单词的结尾寻找匹配的子串

常用正则表达式“\b\w+\b”找出一句话里的所有单词。

用于正则表达式的定位符如表

符号“^”和“$”在正则表达式中也有特殊用处，所以当要匹配它们本身时也需使用它们的转义字符“\^”和“\$”。

分组和后向引用

如果没有括号，正则表达式“tr|bee”匹配“tr”或“bee”，加了括号后，“(tr|b)ee”匹配“tree”或“bee”，这种带括号的形式称为括号表达式。

括号表达式并不简单的起着确定范围的作用，它同时会创建子表达式，每个子表达式形成一个分组，并把捕获到的与子表达式匹配的子串保存在分组中，以供将来使用

举一个例子，电子邮件地址通常由用户名、二级域名、一级域名三部分构成。比如 waterwood @163.com，其中 waterwood 为用户名，163 为二级域名，com 为一级域名。我们可以通过下面的正则表达式匹配这类电子邮件地址: "(\w+)@(\w+)\.(\w+)"

这里有三个括号，形成三个子表达式，就会出现三个分组。默认情况下，每个分组会自动拥有一个组号，规则是：从左向右，按分组左括号的出现顺序进行编号，第一个分组的组号为 1，第二个为 2，以此类推。在正则表达式里引用分组的语法为“\number”，比如 “\1”代表与分组 1 匹配的子串，“\2”代表与分组 2 匹配的字串，等等

如果出现嵌套的分组，它们的编号也按左括号的出现顺序排列。

存储起来的分组有什么作用呢？下面我们通过一个例子来说明。很多句子里会有重复的单词，下面我们就通过正则表达式找出这些重复的单词。

string text = "you are very very good";
foreach (Match match in Regex.Matches(text, @"\b(\w+)\b \1\b"))
{
Console.WriteLine(match);
}
运行结果如图所示

我们前面已经知道“\b(\w+)\b”匹配一个单词，因为这里面有一个括号，所以会捕获一个以 1 为组号的分组，后面的“\1”就代表这个分组，表示这个位置上出现和分组 1 一样的内容。所以两者连起来就表示两个重复的单词。这种在后面的表达式中引用前面的分组的方式就叫做后向引用

除了匹配重复的单词，后向引用还有一个较为常见的应用，那就是匹配有效的 HTML 标签。我们知道，HTML 标签大多是成对出现的

string words = "<h0>not valid</h1> <h2>valid</h2> <h3>not valid</h4>";
foreach (Match match in Regex.Matches(words, @"<(.*?)>.*?</\1>"))
{
Console.WriteLine(match);
}

运行结果如图

string phonebook = "(010)88665987 (020)23658945 (021)88965222";
string pattern = @"$(\d{3,4})$(\d{7,8})";
string result = Regex.Replace(phonebook, pattern, "$1-$2");
Console.WriteLine(result);

替换文本

通过Regex类的Replace() 方法就能以特定字符串替换原字符串中与正则表达式匹配的子串。

在大部分语言的正则表达式中，查找时，使用后向引用的语法为“\number”；而在替换时，其语法为“$number”。例子中的 Regex.Replace ()方法把与正则表达式匹配的子串替换为“$1-$2”，其中$1 对应与分组 1（即区号），$2 对应分组 2（即电话号码）。运行结果如图所示

正则表达式 $(\d{3,4})$(\d{7,8}) 用于匹配一个特定的电话号码格式，其中电话号码由两部分组成：一个括号内的区号（可能是3位或4位数字），以及一个紧跟在括号后的7位或8位数字。

这里是该正则表达式的分解：

\(: 匹配左括号 ( 字符。因为在正则表达式中括号是特殊字符，所以需要使用反斜杠 \ 进行转义。
(\d{3,4}): 这是一个捕获组（因为它被括号包围），它匹配3位或4位的数字。\d 是数字的简写，{3,4} 表示前面的 \d 可以出现3次或4次。
\): 匹配右括号 ) 字符，同样也需要转义。
(\d{7,8}): 这是另一个捕获组，它匹配7位或8位的数字。

在.NET 中使用正则表达式进行替换时，分组的命名方式为：(?<name> subexpression)，
后向引用的语法是：${name}。所以上例也可以写为：
string phonebook = "(010)88665987 (020)23658945 (021)88965222";
string pattern = @"$(?<areacode>\d{3})$(?<number>\d{8})";
string result = Regex.Replace(phonebook, pattern, "${areacode}-${number}");
Console.WriteLine(result);

正向预查?= / 反向预查?<= / 负正向预查?!

有这样一段文本，它包含了六个员工的电话号码，如何能匹配到所有微软员工的
电话号码而不匹配其它公司的电话号码呢？
Jack boy 29 010-88127631 Microsoft, Sally 22 girl 010-88127632 Microsoft,
Ben boy 26 020-65423541 Google,Merry 23 girl 020-65423542 Google,
Alan boy 27 021-23456851 Apple,Kitty girl 18 021-23456852 Apple.
在正则表达式中，正向预查能帮我们解决这个问题，其语法为在分组中添加元字符
“?=”。
string text = @"Jack boy 29 010-88127631 Microsoft, Sally girl 22 010-88127632
Microsoft,Ben boy 26 020-65423541 Google,Merry girl 23
020-65423542 Google,Alan boy 27 021-23456851 Apple,Kitty girl
18 021-23456852 Apple.";
Console.WriteLine("The Telephone numbers of Microsoft are:");

如果仅仅使用正则表达式“\d{3}-\d{8}”，它就会匹配文本里所有的电话号码，那么如何让它只匹配微软的电话号码呢？这时就需要在它后面加上限制条件“(?= Microsoft)”。

需要强调的是正向预查表达式只是用来筛选查询目标，并不属于查询目标本身，不包含在最终结果中。运行结果如图

反向预查?<=

正向预查用来筛选查询目标，限制条件在查询目标的后面，反向预查也用来筛选查询目标，但限制条件在查询目标的前面，其语法是在分组中添加元字符“?<=”。

正则表达式“(?<=girl \d\d )\d{3}-\d{8}”匹配这样的电话号码，它们前面的文本必须与“girl \d\d ”匹配。

负正向预查?!

负正向预查与正向预查相反，查询目标后面不能跟指定的字符串，其语法为在分组中添加元字符“?!”

正则表达式“\d{3}-\d{8}(?! Microsoft)”匹配那些后面不跟“ Microsoft”的电话号码

负反向预查?

负反向预查与反向预查相反，查询目标前面不能跟指定字符串，其语法是在分组中添加元字符“?

正则表达式“(?<!girl \d\d )\d{3}-\d{8}”匹配这样的电话号码，它们前面的文本不能与
“girl \d\d ”匹配。

正则表达式的选项

通过 Regex 类的 Options 属性可以设置正则表达式的选项，表 20-5 是.Net 中常用的正则表达式选项

正则表达式默认是区分大小写的，可以通过 IgnoreCase 选项设置为不区分大小写。

string words = "ROOM215 Room315 room415";
string pattern = @"Room\d{3}";
Regex expression = new Regex(pattern, RegexOptions.IgnoreCase);
foreach (Match match in expression.Matches(words))
{
Console.WriteLine(match);
}

运行结果如图

如果想同时设置多个选项，可以把它们用按位或“|”连接起来。
new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Multiline);

注释#

遇到复杂的、比较难理解的正则表达式时，我们可以通过添加注释的方式进行解释说
明。在正则表达式中添加注释的语法为：(?#注释内容)。比如
@"$(\d{3,4})(?#该分组匹配区号)$(\d{7,8})(?#该分组匹配电话号码)"
编译器把以“?#”开头的分组当作注释，这些注释在编译时都会被忽略掉

练习：验证用户输入

private void btnOK_Click(object sender, EventArgs e)
{
string pattern = @"^SN\w{2}-\d{4}-[abc]{4}-[@#]{4}$";
if (Regex.IsMatch(TextBox.Text, pattern))
{
MessageBox.Show("注册成功！");
}
else
{
MessageBox.Show("注册码错误，请重新输入");
}
}