正則表達式： < (?!/?p/b) [^>]+ >

這個正則的意義就是匹配除 <p…> 或 </p> 之外的其余標簽。

匹配過程：

?

首先由字符 “ < ” 取得控制權，從位置 0 開始匹配，由于 “ < ” 匹配 “ a ” 失敗，在位置 0 處整個表達式匹配失敗，第一次迭代匹配失敗，正則引擎向前傳動，由位置 1 處開始嘗試第二次迭代匹配。

重復以上過程，直到位置 2 ， “ < ” 匹配 “ < ” 成功，控制權交給“ (?!/?p/b) ”；“ (?!/?p/b) ”子表達式取得控制權后，進行內部子表達式的匹配。首先由“ /? ”取得控制權，嘗試匹配“ p ”失敗，進行回溯，不匹配，控制權交給“ p ”；由“ p ”來嘗試匹配“ p ”，匹配成功，控制權交給“ /b ”；由“ /b ”來嘗試匹配位置 4 ，匹配成功。此時子表達式匹配完成，“ /?p/b ”匹配成功，那么環視表達式“ (?!/?p/b) ”就匹配失敗。在位置 2 處整個表達式匹配失敗，新一輪迭代匹配失敗，正則引擎向前傳動，由位置 3 處開始嘗試下一輪迭代匹配。

在位置 8 處也會遇到一輪“ /?p/b ”匹配“ /p ”成功，而導致環視表達式“ (?!/?p/b) ”匹配失敗，從而導致整個表達式匹配失敗的過程。

重復以上過程，直到位置 14 ， “ < ” 匹配 “ < ” 成功，控制權交給“ (?!/?p/b) ”；“ /? ”嘗試匹配“ d ”失敗，進行回溯，不匹配，控制權交給“ p ”；由“ p ”來嘗試匹配“ d ”，匹配失敗，已經沒有備選狀態可供回溯，匹配失敗。此時子表達式匹配完成，“ /?p/b ”匹配失敗，那么環視表達式“ (?!/?p/b) ”就匹配成功。匹配的結果是位置 15 ，然后控制權交給“ [^>]+ ”；由“ [^>]+ ”從位置 15 進行嘗試匹配，可以成功匹配到“ div ”，控制權交給“ > ”；由“ > ”來匹配“ > ”。

此時正則表達式匹配完成，報告匹配成功。匹配結果為 “ <div> ” ，開始位置為 14 ，結束位置為 19 。其中“ < ”匹配“ < ”，“ (?!/?p/b) ”匹配位置 15 ，“ [^>]+ ”匹配字符串“ div ”，“ > ”匹配“ > ”。

逆序環視基礎

對于逆序肯定環視 (?<=Expression) 來說，當子表達式 Expression 匹配成功時， (?<=Expression) 匹配成功，并報告 (?<=Expression) 匹配當前位置成功。

對于逆序否定環視 (?<!Expression) 來說，當子表達式 Expression 匹配成功時， (?<!Expression) 匹配失敗；當子表達式 Expression 匹配失敗時， (?<!Expression) 匹配成功，并報告 (?<!Expression) 匹配當前位置成功；

順序環視相當于在當前位置右側附加一個條件，所以它的匹配嘗試是從當前位置開始的，然后向右嘗試匹配，直到某一位置使得匹配成功或失敗為止。而逆序環視的特殊處在于，它相當于在當前位置左側附加一個條件，所以它不是在當前位置開始嘗試匹配的，而是從當前位置左側某一位置開始，匹配到當前位置為止，報告匹配成功或失敗。

順序環視嘗試匹配的起點是確定的，就是當前位置，而匹配的終點是不確定的。逆序環視匹配的起點是不確定的，是當前位置左側某一位置，而匹配的終點是確定的，就是當前位置。

所以順序環視相對是簡單的，而逆序環視相對是復雜的。這也就是為什么大多數語言和工具都提供了對順序環視的支持，而只有少數語言提供了對逆序環視支持的原因。

JavaScript 中只支持順序環視，不支持逆序環視。

Java 中雖然順序環視和逆序環視都支持，但是逆序環視只支持長度確定的表達式，逆序環視中量詞只支持“ ? ”，不支持其它長度不定的量詞。長度確定時，引擎可以向左查找固定長度的位置作為起點開始嘗試匹配，而如果長度不確定時， 就要從當前位置向左逐個位置開始嘗試匹配，不成功則回溯，再向左側位置進行嘗試匹配，然后重復以上過程，直到匹配成功，或是嘗試到位置 0 處以后，報告匹配失敗， 處理的復雜度是顯而易見的。

目前只有 .NET 中支持不確定長度的逆序環視。

逆序環視匹配過程

?

源字符串： <div> a test </div>

正則表達式： (?<=<div>) [^<]+ (?=</div>)

這個正則的意義就是匹配 <div> 和 </div> 標簽之間的內容，而不包括 <div> 和 </div> 標簽本身。

匹配過程：

首先由“ (?<=<div>) ”取得控制權， 從位置 0 開始匹配，由于位置 0 是起始位置，左側沒有任何內容，所以“ <div> ”必然匹配失敗，從而環視表達式 “ (?<=<div>) ”匹配失敗，導致整個表達式在位置 0 處匹配失敗。第一輪迭代匹配失敗， 正則引擎向前傳動，由位置 1 處開始嘗試第二次迭代匹配。

直到傳動到位置 5 ，“ (?<=<div>) ”取得控制權，向左查找 5 個位置，由位置 0 開始匹配，由“ <div> ”匹配“ <div> ”成功，從而“ (?<=<div>) ”匹配成功，匹配的結果為位置 5 ，控制權交給“ [^<]+ ”；“ [^<]+ ”從位置 5 開始嘗試匹配，匹配“ a test ”成功，控制權交給“ (?=</div>) ”；由“ </div> ”匹配“ </div> ”成功，從而“ (?=</div>) ”匹配成功，匹配結果為位置 11 。

此時正則表達式匹配完成，報告匹配成功。匹配結果為 “ a test ” ，開始位置為 5 ，結束位置為 11 。其中 “ (?<=<div>) ” 匹配位置 5 ， “ [^<]+ ” 匹配 “ a test ” ， “ (?=</div>) ” 匹配位置 11 。

逆序否定環視的匹配過程與上述過程類似，區別只是當 Expression 匹配失敗時，逆序否定表達式 (?<!Expression) 才匹配成功。

到此環視的匹配原理已基本講解完，環視也就沒有什么秘密可言了，所需要的，也只是多加練習而已。

3 ?????? 環視應用

今天寫累了，暫時就給出一個環視的綜合應用實例吧，至于環視的應用場景和技巧，后面再整理。

需求：數字格式化成用“ , ”的貨幣格式。

正則表達式： (?n)(?<=/d)(?<!/./d*)(?=(/d{3})+(/.|$))

測試代碼：

double[] data = new double[] { 0, 12, 123, 1234, 12345, 123456, 1234567, 123456789, 1234567890, 12.345, 123.456, 1234.56, 12345.6789, 123456.789, 1234567.89, 12345678.9 };

foreach (double d in data)

{

??? richTextBox2.Text += " 源字符串 ： " + d.ToString().PadRight(15) + " 格式化 ： " + Regex.Replace(d.ToString(), @"(?n)(?<=/d)(?<!/./d*)(?=(/d{3})+(/.|$))", ",") + "/n";

}

輸出結果：

源字符串：0 ????????????? 格式化：0

源字符串：12 ???????????? 格式化：12

源字符串：123 ??????????? 格式化：123

源字符串：1234 ?????????? 格式化：1,234

源字符串：12345 ????????? 格式化：12,345

源字符串：123456 ???????? 格式化：123,456

源字符串：1234567 ??????? 格式化：1,234,567

源字符串：123456789 ????? 格式化：123,456,789

源字符串：1234567890 ???? 格式化：1,234,567,890

源字符串：12.345 ???????? 格式化：12.345

源字符串：123.456 ??????? 格式化：123.456

源字符串：1234.56 ??????? 格式化：1,234.56

源字符串：12345.6789 ???? 格式化：12,345.6789

源字符串：123456.789 ???? 格式化：123,456.789

源字符串：1234567.89 ???? 格式化：1,234,567.89

源字符串：12345678.9 ???? 格式化：12,345,678.9

實現分析：

首先根據需求可以確定是把一些特定的位置替換為“ , ”，接下來就是分析并找到這些位置的規律，并抽象出來以正則表達式來表示。

1、 ?? 這個位置的左側必須為數字

2、 ?? 這個位置右側到出現“ . ”或結尾為止，必須是數字，且數字的個數必須為 3 的倍數

3、 ?? 這個位置左側相隔任意個數字不能出現“ . ”

由以上三條，就可以完全確定這些位置，只要實現以上三條，組合一下正則表達式就可以了。

根據分析，最終匹配的結果是一個位置，所以所有子表達式都要求是零寬度。

1、 ?? 是對當前所在位置左側附加的條件，所以要用到逆序環視，因為要求必須出現，所以是肯定的，符合這一條件的子表達式即為“ (?<=/d) ”