JavaScript RegExp 基礎詳談

目前 JavaScript RegExp 正規表達式算是最詳細的基礎教程了 ~~~

前言：

　　正則對于一個碼農來說是最基礎的了，而且在部落格園中，發表關于講解正規表達式的技術文章，更是數不勝數，各有各的優點，但是就是這種很基礎的東西，如果我們不去真正仔細研究、學習、掌握，而是抱着需要的時候，就去網上找現成的正規表達式來使用，像這樣恐怕永遠都是很難對正則有一個詳細且全面的了解。

　　是以通過查閱書籍、網上的資料以及通過自己的了解、組織、表達，寫了這篇《JavaScript RegExp 基礎詳談》，算是對自己學習過程的一次總結梳理吧。

　　如果有什麼欠缺，遺漏或者不足的地方，多多麻煩大家的指正與建議。

　　PS：若有童鞋轉載這篇文章，也是對我的認可，感激不盡，隻希望能夠注明轉載的出處就好。

目錄索引：

　　　　1. 正規表達式的概念

　　　　2. RegExp 對象

　　　　　　　2.1 RegExp 對象

　　　　　　　2.2 修飾符說明

　　　　　　　2.3 RegExp對象方法

　　　　　　　2.4 RegExp對象的屬性

　　　　　　　　　　· 靜态屬性

　　　　　　　　　　· 執行個體屬性

　　　　3. JS的正則基礎文法

　　　　　　　3.1 特殊字元一覽表：

　　　　　　　3.2 轉義運算符

　　　　　　　3.3 量詞

　　　　　　　3.4 邊界

　　　　　　　3.5 類

　　　　　　　　· 字元類

　　　　　　　　· 範圍類

　　　　　　　　· 反向類

　　　　　　　3.6 貪婪模式與非貪婪模式

　　　　　　　3.7 分組

　　　　　　　　· 捕獲性分組

　　　　　　　　· 非捕獲性分組

　　　　　　　　· 分組嵌套

　　　　　　　3.8 前瞻

　　　　　　　3.9 運算符

　　　　　　　3.10 其它

　　　　4. 支援正則的String方法

　　　　　　　4.1 replace

　　　　　　　4.2 match

　　　　　　　4.3 split

　　　　　　　4.4 search

　　　　5. 常用正規表達式收集

　　　　附錄：參考頁面

1. 正規表達式的概念

　　正規表達式(regular expression)描述了一種字元串比對的模式。這種模式，我們可以了解成是一種“規則”。根據這種規則再去比對符合條件的結果，而比對的過程就是檢索，查找、提取的過程。

　　正規表達式隻能對字元串進行操作。這一點需要明确知道。

　　正規表達式的“祖先”可以一直上溯至對人類神經系統如何工作的早期研究。Warren McCulloch 和 Walter Pitts 這兩位神經生理學家研究出一種數學方式來描述這些神經網絡。

　　1956 年, 一位叫 Stephen Kleene 的數學家在 McCulloch 和 Pitts 早期工作的基礎上，發表了一篇标題為“神經網事件的表示法”的論文，引入了正規表達式的概念。正規表達式就是用來描述他稱為“正則集的代數”的表達式，是以采用“正規表達式”這個術語。

随後，發現可以将這一工作應用于使用 Ken Thompson 的計算搜尋算法的一些早期研究，Ken Thompson 是 Unix 的主要發明人。正規表達式的第一個實用應用程式就是 Unix 中的 qed 編輯器。

　　剩下的就是衆所周知的曆史了。從那時起直至現在正規表達式都是基于文本的編輯器和搜尋工具中的一個重要部分。

　　基于不同平台或者是語言的 regular expression 并不相同，以下說的都是基于JavaScript語言的正規表達式。

2. RegExp 對象

　　2.1 RegExp 對象

　　　　RegExp是JavaScript中内置的正則對象，通過以下方法均可以建立一個正則對象的執行個體。

　　　　· 構造函數

 var pattern = new RegExp('regexp','modifier'); 

　　　　 regexp ： 比對的模式，也就是上文指的正則規則，實際上我們編寫正規表達式的過程，都是對“規則”的定義過程。

　　　　 modifier : 正則執行個體的修飾符。

　　　　示例：

var pattern = new RegExp('world','i');
var reg = new RegExp('name','ig');      

　　　　· 字面量

 　　　　var pattern = /regexp/modifier; 

　　　　示例：

var pattern = /world/i;
var reg = /name/ig;      

　　　　說明：

　　　　　　字面量與構造函數的差別就是，字面量更類似于定義一個變量，采用指派的方式。這種方式建立正則執行個體是我們更加推薦使用的方式。

　　　　　　注意的是，字面量方式下正則執行個體建立的格式，即用一對斜杠（//）來包裹定義的規則，規則不能用定界符括起來，随後在附加上修飾符。

　　2.2 修飾符說明

　　　　“修飾符” 其含義類似于正則執行個體的附加屬性。用于說明正則規則适用比對的範圍。

　　　　　　i : 表示區分大小寫字母比對。

　　　　　　m ：表示多行比對。

　　　　　　g : 表示全局比對。

　　　　　　　　在非全局的情況下，正則會根據指定的“規則”從左至右對字元串進行比對，一旦規則比對完，便會停止比對操作，傳回結果。

　　　　　　　　在全局的的情況下，正則會根據指定的“規則”從左至右對字元串進行比對，一旦規則比對完，便會在目前字元串比對位置

　　　　　　　　重新使用“規則”繼續向下比對，一直到字元串比對完成。這也是下文中，我們會提到lastIndex屬性存在的必要性。

 　　2.3 RegExp對象方法

　　　　以下方法都是RegExp對象的内置方法，這些方法可以根據指定的規則來對字元串進行比對，查找等。

　　　　可以支援正規表達式的方法，不僅僅隻有RegExp對象才有，實際上String對象也具有同樣功能的方法。這些我們下文會講解到。

　　　　· test() 

　　　　　　test 方法用于測試正則規則在指定的字元串中是否具有符合的比對結果，如果比對到則傳回true，否則傳回false。

　　　　　　示例:

var pattern = /a/;
console.log(pattern.test('edcba')) // => true      

　　　　　　當test方法在全局模式下被多次執行的時候，每次執行的傳回值會因為比對結果的不同而不同，但在實際的應用中，

　　　　　　我隻需要進行一次比對即可。

　　　　· exec()

　　　　　　在非全局的比對模式下，一旦比對到符合規則的結果，便會停止執行。

　　　　　　在全局模式下，當比對到符合規則的結果也會停止執行，但是若多次重複執行test方法，則會根據lastIndex屬性的值為錨點依次向後比對，

　　　　　　在比對到字元串的末尾後，會從頭到尾再重新循環比對。

　　　　　　示例：

1 var pattern = /a/g;
2     console.log(pattern.test('edcba')) // => true 第一次執行。
3     console.log(pattern.test('edcba')) // => false 第二次執行。
4     console.log(pattern.test('edcba')) // => true 第三次執行。從頭到尾重新循環執行。　　　      

　　　　　　exec方法可以傳回比對的結果，以及結果在字元串中的索引和下一次比對的起始位置。如果正規表達式沒有比對到結果，

　　　　　　那麼傳回的值就是 null。

　　　　　　exec方法在比對到的情況下，傳回的是一個數組，數組的格式如下：

1 var result = /a/.exec('abcdaefga');
2     result[0] // -> 目前比對到的結果。
3     result.input // -> 進行比對操作的字元串。
4     result.index // -> 目前比對結果首字母在字元串中的索引      

　　　　　　如果存在分組比對的情況下:

　　　　　　　　result[1] -> 表示第一個分組比對到的結果。

　　　　　　　　result[2] -> 表示第二個分組比對到的結果。

　　　　　　　　...

　　　　　　　　result[n] -> 表示第n個分組比對到的結果。

　　　　　　示例：

1 var str = '2012 google';
2 var pattern = /(\d{4})\s(\w+)/;
3 var result = pattern.exec(str);
4 console.log(result[0]);
5 console.log(result[1]);
6 console.log(result[2]);　　　　　      

　　　　　　如果想使用exec方法對字元串中的某個結果進行全面比對，那麼正規表達式必須要開啟全局模式。在非全局的模式下，

　　　　　　exec方法一旦比對到結果，便會停止執行。

1 var pattern = /a/g;
2 while(result = pattern.exec('abababab')){
3     console.log(result+'index:'+ result.index +' input:'+ result.input);
4 }      

　　　　· compile()

　　　　　　compile可以重新指定正則執行個體的規則與修飾符。

var pattern = /res/i;
pattern.compile('rp','g') -> /rp/g      

　　2.4 RegExp對象的屬性

　　　　· 靜态屬性

　　　　　　靜态屬性是RegExp這個内置對象的固有屬性。通路這些靜态屬性，不需要進行聲明執行個體化，而是直接調用。

　　　　　　調用格式：RegExp.attribute

　　　　　　下面所有屬性的說明，就以：

var desc = 'Hello,everyone.My name is gtshen';
reg = /na(.?)/g;
reg.test(desc);      

　　　　　　這段代碼測試為例，進行說明：

　　　　　　- input

　　　　　　　　功能：傳回目前要比對的字元串

　　　　　　　　示例： console.log('input:'+RegExp.input) // -> 'Hello,everyone.My name is gtshen' 

　　　　　　　　短名：RegExp.$_;

　　　　　　　　注意：opera 低版本并不支援。

　　　　　　- lastMatch

　　　　　　　　功能：最後一次比對到的子串結果，需要開啟修飾符-g。

　　　　　　　　示例： console.log('lastMatch:'+RegExp.lastMatch) // -> nam 

　　　　　　　　短名：RegExp['$&'];

　　　　　　- lastParen

　　　　　　　　功能：最後一次分組中捕獲到的内容。需要開啟修飾符-g。

　　　　　　　　示例： console.log('lastParen:'+RegExp.lastParen) // -> 'm'; 

　　　　　　　　短名：RegExp['$+'];

　　　　　　- leftContext

　　　　　　　　功能：以目前比對到的子串為上下文，傳回之前的子串。

　　　　　　　　示例： console.log('leftContext:'+RegExp.leftContext) // -> 'Hello,everyone.My '; 

　　　　　　　　短名：RegExp['$&`'];

　　　　　　- rightContext

　　　　　　　　功能：以目前比對到的子串為上下文，傳回之後的子串。

　　　　　　　　示例： console.log('rightContext:'+RegExp.rightContext) // -> 'e is gtshen'; 

　　　　　　　　短名：RegExp['$\''];

　　　　　　- multiline

　　　　　　　　功能：是否支援多行。傳回值為boolean值，true表示支援，false表示不支援。

　　　　　　　　示例： console.log('multiline:'+RegExp.multiline); 

　　　　　　　　短名：RegExp['$*'];

　　　　　　　　注意：IE 并不支援。

　　　　　　- $1 - $9

　　　　　　　　功能：傳回1 - 9個分組的值。

　　　　　　　　示例： console.log('$1:'+ RegExp.$1) // -> 'm' 

　　　　　　* 注意的是“RegExp”指的是最近一次在程式運作中進行比對操作的正則執行個體對象。

 　　　　· 執行個體屬性

　　　　　　執行個體屬性，就是指必須進過聲明或執行個體化後的正規表達式對象方能調用的屬性。

　　　　　　下面所有屬性的說明，就以下代碼為例進行說明：

var pattern = /\w?/g;      

　　　　　　- ingoreCase

　　　　　　　　功能：修飾符屬性，隻讀。判斷指定正規表達式是否開啟大小寫，傳回值布爾值。

　　　　　　　　示例：pattern.ingoreCase

　　　　　　- global

　　　　　　　　示例：pattern.global

　　　　　　- multiline

　　　　　　　　功能：修飾符屬性，隻讀。判斷指定正規表達式是否開啟多行模式，傳回值布爾值。

　　　　　　　　示例：pattern.multiline

　　　　　　- lastIndex

　　　　　　　　功能：傳回目前比對結果下一次比對的起始位置。也可以手動設定lastIndex的值，用于設定指定的起始位置。

　　　　　　　　示例：

1 var desc = 'hellow,hi,oh';
2 pattern.test(desc) 
3 console.log(pattern.lastIndex) //-> 1;
4 pattern.lastIndex = 2;
5 console.log(pattern.lastIndex) // -> 3;      

　　　　　　- source

　　　　　　　　功能：傳回正規表達式對象的正則規則。

　　　　　　　　示例： console.log(pattern.source) // -> \w? 

　　　　　　* ingoreCase、global、multiline等均為隻讀屬性，不能直接修改正規表達式的修飾符。

　　　　　　* lastIndex的值，隻能在RegExp内置方法中才能夠使用到。

3. JS的正則基礎文法

　　正規表達式是有兩種字元模式組成：“普通字元”、"元字元"。通過這兩種字元模式的結合使用，可以編寫出符合我們要求的正則規則。

　　普通字元：

　　　　就是由顯性的沒有特殊含義的列印字元和沒有指定為元字元的非列印字元組成。

　　　　顯性的列印字元，它是實際可見的，例如0-9，a-z，除了可列印的字元，還存在一些非列印的字元，例如ASCII碼值在0-31的為控制字元，

　　　　無法顯示和列印，但實際存在。

　　元字元：元字元更接近計算機語言中的變量含義，它可以代表某種特殊的含義，并且會根據使用場合不同，其具體的含義也不盡相同。

　　普通字元很好了解，按照計算機語言中的字面量去了解就可以，我們着重研究“元字元”。

　　元字元，根據其特性與含義，又可以分為以下幾個小類去說明：

　　3.1 特殊字元一覽表：

 　　3.2 轉義運算符

　　　　功能：對元字元進行轉義，使其轉換為普通字元。

　　　　示例：

1 var pattern = /\[/;
2 var str = '[]';
3 console.log(pattern.test(str)) // -> true;      

　　3.3 量詞

　　　　?：表示比對0次或1次

　　　　+：表示比對1次或多次

　　　　{n}：表示比對n次

　　　　{n,m}：表示比對n到m次

　　　　{n,}：表示至少比對n次

　　3.4 邊界

　　　　\b：比對單詞邊界，用于比對一個整體的單詞時使用。

　　　　\B：比對非單詞邊界。

　　　　^：強制首比對，以指定規則開始的字元，避免前導的其它字元。

　　　　$：強制尾比對，以指定規則結束的字元，避免後導的其它字元。

　　3.5 類

　　　“類”是具有相同特征的集合，是一個泛指。

　　　· 字元類

　　　　　[abc]：隻根據區間内的内容進行比對。

　　　· 範圍類

　　　　　[a-zA-Z0-9]：比對大小寫字元a-z以及數組0-9的範圍

　　　· 反向類

　　　　　[^a-z]：取反比對。比對不在這個區間範圍内的内容，

　　　示例：

1 var str = 'google';
2 var pattern = /[gle]/;
3 console.log(pattern.test(str))      

　　3.6 貪婪模式與非貪婪模式

　　　　貪婪模式會按照比對規則盡可能的去比對，一直到比對失敗。

　　　　非貪婪模式則會根據最小比對規則去比對。

　　　　以比對規則為例來說，貪婪是指比對所有符合規則的結果，按照最大可能的結果去比對，而非貪婪則隻要有比對結果便會停止比對。

　　　　從量詞上看：*+?都是貪婪比對，因為*+?都會按照比對規則盡可能的去比對。

　　　　例如*比對零個或多個，但實際比對上，會以多個的情況為優先比對。

　　　　　　貪婪比對 　　 　　 非貪婪比對

　　　　　　+ 一次或多次 　　 +? 隻比對一次

　　　　　　? 0次或一次 　　   ?? 比對 0次

　　　　　　* 0次或多次 　　   *? 比對0次

　　　　　　{n} n次　　　　　{n}? 按照n次比對

　　　　　　{n,} 最少n次 　　 {n,}? 按照n次比對

　　　　　　{n,m} n到m次 　  {n,m}? 按照n次比對

　　　　取消貪婪模式也很簡單，在原有的基礎上附加上一個?号，這時就改為非貪婪模式，一旦條件滿足，就不再往下比對。

　　　　示例：

1 var str = 'aaa',
2 pattern1 = /a*/,
3 pattern2 = /a*?/;
4 pattern1.exec(str); // -> aaa 
5 pattern2.exec(str); // -> ''      

　　3.7 分組

　　　　分組就是把要比對的結果作為一個組一個整體來看待。是以隻要是屬于該分組的資訊，都要放在()符号内。

　　　　· () 捕獲性分組

1 var str = '123abc';
2 var pattern = /(\d{4})(\w+)/;
3 pattern.test(str); 
4 console.log(RegExp.$1) //-> 123
5 console.log(RegExp.$2) //-> abc      

　　　　· (?:) 非捕獲性分組

1 var str = '123abc';
2 var pattern = /(\d{3})(?:\w+)/;
3 pattern.test(str); 
4 console.log(RegExp.$1) //-> 123
5 console.log(RegExp.$2) //-> '';      

　　　　· ((...)) 嵌套分組

　　　　　　說明：嵌套分組從外向内擷取

1 var str = 'abc';
2 var pattern = /(a?(b?(c?)))/;
3 pattern.test(str); 
4 console.log(RegExp.$1) //-> abc
5 console.log(RegExp.$2) //-> bc
6 console.log(RegExp.$3) //-> c      

　　 3.8 前瞻

　　　　對于人的習慣而言，我們認為我們在看一段話的順序是從前到後的閱讀順序，但是對于計算機而言，

　　　　已經識别到的則是“後”，而未能或者即将識别的區域則是“前”。是以正則前瞻的本質含義就是判斷前方的内容是否是符合比對條件。

　　　　如果符合比對條件，那麼“正向前瞻”就為true,否者為false。如果不符合比對條件，那麼“負向前瞻”為true，否則為false。

　　　　下面解釋用到的“後續内容”字眼，是從我們人的習慣出發加以說明的。

　　　　· (?=) 正向前瞻

　　　　　　說明：“正向前瞻”是根據後續内容是否符合比對條件來傳回比對的結果。

　　　　　　示例：

1 var str = 'google';
2 var pattern = /goo(?=gle)/;
3 console.log(pattern.exec(str)[0]); // -> goo      

　　　　　　從示例我們可以看出，goo是我們要比對的結果，而(?=gle)則是後續内容的判斷條件，一旦字元串中有符合goo後續為gle的字元串，那麼就傳回比對結果。goo。

　　　　· (?!) 負向前瞻

　　　　　　說明：“負向前瞻”是根據後續内容是否不符合條件來傳回比對的結果。

　　　　　　　　    “負向前瞻”與“正向前瞻” 含義與功能相反。

1 var str = 'google';
2 var pattern1 = /goo(?!gle)/;
3 var pattern2 = /goo(?!ogl)/;
4 pattern1.test(str) // -> false 因為gle是符合goo的後續内容的，是以傳回false，條件不成立。
5 pattern2.test(str) // -> true 因為ogl不是goo的後續内容，是以傳回true，條件成立。      

　　　　* 前瞻是一種零寬度斷言比對。　　

　　　　　　世界本來沒有路，隻是人走多了，自然就有了路，同樣的道理，零寬度斷言，雖然聽上去怪怪的，還有點反人類的感覺，

　　　　　　但是多說說也就習慣了。畢竟隻是一個取名的問題而已，無需較真。所謂的“零寬度”，指的就是其比對的位置不會發生改變。

　　　　　　而“斷言”，則用來聲明一個應該為真的事實。是以我們前面學習到的 “正向前瞻” 也叫 “零寬度正預測先行斷言”。

　　　　　　用一句話概括其功能：

　　　　　　　　零寬度斷言比對不會捕獲或儲存比對結果，更加不會改變比對時的比對位置(lastIndex)。

　　　　　　　　比對的起始位置也是它比對的結束位置。是以比對位置固定不變。

　　　　　　示例：

1 var str = 'find123';
2 var pattern = /(?=find)\d+/;
3 alert(pattern.test(str)) // -> false      

　　　　　　就如我們前面說到的那樣，前瞻是一種零寬度比對，而零寬度的特點概要來說，就是不捕獲比對内容，不改變比對位置。

　　　　　　首先，整個比對順序是從左到右，左為後，右為前。在位置0處正則的控制權交由(?=find)去比對，此時在位置0處向右嘗試檢索find字元串，

　　　　　　并且成功檢索到是以比對成功，但并不捕獲内容，也不改變比對位置，是以從位置0處開始比對，也從位置0處結束比對，

　　　　　　接着比對控制權交由\d+,然後從位置0處開始比對（因為之前的零寬度并未改變比對位置），

　　　　　　再向右檢索數字的時候，發現位置0為f,位置1位i ... 是以比對失敗，最終傳回false。

1 var str = 'abcfind123';
2 var pattern = /abc(?=find)find\d+/;
3 alert(pattern.test(str)) // -> true      

　　　　　　這個示例的傳回結果為true，讓我們仔細分析以下，首先，從左向右比對，位置0，位置1，

　　　　　　位置2 等處的字元串abc正好與正規表達式吻合，是以比對成功，接着從位置3處将比對控制權交由(?=find)，

　　　　　　此時正規表達式從位置3處開始向右檢索字元串find，檢索到是以比對成功，然後在位置3處結束檢索，

　　　　　　将控制權分别交由位置3的find 到 位置6的d 這一過程都是比對成功的，再接着将比對控制權交由\d+，

　　　　　　從位置7開始到結束都是數字，是以最終的比對結果為true。

　　3.9 運算符

　　　　相同優先級的從左到右進行運算，不同優先級的運算先高後低。各種操作符的優先級從高到低如下：

操作符	描述
\	轉義符
(), (?:), (?=), []	分組和類
*, +, ?, {n}, {n,}, {n,m}	量詞
^, $, \anymetacharacter	邊界以及字元順序
|	“或”操作

　　

　　3.10 其它

　　　　· 控制字元比對

　　　　　　\cX

　　　　　　X是a-Z之間的字元，\cX則表示比對control+X形式的控制字元。

　　　　　　但是在實際的測試中，發現通過\cX比對任意字元都是為空，是以猜測該正則在浏覽器中并不支援，或者是所應用的場合環境比較特殊。

　　　　　　下面是具體的測試代碼：

1 var pattern = '',
 2     str = '',
 3     c = '',
 4     r = '';
 5 for(var i=0;i<255;i++){
 6     str+=String.fromCharCode(i);
 7 }
 8 for(var i=65;i<90;i++){
 9     c = String.fromCharCode(i);
10     pattern = new RegExp('\\c'+c);
11     r = str.match(pattern);
12     r?console.log(r,c,pattern):'';
13 }      

　　　　· 修飾符m對位置元字元的影響。

　　　　　　我們知道修飾符m表示多行比對，而^$表示比對的開始于結束位置，那麼如果這兩種情況如果一起使用，或者分别使用，有什麼差別呢？

　　　　　　　　^$m：不僅比對字元串的起始于結束位置，還會比對每一行的起始于結束位置。

　　　　　　　　^$：隻比對字元串的起始于結束位置。

　　　　　　示例：

1 var str = 'hellow World\nWorld\naWorld',
2 pattern1 = /World$/g;
3 pattern2 = /^World$/gm;
4 pattern1.exec(str);    // -> index:20 
5 pattern2.exec(str); // -> index:13      

　　　　　　由此我們可以看出對于正則來說，字元串如果存在多行，那麼每一行都會存在^$比對操作。

　　　　· \Number 指定重複分組

　　　　　　在分組比對捕獲時，也可以在正則規則中指定\n(注:n:1-9)的形式來代指某個分組的值。

1 var str = 'abcabc',
2 pattern = /(.)b(.)\1b\2/;
3 pattern.test(str); // -> true      

　　　　　　示例：找出重複最多的字元。

1 /*  
 2  * 方法說明
 3  * split('') 将字元通過“空字元”來拆分為數組。
 4  * sort() 将數組元素的值按照ASCII碼進行排序。
 5  * join('') 将數組轉換為字元串。
 6   
 7 */
 8 
 9 var str = 'abcababaaaccddcd',
10      pattern = /(\w)\1+/g,
11      len = 0,
12      result = '',
13      data = '';
14 
15 str =  str.split('').sort().join('');    //通過這些步驟，我們可以得到一個具有相同字元Y一起排列出現的新字元串。aaaaaabbbccccddd
16 while(result = pattern.exec(str)){
17 
18     if(result[0].length > len){
19         len = result[0].length;
20         data = RegExp.$1;
21     }
22 }      

　　　　· 換行比對

　　　　　　在正則中字元串的換行是用\n進行表示的。

1 var str = '1.baidu\n2.google\n3.bing';
2 var pattern1 = /\d/g;    //此種方式也可以做到，但是建議使用标準的換行模式。
3 var pattern2 = /^\d/gm;
4 document.write(str.replace(pattern1,'#'));
5 document.write(str.replace(pattern2,'#'));      

4. 支援正則的String方法

　　除了RegExp對象具有支援正規表達式的方法外，字元串String對象也具有可以支援正規表達式作為參數進行比對篩選的的方法。

　　4.1 replace()

　　　　格式:str.replace(pattern,given);

　　　　功能：根據比對規則pattern來用指定的内容given去替換str或其部分字元。

　　　　　　　其中pattern可以是str中的部分字元也可以是一個正規表達式。

1 var str = 'i see you See you';
2 var pattern = /you/;
3 str.replace(pattern,'*'); // -> i see * See you      

　　　　注意：given所代表替換的指定内容，既可以是字元串，也可以是一個回調函數。

1 var str = 'i see you See you';
2 var pattern = /\byou\b/g;
3 str.replace(pattern,function(result,[$1...$9],index,input){});      

　　　　　　· result : 表示目前比對的結果

　　　　　　· [$1 - $9] : 存在分組的情況下，表示目前 1 - 9 個分組的内容。

　　　　　　· index : 目前比對内容首字母在字元創中索引。

　　　　　　· input ：進行比對的原字元創。

　　　　示例：敏感詞過濾

1  var str = '世界上最遙遠的距離 不是生與死的距離 而是我就站在你的面前 你卻不知道我愛你。',
 2         st = ['死','愛','距離'],
 3         pattern = '',
 4         alt = '';
 5 
 6   for(var i=0;i<st.length;i++){
 7 
 8 
 9       pattern = new RegExp(st[i],'g');
10 
11       for(var j=0;j<st[i].length;j++){
12           alt+='*';
13       }
14 
15       str = str.replace(pattern,alt);
16       alt = '';
17   }      

　　　　示例：回調函數使用

1 var str = '2016/10/29';
2 var pattern = /(\d+)(\/)/g;
3 var data = str.replace(pattern,function(result,$1,$2){
4     return $1+'.';
5 });      

　　* replace方法隻會傳回原字元被操作後的副本，并不會對原字元串進行改動。

　　4.2 match()

　　　　格式：str.match(pattern)

　　　　功能：

　　　　　　match 在功能上與正則對象自帶的方法exec很類似。

　　　　　　match 根據比對規則pattern比對指定的字元串str，如果比對成功則傳回一個數組格式的結果用于存放比對文本有關的資訊，

　　　　　　　　　如果沒有比對到則傳回null。

 　　　　　　var result = str.match(pattern); 

　　　　格式如下：

　　　　　　result --> 目前的比對結果。

　　　　　　result[0] --> 從數組中讀取目前的比對結果。

　　　　　　result[1]

　　　　　　　　.... ---> 指定分組中捕獲的内容。

　　　　　　result[n+1]

　　　　　　result.index --> 目前比對結果的首字母在給定字元串中的索引。

　　　　　　result.input --> 進行比對操作的給定字元串。

　　　　　　如果match的比對規則是一個正則，并且具有全局g屬性，那麼match傳回的比對結果，便是一個包含所有比對結果的純數組。

1 var str = 'abcdabcda';
2 var result = str.match(/a/g);
3 result --> [a,a,a]
4 result.input --> undefined
5 result.index --> undefined      

　　4.3 split()

　　　　格式：str.split(pattern,length)

　　　　　　根據規則pattern将字元串拆分為數組，拆分後的數組并不包含作為拆分依據的那個參數。

　　　　　　預設情況下是空字元進行拆分，也就是每個任意的字元作為一個數組元素。

　　　　　　pattern參數，可以是正規表達式，也可以是單純的字元或字元串。

　　　　　　length參數，用于設定拆分數組後數組最大的長度（即數組元素的個數）。預設該項，表示将字元全部拆分為數組。

1 var str = 'hellow word!';
2 str.spilit(''); // --> ''空字元（并非空格字元）["h", "e", "l", "l", "o", "w", " ", "w", "o", "r", "l", "d", "!"]
3 str.split('',5) // --> ["h", "e", "l", "l", "o"]
4 str.split(/\o/g) // --> ["hell", "w w", "rld!"]      

　　4.4 search();

　　　　格式：str.search(pattern)

　　　　功能：根絕比對規則pattern在字元串中檢索指定的結果，如果檢索到則傳回該結果首字母在原字元中的索引，否則傳回-1。其功能類似于indexOf,

　　　　　　   隻是indexOf并不支援正則比對。

1 var str = 'hellow world!';
2 str.search('o') // --> 4
3 str.search('x') // --> -1      

　　　　注意：該方法忽略全局修飾符g，也不支援lastIndex也就是意味着它不能被多次調用，一旦檢索到結果，便會停止檢索。

5. 常用正規表達式收集。

　　1. 比對任意字元

　　　　正則： /[^]/ 

　　2. 比對ASCII碼範圍

　　　　規則：\x00表示十進制0 ，\xff表示十進制255,0-255正好是ASCII碼表可表示的範圍。

　　　　正則： /[\x00-\xff]/g 

　　　　說明：同理， /[^\x00-\xff]/g  則表示比對漢字或者是全角字元。

　　3. 比對漢字

　　　　規則：\u4e00 : 在Unicode碼中漢字的開始編碼，\u9fa5 : 在Unicode碼中漢字的結束編碼。

　　　　正則： /^[\u4e00-\u9fa5]+$/ 

　　4. 手機号碼檢測

　　　　規則：[3|4|5|7|8] : 手機号11位，但是第二位數字隻有這幾種固定的網段。

　　　　正則： /^1[3|4|5|7|8]\d{9}$/ 

　　5. 郵政編碼

　　　　規則：郵政編碼必須為數字，長度為6位且第一位不能為0，示例：224000

　　　　正則： /[1-9]\d{5}/ 

　　6. 電子郵件

　　　　規則：以@為上下文表示，左側隻能是數字，字母及下劃線組成。

　　　　　　  而右側又以.符号為上下文，左側與上述一樣，而右側隻能為字母結尾。

　　　　正則： /^([\w\-\.]+)@([\w\-]+)\.([a-zA-Z]{2,4})$/ 

　　7. 比對前後空格

　　　　正則： /^\s+|\s+$/g 

　　8. QQ号比對

　　　　規則：首位不能為0，位數5-12位。

　　　　正則： /^[1-9]\d{4,11}$/; 

　　9. 比對網址url的正規表達式

　　　　正則： [a-zA-z]+://[^\s]* 

　　10. 比對國内電話号碼

　　　　正則： \d{3}-\d{8}|\d{4}-\d{7} 

　　11. 比對國内身份證号碼

　　　　規則：簡單的身份證比對，根據位數以及結尾是否有字母。

　　　　正則： /^\d{15}(\d{2}[A-Za-z0-9])?$/ 

　　12. 比對IP位址

　　　　正則： /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/g 

　　13. 驗證是否含有^%&',;=?$\"等字元

　　　　正則： /[^%&',;=?$\x22]+/ 

　　14. 比對空行的正規表達式

　　　　正則： \n[\s| ]*\r 

　　15. 數學正則

　　　　整數 :  /^[-\+]?\d+$/ 

　　　　浮點數 :  /^[-\+]?\d+(\.\d+)?$/ 

　　　　Chinese :  /^[\u0391-\uFFE5]+$/ 

　　　　實數： ^[-+]?\d+(\.\d+)?$ 

附錄：參考頁面

PS：感謝這些作者們！

http://javascript.ruanyifeng.com/stdlib/regexp.html#toc13 (講解很到位的正則教程)

http://www.cnblogs.com/52cik/p/js-regular-control-character.html (關于控制字元的代碼測試執行個體)

http://baike.baidu.com/view/1112575.htm?fr=aladdin (關于控制字元的說明)

http://www.cnblogs.com/hustskyking/archive/2013/06/04/RegExp.html(正規表達式30分鐘入門教程 PS:内容很豐富，适合全面了解正則的教程，但是裡面講到的很多功能并不能被浏覽器實作)

http://www.cnblogs.com/dwlsxj/p/Reg.html （對零寬度講解很好的文章）

http://www.cnblogs.com/moqing/p/5665126.html