正則表達式內部機理是什么

這篇文章主要介紹正則表達式內部機理是什么，文中介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們一定要看完！

9. 單詞邊界

元字符<<\b>>也是一種對位置進行匹配的“錨”。這種匹配是0長度匹配。

有4種位置被認為是“單詞邊界”：

1) 在字符串的***個字符前的位置(如果字符串的***個字符是一個“單詞字符”)

2) 在字符串的***一個字符后的位置(如果字符串的***一個字符是一個“單詞字符”)

3) 在一個“單詞字符”和“非單詞字符”之間，其中“非單詞字符”緊跟在“單詞字符”之后

4) 在一個“非單詞字符”和“單詞字符”之間，其中“單詞字符”緊跟在“非單詞字符”后面

“單詞字符”是可以用“\w”匹配的字符，“非單詞字符”是可以用“\W”匹配的字符。在大多數的正則表達式實現中，“單詞字符”通常包括<<[a-zA-Z0-9_]>>。

例如：<<\b4\b>>能夠匹配單個的4而不是一個更大數的一部分。這個正則表達式不會匹配“44”中的4。

換種說法，幾乎可以說<<\b>>匹配一個“字母數字序列”的開始和結束的位置。

“單詞邊界”的取反集為<<\B>>，他要匹配的位置是兩個“單詞字符”之間或者兩個“非單詞字符”之間的位置。

深入正則表達式引擎內部

讓我們看看把正則表達式<<\bis\b>>應用到字符串“This island is beautiful”。引擎先處理符號<<\b>>。因為\b是0長度 ，所以***個字符T前面的位置會被考察。因為T是一個“單詞字符”，而它前面的字符是一個空字符(void)，所以\b匹配了單詞邊界。接著<<i>>和***個字符“T”匹配失敗。匹配過程繼續進行，直到第五個空格符，和第四個字符“s”之間又匹配了<<\b>>。

然而空格符和<<i>>不匹配。繼續向后，到了第六個字符“i”，和第五個空格字符之間匹配了<<\b>>，然后<<is>>和第六、第七個字符都匹配了。然而第八個字符和第二個“單詞邊界”不匹配，所以匹配又失敗了。到了第13個字符i，因為和前面一個空格符形成“單詞邊界”，同時<<is>>和“is”匹配。引擎接著嘗試匹配第二個<<\b>>。因為第15個空格符和“s”形成單詞邊界，所以匹配成功。引擎“急著”返回成功匹配的結果。

10. 選擇符

正則表達式中“|”表示選擇。你可以用選擇符匹配多個可能的正則表達式中的一個。

如果你想搜索文字“cat”或“dog”，你可以用<<cat|dog>>。如果你想有更多的選擇，你只要擴展列表<<cat|dog|mouse|fish>>。

選擇符在正則表達式中具有***的優先級，也就是說，它告訴引擎要么匹配選擇符左邊的所有表達式，要么匹配右邊的所有表達式。你也可以用圓括號來限制選擇符的作用范圍。如<<\b(cat|dog)\b>>，這樣告訴正則引擎把(cat|dog)當成一個正則表達式單位來處理。

注意正則引擎的“急于表功”性

正則引擎是急切的，當它找到一個有效的匹配時，它會停止搜索。因此在一定條件下，選擇符兩邊的表達式的順序對結果會有影響。假設你想用正則表達式搜索一個編程語言的函數列表：Get，GetValue，Set或SetValue。一個明顯的解決方案是<<Get|GetValue|Set|SetValue>>。讓我們看看當搜索SetValue時的結果。

因為<<Get>>和<<GetValue>>都失敗了，而<<Set>>匹配成功。因為正則導向的引擎都是“急切”的，所以它會返回***個成功的匹配，就是“Set”，而不去繼續搜索是否有其他更好的匹配。

和我們期望的相反，正則表達式并沒有匹配整個字符串。有幾種可能的解決辦法。一是考慮到正則引擎的“急切”性，改變選項的順序，例如我們使用<<GetValue|Get|SetValue|Set>>，這樣我們就可以優先搜索最長的匹配。我們也可以把四個選項結合起來成兩個選項：<<Get(Value)?|Set(Value)?>>。因為問號重復符是貪婪的，所以SetValue總會在Set之前被匹配。

一個更好的方案是使用單詞邊界：<<\b(Get|GetValue|Set|SetValue)\b>>或<<\b(Get(Value)?|Set(Value)?\b>>。更進一步，既然所有的選擇都有相同的結尾，我們可以把正則表達式優化為<<\b(Get|Set)(Value)?\b>>。

11. 組與向后引用

把正則表達式的一部分放在圓括號內，你可以將它們形成組。然后你可以對整個組使用一些正則操作，例如重復操作符。

要注意的是，只有圓括號“()”才能用于形成組。“[]”用于定義字符集。“{}”用于定義重復操作。

當用“()”定義了一個正則表達式組后，正則引擎則會把被匹配的組按照順序編號，存入緩存。當對被匹配的組進行向后引用的時候，可以用“\數字”的方式進行引用。<<\1>>引用***個匹配的后向引用組，<<\2>>引用第二個組，以此類推，<<\n>>引用第n個組。而<<\0>>則引用整個被匹配的正則表達式本身。我們看一個例子。

假設你想匹配一個HTML標簽的開始標簽和結束標簽，以及標簽中間的文本。比如<B>This is a test</B>，我們要匹配<B>和</B>以及中間的文字。我們可以用如下正則表達式：“<([A-Z][A-Z0-9]*)[^>]*>.*?</\1>”

首先，“<”將會匹配“<B>”的***個字符“<”。然后[A-Z]匹配B，[A-Z0-9]*將會匹配0到多次字母數字，后面緊接著0到多個非“>”的字符。***正則表達式的“>”將會匹配“<B>”的“>”。接下來正則引擎將對結束標簽之前的字符進行惰性匹配，直到遇到一個“</”符號。然后正則表達式中的“\1”表示對前面匹配的組“([A-Z][A-Z0-9]*)”進行引用，在本例中，被引用的是標簽名“B”。所以需要被匹配的結尾標簽為“</B>”

你可以對相同的后向引用組進行多次引用，<<([a-c])x\1x\1>>將匹配“axaxa”、“bxbxb”以及“cxcxc”。如果用數字形式引用的組沒有有效的匹配，則引用到的內容簡單的為空。

一個后向引用不能用于它自身。<<([abc]\1)>>是錯誤的。因此你不能將<<\0>>用于一個正則表達式匹配本身，它只能用于替換操作中。

后向引用不能用于字符集內部。<<(a)[\1b]>>中的<<\1>>并不表示后向引用。在字符集內部，<<\1>>可以被解釋為八進制形式的轉碼。

向后引用會降低引擎的速度，因為它需要存儲匹配的組。如果你不需要向后引用，你可以告訴引擎對某個組不存儲。例如：<<Get(?:Value)>>。其中“(”后面緊跟的“?:”會告訴引擎對于組(Value)，不存儲匹配的值以供后向引用。

（1）重復操作與后向引用

當對組使用重復操作符時，緩存里后向引用內容會被不斷刷新，只保留***匹配的內容。例如：<<([abc]+)=\1>>將匹配“cab=cab”，但是<<([abc])+=\1>>卻不會。因為([abc])***次匹配“c”時，“\1”代表“c”；然后([abc])會繼續匹配“a”和“b”。***“\1”代表“b”，所以它會匹配“cab=b”。

應用：檢查重復單詞--當編輯文字時，很容易就會輸入重復單詞，例如“the the”。使用<<\b(\w+)\s+\1\b>>可以檢測到這些重復單詞。要刪除第二個單詞，只要簡單的利用替換功能替換掉“\1”就可以了。

（2）組的命名和引用

在PHP，Python中，可以用<<(?P<name>group)>>來對組進行命名。在本例中，詞法?P<name>就是對組(group)進行了命名。其中name是你對組的起的名字。你可以用(?P=name)進行引用。

.NET的命名組

.NET framework也支持命名組。不幸的是，微軟的程序員們決定發明他們自己的語法，而不是沿用Perl、Python的規則。目前為止，還沒有任何其他的正則表達式實現支持微軟發明的語法。

下面是.NET中的例子：

(?<first>group)(?&rsquo;second&rsquo;group)

正如你所看到的，.NET提供兩種詞法來創建命名組：一是用尖括號“<>”，或者用單引號“&rsquo;&rsquo;”。尖括號在字符串中使用更方便，單引號在ASP代碼中更有用，因為ASP代碼中“<>”被用作HTML標簽。

要引用一個命名組，使用\k<name>或\k&rsquo;name&rsquo;.

當進行搜索替換時，你可以用“${name}”來引用一個命名組。

12. 正則表達式的匹配模式

本教程所討論的正則表達式引擎都支持三種匹配模式：

<</i>>使正則表達式對大小寫不敏感，

<</s>>開啟“單行模式”，即點號“.”匹配新行符

<</m>>開啟“多行模式”，即“^”和“$”匹配新行符的前面和后面的位置。

在正則表達式內部打開或關閉模式

如果你在正則表達式內部插入修飾符(?ism)，則該修飾符只對其右邊的正則表達式起作用。(?-i)是關閉大小寫不敏感。你可以很快的進行測試。<<(?i)te(?-i)st>>應該匹配TEst，但是不能匹配teST或TEST.

13. 原子組與防止回溯

在一些特殊情況下，因為回溯會使得引擎的效率極其低下。

讓我們看一個例子：要匹配這樣的字串，字串中的每個字段間用逗號做分隔符，第12個字段由P開頭。

我們容易想到這樣的正則表達式<<^(.*?,){11}P>>。這個正則表達式在正常情況下工作的很好。但是在極端情況下，如果第12個字段不是由P開頭，則會發生災難性的回溯。如要搜索的字串為“1,2,3,4,5,6,7,8,9,10,11,12,13”。首先，正則表達式一直成功匹配直到第12個字符。這時，前面的正則表達式消耗的字串為“1,2,3,4,5,6,7,8,9,10,11,”，到了下一個字符，<<P>>并不匹配“12”。所以引擎進行回溯，這時正則表達式消耗的字串為“1,2,3,4,5,6,7,8,9,10,11”。繼續下一次匹配過程，下一個正則符號為點號<<.>>，可以匹配下一個逗號“,”。然而<<，>>并不匹配字符“12”中的“1”。匹配失敗，繼續回溯。大家可以想象，這樣的回溯組合是個非常大的數量。因此可能會造成引擎崩潰。

用于阻止這樣巨大的回溯有幾種方案：

一種簡單的方案是盡可能的使匹配精確。用取反字符集代替點號。例如我們用如下正則表達式<<^([^,\r\n]*,){11}P>>，這樣可以使失敗回溯的次數下降到11次。

另一種方案是使用原子組。

原子組的目的是使正則引擎失敗的更快一點。因此可以有效的阻止海量回溯。原子組的語法是<<(?>正則表達式)>>。位于(?>)之間的所有正則表達式都會被認為是一個單一的正則符號。一旦匹配失敗，引擎將會回溯到原子組前面的正則表達式部分。前面的例子用原子組可以表達成<<^(?>(.*?,){11})P>>。一旦第十二個字段匹配失敗，引擎回溯到原子組前面的<<^>>。

14. 向前查看與向后查看

Perl 5 引入了兩個強大的正則語法：“向前查看”和“向后查看”。他們也被稱作“零長度斷言”。他們和錨定一樣都是零長度的（所謂零長度即指該正則表達式不消耗被匹配的字符串）。不同之處在于“前后查看”會實際匹配字符，只是他們會拋棄匹配只返回匹配結果：匹配或不匹配。這就是為什么他們被稱作“斷言”。他們并不實際消耗字符串中的字符，而只是斷言一個匹配是否可能。

幾乎本文討論的所有正則表達式的實現都支持“向前向后查看”。唯一的一個例外是Javascript只支持向前查看。

（1）肯定和否定式的向前查看

如我們前面提過的一個例子：要查找一個q，后面沒有緊跟一個u。也就是說，要么q后面沒有字符，要么后面的字符不是u。采用否定式向前查看后的一個解決方案為<<q(?!u)>>。否定式向前查看的語法是<<(?!查看的內容)>>。

肯定式向前查看和否定式向前查看很類似：<<(?=查看的內容)>>。

如果在“查看的內容”部分有組，也會產生一個向后引用。但是向前查看本身并不會產生向后引用，也不會被計入向后引用的編號中。這是因為向前查看本身是會被拋棄掉的，只保留匹配與否的判斷結果。如果你想保留匹配的結果作為向后引用，你可以用<<(?=(regex))>>來產生一個向后引用。

（2）肯定和否定式的先后查看

向后查看和向前查看有相同的效果，只是方向相反

否定式向后查看的語法是：<<(?<!查看內容)>>

肯定式向后查看的語法是：<<(?<=查看內容)>>

我們可以看到，和向前查看相比，多了一個表示方向的左尖括號。

例：<<(?<!a)b>>將會匹配一個沒有“a”作前導字符的“b”。

值得注意的是：向前查看從當前字符串位置開始對“查看”正則表達式進行匹配；向后查看則從當前字符串位置開始先后回溯一個字符，然后再開始對“查看”正則表達式進行匹配。

（2）深入正則表達式引擎內部

讓我們看一個簡單例子。

把正則表達式<<q(?!u)>>應用到字符串“Iraq”。正則表達式的***個符號是<<q>>。正如我們知道的，引擎在匹配<<q>>以前會掃過整個字符串。當第四個字符“q”被匹配后，“q”后面是空字符(void)。而下一個正則符號是向前查看。引擎注意到已經進入了一個向前查看正則表達式部分。下一個正則符號是<<u>>，和空字符不匹配，從而導致向前查看里的正則表達式匹配失敗。因為是一個否定式的向前查看，意味著整個向前查看結果是成功的。于是匹配結果“q”被返回了。

我們在把相同的正則表達式應用到“quit”。<<q>>匹配了“q”。下一個正則符號是向前查看部分的<<u>>，它匹配了字符串中的第二個字符“i”。引擎繼續走到下個字符“i”。然而引擎這時注意到向前查看部分已經處理完了，并且向前查看已經成功。于是引擎拋棄被匹配的字符串部分，這將導致引擎回退到字符“u”。

因為向前查看是否定式的，意味著查看部分的成功匹配導致了整個向前查看的失敗，因此引擎不得不進行回溯。***因為再沒有其他的“q”和<<q>>匹配，所以整個匹配失敗了。

為了確保你能清楚地理解向前查看的實現，讓我們把<<q(?=u)i>>應用到“quit”。<<q>>首先匹配“q”。然后向前查看成功匹配“u”，匹配的部分被拋棄，只返回可以匹配的判斷結果。引擎從字符“i”回退到“u”。由于向前查看成功了，引擎繼續處理下一個正則符號<<i>>。結果發現<<i>>和“u”不匹配。因此匹配失敗了。由于后面沒有其他的“q”，整個正則表達式的匹配失敗了。

（3）更進一步理解正則表達式引擎內部機制

讓我們把<<(?<=a)b>>應用到“thingamabob”。引擎開始處理向后查看部分的正則符號和字符串中的***個字符。在這個例子中，向后查看告訴正則表達式引擎回退一個字符，然后查看是否有一個“a”被匹配。因為在“t”前面沒有字符，所以引擎不能回退。因此向后查看失敗了。引擎繼續走到下一個字符“h”。再一次，引擎暫時回退一個字符并檢查是否有個“a”被匹配。結果發現了一個“t”。向后查看又失敗了。

向后查看繼續失敗，直到正則表達式到達了字符串中的“m”，于是肯定式的向后查看被匹配了。因為它是零長度的，字符串的當前位置仍然是“m”。下一個正則符號是<<b>>，和“m”匹配失敗。下一個字符是字符串中的第二個“a”。引擎向后暫時回退一個字符，并且發現<<a>>不匹配“m”。

在下一個字符是字符串中的***個“b”。引擎暫時性的向后退一個字符發現向后查看被滿足了，同時<<b>>匹配了“b”。因此整個正則表達式被匹配了。作為結果，正則表達式返回字符串中的***個“b”。

（4）向前向后查看的應用

我們來看這樣一個例子：查找一個具有6位字符的，含有“cat”的單詞。

首先，我們可以不用向前向后查看來解決問題，例如：

<< cat\w{3}|\wcat\w{2}|\w{2}cat\w|\w{3}cat>>

足夠簡單吧！但是當需求變成查找一個具有6-12位字符，含有“cat”，“dog”或“mouse”的單詞時，這種方法就變得有些笨拙了。

我們來看看使用向前查看的方案。在這個例子中，我們有兩個基本需求要滿足：一是我們需要一個6位的字符，二是單詞含有“cat”。

滿足***個需求的正則表達式為<<\b\w{6}\b>>。滿足第二個需求的正則表達式為<<\b\w*cat\w*\b>>。

把兩者結合起來，我們可以得到如下的正則表達式：

<<(?=\b\w{6}\b)\b\w*cat\w*\b>>

具體的匹配過程留給讀者。但是要注意的一點是，向前查看是不消耗字符的，因此當判斷單詞滿足具有6個字符的條件后，引擎會從開始判斷前的位置繼續對后面的正則表達式進行匹配。

***作些優化，可以得到下面的正則表達式：

<<\b(?=\w{6}\b)\w{0,3}cat\w*>>

15. 正則表達式中的條件測試

條件測試的語法為<<(?ifthen|else)>>。“if”部分可以是向前向后查看表達式。如果用向前查看，則語法變為：<<(?(?=regex)then|else)>>，其中else部分是可選的。

如果if部分為true，則正則引擎會試圖匹配then部分，否則引擎會試圖匹配else部分。

需要記住的是，向前先后查看并不實際消耗任何字符，因此后面的then與else部分的匹配時從if測試前的部分開始進行嘗試。

16. 為正則表達式添加注釋

在正則表達式中添加注釋的語法是：<<(?#comment)>>

例：為用于匹配有效日期的正則表達式添加注釋：

(?#year)(19|20)\d\d[- /.](?#month)(0[1-9]|1[012])[- /.](?#day)(0[1-9]|[12][0-9]|3[01])

以上是“正則表達式內部機理是什么”這篇文章的所有內容，感謝各位的閱讀！希望分享的內容對大家有幫助，更多相關知識，歡迎關注億速云行業資訊頻道！