前言
在微信公衆號看到的一遍關於正則的文章，特此記錄一下
原文地址：https://mp.weixin.qq.com/s/CBexZfG1DHYji_Pk6Zo38w
本文旨在用最通俗的語言講述最枯燥的基本知識。
文章提綱：
元字符
重複限定符
分組
轉義
條件或
區間
零寬斷言
捕獲和非捕獲
反向引用
貪婪和非貪婪
反義
正則表達式在幾乎所有語言中都可以使用，無論是前端的 JavaScript、還是後端的 Java、c#。他們都提供相應的接口 / 函數支持正則表達式。
但很神奇的是：無論你大學選擇哪一門計算機語言，都沒有關於正則表達式的課程給你修，在你學會正則之前，你只能看着那些正則大師們，寫了一串外星文似的字符串，替代了你用一大篇幅的 if else 代碼來做一些數據校驗。
既然喜歡，那就動手學唄，可當你百度出一一堆相關資料時，你發現無一不例外的枯燥至極，難以學習（實話說，當年不理君也是這樣的心態😂😂）。
下面，不理君嘗試用一種比較通俗點的方式講一下正則，讓你能在讀完之後，能自己寫出一些簡單的正則，再不濟，能看到別人寫的正則，那也不錯了。
1. 元字符
萬物皆有緣，正則也是如此，元字符是構造正則表達式的一種基本元素。
我們先來記幾個常用的元字符：
| 元字符 | 說明 |
|---|---|
| . | 匹配除換行符以外的任意字符 |
| \w | 匹配字母或數字或下劃線或漢字 |
| \s | 匹配任意的空白符 |
| \d | 匹配數字 |
| \b | 匹配單詞的開始或結束 |
| ^ | 匹配字符串的開始 |
| $ | 匹配字符串結束 |
有了元字符之後，我們就可以利用這些元字符來寫一些簡單的正則表達式了，
比如：
匹配有abc開頭的字符串：
\babc或者^abc
匹配8位數字的QQ號碼：
^\d\d\d\d\d\d\d\d$
匹配1開頭11位數字的手機號碼：
^1\d\d\d\d\d\d\d\d\d\d$
2. 重複限定符
有了元字符就可以寫不少的正則表達式了，但細心的你們可能會發現：別人寫的正則簡潔明瞭，而不理君寫的正則一堆亂七八糟而且重複的元字符組成的。正則沒提供辦法處理這些重複的元字符嗎？
答案是有的！
爲了處理這些重複問題，正則表達式中一些重複限定符，把重複部分用合適的限定符替代，下面我們來看一些限定符：
| 語法 | 說明 |
|---|---|
| * | 重複零次或更多次 |
| + | 重複一次或更多次 |
| ? | 重複零次或一次 |
| {n} | 重複n次 |
| {n,} | 重複n次或更多次 |
| {n,m} | 重複n到m次 |
有了這些限定符之後，我們就可以對之前的正則表達式進行改造了，比如：
匹配8位數字的QQ號碼：
^\d{8}$
匹配1開頭11位數字的手機號碼：
^1\d{10}$
匹配銀行卡號是14~18位的數字：
^\d{14,18}$
匹配以a開頭的，0個或多個b結尾的字符串
^ab*$
3. 分組
從上面的例子（4）中看到，限定符是作用在與他左邊最近的一個字符，那麼問題來了，如果我想要 ab 同時被限定那怎麼辦呢？
正則表達式中用小括號 () 來做分組，也就是括號中的內容作爲一個整體。
因此當我們要匹配多個 ab 時，我們可以這樣。
如：匹配字符串中包含 0 到多個 ab 開頭：
^(ab)*
4. 轉義
我們看到正則表達式用小括號來做分組，那麼問題來了：
如果要匹配的字符串中本身就包含小括號，那是不是衝突？應該怎麼辦？
針對這種情況，正則提供了轉義的方式，也就是要把這些元字符、限定符或者關鍵字轉義成普通的字符，做法很簡答，就是在要轉義的字符前面加個斜槓，也就是\即可。如：要匹配以 (ab) 開頭：
^(\(ab\))*
5. 條件或
回到我們剛纔的手機號匹配，我們都知道：國內號碼都來自三大網，它們都有屬於自己的號段，比如聯通有 130/131/132/155/156/185/186/145/176 等號段，假如讓我們匹配一個聯通的號碼，那按照我們目前所學到的正則，應該無從下手的，因爲這裏包含了一些並列的條件，也就是“或”，那麼在正則中是如何表示“或”的呢？
正則用符號 | 來表示或，也叫做分支條件，當滿足正則裏的分支條件的任何一種條件時，都會當成是匹配成功。
那麼我們就可以用或條件來處理這個問題：
^(130|131|132|155|156|185|186|145|176)\d{8}$
6. 區間
看到上面的例子，是不是看到有什麼規律？是不是還有一種想要簡化的衝動？
實際是有的。
正則提供一個元字符中括號 [] 來表示區間條件。
限定 0 到 9 可以寫成 [0-9]
限定 A-Z 寫成 [A-Z]
限定某些數字 [165]
那上面的正則我們還改成這樣：
^((13[0-2])|(15[56])|(18[5-6])|145|176)\d{8}$
7. 零寬斷言
無論是零寬還是斷言，聽起來都古古怪怪的，那先解釋一下這兩個詞。
斷言：俗話的斷言就是“我斷定什麼什麼”，而正則中的斷言，就是說正則可以指明在指定的內容的前面或後面會出現滿足指定規則的內容，意思正則也可以像人類那樣斷定什麼什麼，比如"ss1aa2bb3", 正則可以用斷言找出 aa2 前面有 bb3，也可以找出 aa2 後面有 ss1.
零寬：就是沒有寬度，在正則中，斷言只是匹配位置，不佔字符，也就是說，匹配結果裏是不會返回斷言本身。
意思是講明白了，那他有什麼用呢？
我們來舉個栗子：
假設我們要用爬蟲抓取 csdn 裏的文章閱讀量。通過查看源代碼可以看到文章閱讀量這個內容是這樣的結構。
"<span class="read-count">閱讀數：641</span>"
其中只有‘641’這個是一個變量，也就是不同文章有不同的值，當我們拿到這個字符串時，需要獲得這裏邊的‘641’有很多種辦法，但如果使用正則應該怎麼匹配呢？
下面先講一下幾種類型的斷言：
正向先行斷言（正前瞻）
語法：（?=pattern）
作用：匹配 pattern 表達式的前面內容，不返回本身。
這樣子說，還是一臉懵逼，好吧，迴歸剛纔那個栗子，要取到閱讀量，在正則表達式中就意味着要能匹配到‘</span>’前面的數字內容按照上所說的正向先行斷言可以匹配表達式前面的內容，那意思就是:(?=</span>) 就可以匹配到前面的內容了。匹配什麼內容呢？如果要所有內容那就是：
String reg=".+(?=</span>)";
String test = "<span class=\"read-count\">閱讀數：641</span>";
Pattern pattern = Pattern.compile(reg);
Matcher mc = pattern.matcher(test);
while(mc.find()){
System.out.println("匹配結果：")
System.out.println(mc.group());
}
//匹配結果：
//<span class="read-count">閱讀數：641
可是老哥我們要的只是前面的數字呀，那也簡單咯，匹配數字 \d, 那可以改成：
String reg="\\d+(?=</span>)";
String test = "<span class=\"read-count\">閱讀數：641</span>";
Pattern pattern = Pattern.compile(reg);
Matcher mc= pattern.matcher(test);
while(mc.find()){
System.out.println(mc.group());
}
//匹配結果：
//641
大功告成！
正向後行斷言（正後顧）
語法：（?<=pattern）
作用：匹配 pattern 表達式的後面的內容，不返回本身。
有先行就有後行，先行是匹配前面的內容，那後行就是匹配後面的內容啦。
上面的栗子，我們也可以用後行斷言來處理：
//(?<=<span class="read-count">閱讀數：)\d+
String reg="(?<=<span class=\"read-count\">閱讀數：)\\d+";
String test = "<span class=\"read-count\">閱讀數：641</span>";
Pattern pattern = Pattern.compile(reg);
Matcher mc= pattern.matcher(test);
while(mc.find()){
System.out.println(mc.group());
}
//匹配結果：
//641
就這麼簡單。
負向先行斷言（負前瞻）
語法：(?!pattern)
作用：匹配非 pattern 表達式的前面內容，不返回本身。
有正向也有負向，負向在這裏其實就是非的意思。
舉個栗子：比如有一句 “我愛祖國，我是祖國的花朵”
現在要找到不是'的花朵'前面的祖國
用正則就可以這樣寫：
祖國(?!的花朵)
負向後行斷言（負後顧）
語法：(?<!pattern)
作用：匹配非 pattern 表達式的後面內容，不返回本身。
8. 捕獲和非捕獲
單純說到捕獲，他的意思是匹配表達式，但捕獲通常和分組聯繫在一起，也就是“捕獲組”。
捕獲組：匹配子表達式的內容，把匹配結果保存到內存中中數字編號或顯示命名的組裏，以深度優先進行編號，之後可以通過序號或名稱來使用這些匹配結果。
而根據命名方式的不同，又可以分爲兩種組：
數字編號捕獲組：
語法：(exp)
解釋：從表達式左側開始，每出現一個左括號和它對應的右括號之間的內容爲一個分組，在分組中，第 0 組爲整個表達式，第一組開始爲分組。
比如固定電話的：020-85653333
他的正則表達式爲：(0\d{2})-(\d{8})
按照左括號的順序，這個表達式有如下分組：
| 序號 | 編號 | 分組 | 內容 |
|---|---|---|---|
| 0 | 0 | (0\d{2})-(\d{8}) | 020-85653333 |
| 1 | 1 | (0\d{2}) | 020 |
| 2 | 2 | (\d{8}) | 85653333 |
我們用Java來驗證一下：
String test = "020-85653333";
String reg="(0\\d{2})-(\\d{8})";
Pattern pattern = Pattern.compile(reg);
Matcher mc= pattern.matcher(test);
if(mc.find()){
System.out.println("分組的個數有："+mc.groupCount());
for(int i=0;i<=mc.groupCount();i++){
System.out.println("第"+i+"個分組爲："+mc.group(i));
}
}
輸出結果：
分組的個數有：2
第0個分組爲：020-85653333
第1個分組爲：020
第2個分組爲：85653333
可見，分組個數是2，但是因爲第0個爲整個表達式本身，因此也一起輸出了。
命名編號捕獲組
語法：(?<name>exp)
解釋：分組的命名由表達式中的 name 指定
比如區號也可以這樣寫:(?<quhao>\0\d{2})-(?<haoma>\d{8})，按照左括號的順序，這個表達式有如下分組：
| 序號 | 名稱 | 分組 | 內容 |
|---|---|---|---|
| 0 | 0 | (0\d{2})-(\d{8}) | 020-85653333 |
| 1 | quhao | (0\d{2}) | 020 |
| 2 | haoma | (\d{8}) | 85653333 |
用代碼來驗證一下：
String test = "020-85653333";
String reg="(?<quhao>0\\d{2})-(?<haoma>\\d{8})";
Pattern pattern = Pattern.compile(reg);
Matcher mc= pattern.matcher(test);
if(mc.find()){
System.out.println("分組的個數有："+mc.groupCount());
System.out.println(mc.group("quhao"));
System.out.println(mc.group("haoma"));
}
輸出結果：
分組的個數有：2
分組名稱爲:quhao,匹配內容爲：020
分組名稱爲:haoma,匹配內容爲：85653333
非捕獲組
語法：(?:exp)
解釋：和捕獲組剛好相反，它用來標識那些不需要捕獲的分組，說的通俗一點，就是你可以根據需要去保存你的分組。
比如上面的正則表達式，程序不需要用到第一個分組，那就可以這樣寫：
1(?:\0\d{2})-(\d{8})
| 序號 | 編號 | 分組 | 內容 |
|---|---|---|---|
| 0 | 0 | (0\d{2})-(\d{8}) | 020-85653333 |
| 1 | 1 | (\d{8}) | 85653333 |
驗證一下：
String test = "020-85653333";
String reg="(?:0\\d{2})-(\\d{8})";
Pattern pattern = Pattern.compile(reg);
Matcher mc= pattern.matcher(test);
if(mc.find()){
System.out.println("分組的個數有："+mc.groupCount());
for(int i=0;i<=mc.groupCount();i++){
System.out.println("第"+i+"個分組爲："+mc.group(i));
}
}
輸出結果：
分組的個數有：1
第0個分組爲：020-85653333
第1個分組爲：85653333
9. 反向引用
上面講到捕獲，我們知道：捕獲會返回一個捕獲組，這個分組是保存在內存中，不僅可以在正則表達式外部通過程序進行引用，也可以在正則表達式內部進行引用，這種引用方式就是反向引用。
根據捕獲組的命名規則，反向引用可分爲：
根據捕獲組的命名規則，反向引用可分爲：
-
數字編號組反向引用：\k 或\number
-
命名編號組反向引用：\k 或者\'name'
好了 講完了，懂嗎？不懂！！！
可能連前面講的捕獲有什麼用都還不懂吧？
其實只是看完捕獲不懂不會用是很正常的！
因爲捕獲組通常是和反向引用一起使用的
上面說到捕獲組是匹配子表達式的內容按序號或者命名保存起來以便使用。
注意兩個字眼：“內容” 和 “使用”。
這裏所說的“內容”，是匹配結果，而不是子表達式本身，強調這個有什麼用？嗯，先記住。
那這裏所說的“使用”是怎樣使用呢？
因爲它的作用主要是用來查找一些重複的內容或者做替換指定字符。
還是舉栗子吧：
比如要查找一串字母"aabbbbgbddesddfiid"裏成對的字母。
如果按照我們之前學到的正則，什麼區間啊限定啊斷言啊可能是辦不到的，現在我們先用程序思維理一下思路：
1）匹配到一個字母
2）匹配第下一個字母，檢查是否和上一個字母是否一樣
3）如果一樣，則匹配成功，否則失敗
這裏的思路 2 中匹配下一個字母時，需要用到上一個字母，那怎麼記住上一個字母呢？？？
這下子捕獲就有用處啦，我們可以利用捕獲把上一個匹配成功的內容用來作爲本次匹配的條件。
好了，有思路就要實踐
首先匹配一個字母：\w，我們需要做成分組才能捕獲，因此寫成這樣：(\w)
那這個表達式就有一個捕獲組：（\w）
然後我們要用這個捕獲組作爲條件，那就可以：(\w)\1這樣就大功告成了
可能有人不明白了，\1 是什麼意思呢？
還記得捕獲組有兩種命名方式嗎，一種是是根據捕獲分組順序命名，一種是自定義命名來作爲捕獲組的命名在默認情況下都是以數字來命名，而且數字命名的順序是從 1 開始的。
因此要引用第一個捕獲組，根據反向引用的數字命名規則 就需要 \k<1>或者\1，當然，通常都是是後者。
我們來測試一下：
String test = "aabbbbgbddesddfiid";
Pattern pattern = Pattern.compile("(\\w)\\1");
3Matcher mc= pattern.matcher(test);
while(mc.find()){
System.out.println(mc.group());
}
輸出結果：
aa
bb
bb
dd
dd
ii
嗯，這就是我們想要的了。
在舉個替換的例子，假如想要把字符串中abc換成a。
String test = "abcbbabcbcgbddesddfiid";
String reg="(a)(b)c";
System.out.println(test.replaceAll(reg, "$1"));;
輸出結果：
abbabcgbddesddfiid
10. 貪婪和非貪婪
貪婪
我們都知道，貪婪就是不滿足，儘可能多的要。在正則中，貪婪也是差不多的意思:
貪婪匹配：當正則表達式中包含能接受重複的限定符時，通常的行爲是（在使整個表達式能得到匹配的前提下）匹配儘可能多的字符，這匹配方式叫做貪婪匹配。
特性：一次性讀入整個字符串進行匹配，每當不匹配就捨棄最右邊一個字符，繼續匹配，依次匹配和捨棄（這種匹配 - 捨棄的方式也叫做回溯），直到匹配成功或者把整個字符串捨棄完爲止，因此它是一種最大化的數據返回，能多不會少。
前面我們講過重複限定符，其實這些限定符就是貪婪量詞，比如表達式：
\d{3,6}
用來匹配3到6位數字，在這種情況下，它是一種貪婪模式的匹配，也就是假如字符串裏有6個個數字可以匹配，那它就是全部匹配到。
如:
String reg="\\d{3,6}";
String test="61762828 176 2991 871";
System.out.println("文本："+test);
System.out.println("貪婪模式："+reg);
Pattern p1 =Pattern.compile(reg);
Matcher m1 = p1.matcher(test);
while(m1.find()){
System.out.println("匹配結果："+m1.group(0));
}
輸出結果：
文本：61762828 176 2991 44 871
貪婪模式：\d{3,6}
匹配結果：617628
匹配結果：176
匹配結果：2991
匹配結果：871
由結果可見：本來字符串中的“61762828”這一段，其實只需要出現3個（617）就已經匹配成功了的，但是他並不滿足，而是匹配到了最大能匹配的字符，也就是6個。
一個量詞就如此貪婪了，那有人會問，如果多個貪婪量詞湊在一起，那他們是如何支配自己的匹配權的呢？
是這樣的，多個貪婪在一起時，如果字符串能滿足他們各自最大程度的匹配時，就互不干擾，但如果不能滿足時，會根據深度優先原則，也就是從左到右的每一個貪婪量詞，優先最大數量的滿足，剩餘再分配下一個量詞匹配。
String reg="(\\d{1,2})(\\d{3,4})";
String test="61762828 176 2991 87321";
System.out.println("文本："+test);
System.out.println("貪婪模式："+reg);
Pattern p1 =Pattern.compile(reg);
Matcher m1 = p1.matcher(test);
while(m1.find()){
System.out.println("匹配結果："+m1.group(0));
}
輸出結果：
文本：61762828 176 2991 87321
貪婪模式：(\d{1,2})(\d{3,4})
匹配結果：617628
匹配結果：2991
匹配結果：87321
-
“617628” 是前面的\d{1,2}匹配出了 61，後面的匹配出了 7628
-
"2991" 是前面的\d{1,2}匹配出了 29 ，後面的匹配出了 91
-
"87321"是前面的\d{1,2}匹配出了 87，後面的匹配出了 321
懶惰（非貪婪）
懶惰匹配：當正則表達式中包含能接受重複的限定符時，通常的行爲是（在使整個表達式能得到匹配的前提下）匹配儘可能少的字符，這匹配方式叫做懶惰匹配。
特性：從左到右，從字符串的最左邊開始匹配，每次試圖不讀入字符匹配，匹配成功，則完成匹配，否則讀入一個字符再匹配，依此循環（讀入字符、匹配）直到匹配成功或者把字符串的字符匹配完爲止。
懶惰量詞是在貪婪量詞後面加個“？”
| 代碼 | 說明 |
|---|---|
| *? | 重複任意次，但儘可能少重複 |
| +? | 重複1次或更多次，但儘可能少重複 |
| ?? | 重複0次或1次，但儘可能少重複 |
| {n,m}? | 重複n到m次，但儘可能少重複 |
| {n,}? | 重複n次以上，但儘可能少重複 |
String reg="(\\d{1,2}?)(\\d{3,4})";
String test="61762828 176 2991 87321";
System.out.println("文本："+test);
System.out.println("貪婪模式："+reg);
Pattern p1 =Pattern.compile(reg);
Matcher m1 = p1.matcher(test);
while(m1.find()){
System.out.println("匹配結果："+m1.group(0));
}
輸出結果：
文本：61762828 176 2991 87321
貪婪模式：(\d{1,2}?)(\d{3,4})
匹配結果：61762
匹配結果：2991
匹配結果：87321
解答：
-
“61762” 是左邊的懶惰匹配出 6，右邊的貪婪匹配出 1762
-
"2991" 是左邊的懶惰匹配出 2，右邊的貪婪匹配出 991
-
"87321" 左邊的懶惰匹配出 8，右邊的貪婪匹配出 7321
11. 反義
前面說到元字符的都是要匹配什麼什麼，當然如果你想反着來，不想匹配某些字符，正則也提供了一些常用的反義元字符：
| 元字符 | 解釋 |
|---|---|
| \W | 匹配任意不是字母，數字，下劃線，漢字的字符 |
| \S | 匹配任意不是空白符的字符 |
| \D | 匹配任意非數字的字符 |
| \B | 匹配不是單詞開頭或結束的位置 |
| [^x] | 匹配除了x以外的任意字符 |
| [^aeiou] | 匹配除了aeiou這幾個字母以外的任意字符 |
正則知識就講到這裏，正則是一門博大精深的語言，其實學會它的一些語法和知識點還算不太難，但想要做到真正學以致用能寫出非常 6 的正則，還有很遠的距離，只有真正對它感興趣的，並且經常研究和使用它，纔會漸漸的理解它的博大精深之處，我就帶你們走到這，剩下的，靠自己啦。