正則表達式真的很騷，可惜你不會寫！
- 正則基礎知識點
- 1.元字符
- 2. 重復限定符
- 3. 分組
- 4. 轉義
- 5. 條件或
- 6. 區間
- 正則進階知識點
- 1. 零寬斷言
- 2. 捕獲和非捕獲
- 3. 反向引用
- 4. 貪婪和非貪婪
- 5. 反義
正則表達式在幾乎所有語言中都可以使用，無論是前端的JavaScript、還是后端的Java、c#。他們都提供相應的接口/函數支持正則表達式。
但很神奇的是：無論你大學選擇哪一門計算機語言，都沒有關于正則表達式的課程給你修，在你學會正則之前，你只能看著那些正則大師們，寫了一串外星文似的字符串，替代了你用一大篇幅的if else代碼來做一些數據校驗。
既然喜歡，那就動手學唄，可當你百度出一一堆相關資料時，你發現無一不例外的枯燥至極，難以學習。
本文旨在用最通俗的語言講述最枯燥的基本知識！
正則基礎知識點
1.元字符
萬物皆有緣，正則也是如此，元字符是構造正則表達式的一種基本元素。
我們先來記幾個常用的元字符：
元字符說明.匹配除換行符以外的任意字符w匹配字母或數字或下劃線或漢字s匹配任意的空白符d匹配數字匹配單詞的開始或結束^匹配字符串的開始$匹配字符串的結束
有了元字符之后，我們就可以利用這些元字符來寫一些簡單的正則表達式了，
比如：
- 匹配有abc開頭的字符串：
- abc或者^abc
- 匹配8位數字的QQ號碼：
- ^dddddddd$
- 匹配1開頭11位數字的手機號碼：
- ^1dddddddddd$
2. 重復限定符
有了元字符就可以寫不少的正則表達式了，但細心的你們可能會發現：別人寫的正則簡潔明了，而不理君寫的正則一堆亂七八糟而且重復的元字符組成的。正則沒提供辦法處理這些重復的元字符嗎？
答案是有的！
為了處理這些重復問題，正則表達式中一些重復限定符，把重復部分用合適的限定符替代，下面我們來看一些限定符：
語法說明*重復零次或更多次+重復一次或更多次?重復零次或一次{n}重復n次{n,}重復n次或更多次{n,m}重復n到m次
有了這些限定符之后，我們就可以對之前的正則表達式進行改造了，比如：
- 匹配8位數字的QQ號碼：
^d{8}$
- 匹配1開頭11位數字的手機號碼：
^1d{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}$
好了，正則表達式的基本用法就講到這里了，其實它還有非常多的知識點以及元字符，我們在此只列舉了部分元字符和語法來講，旨在給那些不懂正則或者想學正則但有看不下去文檔的人做一個快速入門級的教程，看完本教程，即使你不能寫出高大上的正則，至少也能寫一些簡單的正則或者看得懂別人寫的正則了。
正則進階知識點
1. 零寬斷言
無論是零寬還是斷言，聽起來都古古怪怪的，
那先解釋一下這兩個詞。
- 斷言：俗話的斷言就是“我斷定什么什么”，而正則中的斷言，就是說正則可以指明在指定的內容的前面或后面會出現滿足指定規則的內容，
- 意思正則也可以像人類那樣斷定什么什么，比如"ss1aa2bb3",正則可以用斷言找出aa2前面有bb3，也可以找出aa2后面有ss1.
- 零寬：就是沒有寬度，在正則中，斷言只是匹配位置，不占字符，也就是說，匹配結果里是不會返回斷言本身。
意思是講明白了，那他有什么用呢？
我們來舉個栗子：
假設我們要用爬蟲抓取csdn里的文章閱讀量。通過查看源代碼可以看到文章閱讀量這個內容是這樣的結構
"<span class="read-count">閱讀數：641</span>"
其中也就‘641’這個是變量，也就是說不同文章不同的值，當我們拿到這個字符串時，需要獲得這里邊的‘641’有很多種辦法，但如果正則應該怎么匹配呢？
下面先來講幾種類型的斷言：
- 正向先行斷言（正前瞻）：
- 語法：（?=pattern）
- 作用：匹配pattern表達式的前面內容，不返回本身。
這樣子說，還是一臉懵逼，好吧，回歸剛才那個栗子，要取到閱讀量，在正則表達式中就意味著要能匹配到‘’前面的數字內容
按照上所說的正向先行斷言可以匹配表達式前面的內容，那意思就是:(?=) 就可以匹配到前面的內容了。
匹配什么內容呢？如果要所有內容那就是：
- 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表達式的后面內容，不返回本身。
2. 捕獲和非捕獲
單純說到捕獲，他的意思是匹配表達式，但捕獲通常和分組聯系在一起，也就是“捕獲組”
捕獲組：匹配子表達式的內容，把匹配結果保存到內存中中數字編號或顯示命名的組里，以深度優先進行編號，之后可以通過序號或名稱來使用這些匹配結果。
而根據命名方式的不同，又可以分為兩種組：
- 數字編號捕獲組：
- 語法：(exp)
- 解釋：從表達式左側開始，每出現一個左括號和它對應的右括號之間的內容為一個分組，在分組中，第0組為整個表達式，***組開始為分組。
- 比如固定電話的：020-85653333
- 他的正則表達式為：(0d{2})-(d{8})
- 按照左括號的順序，這個表達式有如下分組：
序號編號分組內容00(0d{2})-(d{8})020-8565333311(0d{2})02022(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個為整個表達式本身，因此也一起輸出了。
- 命名編號捕獲組：
- 語法：(?
- exp)
- 解釋：分組的命名由表達式中的name指定
- 比如區號也可以這樣寫:(?d{2})-(?d{8})
- 按照左括號的順序，這個表達式有如下分組：
序號名稱分組內容00(0d{2})-(d{8})020-856533331quhao(0d{2})0202haoma(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)
- 解釋：和捕獲組剛好相反，它用來標識那些不需要捕獲的分組，說的通俗一點，就是你可以根據需要去保存你的分組。
比如上面的正則表達式，程序不需要用到***個分組，那就可以這樣寫：
- (?:d{2})-(d{8})
序號編號分組內容00(0d{2})-(d{8})020-8565333311(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
3. 反向引用
上面講到捕獲，我們知道：捕獲會返回一個捕獲組，這個分組是保存在內存中，不僅可以在正則表達式外部通過程序進行引用，也可以在正則表達式內部進行引用，這種引用方式就是反向引用。
根據捕獲組的命名規則，反向引用可分為：
- 數字編號組反向引用：k
- 或 umber
- 命名編號組反向引用：k
- 或者'name'
好了 講完了，懂嗎？不懂！！！
可能連前面講的捕獲有什么用都還不懂吧？
其實只是看完捕獲不懂不會用是很正常的！
因為捕獲組通常是和反向引用一起使用的
上面說到捕獲組是匹配子表達式的內容按序號或者命名保存起來以便使用
注意兩個字眼：“內容” 和 “使用”
這里所說的“內容”，是匹配結果，而不是子表達式本身，強調這個有什么用？嗯，先記住
那這里所說的“使用”是怎樣使用呢？
因為它的作用主要是用來查找一些重復的內容或者做替換指定字符。
還是舉栗子吧：
比如要查找一串字母"aabbbbgbddesddfiid"里成對的字母
如果按照我們之前學到的正則，什么區間啊限定啊斷言啊可能是辦不到的，
現在我們先用程序思維理一下思路：
- 1）匹配到一個字母
- 2）匹配第下一個字母，檢查是否和上一個字母是否一樣
- 3）如果一樣，則匹配成功，否則失敗
這里的思路2中匹配下一個字母時，需要用到上一個字母，那怎么記住上一個字母呢？？？
這下子捕獲就有用處啦，我們可以利用捕獲把上一個匹配成功的內容用來作為本次匹配的條件
好了，有思路就要實踐
首先匹配一個字母：w
我們需要做成分組才能捕獲，因此寫成這樣：(w)
那這個表達式就有一個捕獲組：（w）
然后我們要用這個捕獲組作為條件，那就可以：(w)
這樣就大功告成了
可能有人不明白了，是什么意思呢？
還記得捕獲組有兩種命名方式嗎，一種是是根據捕獲分組順序命名，一種是自定義命名來作為捕獲組的命名
在默認情況下都是以數字來命名，而且數字命名的順序是從1開始的
因此要引用***個捕獲組，根據反向引用的數字命名規則 就需要 k<1>或者
當然，通常都是是后者。
我們來測試一下：
- String test = "aabbbbgbddesddfiid";
- Pattern pattern = Pattern.compile("(\w)\1");
- Matcher 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
4. 貪婪和非貪婪
1.貪婪
我們都知道，貪婪就是不滿足，盡可能多的要。
在正則中，貪婪也是差不多的意思:
貪婪匹配：當正則表達式中包含能接受重復的限定符時，通常的行為是（在使整個表達式能得到匹配的前提下）匹配盡可能多的字符，這匹配方式叫做貪婪匹配。
特性：一次性讀入整個字符串進行匹配，每當不匹配就舍棄最右邊一個字符，繼續匹配，依次匹配和舍棄（這種匹配-舍棄的方式也叫做回溯），直到匹配成功或者把整個字符串舍棄完為止，因此它是一種***化的數據返回，能多不會少。
前面我們講過重復限定符，其實這些限定符就是貪婪量詞，比如表達式：
- 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
2. 懶惰（非貪婪）
懶惰匹配：當正則表達式中包含能接受重復的限定符時，通常的行為是（在使整個表達式能得到匹配的前提下）匹配盡可能少的字符，這匹配方式叫做懶惰匹配。
特性：從左到右，從字符串的最左邊開始匹配，每次試圖不讀入字符匹配，匹配成功，則完成匹配，否則讀入一個字符再匹配，依此循環（讀入字符、匹配）直到匹配成功或者把字符串的字符匹配完為止。
懶惰量詞是在貪婪量詞后面加個“？”
代碼說明*?重復任意次，但盡可能少重復+?重復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
5. 反義
前面說到元字符的都是要匹配什么什么，當然如果你想反著來，不想匹配某些字符，正則也提供了一些常用的反義元字符：
元字符解釋W匹配任意不是字母，數字，下劃線，漢字的字符S匹配任意不是空白符的字符D匹配任意非數字的字符B匹配不是單詞開頭或結束的位置[x]匹配除了x以外的任意字符[aeiou]匹配除了aeiou這幾個字母以外的任意字符
正則進階知識就講到這里，正則是一門博大精深的語言，其實學會它的一些語法和知識點還算不太難，但想要做到真正學以致用能寫出非常6的正則，還有很遠的距離，只有真正對它感興趣的，并且經常研究和使用它，才會漸漸的理解它的博大精深之處，我就帶你們走到這，剩下的，靠自己啦。
