深入理解ES5系列之標準庫-正則表達式對象

2 標準庫

2.1 正則表達式對象（RegExp對象）

2.1.1 表示方法

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

var regex = /xyz/;

另一種是使用RegExp構造函數。

var regex = new RegExp('xyz');

上面兩種寫法是等價的，都新建了一個內容爲xyz的正則表達式對象。它們的主要區別是，第一種方法在引擎編譯代碼時，就會新建正則表達式，第二種方法在運行時新建正則表達式，所以前者的效率較高。而且，前者比較便利和直觀，所以實際應用中，基本上都採用字面量定義正則表達式。

2.1.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：返回正則表達式的字符串形式（不包括反斜槓），該屬性只讀。

2.1.3 實例方法

2.1.3.1 RegExp.prototype.test()

正則實例對象的test方法返回一個布爾值，表示當前模式是否能匹配參數字符串。

如果正則表達式帶有g修飾符，則每一次test方法都從上一次結束的位置開始向後匹配。

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

上面代碼的正則表達式使用了g修飾符，表示是全局搜索，會有多個結果。接着，三次使用test方法，每一次開始搜索的位置都是上一次匹配的後一個位置。

帶有g修飾符時，可以通過正則對象的lastIndex屬性指定開始搜索的位置。

var r = /x/g;
var s = '_x_x';

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

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

上面代碼指定從字符串的第五個位置開始搜索，這個位置爲空，所以返回false。同時，lastIndex屬性重置爲0，所以第二次執行r.test(s)會返回true。

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

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

上面代碼中，由於正則表達式r是從上一次的lastIndex位置開始匹配，導致第二次執行test方法時出現預期以外的結果。

lastIndex屬性只對同一個正則表達式有效，所以下面這樣寫是錯誤的。

var count = 0;
while (/a/g.test('babaa')) count++;

上面代碼會導致無限循環，因爲while循環的每次匹配條件都是一個新的正則表達式，導致lastIndex屬性總是等於0。

如果正則模式是一個空字符串，則匹配所有字符串。

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

2.1.3.2 RegExp.prototype.exec()

正則實例對象的exec()方法，用來返回匹配結果。如果發現匹配，就返回一個數組，成員是匹配成功的子字符串，否則返回null。

如果正則表示式包含圓括號（即含有“組匹配”），則返回的數組會包括多個成員。第一個成員是整個匹配成功的結果，後面的成員就是圓括號對應的匹配成功的組。也就是說，第二個成員對應第一個括號，第三個成員對應第二個括號，以此類推。整個數組的length屬性等於組匹配的數量再加1。

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

r.exec(s) // ["_x", "x"]

上面代碼的exec()方法，返回一個數組。第一個成員是整個匹配的結果，第二個成員是圓括號匹配的結果。

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，是因爲從原字符串的第二個位置開始匹配成功。

如果正則表達式加上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，就會一直循環下去，每次輸出匹配的位置和匹配的文本。

正則實例對象的lastIndex屬性不僅可讀，還可寫。設置了g修飾符的時候，只要手動設置了lastIndex的值，就會從指定位置開始匹配。

2.1.4 字符串的實例方法

字符串的實例方法之中，有4種與正則表達式有關。

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

2.1.4.1 String.prototype.match()

字符串實例對象的match方法對字符串進行正則匹配，返回匹配結果。

var s = '_x_x';
var r1 = /x/;
var r2 = /y/;

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

從上面代碼可以看到，字符串的match方法與正則對象的exec方法非常類似：匹配成功返回一個數組，匹配失敗返回null。

如果正則表達式帶有g修飾符，則該方法與正則對象的exec方法行爲不同，會一次性返回所有匹配成功的結果。

var s = 'abba';
var r = /a/g;

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

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

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

上面代碼表示，設置正則對象的lastIndex屬性是無效的。

2.1.4.2 String.prototype.search()

字符串對象的search方法，返回第一個滿足條件的匹配結果在整個字符串中的位置。如果沒有任何匹配，則返回-1。

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

上面代碼中，第一個匹配結果出現在字符串的1號位置。

2.1.4.3 String.prototype.replace()

字符串對象的replace方法可以替換匹配的值。它接受兩個參數，第一個是正則表達式，表示搜索模式，第二個是替換的內容。

str.replace(search, replacement)

正則表達式如果不加g修飾符，就替換第一個匹配成功的值，否則替換所有匹配成功的值。

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

上面代碼中，最後一個正則表達式使用了g修飾符，導致所有的a都被替換掉了。

replace方法的一個應用，就是消除字符串首尾兩端的空格。

var str = '  #id div.class  ';

str.replace(/^\s+|\s+$/g, '')
// "#id div.class"

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

$&：匹配的子字符串。
$`：匹配結果前面的文本。
$’：匹配結果後面的文本。
$n：匹配成功的第n組內容，n是從1開始的自然數。
$$：指代美元符號$。

'hello world'.replace(/(\w+)\s(\w+)/, '$2 $1')
// "world hello"

'abc'.replace('b', '[$`-$&-$\']')
// "a[a-b-c]c"

上面代碼中，第一個例子是將匹配的組互換位置，第二個例子是改寫匹配的值。

replace方法的第二個參數還可以是一個函數，將每一個匹配內容替換爲函數返回值。

'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表示。匹配函數的作用是將價格插入模板中。

2.1.4.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' ]

上面代碼使用正則表達式，去除了子字符串的逗號後面的空格。

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

// 例二
'aaa**a*'.split(/a*/)
// ["", "*", "*", "*"]

上面代碼的分割規則是0次或多次的a，由於正則默認是貪婪匹配，所以例一的第一個分隔符是aaa，第二個分割符是a，將字符串分成三個部分，包含開始處的空字符串。例二的第一個分隔符是aaa，第二個分隔符是0個a（即空字符），第三個分隔符是a，所以將字符串分成四個部分。

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

'aaa*a*'.split(/(a*)/)
// [ '', 'aaa', '*', 'a', '*' ]

上面代碼的正則表達式使用了括號，第一個組匹配是aaa，第二個組匹配是a，它們都作爲數組成員返回。

2.1.5 匹配規則

2.1.5.1 字面量字符和元字符

大部分字符在正則表達式中，就是字面的含義，比如/a/匹配a，/b/匹配b。如果在正則表達式之中，某個字符只表示它字面的含義（就像前面的a和b），那麼它們就叫做“字面量字符”（literal characters）。

除了字面量字符以外，還有一部分字符有特殊含義，不代表字面的意思。它們叫做“元字符”（metacharacters），主要有以下幾個。

（1）點字符（.）

點字符（.）匹配除回車（\r）、換行(\n) 、行分隔符（\u2028）和段分隔符（\u2029）以外的所有字符。注意，對於碼點大於0xFFFF字符，點字符不能正確匹配，會認爲這是兩個字符。

/c.t/

上面代碼中，c.t匹配c和t之間包含任意一個字符的情況，只要這三個字符在同一行，比如cat、c2t、c-t等等，但是不匹配coot。

（2）位置字符

位置字符用來提示字符所處的位置，主要有兩個字符。

^ 表示字符串的開始位置
$ 表示字符串的結束位置

（3）選擇符（|）

豎線符號（|）在正則表達式中表示“或關係”（OR），即cat|dog表示匹配cat或dog。

/11|22/.test('911') // true

上面代碼中，正則表達式指定必須匹配11或22。

多個選擇符可以聯合使用。

// 匹配fred、barney、betty之中的一個
/fred|barney|betty/

選擇符會包括它前後的多個字符，比如/ab|cd/指的是匹配ab或者cd，而不是指匹配b或者c。如果想修改這個行爲，可以使用圓括號。

/a( |\t)b/.test('a\tb') // true

上面代碼指的是，a和b之間有一個空格或者一個製表符。

其他的元字符還包括\、*、+、?、()、[]、{}等，將在下文解釋。

2.1.5.2 轉義符

正則表達式中那些有特殊含義的元字符，如果要匹配它們本身，就需要在它們前面要加上反斜槓。比如要匹配+，就要寫成+。

/1+1/.test('1+1')
// false

/1\+1/.test('1+1')
// true

上面代碼中，第一個正則表達式之所以不匹配，因爲加號是元字符，不代表自身。第二個正則表達式使用反斜槓對加號轉義，就能匹配成功。

正則表達式中，需要反斜槓轉義的，一共有12個字符：^、.、[、$、(、)、|、*、+、?、{和\。 ¹ 需要特別注意的是，如果使用RegExp方法生成正則對象，轉義需要使用兩個斜槓，因爲字符串內部會先轉義一次。

/[]/.exec('[]') // null
/\[]/.exec('[]') // [ "[]" ]
/\[\]/.exec('[]') // [ "[]" ] 

/()/.exec('()') // [ "", "" ]
/\()/.exec('()') // SyntaxError: unmatched ) in regular expression
/\(\)/.exec('()') // [ "()" ]

/{}/.exec('{}') // [ "{}" ]
/{.*}/.exec('{aaa}') // [ "{aaa}" ]
/\{}/.exec('{}') // [ "{}" ]
 /\{\}/.exec('{}') // [ "{}" ]

上面代碼的第一段，說明"[“和”]"，只需要轉義"["，第二段，說明"(“和”)“都需要轉義，第三段，說明”{“和”}"都不需要轉義，上面的符號即使都轉義也不會出錯。

(new RegExp('1\+1')).test('1+1')
// false

(new RegExp('1\\+1')).test('1+1')
// true

上面代碼中，RegExp作爲構造函數，參數是一個字符串。但是，在字符串內部，反斜槓也是轉義字符，所以它會先被反斜槓轉義一次，然後再被正則表達式轉義一次，因此需要兩個反斜槓轉義。

2.1.5.3 特殊字符

正則表達式對一些不能打印的特殊字符，提供了表達方法。

\cX 表示Ctrl-[X]，其中的X是A-Z之中任一個英文字母，用來匹配控制字符。
[\b] 匹配退格鍵(U+0008)，不要與\b混淆。
\n 匹配換行鍵。
\r 匹配回車鍵。
\t 匹配製表符 tab（U+0009）。
\v 匹配垂直製表符（U+000B）。
\f 匹配換頁符（U+000C）。
\0 匹配null字符（U+0000）。
\xhh 匹配一個以兩位十六進制數（\x00-\xFF）表示的字符。
\uhhhh 匹配一個以四位十六進制數（\u0000-\uFFFF）表示的 Unicode 字符。

2.1.5.4 字符類

字符類（class）表示有一系列字符可供選擇，只要匹配其中一個就可以了。所有可供選擇的字符都放在方括號內，比如[xyz] 表示x、y、z之中任選一個匹配。

/[abc]/.test('hello world') // false
/[abc]/.test('apple') // true

上面代碼中，字符串hello world不包含a、b、c這三個字母中的任一個，所以返回false；字符串apple包含字母a，所以返回true。

有兩個字符在字符類中有特殊含義。

（1）脫字符（^）

如果方括號內的第一個字符是 [^]，則表示除了字符類之中的字符，其他字符都可以匹配。比如，[^xyz]表示除了x、y、z之外都可以匹配。

如果方括號內沒有其他字符，即只有[^]，就表示匹配一切字符，其中包括換行符。 相比之下，點號作爲元字符（.）是不包括換行符的。

var s = 'Please yes\nmake my day!';

s.match(/yes.*day/) // null
s.match(/yes[^]*day/) // [ 'yes\nmake my day']

上面代碼中，字符串s含有一個換行符，點號不包括換行符，所以第一個正則表達式匹配失敗；第二個正則表達式[^]包含一切字符，所以匹配成功。

注意，脫字符只有在字符類的第一個位置纔有特殊含義，否則就是字面含義。

（2）連字符（-）

某些情況下，對於連續序列的字符，連字符（-）用來提供簡寫形式，表示字符的連續範圍。比如，[abc]可以寫成[a-c]，[0123456789]可以寫成[0-9]，同理[A-Z]表示26個大寫字母。

/a-z/.test('b') // false
/[a-z]/.test('b') // true

上面代碼中，當連字號（dash）不出現在方括號之中，就不具備簡寫的作用，只代表字面的含義，所以不匹配字符b。只有當連字號用在方括號之中，才表示連續的字符序列。

以下都是合法的字符類簡寫形式。

[0-9.,]
[0-9a-fA-F]
[a-zA-Z0-9-]
[1-31]

上面代碼中最後一個字符類[1-31]，不代表1到31，只代表1到3。

連字符還可以用來指定 Unicode 字符的範圍。

var str = "\u0130\u0131\u0132";
/[\u0128-\uFFFF]/.test(str)
// true

上面代碼中，\u0128-\uFFFF表示匹配碼點在0128到FFFF之間的所有字符。

另外，不要過分使用連字符，設定一個很大的範圍，否則很可能選中意料之外的字符。最典型的例子就是[A-z]，表面上它是選中從大寫的A到小寫的z之間52個字母，但是由於在 ASCII 編碼之中，大寫字母與小寫字母之間還有其他字符，結果就會出現意料之外的結果。

/[A-z]/.test('\\') // true

上面代碼中，由於反斜槓（’’）的ASCII碼在大寫字母與小寫字母之間，結果會被選中。

2.1.5.5 預定義模式

預定義模式指的是某些常見模式的簡寫方式。

\d 匹配0-9之間的任一數字，相當於[0-9]。
\D 匹配所有0-9以外的字符，相當於[^0-9]。
\w 匹配任意的字母、數字和下劃線，相當於[A-Za-z0-9_]。
\W 除所有字母、數字和下劃線以外的字符，相當於[^A-Za-z0-9_]。
\s 匹配空格（包括換行符、製表符、空格符等），相等於[ \t\r\n\v\f]。
\S 匹配非空格的字符，相當於[^ \t\r\n\v\f]。
\b 匹配詞的邊界。
\B 匹配非詞邊界，即在詞的內部。

下面是一些例子。

// \s 的例子
/\s\w*/.exec('hello world') // [" world"]

// \b 的例子
/\bworld/.test('hello world') // true
/\bworld/.test('hello-world') // true
/\bworld/.test('helloworld') // false

// \B 的例子
/\Bworld/.test('hello-world') // false
/\Bworld/.test('helloworld') // true

上面代碼中，\s表示空格，所以匹配結果會包括空格。\b表示詞的邊界，所以world的詞首必須獨立（詞尾是否獨立未指定），纔會匹配。同理，\B表示非詞的邊界，只有world的詞首不獨立，纔會匹配。

通常，正則表達式遇到換行符（\n）就會停止匹配。

var html = "<b>Hello</b>\n<i>world!</i>";

/.*/.exec(html)[0]
// "<b>Hello</b>"

上面代碼中，字符串html包含一個換行符，結果點字符（.）不匹配換行符，導致匹配結果可能不符合原意。這時使用\s字符類，就能包括換行符。

var html = "<b>Hello</b>\n<i>world!</i>";

/[\S\s]*/.exec(html)[0]
// "<b>Hello</b>\n<i>world!</i>"

上面代碼中，[\S\s]指代一切字符。

有兩種表示“任意字符”的方式：
[^] 和 [\S\s]

2.1.5.6 重複類

模式的精確匹配次數，使用大括號（{}）表示。{n}表示恰好重複n次，{n,}表示至少重複n次，{n,m}表示重複不少於n次，不多於m次。

/lo{2}k/.test('look') // true
/lo{2,5}k/.test('looook') // true

上面代碼中，第一個模式指定o連續出現2次，第二個模式指定o連續出現2次到5次之間。

2.1.5.7 量詞符

量詞符用來設定某個模式出現的次數。

? 問號表示某個模式出現0次或1次，等同於{0, 1}。
- 星號表示某個模式出現0次或多次，等同於{0,}。
- 加號表示某個模式出現1次或多次，等同於{1,}。

// t 出現0次或1次
/t?est/.test('test') // true
/t?est/.test('est') // true

// t 出現1次或多次
/t+est/.test('test') // true
/t+est/.test('ttest') // true
/t+est/.test('est') // false

// t 出現0次或多次
/t*est/.test('test') // true
/t*est/.test('ttest') // true
/t*est/.test('tttest') // true
/t*est/.test('est') // true

2.1.5.8 貪婪模式

上一小節的三個量詞符，默認情況下都是最大可能匹配，即匹配直到下一個字符不滿足匹配規則爲止。這被稱爲貪婪模式。

var s = 'aaa';
s.match(/a+/) // ["aaa"]

上面代碼中，模式是/a+/，表示匹配1個a或多個a，那麼到底會匹配幾個a呢？因爲默認是貪婪模式，會一直匹配到字符a不出現爲止，所以匹配結果是3個a。

如果想將貪婪模式改爲非貪婪模式，可以在量詞符後面加一個問號。

var s = 'aaa';
s.match(/a+?/) // ["a"]

上面代碼中，模式結尾添加了一個問號/a+?/，這時就改爲非貪婪模式，一旦條件滿足，就不再往下匹配。

除了非貪婪模式的加號，還有非貪婪模式的星號（*）和非貪婪模式的問號（?）。

+?：表示某個模式出現1次或多次，匹配時採用非貪婪模式。
*?：表示某個模式出現0次或多次，匹配時採用非貪婪模式。
??：表格某個模式出現0次或1次，匹配時採用非貪婪模式。

'abb'.match(/ab*b/) // ["abb"]
'abb'.match(/ab*?b/) // ["ab"]

'abb'.match(/ab?b/) // ["abb"]
'abb'.match(/ab??b/) // ["ab"]

2.1.5.9 修飾符

修飾符（modifier）表示模式的附加規則，放在正則模式的最尾部。

修飾符可以單個使用，也可以多個一起使用。

// 單個修飾符
var regex = /test/i;

// 多個修飾符
var regex = /test/ig;

（1）g 修飾符

默認情況下，第一次匹配成功後，正則對象就停止向下匹配了。g修飾符表示全局匹配（global），加上它以後，正則對象將匹配全部符合條件的結果，主要用於搜索和替換。

var regex = /b/;
var str = 'abba';

regex.test(str); // true
regex.test(str); // true
regex.test(str); // true

上面代碼中，正則模式不含g修飾符，每次都是從字符串頭部開始匹配。所以，連續做了三次匹配，都返回true。

var regex = /b/g;
var str = 'abba';

regex.test(str); // true
regex.test(str); // true
regex.test(str); // false

上面代碼中，正則模式含有g修飾符，每次都是從上一次匹配成功處，開始向後匹配。因爲字符串abba只有兩個b，所以前兩次匹配結果爲true，第三次匹配結果爲false。

（2）i 修飾符

默認情況下，正則對象區分字母的大小寫，加上i修飾符以後表示忽略大小寫（ignoreCase）。

/abc/.test('ABC') // false
/abc/i.test('ABC') // true

上面代碼表示，加了i修飾符以後，不考慮大小寫，所以模式abc匹配字符串ABC。

（3）m 修飾符

m修飾符表示多行模式（multiline），會修改^和$的行爲。默認情況下（即不加m修飾符時），^和$匹配字符串的開始處和結尾處，加上m修飾符以後，^和$還會匹配行首和行尾，即^和$會識別換行符（\n）。

/world$/.test('hello world\n') // false
/world$/m.test('hello world\n') // true

上面的代碼中，字符串結尾處有一個換行符。如果不加m修飾符，匹配不成功，因爲字符串的結尾不是world；加上以後，$可以匹配行尾。

/^b/m.test('a\nb') // true

上面代碼要求匹配行首的b，如果不加m修飾符，就相當於b只能處在字符串的開始處。加上m修飾符以後，換行符\n也會被認爲是一行的開始。

2.1.5.10 組匹配

（1）概述

正則表達式的括號表示分組匹配，括號中的模式可以用來匹配分組的內容。

/fred+/.test('fredd') // true
/(fred)+/.test('fredfred') // true

上面代碼中，第一個模式沒有括號，結果+只表示重複字母d，第二個模式有括號，結果+就表示匹配fred這個詞。

下面是另外一個分組捕獲的例子。

var m = 'abcabc'.match(/(.)b(.)/);
m
// ['abc', 'a', 'c']

上面代碼中，正則表達式/(.)b(.)/一共使用兩個括號，第一個括號捕獲a，第二個括號捕獲c。

注意，使用組匹配時，不宜同時使用g修飾符，否則match方法不會捕獲分組的內容。

var m = 'abcabc'.match(/(.)b(.)/g);
m // ['abc', 'abc']

上面代碼使用帶g修飾符的正則表達式，結果match方法只捕獲了匹配整個表達式的部分。這時必須使用正則表達式的exec方法，配合循環，才能讀到每一輪匹配的組捕獲。

var str = 'abcabc';
var reg = /(.)b(.)/g;
while (true) {
  var result = reg.exec(str);
  if (!result) break;
  console.log(result);
}
// ["abc", "a", "c"]
// ["abc", "a", "c"]

正則表達式內部，還可以用\n引用括號匹配的內容，n是從1開始的自然數，表示對應順序的括號。

/(.)b(.)\1b\2/.test("abcabc")
// true

上面的代碼中，\1表示第一個括號匹配的內容（即a），\2表示第二個括號匹配的內容（即c）。

下面是另外一個例子。

/y(..)(.)\2\1/.test('yabccab') // true

括號還可以嵌套。

/y((..)\2)\1/.test('yabababab') // true

上面代碼中，\1指向外層括號，\2指向內層括號。

組匹配非常有用，下面是一個匹配網頁標籤的例子。

var tagName = /<([^>]+)>[^<]*<\/\1>/;

tagName.exec("<b>bold</b>")[1]
// 'b'

上面代碼中，圓括號匹配尖括號之中的標籤，而\1就表示對應的閉合標籤。

上面代碼略加修改，就能捕獲帶有屬性的標籤。

var html = '<b class="hello">Hello</b><i>world</i>';
var tag = /<(\w+)([^>]*)>(.*?)<\/\1>/g;

var match = tag.exec(html);

match[1] // "b"
match[2] // " class="hello""
match[3] // "Hello"

match = tag.exec(html);

match[1] // "i"
match[2] // ""
match[3] // "world"

（2）非捕獲組

(?:x)稱爲非捕獲組（Non-capturing group），表示不返回該組匹配的內容，即匹配的結果中不計入這個括號。

非捕獲組的作用請考慮這樣一個場景，假定需要匹配foo或者foofoo，正則表達式就應該寫成/(foo){1, 2}/，但是這樣會佔用一個組匹配。這時，就可以使用非捕獲組，將正則表達式改爲/(?:foo){1, 2}/，它的作用與前一個正則是一樣的，但是不會單獨輸出括號內部的內容。

請看下面的例子。

var m = 'abc'.match(/(?:.)b(.)/);
m // ["abc", "c"]

上面代碼中的模式，一共使用了兩個括號。其中第一個括號是非捕獲組，所以最後返回的結果中沒有第一個括號，只有第二個括號匹配的內容。

下面是用來分解網址的正則表達式。

// 正常匹配
var url = /(http|ftp):\/\/([^/\r\n]+)(\/[^\r\n]*)?/;

url.exec('http://google.com/');
// ["http://google.com/", "http", "google.com", "/"]

// 非捕獲組匹配
var url = /(?:http|ftp):\/\/([^/\r\n]+)(\/[^\r\n]*)?/;

url.exec('http://google.com/');
// ["http://google.com/", "google.com", "/"]

上面的代碼中，前一個正則表達式是正常匹配，第一個括號返回網絡協議；後一個正則表達式是非捕獲匹配，返回結果中不包括網絡協議。

（3）先行斷言

x(?=y)稱爲先行斷言（Positive look-ahead），x只有在y前面才匹配，y不會被計入返回結果。比如，要匹配後面跟着百分號的數字，可以寫成/\d+(?=%)/。

“先行斷言”中，括號裏的部分是不會返回的。

var m = 'abc'.match(/b(?=c)/);
m // ["b"]

上面的代碼使用了先行斷言，b在c前面所以被匹配，但是括號對應的c不會被返回。

（4）先行否定斷言

x(?!y)稱爲先行否定斷言（Negative look-ahead），x只有不在y前面才匹配，y不會被計入返回結果。比如，要匹配後面跟的不是百分號的數字，就要寫成/\d+(?!%)/。

/\d+(?!\.)/.exec('3.14')
// ["14"]

上面代碼中，正則表達式指定，只有不在小數點前面的數字纔會被匹配，因此返回的結果就是14。

“先行否定斷言”中，括號裏的部分是不會返回的。

var m = 'abd'.match(/b(?!c)/);
m // ['b']

上面的代碼使用了先行否定斷言，b不在c前面所以被匹配，而且括號對應的d不會被返回。

參考：阮一峯《JavaScript教程》

現在嚴格上是11個，不含"{" ↩︎

深入理解ES5系列之標準庫-正則表達式對象

目錄

2 標準庫

2.1 正則表達式對象（RegExp對象）

2.1.1 表示方法

2.1.2 實例屬性

2.1.3 實例方法

2.1.3.1 RegExp.prototype.test()

2.1.3.2 RegExp.prototype.exec()

2.1.4 字符串的實例方法

2.1.4.1 String.prototype.match()

2.1.4.2 String.prototype.search()

2.1.4.3 String.prototype.replace()

2.1.4.4 String.prototype.split()

2.1.5 匹配規則

2.1.5.1 字面量字符和元字符

2.1.5.2 轉義符

2.1.5.3 特殊字符

2.1.5.4 字符類

2.1.5.5 預定義模式

2.1.5.6 重複類

2.1.5.7 量詞符

2.1.5.8 貪婪模式

2.1.5.9 修飾符

2.1.5.10 組匹配

vue-cli 4.x版本生成的工程，SCSS樣式問題

vue2.X版本中filters訪問methods中的方法

瞭解node中的setImmediate()

win10下vue-cli3.x全局安裝失敗問題解決

深入理解ES5系列之標準庫-正則表達式對象

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結