.net中的正则表达式使用高级技巧

.net中的正则表达式使用高级技巧

前言

一、本系列文章不讲述基本的正则语法，这些可以在微软的 JS 帮助文档中找到，也可以 Google 一下
二、写系列文章的原因
1 、正则很有用，而且经常要用
2 、正则的一些高级用法有相当一部分人还没有理解和掌握
3 、刚好又在网上看到了一篇文章错误的使用了正则式，使我有了写本文的冲动
4 、本系列文章的大部分知识可同时适用于 .net 语言， JavaScript 等
三、本系列文章特点：尽量使用小例子来说明相对难懂而很多正则书籍都没有说清的正则语法
四、本系列文章内容：替换的高级语法，内联表达式选项，组，反向引用，正声明，负声明，正反声明，负反声明，非回溯匹配，判断式， .net 正则引擎特点等  

 

因为 .net 的基本正则语法和 Perl5 基本相同，所以基本语法你可以去下载一下 M$ 的 JS 帮助文档，上面有详细的说明 /d 表示什么， {,5} 表示什么， /[ 表示什么……，这里我只想提醒大家一点，为了避免和反向引用相冲突，在你用 /nn 表示八进制的 ASCII 码时，请在 / 后加 0 ，就是说，/40在表示ASCII码时，请这样写/040。

替换

Regex 类有一个静态的 Replace 方法，其实例也有一个 Replace 方法，这个方法很强大，因为它可以传入一个 delegate ，这样，你可以自定义每次捕获匹配时，如何处理捕获的内容。  

         public   static   void  Main()
         {    
             string  s  =   " 1 12 3 5 " ;
            s  =  Regex.Replace(s, @" /d+ " , new  MatchEvaluator(CorrectString),RegexOptions.Compiled | RegexOptions.IgnoreCase);
            Console.WriteLine(s);
            Console.ReadLine();
        }
         private   static   string  CorrectString(Match match)
         {
             string  matchValue  =  match.Value;
             if (matchValue.Length  ==   1 )
                matchValue  =   " 0 "   +  matchValue;
             return  matchValue;
        }

以上这段代码说明了如果使用 delegate MatchEvaluator 来处理正则的 Match 结果，该代码返回 "01 12 03 05" 。 Replace 方法除了使用 delegate 来处理捕获的 Match ，还可以用字符串来替换 Match 的结果，而用字符串来替换 Match 结果除了把 Match 结果静态的替换成一个固定的文本外，还可以使用以下语法来更方便的实现你需要的功能：

 

$number

把匹配的第 number 组替换成替换表达式，还有这句话怎么写也表达不清楚意思，还是来个例子吧：          public   static   void  Main()          {                  string  s  =   " 1 12 3 5 " ;             s  =  Regex.Replace(s, @" (/d+)(?#这个是注释) " , " 0$1 " ,RegexOptions.Compiled | RegexOptions.IgnoreCase);             Console.WriteLine(s);             Console.ReadLine();         } 这段代码返回的是 “ 01 012 03 05 ”   就是说，对组一的每个匹配结果都用 "0$1" 这个表达式来替换， "0$1" 中 "$1" 由组 1 匹配的结果代入

 

 

${name}

 

把匹配的组名为 "name" 的组替换成表达式，

上例的 Regex expression 改成 @"(?<name>/d+)(?# 这个是注释 )" 后面的替换式改为 "0${name}" 结果是一样的

 

$$   

 

做 $ 的转义符，如上例表达式改成 @"(?<name>/d+)(?# 这个是注释 )" 和 "$$${name}" ，则结果为 "$1 $12 $3 $5"

 

$&

 

替换整个匹配

 

$`

 

替换匹配前的字符

 

$'

 

替换匹配后的字符

 

$+

 

替换最后匹配的组

 

$_

 

替换整个字符串

后面的选项，大家自己写个例子体味一下。

* 注 , 上例中的 (?# 这个是注释 ) 说明了正则的内联注释语法为 (?#)

表达项选项

正则表达式选项 RegexOptions 有如下一下选项，详细说明请参考联机帮助

 

RegexOptions 枚举值	内联标志	简单说明
ExplicitCapture	n	只有定义了命名或编号的组才捕获
IgnoreCase	i	不区分大小写
IgnorePatternWhitespace	x	消除模式中的非转义空白并启用由 # 标记的注释。
MultiLine	m	多行模式，其原理是修改了 ^ 和 $ 的含义
SingleLine	s	单行模式，和 MultiLine 相对应

这里我提到内联标志，是因为相对于用 RegexOptions 在 new Regex 时定义 Regex 表达式的全局选项来说，内联标志可以更小粒度（以组为单位）的定义匹配选项，从而更方便表达我们的思想

语法是这样的： (?i:expression) 为定义一个选项， (?-i:expression) 为删除一个选项， (?i-s:expression) 则定义 i ，删除 s, 是的，我们可以一次定义很多个选项。这样，通过内联选项，你就可以在一个 Regex 中定义一个组为匹分大小写的，一个组不匹分大小写的，是不是很方便呢 ?

更多精彩内容，请看下回分解，

下一篇： .net中的正则表达式使用高级技巧 （二）   
                .net中的正则表达式使用高级技巧 （三）  
                .net中的正则表达式使用高级技巧 （四）

正则表达式中的组是很重要的一个概念，它是我们通向高级正则应用的的桥梁

组的概念

一个正则表达式匹配结果可以分成多个部分，这就是组 (Group) 的目的。能够灵活的使用组后，你会发现 Regex 真是很方便，也很强大。

先举个例子   

         public   static   void  Main()
         {    
             string  s  =   " 2005-2-21 " ;
            Regex reg  =   new  Regex( @" (?<y>/d{4})-(?<m>/d{1,2})-(?<d>/d{1,2}) " ,RegexOptions.Compiled);
            Match match  =  reg.Match(s);
             int  year  =    int .Parse(match.Groups[ " y " ].Value);
             int  month  =   int .Parse(match.Groups[ " m " ].Value);
             int  day  =   int  .Parse(match.Groups[ " d " ].Value);
            DateTime time  =   new  DateTime(year,month,day);
            Console.WriteLine(time);
            Console.ReadLine();
        }

以上的例子通过组来实现分析一个字符串，并把其转化为一个 DateTime 实例，当然，这个功能用 DateTime.Parse 方法就能很方便的实现。

在这个例子中，我把一次 Match 结果用 (?<name>) 的方式分成三个组 "y","m","d" 分别代表年、月、日。

现在我们已经有了组的概念了，再来看如何分组，很简单的，除了上在的办法，我们可以用一对括号就定义出一个组，比如上例可以改成   

         public   static   void  Main()
         {    
             string  s  =   " 2005-2-21 " ;
            Regex reg  =   new  Regex( @" (/d{4})-(/d{1,2})-(/d{1,2}) " ,RegexOptions.Compiled);
            Match match  =  reg.Match(s);
             int  year  =    int .Parse(match.Groups[ 1 ].Value);
             int  month  =   int .Parse(match.Groups[ 2 ].Value);
             int  day  =   int  .Parse(match.Groups[ 3 ].Value);
            DateTime time  =   new  DateTime(year,month,day);
            Console.WriteLine(time);
            Console.ReadLine();
        }

从上例可以看出，第一个括号对包涵的组被自动编号为1,后面的括号依次编号为2、3……  

         public   static   void  Main()
         {    
             string  s  =   " 2005-2-21 " ;
            Regex reg  =   new  Regex( @" (?<2>/d{4})-(?<1>/d{1,2})-(?<3>/d{1,2}) " ,RegexOptions.Compiled);
            Match match  =  reg.Match(s);
             int  year  =    int .Parse(match.Groups[ 2 ].Value);
             int  month  =   int .Parse(match.Groups[ 1 ].Value);
             int  day  =   int  .Parse(match.Groups[ 3 ].Value);
            DateTime time  =   new  DateTime(year,month,day);
            Console.WriteLine(time);
            Console.ReadLine();
        }

再看上例，我们用 (?< 数字 >) 的方式手工给每个括号对的组编号，（注意我定义 1 和 2 的位置时不是从左到右定义的）

通过以上三例，我们知道了给 Regex 定义 Group 的三种办法以及相应的引用组匹配结果的方式。

然后，关于组定义，还有两点请注意：
1 、因为括号用于定义组了，所以如果要匹配 "(" 和 ")" ，请使用 "/(" 和 "/)"( 关于所有特殊字符的定义，请查看相关 Regex expression 帮助文档 ) 。
2 、如果定义 Regex 时，使用了 ExplicitCapture 选项，则第二个例子不会成功，因为此选项要求显式定义了编号或名字的组才捕获并保存结果，如果你没有定义 ExplicitCapture 选项，而有时又定义了类式于 (A|B) 这样的部分在表达式，而这个 (A|B) 你又并不想捕获结果，那么可以使用“不捕获的组”语法，即定义成 (?:) 的方式，针对于 (A|B), 你可以这样来定义以达到不捕获并保存它到 Group 集合中的目的－－ (?:A|B) 。  

上面内容仅讨论了一般的组，组还有很多的花样，很多高级的功能，下一篇将试图带您体验一番其中洞天。

反向引用

反向引用，指把匹配出来的组引用到表达式本身其它地方，比如，在匹配 HTML 的标记时，我们匹配出一个 <a>, 我们要把匹配出来的 a 引用出来，用来找到 </a> ，这个时候就要用到反向引用。
语法
    a 、反向引用编号的组，语法为 /number
    b 、反向引用命名的组，语法为 /k<name>
举例
    a 、匹配成对的 HTML 标签

@" <(?<tag>[^/s>]+)[^>]*>.*<//k<tag>> "         

    b 、匹配两个两个重叠出现的字符   

         public   static   void  Main()
         {    
             string  s  =   " aabbc11asd " ;
            Regex reg  =   new  Regex( @" (/w)/1 " );
            MatchCollection matches  =  reg.Matches(s);
             foreach (Match m  in  matches)
                Console.WriteLine(m.Value);
            Console.ReadLine();
        }       

返回结果为 aa bb 11  

辅助匹配组

以下几种组结构，括号中的 Pattern 都不作为匹配结果的一部分进行保存
    1 、正声明 (?=)
    涵义：括号中的模式必须出现在声明右侧，但不作为匹配的一部分

         public   static   void  Main()
         {    
             string  s  =   " C#.net,VB.net,PHP,Java,JScript.net " ;
            Regex reg  =   new  Regex( @" [/w/#]+(?=/.net) " ,RegexOptions.Compiled);
            MatchCollection mc  =  reg.Matches(s);
             foreach (Match m  in  mc)
                Console.WriteLine(m.Value); 
            Console.ReadLine();
             // 输出 C# VB JScript
        }

    可以看到匹配引擎要求匹配.net，但却不把.net 放到匹配结果中
    2 、负声明 (?!)
     涵义：括号中的模式必须不出现在声明右侧
         下例演示如何取得一个 <a> 标签对中的全部内容，即使其中包含别的 HTML tag 。

         public   static   void  Main()
         { 
             string  newsContent  =   @" url:<a href=""1.html""><img src=""1.gif"">test<span style=""color:red;"">Regex</span></a>. " ;
            Regex regEnd  =   new  Regex( @" </s*a[^>]*>([^<]|<(?!/a))*</s*/a/s*> " ,RegexOptions.Multiline);
            
            Console.WriteLine(regEnd.Match(newsContent).Value);
// Result: <a href="1.html"><img src="1.gif">test<span style="color:red;">Regex</span></a>
            Console.ReadLine();
        }

    3、反向正声明 (?<=) 
    涵义：括号中的模式必须出现在声明左侧，但不作为匹配的一部分
    4 、反向负声明 (?<!)
    涵义：括号中的模式必须不出现在声明左侧

非回溯匹配
语法： (?>)
涵义：该组匹配后，其匹配的字符不能通过回溯用于后面的表达式的匹配。呵呵，光看这句话肯定搞不懂，我当初为了搞懂这个也花了不少的时间，还是通过实例来说明吧：
"www.csdn.net" 可以通过 @"/w+/.(.*)/./w+" 来匹配，却不能通过 @"/w+/.(?>.*)/./w+" 来匹配！为什么呢？

原因是正则匹配是贪婪的，匹配时它会尽可能多的匹配最多的结果，所以，上例两个正则式中的 .* 都会把 csdn.net 匹配完， 这个时候，第一个表达式在开始匹配时发现 /./w+ 没得字符给它匹配了，所以它会进行回溯，所谓回溯，就是把 .* 匹配的结果往回推，回推留出来的字符再用来匹配 /./w+, 直到 /./w+ 匹配成功，整个表达式返回成功的匹配结果。而第二个表达式，因使用的是非回溯匹配，所以， .* 匹配完后，不允许通过回溯来匹配 /./w+ ，所以整个表达式匹配失败。

请注意，回溯匹配是很浪费资源的一种匹配方式，所以，请尽量避免您的正则式要通过回溯来成功匹配，如上例， 可以换成@"/w+/.([^/.]+/.)+/w+" +" 。

Lazy 匹配

语法： ??,*?,+?,{n}?,{n,m}?

涵义：简单说，后面的这个 ?(lazy 符 ) 告诉正则引擎，它前面的表达式匹配到最短的匹配项就不用匹配下去了，如 ?? ， ? 本身匹配 0-1 个匹配项，那么 ?? 就取最短的，匹配 0 个项就不匹配下去了，同理， *? 匹配 0 个， +? 匹配 1 个， {n}? 匹配 n 个， {n,m}? 匹配 n 个。当用 @”/w*?” 匹配 ”abcd” 时，会有 五次 成功匹配， 每次都匹配的结果都是空字符串 ， 为什么会是 5 次呢 ，这是因为正则引擎在匹配一个表达式时是一个字符一个字符对比下去的，每成功匹配一次，就前进一下。

判断表达式

语法：

    1 、 A|B ，这个是最基本的， A 或者 B ，其实这个不能算判断
    2 、 (?(expression)yes-expression|no-expression), 其中 no-expression 为可选项，意为，如果 expression 成立，则要求匹配 yes-expression, 否则要求匹配 no-expression
    3 、 (?(group-name)yes-expressioin|no-expression), 其中 no-expression 为可选项，意为，如果名为 group-name 的组匹配成功，则要求匹配 yes-expression, 否则要求匹配 no-expression
      判断表达式还是很好理解的，唯有一点要注意： @"(?(A)A|B)" 不能匹配 "AA", 为什么呢 ? 要怎么样写才能匹配呢，大家先想想……

我们应该这样写 Regex: @”(?(A)AA|B)” ，请注意，判断式中的内容并不会做为 yes-expression 或 no-expression 表达式的一部分。  

.net 的正则引擎工作特点

    .net 的正则引擎工作方式大多数和我们“想当然”的方式一样，只是有几点要注意：
    1 、 .NET Framework 正则表达式引擎尽可能的匹配多的字符（贪婪）。正是由于这一点，所以，不要用 @"<.*>(.*)</.*>" 这样的正则式来试图找出一个 HTML 文档中的所有 innerText 。（我也正是在网上看到有人这样写正则式才决定要写《正则表达式 高级技巧》的，呵呵）
2 、 .NET Framework 正则表达式引擎是回溯的正则表达式匹配器，它并入了传统的非确定性有限自动机 (NFA) 引擎（例如 Perl 、 Python 使用的引擎）。这使其有别于更快的、但功能更有限的纯正则表达式确定性有限自动机 (DFA) 引擎。 .NET Framework 正则表达式引擎尽量匹配成功，所以，当 @"/w+/.(.*)/./w+" 中的 .* 把 www. .csdn.net 中的 .csdn.net 都匹配完了，让后面的 /./w+ 没得字符去匹配时，引擎会进行回溯，以得到成功的匹配。
NET Framework 正则表达式引擎还包括了一组完整的语法，让程序员能够操纵回溯引擎。包括：
“惰性”限定符： ?? 、 *? 、 +? 、 {n,m}? 。这些惰性限定符指示回溯引擎首先搜索最少数目的重复。与之相反，普通的“贪婪的”限定符首先尝试匹配最大数目的重复。
从右到左匹配。这在从右到左而非从左到右搜索的情况下十分有用，或者在从模式的右侧部分开始搜索比从模式的左侧部分开始搜索更为有效的情况下十分有用。
3 、 .NET Framework 正则表达式引擎在 (expression1|expression2|expression3) 这样情况下， expression1 总是最先得到尝试，再依次是 expression2 和 expression3            

         public   static   void  Main()
         {    
             string  s  =   " THIN is a asp.net developer. " ;
            Regex reg  =   new  Regex( @" (/w{2}|/w{3}|/w{4}) " ,RegexOptions.Compiled | RegexOptions.IgnoreCase);
            MatchCollection mc  =  reg.Matches(s);
             foreach (Match m  in  mc)
                Console.WriteLine(m.Value); 
            Console.ReadLine();
    }

输出结果是 : ‘ TH’ ‘IN’ ‘is’ ‘as’ ‘ne’ ‘de’ ‘ve’ ‘lo’ ‘pe’

附表

 

转义符	说明
一般字符	除 .$ ^ { [ ( | ) * + ? / 外，其他字符与自身匹配。
/a	与响铃（警报） /u0007 匹配。
/b	在正则表达式中， /b 表示单词边界（在 /w 和 /W 之间），不过，在 [] 字符类中， /b 表示退格符。在替换模式中， /b 始终表示退格符。
/t	与 Tab 符 /u0009 匹配。
/r	与回车符 /u000D 匹配。
/v	与垂直 Tab 符 /u000B 匹配。
/f	与换页符 /u000C 匹配。
/n	与换行符 /u000A 匹配。
/e	与 Esc 符 /u001B 匹配。
/040	将 ASCII 字符匹配为八进制数（最多三位）；如果没有前导零的数字只有一位数或者与捕获组号相对应，则该数字为后向引用。例如，字符   /040 表示空格。
/x20	使用十六进制表示形式（恰好两位）与 ASCII 字符匹配。
/cC	与 ASCII 控制字符匹配；例如， /cC 为 Ctrl-C 。
/u0020	使用十六进制表示形式（恰好四位）与 Unicode 字符匹配。
/	在后面带有不识别为转义符的字符时，与该字符匹配。例如， /* 与 /x2A 相同。
字符类	说明
.	匹配除 /n 以外的任何字符。如果已用 Singleline 选项做过修改，则句点字符可与任何字符匹配。
[ aeiou ]	与指定字符集中包含的任何单个字符匹配。
[^ aeiou ]	与不在指定字符集中的任何单个字符匹配。
[0-9a-fA-F]	使用连字号 (–) 允许指定连续字符范围。
/p{ name }	与 {name} 指定的命名字符类中的任何字符都匹配。支持的名称为 Unicode 组和块范围。例如， Ll 、 Nd 、 Z 、 IsGreek 、 IsBoxDrawing 。可以使用 GetUnicodeCategory 方法找到某个字符所属的 Unicode 类别。
/P{ name }	与在 {name} 中指定的组和块范围不包括的文本匹配。
/w	与任何单词字符匹配。等效于 Unicode 字符类别 [/p{Ll}/p{Lu}/p{Lt}/p{Lo}/p{Nd}/p{Pc}/p{Lm}] 。如果用 ECMAScript 选项指定了符合 ECMAScript 的行为，则 /w 等效于 [a-zA-Z_0-9] 。
/W	与任何非单词字符匹配。等效于 Unicode 字符类别 [^/p{Ll}/p{Lu}/p{Lt}/p{Lo}/p{Nd}/p{Pc}/p{Lm}] 。如果用 ECMAScript 选项指定了符合 ECMAScript 的行为，则 /W 等效于 [^a-zA-Z_0-9] 。
/s	与任何空白字符匹配。等效于 Unicode 字符类别 [/f/n/r/t/v/x85/p{Z}] 。如果用 ECMAScript 选项指定了符合 ECMAScript 的行为，则 /s 等效于 [ /f/n/r/t/v] 。
/S	与任何非空白字符匹配。等效于 Unicode 字符类别 [^/f/n/r/t/v/x85/p{Z}] 。如果用 ECMAScript 选项指定了符合 ECMAScript 的行为，则 /S 等效于 [^ /f/n/r/t/v] 。
/d	与任何十进制数字匹配。对于 Unicode 类别的 ECMAScript 行为，等效于 /p{Nd} ，对于非 Unicode 类别的 ECMAScript 行为，等效于 [0-9] 。
/D	与任何非数字匹配。对于 Unicode 类别的 ECMAScript 行为，等效于 /P{Nd} ，对于非 Unicode 类别的 ECMAScript 行为，等效于 [^0-9] 。
断言	说明
^	指定匹配必须出现在字符串的开头或行的开头。。
$	指定匹配必须出现在以下位置：字符串结尾、字符串结尾处的 /n 之前或行的结尾。
/A	指定匹配必须出现在字符串的开头（忽略 Multiline 选项）。
/Z	指定匹配必须出现在字符串的结尾或字符串结尾处的 /n 之前（忽略 Multiline 选项）。
/z	指定匹配必须出现在字符串的结尾（忽略 Multiline 选项）。
/G	指定匹配必须出现在上一个匹配结束的地方。与 Match.NextMatch() 一起使用时，此断言确保所有匹配都是连续的。
/b	指定匹配必须出现在 /w （字母数字）和 /W （非字母数字）字符之间的边界上。匹配必须出现在单词边界上，即出现在由任何非字母数字字符分隔的单词中第一个或最后一个字符上。
/B	指定匹配不得出现在 /b 边界上。
限定符	说明
*	指定零个或更多个匹配；例如 /w* 或 (abc)* 。等效于 {0,} 。
+	指定一个或多个匹配；例如 /w+ 或 (abc)+ 。等效于 {1,} 。
?	指定零个或一个匹配；例如 /w? 或 (abc)? 。等效于 {0,1} 。
{ n }	指定恰好 n 个匹配；例如 (pizza){2} 。
{ n ,}	指定至少 n 个匹配；例如 (abc){2,} 。
{ n , m }	指定至少 n 个但不多于 m 个匹配。
*?	指定尽可能少地使用重复的第一个匹配（等效于 lazy * ）。
+?	指定尽可能少地使用重复但至少使用一次（等效于 lazy + ）。
??	指定使用零次重复（如有可能）或一次重复 (lazy ?) 。
{ n }?	等效于 {n} (lazy {n}) 。
{ n ,}?	指定尽可能少地使用重复但至少使用 n 次 (lazy {n,}) 。
{ n , m }?	指定介于 n 次和 m 次之间、尽可能少地使用重复 (lazy {n,m}) 。

 --完--