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

一、前言

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

转载自：http://www.cnblogs.com/think/

http://www.cnblogs.com/thinhunan/archive/2006/02/28/RegexExpressionSyntax1.html

http://www.cnblogs.com/thinhunan/archive/2006/03/01/regexexpressionsyntax2.html

http://www.cnblogs.com/thinhunan/archive/2006/03/02/regexexpressionsyntax3.html

http://www.cnblogs.com/thinhunan/archive/2006/03/03/regexexpressionsyntax4.html

1、高级技巧1

替换

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在new Regex时定义Regex表达式的全局选项来说，内联标志可以更小粒度（以组为单位）的定义匹配选项，从而更方便表达我们的思想

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

2、高级技巧2

组的概念

一个正则表达式匹配结果可以分成多个部分，这就是组(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)。 

3、高级技巧3

反向引用

反向引用，指把匹配出来的组引用到表达式本身其它地方，比如，在匹配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+，所以整个表达式匹配失败。

4、高级技巧4

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’

附表

 --完--