本文是Jan Goyvaerts為RegexBuddy寫的教程的譯文，版權歸原作者所有，歡迎轉載。但是為了尊重原作者和譯者的勞動，請註明出處！謝謝！

1. 什麽是正則表達式

基本說來，正則表達式是一種用來描述一定數量文本的模式。Regex代表Regular Express。本文將用<<regex>>來表示一段具體的正則表達式。

一段文本就是最基本的模式，簡單的匹配相同的文本。

2. 不同的正則表達式引擎

正則表達式引擎是一種可以處理正則表達式的軟件。通常，引擎是更大的應用程序的一部分。在軟件世界，不同的正則表達式並不互相兼容。本教程會集中討論Perl 5 類型的引擎，因為這種引擎是應用最廣泛的引擎。同時我們也會提到一些和其他引擎的區別。許多近代的引擎都很類似，但不完全一樣。例如.NET正則庫，JDK正則包。

3. 文字符號

最基本的正則表達式由單個文字符號組成。如<<a>>，它將匹配字符串中第一次出現的字符“a”。如對字符串“Jack is a boy”。“J”後的“a”將被匹配。而第二個“a”將不會被匹配。

正則表達式也可以匹配第二個“a”，這必須是你告訴正則表達式引擎從第一次匹配的地方開始搜索。在文本編輯器中，你可以使用“查找下一個”。在編程語言中，會有一個函數可以使你從前一次匹配的位置開始繼續向後搜索。

類似的，<<cat>>會匹配“About cats and dogs”中的“cat”。這等於是告訴正則表達式引擎，找到一個<<c>>，緊跟一個<<a>>，再跟一個<<t>>。

要註意，正則表達式引擎缺省是大小寫敏感的。除非你告訴引擎忽略大小寫，否則<<cat>>不會匹配“Cat”。

· 特殊字符

對於文字字符，有11個字符被保留作特殊用途。他們是：

[ ] " ^ $ . | ? * + ( )

這些特殊字符也被稱作元字符。

如果你想在正則表達式中將這些字符用作文本字符，你需要用反斜杠“"”對其進行換碼 (escape)。例如你想匹配“1+1=2”，正確的表達式為<<1"+1=2>>.

需要註意的是，<<1+1=2>>也是有效的正則表達式。但它不會匹配“1+1=2”，而會匹配“123+111=234”中的“111=2”。因為“+”在這裏表示特殊含義（重復1次到多次）。

在編程語言中，要註意，一些特殊的字符會先被編譯器處理，然後再傳遞給正則引擎。因此正則表達式<<1"+2=2>>在C++中要寫成“1""+1=2”。為了匹配“C:"temp”，你要用正則表達式<<C:""temp>>。而在C++中，正則表達式則變成了“C:""""temp”。

· 不可顯示字符

可以使用特殊字符序列來代表某些不可顯示字符：

<<"t>>代表Tab(0x09)

<<"r>>代表回車符(0x0D)

<<"n>>代表換行符(0x0A)

要註意的是Windows中文本文件使用“"r"n”來結束一行而Unix使用“"n”。

4. 正則表達式引擎的內部工作機制

知道正則表達式引擎是如何工作的有助於你很快理解為何某個正則表達式不像你期望的那樣工作。

有兩種類型的引擎：文本導向(text-directed)的引擎和正則導向(regex-directed)的引擎。Jeffrey Friedl把他們稱作DFA和NFA引擎。本文談到的是正則導向的引擎。這是因為一些非常有用的特性，如“惰性”量詞(lazy quantifiers)和反向引用(backreferences)，只能在正則導向的引擎中實現。所以毫不意外這種引擎是目前最流行的引擎。

你可以輕易分辨出所使用的引擎是文本導向還是正則導向。如果反向引用或“惰性”量詞被實現，則可以肯定你使用的引擎是正則導向的。你可以作如下測試：將正則表達式<<regex|regex not>>應用到字符串“regex not”。如果匹配的結果是regex，則引擎是正則導向的。如果結果是regex not，則是文本導向的。因為正則導向的引擎是“猴急”的，它會很急切的進行表功，報告它找到的第一個匹配 。

· 正則導向的引擎總是返回最左邊的匹配

這是需要你理解的很重要的一點：即使以後有可能發現一個“更好”的匹配，正則導向的引擎也總是返回最左邊的匹配。

當把<<cat>>應用到“He captured a catfish for his cat”，引擎先比較<<c>>和“H”，結果失敗了。於是引擎再比較<<c>>和“e”，也失敗了。直到第四個字符，<<c>>匹配了“c”。<<a>>匹配了第五個字符。到第六個字符<<t>>沒能匹配“p”，也失敗了。引擎再繼續從第五個字符重新檢查匹配性。直到第十五個字符開始，<<cat>>匹配上了“catfish”中的“cat”，正則表達式引擎急切的返回第一個匹配的結果，而不會再繼續查找是否有其他更好的匹配。

5. 字符集

字符集是由一對方括號“[]”括起來的字符集合。使用字符集，你可以告訴正則表達式引擎僅僅匹配多個字符中的一個。如果你想匹配一個“a”或一個“e”，使用<<[ae]>>。你可以使用<<gr[ae]y>>匹配gray或grey。這在你不確定你要搜索的字符是采用美國英語還是英國英語時特別有用。相反，<<gr[ae]y>>將不會匹配graay或graey。字符集中的字符順序並沒有什麽關系，結果都是相同的。

你可以使用連字符“-”定義一個字符範圍作為字符集。<<[0-9]>>匹配0到9之間的單個數字。你可以使用不止一個範圍。<<[0-9a-fA-F] >>匹配單個的十六進制數字，並且大小寫不敏感。你也可以結合範圍定義與單個字符定義。<<[0-9a-fxA-FX]>>匹配一個十六進制數字或字母X。再次強調一下，字符和範圍定義的先後順序對結果沒有影響。

· 字符集的一些應用

查找一個可能有拼寫錯誤的單詞，比如<<sep[ae]r[ae]te>> 或 <<li[cs]en[cs]e>>。

查找程序語言的標識符，<<A-Za-z_][A-Za-z_0-9]*>>。(*表示重復0或多次)

查找C風格的十六進制數<<0[xX][A-Fa-f0-9]+>>。(+表示重復一次或多次)

· 取反字符集

在左方括號“[”後面緊跟一個尖括號“^”，將會對字符集取反。結果是字符集將匹配任何不在方括號中的字符。不像“.”，取反字符集是可以匹配回車換行符的。

需要記住的很重要的一點是，取反字符集必須要匹配一個字符。<<q[^u]>>並不意味著：匹配一個q，後面沒有u跟著。它意味著：匹配一個q，後面跟著一個不是u的字符。所以它不會匹配“Iraq”中的q，而會匹配“Iraq is a country”中的q和一個空格符。事實上，空格符是匹配中的一部分，因為它是一個“不是u的字符”。

如果你只想匹配一個q，條件是q後面有一個不是u的字符，我們可以用後面將講到的向前查看來解決。

· 字符集中的元字符

需要註意的是，在字符集中只有4個 字符具有特殊含義。它們是：“] " ^ -”。“]”代表字符集定義的結束；“"”代表轉義；“^”代表取反；“-”代表範圍定義。其他常見的元字符在字符集定義內部都是正常字符，不需要轉義。例如，要搜索星號*或加號+，你可以用<<[+*]>>。當然，如果你對那些通常的元字符進行轉義，你的正則表達式一樣會工作得很好，但是這會降低可讀性。

在字符集定義中為了將反斜杠“"”作為一個文字字符而非特殊含義的字符，你需要用另一個反斜杠對它進行轉義。<<[""x]>>將會匹配一個反斜杠和一個X。“]^-”都可以用反斜杠進行轉義，或者將他們放在一個不可能使用到他們特殊含義的位置。我們推薦後者，因為這樣可以增加可讀性。比如對於字符“^”，將它放在除了左括號“[”後面的位置，使用的都是文字字符含義而非取反含義。如<<[x^]>>會匹配一個x或^。<<[]x]>>會匹配一個“]”或“x”。<<[-x]>>或<<[x-]>>都會匹配一個“-”或“x”。

· 字符集的簡寫

因為一些字符集非常常用，所以有一些簡寫方式。

<<"d>>代表<<[0-9]>>;

<<"w>>代表單詞字符。這個是隨正則表達式實現的不同而有些差異。絕大多數的正則表達式實現的單詞字符集都包含了<<A-Za-z0-9_]>>。

<<"s>>代表“白字符”。這個也是和不同的實現有關的。在絕大多數的實現中，都包含了空格符和Tab符，以及回車換行符<<"r"n>>。

字符集的縮寫形式可以用在方括號之內或之外。<<"s"d>>匹配一個白字符後面緊跟一個數字。<<["s"d]>>匹配單個白字符或數字。<<["da-fA-F]>>將匹配一個十六進制數字。

取反字符集的簡寫

<<["S]>> = <<[^"s]>>

<<["W]>> = <<[^"w]>>

<<["D]>> = <<[^"d]>>

· 字符集的重復

如果你用“?*+”操作符來重復一個字符集，你將會重復整個字符集。而不僅是它匹配的那個字符。正則表達式<<[0-9]+>>會匹配837以及222。

如果你僅僅想重復被匹配的那個字符，可以用向後引用達到目的。我們以後將講到向後引用。

6. 使用?*或+ 進行重復

?：告訴引擎匹配前導字符0次或一次。事實上是表示前導字符是可選的。

+：告訴引擎匹配前導字符1次或多次

*：告訴引擎匹配前導字符0次或多次

<[A-Za-z][A-Za-z0-9]*>匹配沒有屬性的HTML標簽，“<”以及“>”是文字符號。第一個字符集匹配一個字母，第二個字符集匹配一個字母或數字。

我們似乎也可以用<[A-Za-z0-9]+>。但是它會匹配<1>。但是這個正則表達式在你知道你要搜索的字符串不包含類似的無效標簽時還是足夠有效的。

· 限制性重復

許多現代的正則表達式實現，都允許你定義對一個字符重復多少次。詞法是：{min,max}。min和max都是非負整數。如果逗號有而max被忽略了，則max沒有限制。如果逗號和max都被忽略了，則重復min次。

因此{0,}和*一樣，{1，}和+ 的作用一樣。

你可以用<<"b[1-9][0-9]{3}"b>>匹配1000~9999之間的數字(“"b”表示單詞邊界)。<<"b[1-9][0-9]{2,4}"b>>匹配一個在100~99999之間的數字。

· 註意貪婪性

假設你想用一個正則表達式匹配一個HTML標簽。你知道輸入將會是一個有效的HTML文件，因此正則表達式不需要排除那些無效的標簽。所以如果是在兩個尖括號之間的內容，就應該是一個HTML標簽。

許多正則表達式的新手會首先想到用正則表達式<< <.+> >>，他們會很驚訝的發現，對於測試字符串，“This is a <EM>first</EM> test”，你可能期望會返回<EM>，然後繼續進行匹配的時候，返回</EM>。

但事實是不會。正則表達式將會匹配“<EM>first</EM>”。很顯然這不是我們想要的結果。原因在於“+”是貪婪的。也就是說，“+”會導致正則表達式引擎試圖盡可能的重復前導字符。只有當這種重復會引起整個正則表達式匹配失敗的情況下，引擎會進行回溯。也就是說，它會放棄最後一次的“重復”，然後處理正則表達式余下的部分。

和“+”類似，“?*”的重復也是貪婪的。

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

讓我們來看看正則引擎如何匹配前面的例子。第一個記號是“<”，這是一個文字符號。第二個符號是“.”，匹配了字符“E”，然後“+”一直可以匹配其余的字符，直到一行的結束。然後到了換行符，匹配失敗(“.”不匹配換行符)。於是引擎開始對下一個正則表達式符號進行匹配。也即試圖匹配“>”。到目前為止，“<.+”已經匹配了“<EM>first</EM> test”。引擎會試圖將“>”與換行符進行匹配，結果失敗了。於是引擎進行回溯。結果是現在“<.+”匹配“<EM>first</EM> tes”。於是引擎將“>”與“t”進行匹配。顯然還是會失敗。這個過程繼續，直到“<.+”匹配“<EM>first</EM”，“>”與“>”匹配。於是引擎找到了一個匹配“<EM>first</EM>”。記住，正則導向的引擎是“急切的”，所以它會急著報告它找到的第一個匹配。而不是繼續回溯，即使可能會有更好的匹配，例如“<EM>”。所以我們可以看到，由於“+”的貪婪性，使得正則表達式引擎返回了一個最左邊的最長的匹配。

· 用懶惰性取代貪婪性

一個用於修正以上問題的可能方案是用“+”的惰性代替貪婪性。你可以在“+”後面緊跟一個問號“?”來達到這一點。“*”，“{}”和“?”表示的重復也可以用這個方案。因此在上面的例子中我們可以使用“<.+?>”。讓我們再來看看正則表達式引擎的處理過程。

再一次，正則表達式記號“<”會匹配字符串的第一個“<”。下一個正則記號是“.”。這次是一個懶惰的“+”來重復上一個字符。這告訴正則引擎，盡可能少的重復上一個字符。因此引擎匹配“.”和字符“E”，然後用“>”匹配“M”，結果失敗了。引擎會進行回溯，和上一個例子不同，因為是惰性重復，所以引擎是擴展惰性重復而不是減少，於是“<.+”現在被擴展為“<EM”。引擎繼續匹配下一個記號“>”。這次得到了一個成功匹配。引擎於是報告“<EM>”是一個成功的匹配。整個過程大致如此。

· 惰性擴展的一個替代方案

我們還有一個更好的替代方案。可以用一個貪婪重復與一個取反字符集：“<[^>]+>”。之所以說這是一個更好的方案在於使用惰性重復時，引擎會在找到一個成功匹配前對每一個字符進行回溯。而使用取反字符集則不需要進行回溯。

最後要記住的是，本教程僅僅談到的是正則導向的引擎。文本導向的引擎是不回溯的。但是同時他們也不支持惰性重復操作。

7. 使用“.”匹配幾乎任意字符

在正則表達式中，“.”是最常用的符號之一。不幸的是，它也是最容易被誤用的符號之一。

“.”匹配一個單個的字符而不用關心被匹配的字符是什麽。唯一的例外是新行符。在本教程中談到的引擎，缺省情況下都是不匹配新行符的。因此在缺省情況下，“.”等於是字符集[^"n"r](Window)或[^"n]( Unix)的簡寫。

這個例外是因為歷史的原因。因為早期使用正則表達式的工具是基於行的。它們都是一行一行的讀入一個文件，將正則表達式分別應用到每一行上去。在這些工具中，字符串是不包含新行符的。因此“.”也就從不匹配新行符。

現代的工具和語言能夠將正則表達式應用到很大的字符串甚至整個文件上去。本教程討論的所有正則表達式實現都提供一個選項，可以使“.”匹配所有的字符，包括新行符。在RegexBuddy, EditPad Pro或PowerGREP等工具中，你可以簡單的選中“點號匹配新行符”。在Perl中，“.”可以匹配新行符的模式被稱作“單行模式”。很不幸，這是一個很容易混淆的名詞。因為還有所謂“多行模式”。多行模式只影響行首行尾的錨定(anchor)，而單行模式只影響“.”。

其他語言和正則表達式庫也采用了Perl的術語定義。當在.NET Framework中使用正則表達式類時，你可以用類似下面的語句來激活單行模式：Regex.Match(“string”,”regex”,RegexOptions.SingleLine)

· 保守的使用點號“.”

點號可以說是最強大的元字符。它允許你偷懶：用一個點號，就能匹配幾乎所有的字符。但是問題在於，它也常常會匹配不該匹配的字符。

我會以一個簡單的例子來說明。讓我們看看如何匹配一個具有“mm/dd/yy”格式的日期，但是我們想允許用戶來選擇分隔符。很快能想到的一個方案是<<"d"d."d"d."d"d>>。看上去它能匹配日期“02/12/03”。問題在於02512703也會被認為是一個有效的日期。

<<"d"d[-/.]"d"d[-/.]"d"d>>看上去是一個好一點的解決方案。記住點號在一個字符集裏不是元字符。這個方案遠不夠完善，它會匹配“99/99/99”。而<<[0-1]"d[-/.][0-3]"d[-/.]"d"d>>又更進一步。盡管他也會匹配“19/39/99”。你想要你的正則表達式達到如何完美的程度取決於你想達到什麽樣的目的。如果你想校驗用戶輸入，則需要盡可能的完美。如果你只是想分析一個已知的源，並且我們知道沒有錯誤的數據，用一個比較好的正則表達式來匹配你想要搜尋的字符就已經足夠。

8. 字符串開始和結束的錨定

錨定和一般的正則表達式符號不同，它不匹配任何字符。相反，他們匹配的是字符之前或之後的位置。“^”匹配一行字符串第一個字符前的位置。<<^a>>將會匹配字符串“abc”中的a。<<^b>>將不會匹配“abc”中的任何字符。

類似的，$匹配字符串中最後一個字符的後面的位置。所以<<c$>>匹配“abc”中的c。

· 錨定的應用

在編程語言中校驗用戶輸入時，使用錨定是非常重要的。如果你想校驗用戶的輸入為整數，用<<^"d+$>>。

用戶輸入中，常常會有多余的前導空格或結束空格。你可以用<<^"s*>>和<<"s*$>>來匹配前導空格或結束空格。

· 使用“^”和“$”作為行的開始和結束錨定

如果你有一個包含了多行的字符串。例如：“first line"n"rsecond line”(其中"n"r表示一個新行符)。常常需要對每行分別處理而不是整個字符串。因此，幾乎所有的正則表達式引擎都提供一個選項，可以擴展這兩種錨定的含義。“^”可以匹配字串的開始位置(在f之前)，以及每一個新行符的後面位置(在"n"r和s之間)。類似的，$會匹配字串的結束位置(最後一個e之後)，以及每個新行符的前面(在e與"n"r之間)。

在.NET中，當你使用如下代碼時，將會定義錨定匹配每一個新行符的前面和後面位置：Regex.Match("string", "regex", RegexOptions.Multiline)

應用：string str = Regex.Replace(Original, "^", "> ", RegexOptions.Multiline)--將會在每行的行首插入“> ”。

· 絕對錨定

<<"A>>只匹配整個字符串的開始位置，<<"Z>>只匹配整個字符串的結束位置。即使你使用了“多行模式”，<<"A>>和<<"Z>>也從不匹配新行符。

即使"Z和$只匹配字符串的結束位置，仍然有一個例外的情況。如果字符串以新行符結束，則"Z和$將會匹配新行符前面的位置，而不是整個字符串的最後面。這個“改進”是由Perl引進的，然後被許多的正則表達式實現所遵循，包括Java，.NET等。如果應用<<^[a-z]+$>>到“joe"n”，則匹配結果是“joe”而不是“joe"n”。

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)，不存儲匹配的值以供後向引用。

· 重復操作與後向引用

當對組使用重復操作符時，緩存裏後向引用內容會被不斷刷新，只保留最後匹配的內容。例如：<<([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. 正則表達式的匹配模式

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

<</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只支持向前查看。

· 肯定和否定式的向前查看

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

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

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

· 肯定和否定式的先後查看

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

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

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

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

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

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

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

讓我們看一個簡單例子。

把正則表達式<<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”，整個正則表達式的匹配失敗了。

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

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

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

在下一個字符是字符串中的第一個“b”。引擎暫時性的向後退一個字符發現向後查看被滿足了，同時<<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個字符的條件後，引擎會從開始判斷前的位置繼續對後面的正則表達式進行匹配。

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

<<"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])

非常經典的正則表達式