解读C#中的正则表达式

本文摘自LTP.NET知识库。

regexp规则类包含在System.Text.RegularExpressions.dll文件中，在对应用软件进行编译时你必须引用这个文件：

System.Text.RegularExpressions.dll

名字空间简介

在名字空间中仅仅包含着6个类和一个定义，它们是：

Capture: 包含一次匹配的结果；

CaptureCollection: Capture的序列；

Group: 一次组记录的结果，由Capture继承而来；

Match: 一次表达式的匹配结果，由Group继承而来；

MatchCollection: Match的一个序列；

MatchEvaluator: 执行替换操做时使用的代理；

Regex: 编译后的表达式的实例。

Regex类中还包含一些静态的方法

Escape: 对字符串中的regex中的转义符进行转义；

IsMatch: 若是表达式在字符串中匹配，该方法返回一个布尔值；

Match: 返回Match的实例；

Matches: 返回一系列的Match的方法；

Replace: 用替换字符串替换匹配的表达式；

Split: 返回一系列由表达式决定的字符串；

Unescape:不对字符串中的转义字符转义。

简单匹配

先从使用Regex、Match类的简单表达式开始学习。

Match m = Regex.Match("abracadabra", "(a|b|r)+");

例：

if (m.Success)...

若是想使用匹配的字符串，能够把它转换成一个字符串：

Console.WriteLine("Match="+m.ToString());

输出: Match=abra。

这就是匹配的字符串。

字符串的替换

简单字符串的替换很是直观。

例以下面的语句：

string s = Regex.Replace("abracadabra", "abra", "zzzz");

它返回字符串zzzzcadzzzz，全部匹配的字符串都被替换成了zzzzz。

如今咱们来看一个比较复杂的字符串替换的例子：

string s = Regex.Replace(" abra ", @"^\s*(.*?)\s*$", "$1");

这个语句返回字符串abra，其前导和后缀的空格都去掉了。

上面的模式对于删除任意字符串中的前导和后续空格都很是有用。

在C#中，咱们还常用字母字符串，在一个字母字符串中，编译程序不把字符“ ” 做为转义字符处理。在使用字符“”指定转义字符时，@"..."是很是有用的。

另外值得一提的是$1在字符串替换方面的使用，它代表替换字符串只能包含被替换的字符串。

匹配引擎的细节

接下来经过一个组结构来理解一个稍微复杂的例子：

string text = "abracadabra1abracadabra2abracadabra3";    
string pat = @"    
      ( # 第一个组的开始    
       abra # 匹配字符串abra    
       ( # 第二个组的开始    
       cad # 匹配字符串cad    
       )? # 第二个组结束（可选）    
      ) # 第一个组结束    
      + # 匹配一次或屡次    
      "; 
   
    //利用x修饰符忽略注释    
    Regex r = new Regex(pat, "x"); 
   
    //得到组号码的清单    
    int[] gnums = r.GetGroupNumbers(); 
   
    //首次匹配    
    Match m = r.Match(text); 
   
    while (m.Success)    
     {    
    //从组1开始    
     for (int i = 1; i < gnums.Length; i++) 
   
      { 
   
      Group g = m.Group(gnums[i]); 
   
    //得到此次匹配的组    
      Console.WriteLine("Group"+gnums[i]+"=["+g.ToString()+"]"); 
   
    //计算这个组的起始位置和长度    
      CaptureCollection cc = g.Captures; 
   
      for (int j = 0; j < cc.Count; j++) 
   
       { 
   
       Capture c = cc[j]; 
   
       Console.WriteLine(" Capture" + j + "=["+c.ToString() 
   
         + "] Index=" + c.Index + " Length=" + c.Length); 
   
       }    
      }    
    //下一个匹配    
     m = m.NextMatch();    
     }

这个例子的输出以下所示：

Group1=[abra] 
   
        Capture0=[abracad] Index=0 Length=7 
   
        Capture1=[abra] Index=7 Length=4 
   
    Group2=[cad] 
   
        Capture0=[cad] Index=4 Length=3 
   
    Group1=[abra] 
   
        Capture0=[abracad] Index=12 Length=7 
   
        Capture1=[abra] Index=19 Length=4 
   
    Group2=[cad] 
   
        Capture0=[cad] Index=16 Length=3 
   
    Group1=[abra] 
   
        Capture0=[abracad] Index=24 Length=7 
   
        Capture1=[abra] Index=31 Length=4 
   
    Group2=[cad] 
   
        Capture0=[cad] Index=28 Length=3

咱们首先从考查字符串pat开始，pat中包含有表达式。

第一个capture是从第一个圆括号开始的，而后表达式将匹配到一个abra。

第二个capture组从第二个圆括号开始，但第一个capture组尚未结束，这意味着第一个组匹配的结果是abracad ，而第二个组的匹配结果仅仅是cad。

所以若是经过使用？符号而使cad成为一项可选的匹配，匹配的结果就多是abra或abracad。

而后，第一个组就会结束，经过指定+符号要求表达式进行屡次匹配。

如今咱们来看看匹配过程当中发生的状况。

首先，经过调用Regex的constructor方法创建表达式的一个实例，并在其中指定各类选项。

在这个例子中，因为在表达式中有注释，所以选用了x选项，另外还使用了一些空格。

打开x选项，表达式将会忽略注释和其中没有转义的空格。

而后，取得表达式中定义的组的编号的清单。

你固然能够显性地使用这些编号，在这里使用的是编程的方法。

若是使用了命名的组，做为一种创建快速索引的途径这种方法也十分有效。

接下来是完成第一次匹配。

经过一个循环测试当前的匹配是否成功，接下来是从group 1开始重复对组清单执行这一操做。

在这个例子中没有使用group 0的缘由是group 0是一个彻底匹配的字符串，若是要经过收集所有匹配的字符串做为一个单一的字符串，就会用到group 0了。

咱们跟踪每一个group中的CaptureCollection。

一般状况下每次匹配、每一个group中只能有一个capture，但本例中的Group1则有两个capture：Capture0和Capture1。

若是你仅须要Group1的ToString，就会只获得abra，固然它也会与abracad匹配。

组中ToString的值就是其CaptureCollection中最后一个Capture的值，这正是咱们所须要的。

若是你但愿整个过程在匹配abra后结束，就应该从表达式中删除+符号，让regex引擎知道咱们只须要对表达式进行匹配。

基于过程和基于表达式方法的比较

通常状况下，使用正则表达式的用户能够分为如下二大类：

第一类用户尽可能不使用正则表达式，而是使用过程来执行一些须要重复的操做；

第二类用户则充分利用正则表达式处理引擎的功能和威力，而尽量少地使用过程。

对于咱们大多数用户而言，最好的方案莫过于两者兼而用之了。

但愿这篇文章可以说明.NET语言中regexp类的做用以及它在性能和复杂性之间的优、劣点。

基于过程的模式

咱们在编程中常常须要用到的一个功能是对字符串中的一部分进行匹配或其余一些对字符串处理，下面是一个对字符串中的单词进行匹配的例子：

string text = "the quick red fox jumped over the lazy brown dog."; 
System.Console.WriteLine("text=[" + text + "]"); 
string result = ""; 
string pattern = @"\w+|\W+"; 
foreach (Match m in Regex.Matches(text, pattern)) 
{ 
   
    // 取得匹配的字符串    
     string x = m.ToString(); 
   
    // 若是第一个字符是小写    
     if (char.IsLower(x[0])) 
   
    // 变成大写    
    x = char.ToUpper(x[0]) + x.Substring(1, x.Length-1); 
   
    // 收集全部的字符    
     result += x; 
 } 
   
System.Console.WriteLine("result=[" + result + "]");

正象上面的例子所示，咱们使用了C#语言中的foreach语句处理每一个匹配的字符，并完成相应的处理，在这个例子中，新建立了一个result字符串。

这个例子的输出所下所示：

text=[the quick red fox jumped over the lazy brown dog.] 
result=[The Quick Red Fox Jumped Over The Lazy Brown Dog.]

基于表达式的模式

完成上例中的功能的另外一条途径是经过一个MatchEvaluator，新的代码以下所示：

static string CapText(Match m) 
   
      { 
   
    //取得匹配的字符串 
   
      string x = m.ToString(); 
   
    // 若是第一个字符是小写 
   
      if (char.IsLower(x[0])) 
   
    // 转换为大写 
   
       return char.ToUpper(x[0]) + x.Substring(1, x.Length-1); 
   
      return x; 
   
      } 
   
       
   
     static void Main() 
   
      { 
   
      string text = "the quick red fox jumped over the 
   
       lazy brown dog."; 
   
      System.Console.WriteLine("text=[" + text + "]"); 
   
      string pattern = @"\w+"; 
   
      string result = Regex.Replace(text, pattern, 
   
     new MatchEvaluator(Test.CapText)); 
   
      System.Console.WriteLine("result=[" + result + "]"); 
   
      }

同时须要注意的是，因为仅仅须要对单词进行修改而无需对非单词进行修改，这个模式显得很是简单。

本文来自 木庄网络博客> 解读C#中的正则表达式