Regexp對象

概述
實例屬性
實例方法
RegExp.prototype.test()g
RegExp.prototype.exec()g括號indexx input屬性
字符串的實例方法
String.prototype.match()像exec返回字符串數組 區別g一次返回所有 lastibdex無效
String.prototype.search()
String.prototype.replace()加g一次換所有
String.prototype.split()
匹配規則
字面量字符和元字符
轉義符
特殊字符
字符類
預約義模式
重複類
量詞符
貪婪模式
修飾符
組匹配

1.概述
正則表達式（regular expression）是一種表達文本模式（即字符串結構）的方法

1.1新建正則表達式有兩種方法。一種是使用字面量，以斜槓表示開始和結束。

var regex = /xyz/;
另外一種是使用RegExp構造函數。

var regex = new RegExp('xyz');

主要區別是，第一種方法在引擎編譯代碼時，就會新建正則表達式，第二種方法在運行時新建正則表達式，因此前者的效率較高

RegExp構造函數還能夠接受第二個參數，表示修飾符（詳細解釋見下文）。

var regex = new RegExp('xyz', 'i');
// 等價於
var regex = /xyz/i;

2.實例屬性
正則對象的實例屬性分紅兩類。

一類是修飾符相關，用於瞭解設置了什麼修飾符。

RegExp.prototype.ignoreCase：返回一個布爾值，表示是否設置了i修飾符。
RegExp.prototype.global：返回一個布爾值，表示是否設置了g修飾符。
RegExp.prototype.multiline：返回一個布爾值，表示是否設置了m修飾符。
RegExp.prototype.flags：返回一個字符串，包含了已經設置的全部修飾符，按字母排序。
上面四個屬性都是隻讀的。

var r = /abc/igm;

r.ignoreCase // true
r.global // true
r.multiline // true
r.flags // 'gim'

另外一類是與修飾符無關的屬性，主要是下面兩個。

RegExp.prototype.lastIndex：返回一個整數，表示下一次開始搜索的位置。該屬性可讀寫，可是隻在進行連續搜索時有意義，詳細介紹請看後文。
RegExp.prototype.source：返回正則表達式的字符串形式（不包括反斜槓），該屬性只讀。
var r = /abc/igm;

r.lastIndex // 0
r.source // "abc"

3.實例方法
3.1RegExp.prototype.test()
返回布爾值，看是否匹配
3.1.1帶g
（1）則每一次test方法都從上一次結束的位置開始向後匹配。 回記住lastindex
var r = /x/g;
var s = '_x_x';

r.lastIndex // 0
r.test(s) // true

r.lastIndex // 2
r.test(s) // true

r.lastIndex // 4
r.test(s) // false

（2）能夠指定lastIndex屬性指定開始搜索的位置，
var r = /x/g;
var s = '_x_x';

r.lastIndex = 4;
r.test(s) // false

r.lastIndex // 0
r.test(s)

（3）注意，帶有g修飾符時，正則表達式內部會記住上一次的lastIndex屬性，這時不該該更換所要匹配的字符串，不然會有一些難以察覺的錯誤。

var r = /bb/g;
r.test('bb') // true
r.test('-bb-') // false

（4）lastIndex屬性只對同一個正則表達式有效，因此下面這樣寫是錯誤的。

var count = 0;
while (/a/g.test('babaa')) count++;
上面代碼會致使無限循環，由於while循環的每次匹配條件都是一個新的正則表達式，致使lastIndex屬性老是等於0。每次新建一個regexp對象

3.1.3若是正則模式是一個空字符串，則匹配全部字符串。

new RegExp('').test('abc')
// true

3.1.2RegExp.prototype.exec()
匹配到的返回字符串數組，只有一個元素的數組。不然返回null

（1）有括號（組匹配） 返回多個成員

第一個成員是整個匹配成功的結果，後面的成員就是圓括號對應的匹配成功的組。也就是說，第二個成員對應第一個括號，第三個成員對應第二個括號，以此類推。整個數組的length屬性等於組匹配的數量再加1。

var s = '_x_x';
var r = /_(x)/;

r.exec(s) // ["_x", "x"]
上面代碼的exec方法，返回一個數組。第一個成員是整個匹配的結果，第二個成員是圓括號匹配的結果。

（2）exec方法的返回數組還包含如下兩個屬性：

input：整個原字符串。
index：整個模式匹配成功的開始位置（從0開始計數）。

var r = /a(b+)a/;
var arr = r.exec('_abbba_aba_');

arr // ["abbba", "bbb"]

arr.index // 1
arr.input // "_abbba_aba_"
上面代碼中的index屬性等於1，是由於從原字符串的第二個位置開始匹配成功。

（3）正則表達式加上g修飾符，則可使用屢次exec方法，下一次搜索的位置從上一次匹配成功結束的位置開始。

var reg = /a/g;
var str = 'abc_abc_abc'

var r1 = reg.exec(str);
r1 // ["a"]
r1.index // 0
reg.lastIndex // 1

var r2 = reg.exec(str);
r2 // ["a"]
r2.index // 4
reg.lastIndex // 5

var r3 = reg.exec(str);
r3 // ["a"]
r3.index // 8
reg.lastIndex // 9

var r4 = reg.exec(str);
r4 // null
reg.lastIndex // 0

連續用了四次exec方法，前三次都是從上一次匹配結束的位置向後匹配。當第三次匹配結束之後，整個字符串已經到達尾部，匹配結果返回null，正則實例對象的lastIndex屬性也重置爲0，意味着第四次匹配將從頭開始。

g修飾符容許屢次匹配的特色，能夠用一個循環完成所有匹配。

var reg = /a/g;
var str = 'abc_abc_abc'

while(true) {
var match = reg.exec(str);
if (!match) break;
console.log('#' + match.index + ':' + match[0]);
}
// #0:a
// #4:a
// #8:a
上面代碼中，只要exec方法不返回null，就會一直循環下去，每次輸出匹配的位置和匹配的文本。

4.字符串的實例方法
String.prototype.match()：返回一個數組，成員是全部匹配的子字符串。
String.prototype.search()：按照給定的正則表達式進行搜索，返回一個整數，表示匹配開始的位置。
String.prototype.replace()：按照給定的正則表達式進行替換，返回替換後的字符串。一個而已 有g才替換所有
String.prototype.split()：按照給定規則進行字符串分割，返回一個數組，包含分割後的各個成員

String.prototype.match()
正則表達式帶有g修飾符，則該方法與正則對象的exec方法行爲不一樣，會一次性返回全部匹配成功的結果。
var s = '_x_x';
var r1 = /x/;
var r2 = /y/;

s.match(r1) // ["x"]
s.match(r2) // null

設置正則表達式的lastIndex屬性，對match方法無效，匹配老是從字符串的第一個字符開始。

var r = /a|b/g;
r.lastIndex = 7;
'xaxb'.match(r) // ['a', 'b']
r.lastIndex // 0
var s = 'abba';
var r = /a/g;

s.match(r) // ["a", "a"]
r.exec(s) // ["a"]

String.prototype.search()
字符串對象的search方法，返回第一個知足條件的匹配結果在整個字符串中的位置。若是沒有任何匹配，則返回-1。

'_x_x'.search(/x/)
// 1

（2）String.prototype.replace()
正則表達式若是不加g修飾符，就替換第一個匹配成功的值，不然替換全部匹配成功的值。

'aaa'.replace('a', 'b') // "baa"
'aaa'.replace(/a/, 'b') // "baa"
'aaa'.replace(/a/g, 'b') // "bbb"

2.1replace方法的第二個參數可使用美圓符號$，用來指代所替換的內容。

$&：匹配的子字符串。
$`：匹配結果前面的文本。
$'：匹配結果後面的文本。
$n：匹配成功的第n組內容，n是從1開始的天然數。
$$：指代美圓符號$。
'hello world'.replace(/(w+)s(w+)/, '$2 $1')
// "world hello"

'abc'.replace('b', '[$`-$&-$']')
// "a[a-b-c]c"
上面代碼中，第一個例子是將匹配的組互換位置，第二個例子是改寫匹配的值。

2.2replace方法的第二個參數還能夠是一個函數，將每個匹配內容替換爲函數返回值
'3 and 5'.replace(/[0-9]+/g, function (match) {
return 2 * match;
})
// "6 and 10"

var a = 'The quick brown fox jumped over the lazy dog.';
var pattern = /quick|brown|lazy/ig;

a.replace(pattern, function replacer(match) {
return match.toUpperCase();
});
// The QUICK BROWN fox jumped over the LAZY dog.
做爲replace方法第二個參數的替換函數，能夠接受多個參數。其中，第一個參數是捕捉到的內容，第二個參數是捕捉到的組匹配（有多少個組匹配，就有多少個對應的參數）。此外，最後還能夠添加兩個參數，倒數第二個參數是捕捉到的內容在整個字符串中的位置（好比從第五個位置開始），最後一個參數是原字符串。下面是一個網頁模板替換的例子。

var prices = {
'p1': '$1.99',
'p2': '$9.99',
'p3': '$5.00'
};

var template = '<span id="p1"></span>'

• '<span id="p2"></span>'
• '<span id="p3"></span>';

template.replace(
/(<span id=")(.*?)(">)(</span>)/g,
function(match, $1, $2, $3, $4){

return $1 + $2 + $3 + prices[$2] + $4;

}
);
// "<span id="p1">$1.99</span><span id="p2">$9.99</span><span id="p3">$5.00</span>"
上面代碼的捕捉模式中，有四個括號，因此會產生四個組匹配，在匹配函數中用$1到$4表示。匹配函數的做用是將價格插入模板中。

String.prototype.split()

字符串對象的split方法按照正則規則分割字符串，返回一個由分割後的各個部分組成的數組。

str.split(separator, [limit])
該方法接受兩個參數，第一個參數是正則表達式，表示分隔規則，第二個參數是返回數組的最大成員數。

// 非正則分隔
'a, b,c, d'.split(',')
// [ 'a', ' b', 'c', ' d' ]

// 正則分隔，去除多餘的空格
'a, b,c, d'.split(/, */)
// [ 'a', 'b', 'c', 'd' ]

// 指定返回數組的最大成員
'a, b,c, d'.split(/, */, 2)
[ 'a', 'b' ]
上面代碼使用正則表達式，去除了子字符串的逗號後面的空格。

// 例一
'aaaa'.split(/a*/)
// [ '', '', '' ]

// 例二
'aaa*a'.split(/a*/)
// ["", "", "", "*"]
上面代碼的分割規則是0次或屢次的a，因爲正則默認是貪婪匹配，因此例一的第一個分隔符是aaa，第二個分割符是a，將字符串分紅三個部分，包含開始處的空字符串。例二的第一個分隔符是aaa，第二個分隔符是0個a（即空字符），第三個分隔符是a，因此將字符串分紅四個部分。

若是正則表達式帶有括號，則括號匹配的部分也會做爲數組成員返回。

'aaaa'.split(/(a*)/)
// [ '', 'aaa', '', 'a', '' ]
上面代碼的正則表達式使用了括號，第一個組匹配是aaa，第二個組匹配是a，它們都做爲數組成員返回。

（3）String.prototype.split()5.匹配規則字面量字符和元字符轉義符特殊字符字符類預約義模式重複類量詞符貪婪模式修飾符組匹配