深刻淺出之正則表達式二

時間 2020-10-01

原文原文鏈接

前言：
本文是前一片文章《深刻淺出之正則表達式一》的續篇，在本文中講述了正則表達式中的組與向後引用，先前向後查看，條件測試，單詞邊界，選擇符等表達式及例子，並分析了正則引擎在執行匹配時的內部機理。
本文是Jan Goyvaerts爲RegexBuddy寫的教程的譯文，版權歸原做者全部，歡迎轉載。可是爲了尊重原做者和譯者的勞動，請註明出處！謝謝！html

9. 單詞邊界

元字符<<\b>>也是一種對位置進行匹配的「錨」。這種匹配是0長度匹配。程序員

有4種位置被認爲是「單詞邊界」：正則表達式

1) 在字符串的第一個字符前的位置(若是字符串的第一個字符是一個「單詞字符」)編程

2) 在字符串的最後一個字符後的位置(若是字符串的最後一個字符是一個「單詞字符」)緩存

3) 在一個「單詞字符」和「非單詞字符」之間，其中「非單詞字符」緊跟在「單詞字符」以後編程語言

4) 在一個「非單詞字符」和「單詞字符」之間，其中「單詞字符」緊跟在「非單詞字符」後面ide

「單詞字符」是能夠用「\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匹配了單詞邊界。接着<>和第一個字符「T」匹配失敗。匹配過程繼續進行，直到第五個空格符，和第四個字符「s」之間又匹配了<<\b>>。然而空格符和<>不匹配。繼續向後，到了第六個字符「i」，和第五個空格字符之間匹配了<<\b>>，而後<<is>>和第6、第七個字符都匹配了。然而第八個字符和第二個「單詞邊界」不匹配，因此匹配又失敗了。到了第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以前被匹配。

11. 組與向後引用

把正則表達式的一部分放在圓括號內，你能夠將它們造成組。而後你能夠對整個組使用一些正則操做，例如重複操做符。

要注意的是，只有圓括號「()」才能用於造成組。「[]」用於定義字符集。「{}」用於定義重複操做。

當用「()」定義了一個正則表達式組後，正則引擎則會把被匹配的組按照順序編號，存入緩存。當對被匹配的組進行向後引用的時候，能夠用「\數字」的方式進行引用。<<\1>>引用第一個匹配的後向引用組，<<\2>>引用第二個組，以此類推，<<\n>>引用第n個組。而<<\0>>則引用整個被匹配的正則表達式自己。咱們看一個例子。

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

首先，「<」將會匹配「」的第一個字符「<」。而後[A-Z]匹配B，[A-Z0-9]*將會匹配0到屢次字母數字，後面緊接着0到多個非「>」的字符。最後正則表達式的「>」將會匹配「」的「>」。接下來正則引擎將對結束標籤以前的字符進行惰性匹配，直到遇到一個「</」符號。而後正則表達式中的「\1」表示對前面匹配的組「([A-Z][A-Z0-9]*)」進行引用，在本例中，被引用的是標籤名「B」。因此須要被匹配的結尾標籤爲「」

你能夠對相同的後向引用組進行屢次引用，<<([a-c])x\1x\1>>將匹配「axaxa」、「bxbxb」以及「cxcxc」。若是用數字形式引用的組沒有有效的匹配，則引用到的內容簡單的爲空。

一個後向引用不能用於它自身。<<([abc]\1)>>是錯誤的。所以你不能將<<\0>>用於一個正則表達式匹配自己，它只能用於替換操做中。

後向引用不能用於字符集內部。<<(a)[\1b]>>中的<<\1>>並不表示後向引用。在字符集內部，<<\1>>能夠被解釋爲八進制形式的轉碼。

向後引用會下降引擎的速度，由於它須要存儲匹配的組。若是你不須要向後引用，你能夠告訴引擎對某個組不存儲。例如：<<Get(?:Value)>>。其中「(」後面緊跟的「?:」會告訴引擎對於組(Value)，不存儲匹配的值以供後向引用。

· 重複操做與後向引用

當對組使用重複操做符時，緩存裏後向引用內容會被不斷刷新，只保留最後匹配的內容。例如：<<([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」就能夠了。

· 組的命名和引用

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

.NET的命名組

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

下面是.NET中的例子：

(?<first>group)(?’second’group)

正如你所看到的，.NET提供兩種詞法來建立命名組：一是用尖括號「<>」，或者用單引號「’’」。尖括號在字符串中使用更方便，單引號在ASP代碼中更有用，由於ASP代碼中「<>」被用做HTML標籤。

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

當進行搜索替換時，你能夠用「${name}」來引用一個命名組。

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

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

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

<</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,」，到了下一個字符，<>並不匹配「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只支持向前查看。

· 確定和否認式的向前查看

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

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

若是在「查看的內容」部分有組，也會產生一個向後引用。可是向前查看自己並不會產生向後引用，也不會被計入向後引用的編號中。這是由於向前查看自己是會被拋棄掉的，只保留匹配與否的判斷結果。若是你想保留匹配的結果做爲向後引用，你能夠用<<(?=(regex))>>來產生一個向後引用。

· 確定和否認式的前後查看

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

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

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

咱們能夠看到，和向前查看相比，多了一個表示方向的左尖括號。

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

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

· 深刻正則表達式引擎內部

讓咱們看一個簡單例子。

把正則表達式<<q(?!u)>>應用到字符串「Iraq」。正則表達式的第一個符號是<<q>>。正如咱們知道的，引擎在匹配<<q>>之前會掃過整個字符串。當第四個字符「q」被匹配後，「q」後面是空字符(void)。而下一個正則符號是向前查看。引擎注意到已經進入了一個向前查看正則表達式部分。下一個正則符號是<>，和空字符不匹配，從而致使向前查看裏的正則表達式匹配失敗。由於是一個否認式的向前查看，意味着整個向前查看結果是成功的。因而匹配結果「q」被返回了。

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

由於向前查看是否認式的，意味着查看部分的成功匹配致使了整個向前查看的失敗，所以引擎不得不進行回溯。最後由於再沒有其餘的「q」和<<q>>匹配，因此整個匹配失敗了。

爲了確保你能清楚地理解向前查看的實現，讓咱們把<<q(?=u)i>>應用到「quit」。<<q>>首先匹配「q」。而後向前查當作功匹配「u」，匹配的部分被拋棄，只返回能夠匹配的判斷結果。引擎從字符「i」回退到「u」。因爲向前查當作功了，引擎繼續處理下一個正則符號<>。結果發現<>和「u」不匹配。所以匹配失敗了。因爲後面沒有其餘的「q」，整個正則表達式的匹配失敗了。

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

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

向後查看繼續失敗，直到正則表達式到達了字符串中的「m」，因而確定式的向後查看被匹配了。由於它是零長度的，字符串的當前位置仍然是「m」。下一個正則符號是<>，和「m」匹配失敗。下一個字符是字符串中的第二個「a」。引擎向後暫時回退一個字符，而且發現<<a>>不匹配「m」。

在下一個字符是字符串中的第一個「b」。引擎暫時性的向後退一個字符發現向後查看被知足了，同時<>匹配了「b」。所以整個正則表達式被匹配了。做爲結果，正則表達式返回字符串中的第一個「b」。

· 向前向後查看的應用

咱們來看這樣一個例子：查找一個具備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個字符的條件後，引擎會從開始判斷前的位置繼續對後面的正則表達式進行匹配。