半年前我對正則表達(dá)式產(chǎn)生了興趣，在網(wǎng)上查找過不少資料，看過不少的教程，最后在使用一個正則表達(dá)式工具RegexBuddy時發(fā)現(xiàn)他的教程寫的非常好，可以說是我目前見過最好的正則表達(dá)式教程。于是一直想把他翻譯過來。這個愿望直到這個五一長假才得以實現(xiàn)，結(jié)果就有了這篇文章。關(guān)于本文的名字，使用“深入淺出”似乎已經(jīng)太俗。但是通讀原文以后，覺得只有用“深入淺出”才能準(zhǔn)確的表達(dá)出該教程給我的感受，所以也就不能免俗了。
本文是Jan Goyvaerts為RegexBuddy寫的教程的譯文，版權(quán)歸原作者所有，歡迎轉(zhuǎn)載。但是為了尊重原作者和譯者的勞動，請注明出處！謝謝！
1. 什么是正則表達(dá)式
基本說來，正則表達(dá)式是一種用來描述一定數(shù)量文本的模式。Regex代表Regular Express。本文將用<<regex>>來表示一段具體的正則表達(dá)式。
一段文本就是最基本的模式，簡單的匹配相同的文本。
2. 不同的正則表達(dá)式引擎
正則表達(dá)式引擎是一種可以處理正則表達(dá)式的軟件。通常，引擎是更大的應(yīng)用程序的一部分。在軟件世界，不同的正則表達(dá)式并不互相兼容。本教程會集中討論Perl 5 類型的引擎，因為這種引擎是應(yīng)用最廣泛的引擎。同時我們也會提到一些和其他引擎的區(qū)別。許多近代的引擎都很類似，但不完全一樣。例如.NET正則庫，JDK正則包。
3. 文字符號
最基本的正則表達(dá)式由單個文字符號組成。如<<a>>，它將匹配字符串中第一次出現(xiàn)的字符“a”。如對字符串“Jack is a boy”�！癑”后的“a”將被匹配。而第二個“a”將不會被匹配。
正則表達(dá)式也可以匹配第二個“a”，這必須是你告訴正則表達(dá)式引擎從第一次匹配的地方開始搜索。在文本編輯器中，你可以使用“查找下一個”。在編程語言中，會有一個函數(shù)可以使你從前一次匹配的位置開始繼續(xù)向后搜索。
類似的，<<cat>>會匹配“About cats and dogs”中的“cat”。這等于是告訴正則表達(dá)式引擎，找到一個<<c>>，緊跟一個<<a>>，再跟一個<<t>>。
要注意，正則表達(dá)式引擎缺省是大小寫敏感的。除非你告訴引擎忽略大小寫，否則<<cat>>不會匹配“Cat”。
· 特殊字符
對于文字字符，有12個字符被保留作特殊用途。他們是：
[ ] \ ^ $ . | ? * + ( )
這些特殊字符也被稱作元字符。
如果你想在正則表達(dá)式中將這些字符用作文本字符，你需要用反斜杠“\”對其進(jìn)行換碼 (escape)。例如你想匹配“1+1=2”，正確的表達(dá)式為<<1\+1=2>>.
需要注意的是，<<1+1=2>>也是有效的正則表達(dá)式。但它不會匹配“1+1=2”，而會匹配“123+111=234”中的“111=2”。因為“+”在這里表示特殊含義（重復(fù)1次到多次）。
在編程語言中，要注意，一些特殊的字符會先被編譯器處理，然后再傳遞給正則引擎。因此正則表達(dá)式<<1\+2=2>>在C++中要寫成“1\\+1=2”。為了匹配“C:\temp”，你要用正則表達(dá)式<<C:\\temp>>。而在C++中，正則表達(dá)式則變成了“C:\\\\temp”。
· 不可顯示字符
可以使用特殊字符序列來代表某些不可顯示字符：
<<\t>>代表Tab(0x09)
<<\r>>代表回車符(0x0D)
<<\n>>代表換行符(0x0A)
要注意的是Windows中文本文件使用“\r\n”來結(jié)束一行而Unix使用“\n”。
4. 正則表達(dá)式引擎的內(nèi)部工作機制
知道正則表達(dá)式引擎是如何工作的有助于你很快理解為何某個正則表達(dá)式不像你期望的那樣工作。
有兩種類型的引擎：文本導(dǎo)向(text-directed)的引擎和正則導(dǎo)向(regex-directed)的引擎。Jeffrey Friedl把他們稱作DFA和NFA引擎。本文談到的是正則導(dǎo)向的引擎。這是因為一些非常有用的特性，如“惰性”量詞(lazy quantifiers)和反向引用(backreferences)，只能在正則導(dǎo)向的引擎中實現(xiàn)。所以毫不意外這種引擎是目前最流行的引擎。
你可以輕易分辨出所使用的引擎是文本導(dǎo)向還是正則導(dǎo)向。如果反向引用或“惰性”量詞被實現(xiàn)，則可以肯定你使用的引擎是正則導(dǎo)向的。你可以作如下測試：將正則表達(dá)式<<regex|regex not>>應(yīng)用到字符串“regex not”。如果匹配的結(jié)果是regex，則引擎是正則導(dǎo)向的。如果結(jié)果是regex not，則是文本導(dǎo)向的。因為正則導(dǎo)向的引擎是“猴急”的，它會很急切的進(jìn)行表功，報告它找到的第一個匹配 。
· 正則導(dǎo)向的引擎總是返回最左邊的匹配
這是需要你理解的很重要的一點：即使以后有可能發(fā)現(xiàn)一個“更好”的匹配，正則導(dǎo)向的引擎也總是返回最左邊的匹配。
當(dāng)把<<cat>>應(yīng)用到“He captured a catfish for his cat”，引擎先比較<<c>>和“H”，結(jié)果失敗了。于是引擎再比較<<c>>和“e”，也失敗了。直到第四個字符，<<c>>匹配了“c”。<<a>>匹配了第五個字符。到第六個字符<<t>>沒能匹配“p”，也失敗了。引擎再繼續(xù)從第五個字符重新檢查匹配性。直到第十五個字符開始，<<cat>>匹配上了“catfish”中的“cat”，正則表達(dá)式引擎急切的返回第一個匹配的結(jié)果，而不會再繼續(xù)查找是否有其他更好的匹配。
5. 字符集
字符集是由一對方括號“[]”括起來的字符集合。使用字符集，你可以告訴正則表達(dá)式引擎僅僅匹配多個字符中的一個。如果你想匹配一個“a”或一個“e”，使用<<[ae]>>。你可以使用<<gr[ae]y>>匹配gray或grey。這在你不確定你要搜索的字符是采用美國英語還是英國英語時特別有用。相反，<<gr[ae]y>>將不會匹配graay或graey。字符集中的字符順序并沒有什么關(guān)系，結(jié)果都是相同的。
你可以使用連字符“-”定義一個字符范圍作為字符集。<<[0-9]>>匹配0到9之間的單個數(shù)字。你可以使用不止一個范圍。<<[0-9a-fA-F] >>匹配單個的十六進(jìn)制數(shù)字，并且大小寫不敏感。你也可以結(jié)合范圍定義與單個字符定義。<<[0-9a-fxA-FX]>>匹配一個十六進(jìn)制數(shù)字或字母X。再次強調(diào)一下，字符和范圍定義的先后順序?qū)Y(jié)果沒有影響。
· 字符集的一些應(yīng)用
查找一個可能有拼寫錯誤的單詞，比如<<sep[ae]r[ae]te>> 或 <<li[cs]en[cs]e>>。
查找程序語言的標(biāo)識符，<<A-Za-z_][A-Za-z_0-9]*>>。(*表示重復(fù)0或多次)
查找C風(fēng)格的十六進(jìn)制數(shù)<<0[xX][A-Fa-f0-9]+>>。(+表示重復(fù)一次或多次)
· 取反字符集
在左方括號“[”后面緊跟一個尖括號“^”，將會對字符集取反。結(jié)果是字符集將匹配任何不在方括號中的字符。不像“.”，取反字符集是可以匹配回車換行符的。
需要記住的很重要的一點是，取反字符集必須要匹配一個字符。<<q[^u]>>并不意味著：匹配一個q，后面沒有u跟著。它意味著：匹配一個q，后面跟著一個不是u的字符。所以它不會匹配“Iraq”中的q，而會匹配“Iraq is a country”中的q和一個空格符。事實上，空格符是匹配中的一部分，因為它是一個“不是u的字符”。
如果你只想匹配一個q，條件是q后面有一個不是u的字符，我們可以用后面將講到的向前查看來解決。
· 字符集中的元字符
需要注意的是，在字符集中只有4個 字符具有特殊含義。它們是：“] \ ^ -”�！癩”代表字符集定義的結(jié)束；“\”代表轉(zhuǎn)義；“^”代表取反；“-”代表范圍定義。其他常見的元字符在字符集定義內(nèi)部都是正常字符，不需要轉(zhuǎn)義。例如，要搜索星號*或加號+，你可以用<<[+*]>>。當(dāng)然，如果你對那些通常的元字符進(jìn)行轉(zhuǎn)義，你的正則表達(dá)式一樣會工作得很好，但是這會降低可讀性。
在字符集定義中為了將反斜杠“\”作為一個文字字符而非特殊含義的字符，你需要用另一個反斜杠對它進(jìn)行轉(zhuǎn)義。<<[\\x]>>將會匹配一個反斜杠和一個X�！癩^-”都可以用反斜杠進(jìn)行轉(zhuǎn)義，或者將他們放在一個不可能使用到他們特殊含義的位置。我們推薦后者，因為這樣可以增加可讀性。比如對于字符“^”，將它放在除了左括號“[”后面的位置，使用的都是文字字符含義而非取反含義。如<<[x^]>>會匹配一個x或^。<<[]x]>>會匹配一個“]”或“x”。<<[-x]>>或<<[x-]>>都會匹配一個“-”或“x”。
· 字符集的簡寫
因為一些字符集非常常用，所以有一些簡寫方式。
<<\d>>代表<<[0-9]>>;
<<\w>>代表單詞字符。這個是隨正則表達(dá)式實現(xiàn)的不同而有些差異。絕大多數(shù)的正則表達(dá)式實現(xiàn)的單詞字符集都包含了<<A-Za-z0-9_]>>。
<<\s>>代表“白字符”。這個也是和不同的實現(xiàn)有關(guān)的。在絕大多數(shù)的實現(xiàn)中，都包含了空格符和Tab符，以及回車換行符<<\r\n>>。
字符集的縮寫形式可以用在方括號之內(nèi)或之外。<<\s\d>>匹配一個白字符后面緊跟一個數(shù)字。<<[\s\d]>>匹配單個白字符或數(shù)字。<<[\da-fA-F]>>將匹配一個十六進(jìn)制數(shù)字。
取反字符集的簡寫
<<[\S]>> = <<[^\s]>>
<<[\W]>> = <<[^\w]>>
<<[\D]>> = <<[^\d]>>
· 字符集的重復(fù)
如果你用“?*+”操作符來重復(fù)一個字符集，你將會重復(fù)整個字符集。而不僅是它匹配的那個字符。正則表達(dá)式<<[0-9]+>>會匹配837以及222。
如果你僅僅想重復(fù)被匹配的那個字符，可以用向后引用達(dá)到目的。我們以后將講到向后引用。
6. 使用?*或+ 進(jìn)行重復(fù)
?：告訴引擎匹配前導(dǎo)字符0次或一次。事實上是表示前導(dǎo)字符是可選的。
+：告訴引擎匹配前導(dǎo)字符1次或多次
*：告訴引擎匹配前導(dǎo)字符0次或多次
<[A-Za-z][A-Za-z0-9]*>匹配沒有屬性的HTML標(biāo)簽，“<”以及“>”是文字符號。第一個字符集匹配一個字母，第二個字符集匹配一個字母或數(shù)字。
我們似乎也可以用<[A-Za-z0-9]+>。但是它會匹配<1>。但是這個正則表達(dá)式在你知道你要搜索的字符串不包含類似的無效標(biāo)簽時還是足夠有效的。
· 限制性重復(fù)
許多現(xiàn)代的正則表達(dá)式實現(xiàn)，都允許你定義對一個字符重復(fù)多少次。詞法是：{min,max}。min和max都是非負(fù)整數(shù)。如果逗號有而max被忽略了，則max沒有限制。如果逗號和max都被忽略了，則重復(fù)min次。
因此{(lán)0,}和*一樣，{1，}和+ 的作用一樣。
你可以用<<\b[1-9][0-9]{3}\b>>匹配1000~9999之間的數(shù)字(“\b”表示單詞邊界)。<<\b[1-9][0-9]{2,4}\b>>匹配一個在100~99999之間的數(shù)字。
· 注意貪婪性
假設(shè)你想用一個正則表達(dá)式匹配一個HTML標(biāo)簽。你知道輸入將會是一個有效的HTML文件，因此正則表達(dá)式不需要排除那些無效的標(biāo)簽。所以如果是在兩個尖括號之間的內(nèi)容，就應(yīng)該是一個HTML標(biāo)簽。
許多正則表達(dá)式的新手會首先想到用正則表達(dá)式<< <.+> >>，他們會很驚訝的發(fā)現(xiàn)，對于測試字符串，“This is a <EM>first</EM> test”，你可能期望會返回<EM>，然后繼續(xù)進(jìn)行匹配的時候，返回</EM>。
但事實是不會。正則表達(dá)式將會匹配“<EM>first</EM>”。很顯然這不是我們想要的結(jié)果。原因在于“+”是貪婪的。也就是說，“+”會導(dǎo)致正則表達(dá)式引擎試圖盡可能的重復(fù)前導(dǎo)字符。只有當(dāng)這種重復(fù)會引起整個正則表達(dá)式匹配失敗的情況下，引擎會進(jìn)行回溯。也就是說，它會放棄最后一次的“重復(fù)”，然后處理正則表達(dá)式余下的部分。
和“+”類似，“?*”的重復(fù)也是貪婪的。
· 深入正則表達(dá)式引擎內(nèi)部
讓我們來看看正則引擎如何匹配前面的例子。第一個記號是“<”，這是一個文字符號。第二個符號是“.”，匹配了字符“E”，然后“+”一直可以匹配其余的字符，直到一行的結(jié)束。然后到了換行符，匹配失敗(“.”不匹配換行符)。于是引擎開始對下一個正則表達(dá)式符號進(jìn)行匹配。也即試圖匹配“>”。到目前為止，“<.+”已經(jīng)匹配了“<EM>first</EM> test”。引擎會試圖將“>”與換行符進(jìn)行匹配，結(jié)果失敗了。于是引擎進(jìn)行回溯。結(jié)果是現(xiàn)在“<.+”匹配“<EM>first</EM> tes”。于是引擎將“>”與“t”進(jìn)行匹配。顯然還是會失敗。這個過程繼續(xù)，直到“<.+”匹配“<EM>first</EM”，“>”與“>”匹配。于是引擎找到了一個匹配“<EM>first</EM>”。記住，正則導(dǎo)向的引擎是“急切的”，所以它會急著報告它找到的第一個匹配。而不是繼續(xù)回溯，即使可能會有更好的匹配，例如“<EM>”。所以我們可以看到，由于“+”的貪婪性，使得正則表達(dá)式引擎返回了一個最左邊的最長的匹配。
· 用懶惰性取代貪婪性
一個用于修正以上問題的可能方案是用“+”的惰性代替貪婪性。你可以在“+”后面緊跟一個問號“?”來達(dá)到這一點�！�*”，“{}”和“?”表示的重復(fù)也可以用這個方案。因此在上面的例子中我們可以使用“<.+?>”。讓我們再來看看正則表達(dá)式引擎的處理過程。
再一次，正則表達(dá)式記號“<”會匹配字符串的第一個“<”。下一個正則記號是“.”。這次是一個懶惰的“+”來重復(fù)上一個字符。這告訴正則引擎，盡可能少的重復(fù)上一個字符。因此引擎匹配“.”和字符“E”，然后用“>”匹配“M”，結(jié)果失敗了。引擎會進(jìn)行回溯，和上一個例子不同，因為是惰性重復(fù)，所以引擎是擴展惰性重復(fù)而不是減少，于是“<.+”現(xiàn)在被擴展為“<EM”。引擎繼續(xù)匹配下一個記號“>”。這次得到了一個成功匹配。引擎于是報告“<EM>”是一個成功的匹配。整個過程大致如此。
· 惰性擴展的一個替代方案
我們還有一個更好的替代方案。可以用一個貪婪重復(fù)與一個取反字符集：“<[^>]+>”。之所以說這是一個更好的方案在于使用惰性重復(fù)時，引擎會在找到一個成功匹配前對每一個字符進(jìn)行回溯。而使用取反字符集則不需要進(jìn)行回溯。
最后要記住的是，本教程僅僅談到的是正則導(dǎo)向的引擎。文本導(dǎo)向的引擎是不回溯的。但是同時他們也不支持惰性重復(fù)操作。
7. 使用“.”匹配幾乎任意字符
在正則表達(dá)式中，“.”是最常用的符號之一。不幸的是，它也是最容易被誤用的符號之一。
“.”匹配一個單個的字符而不用關(guān)心被匹配的字符是什么。唯一的例外是新行符。在本教程中談到的引擎，缺省情況下都是不匹配新行符的。因此在缺省情況下，“.”等于是字符集[^\n\r](Window)或[^\n]( Unix)的簡寫。
這個例外是因為歷史的原因。因為早期使用正則表達(dá)式的工具是基于行的。它們都是一行一行的讀入一個文件，將正則表達(dá)式分別應(yīng)用到每一行上去。在這些工具中，字符串是不包含新行符的。因此“.”也就從不匹配新行符。
現(xiàn)代的工具和語言能夠?qū)⒄齽t表達(dá)式應(yīng)用到很大的字符串甚至整個文件上去。本教程討論的所有正則表達(dá)式實現(xiàn)都提供一個選項，可以使“.”匹配所有的字符，包括新行符。在RegexBuddy, EditPad Pro或PowerGREP等工具中，你可以簡單的選中“點號匹配新行符”。在Perl中，“.”可以匹配新行符的模式被稱作“單行模式”。很不幸，這是一個很容易混淆的名詞。因為還有所謂“多行模式”。多行模式只影響行首行尾的錨定(anchor)，而單行模式只影響“.”。
其他語言和正則表達(dá)式庫也采用了Perl的術(shù)語定義。當(dāng)在.NET Framework中使用正則表達(dá)式類時，你可以用類似下面的語句來激活單行模式：Regex.Match(“string”,”regex”,RegexOptions.SingleLine)
· 保守的使用點號“.”
點號可以說是最強大的元字符。它允許你偷懶：用一個點號，就能匹配幾乎所有的字符。但是問題在于，它也常常會匹配不該匹配的字符。
我會以一個簡單的例子來說明。讓我們看看如何匹配一個具有“mm/dd/yy”格式的日期，但是我們想允許用戶來選擇分隔符。很快能想到的一個方案是<<\d\d.\d\d.\d\d>>�？瓷先ニ芷ヅ淙掌凇�02/12/03”。問題在于02512703也會被認(rèn)為是一個有效的日期。
<<\d\d[-/.]\d\d[-/.]\d\d>>看上去是一個好一點的解決方案。記住點號在一個字符集里不是元字符。這個方案遠(yuǎn)不夠完善，它會匹配“99/99/99”。而<<[0-1]\d[-/.][0-3]\d[-/.]\d\d>>又更進(jìn)一步。盡管他也會匹配“19/39/99”。你想要你的正則表達(dá)式達(dá)到如何完美的程度取決于你想達(dá)到什么樣的目的。如果你想校驗用戶輸入，則需要盡可能的完美。如果你只是想分析一個已知的源，并且我們知道沒有錯誤的數(shù)據(jù)，用一個比較好的正則表達(dá)式來匹配你想要搜尋的字符就已經(jīng)足夠。
8. 字符串開始和結(jié)束的錨定
錨定和一般的正則表達(dá)式符號不同，它不匹配任何字符。相反，他們匹配的是字符之前或之后的位置�！癪”匹配一行字符串第一個字符前的位置。<<^a>>將會匹配字符串“abc”中的a。<<^b>>將不會匹配“abc”中的任何字符。
類似的，$匹配字符串中最后一個字符的后面的位置。所以<<c$>>匹配“abc”中的c。
· 錨定的應(yīng)用
在編程語言中校驗用戶輸入時，使用錨定是非常重要的。如果你想校驗用戶的輸入為整數(shù)，用<<^\d+$>>。
用戶輸入中，常常會有多余的前導(dǎo)空格或結(jié)束空格。你可以用<<^\s*>>和<<\s*$>>來匹配前導(dǎo)空格或結(jié)束空格。
· 使用“^”和“$”作為行的開始和結(jié)束錨定
如果你有一個包含了多行的字符串。例如：“first line\n\rsecond line”(其中\(zhòng)n\r表示一個新行符)。常常需要對每行分別處理而不是整個字符串。因此，幾乎所有的正則表達(dá)式引擎都提供一個選項，可以擴展這兩種錨定的含義�！癪”可以匹配字串的開始位置(在f之前)，以及每一個新行符的后面位置(在\n\r和s之間)。類似的，$會匹配字串的結(jié)束位置(最后一個e之后)，以及每個新行符的前面(在e與\n\r之間)。
在.NET中，當(dāng)你使用如下代碼時，將會定義錨定匹配每一個新行符的前面和后面位置：Regex.Match("string", "regex", RegexOptions.Multiline)
應(yīng)用：string str = Regex.Replace(Original, "^", "> ", RegexOptions.Multiline)--將會在每行的行首插入“> ”。
· 絕對錨定
<<\A>>只匹配整個字符串的開始位置，<<\Z>>只匹配整個字符串的結(jié)束位置。即使你使用了“多行模式”，<<\A>>和<<\Z>>也從不匹配新行符。
即使\Z和$只匹配字符串的結(jié)束位置，仍然有一個例外的情況。如果字符串以新行符結(jié)束，則\Z和$將會匹配新行符前面的位置，而不是整個字符串的最后面。這個“改進(jìn)”是由Perl引進(jìn)的，然后被許多的正則表達(dá)式實現(xiàn)所遵循，包括Java，.NET等。如果應(yīng)用<<^[a-z]+$>>到“joe\n”，則匹配結(jié)果是“joe”而不是“joe\n”。
在本文中講述了正則表達(dá)式中的組與向后引用，先前向后查看，條件測試，單詞邊界，選擇符等表達(dá)式及例子，并分析了正則引擎在執(zhí)行匹配時的內(nèi)部機理。
本文是Jan Goyvaerts為RegexBuddy寫的教程的譯文，版權(quán)歸原作者所有，歡迎轉(zhuǎn)載。但是為了尊重原作者和譯者的勞動，請注明出處！謝謝！
9. 單詞邊界
元字符<<\b>>也是一種對位置進(jìn)行匹配的“錨”。這種匹配是0長度匹配。
有4種位置被認(rèn)為是“單詞邊界”：
1) 在字符串的第一個字符前的位置(如果字符串的第一個字符是一個“單詞字符”)
2) 在字符串的最后一個字符后的位置(如果字符串的最后一個字符是一個“單詞字符”)
3) 在一個“單詞字符”和“非單詞字符”之間，其中“非單詞字符”緊跟在“單詞字符”之后
4) 在一個“非單詞字符”和“單詞字符”之間，其中“單詞字符”緊跟在“非單詞字符”后面
“單詞字符”是可以用“\w”匹配的字符，“非單詞字符”是可以用“\W”匹配的字符。在大多數(shù)的正則表達(dá)式實現(xiàn)中，“單詞字符”通常包括<<[a-zA-Z0-9_]>>。
例如：<<\b4\b>>能夠匹配單個的4而不是一個更大數(shù)的一部分。這個正則表達(dá)式不會匹配“44”中的4。
換種說法，幾乎可以說<<\b>>匹配一個“字母數(shù)字序列”的開始和結(jié)束的位置。
“單詞邊界”的取反集為<<\B>>，他要匹配的位置是兩個“單詞字符”之間或者兩個“非單詞字符”之間的位置。
· 深入正則表達(dá)式引擎內(nèi)部
讓我們看看把正則表達(dá)式<<\bis\b>>應(yīng)用到字符串“This island is beautiful”。引擎先處理符號<<\b>>。因為\b是0長度 ，所以第一個字符T前面的位置會被考察。因為T是一個“單詞字符”，而它前面的字符是一個空字符(void)，所以\b匹配了單詞邊界。接著<<i>>和第一個字符“T”匹配失敗。匹配過程繼續(xù)進(jìn)行，直到第五個空格符，和第四個字符“s”之間又匹配了<<\b>>。然而空格符和<<i>>不匹配。繼續(xù)向后，到了第六個字符“i”，和第五個空格字符之間匹配了<<\b>>，然后<<is>>和第六、第七個字符都匹配了。然而第八個字符和第二個“單詞邊界”不匹配，所以匹配又失敗了。到了第13個字符i，因為和前面一個空格符形成“單詞邊界”，同時<<is>>和“is”匹配。引擎接著嘗試匹配第二個<<\b>>。因為第15個空格符和“s”形成單詞邊界，所以匹配成功。引擎“急著”返回成功匹配的結(jié)果。
10. 選擇符
正則表達(dá)式中“|”表示選擇。你可以用選擇符匹配多個可能的正則表達(dá)式中的一個。
如果你想搜索文字“cat”或“dog”，你可以用<<cat|dog>>。如果你想有更多的選擇，你只要擴展列表<<cat|dog|mouse|fish>>。
選擇符在正則表達(dá)式中具有最低的優(yōu)先級，也就是說，它告訴引擎要么匹配選擇符左邊的所有表達(dá)式，要么匹配右邊的所有表達(dá)式。你也可以用圓括號來限制選擇符的作用范圍。如<<\b(cat|dog)\b>>，這樣告訴正則引擎把(cat|dog)當(dāng)成一個正則表達(dá)式單位來處理。
· 注意正則引擎的“急于表功”性
正則引擎是急切的，當(dāng)它找到一個有效的匹配時，它會停止搜索。因此在一定條件下，選擇符兩邊的表達(dá)式的順序?qū)Y(jié)果會有影響。假設(shè)你想用正則表達(dá)式搜索一個編程語言的函數(shù)列表：Get，GetValue，Set或SetValue。一個明顯的解決方案是<<Get|GetValue|Set|SetValue>>。讓我們看看當(dāng)搜索SetValue時的結(jié)果。
因為<<Get>>和<<GetValue>>都失敗了，而<<Set>>匹配成功。因為正則導(dǎo)向的引擎都是“急切”的，所以它會返回第一個成功的匹配，就是“Set”，而不去繼續(xù)搜索是否有其他更好的匹配。
和我們期望的相反，正則表達(dá)式并沒有匹配整個字符串。有幾種可能的解決辦法。一是考慮到正則引擎的“急切”性，改變選項的順序，例如我們使用<<GetValue|Get|SetValue|Set>>，這樣我們就可以優(yōu)先搜索最長的匹配。我們也可以把四個選項結(jié)合起來成兩個選項：<<Get(Value)?|Set(Value)?>>。因為問號重復(fù)符是貪婪的，所以SetValue總會在Set之前被匹配。
一個更好的方案是使用單詞邊界：<<\b(Get|GetValue|Set|SetValue)\b>>或<<\b(Get(Value)?|Set(Value)?\b>>。更進(jìn)一步，既然所有的選擇都有相同的結(jié)尾，我們可以把正則表達(dá)式優(yōu)化為<<\b(Get|Set)(Value)?\b>>。
11. 組與向后引用
把正則表達(dá)式的一部分放在圓括號內(nèi)，你可以將它們形成組。然后你可以對整個組使用一些正則操作，例如重復(fù)操作符。
要注意的是，只有圓括號“()”才能用于形成組�！癧]”用于定義字符集�！皗}”用于定義重復(fù)操作。
當(dāng)用“()”定義了一個正則表達(dá)式組后，正則引擎則會把被匹配的組按照順序編號，存入緩存。當(dāng)對被匹配的組進(jìn)行向后引用的時候，可以用“\數(shù)字”的方式進(jìn)行引用。<<\1>>引用第一個匹配的后向引用組，<<\2>>引用第二個組，以此類推，<<\n>>引用第n個組。而<<\0>>則引用整個被匹配的正則表達(dá)式本身。我們看一個例子。
假設(shè)你想匹配一個HTML標(biāo)簽的開始標(biāo)簽和結(jié)束標(biāo)簽，以及標(biāo)簽中間的文本。比如<B>This is a test</B>，我們要匹配<B>和</B>以及中間的文字。我們可以用如下正則表達(dá)式：“<([A-Z][A-Z0-9]*)[^>]*>.*?</\1>”
首先，“<”將會匹配“<B>”的第一個字符“<”。然后[A-Z]匹配B，[A-Z0-9]*將會匹配0到多次字母數(shù)字，后面緊接著0到多個非“>”的字符。最后正則表達(dá)式的“>”將會匹配“<B>”的“>”。接下來正則引擎將對結(jié)束標(biāo)簽之前的字符進(jìn)行惰性匹配，直到遇到一個“</”符號。然后正則表達(dá)式中的“\1”表示對前面匹配的組“([A-Z][A-Z0-9]*)”進(jìn)行引用，在本例中，被引用的是標(biāo)簽名“B”。所以需要被匹配的結(jié)尾標(biāo)簽為“</B>”
你可以對相同的后向引用組進(jìn)行多次引用，<<([a-c])x\1x\1>>將匹配“axaxa”、“bxbxb”以及“cxcxc”。如果用數(shù)字形式引用的組沒有有效的匹配，則引用到的內(nèi)容簡單的為空。
一個后向引用不能用于它自身。<<([abc]\1)>>是錯誤的。因此你不能將<<\0>>用于一個正則表達(dá)式匹配本身，它只能用于替換操作中。
后向引用不能用于字符集內(nèi)部。<<(a)[\1b]>>中的<<\1>>并不表示后向引用。在字符集內(nèi)部，<<\1>>可以被解釋為八進(jìn)制形式的轉(zhuǎn)碼。
向后引用會降低引擎的速度，因為它需要存儲匹配的組。如果你不需要向后引用，你可以告訴引擎對某個組不存儲。例如：<<Get(?:Value)>>。其中“(”后面緊跟的“?:”會告訴引擎對于組(Value)，不存儲匹配的值以供后向引用。
· 重復(fù)操作與后向引用
當(dāng)對組使用重復(fù)操作符時，緩存里后向引用內(nèi)容會被不斷刷新，只保留最后匹配的內(nèi)容。例如：<<([abc]+)=\1>>將匹配“cab=cab”，但是<<([abc])+=\1>>卻不會。因為([abc])第一次匹配“c”時，“\1”代表“c”；然后([abc])會繼續(xù)匹配“a”和“b”。最后“\1”代表“b”，所以它會匹配“cab=b”。
應(yīng)用：檢查重復(fù)單詞--當(dāng)編輯文字時，很容易就會輸入重復(fù)單詞，例如“the the”。使用<<\b(\w+)\s+\1\b>>可以檢測到這些重復(fù)單詞。要刪除第二個單詞，只要簡單的利用替換功能替換掉“\1”就可以了。
· 組的命名和引用
在PHP，Python中，可以用<<(?P<name>group)>>來對組進(jìn)行命名。在本例中，詞法?P<name>就是對組(group)進(jìn)行了命名。其中name是你對組的起的名字。你可以用(?P=name)進(jìn)行引用。
.NET的命名組
.NET framework也支持命名組。不幸的是，微軟的程序員們決定發(fā)明他們自己的語法，而不是沿用Perl、Python的規(guī)則。目前為止，還沒有任何其他的正則表達(dá)式實現(xiàn)支持微軟發(fā)明的語法。
下面是.NET中的例子：
(?<first>group)(?’second’group)
正如你所看到的，.NET提供兩種詞法來創(chuàng)建命名組：一是用尖括號“<>”，或者用單引號“’’”。尖括號在字符串中使用更方便，單引號在ASP代碼中更有用，因為ASP代碼中“<>”被用作HTML標(biāo)簽。
要引用一個命名組，使用\k<name>或\k’name’.
當(dāng)進(jìn)行搜索替換時，你可以用“${name}”來引用一個命名組。
12. 正則表達(dá)式的匹配模式
本教程所討論的正則表達(dá)式引擎都支持三種匹配模式：
<</i>>使正則表達(dá)式對大小寫不敏感，
<</s>>開啟“單行模式”，即點號“.”匹配新行符
<</m>>開啟“多行模式”，即“^”和“$”匹配新行符的前面和后面的位置。
· 在正則表達(dá)式內(nèi)部打開或關(guān)閉模式
如果你在正則表達(dá)式內(nèi)部插入修飾符(?ism)，則該修飾符只對其右邊的正則表達(dá)式起作用。(?-i)是關(guān)閉大小寫不敏感。你可以很快的進(jìn)行測試。<<(?i)te(?-i)st>>應(yīng)該匹配TEst，但是不能匹配teST或TEST.
13. 原子組與防止回溯
在一些特殊情況下，因為回溯會使得引擎的效率極其低下。
讓我們看一個例子：要匹配這樣的字串，字串中的每個字段間用逗號做分隔符，第12個字段由P開頭。
我們?nèi)菀紫氲竭@樣的正則表達(dá)式<<^(.*?,){11}P>>。這個正則表達(dá)式在正常情況下工作的很好。但是在極端情況下，如果第12個字段不是由P開頭，則會發(fā)生災(zāi)難性的回溯。如要搜索的字串為“1,2,3,4,5,6,7,8,9,10,11,12,13”。首先，正則表達(dá)式一直成功匹配直到第12個字符。這時，前面的正則表達(dá)式消耗的字串為“1,2,3,4,5,6,7,8,9,10,11,”，到了下一個字符，<<P>>并不匹配“12”。所以引擎進(jìn)行回溯，這時正則表達(dá)式消耗的字串為“1,2,3,4,5,6,7,8,9,10,11”。繼續(xù)下一次匹配過程，下一個正則符號為點號<<.>>，可以匹配下一個逗號“,”。然而<<，>>并不匹配字符“12”中的“1”。匹配失敗，繼續(xù)回溯。大家可以想象，這樣的回溯組合是個非常大的數(shù)量。因此可能會造成引擎崩潰。
用于阻止這樣巨大的回溯有幾種方案：
一種簡單的方案是盡可能的使匹配精確。用取反字符集代替點號。例如我們用如下正則表達(dá)式<<^([^,\r\n]*,){11}P>>，這樣可以使失敗回溯的次數(shù)下降到11次。
另一種方案是使用原子組。
原子組的目的是使正則引擎失敗的更快一點。因此可以有效的阻止海量回溯。原子組的語法是<<(?>正則表達(dá)式)>>。位于(?>)之間的所有正則表達(dá)式都會被認(rèn)為是一個單一的正則符號。一旦匹配失敗，引擎將會回溯到原子組前面的正則表達(dá)式部分。前面的例子用原子組可以表達(dá)成<<^(?>(.*?,){11})P>>。一旦第十二個字段匹配失敗，引擎回溯到原子組前面的<<^>>。
14. 向前查看與向后查看
Perl 5 引入了兩個強大的正則語法：“向前查看”和“向后查看”。他們也被稱作“零長度斷言”。他們和錨定一樣都是零長度的（所謂零長度即指該正則表達(dá)式不消耗被匹配的字符串）。不同之處在于“前后查看”會實際匹配字符，只是他們會拋棄匹配只返回匹配結(jié)果：匹配或不匹配。這就是為什么他們被稱作“斷言”。他們并不實際消耗字符串中的字符，而只是斷言一個匹配是否可能。
幾乎本文討論的所有正則表達(dá)式的實現(xiàn)都支持“向前向后查看”。唯一的一個例外是Javascript只支持向前查看。
· 肯定和否定式的向前查看
如我們前面提過的一個例子：要查找一個q，后面沒有緊跟一個u。也就是說，要么q后面沒有字符，要么后面的字符不是u。采用否定式向前查看后的一個解決方案為<<q(?!u)>>。否定式向前查看的語法是<<(?!查看的內(nèi)容)>>。
肯定式向前查看和否定式向前查看很類似：<<(?=查看的內(nèi)容)>>。
如果在“查看的內(nèi)容”部分有組，也會產(chǎn)生一個向后引用。但是向前查看本身并不會產(chǎn)生向后引用，也不會被計入向后引用的編號中。這是因為向前查看本身是會被拋棄掉的，只保留匹配與否的判斷結(jié)果。如果你想保留匹配的結(jié)果作為向后引用，你可以用<<(?=(regex))>>來產(chǎn)生一個向后引用。
· 肯定和否定式的先后查看
向后查看和向前查看有相同的效果，只是方向相反
否定式向后查看的語法是：<<(?<!查看內(nèi)容)>>
肯定式向后查看的語法是：<<(?<=查看內(nèi)容)>>
我們可以看到，和向前查看相比，多了一個表示方向的左尖括號。
例：<<(?<!a)b>>將會匹配一個沒有“a”作前導(dǎo)字符的“b”。
值得注意的是：向前查看從當(dāng)前字符串位置開始對“查看”正則表達(dá)式進(jìn)行匹配；向后查看則從當(dāng)前字符串位置開始先后回溯一個字符，然后再開始對“查看”正則表達(dá)式進(jìn)行匹配。
· 深入正則表達(dá)式引擎內(nèi)部
讓我們看一個簡單例子。
把正則表達(dá)式<<q(?!u)>>應(yīng)用到字符串“Iraq”。正則表達(dá)式的第一個符號是<<q>>。正如我們知道的，引擎在匹配<<q>>以前會掃過整個字符串。當(dāng)?shù)谒膫�字符“q”被匹配后，“q”后面是空字符(void)。而下一個正則符號是向前查看。引擎注意到已經(jīng)進(jìn)入了一個向前查看正則表達(dá)式部分。下一個正則符號是<<u>>，和空字符不匹配，從而導(dǎo)致向前查看里的正則表達(dá)式匹配失敗。因為是一個否定式的向前查看，意味著整個向前查看結(jié)果是成功的。于是匹配結(jié)果“q”被返回了。
我們在把相同的正則表達(dá)式應(yīng)用到“quit”。<<q>>匹配了“q”。下一個正則符號是向前查看部分的<<u>>，它匹配了字符串中的第二個字符“i”。引擎繼續(xù)走到下個字符“i”。然而引擎這時注意到向前查看部分已經(jīng)處理完了，并且向前查看已經(jīng)成功。于是引擎拋棄被匹配的字符串部分，這將導(dǎo)致引擎回退到字符“u”。
因為向前查看是否定式的，意味著查看部分的成功匹配導(dǎo)致了整個向前查看的失敗，因此引擎不得不進(jìn)行回溯。最后因為再沒有其他的“q”和<<q>>匹配，所以整個匹配失敗了。
為了確保你能清楚地理解向前查看的實現(xiàn)，讓我們把<<q(?=u)i>>應(yīng)用到“quit”。<<q>>首先匹配“q”。然后向前查看成功匹配“u”，匹配的部分被拋棄，只返回可以匹配的判斷結(jié)果。引擎從字符“i”回退到“u”。由于向前查看成功了，引擎繼續(xù)處理下一個正則符號<<i>>。結(jié)果發(fā)現(xiàn)<<i>>和“u”不匹配。因此匹配失敗了。由于后面沒有其他的“q”，整個正則表達(dá)式的匹配失敗了。
· 更進(jìn)一步理解正則表達(dá)式引擎內(nèi)部機制
讓我們把<<(?<=a)b>>應(yīng)用到“thingamabob”。引擎開始處理向后查看部分的正則符號和字符串中的第一個字符。在這個例子中，向后查看告訴正則表達(dá)式引擎回退一個字符，然后查看是否有一個“a”被匹配。因為在“t”前面沒有字符，所以引擎不能回退。因此向后查看失敗了。引擎繼續(xù)走到下一個字符“h”。再一次，引擎暫時回退一個字符并檢查是否有個“a”被匹配。結(jié)果發(fā)現(xiàn)了一個“t”。向后查看又失敗了。
向后查看繼續(xù)失敗，直到正則表達(dá)式到達(dá)了字符串中的“m”，于是肯定式的向后查看被匹配了。因為它是零長度的，字符串的當(dāng)前位置仍然是“m”。下一個正則符號是<<b>>，和“m”匹配失敗。下一個字符是字符串中的第二個“a”。引擎向后暫時回退一個字符，并且發(fā)現(xiàn)<<a>>不匹配“m”。
在下一個字符是字符串中的第一個“b”。引擎暫時性的向后退一個字符發(fā)現(xiàn)向后查看被滿足了，同時<<b>>匹配了“b”。因此整個正則表達(dá)式被匹配了。作為結(jié)果，正則表達(dá)式返回字符串中的第一個“b”。
· 向前向后查看的應(yīng)用
我們來看這樣一個例子：查找一個具有6位字符的，含有“cat”的單詞。
首先，我們可以不用向前向后查看來解決問題，例如：
<< cat\w{3}|\wcat\w{2}|\w{2}cat\w|\w{3}cat>>
足夠簡單吧！但是當(dāng)需求變成查找一個具有6-12位字符，含有“cat”，“dog”或“mouse”的單詞時，這種方法就變得有些笨拙了。
我們來看看使用向前查看的方案。在這個例子中，我們有兩個基本需求要滿足：一是我們需要一個6位的字符，二是單詞含有“cat”。
滿足第一個需求的正則表達(dá)式為<<\b\w{6}\b>>。滿足第二個需求的正則表達(dá)式為<<\b\w*cat\w*\b>>。
把兩者結(jié)合起來，我們可以得到如下的正則表達(dá)式：
<<(?=\b\w{6}\b)\b\w*cat\w*\b>>
具體的匹配過程留給讀者。但是要注意的一點是，向前查看是不消耗字符的，因此當(dāng)判斷單詞滿足具有6個字符的條件后，引擎會從開始判斷前的位置繼續(xù)對后面的正則表達(dá)式進(jìn)行匹配。
最后作些優(yōu)化，可以得到下面的正則表達(dá)式：
<<\b(?=\w{6}\b)\w{0,3}cat\w*>>
15. 正則表達(dá)式中的條件測試
條件測試的語法為<<(?ifthen|else)>>。“if”部分可以是向前向后查看表達(dá)式。如果用向前查看，則語法變?yōu)椋?lt;<(?(?=regex)then|else)>>，其中else部分是可選的。
如果if部分為true，則正則引擎會試圖匹配then部分，否則引擎會試圖匹配else部分。
需要記住的是，向前先后查看并不實際消耗任何字符，因此后面的then與else部分的匹配時從if測試前的部分開始進(jìn)行嘗試。
16. 為正則表達(dá)式添加注釋
在正則表達(dá)式中添加注釋的語法是：<<(?#comment)>>
例：為用于匹配有效日期的正則表達(dá)式添加注釋：
(?#year)(19|20)\d\d[- /.](?#month)(0[1-9]|1[012])[- /.](?#day)(0[1-9]|[12][0-9]|3[01])
喜歡 
頂
難過
囧
圍觀
無聊
