本文介紹了js正則表達式，具體如下：

1. 正則表達式規(guī)則

1.1 普通字符

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

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

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

--------------------------------------------------------------------------------

1.2 簡單的轉義字符

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

還有其他一些在后邊章節(jié)中有特殊用處的標點符號，在前面加 "/" 后，就代表該符號本身。比如：^, $ 都有特殊意義，如果要想匹配字符串中 "^" 和 "$" 字符，則表達式就需要寫成 "/^" 和 "/$"。

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

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

1.3 能夠與 '多種字符' 匹配的表達式

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

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

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

--------------------------------------------------------------------------------

1.4 自定義能夠匹配 '多種字符' 的表達式

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

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

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

--------------------------------------------------------------------------------

1.5 修飾匹配次數(shù)的特殊符號

    前面章節(jié)中講到的表達式，無論是只能匹配一種字符的表達式，還是可以匹配多種字符其中任意一個的表達式，都只能匹配一次。如果使用表達式再加上修飾匹配次數(shù)的特殊符號，那么不用重復書寫表達式就可以重復匹配。

    使用方法是："次數(shù)修飾"放在"被修飾的表達式"后邊。比如："[bcd][bcd]" 可以寫成 "[bcd]{2}"。

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

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

--------------------------------------------------------------------------------

1.6 其他一些代表抽象意義的特殊符號

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

    進一步的文字說明仍然比較抽象，因此，舉例幫助大家理解。

    舉例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。

    一些符號可以影響表達式內部的子表達式之間的關系：

 舉例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. 正則表達式中的一些高級規(guī)則

2.1 匹配次數(shù)中的貪婪與非貪婪

    在使用修飾匹配次數(shù)的特殊符號時，有幾種表示方法可以使同一個表達式能夠匹配不同的次數(shù)，比如："{m,n}", "{m,}", "?", "*", "+"，具體匹配的次數(shù)隨被匹配的字符串而定。這種重復匹配不定次數(shù)的表達式在匹配過程中，總是盡可能多的匹配。比如，針對文本 "dxxxdxxxd"，舉例如下：

由此可見，"/w+" 在匹配的時候，總是盡可能多的匹配符合它規(guī)則的字符。雖然第二個舉例中，它沒有匹配最后一個 "d"，但那也是為了讓整個表達式能夠匹配成功。同理，帶 "*" 和 "{m,n}" 的表達式都是盡可能地多匹配，帶 "?" 的表達式在可匹配可不匹配的時候，也是盡可能的 "要匹配"。這 種匹配原則就叫作 "貪婪" 模式 。

    非貪婪模式：

    在修飾匹配次數(shù)的特殊符號后再加上一個 "?" 號，則可以使匹配次數(shù)不定的表達式盡可能少的匹配，使可匹配可不匹配的表達式，盡可能的 "不匹配"。這種匹配原則叫作 "非貪婪" 模式，也叫作 "勉強" 模式。如果少匹配就會導致整個表達式匹配失敗的時候，與貪婪模式類似，非貪婪模式會最小限度的再匹配一些，以使整個表達式匹配成功。舉例如下，針對文本 "dxxxdxxxd" 舉例：

更多的情況，舉例如下：

    舉例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>"。

    其實，"小括號包含的表達式所匹配到的字符串" 不僅是在匹配結束后才可以使用，在匹配過程中也可以使用。表達式后邊的部分，可以引用前面 "括號內的子匹配已經匹配到的字符串"。引用方法是 "/" 加上一個數(shù)字。"/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,}" 之間的區(qū)別。

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

--------------------------------------------------------------------------------

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

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

    正向預搜索："(?=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次以上的字母數(shù)字，則匹配其剩下最后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個數(shù)字和后4個數(shù)字之外的中間8個數(shù)字。由于 JScript.RegExp 不支持反向預搜索，因此，本條舉例不能夠進行演示。很多其他的引擎可以支持反向預搜索，比如：Java 1.4 以上的 Java.util.regex 包，.NET 中System.Text.RegularExpressions 命名空間，以及本站推薦的最簡單易用的 DEELX 正則引擎。

--------------------------------------------------------------------------------

3. 其他通用規(guī)則

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

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

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

3.3 在表達式中有特殊意義，需要添加 "/" 才能匹配該字符本身的字符匯總

3.4 括號 "( )" 內的子表達式，如果希望匹配結果不進行記錄供以后使用，可以使用 "(?:xxxxx)" 格式

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

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

--------------------------------------------------------------------------------

 4. 其他提示

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

4.2 如果要要求表達式所匹配的內容是整個字符串，而不是從字符串中找一部分，那么可以在表達式的首尾使用 "^" 和 "$"，比如："^/d+$" 要求整個字符串只有數(shù)字。

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

4.4 表達式不要匹配空字符串。否則會一直得到匹配成功，而結果什么都沒有匹配到。比如：準備寫一個匹配 "123"、"123."、"123.5"、".5" 這幾種形式的表達式時，整數(shù)、小數(shù)點、小數(shù)數(shù)字都可以省略，但是不要將表達式寫成："/d*/.?/d*"，因為如果什么都沒有，這個表達式也可以匹配成功。更好的寫法是："/d+/.?/d*|/./d+"。

4.5 能匹配空字符串的子匹配不要循環(huán)無限次。如果括號內的子表達式中的每一部分都可以匹配 0 次，而這個括號整體又可以匹配無限次，那么情況可能比上一條所說的更嚴重，匹配過程中可能死循環(huán)。雖然現(xiàn)在有些正則表達式引擎已經通過辦法避免了這種情況出現(xiàn)死循環(huán)了，比如 .NET 的正則表達式，但是我們仍然應該盡量避免出現(xiàn)這種情況。如果我們在寫表達式時遇到了死循環(huán)，也可以從這一點入手，查找一下是否是本條所說的原因。

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

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

------------------------------------------------------------------------------------------

1，定義正則表達式

1）定義正則表達式有兩種形式，一種是普通方式，一種是構造函數(shù)方式。

2）普通方式：var reg=/表達式/附加參數(shù)

表達式：一個字符串，代表了某種規(guī)則，其中可以使用某些特殊字符，來代表特殊的規(guī)則，后面會詳細說明。

附加參數(shù)：用來擴展表達式的含義，目前主要有三個參數(shù)：

• g：代表可以進行全局匹配。
• i：代表不區(qū)分大小寫匹配。
• m：代表可以進行多行匹配。

上面三個參數(shù)，可以任意組合，代表復合含義，當然也可以不加參數(shù)。

例子：

var reg=/a*b/;
var reg=/abc+f/g;

3）構造函數(shù)方式：var reg=new RegExp(“表達式”,”附加參數(shù)”);

其中“表達式”與“附加參數(shù)”的含義與上面那種定義方式中的含義相同。

例子：

var reg=new RegExp(“a*b”);
var reg=new RegExp(“abc+f”,”g”);

4）普通方式與構造函數(shù)方式的區(qū)別

普通方式中的表達式必須是一個常量字符串，而構造函數(shù)中的表達式可以是常量字符串，也可以是一個js變量，例如根據(jù)用戶的輸入來作為表達式參數(shù)等等：

var reg=new RegExp(document.forms[0].exprfiled.value,”g”);

2，表達式模式

1）表達式模式，是指表達式的表達方式與樣式， 即 var reg=/表達式/附加參數(shù) 中的“表達式”怎樣去描述？

2）從規(guī)范上講，表達式模式分為簡單模式和復合模式。

3）簡單模式：是指通過普通字符的組合來表達的模式，例如

var reg=/abc0d/;

可見簡單模式只能表示具體的匹配。

4）復合模式：是指含有通配符來表達的模式，例如：

var reg=/a+b?/w/;

其中的+、?和/w都屬于通配符，代表著特殊的含義。因此復合模式可以表達更為抽象化的邏輯。

下面我們著重說一下復合模式中各個通配符的含義及其使用。

5)復合模式中特殊字符的講解：

1>/：在許多編程語言里面被用作轉義符，一般來說

/符號后面如果跟的是普通字符c，那么/c就代表特殊的含義，例如n本來代表字符n，但/n就代表換行。

/符號后面如果跟的是特殊字符c，那么/c就代表普通字符c，例如/一般用作轉義符，但//則調表普通字符/。

JavaScript的正則表達式中/的用法與上面相同，只是不同的編程語言，特殊字符表可能不太一樣罷了。

2>^：匹配輸入字符串的起始端，如果是多行匹配，即表達式的附加參數(shù)中含有m，則也在一個換行符后匹配。

例子：/^B/匹配 “Bab Bc ”中的第一個B

例子2：/^B/gm匹配
          “Badd B
          cdaf
          B dsfB”
          中的第一行第一個B，第三行中的第一個B       

3>$：匹配輸入字符創(chuàng)的尾端，如果是多行匹配，即表達式的附加參數(shù)中含有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次匹配，但是它有另外兩種特殊的用法：

如果緊跟在*、+、?和{ }之后，則表示原始匹配的最小次數(shù)匹配，例如：

/ba*/本來匹配“bbbaaaa”中的“baaaa”，但是/ba*?/則匹配“bbbaaaa”中的“b”（因為*表示0次或多次匹配，而加?應該表示最少次數(shù)匹配，即0次匹配）。

同理：/ba+?/則匹配“baaaa”中的“ba”。

作為語法結構符號，使用于前置斷言中，即后面要說到的x(?=y)和x(?!=y)

7>.：小數(shù)點中的“.”號，匹配任何一個單獨的字符，但是換行符除外。

標準中總共有哪些字符？請參考：字符集

例如：/a.b/匹配“acbaa”中的“acb”，但是不匹配“abbb”。

8>(x)：表示匹配x(并非特指字符x或者特指一個字符，x表示一個字符串)，而且匹配會被記住，在語法中這種()被稱為“capturing parentheses ”，即捕捉用的小括號。

匹配會被記住，是因為在表達式提供的函數(shù)中，有些函數(shù)返回一個數(shù)組，該數(shù)組會保存所匹配的所有字符串，例如exec()函數(shù)。

另外還要注意()中的x被記住的前提是匹配x。

例子1：

var regx=/a(b)c/;
var rs=regx.exec(“abcddd”);

從上面可以看出,/a(b)c/匹配“abcddd”中的“abc”，因為()的原因，b也會記錄下來，因此rs返回的數(shù)字內容為：{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返回的數(shù)字內容為：
{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次出現(xiàn)。

n必須是一個非負數(shù)，當然如果是一個負數(shù)或小數(shù)也不會報語法錯誤。

例子：

var regx=/ab{2}c/;
var rs=regx.exec(“abbcd”);

結果：匹配成功，rs的值為：{abbc}。

14>{n,}：匹配前一個字符的至少n次出現(xiàn)。

例子：

var regx=/ab{2,}c/;
var rs=regx.exec(“abbcdabbbc”);

結果：匹配成功，rs的值為：{abbc}。注意為什么abbbc也符合條件為什么沒有被記住，這與exec方法的行為有關，后面會統(tǒng)一講解。

15>{n,m}：匹配前一個字符的至少n次最多m次的出現(xiàn)。

只要n與m為數(shù)字，而且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}，這說明，如果前一個字符出現(xiàn)多于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：匹配一個詞的邊界符，例如空格和換行符等等，當然匹配換行符時，表達式應該附加參數(shù)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：匹配一個數(shù)字字符，等同于[0-9]。

例子：

var regx=/user/d/;
var rs=regx.exec(“user1”);

結果：匹配成功，rs的值為：{user1}

22>/D：匹配一個非數(shù)字字符，等同于[^0-9]。

例子：

var regx=/user/D/;
var rs=regx.exec(“userA”);

結果：匹配成功，rs的值為：{userA}

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

24>/n：匹配一個換行符。因為是換行符，所以在表達式中要加入m參數(shù)。
例子：

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：匹配一個數(shù)字、_或字母表字符，即[A-Za-z0-9_ ]。
例子：

var regx=//w/;
var rs=regx.exec(“$25.23”);

結果：匹配成功，rs的值為：{2}

31>/W：匹配一個非數(shù)字、_或字母表字符，即[^A-Za-z0-9_ ]。

例子：

var regx=//w/;
var rs=regx.exec(“$25.23”);

結果：匹配成功，rs的值為：{$}

32>/n：注意不是/n，這里n是一個正整數(shù)，表示匹配第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進制數(shù)字所表達的字符。

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

3，表達式操作

1）表達式操作，在這里是指和表達式相關的方法，我們將介紹六個方法。

2）表達式對象（RegExp）方法：

1>exec(str)，返回str中與表達式相匹配的第一個字符串，而且以數(shù)組的形式表現(xiàn)，當然如果表達式中含有捕捉用的小括號，則返回的數(shù)組中也可能含有()中的匹配字符串，例如：

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}

另外，如果有多個合適的匹配，則第一次執(zhí)行exec返回一個第一個匹配，此時繼續(xù)執(zhí)行exec，則依次返回第二個第三個匹配。例如：

var regx=/user/d/g;
var rs=regx.exec(“ddduser1dsfuser2dd”);
var rs1=regx.exec(“ddduser1dsfuser2dd”);

則rs的值為{user1}，rs的值為{rs2}，當然注意regx中的g參數(shù)是必須的，否則無論exec執(zhí)行多少次，都返回第一個匹配。后面還有相關內容涉及到對此想象的解釋。

2>test(str)，判斷字符串str是否匹配表達式，返回一個布爾值。例如：

var regx=/user/d+/g;
var flag=regx.test(“user12dd”);

flag的值為true。

3）String對象方法

1>match(expr)，返回與expr相匹配的一個字符串數(shù)組，如果沒有加參數(shù)g，則返回第一個匹配，加入參數(shù)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是一個表達式對象則會進行全局替換（此時表達式必須附加參數(shù)g，否則也只是替換第一個匹配），如果expr是一個字符串對象，則只會替換第一個匹配的部分，例如：

var regx=“user”
var str=“user13userddduser345”;
var rs=str.replace(regx,”00”);

rs的值為： 0013userddduser345

4>split(expr)，將字符串以匹配expr的部分做分割，返回一個數(shù)組，而且表達式是否附加參數(shù)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參數(shù)）時，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，如果表達式加入參數(shù)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而言可能返回一個多值的數(shù)字，則除了[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個漢字。
實現(xiàn)：

<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標記去掉。

實現(xiàn)：

<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正則表達式，我想在一般的程序員之中，使用者應該不是很多，因為我們處理的頁面一般都不是很復雜，而復雜的邏輯一般我們都在后臺處理完成了。但是目前趨勢已經出現(xiàn)了扭轉，富客戶端已經被越來越多的人接受，而Javascript就是其中的關鍵技術，對于復雜的客戶端邏輯而言，正則表達式的作用也是很關鍵的，同時它也是Javascript高手必須要掌握的重要技術之一。

2，為了能夠便于大家對前面講述的內容有一個更為綜合和深刻的認識，我將前面的一些關鍵點和容易犯糊涂的地方再系統(tǒng)總結一下，這部分很關鍵！

總結1：附件參數(shù)g的用法

表達式加上參數(shù)g之后，表明可以進行全局匹配，注意這里“可以”的含義。我們詳細敘述：

1）對于表達式對象的exec方法，不加入g，則只返回第一個匹配，無論執(zhí)行多少次均是如此，如果加入g，則第一次執(zhí)行也返回第一個匹配，再執(zhí)行返回第二個匹配，依次類推。例如

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，并不是說執(zhí)行exec方法就可以返回所有的匹配，而是說加入了g之后，我可以通過某種方式得到所有的匹配，這里的“方式”對于exec而言，就是依次執(zhí)行這個方法即可。

2）對于表達式對象的test方法，加入g于不加上g沒有什么區(qū)別。

3）對于String對象的match方法，不加入g，也只是返回第一個匹配，一直執(zhí)行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：附加參數(shù)m的用法

附加參數(shù)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);

此時不加參數(shù)g，則返回{user3}，加入參數(shù)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}（也就是說，在第一行沒有找到匹配，因為有參數(shù)m，所以可以繼續(xù)去下面的行去找是否有匹配），如果m和g都加上，則返回{bj,b7}（只加m不加g說明，可以去多行進行匹配，但是找到一個匹配后就返回，加入g表明將多行中所有的匹配返回，當然對于match方法是如此，對于exec呢，則需要執(zhí)行多次才能依次返回）

總結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域中是這樣的。

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。