js正則表達式語法

1. 正則表達式規則

1.1 普通字符

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

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

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

1.2 簡單的轉義字符

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

表達式	可匹配
/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" 來匹配程序中的keyword。

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” οnclick=“toPlainText(document.getElementById(‘htmlInput’).value”/>
</form>

三，小結

1，Javascript正則表達式，我想在一般的程序猿之中，使用者應該不是非常多，由于我們處理的頁面一般都不是非常復雜，而復雜的邏輯一般我們都在后臺處理完畢了。可是眼下趨勢已經出現了扭轉，富client已經被越來越多的人接受，而Javascript就是當中的關鍵技術，對于復雜的client邏輯而言，正則表達式的作用也是非常關鍵的，同一時候它也是Javascript高手必需要掌握的重要技術之中的一個。

2，為了能夠便于大家對前面講述的內容有一個更為綜合和深刻的認識，我將前面的一些關鍵點和easy犯糊涂的地方再系統總結一下，這部分非常關鍵！
總結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域中是這種。