C# 篇基础知识8——正则表达式
正则表达式（Regular Expression）也叫匹配模式(Pattern)，用来检验字符串是否满足特定规则，或从字符串中捕获满足特定规则的子串。正则表达式的命名空间是System.Text.RegularExpressions，Regex类即正则表达式。
1.字符匹配
最简单的正则表达式由“普通字符”和“通配符”组成。比如“Room\d\d\d”就这样的正则表达式。
这些特殊字符在正则表达式中称为元字符，因为符号“.”在正则表达式里已有特殊用处，所以要想表达“.”本身，需使用它的转移字符“\.”，要表达符号“\”本身，同样，需使用它的转移字符“\\”。 .NET 提供了一批与正则表达式相关的类，它们都位于System.Text.RegularExpressions命名空间，现在我们来学习最主要的Regex 类，并用它来匹配正则表达式。Regex 类的部分方法如表所示：
通过 Regex.Matches()方法，可以从给定字符串中分解出所有与正则表达式匹配的子串，这些子串被保存在一个MatchCollection 型集合中，每个子串都被看作Match 类的对象。
现在假设某份电子文件里包含着 Kitty 的房间号码(格式为RoomXXX)，档案很长，人工查阅很耗时间，那么如何通过计算机帮我们找到房间号码呢？
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); }
@前缀和转义字符，前面学习过控制文本格式的转义字符，如“\n”、“\"”、“\t”、“\\”等；现在我们又学习了正则表达式的转义字符，如“\.”、“\w”、“\d” 、“\s” 、“\\”等。在正则表达式中它们两者是有区别的。类似Regex expression = new Regex("\d");这样的语句是错误的，因为反斜杠“\”本身就是一个很特殊的字符，要想表示反斜杠本身，需要使用它的转移字符“\\”，所以需要写成下面的形式：Regex expression = new Regex("\\d");但这种形式会降低可读性，所以我们通常使用添加@前缀的方式。Regex expression = new Regex(@"\d");这时会忽略控制文本格式的转义字符，但不忽略正则表达式的转义字符。添加前缀@后，如果字符串里需要双引号本身，可以用两个连续的双引号表示。Regex expression = new Regex(@"Say ""Hello"" to Heaven");。
2.可选的字符集
通符符限定了某个位置上匹配的某一类型字符，但有时还想缩小匹配的范围，限定到某一类型的某一范围，这里可以把某个位置上允许出现的字符写在方括号[]内，组成可选字符集，比如：
[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]表示该位置可以出现任何字符，包括任何可见字符和不可见字符（如空格、制表符、换行等）
注意，不管中括号看起来有多长，它都只代表一个字符。表达式中的[VR]、[a-z]、[89]、[0-9]都是一个字符，不能看作多个字符。例如：
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(text))
{ Console.WriteLine(match); }
因为在中括号表达式中，“[”标志着中括号表达式的开始，而“]”标志着中括号表达式的结束，所以要想在中括号表达式外表示它本身，需使用它的转义字符“\[”、 “\]”，同样“-”表示连字符，要想在中括号表达式外表示它本身，需使用它们的转义字符“\-”。对于“-”还有不用转义字符的方式，也能使中括号包含“-”，例如把连字符放在中括号列表的开始或结尾，比如[-1-9]或[abc-]；
反向字符集，在中括号表达式用符号“^”表示非，例如[^x]表示匹配除x的所有字符，[^abc] 匹配除a、b、c 以外的所有字符。当然，当需要匹配它本身时，要在中括号表达式中使用它的转义字符“\^”。
3.或匹配｜
在正则表达式中用符号“|”表示“或”，其左右供部分与｜一起应放到()中。例如：
"x|y" 匹配 "x"或"y"
"good|ok" 匹配 "good"或"ok"
"(tr|b)ee" 匹配 "tree"或"bee"
"th(i|a)nk" 匹配 "think"或"thank"
"Book One|Two" 匹配 "Book One"或"Two"
"Book (One|Two)" 匹配 "Book One"或"Book Two"
因为符号“|”、“(”和“)”在正则表达式中也有特殊用处，所以当需要匹配它们本身时，也要使用它们的转义字符“\|”、“\(”“\)”。
4.数量限定符
数量限定符有多种，它们之间有细微的区别。
数量限定符“*”将前面的字符重复0 次或多次，而数量限定符“+”将前面的字符重复1 次或多次，数量限定符“？”将前面的字符重复0 次或1 次，如果需要明确指定重复次数，可使用数量限定符{n}，它表示把前面的字符重复n 遍，而数量限定符{n,}表示把它前面的字符至少重复n遍, 数量限定符{n,m}把前面的字符重复n至m遍。例如：
string words = "lg log loog looog loooog looooog";
//正则表达式
Regex expression = new Regex("lo*g");
//获取并输出匹配的字符串
foreach (Match match in expression.Matches(words))
{ Console.WriteLine(match); }
Regex expression1 = new Regex("lo+g");
//获取并输出匹配的字符串
foreach (Match match in expression1.Matches(words))
{ Console.WriteLine(match); }
Regex expression2 = new Regex("lo?g");
//获取并输出匹配的字符串
foreach (Match match in expression2.Matches(words))
{ Console.WriteLine(match); }
//正则表达式
Regex expression = new Regex("lo{3}g");
//获取并输出匹配的字符串
foreach (Match match in expression.Matches(words))
{ Console.WriteLine(match);}
//正则表达式
Regex expression = new Regex("lo{3,}g");
//获取并输出匹配的字符串
foreach (Match match in expression.Matches(words))
{ Console.WriteLine(match);}
//正则表达式
Regex expression = new Regex("lo{2,4}g");
//获取并输出匹配的字符串
foreach (Match match in expression.Matches(words))
{ Console.WriteLine(match);}
以上4个输出结果分别为：“lg loog looog loooog looooog”、 “log loog looog loooog looooog”、“lg log”、“looog”、“looog loooog looooog”、“loog looog loooog”。
用数量限定符还可以重复多个字符，例如：
string words = "lg leog leoeog leoeoeog leoeoeoeog leoeoeoeoeog";
//正则表达式
Regex expression = new Regex("l(eo)+g");
//获取并输出匹配的字符串
foreach (Match match in expression.Matches(words))
{ Console.WriteLine(match); }
正则表达式“l(eo)+g”表示字符串的第一个字符为l，最后一个字符为g，中间有一个或多个eo。结果为："leog leoeog leoeoeog leoeoeoeog leoeoeoeoeog"。
最奇妙的是这些数量限定符还可以与通配符组合。比如通配符“\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); }
结果为：Van is 16 、Vicky is 18、Vivien is 19、Vinvcent is 22
贪婪和懒惰
以上限定符都是“贪婪的”(Greedy)，它们会匹配尽可能多的文本。如果在限定符后加上？号，它就会变成“懒惰的”(Lazy)，会匹配尽可能少的文本。
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);}
使用贪婪的限定符有一条长子串与之匹配，使用懒惰的限定符有两条短子串与之匹配。所以结果分别为：<H1>Hello World</H1>、<H1> </H1>。。一个是“{n}?”，它实际上与“{n}”是等价的，因为不管是贪婪还是懒惰，都已经限定死了，只能重复n次。“?”是把“?”前面字母重复0 到1 次。因为“?”是贪婪的，能重复1 次就不重复0 次（实在没有也能匹配），“?？”是懒惰的，重复次数要尽量少，所以它选择重复0 次。
符号“*”、“+”、“？”“{”和“}”在正则表达式中也有特殊用处，所以当需要
匹配它们本身时，也要使用它们的转义字符“\*”、“\+”、“\？”“\{”和“\}”。
5.定位符
通过定位符可以在指定位置寻找匹配的子串。若正则表达式中使用了定位符“^”，则在整个字符串的头部寻找匹配的子串。例如string words = "year1998 year2008 year2018"; Regex expression = new Regex(@"^year\d\d\d\d");“^”匹配字符串的开头位置，所以“^year\d\d\d\d”表示要从字符串的开头位置开始寻找，这里匹配结果为year1998。若正则表达式中使用了定位符“$”，则在整个字符串的尾部寻找匹配的子串。string words = "year1998 year2008 year2018"; Regex expression = new Regex(@"year\d\d\d\d$");匹配结果为year2018。
若正则表达式中使用了定位符“\b”，则在字符串中每个“单词”的边界寻找匹配的子串。（单词通常以空格、段首、段尾、逗号、句号等符号作为边界，分隔符“-”也可以作为边界。但要注意“\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");}
结果为：form ford fork 、form、fork。
可以看出当没有定位符时，匹配单词中所有符合要求的子串；当定位符\b 在前面时，在单词的头部寻找匹配的子串；当定位符\b 在后面时，在单词的结尾寻找匹配的子串。常用正则表达式“\b\w+\b”找出一句话里的所有单词。
string words = "are you ok?";
Regex expression = new Regex(@"\b\w+\b");
foreach (Match match in expression.Matches(words))
{Console.WriteLine(match);}
结果为：are you ok。
显然，“^”和“$”在正则表达式中也有特殊用处，所以当要匹配它们本身时也需使用它们的转义字符“\^”和“\$”。
6.分组和向后引用
括号表达式并不简单的起着确定范围的作用，它同时会创建子表达式，每个子表达式形成一个分组，并把捕获到的与子表达式匹配的子串保存在分组中，以供将来使用。电子邮件地址通常由用户名、二级域名、一级域名三部分构成，通常用"(\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);}
结果为：very very。
前面已经知道“\b(\w+)\b”匹配一个单词，因为这里面有一个括号，所以会捕获一个以1 为组号的分组，后面的“\1”就代表这个分组，表示这个位置上出现和分组1 一样的内容。所以两者连起来就表示两个重复的单词。这种在后面的表达式中引用前面的分组的方式就叫做后向引用。除了匹配重复的单词，后向引用还有一个较为常见的应用，那就是匹配有效的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);}
结果为：<h2>valid</h2>。
7.替换文本
正则表达式除了查找文本外，另一项重要功能就是替换文本。通过Regex 类的Replace()方法就能以特定字符串替换原字符串中与正则表达式匹配的子串。下面通过一个例子说明如何替换文本以及如何在替换中引用分组。电话号码格式(010)88665987、(0769)23658945 ，可以用正则表达式“\((\d{3,4})\)(\d{7,8})”匹配，该表达式中有两个分组，第一个分组对应区号，第二个分组对应号码，现在来把电话本中所有的电话都改为形如010-88665987 的格式。
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);
结果：010-88665987、020-23658945、021-88965222。
在大部分语言的正则表达式中，查找时，使用后向引用的语法为“\number”；而在替换时，其语法为“$number”。 例子中的Regex.Replace ()方法把与正则表达式匹配的子串替换为“$1-$2”，其中$1 对应与分组1（即区号），$2 对应分组2（即电话号码）。
在.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);
8. 非捕获分组和预查
（1）非捕获后组?:
很多时候，我们添加一个分组，并不是为了在后向引用中使用它，而是出于表达上的需要。比如正则表达式“(tr|b)ee”中括号，仅仅是为了确定范围，使之正确匹配“tree”或“bee”。 存储分组会花费一定的时间，如果我们不需要存储分组，可以在分组内部添加元字符“?:”，把它标志成一个非捕获分组。"(?:tr|b)ee"。这样就不会存储分组了。
（2）正向预查?=和负正向预查?!
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:");
foreach (Match match in Regex.Matches(text, @"\d{3}-\d{8}(?= Microsoft)"))
{Console.WriteLine(match);}
结果为：010-88127631、010-88127632。
如果仅仅使用正则表达式“\d{3}-\d{8}”，它就会匹配文本里所有的电话号码，那么如何让它只匹配微软的电话号码呢？这时就需要在它后面的一个分组中添加元字符“(?= Microsoft)”作为限制条件，其格式如下所示。正向预查表达式用来筛选与查询目标表达式匹配的文本，其结果不光要和查询目标表达式匹配，它后面跟随的文本还要和正向预查表达式匹配。需要强调的是正向预查表达式只是用来筛选查询目标，并不属于查询目标本身，不包含在最终结果中。
负正向预查与正向预查相反，查询目标后面不能跟指定的字符串，其语法为在分组中添加元字符“?!”。 正则表达式“\d{3}-\d{8}(?! Microsoft)”匹配那些后面不跟“ Microsoft”的电话号码。
（3）反向预查?<=和负反向预查?<!
正向预查?=筛选查寻目标，限制条件在查询目标的后面，反向预查?<=筛选查寻目标时，限制条件则在查询目标的前面，这时就需要在它前面的一个分组中添加元字符“(?= Microsoft)”作为限制条件。其使用方法例如：
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 girls are:");
foreach (Match match in Regex.Matches(text, @"(?<=girl \d\d )\d{3}-\d{8}"))
{Console.WriteLine(match);}
负反向预查与反向预查相反，查询目标前面不能跟指定字符串，其语法是在分组中添加元字符“?<!”。正则表达式“(?<!girl \d\d )\d{3}-\d{8}”匹配这样的电话号码，它们前面的文本不能与“girl \d\d ”匹配。
总之，预查表达式的作用就是给查询目标添加限制条件，可以在前面，也可以在后面，可以正面限制，也可以反面限制。
9.正则表达式的类
和正则表达式相关的类都在命名空间System.Text.RegularExpressions 中，上图展示了部分常用正则表达式类。
string s = "aaa@163.com bbb@263.net ccc@363.cn";
MatchCollection matchs = Regex.Matches(s, @"(\w+)@(\w+)\.(\w+)");
//输出MatchCollection中所有的Match
Console.WriteLine("所有Match为:");
for (int i = 0; i < matchs.Count; i++)
{ Match match = matchs[i];
Console.WriteLine(match.Value); }
Macth 的Value 属性就是匹配的字符串，每个 Match 中都有一个Groups 属性，里面包含了该Match 的所有分组。其中第0 个分组是Match 本身
10.正则表达式的选项
通过Regex 类的Options 属性可以设置正则表达式的选项，下表是.Net 中常用的正则表达式选项。
例如：
string pattern = @"Room\d{3}";
Regex expression = new Regex(pattern, RegexOptions.IgnoreCase);
如果想同时设置多个选项，可以把它们用按位或“|”连接起来。
new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Multiline);
11.注释
遇到复杂的、比较难理解的正则表达式时，我们可以通过添加注释的方式进行解释说明。在正则表达式中添加注释的语法为：(?#注释内容)。比如：
@"\((\d{3,4})(?#该分组匹配区号)\)(\d{7,8})(?#该分组匹配电话号码)"。
