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中定义一个组为匹分大小写的,一个组不匹分大小写的
============================================
<$NextPage$>
正则表达式中的组是很重要的一个概念,它是我们通向高级正则应用的的桥梁 

组的概念 

一个正则表达式匹配结果可以分成多个部分,这就是组(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方法就能很方便的实现。 


        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的位置时不是从左到右定义的) 


        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的位置时不是从左到右定义的) 




        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的位置时不是从左到右定义的) 


        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)。
<$NextPage$>
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
posted on 2008-03-22 14:35  Eric Yao  阅读(208)  评论(0编辑  收藏  举报