這次不會說我的正則教程沒寫全了吧？？

09-18

這次不會說我的正則教程沒寫全了吧？？

來自專欄編程無界1 人贊了文章

由於上一篇文章：《正則表達式真的很騷，可惜你不會寫！！！》發表之後，不少網友說怎麼沒講斷言沒講反向沒講貪婪….，甚至有老鐵說我褲子都脫了你就給講了一點，哈哈哈，好吧，趁著山竹颱風被迫放假在家的時間，把正則剩餘的一些知識點給講一下，希望大家喜歡，希望這次脫褲子閱讀的老鐵可以暢快的操作了。

本文旨在用最通俗的語言講述最枯燥的基本知識。

關注我的公眾號（ID:編程無界）有更多精彩內容哦，而且不定期送書活動。

文章提綱：

零寬斷言
捕獲和非捕獲
反向引用
貪婪和非貪婪
反義

1. 零寬斷言

無論是零寬還是斷言，聽起來都古古怪怪的，

那先解釋一下這兩個詞。

斷言：俗話的斷言就是「我斷定什麼什麼」，而正則中的斷言，就是說正則可以指明在指定的內容的前面或後面會出現滿足指定規則的內容，
意思正則也可以像人類那樣斷定什麼什麼，比如"ss1aa2bb3",正則可以用斷言找出aa2前面有bb3，也可以找出aa2後面有ss1.
零寬：就是沒有寬度，在正則中，斷言只是匹配位置，不佔字元，也就是說，匹配結果里是不會返回斷言本身。

意思是講明白了，那他有什麼用呢？

我們來舉個栗子：

假設我們要用爬蟲抓取csdn里的文章閱讀量。通過查看源代碼可以看到文章閱讀量這個內容是這樣的結構

1"閱讀數：641"

其中只有『641』這個是一個變數，也就是不同文章有不同的值，當我們拿到這個字元串時，需要獲得這裡邊的『641』有很多種辦法，但如果使用正則應該怎麼匹配呢？

下面先講一下幾種類型的斷言：

正向先行斷言（正前瞻）：

語法：（?=pattern）
作用：匹配pattern表達式的前面內容，不返回本身。

這樣子說，還是一臉懵逼，好吧，回歸剛才那個栗子，要取到閱讀量，在正則表達式中就意味著要能匹配到『』前面的數字內容

按照上所說的正向先行斷言可以匹配表達式前面的內容，那意思就是:(?=) 就可以匹配到前面的內容了。

匹配什麼內容呢？如果要所有內容那就是：

1String reg=".+(?=)"; 2 3String test = "閱讀數：641"; 4Pattern pattern = Pattern.compile(reg); 5Matcher mc= pattern.matcher(test); 6while(mc.find()){ 7 System.out.println("匹配結果：") 8 System.out.println(mc.group()); 9}1011//匹配結果：12//閱讀數：641

可是老哥我們要的只是前面的數字呀，那也簡單咯，匹配數字 d,那可以改成：

1String reg="\d+(?=)";2String test = "閱讀數：641";3Pattern pattern = Pattern.compile(reg);4Matcher mc= pattern.matcher(test);5while(mc.find()){6 System.out.println(mc.group());7}8//匹配結果：9//641

大功告成！

正向後行斷言（正後顧）:

語法：（?<=pattern）
作用：匹配pattern表達式的後面的內容，不返回本身。

有先行就有後行，先行是匹配前面的內容，那後行就是匹配後面的內容啦。

上面的栗子，我們也可以用後行斷言來處理.

1//(?<=閱讀數：)d+ 2String reg="(?<=閱讀數：)\d+"; 3 4String test = "閱讀數：641"; 5Pattern pattern = Pattern.compile(reg); 6Matcher mc= pattern.matcher(test); 7 while(mc.find()){ 8 System.out.println(mc.group()); 9 }10//匹配結果：11//641

就這麼簡單。

負向先行斷言（負前瞻）

語法：(?!pattern)
作用：匹配非pattern表達式的前面內容，不返回本身。

有正向也有負向，負向在這裡其實就是非的意思。

舉個栗子：比如有一句「我愛祖國，我是祖國的花朵」

現在要找到不是的花朵前面的祖國

用正則就可以這樣寫：

1祖國(?!的花朵)

負向後行斷言（負後顧）

語法：(?<!pattern)
作用：匹配非pattern表達式的後面內容，不返回本身。

2. 捕獲和非捕獲

單純說到捕獲，他的意思是匹配表達式，但捕獲通常和分組聯繫在一起，也就是「捕獲組」

捕獲組：匹配子表達式的內容，把匹配結果保存到內存中中數字編號或顯示命名的組裡，以深度優先進行編號，之後可以通過序號或名稱來使用這些匹配結果。

而根據命名方式的不同，又可以分為兩種組：

數字編號捕獲組：
語法：(exp)
解釋：從表達式左側開始，每出現一個左括弧和它對應的右括弧之間的內容為一個分組，在分組中，第0組為整個表達式，第一組開始為分組。
比如固定電話的：020-85653333
他的正則表達式為：(0d{2})-(d{8})
按照左括弧的順序，這個表達式有如下分組：

序號編號分組內容00(0d{2})-(d{8})020-8565333311(0d{2})02022(d{8})85653333

我們用Java來驗證一下：

1String test = "020-85653333"; 2 String reg="(0\d{2})-(\d{8})"; 3 Pattern pattern = Pattern.compile(reg); 4 Matcher mc= pattern.matcher(test); 5 if(mc.find()){ 6 System.out.println("分組的個數有："+mc.groupCount()); 7 for(int i=0;i<=mc.groupCount();i++){ 8 System.out.println("第"+i+"個分組為："+mc.group(i)); 9 }10 }

輸出結果：

1分組的個數有：22第0個分組為：020-856533333第1個分組為：0204第2個分組為：85653333

可見，分組個數是2，但是因為第0個為整個表達式本身，因此也一起輸出了。

命名編號捕獲組：
語法：(?<name>exp)
解釋：分組的命名由表達式中的name指定
比如區號也可以這樣寫:(?<quhao>d{2})-(?<haoma>d{8})
按照左括弧的順序，這個表達式有如下分組：

序號名稱分組內容00(0d{2})-(d{8})020-856533331quhao(0d{2})0202haoma(d{8})85653333

用代碼來驗證一下：

1String test = "020-85653333";2 String reg="(?<quhao>0\d{2})-(?<haoma>\d{8})";3 Pattern pattern = Pattern.compile(reg);4 Matcher mc= pattern.matcher(test);5 if(mc.find()){6 System.out.println("分組的個數有："+mc.groupCount());7 System.out.println(mc.group("quhao"));8 System.out.println(mc.group("haoma"));9 }

輸出結果：

1分組的個數有：22分組名稱為:quhao,匹配內容為：0203分組名稱為:haoma,匹配內容為：85653333

非捕獲組：
語法：(?:exp)

解釋：和捕獲組剛好相反，它用來標識那些不需要捕獲的分組，說的通俗一點，就是你可以根據需要去保存你的分組。

比如上面的正則表達式，程序不需要用到第一個分組，那就可以這樣寫：

1(?:d{2})-(d{8})

序號編號分組內容00(0d{2})-(d{8})020-8565333311(d{8})85653333

驗證一下：

1String test = "020-85653333"; 2 String reg="(?:0\d{2})-(\d{8})"; 3 Pattern pattern = Pattern.compile(reg); 4 Matcher mc= pattern.matcher(test); 5 if(mc.find()){ 6 System.out.println("分組的個數有："+mc.groupCount()); 7 for(int i=0;i<=mc.groupCount();i++){ 8 System.out.println("第"+i+"個分組為："+mc.group(i)); 9 }10 }

輸出結果：

1分組的個數有：12第0個分組為：020-856533333第1個分組為：85653333

3. 反向引用

上面講到捕獲，我們知道：捕獲會返回一個捕獲組，這個分組是保存在內存中，不僅可以在正則表達式外部通過程序進行引用，也可以在正則表達式內部進行引用，這種引用方式就是反向引用。

根據捕獲組的命名規則，反向引用可分為：

數字編號組反向引用：k或
umber
命名編號組反向引用：k或者
ame

好了講完了，懂嗎？不懂！！！

可能連前面講的捕獲有什麼用都還不懂吧？

其實只是看完捕獲不懂不會用是很正常的！

因為捕獲組通常是和反向引用一起使用的

上面說到捕獲組是匹配子表達式的內容按序號或者命名保存起來以便使用

注意兩個字眼：「內容」和「使用」

這裡所說的「內容」，是匹配結果，而不是子表達式本身，強調這個有什麼用？嗯，先記住

那這裡所說的「使用」是怎樣使用呢？

因為它的作用主要是用來查找一些重複的內容或者做替換指定字元。

還是舉栗子吧：

比如要查找一串字母"aabbbbgbddesddfiid"里成對的字母

如果按照我們之前學到的正則，什麼區間啊限定啊斷言啊可能是辦不到的，

現在我們先用程序思維理一下思路：

1）匹配到一個字母
2）匹配第下一個字母，檢查是否和上一個字母是否一樣
3）如果一樣，則匹配成功，否則失敗

這裡的思路2中匹配下一個字母時，需要用到上一個字母，那怎麼記住上一個字母呢？？？

這下子捕獲就有用處啦，我們可以利用捕獲把上一個匹配成功的內容用來作為本次匹配的條件

好了，有思路就要實踐

首先匹配一個字母：w

我們需要做成分組才能捕獲，因此寫成這樣：(w)

那這個表達式就有一個捕獲組：（w）

然後我們要用這個捕獲組作為條件，那就可以：(w)1

這樣就大功告成了

可能有人不明白了，1是什麼意思呢？

還記得捕獲組有兩種命名方式嗎，一種是是根據捕獲分組順序命名，一種是自定義命名來作為捕獲組的命名

在默認情況下都是以數字來命名，而且數字命名的順序是從1開始的

因此要引用第一個捕獲組，根據反向引用的數字命名規則就需要 k<1>或者1

當然，通常都是是後者。

我們來測試一下：

1String test = "aabbbbgbddesddfiid";2 Pattern pattern = Pattern.compile("(\w)\1");3 Matcher mc= pattern.matcher(test);4 while(mc.find()){5 System.out.println(mc.group());67 }

輸出結果：

1aa2bb3bb4dd5dd6ii

嗯，這就是我們想要的了。

在舉個替換的例子，假如想要把字元串中abc換成a

1String test = "abcbbabcbcgbddesddfiid";2String reg="(a)(b)c";3System.out.println(test.replaceAll(reg, "$1"));;

輸出結果：

1abbabcgbddesddfiid

4. 貪婪和非貪婪

1.貪婪

我們都知道，貪婪就是不滿足，儘可能多的要。

在正則中，貪婪也是差不多的意思:

貪婪匹配：當正則表達式中包含能接受重複的限定符時，通常的行為是（在使整個表達式能得到匹配的前提下）匹配儘可能多的字元，這匹配方式叫做貪婪匹配。

特性：一次性讀入整個字元串進行匹配，每當不匹配就捨棄最右邊一個字元，繼續匹配，依次匹配和捨棄（這種匹配-捨棄的方式也叫做回溯），直到匹配成功或者把整個字元串捨棄完為止，因此它是一種最大化的數據返回，能多不會少。

前面我們講過重複限定符，其實這些限定符就是貪婪量詞，比如表達式：

1d{3,6}

用來匹配3到6位數字，在這種情況下，它是一種貪婪模式的匹配，也就是假如字元串里有6個個數字可以匹配，那它就是全部匹配到。

如

1String reg="\d{3,6}"; 2String test="61762828 176 2991 871";3System.out.println("文本："+test);4System.out.println("貪婪模式："+reg);5Pattern p1 =Pattern.compile(reg);6Matcher m1 = p1.matcher(test);7 while(m1.find()){8 System.out.println("匹配結果："+m1.group(0));9 }

輸出結果：

1文本：61762828 176 2991 44 8712貪婪模式：d{3,6}3匹配結果：6176284匹配結果：1765匹配結果：29916匹配結果：871

由結果可見：本來字元串中的「61762828」這一段，其實只需要出現3個（617）就已經匹配成功了的，但是他並不滿足，而是匹配到了最大能匹配的字元，也就是6個。

一個量詞就如此貪婪了，

那有人會問，如果多個貪婪量詞湊在一起，那他們是如何支配自己的匹配權的呢？

是這樣的，多個貪婪在一起時，如果字元串能滿足他們各自最大程度的匹配時，就互不干擾，但如果不能滿足時，會根據深度優先原則，也就是從左到右的每一個貪婪量詞，優先最大數量的滿足，剩餘再分配下一個量詞匹配。

1String reg="(\d{1,2})(\d{3,4})"; 2String test="61762828 176 2991 87321";3System.out.println("文本："+test);4System.out.println("貪婪模式："+reg);5Pattern p1 =Pattern.compile(reg);6Matcher m1 = p1.matcher(test);7 while(m1.find()){8 System.out.println("匹配結果："+m1.group(0));9 }

輸出結果：

1文本：61762828 176 2991 873212貪婪模式：(d{1,2})(d{3,4})3匹配結果：6176284匹配結果：29915匹配結果：87321

「617628」是前面的d{1,2}匹配出了61，後面的匹配出了7628
"2991" 是前面的d{1,2}匹配出了29 ，後面的匹配出了91
"87321"是前面的d{1,2}匹配出了87，後面的匹配出了321

2. 懶惰（非貪婪）

懶惰匹配：當正則表達式中包含能接受重複的限定符時，通常的行為是（在使整個表達式能得到匹配的前提下）匹配儘可能少的字元，這匹配方式叫做懶惰匹配。
特性：從左到右，從字元串的最左邊開始匹配，每次試圖不讀入字元匹配，匹配成功，則完成匹配，否則讀入一個字元再匹配，依此循環（讀入字元、匹配）直到匹配成功或者把字元串的字元匹配完為止。

懶惰量詞是在貪婪量詞後面加個「？」

代碼說明*?重複任意次，但儘可能少重複+?重複1次或更多次，但儘可能少重複??重複0次或1次，但儘可能少重複{n,m}?重複n到m次，但儘可能少重複{n,}?重複n次以上，但儘可能少重複

1String reg="(\d{1,2}?)(\d{3,4})"; 2 String test="61762828 176 2991 87321";3 System.out.println("文本："+test);4 System.out.println("貪婪模式："+reg);5 Pattern p1 =Pattern.compile(reg);6 Matcher m1 = p1.matcher(test);7 while(m1.find()){8 System.out.println("匹配結果："+m1.group(0));9 }

輸出結果：

1文本：61762828 176 2991 873212貪婪模式：(d{1,2}?)(d{3,4})3匹配結果：617624匹配結果：29915匹配結果：87321

解答：

「61762」是左邊的懶惰匹配出6，右邊的貪婪匹配出1762
"2991" 是左邊的懶惰匹配出2，右邊的貪婪匹配出991
"87321" 左邊的懶惰匹配出8，右邊的貪婪匹配出7321

5. 反義

前面說到元字元的都是要匹配什麼什麼，當然如果你想反著來，不想匹配某些字元，正則也提供了一些常用的反義元字元：

元字元解釋W匹配任意不是字母，數字，下劃線，漢字的字元S匹配任意不是空白符的字元D匹配任意非數字的字元B匹配不是單詞開頭或結束的位置[^x]匹配除了x以外的任意字元[^aeiou]匹配除了aeiou這幾個字母以外的任意字元

正則進階知識就講到這裡，正則是一門博大精深的語言，其實學會它的一些語法和知識點還算不太難，但想要做到真正學以致用能寫出非常6的正則，還有很遠的距離，只有真正對它感興趣的，並且經常研究和使用它，才會漸漸的理解它的博大精深之處，我就帶你們走到這，剩下的，靠自己啦。