916
.NET正則基礎之——平衡組
1 概述
平衡組是微軟在.NET中提出的一個概念，主要是結合幾種正則語法規則，提供對配對出現的嵌套結構的匹配。.NET是目前對正則支持最完備、功能最強大的語言平台之一，而平衡組正是其強大功能的外在表現，也是比較實用的文本處理功能，目前隻有.NET支持，相信後續其它語言會提供支持。
平衡組可以有狹義和廣義兩種定義，狹義平衡組指.NET中定義的(?<Close-Open>Expression)語法，廣義平衡組並不是固定的語法規則，而是幾種語法規則的綜合運用，我們平時所說的平衡組通常指的是廣義平衡組。本文中如無特殊說明，平衡組這種簡寫指的是廣義平衡組。
正是由於平衡組功能的強大，所以帶來了一些神秘色彩，其實平衡組並不難掌握。下麵就平衡組的匹配原理、應用場景以及性能調優展開討論。
2 平衡組匹配原理
2.1 預備知識
平衡組通常是由量詞，分支結構，命名捕獲組，狹義平衡組，條件判斷結構組成的，量詞和分支結構這裏不做介紹，這裏隻對命名捕獲組，狹義平衡組和條件判斷結構做下說明。
2.1.1 命名捕獲組
語法：(?<name>Expression)
(?’name’Expression)
以上兩種寫法在.NET中是等價的，都是將“Expression”子表達式匹配到的內容，保存到以“name”命名的組裏，以供後續引用。
對於命名捕獲組的應用，這裏不做重點介紹，隻是需要澄清一點，平時使用捕獲組時，一般反向引用或Group對象使用得比較多，可能會有一種誤解，那就是捕獲組隻保留一個匹配結果，即使一個捕獲組可以先後匹配多個子串，也隻保留最後一個匹配到的子串。但事實是這樣嗎？
舉例來說：
源字符串：abcdefghijkl
正則表達式：(?<chars>[a-z]{2})+
命名捕獲組chars最終捕獲的是什麼？
string test = "abcdefghijkl";
Regex reg = new Regex(@"(?<chars>[a-z]{2})+");
Match m = reg.Match(test);
if (m.Success)
{
richTextBox2.Text += "匹配結果：" + m.Value + "\n";
richTextBox2.Text += "Group：" + m.Groups["chars"].Value + "\n";
}
/*--------輸出--------
匹配結果：abcdefghijkl
Group：kl
*/
從m.Groups["chars"].Value的輸出上看，似乎確實是隻保留了一個匹配內容，但卻忽略了一個事實，Group實際上是Capture的一個集合
string test = "abcdefghijkl";
Regex reg = new Regex(@"(?<chars>[a-z]{2})+");
Match m = reg.Match(test);
if (m.Success)
{
richTextBox2.Text += "匹配結果：" + m.Value + "\n";
richTextBox2.Text += "Group：" + m.Groups["chars"].Value + "\n--------------\n";
foreach (Capture c in m.Groups["chars"].Captures)
{
richTextBox2.Text += "Capture：" + c + "\n";
}
}
/*--------輸出--------
匹配結果：abcdefghijkl
Group：kl
--------------
Capture：ab
Capture：cd
Capture：ef
Capture：gh
Capture：ij
Capture：kl
*/
平時應用時可能會忽略這一點，因為很少遇到一個捕獲組先後匹配多個子串的情況，而在一個捕獲組隻匹配一個子串時，Group集合中就隻有一個Capture元素，所以內容是一樣的。
string test = "abcdefghijkl";
Regex reg = new Regex(@"(?<chars>[a-z]{2})");
Match m = reg.Match(test);
if (m.Success)
{
richTextBox2.Text += "匹配結果：" + m.Value + "\n";
richTextBox2.Text += "Group：" + m.Groups["chars"].Value + "\n--------------\n";
foreach (Capture c in m.Groups["chars"].Captures)
{
richTextBox2.Text += "Capture：" + c + "\n";
}
}
/*--------輸出--------
匹配結果：ab
Group：ab
--------------
Capture：ab
*/
捕獲組保存的是一個集合，而不隻是一個元素，這一知識點對於理解平衡組的匹配原理是有幫助的。
2.1.2 狹義平衡組
語法：(?<Close-Open>Expression)
其中“Close”是命名捕獲組的組名，也就是“(?<name>Expression)”中的“name”，可以省略，通常應用時並不關注，所以一般都是省略的，寫作“(?<-Open>Expression)”。作用就是當此處的“Expression”子表達式匹配成功時，則將最近匹配成功到的命名為“Open”組出棧，如果此前不存在匹配成功的“Open”組，那麼就報告“(?<-Open>Expression)”匹配失敗，整個表達式在這一位置也是匹配失敗的。
2.1.3 條件判斷結構
語法：(?(Expression)yes|no)
(?(name)yes|no)
對於“(?(Expression)yes|no)”，它是“(?(?=Expression)yes|no)”的簡寫形式，相當於三元運算符
(?=Expression) ? yes : no
表示如果子表達式“(?=Expression)”匹配成功，則匹配“yes”子表達式，否則匹配“no”子表達式。如果“Expression”與可能出現的命名捕獲組的組名相同，為避免混淆，可以采用“(?(?=Expression)yes|no)”方式顯示聲明“Expression”為子表達式，而不是捕獲組名。
“(?=Expression)”驗證當前位置右側是否能夠匹配“Expression”，屬於順序環視結構，是零寬度的，所以它隻參與判斷，即使匹配成功，也不會占有字符。
舉例來說：
源字符串：abc
正則表達式：(?(?=a)\w{2}|\w)
當前位置右側如果是字符“a” ，則匹配兩個“\w”，否則匹配一個“\w”。
string test = "abc";
Regex reg = new Regex(@"(?(?=a)\w{2}|\w)");
MatchCollection mc = reg.Matches(test);
foreach(Match m in mc)
{
richTextBox2.Text += m.Value + "\n";
}
/*--------輸出--------
ab
c
*/
對於“(?(name)yes|no)”，如果命名捕獲組“name”有捕獲，則匹配“yes”子表達式，否則匹配“no”子表達式。這一語法最典型的一種應用是平衡組。
當然，以上兩種語法中，“yes”和“no都是可以省略的，但同一時間隻能省略一個，不能一起省略。平衡組的應用中就是省略了“no”子表達式。
2.2 平衡組的匹配原理
平衡組的匹配原理可以用堆棧來解釋，先舉個例子，再根據例子進行解釋。
源字符串：a+(b*(c+d))/e+f-(g/(h-i))*j
正則表達式：\(((?<Open>\()|(?<-Open>\))|[^()])*(?(Open)(?!))\)
需求說明：匹配成對出現的()中的內容
string test = "a+(b*(c+d))/e+f-(g/(h-i))*j";
Regex reg = new Regex(@"\(((?<Open>\()|(?<-Open>\))|[^()])*(?(Open)(?!))\)");
MatchCollection mc = reg.Matches(test);
foreach (Match m in mc)
{
richTextBox2.Text += m.Value + "\n";
}
/*--------輸出--------
(b*(c+d))
(g/(h-i))
*/
下麵來考察一下這個正則，為了閱讀方便，寫成寬鬆模式。
Regex reg = new Regex(@"\( #普通字符“(”
( #分組構造，用來限定量詞“*”修飾範圍
(?<Open>\() #命名捕獲組，遇到開括弧’Open’計數加1
| #分支結構
(?<-Open>\)) #狹義平衡組，遇到閉括弧’Open’計數減1
| #分支結構
[^()]+ #非括弧的其它任意字符
)* #以上子串出現0次或任意多次
(?(Open)(?!)) #判斷是否還有’Open’，有則說明不配對，什麼都不匹配
\) #普通閉括弧
", RegexOptions.IgnorePatternWhitespace);
對於一個嵌套結構而言，開始和結束標記都是確定的，對於本例開始為“(”，結束為“)”，那麼接下來就是考察中間的結構，中間的字符可以劃分為三類，一類是“(”，一類是“)”，其餘的就是除這兩個字符以外的任意字符。
那麼平衡組的匹配原理就是這樣的：
1. 先找到第一個“(”，作為匹配的開始
2. 在第1步以後，每匹配到一個“(”，就入棧一個Open捕獲組，計數加1
3. 在第1步以後，每匹配到一個“)”，就出棧最近入棧的Open捕獲組，計數減1
4. 後麵的(?(Open)(?!))用來保證堆棧中Open捕獲組計數是否為0，也就是“(”和“)”是配對出現的
5. 最後的“)”，作為匹配的結束
匹配過程（以下匹配過程，如果覺得難以理解，可以暫時跳過，先學會如何使用，再研究為什麼可以這樣用吧）
首先匹配第一個“(”，然後一直匹配，直到出現以下兩種情況之一：
a) 堆棧中Open計數已為0，此時再遇到“)”
b) 匹配到字符串結束符
這時控製權交給(?(Open)(?!))，判斷Open是否有匹配，由於此時計數為0，沒有匹配，那麼就匹配“no”分支，由於這個條件判斷結構中沒有“no”分支，所以什麼都不做，把控製權交給接下來的“\)”
如果上麵遇到的是情況a)，那麼此時“\)”可以匹配接下來的“\)”，匹配成功；如果上麵遇到的是情況b)，那麼此時會進行回溯，直到“\)”匹配成功為止，否則報告整個表達式匹配失敗。
由於.NET中的狹義平衡組“(?<Close-Open>Expression)”結構，可以動態的對堆棧中捕獲組進行計數，匹配到一個開始標記，入棧，計數加1，匹配到一個結束標記，出棧，計數減1，最後再判斷堆棧中是否還有Open，有則說明開始和結束標記不配對出現，不匹配，進行回溯或報告匹配失敗；如果沒有，則說明開始和結束標記配對出現，繼續進行後麵子表達式的匹配。
需要對“(?!)”進行一下說明，它屬於順序否定環視，完整的語法是“(?!Expression)”。由於這裏的“Expression”不存在，表示這裏不是一個位置，所以試圖嚐試匹配總是失敗的，作用就是在Open不配對出現時，報告匹配失敗。
3 平衡組的應用及優化
平衡組提供了嵌套結構的匹配功能，這一創新是很讓人興奮的，因為此前正則對於嵌套結構的匹配是無能為力的。然而功能的強大，自然也帶來了實現的複雜，正則書寫得不好，可能會存在效率陷阱，甚至導致程序崩潰，這裏介紹一些基本的優化方法。
3.1 單字符嵌套結構平衡組優化
單字符的嵌套結構指的是開始和結束標記都單個字符的嵌套結構，這種嵌套相對來說比較簡單，優化起來也比較容易。先從上麵提到的例子開始。
3.1.1 貪婪與非貪婪模式
上麵給的例子是一種做了部分優化的常規寫法，算作是版本1吧，它做了哪些優化呢，先來看下完全沒有做過優化的版本0吧。
string test = "a+(b*(c+d))/e+f-(g/(h-i))*j";
Regex reg0 = new Regex(@"\( #普通字符“(”
( #分組構造，用來限定量詞“*”修飾範圍
(?<Open>\() #命名捕獲組，遇到開括弧Open計數加1
| #分支結構
(?<-Open>\)) #狹義平衡組，遇到閉括弧Open計數減1
| #分支結構
. #任意字符
)*? #以上子串出現0次或任意多次，非貪婪模式
(?(Open)(?!)) #判斷是否還有'OPEN'，有則說明不配對，什麼都不匹配
\) #普通閉括弧
", RegexOptions.IgnorePatternWhitespace);
MatchCollection mc = reg0.Matches(test);
foreach (Match m in mc)
{
richTextBox2.Text += m.Value + "\n";
}
/*--------輸出--------
(b*(c+d))
(g/(h-i))
*/
接下來對比一下版本1。
Regex reg1 = new Regex(@"\( #普通字符“(”
( #分組構造，用來限定量詞“*”修飾範圍
(?<Open>\() #命名捕獲組，遇到開括弧’Open’計數加1
| #分支結構
(?<-Open>\)) #狹義平衡組，遇到閉括弧’Open’計數減1
| #分支結構
[^()]+ #非括弧的其它任意字符
)* #以上子串出現0次或任意多次
(?(Open)(?!)) #判斷是否還有’Open’，有則說明不配對，什麼都不匹配
\) #普通閉括弧
", RegexOptions.IgnorePatternWhitespace);
看到區別了嗎？版本1對版本0的改進主要有兩個地方，一個是用“[^()]+”來代替“.”，另一個是用“*”來代替“*?”，也就是用貪婪模式來代替非貪婪模式。
如果使用了小數點“.”，那麼為什麼不能在分組內使用“.+”，後麵又為什麼不能用“*”呢？隻要在上麵的正則中使用並運行一下代碼就可以知道了，匹配的結果是
(b*(c+d))/e+f-(g/(h-i))
而不是
(b*(c+d))
(g/(h-i))
因為無論是分組內使用“.+”還是後麵使用“*”，都是貪婪模式，所以小數點會一直匹配下去，直到匹配到字符串的結束符才會停止，然後進行回溯匹配。為了取得正確結果，必須使用非貪婪模式“*?”。
這就類似於用“\(.+\)”去匹配“(abc)def(ghi)”一樣，得到的結果是“(abc)def(ghi)”，而不是通常我們希望的“(abc)”和“(ghi)”。這時要用非貪婪模式“\(.+?\)”來得到正確的結果。
貪婪模式和非貪婪模式在匹配失敗時，回溯的次數基本上是一樣的，效率上沒有多大區別，但是在匹配成功時，貪婪模式比非貪婪模式回溯的次數要少得多，效率要高得多。
對於“\(.+\)”如果既要得到正確的匹配結果，又要提高匹配效率，可以使用排除型捕獲組+貪婪模式的方式，即“\([^()]+\)”。
版本0的平衡組也是一樣，可以使用排除字符組“[^()]+”和貪婪模式“*”結合的方式，提高匹配效率，得到的就是版本1的平衡組。
相對於版本0，或許你會認為版本1的寫法是很自然的，但是如果不了解這樣一個演進過程，那麼在字符序列嵌套結構平衡組優化時，就不會是那麼自然的一件事了。
3.1.2 分支結構
接下來就是分支結構的優化。
語法：(Exp1|Exp2|Exp3)
因為分支結構的匹配規則是，從左向右嚐試匹配，當左側分支匹配成功時，就不再向右嚐試。所以使用分支結構時，可以根據以下兩條規則進行優化：
1. 盡量抽象出每個分支中的公共的部分，使最後的表達式中，每個分支共公部分盡可能的少，比如(this|that)的匹配效率是沒有th(is|at)高的。
2. 在不影響匹配結果的情況下，把出現概率高的分支放在左側，出現概率低的分支放右側。
對於本例中的分支結構，已經沒有公共部分，符合第一條規則，再看下第二條規則，開始標記“(”和結束標記“)”出現的概率基本上是一樣的，而除“(”和“)”之外的字符出現的概率是比“(”和“)”出現的概率高的，所以應該把“[^()]+”分支放在左側。
版本1由於采用了排除型捕獲組，所以這三個分支沒有包含關係，左右順序對結果不會造成影響，可以調整順序。因為這是已經經過優化的了，而如果是版本0，由“.”對“(”和“)”有包含關係，就不能調整順序了。
在版本1基礎上對分支結構進行優化後，就得到版本2。
string test = "a+(b*(c+d))/e+f-(g/(h-i))*j";
Regex reg2 = new Regex(@"\( #普通字符“(”
( #分組構造，用來限定量詞“*”修飾範圍
[^()]+ #非括弧的其它任意字符
| #分支結構
(?<Open>\() #命名捕獲組，遇到開括弧Open計數加1
| #分支結構
(?<-Open>\)) #狹義平衡組，遇到閉括弧Open計數減1
)* #以上子串出現0次或任意多次
(?(Open)(?!)) #判斷是否還有'OPEN'，有則說明不配對，什麼都不匹配
\) #普通閉括弧
", RegexOptions.IgnorePatternWhitespace);
MatchCollection mc = reg2.Matches(test);
foreach (Match m in mc)
{
richTextBox2.Text += m.Value + "\n";
}
/*--------輸出--------
(b*(c+d))
(g/(h-i))
*/
3.1.3 捕獲組
這裏麵主要涉及到了兩個捕獲組“(?<Open>\()”和“(?<-Open>\))”，而在平衡組的應用中，我是隻關心它是否匹配了，而對於匹配到的內容是不關心的。對於這樣一種需求，可以用以下方式實現
\( (?<Open>)
\)(?<-Open>)
“(?<Open>)”和“(?<-Open>)”這兩種方式隻是使用了命名捕獲組，捕獲的是一個位置，它總是能夠匹配成功的，而匹配的內容是空的，分配的內存空間是固定的，可以有效的節省資源，這在單字符嵌套結構中並不明顯，但是在字符序列嵌套結構中就比較明顯了。
由於捕獲組是直接跟在開始或結束標記之後的，所以隻要開始或結束標記匹配成功，命名捕獲組自然就會匹配成功，對於功能是沒有任何影響的。
那麼把標記和捕獲組調整一下順序是否可以呢？從功能上來講，是可以的，但是匹配的流程上會有所不同，先是捕獲組匹配成功，入棧，然後再匹配標記，成功則繼續匹配，不成功則該分支匹配失敗，進行回溯，出棧，繼續嚐試下一分支。這樣將增加許多入棧和出棧的操作，對匹配效率是有影響的，所以這種方式並不可取。
在版本2基礎上對捕獲組進行優化後，就得到版本3。
string test = "a+(b*(c+d))/e+f-(g/(h-i))*j";
Regex reg3 = new Regex(@"\( #普通字符“(”
( #分組構造，用來限定量詞“*”修飾範圍
[^()]+ #非括弧的其它任意字符
| #分支結構
\( (?<Open>) #命名捕獲組，遇到開括弧Open計數加1
| #分支結構
\) (?<-Open>) #狹義平衡組，遇到閉括弧Open計數減1
)* #以上子串出現0次或任意多次
(?(Open)(?!)) #判斷是否還有'OPEN'，有則說明不配對，什麼都不匹配
\) #普通閉括弧
", RegexOptions.IgnorePatternWhitespace);
MatchCollection mc = reg3.Matches(test);
foreach (Match m in mc)
{
richTextBox2.Text += m.Value + "\n";
}
/*--------輸出--------
(b*(c+d))
(g/(h-i))
*/
3.1.4 固化分組
看到有些人使用平衡組時用到了固化分組，但並不是所有人都明白固化分組的作用。
語法：(?>Expression)
用“\([^()]+\)”去匹配“(abc)”是可以匹配成功的，因為不用回溯，相對於“\(.+?\)”這種非貪婪模式，效率上有所提升，但是對於匹配失敗的情況又如何呢？
源字符串：(abc
正則表達式：\([^()]+\)
匹配中間過程這裏不再詳述，可以參考NFA引擎匹配原理。
當“[^()]+”匹配到結束位置時，控製權交給“\)”，匹配失敗，進行回溯，而由於前麵使用了“[^()]+”這種排除型字符組，所以可供回溯的位置，不會存在可以匹配“\)”的情況，這時候的回溯是完全沒有意義的，隻會浪費時間，但是由於傳統NFA引擎的特點，必須回溯所有可能之後才會報告匹配失敗。
這時可以用固化分組來進行優化，一旦占有字符，就不再釋放。也就是一旦占有，就不再記錄可供回溯的可能。通常是與排除型字符組或順序否定環視一起使用的。
優化後的正則表達式：\((?>[^()]+)\)
需要說明的一點，固化分組要作用於量詞修飾的子表達式才有意義，對於“(?>abc)”由於內容是固定的，根本就不會產生回溯，所以使用固化分組是沒有意義的。
對於平衡組的應用也是一樣，如果分組構造中沒有量詞，那麼使用固化分組就是沒有意義的，比如版本0
Regex reg = new Regex(@"\((?>(?<Open>\()|(?<-Open>\))|.)*?(?(Open)(?!))\)");
這種場景下使用固化分組就是沒有意義的。
在版本3基礎上對捕獲組進行優化後，就得到版本4。
string test = "a+(b*(c+d))/e+f-(g/(h-i))*j";
Regex reg4 = new Regex(@"\( #普通字符“(”
(?> #分組構造，用來限定量詞“*”修飾範圍
[^()]+ #非括弧的其它任意字符
| #分支結構
\( (?<Open>) #命名捕獲組，遇到開括弧Open計數加1
| #分支結構
\) (?<-Open>) #狹義平衡組，遇到閉括弧Open計數減1
)* #以上子串出現0次或任意多次
(?(Open)(?!)) #判斷是否還有'OPEN'，有則說明不配對，什麼都不匹配
\) #普通閉括弧
", RegexOptions.IgnorePatternWhitespace);
MatchCollection mc = reg4.Matches(test);
foreach (Match m in mc)
{
richTextBox2.Text += m.Value + "\n";
}
/*--------輸出--------
(b*(c+d))
(g/(h-i))
*/
那麼對於分組構造外層的“*”修飾的子表達式是否可以使用固化分組呢？答案是否定的，因為平衡組通常是要進行回溯才能最終匹配成功的，所以如果使用固化分組，不記錄回溯可能的話，將無法得到正確結果。
3.1.5 進一步優化討論
那麼現在是不是已經完成優化了呢？是的，通常可以這麼認為。在一般應用當中，這已經是從正則層麵上來說，最優方案了。
但是在有些場景下，由於Compiled模式可以有效提高分支結構的匹配效率，所以對於源字符串比較複雜的情況，犧牲一些編譯時間和內存，還是可以有效提高匹配效率的。
Regex reg5 = new Regex(@"\( #普通字符“(”
(?> #分組構造，用來限定量詞“*”修飾範圍
[^()]+ #非括弧的其它任意字符
| #分支結構
\( (?<Open>) #命名捕獲組，遇到開括弧Open計數加1
| #分支結構
\) (?<-Open>) #狹義平衡組，遇到閉括弧Open計數減1
)* #以上子串出現0次或任意多次
(?(Open)(?!)) #判斷是否還有'OPEN'，有則說明不配對，什麼都不匹配
\) #普通閉括弧
", RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled);
MatchCollection mc = reg5.Matches(test);
foreach (Match m in mc)
{
richTextBox2.Text += m.Value + "\n";
}
/*--------輸出--------
(b*(c+d))
(g/(h-i))
*/
並不是所有應用場景都適合使用Compiled模式，比如上麵這個例子裏的源字符串如果是“a+(b*(c+d))/e+f-(g/(h-i))*j”，本身是非常簡單的，使用Compiled模式將是得不償失的。什麼時候使用，要根據具體問題具體分析。
3.2 字符序列嵌套結構平衡組應用
字符序列嵌套結構的匹配，典型的應用就是html標簽的提取。由於上麵詳細說明了單字符嵌套結構的優化過程，這裏主要講應用場景，個別涉及到優化的地方再討論。
字符序列嵌套結構的匹配，舉例來說，取div標簽。源字符串如下：
<div id="0">
0
</div>
<div id="1">
1
<div id="2">
2
</div>
</div>
3.2.1 提取最外層嵌套結構
提取最外層div標簽，分析過程及構造方式與單字符嵌套結構差不多，隻是捕獲組等內容稍稍複雜點，先給出實現，再進行解釋。
string test = @"<div 0"">
0
</div>
<div 1"">
1
<div 2"">
2
</div>
</div>";
Regex reg = new Regex(@"(?isx) #匹配模式，忽略大小寫，“.”匹配任意字符
<div[^>]*> #開始標記“<div...>”
(?> #分組構造，用來限定量詞“*”修飾範圍
<div[^>]*> (?<Open>) #命名捕獲組，遇到開始標記，入棧，Open計數加1
| #分支結構
</div> (?<-Open>) #狹義平衡組，遇到結束標記，出棧，Open計數減1
| #分支結構
(?:(?!</?div\b).)* #右側不為開始或結束標記的任意字符
)* #以上子串出現0次或任意多次
(?(Open)(?!)) #判斷是否還有'OPEN'，有則說明不配對，什麼都不匹配
</div> #結束標記“</div>”
");
MatchCollection mc = reg.Matches(test);
foreach (Match m in mc)
{
richTextBox2.Text += m.Value + "\n--------------------\n";
}
/*--------輸出--------
<div >
0
</div>
--------------------
<div >
1
<div >
2
</div>
</div>
--------------------
*/
在單字符嵌套結構中，使用排除型字符組“[^()]+”，與分組構造外的匹配優先量詞“*” 達到貪婪模式匹配效果。在字符序列嵌套結構中，要排除的是一個子串，而不是簡單的幾個無序字符，所以不能使用排除型字符組，此時需要用到順序否定環視來達到這一目的。“(?:(?!</?div\b).)*”表示的是所在位置右側不是“<div…>”或“</div>”的字符，這樣的字符重複0次或任意多次。關於環視的細節，可以參考 正則基礎之——環視。
而由於這種否定環視包含兩種狀態，所以在與固化分組結合使用時，會與後麵的開始或結束標記形成包含關係，所以與固化分組一起使用時，不能放在左側，隻能放在右側。
3.2.2 根據id提取div嵌套標簽
根據id提取div時，改變的隻是最外層div的結構，對內分組構造內部結構沒有影響。但是因為id是變化的，所以正則需要動態生成。下麵給出實現，源字符串和輸出結果由於比較影響篇幅，就不再給出了。
string id = Regex.Escape(textBox1.Text); //動態獲取id
Regex reg = new Regex(@"(?isx)
<div(?:(?!(?:id=|</?div\b)).)*id=(['""]?)" + id + @"\1[^>]*> #開始標記“<div...>”
(?> #分組構造，用來限定量詞“*”修飾範圍
<div[^>]*> (?<Open>) #命名捕獲組，遇到開始標記，入棧，Open計數加1
| #分支結構
</div> (?<-Open>) #狹義平衡組，遇到結束標記，出棧，Open計數減1
| #分支結構
(?:(?!</?div\b).)* #右側不為開始或結束標記的任意字符
)* #以上子串出現0次或任意多次
(?(Open)(?!)) #判斷是否還有'OPEN'，有則說明不配對，什麼都不匹配
</div> #結束標記“</div>”
");
MatchCollection mc = reg.Matches(test);
foreach (Match m in mc)
{
richTextBox2.Text += m.Value + "\n--------------------\n";
}
在動態生成正則表達式時，由於輸入的字符串中可能存在正則中有特殊意義的元字符，如果不進行轉義的話，正則解析時會拋出異常。所以用Regex.Escape(string str)來對動態輸入的字符串進行轉義處理，確保不會因動態輸入的內容而拋異常。比如上麵的例子，如果id不進行轉義處理時，輸入“abc(def”就會拋“) 不足”這樣的異常。
3.2.3 根據id提取任意嵌套標簽
再擴展一下，根據id屬性取任意嵌套標簽。實現如下，具體實現細節和討論參考 就是通過id獲得一個html標簽塊。以下正則相對於帖子對個別細節做了調整。
string html = @"
<html>
<body>
<div div1"">
<div div2"" background:Red;"">
<div div3"">
<table table1"">
<tr>
<td>
<div div4"" width:100px""></div>
</td>
</tr>
</table>
</div>
</div>
<div id=div5>
<a href=""https://www.csdn.net"">csdn</a>
</div>
</div>
<img src=""https://www.csdn.net/Images/logo_csdn.gif""/>
</body>
</html>";
Console.WriteLine(html);
string[] idList = { "div1", "div2", "div3", "div4", "table1", "div5", "abc(def" };
string pattern = @"<([a-z]+)(?:(?!\bid\b)[^<>])*id=([""']?){0}\2[^>]*>(?><\1[^>]*>(?<o>)|</\1>(?<-o>)|(?:(?!</?\1).)*)*(?(o)(?!))</\1>";
foreach (string id in idList)
{
Match match = Regex.Match(html, string.Format(pattern, Regex.Escape(id)),
RegexOptions.Singleline | RegexOptions.IgnoreCase);
Console.WriteLine("--------begin {0}--------", id);
if (match.Success)
Console.WriteLine(match.Value);
else
Console.WriteLine("o(╯□╰)o");
Console.WriteLine("--------end {0}--------", id);
}
Console.ReadLine();
3.2.4 根據標簽取外層嵌套結構
根據動態輸入的tag，取相應的最外層的嵌套標簽，實現如下。
string html = @"
<html>
<body>
<div div1"">
<div div2"" background:Red;"">
<div div3"">
<table table1"">
<tr>
<td>
<div div4"" width:100px""></div>
</td>
</tr>
</table>
</div>
</div>
<div id=div5>
<a href=""https://www.csdn.net"">csdn</a>
</div>
</div>
<img src=""https://www.csdn.net/Images/logo_csdn.gif""/>
</body>
</html>";
Console.WriteLine(html);
string[] tagList = { "html", "body", "div", "table", "abc(def" };
string pattern = @"(?isx)
<({0})\b[^>]*> #開始標記“<tag...>”
(?> #分組構造，用來限定量詞“*”修飾範圍
<\1[^>]*> (?<Open>) #命名捕獲組，遇到開始標記，入棧，Open計數加1
| #分支結構
</\1> (?<-Open>) #狹義平衡組，遇到結束標記，出棧，Open計數減1
| #分支結構
(?:(?!</?\1\b).)* #右側不為開始或結束標記的任意字符
)* #以上子串出現0次或任意多次
(?(Open)(?!)) #判斷是否還有'OPEN'，有則說明不配對，什麼都不匹配
</\1> #結束標記“</tag>”
";
foreach (string tag in tagList)
{
Match match = Regex.Match(html, string.Format(pattern, Regex.Escape(tag)));
Console.WriteLine("--------begin {0}--------", tag);
if (match.Success)
Console.WriteLine(match.Value);
else
Console.WriteLine("o(╯□╰)o");
Console.WriteLine("--------end {0}--------", tag);
}
Console.ReadLine();
3.2.5 條件判斷結構擴展應用
條件判斷結構的作用不隻限於驗證開始和結束標記是否配對，根據需求的不同，還可以有其它一些應用。比如在匹配div標簽時，隻取內部“存在”嵌套的外層標簽。
string test = @"<div 0"">
0
</div>
<div 1"">
1
<div 2"">
2
</div>
</div>";
Regex reg = new Regex(@"(?isx) #匹配模式，忽略大小寫，“.”匹配任意字符
<div[^>]*> #開始標記“<div...>”
(?> #分組構造，用來限定量詞“*”修飾範圍
<div[^>]*> (?<Open>)(?<Mask>) #遇到開始標記，入棧，Open和Mask計數各加1
| #分支結構
</div> (?<-Open>) #遇到結束標記，出棧，Open計數減1
| #分支結構
(?:(?!</?div\b).)* #右側不為開始或結束標記的任意字符
)* #以上子串出現0次或任意多次
(?(Open)(?!))(?(Mask)|(?!)) #'OPEN'保證標記配對，'Mask'保證內部有嵌套
</div> #結束標記“</div>”
");
MatchCollection mc = reg.Matches(test);
foreach (Match m in mc)
{
richTextBox2.Text += m.Value + "\n--------------------\n";
}
/*--------輸出--------
<div >
1
<div >
2
</div>
</div>
--------------------
*/
命名捕獲組“(?<Mask>)”隻入棧不出棧，如果內部有嵌套，則“(?<Mask>)”一定有匹配，此時匹配“(?(Mask)yes|no)”中的“yes”子表達式，也就是什麼都不做；如果內部沒有嵌套，則“(?<Mask>)”沒有匹配，此時匹配“(?(Mask)yes|no)”中的“no”子表達式，也就是報告匹配失敗。這裏省略的是“(?(Mask)yes|no)”中的“yes”子表達式。
對於匹配內部沒有嵌套的標簽，也就是最內層標簽，可以使用上麵的正則表達式，將“(?(Mask)yes|no)”中的“yes”子表達式設為“(?!)”，將“yes”子表達式省略。不過這樣做有些浪費，完全可以用順序否定環
最後更新：2017-04-03 16:48:47