正則表達式－語法大全

時間 2019-12-12

原文原文鏈接

1. 正則表達式規則

1.1 普通字符

    字母、數字、漢字、下劃線、以及後邊章節中沒有特殊定義的標點符號，都是"普通字符"。表達式中的普通字符，在匹配一個字符串的時候，匹配與之相同的一個字符。

    舉例1：表達式 "c"，在匹配字符串 "abcde" 時，匹配結果是：成功；匹配到的內容是："c"；匹配到的位置是：開始於2，結束於3。（注：下標從0開始仍是從1開始，因當前編程語言的不一樣而可能不一樣）

    舉例2：表達式 "bcd"，在匹配字符串 "abcde" 時，匹配結果是：成功；匹配到的內容是："bcd"；匹配到的位置是：開始於1，結束於4。html

1.2 簡單的轉義字符

一些不便書寫的字符，採用在前面加 "/" 的方法。這些字符其實咱們都已經熟知了。java

表達式程序員	可匹配正則表達式
/r, /n編程	表明回車和換行符數組
/t編程語言	製表符編輯器
//函數	表明 "/" 自己測試

還有其餘一些在後邊章節中有特殊用處的標點符號，在前面加 "/" 後，就表明該符號自己。好比：^, $ 都有特殊意義，若是要想匹配字符串中 "^" 和 "$" 字符，則表達式就須要寫成 "/^" 和 "/$"。

表達式	可匹配
/^	匹配 ^ 符號自己
/$	匹配 $ 符號自己
/.	匹配小數點（.）自己

這些轉義字符的匹配方法與 "普通字符" 是相似的。也是匹配與之相同的一個字符。

舉例1：表達式 "/$d"，在匹配字符串 "abc$de" 時，匹配結果是：成功；匹配到的內容是："$d"；匹配到的位置是：開始於3，結束於5。

1.3 可以與 '多種字符' 匹配的表達式

正則表達式中的一些表示方法，能夠匹配 '多種字符' 其中的任意一個字符。好比，表達式 "/d" 能夠匹配任意一個數字。雖然能夠匹配其中任意字符，可是隻能是一個，不是多個。這就比如玩撲克牌時候，大小王能夠代替任意一張牌，可是隻能代替一張牌。

表達式	可匹配
/d	任意一個數字，0~9 中的任意一個
/w	任意一個字母或數字或下劃線，也就是 A~Z,a~z,0~9,_ 中任意一個
/s	包括空格、製表符、換頁符等空白字符的其中任意一個
.	小數點能夠匹配除了換行符（/n）之外的任意一個字符

舉例1：表達式 "/d/d"，在匹配 "abc123" 時，匹配的結果是：成功；匹配到的內容是："12"；匹配到的位置是：開始於3，結束於5。

舉例2：表達式 "a./d"，在匹配 "aaa100" 時，匹配的結果是：成功；匹配到的內容是："aa1"；匹配到的位置是：開始於1，結束於4。

1.4 自定義可以匹配 '多種字符' 的表達式

使用方括號 [ ] 包含一系列字符，可以匹配其中任意一個字符。用 [^ ] 包含一系列字符，則可以匹配其中字符以外的任意一個字符。一樣的道理，雖然能夠匹配其中任意一個，可是隻能是一個，不是多個。

表達式	可匹配
[ab5@]	匹配 "a" 或 "b" 或 "5" 或 "@"
[^abc]	匹配 "a","b","c" 以外的任意一個字符
[f-k]	匹配 "f"~"k" 之間的任意一個字母
[^A-F0-3]	匹配 "A"~"F","0"~"3" 以外的任意一個字符

舉例1：表達式 "[bcd][bcd]" 匹配 "abc123" 時，匹配的結果是：成功；匹配到的內容是："bc"；匹配到的位置是：開始於1，結束於3。

舉例2：表達式 "[^abc]" 匹配 "abc123" 時，匹配的結果是：成功；匹配到的內容是："1"；匹配到的位置是：開始於3，結束於4。

1.5 修飾匹配次數的特殊符號

前面章節中講到的表達式，不管是隻能匹配一種字符的表達式，仍是能夠匹配多種字符其中任意一個的表達式，都只能匹配一次。若是使用表達式再加上修飾匹配次數的特殊符號，那麼不用重複書寫表達式就能夠重複匹配。

使用方法是："次數修飾"放在"被修飾的表達式"後邊。好比："[bcd][bcd]" 能夠寫成 "[bcd]{2}"。

表達式	做用
{n}	表達式重複n次，好比："/w{2}" 至關於 "/w/w"；"a{5}" 至關於 "aaaaa"
{m,n}	表達式至少重複m次，最多重複n次，好比："ba{1,3}"能夠匹配 "ba"或"baa"或"baaa"
{m,}	表達式至少重複m次，好比："/w/d{2,}"能夠匹配 "a12","_456","M12344"...
?	匹配表達式0次或者1次，至關於 {0,1}，好比："a[cd]?"能夠匹配 "a","ac","ad"
+	表達式至少出現1次，至關於 {1,}，好比："a+b"能夠匹配 "ab","aab","aaab"...
*	表達式不出現或出現任意次，至關於 {0,}，好比："/^*b"能夠匹配 "b","^^^b"...

舉例1：表達式 "/d+/.?/d*" 在匹配 "It costs $12.5" 時，匹配的結果是：成功；匹配到的內容是："12.5"；匹配到的位置是：開始於10，結束於14。

舉例2：表達式 "go{2,8}gle" 在匹配 "Ads by goooooogle" 時，匹配的結果是：成功；匹配到的內容是："goooooogle"；匹配到的位置是：開始於7，結束於17。

1.6 其餘一些表明抽象意義的特殊符號

一些符號在表達式中表明抽象的特殊意義：

表達式	做用
^	與字符串開始的地方匹配，不匹配任何字符
$	與字符串結束的地方匹配，不匹配任何字符
/b	匹配一個單詞邊界，也就是單詞和空格之間的位置，不匹配任何字符

    進一步的文字說明仍然比較抽象，所以，舉例幫助你們理解。

    舉例1：表達式 "^aaa" 在匹配 "xxx aaa xxx" 時，匹配結果是：失敗。由於 "^" 要求與字符串開始的地方匹配，所以，只有當 "aaa" 位於字符串的開頭的時候，"^aaa" 才能匹配，好比："aaa xxx xxx"。

    舉例2：表達式 "aaa$" 在匹配 "xxx aaa xxx" 時，匹配結果是：失敗。由於 "$" 要求與字符串結束的地方匹配，所以，只有當 "aaa" 位於字符串的結尾的時候，"aaa$" 才能匹配，好比："xxx xxx aaa"。

    舉例3：表達式 "./b." 在匹配 "@@@abc" 時，匹配結果是：成功；匹配到的內容是："@a"；匹配到的位置是：開始於2，結束於4。
    進一步說明："/b" 與 "^" 和 "$" 相似，自己不匹配任何字符，可是它要求它在匹配結果中所處位置的左右兩邊，其中一邊是 "/w" 範圍，另外一邊是非"/w" 的範圍。

    舉例4：表達式 "/bend/b" 在匹配 "weekend,endfor,end" 時，匹配結果是：成功；匹配到的內容是："end"；匹配到的位置是：開始於15，結束於18。

一些符號能夠影響表達式內部的子表達式之間的關係：

表達式	做用
\|	左右兩邊表達式之間 "或" 關係，匹配左邊或者右邊
( )	(1). 在被修飾匹配次數的時候，括號中的表達式能夠做爲總體被修飾 (2). 取匹配結果的時候，括號中的表達式匹配到的內容能夠被單獨獲得

    舉例5：表達式 "Tom|Jack" 在匹配字符串 "I'm Tom, he is Jack" 時，匹配結果是：成功；匹配到的內容是："Tom"；匹配到的位置是：開始於4，結束於7。匹配下一個時，匹配結果是：成功；匹配到的內容是："Jack"；匹配到的位置時：開始於15，結束於19。

    舉例6：表達式 "(go/s*)+" 在匹配 "Let's go go go!" 時，匹配結果是：成功；匹配到內容是："go go go"；匹配到的位置是：開始於6，結束於14。

    舉例7：表達式 "￥(/d+/.?/d*)" 在匹配 "＄10.9,￥20.5" 時，匹配的結果是：成功；匹配到的內容是："￥20.5"；匹配到的位置是：開始於6，結束於10。單獨獲取括號範圍匹配到的內容是："20.5"。

2. 正則表達式中的一些高級規則

2.1 匹配次數中的貪婪與非貪婪

在使用修飾匹配次數的特殊符號時，有幾種表示方法可使同一個表達式可以匹配不一樣的次數，好比："{m,n}", "{m,}", "?", "*", "+"，具體匹配的次數隨被匹配的字符串而定。這種重複匹配不定次數的表達式在匹配過程當中，老是儘量多的匹配。好比，針對文本 "dxxxdxxxd"，舉例以下：

表達式	匹配結果
(d)(/w+)	"/w+" 將匹配第一個 "d" 以後的全部字符 "xxxdxxxd"
(d)(/w+)(d)	"/w+" 將匹配第一個 "d" 和最後一個 "d" 之間的全部字符 "xxxdxxx"。雖然 "/w+" 也可以匹配上最後一個 "d"，可是爲了使整個表達式匹配成功，"/w+" 能夠 "讓出" 它原本可以匹配的最後一個 "d"

因而可知，"/w+" 在匹配的時候，老是儘量多的匹配符合它規則的字符。雖然第二個舉例中，它沒有匹配最後一個 "d"，但那也是爲了讓整個表達式可以匹配成功。同理，帶 "*" 和 "{m,n}" 的表達式都是儘量地多匹配，帶 "?" 的表達式在可匹配可不匹配的時候，也是儘量的 "要匹配"。這種匹配原則就叫做 "貪婪" 模式。

非貪婪模式：

在修飾匹配次數的特殊符號後再加上一個 "?" 號，則可使匹配次數不定的表達式儘量少的匹配，使可匹配可不匹配的表達式，儘量的 "不匹配"。這種匹配原則叫做 "非貪婪" 模式，也叫做 "勉強" 模式。若是少匹配就會致使整個表達式匹配失敗的時候，與貪婪模式相似，非貪婪模式會最小限度的再匹配一些，以使整個表達式匹配成功。舉例以下，針對文本 "dxxxdxxxd" 舉例：

表達式	匹配結果
(d)(/w+?)	"/w+?" 將盡量少的匹配第一個 "d" 以後的字符，結果是："/w+?" 只匹配了一個 "x"
(d)(/w+?)(d)	爲了讓整個表達式匹配成功，"/w+?" 不得不匹配 "xxx" 纔可讓後邊的 "d" 匹配，從而使整個表達式匹配成功。所以，結果是："/w+?" 匹配 "xxx"

    更多的狀況，舉例以下：

    舉例1：表達式 "<td>(.*)</td>" 與字符串 "<td><p>aa</p></td> <td><p>bb</p></td>" 匹配時，匹配的結果是：成功；匹配到的內容是 "<td><p>aa</p></td> <td><p>bb</p></td>" 整個字符串，表達式中的 "</td>" 將與字符串中最後一個 "</td>" 匹配。

    舉例2：相比之下，表達式 "<td>(.*?)</td>" 匹配舉例1中一樣的字符串時，將只獲得 "<td><p>aa</p></td>"，再次匹配下一個時，能夠獲得第二個 "<td><p>bb</p></td>"。

2.2 反向引用 /1, /2...

表達式在匹配時，表達式引擎會將小括號 "( )" 包含的表達式所匹配到的字符串記錄下來。在獲取匹配結果的時候，小括號包含的表達式所匹配到的字符串能夠單獨獲取。這一點，在前面的舉例中，已經屢次展現了。在實際應用場合中，當用某種邊界來查找，而所要獲取的內容又不包含邊界時，必須使用小括號來指定所要的範圍。好比前面的 "<td>(.*?)</td>"。

其實，"小括號包含的表達式所匹配到的字符串" 不只是在匹配結束後纔可使用，在匹配過程當中也可使用。表達式後邊的部分，能夠引用前面 "括號內的子匹配已經匹配到的字符串"。引用方法是 "/" 加上一個數字。"/1" 引用第1對括號內匹配到的字符串，"/2" 引用第2對括號內匹配到的字符串……以此類推，若是一對括號內包含另外一對括號，則外層的括號先排序號。換句話說，哪一對的左括號 "(" 在前，那這一對就先排序號。

    舉例以下：

    舉例1：表達式 "('|")(.*?)(/1)" 在匹配 " 'Hello', "World" " 時，匹配結果是：成功；匹配到的內容是：" 'Hello' "。再次匹配下一個時，能夠匹配到 " "World" "。

    舉例2：表達式 "(/w)/1{4,}" 在匹配 "aa bbbb abcdefg ccccc 111121111 999999999" 時，匹配結果是：成功；匹配到的內容是 "ccccc"。再次匹配下一個時，將獲得 999999999。這個表達式要求 "/w" 範圍的字符至少重複5次，注意與 "/w{5,}" 之間的區別。

    舉例3：表達式 "<(/w+)/s*(/w+(=('|").*?/4)?/s*)*>.*?<//1>" 在匹配 "<td id='td1' style="bgcolor:white"></td>" 時，匹配結果是成功。若是 "<td>" 與 "</td>" 不配對，則會匹配失敗；若是改爲其餘配對，也能夠匹配成功。

2.3 預搜索，不匹配；反向預搜索，不匹配

前面的章節中，我講到了幾個表明抽象意義的特殊符號："^"，"$"，"/b"。它們都有一個共同點，那就是：它們自己不匹配任何字符，只是對 "字符串的兩頭" 或者 "字符之間的縫隙" 附加了一個條件。理解到這個概念之後，本節將繼續介紹另一種對 "兩頭" 或者 "縫隙" 附加條件的，更加靈活的表示方法。

    正向預搜索："(?=xxxxx)"，"(?!xxxxx)"

    格式："(?=xxxxx)"，在被匹配的字符串中，它對所處的 "縫隙" 或者 "兩頭" 附加的條件是：所在縫隙的右側，必須可以匹配上 xxxxx 這部分的表達式。由於它只是在此做爲這個縫隙上附加的條件，因此它並不影響後邊的表達式去真正匹配這個縫隙以後的字符。這就相似 "/b"，自己不匹配任何字符。"/b" 只是將所在縫隙以前、以後的字符取來進行了一下判斷，不會影響後邊的表達式來真正的匹配。

    舉例1：表達式 "Windows (?=NT|XP)" 在匹配 "Windows 98, Windows NT, Windows 2000" 時，將只匹配 "Windows NT" 中的 "Windows "，其餘的 "Windows " 字樣則不被匹配。

    舉例2：表達式 "(/w)((?=/1/1/1)(/1))+" 在匹配字符串 "aaa ffffff 999999999" 時，將能夠匹配6個"f"的前4個，能夠匹配9個"9"的前7個。這個表達式能夠讀解成：重複4次以上的字母數字，則匹配其剩下最後2位以前的部分。固然，這個表達式能夠不這樣寫，在此的目的是做爲演示之用。

    格式："(?!xxxxx)"，所在縫隙的右側，必須不能匹配 xxxxx 這部分表達式。

    舉例3：表達式 "((?!/bstop/b).)+" 在匹配 "fdjka ljfdl stop fjdsla fdj" 時，將從頭一直匹配到 "stop" 以前的位置，若是字符串中沒有 "stop"，則匹配整個字符串。

    舉例4：表達式 "do(?!/w)" 在匹配字符串 "done, do, dog" 時，只能匹配 "do"。在本條舉例中，"do" 後邊使用 "(?!/w)" 和使用 "/b" 效果是同樣的。

    反向預搜索："(?<=xxxxx)"，"(?<!xxxxx)"

    這兩種格式的概念和正向預搜索是相似的，反向預搜索要求的條件是：所在縫隙的 "左側"，兩種格式分別要求必須可以匹配和必須不可以匹配指定表達式，而不是去判斷右側。與 "正向預搜索" 同樣的是：它們都是對所在縫隙的一種附加條件，自己都不匹配任何字符。

    舉例5：表達式 "(?<=/d{4})/d+(?=/d{4})" 在匹配 "1234567890123456" 時，將匹配除了前4個數字和後4個數字以外的中間8個數字。因爲 JScript.RegExp 不支持反向預搜索，所以，本條舉例不可以進行演示。不少其餘的引擎能夠支持反向預搜索，好比：Java 1.4 以上的 java.util.regex 包，.NET 中System.Text.RegularExpressions 命名空間，以及本站推薦的最簡單易用的 DEELX 正則引擎。

3. 其餘通用規則

還有一些在各個正則表達式引擎之間比較通用的規則，在前面的講解過程當中沒有提到。

3.1 表達式中，可使用 "/xXX" 和 "/uXXXX" 表示一個字符（"X" 表示一個十六進制數）

形式	字符範圍
/xXX	編號在 0 ~ 255 範圍的字符，好比：空格可使用 "/x20" 表示
/uXXXX	任何字符可使用 "/u" 再加上其編號的4位十六進制數表示，好比："/中"

3.2 在表達式 "/s"，"/d"，"/w"，"/b" 表示特殊意義的同時，對應的大寫字母表示相反的意義

表達式	可匹配
/S	匹配全部非空白字符（"/s" 可匹配各個空白字符）
/D	匹配全部的非數字字符
/W	匹配全部的字母、數字、下劃線之外的字符
/B	匹配非單詞邊界，即左右兩邊都是 "/w" 範圍或者左右兩邊都不是 "/w" 範圍時的字符縫隙

3.3 在表達式中有特殊意義，須要添加 "/" 才能匹配該字符自己的字符彙總

字符	說明
^	匹配輸入字符串的開始位置。要匹配 "^" 字符自己，請使用 "/^"
$	匹配輸入字符串的結尾位置。要匹配 "$" 字符自己，請使用 "/$"
( )	標記一個子表達式的開始和結束位置。要匹配小括號，請使用 "/(" 和 "/)"
[ ]	用來自定義可以匹配 '多種字符' 的表達式。要匹配中括號，請使用 "/[" 和 "/]"
{ }	修飾匹配次數的符號。要匹配大括號，請使用 "/{" 和 "/}"
.	匹配除了換行符（/n）之外的任意一個字符。要匹配小數點自己，請使用 "/."
?	修飾匹配次數爲 0 次或 1 次。要匹配 "?" 字符自己，請使用 "/?"
+	修飾匹配次數爲至少 1 次。要匹配 "+" 字符自己，請使用 "/+"
*	修飾匹配次數爲 0 次或任意次。要匹配 "" 字符自己，請使用 "/"
\|	左右兩邊表達式之間 "或" 關係。匹配 "\|" 自己，請使用 "/\|"

3.4 括號 "( )" 內的子表達式，若是但願匹配結果不進行記錄供之後使用，可使用 "(?:xxxxx)" 格式

舉例1：表達式 "(?:(/w)/1)+" 匹配 "a bbccdd efg" 時，結果是 "bbccdd"。括號 "(?:)" 範圍的匹配結果不進行記錄，所以 "(/w)" 使用 "/1" 來引用。

3.5 經常使用的表達式屬性設置簡介：Ignorecase，Singleline，Multiline，Global

表達式屬性	說明
Ignorecase	默認狀況下，表達式中的字母是要區分大小寫的。配置爲 Ignorecase 可以使匹配時不區分大小寫。有的表達式引擎，把 "大小寫" 概念延伸至 UNICODE 範圍的大小寫。
Singleline	默認狀況下，小數點 "." 匹配除了換行符（/n）之外的字符。配置爲 Singleline 可以使小數點可匹配包括換行符在內的全部字符。
Multiline	默認狀況下，表達式 "^" 和 "$" 只匹配字符串的開始 ① 和結尾 ④ 位置。如： ①xxxxxxxxx②/n ③xxxxxxxxx④ 配置爲 Multiline 可使 "^" 匹配 ① 外，還能夠匹配換行符以後，下一行開始前 ③ 的位置，使 "$" 匹配 ④ 外，還能夠匹配換行符以前，一行結束 ② 的位置。
Global	主要在將表達式用來替換時起做用，配置爲 Global 表示替換全部的匹配。

4. 其餘提示

4.1 若是想要了解高級的正則引擎還支持那些複雜的正則語法，可參見本站 DEELX 正則引擎的說明文檔。

4.2 若是要要求表達式所匹配的內容是整個字符串，而不是從字符串中找一部分，那麼能夠在表達式的首尾使用 "^" 和 "$"，好比："^/d+$" 要求整個字符串只有數字。

4.3 若是要求匹配的內容是一個完整的單詞，而不會是單詞的一部分，那麼在表達式首尾使用 "/b"，好比：使用 "/b(if|while|else|void|int……)/b" 來匹配程序中的關鍵字。

4.4 表達式不要匹配空字符串。不然會一直獲得匹配成功，而結果什麼都沒有匹配到。好比：準備寫一個匹配 "123"、"123."、"123.5"、".5" 這幾種形式的表達式時，整數、小數點、小數數字均可以省略，可是不要將表達式寫成："/d*/.?/d*"，由於若是什麼都沒有，這個表達式也能夠匹配成功。更好的寫法是："/d+/.?/d*|/./d+"。

4.5 能匹配空字符串的子匹配不要循環無限次。若是括號內的子表達式中的每一部分均可以匹配 0 次，而這個括號總體又能夠匹配無限次，那麼狀況可能比上一條所說的更嚴重，匹配過程當中可能死循環。雖然如今有些正則表達式引擎已經經過辦法避免了這種狀況出現死循環了，好比 .NET 的正則表達式，可是咱們仍然應該儘可能避免出現這種狀況。若是咱們在寫表達式時遇到了死循環，也能夠從這一點入手，查找一下是不是本條所說的緣由。

4.6 合理選擇貪婪模式與非貪婪模式，參見話題討論。

4.7 或 "|" 的左右兩邊，對某個字符最好只有一邊能夠匹配，這樣，不會由於 "|" 兩邊的表達式由於交換位置而有所不一樣。

------------------------------------------------------------------------------------------下一篇

1，定義正則表達式

1）定義正則表達式有兩種形式，一種是普通方式，一種是構造函數方式。
2）普通方式：var reg=/表達式/附加參數
表達式：一個字符串，表明了某種規則，其中可使用某些特殊字符，來表明特殊的規則，後面會詳細說明。
附加參數：用來擴展表達式的含義，目前主要有三個參數：
g：表明能夠進行全局匹配。
i：表明不區分大小寫匹配。
m：表明能夠進行多行匹配。
上面三個參數，能夠任意組合，表明複合含義，固然也能夠不加參數。
例子：
var reg=/a*b/;
var reg=/abc+f/g;
3）構造函數方式：var reg=new RegExp(「表達式」,」附加參數」);
其中「表達式」與「附加參數」的含義與上面那種定義方式中的含義相同。
例子：
var reg=new RegExp(「a*b」);
var reg=new RegExp(「abc+f」,」g」);
4）普通方式與構造函數方式的區別
普通方式中的表達式必須是一個常量字符串，而構造函數中的表達式能夠是常量字符串，也能夠是一個js變量，例如根據用戶的輸入來做爲表達式參數等等：
var reg=new RegExp(document.forms[0].exprfiled.value,」g」);

2，表達式模式

1）表達式模式，是指表達式的表達方式與樣式，即 var reg=/表達式/附加參數中的「表達式」怎樣去描述？
2）從規範上講，表達式模式分爲簡單模式和複合模式。
3）簡單模式：是指經過普通字符的組合來表達的模式，例如
var reg=/abc0d/;
可見簡單模式只能表示具體的匹配。
4）複合模式：是指含有通配符來表達的模式，例如：
var reg=/a+b?/w/;
其中的+、?和/w都屬於通配符，表明着特殊的含義。所以複合模式能夠表達更爲抽象化的邏輯。
下面咱們着重說一下複合模式中各個通配符的含義及其使用。
5)複合模式中特殊字符的講解：

1>/：在許多編程語言裏面被用做轉義符，通常來講
/符號後面若是跟的是普通字符c，那麼/c就表明特殊的含義，例如n原本表明字符n，但/n就表明換行。
/符號後面若是跟的是特殊字符c，那麼/c就表明普通字符c，例如/通常用做轉義符，但//則調錶普通字符/。
Javascript的正則表達式中/的用法與上面相同，只是不一樣的編程語言，特殊字符表可能不太同樣罷了。

2>^：匹配輸入字符串的起始端，若是是多行匹配，即表達式的附加參數中含有m，則也在一個換行符後匹配。
例子：/^B/匹配「Bab Bc 」中的第一個B
例子2：/^B/gm匹配
          「Badd B
          cdaf
          B dsfB」
          中的第一行第一個B，第三行中的第一個B

3>$：匹配輸入字符創的尾端，若是是多行匹配，即表達式的附加參數中含有m，則也在一個換行符前匹配。
與^的用法相反。
例子：/t$/匹配「bat」中的t，可是不匹配「hate」中的t
例子2：/t$/匹配
「tag at
bat」
中第一行的最後一個t和第二行的t。

4>*：匹配前一個字符0次或屢次。
例子：/ab*/匹配「dddabbbbc」中的「abbbb」，也匹配「ddda」中的「a」

5>+：匹配前一個字符1次或屢次。
例子：/ab+/匹配「dddabbbbc」中的「abbbb」，但不匹配「ddda」
與後面的{1,}（原型：{n,}）的用法相似

6>?：?的用法比較特殊，通常來講它用來對前一個字符作0次或1次匹配，可是它有另外兩種特殊的用法：
若是緊跟在*、+、?和{ }以後，則表示原始匹配的最小次數匹配，例如：
/ba*/原本匹配「bbbaaaa」中的「baaaa」，可是/ba*?/則匹配「bbbaaaa」中的「b」（由於*表示0次或屢次匹配，而加?應該表示最少次數匹配，即0次匹配）。
同理：/ba+?/則匹配「baaaa」中的「ba」。
做爲語法結構符號，使用於前置斷言中，即後面要說到的x(?=y)和x(?!=y)

7>.：小數點中的「.」號，匹配任何一個單獨的字符，可是換行符除外。
標準中總共有哪些字符？請參考：字符集
例如：/a.b/匹配「acbaa」中的「acb」，可是不匹配「abbb」。

8>(x)：表示匹配x(並不是特指字符x或者特指一個字符，x表示一個字符串)，並且匹配會被記住，在語法中這種()被稱爲「capturing parentheses 」，即捕捉用的小括號。
匹配會被記住，是由於在表達式提供的函數中，有些函數返回一個數組，該數組會保存所匹配的全部字符串，例如exec()函數。
另外還要注意()中的x被記住的前提是匹配x。
例子1：
var regx=/a(b)c/;
var rs=regx.exec(「abcddd」);
從上面能夠看出,/a(b)c/匹配「abcddd」中的「abc」，由於()的緣由，b也會記錄下來，所以rs返回的數字內容爲：
{abc,b}
例子2：
var regx=/a(b)c/;
var rs=regx.exec(「acbcddd」);
rs返回null，由於/a(b)c/不匹配「acbcddd」，因此()中的b不會被記錄下來（儘管字符串中含有b）

9>(?:x)：匹配x，但不會記住x，這種格式中的()被稱爲「non-capturing parentheses 」，即非捕捉用的小括號。
例子：
var regx=/a(?:b)c/;
var rs=regx.exec(「abcddd」);
從上面能夠看出,/a(?:b)c/匹配「abcddd」中的「abc」，由於(?:)的緣由，b不會記錄下來，所以rs返回的數字內容爲：
{abc}

10>X(?=y)：匹配x，僅當後面緊跟着y時。若是符合匹配，則只有x會被記住，y不會被記住。
例子：
var regx=/user(?=name)/;
var rs=regx.exec(「The username is Mary」);
結果：匹配成功，並且rs的值爲{user}

11>X(?!y)：匹配x，僅當後面不緊跟着y時。若是符合匹配，則只有x會被記住，y不會被記住。
例子：
var regx=/user(?!name)/;
var rs=regx.exec(「The user name is Mary」);
結果：匹配成功，並且rs的值爲{user}
例子2：
var regx=//d+(?!/.)/;
var rs=regx.exec(「54.235」);
結果：匹配成果，rs的值爲{5}，不匹配54是由於54後面跟着「.」號，固然235也匹配，可是因爲exec方法的行爲，235不會被返回

12>x|y：匹配x或y。注意若是x和y都匹配上了，那麼只記住x。
例子：
var regx=/beijing|shanghai/;
var rs=regx.exec(「I love beijing and shanghai」);
結果：匹配成功，rs的值爲{beijing}，雖然shanghai也匹配，但不會被記住。

13>{n}：匹配前一個字符的n次出現。
n必須是一個非負數，固然若是是一個負數或小數也不會報語法錯誤。
例子：
var regx=/ab{2}c/;
var rs=regx.exec(「abbcd」);
結果：匹配成功，rs的值爲：{abbc}。

14>{n,}：匹配前一個字符的至少n次出現。
例子：
var regx=/ab{2,}c/;
var rs=regx.exec(「abbcdabbbc」);
結果：匹配成功，rs的值爲：{abbc}。注意爲何abbbc也符合條件爲何沒有被記住，這與exec方法的行爲有關，後面會統一講解。

15>{n,m}：匹配前一個字符的至少n次最多m次的出現。
只要n與m爲數字，並且m>=n就不會報語法錯誤。
例子：
var regx=/ab{2,5}c/;
var rs=regx.exec(「abbbcd」);
結果：匹配成功，rs的值爲：{abbbc}。
例子2：
var regx=/ab{2,2}c/;
var rs=regx.exec(「abbcd」);
結果：匹配成功，rs的值爲：{abbc}。
例子3：
var regx=/ab(2,5)/;
var rs=regx.exec(「abbbbbbbbbb」);
結果：匹配成功，rs的值爲：{abbbbb}，這說明，若是前一個字符出現多於m次，則只匹配m次。另外：
var regx=/ab(2,5)c/;
var rs=regx.exec(「abbbbbbbbbbc」);
結果：匹配失敗，rs的值爲：null，爲何匹配失敗，由於b多於5個則b(2,5)會匹配前5個b，，而表達式/ab(2,5)c/中b後面是c，但字符串中5個b以後仍是b因此會報錯。

16>[xyz]：xyz表示一個字符串，該模式表示匹配[]中的一個字符，形式上[xyz]等同於[x-z]。
例子：
var regx=/a[bc]d/;
var rs=regx.exec(「abddgg」);
結果：匹配成功，rs的值爲：{abd}
例子2：
var regx=/a[bc]d/;
var rs=regx.exec(「abcd」);
結果：匹配失敗，rs的值爲：null，之因此失敗，是由於[bc]表示匹配b或c中的一個，但不會同時匹配。

17>[^xyz]：該模式表示匹配非[]中的一個字符，形式上[^xyz]等同於[^x-z]。
例子：
var regx=/a[^bc]d/;
var rs=regx.exec(「afddgg」);
結果：匹配成功，rs的值爲：{afd}
例子2：
var regx=/a[^bc]d/;
var rs=regx.exec(「abd」);
結果：匹配失敗，rs的值爲：。

18>[/b]：匹配退格鍵。

19>/b：匹配一個詞的邊界符，例如空格和換行符等等，固然匹配換行符時，表達式應該附加參數m。
例子：
var regx=//bc./;
var rs=regx.exec(「Beijing is a beautiful city」);
結果：匹配成功，rs的值爲：{ci}，注意c前邊的空格不會匹配到結果中，即{ ci}是不正確的。

20>/B：表明一個非單詞邊界。
例子：
var regx=//Bi./;
var rs=regx.exec(「Beijing is a beautiful city」);
結果：匹配成功，rs的值爲：{ij}，即匹配了Beijing中的ij。

21>/cX，匹配一個控制字符。例如， /cM 匹配一個 Control-M 或
回車符。 x 的值必須爲 A-Z 或 a-z 之一。不然，將 c 視爲一
個原義的 ’c’ 字符。（實際的例子還需補充）

21>/d：匹配一個數字字符，等同於[0-9]。
例子：
var regx=/user/d/;
var rs=regx.exec(「user1」);
結果：匹配成功，rs的值爲：{user1}

22>/D：匹配一個非數字字符，等同於[^0-9]。
例子：
var regx=/user/D/;
var rs=regx.exec(「userA」);
結果：匹配成功，rs的值爲：{userA}

23>/f：匹配一個換頁符。

24>/n：匹配一個換行符。由於是換行符，因此在表達式中要加入m參數。
例子：
var regx=/a/nbc/m;
       var str=「a
               bc」;
       var rs=regx.exec(str);
       結果：匹配成功，rs的值爲：{ }，若是表達式爲/a/n/rbc/，則不會被匹配，所以在通常的編輯器中一個」Enter」鍵表明着「回車換行」，而非「換行回車」，至少在textarea域中是這樣的。
25>/r：匹配一個回車符

26>/s：匹配一個空格符，等同於[ /f/n/r/t/v/u00A0/u2028/u2029].
例子：
var regx=//si/;
var rs=regx.exec(「Beijing is a city」);
結果：匹配成功，rs的值爲：{ i}

27>/S：匹配一個非空格符，等同於[ ^/f/n/r/t/v/u00A0/u2028/u2029].
例子：
var regx=//Si/;
var rs=regx.exec(「Beijing is a city」);
結果：匹配成功，rs的值爲：{ei}

28>/t：匹配一個tab
例子：
var regx=/a/tb/;
var rs=regx.exec(「a bc」);
結果：匹配成功，rs的值爲： {a bc}

29>/v：匹配一個豎向的tab

30>/w：匹配一個數字、_或字母表字符，即[A-Za-z0-9_ ]。
例子：
var regx=//w/;
var rs=regx.exec(「$25.23」);
結果：匹配成功，rs的值爲：{2}

31>/W：匹配一個非數字、_或字母表字符，即[^A-Za-z0-9_ ]。
例子：
var regx=//w/;
var rs=regx.exec(「$25.23」);
結果：匹配成功，rs的值爲：{$}

32>/n：注意不是/n，這裏n是一個正整數，表示匹配第n個()中的字符。
例子：
var regx=/user([,-])group/1role/;
var rs=regx.exec(「user-group-role」);
結果：匹配成功，rs的值爲：{user-group-role,-}，一樣對user,group,role的匹配也是成功的，但像user-group,role等就不對了。

33>/0：匹配一個NUL字符。

34>/xhh：匹配一個由兩位16進制數字所表達的字符。

35>/uhhhh：匹配一個由四位16進制數字所表達的字符。

3，表達式操做

1）表達式操做，在這裏是指和表達式相關的方法，咱們將介紹六個方法。
2）表達式對象（RegExp）方法：

1>exec(str)，返回str中與表達式相匹配的第一個字符串，並且以數組的形式表現，固然若是表達式中含有捕捉用的小括號，則返回的數組中也可能含有()中的匹配字符串，例如：
var regx=//d+/;
var rs=regx.exec(「3432ddf53」);
返回的rs值爲：{3432}
var regx2=new RegExp(「ab(/d+)c」);
var rs2=regx2.exec(「ab234c44」);
返回的rs值爲：{ab234c,234}
另外，若是有多個合適的匹配，則第一次執行exec返回一個第一個匹配，此時繼續執行exec，則依次返回第二個第三個匹配。例如：
var regx=/user/d/g;
var rs=regx.exec(「ddduser1dsfuser2dd」);
var rs1=regx.exec(「ddduser1dsfuser2dd」);
則rs的值爲{user1}，rs的值爲{rs2}，固然注意regx中的g參數是必須的，不然不管exec執行多少次，都返回第一個匹配。後面還有相關內容涉及到對此想象的解釋。

2>test(str)，判斷字符串str是否匹配表達式，返回一個布爾值。例如：
var regx=/user/d+/g;
var flag=regx.test(「user12dd」);
flag的值爲true。

3）String對象方法

1>match(expr)，返回與expr相匹配的一個字符串數組，若是沒有加參數g，則返回第一個匹配，加入參數g則返回全部的匹配
例子：
var regx=/user/d/g;
var str=「user13userddduser345」;
var rs=str.match(regx);
rs的值爲：{user1,user3}

2>search(expr)，返回字符串中與expr相匹配的第一個匹配的index值。
例子：
var regx=/user/d/g;
var str=「user13userddduser345」;
var rs=str.search(regx);
rs的值爲：0

3>replace(expr,str)，將字符串中匹配expr的部分替換爲str。另外在replace方法中，str中能夠含有一種變量符號$，格式爲$n，表明匹配中被記住的第n的匹配字符串（注意小括號能夠記憶匹配）。
例子：
var regx=/user/d/g;
var str=「user13userddduser345」;
var rs=str.replace(regx,」00」);
rs的值爲：003userddd0045
例子2：
var regx=/u(se)r/d/g;
var str=「user13userddduser345」;
var rs=str.replace(regx,」$1」);
rs的值爲：se3userdddse45
對於replace(expr,str)方法還要特別注意一點，若是expr是一個表達式對象則會進行全局替換（此時表達式必須附加參數g，不然也只是替換第一個匹配），若是expr是一個字符串對象，則只會替換第一個匹配的部分，例如：
var regx=「user」
var str=「user13userddduser345」;
var rs=str.replace(regx,」00」);
rs的值爲： 0013userddduser345

4>split(expr)，將字符串以匹配expr的部分作分割，返回一個數組，並且表達式是否附加參數g都沒有關係，結果是同樣的。
例子：
var regx=/user/d/g;
var str=「user13userddduser345」;
var rs=str.split(regx);
rs的值爲：{3userddd,45}

4，表達式相關屬性

1）表達式相關屬性，是指和表達式相關的屬性，以下面的形式：
var regx=/myexpr/;
var rs=regx.exec(str);
其中，和表達式自身regx相關的屬性有兩個，和表達式匹配結果rs相關的屬性有三個，下面將逐一介紹。
2）和表達式自身相關的兩個屬性：

1>lastIndex，返回開始下一個匹配的位置，注意必須是全局匹配（表達式中帶有g參數）時，lastIndex纔會有不斷返回下一個匹配值，不然該值爲老是返回第一個下一個匹配位置，例如：
var regx=/user/d/;
var rs=regx.exec(「sdsfuser1dfsfuser2」);
var lastIndex1=regx.lastIndex;
rs=regx.exec(「sdsfuser1dfsfuser2」);
var lastIndex2=regx.lastIndex;
rs=regx.exec(「sdsfuser1dfsfuser2」);
var lastIndex3=regx.lastIndex;
上面lastIndex1爲9，第二個lastIndex2也爲9，第三個也是9；若是regx=/user/d/g，則第一個爲9，第二個爲18，第三個爲0。

2>source，返回表達式字符串自身。例如：
var regx=/user/d/;
var rs=regx.exec(「sdsfuser1dfsfuser2」);
var source=regx.source;
source的值爲user/d
3）和匹配結果相關的三個屬性：

1>index，返回當前匹配的位置。例如：
var regx=/user/d/;
var rs=regx.exec(「sdsfuser1dfsfuser2」);
var index1=rs.index;
rs=regx.exec(「sdsfuser1dfsfuser2」);
var index2=rs.index;
rs=regx.exec(「sdsfuser1dfsfuser2」);
var index3=rs.index;
index1爲4，index2爲4，index3爲4，若是表達式加入參數g，則index1爲4，index2爲13，index3會報錯（index爲空或不是對象）。

2>input，用於匹配的字符串。例如：
var regx=/user/d/;
var rs=regx.exec(「sdsfuser1dfsfuser2」);
var input=rs.input;
input的值爲sdsfuser1dfsfuser2。

3>[0]，返回匹配結果中的第一個匹配值，對於match而言可能返回一個多值的數字，則除了[0]外，還能夠取[1]、[2]等等。例如：
var regx=/user/d/;
var rs=regx.exec(「sdsfuser1dfsfuser2」);
var value1=rs[0];
rs=regx.exec(「sdsfuser1dfsfuser2」);
var value2=rs[0];
value1的值爲user1,value2的值爲user2

5，實際應用

1）實際應用一
描述：有一表單，其中有一個「用戶名」input域
要求：漢字，並且不能少於2個漢字，不能多於4個漢字。
實現：
<script>
function checkForm(obj){
     var username=obj.username.value;
     var regx=/^[/u4e00-/u9fa5]{2,4}$/g
     if(!regx.test(username)){
               alert(「Invalid username!」);
               return false;
     }
     return true;
}
</script>
<form name=「myForm」onSubmit=「return checkForm(this)」>
    <input type=「text」 name=「username」/>
    <input type=「submit」 vlaue=「submit」/>
</form>
2）實際應用二
描述：給定一個含有html標記的字符串，要求將其中的html標記去掉。
實現：
<script>
function toPlainText(htmlStr){
     var regx=/<[^>]*>|<//[^>]*>/gm;
     var str=htmlStr.replace(regx,"");
     return str;
}
</script>
<form name=「myForm」>
    <textarea id=「htmlInput」></textarea>
    <input type=「button」 value=「submit」 onclick=「toPlainText(document.getElementById(‘htmlInput’).value」/>
</form>

三，小結

1，Javascript正則表達式，我想在通常的程序員之中，使用者應該不是不少，由於咱們處理的頁面通常都不是很複雜，而複雜的邏輯通常咱們都在後臺處理完成了。可是目前趨勢已經出現了扭轉，富客戶端已經被愈來愈多的人接受，而Javascript就是其中的關鍵技術，對於複雜的客戶端邏輯而言，正則表達式的做用也是很關鍵的，同時它也是Javascript高手必需要掌握的重要技術之一。

2，爲了可以便於你們對前面講述的內容有一個更爲綜合和深入的認識，我將前面的一些關鍵點和容易犯糊塗的地方再系統總結一下，這部分很關鍵！
總結1：附件參數g的用法
表達式加上參數g以後，代表能夠進行全局匹配，注意這裏「能夠」的含義。咱們詳細敘述：
1）對於表達式對象的exec方法，不加入g，則只返回第一個匹配，不管執行多少次均是如此，若是加入g，則第一次執行也返回第一個匹配，再執行返回第二個匹配，依次類推。例如
var regx=/user/d/;
var str=「user18dsdfuser2dsfsd」;
var rs=regx.exec(str);//此時rs的值爲{user1}
var rs2=regx.exec(str);//此時rs的值依然爲{user1}
若是regx=/user/d/g；則rs的值爲{user1}，rs2的值爲{user2}
經過這個例子說明：對於exec方法，表達式加入了g，並非說執行exec方法就能夠返回全部的匹配，而是說加入了g以後，我能夠經過某種方式獲得全部的匹配，這裏的「方式」對於exec而言，就是依次執行這個方法便可。
2）對於表達式對象的test方法，加入g於不加上g沒有什麼區別。
3）對於String對象的match方法，不加入g，也只是返回第一個匹配，一直執行match方法也老是返回第一個匹配，加入g，則一次返回全部的匹配（注意這與表達式對象的exec方法不一樣，對於exec而言，表達式即便加上了g，也不會一次返回全部的匹配）。例如：
var regx=/user/d/;
var str=「user1sdfsffuser2dfsdf」;
var rs=str.match(regx);//此時rs的值爲{user1}
var rs2=str.match(regx);//此時rs的值依然爲{user1}
若是regx=/user/d/g，則rs的值爲{user1,user2}，rs2的值也爲{user1,user2}
4）對於String對象的replace方法，表達式不加入g，則只替換第一個匹配，若是加入g，則替換全部匹配。（開頭的三道測試題能很好的說明這一點）
5）對於String對象的split方法，加上g與不加g是同樣的，即：
var sep=/user/d/;
var array=「user1dfsfuser2dfsf」.split(sep);
則array的值爲{dfsf, dfsf}
此時sep=/user/d/g，返回值是同樣的。
6）對於String對象的search方法，加不加g也是同樣的。
總結2：附加參數m的用法
附加參數m，代表能夠進行多行匹配，可是這個只有當使用^和$模式時纔會起做用，在其餘的模式中，加不加入m均可以進行多行匹配（其實說多行的字符串也是一個普通字符串），咱們舉例說明這一點
1）使用^的例子
var regx=/^b./g;
var str=「bd76 dfsdf
         sdfsdfs dffs
         b76dsf sdfsdf」;
var rs=str.match(regx);
此時加入g和不加入g，都只返回第一個匹配{bd}，若是regx=/^b./gm，則返回全部的匹配{bd,b7}，注意若是regx=/^b./m，則也只返回第一個匹配。因此，加入m代表能夠進行多行匹配，加入g代表能夠進行全局匹配，綜合到一塊兒就是能夠進行多行全局匹配
2）使用其餘模式的例子，例如
var regx=/user/d/;
var str=「sdfsfsdfsdf
         sdfsuser3 dffs
         b76dsf user6」;
var rs=str.match(regx);
此時不加參數g，則返回{user3}，加入參數g返回{user3,user6}，加不加入m對此沒有影響。
3）所以對於m咱們要清楚它的使用，記住它只對^和$模式起做用，在這兩種模式中，m的做用爲：若是不加入m，則只能在第一行進行匹配，若是加入m則能夠在全部的行進行匹配。咱們再看一個^的例子
var regx=/^b./;
var str=「ret76 dfsdf
         bjfsdfs dffs
         b76dsf sdfsdf」;
var rs=str.match(regx);
此時rs的值爲null，若是加入g，rs的值仍然爲null，若是加入m，則rs的值爲{bj}（也就是說，在第一行沒有找到匹配，由於有參數m，因此能夠繼續去下面的行去找是否有匹配），若是m和g都加上，則返回{bj,b7}（只加m不加g說明，能夠去多行進行匹配，可是找到一個匹配後就返回，加入g代表將多行中全部的匹配返回，固然對於match方法是如此，對於exec呢，則須要執行屢次才能依次返回）
總結3：在HTML的textarea輸入域中，按一個Enter鍵，對應的控制字符爲「/r/n」，即「回車換行」，而不是「/n/r」，即「換行回車」，咱們看一個前面咱們舉過的例子：
var regx=/a/r/nbc/;
var str=「a
         bc」;
var rs=regx.exec(str);
結果：匹配成功，rs的值爲：{      }，若是表達式爲/a/n/rbc/，則不會被匹配，所以在通常的編輯器中一個」Enter」鍵表明着「回車換行」，而非「換行回車」，至少在textarea域中是這樣的。