解讀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#中的正則表達式