js的正則表達式

正則表達式規則

一、普通字元

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

舉例：

表達式 "o"，在匹配字元串 "haorooms" 時，匹配結果是：成功；匹配到的內容是："o"；匹配到的位置是：開始於2，結束於3。[註：o匹配一般只匹配第一個，假如要匹配所有的，那麼表達式要加"/g"，就可以找到全局所有的。]

二、簡單的轉義字元

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

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

舉例1：表達式 "\$d"，在匹配字元串 "haorooms$de" 時，匹配結果是：成功；匹配到的內容是："$d"；匹配到的位置是：開始於8，結束於10。

三、能夠與 '多種字元' 匹配的表達式

正則表達式中的一些表示方法，可以匹配 '多種字元' 其中的任意一個字元。比如，表達式 "\d" 可以匹配任意一個數字。雖然可以匹配其中任意字元，但是只能是一個，不是多個。

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

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

四、自定義能夠匹配 '多種字元' 的表達式

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

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

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

五、修飾匹配次數的特殊符號

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

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

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

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

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

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

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

一、 匹配次數中的貪婪與非貪婪

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

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

非貪婪模式：

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

二、反向引用

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

其實，"小括弧包含的表達式所匹配到的字元串" 不僅是在匹配結束後才可以使用，在匹配過程中也可以使用。表達式後邊的部分，可以引用前面 "括弧內的子匹配已經匹配到的字元串"。引用方法是 "\" 加上一個數字。"\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>" 不配對，則會匹配失敗；如果改成其他配對，也可以匹配成功。

三、預搜索，不匹配；反向預搜索，不匹配

前面的章節中，我講到了幾個代表抽象意義的特殊符號："^"，"$"，"/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 正則引擎。

其他通用規則

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

表達式中，可以使用 "\xXX" 和 "\uXXXX" 表示一個字元（"X" 表示一個十六進位數）

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

在表達式中有特殊意義，需要添加 "\" 才能匹配該字元本身的字元彙總

定義正則表達式

定義正則表達式有兩種形式，一種是普通方式，一種是構造函數方式。

普通方式：var reg=/表達式/附加參數

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

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

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

上面三個參數，可以任意組合，代表複合含義，當然也可以不加參數。

例子：

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

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

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

例子：

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

正則表達式對象的方法

1、test,返回一個 Boolean 值，它指出在被查找的字元串中是否存在模式。如果存在則返回 true，否則就返回 false。

2、exec,用正則表達式模式在字元串中運行查找，並返回包含該查找結果的一個數組。

3、compile,把正則表達式編譯為內部格式，從而執行得更快。

正則表達式對象的屬性

1、source,返回正則表達式模式的文本的複本。只讀。

2、lastIndex,返回字元位置，它是被查找字元串中下一次成功匹配的開始位置。

3、input ($_),返回執行規範表述查找的字元串。只讀。

4、lastMatch ($&),返回任何正則表達式搜索過程中的最後匹配的字元。只讀。

5、lastParen ($+),如果有的話，返回任何正則表達式查找過程中最後括的子匹配。只讀。

6、leftContext ($`),返回被查找的字元串中從字元串開始位置到最後匹配之前的位置之間的字元。只讀。

7、rightContext ($'),返回被搜索的字元串中從最後一個匹配位置開始到字元串結尾之間的字元。只讀。

String對象一些和正則表達式相關的方法

1、match,找到一個或多個正則表達式的匹配。

2、replace,替換與正則表達式匹配的子串。

3、search,檢索與正則表達式相匹配的值。

4、split,把字元串分割為字元串數組。

案例1 test方法測試

//test方法,測試字元串,符合模式時返回true,否則返回false  
var re = /he/;//最簡單的正則表達式,將匹配he這個單詞  
var str = "he"; 
console.log(re.test(str));//true  
str = "we";  
console.log(re.test(str));//false  
str = "HE";  
console.log(re.test(str));//false,大寫,如果要大小寫都匹配可以指定i標誌(i是ignoreCase或case-insensitive的表示)  
re = /he/i;  
console.log(re.test(str));//true  
str = "Certainly!He loves her!";  
console.log(re.test(str));//true,只要包含he(HE)就符合,如果要只是he或HE,不能有其它字元,則可使用^和$  
re = /^he/i;//脫字元(^)代表字元開始位置  
console.log(re.test(str));//false,因為he不在str最開始  
str = "He is a good boy!";  
console.log(re.test(str));//true,He是字元開始位置,還需要使用$  
re = /^he$/i;//$表示字元結束位置  
console.log(re.test(str));//false  
str = "He";  
console.log(re.test(str));//true  
//當然,這樣不能發現正則表達式有多強大,因為我們完全可以在上面的例子中使用==或indexOf  
re = /\s/;// \s匹配任何空白字元，包括空格、製表符、換頁符等等  
str= "user Name";//用戶名包含空格  
console.log(re.test(str));//true  
str = "user     Name";//用戶名包含製表符  
console.log(re.test(str));//true  
re=/^[a-z]/i;//[]匹配指定範圍內的任意字元,這裡將匹配英文字母,不區分大小寫  
str="variableName";//變數名必須以字母開頭  
console.log(re.test(str));//true  
str="123abc";  
console.log(re.test(str));//false  

案例2 exec測試

var haoVersion = "Haorooms 8";//其中的8表示系統主版本號  
var re = /^[a-z]+\s+\d+$/i; //+號表示字元至少要出現1次,\s表示空白字元,\d表示一個數字  
console.log(re.test(haoVersion));//true,但我們想知道主版本號  
//另一個方法exec,返回一個數組,數組的第一個元素為完整的匹配內容  
re=/^[a-z]+\s+\d+$/i;  
arr = re.exec(haoVersion);  
console.log(arr[0]);//將haoVersion完整輸出,因為整個字元串剛好匹配re  
//我只需要取出數字  
re=/\d+/;  
var arr = re.exec(haoVersion);  
console.log(arr[0]);//8  

//exec返回的數組第1到n元素中包含的是匹配中出現的任意一個子匹配  
re=/^[a-z]+\s+(\d+)$/i;//用()來創建子匹配  
arr =re.exec(haoVersion);  
console.log(arr[0]);//整個haoVersion,也就是正則表達式的完整匹配  
console.log(arr[1]);//8,第一個子匹配,事實也可以這樣取出主版本號  
console.log(arr.length);//2  
haoVersion = "Haorooms 8.10";//取出主版本號和次版本號  
re = /^[a-z]+\s+(\d+)\.(\d+)$/i;//.是正則表達式元字元之一,若要用它的字面意義須轉義  
arr = re.exec(haoVersion);  
console.log(arr[0]);//完整的haoVersion  
console.log(arr[1]);//8  
console.log(arr[2]);//10

案例3 String對象的一些和正則表達式有關的方法

1、關於replace，我之前的一片博客專門寫了。還可以傳參數。具體請看：http://www.haorooms.com/post/js_replace_bl

2、其他操作

//replace方法,用於替換字元串  
var str ="some money";  
console.log(str.replace("some","much"));//much money  
//replace的第一個參數可以為正則表達式  
var re = /\s/;//空白字元  
console.log(str.replace(re,"%"));//some%money  
//在不知道字元串中有多少空白字元時,正則表達式極為方便  
str ="some some             \tsome\t\f";  
re = /\s+/;  
console.log(str.replace(re,"#"));//但這樣只會將第一次出現的一堆空白字元替換掉  
//因為一個正則表達式只能進行一次匹配,\s+匹配了第一個空格後就退出了  
re = /\s+/g;//g,全局標誌,將使正則表達式匹配整個字元串  
console.log(str.replace(re,"@"));//some@some@some@  
//另一個與之相似的是split  
var str = "a-bd-c";  
var arr = str.split("-");//返回["a","bd","c"]  
//如果str是用戶輸入的,他可能輸入a-bd-c也可能輸入a bd c或a_bd_c,但不會是abdc(這樣就說他輸錯了)  
str = "a_db-c";//用戶以他喜歡的方式加分隔符s  
re=/[^a-z]/i;//前面我們說^表示字元開始,但在[]里它表示一個負字元集  
//匹配任何不在指定範圍內的任意字元,這裡將匹配除字母處的所有字元  
arr = str.split(re);//仍返回["a","bd","c"];  
//在字元串中查找時我們常用indexOf,與之對應用於正則查找的方法是search  
str = "My age is 18.Golden age!";//年齡不是一定的,我們用indexOf不能查找它的位置  
re = /\d+/;  
console.log(str.search(re));//返回查找到的字元串開始下標10  
//註意,因為查找本身就是出現第一次就立即返回,所以無需在search時使用g標誌  
//下麵的代碼雖然不出錯,但g標誌是多餘的  
re=/\d+/g;  
console.log(str.search(re));//仍然是10 

var str = "My name is CJ.Hello everyone!";  
var re = /[A-Z]/;//匹配所有大寫字母  
var arr = str.match(re);//返回數組  
console.log(arr);//數組中只會包含一個M,因為我們沒有使用全局匹配  
re = /[A-Z]/g;  
arr = str.match(re);  
console.log(arr);//M,C,J,H  
//從字元串中抽取單詞  
re = /\b[a-z]*\b/gi;//\b表示單詞邊界  
str = "one two three four";  
console.log(str.match(re));//one,two,three,four 

案例4 RegExp對象實例的一些屬性

var re = /[a-z]/i;  
console.log(re.source);//將[a-z]字元串輸出  
//請註意,直接console.log(re)會將正則表達式連同前向斜線與標誌輸出,這是re.toString方法定義的  

var re = /[A-Z]/;  
//exec方法執行後,修改了re的lastIndex屬性,  
var str = "Hello,World!!!";  
var arr = re.exec(str);  
console.log(re.lastIndex);//0,因為沒有設置全局標誌  
re = /[A-Z]/g;  
arr = re.exec(str);  
console.log(re.lastIndex);//1  
arr = re.exec(str);  
console.log(re.lastIndex);//7  

var re = /[A-Z]/;  
var str = "Hello,World!!!";  
re.lastIndex = 120;  
var arr = re.exec(str);  
console.log(re.lastIndex);//0 

案例5 RegExp對象的靜態屬性

//input 最後用於匹配的字元串（傳遞給test,exec方法的字元串）  
var re = /[A-Z]/;  
var str = "Hello,World!!!";  
var arr = re.exec(str);  
console.log(RegExp.input);//Hello,World!!!  
re.exec("tempstr");  
console.log(RegExp.input);//仍然是Hello,World!!!,因為tempstr不匹配  
//lastMatch 最後匹配的字元  
re = /[a-z]/g;  
str = "hi";  
re.test(str);  
console.log(RegExp.lastMatch);//h  
re.test(str);  
console.log(RegExp["$&"]);//i  ,$&是lastMatch的短名字，但由於它不是合法變數名，所以要。。  
//lastParen 最後匹配的分組  
re = /[a-z](\d+)/gi;  
str = "Class1 Class2 Class3";  
re.test(str);  
console.log(RegExp.lastParen);//1  
re.test(str);  
console.log(RegExp["$+"]);//2  
//leftContext  返回被查找的字元串中從字元串開始位置到最後匹配之前的位置之間的字元  
//rigthContext 返回被搜索的字元串中從最後一個匹配位置開始到字元串結尾之間的字元  
re = /[A-Z]/g;  
str = "123ABC456";  
re.test(str);  
console.log(RegExp.leftContext);//123  
console.log(RegExp.rightContext);//BC456  
re.test(str);  
console.log(RegExp["$`"]);//123A  
console.log(RegExp["$'"]);//C456  

案例6 使用RegExp構造函數註意點

var str = "\?";  
console.log(str);//只會輸出?  
var re = /\?/;//將匹配?  
console.log(re.test(str));//true  
re = new RegExp("\?");//出錯,因為字元串裡面\是轉義字元\?相當於？要得到\?，就要\\? 
re = new RegExp("\\?");//正確，將匹配？  
console.log(re.test(str));//true