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['$&'];
　　　　　　　　注意：opera 低版本並不支持。

　　　　　　- lastParen
　　　　　　　　功能：最後一次分組中捕獲到的內容。須要開啓修飾符-g。
　　　　　　　　示例： console.log('lastParen:'+RegExp.lastParen) // -> 'm'; 
　　　　　　　　短名：RegExp['$+'];
　　　　　　　　注意：opera 低版本並不支持。

　　　　　　- 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

 

出處：http://www.cnblogs.com/HCJJ/p/6012363.html