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