迅速搞懂JavaScript正則表達式之方法

我們來看看JavaScript中都有哪些操做正則的方法。

RegExp

RegExp 是正則表達式的構造函數。

使用構造函數建立正則表達式有多種寫法：

new RegExp('abc');
// /abc/
new RegExp('abc', 'gi');
// /abc/gi
new RegExp(/abc/gi);
// /abc/gi
new RegExp(/abc/m, 'gi');
// /abc/gi

它接受兩個參數：第一個參數是匹配模式，能夠是字符串也能夠是正則表達式；第二個參數是修飾符。

若是第一個參數的正則表達式定義了修飾符，第二個參數又有值，則以第二個參數定義的修飾符爲準，這是ES2015的新特性。

使用構造函數通常用於須要動態構造正則表達式的場景，性能不如字面量寫法。

咱們來看看它的實例屬性：

• lastIndex屬性。它的做用是全局匹配時標記下一次匹配開始的位置，全局匹配的抓手就是它。
• source屬性。它的做用是存儲正則模式的主體。好比 /abc/gi 中的 abc 。
• 對應的修飾符屬性。目前有 global 、 ignoreCase 、 multiline 、 sticky 、 dotAll 、 unicode 屬性，返回布爾值代表是否開啓對應修飾符。
• flags屬性。返回全部的修飾符。

match

match 是String實例方法。

它的做用是根據參數返回匹配結果，取名match也是很是恰當了。

它接受一個正則表達式做爲惟一參數。

但是字符串也能夠做爲參數怎麼解釋？

'abc'.match('b');
// ["b", index: 1, input: "abc", groups: undefined]

這是由於match方法內部會隱式的調用 new RegExp()將其轉換成一個正則實例。

match方法的返回值能夠分爲三種狀況。

匹配失敗

沒什麼可說的，返回 null 。

非全局匹配

返回一個數組。

數組的第一項是匹配結果。若是不傳參則匹配結果爲空字符串。

'abc'.match();
// ["", index: 0, input: "abc", groups: undefined]

若是正則參數中有捕獲組，捕獲的結果在數組中從第二項開始依次排列。有捕獲組可是沒有捕獲內容則顯示 undefined 。

'@abc2018'.match(/@([a-z]+)([A-Z]+)?/);
// ["@abc", "abc", undefined, index: 0, input: "@abc2018", groups: undefined]

數組有一個 index 屬性，標明匹配結果在文本中的起始位置。

數組有一個 input 屬性，顯示源文本。

數組有一個 groups 屬性，它存儲的不是捕獲組的信息，而是捕獲命名的信息。

'@abc2018'.match(/@(?<lowerCase>[a-z]+)(?<upperCase>[A-Z]+)?/);
// ["@abc", "abc", undefined, index: 0, input: "@abc2018", groups: { lowerCase: "abc", upperCase: undefined }]

全局匹配

返回一個數組。

捕獲的若干結果在數組中依次排列。由於要返回全部匹配的結果，其餘的信息，包括捕獲組和若干屬性就沒法列出了。

'abc&mno&xyz'.match(/[a-z]+/g);
// ["abc", "mno", "xyz"]

replace

replace 是String實例方法。

它的做用是將給定字符串替換匹配結果，並返回新的替換後的文本。源文本不會改變。

它接受兩個參數。

第一個參數能夠是字符串或者正則表達式，它的做用是匹配。

參數是字符串和參數是正則表達式的區別在於：正則表達式的表達能力更強，並且能夠全局匹配。所以參數是字符串的話只能進行一次替換。

'abc-xyz-abc'.replace('abc', 'biu');
// "biu-xyz-abc"
'abc-xyz-abc'.replace(/abc/, 'biu');
// "biu-xyz-abc"
'abc-xyz-abc'.replace(/abc/g, 'biu');
// "biu-xyz-biu"

第二個參數能夠是字符串或者函數，它的做用是替換。

第二個參數是字符串

replace方法爲第二個參數是字符串的方式提供了一些特殊的變量，能知足通常需求。

{$1}biu`，replace內部邏輯會自動解析字符串，提取出變量。

'@abc-xyz-$abc'.replace(/([^-]+)abc/g, '$1biu');
// "@biu-xyz-$biu"

$& 表明匹配結果。

'@abc-xyz-$abc'.replace(/([^-]+)abc/g, '{$&}');
// <a href="mailto:{@abc}-xyz-{$abc}" target="_blank">{@abc}-xyz-{$abc}</a>

$`表明匹配結果左邊的文本。

'@abc-xyz-$abc'.replace(/([^-]+)abc/g, '{$`}');
// <a href="mailto:{}-xyz-{@abc-xyz-}" target="_blank">{}-xyz-{@abc-xyz-}</a>

$' 表明匹配結果右邊的文本。

'@abc-xyz-$abc'.replace(/([^-]+)abc/g, "{$'}");
// "{-xyz-$abc}-xyz-{}"

有些時候我要的是變量的符號自己，而不是它的變量值，怎麼辦？加一個 $ 轉義一下。

'@abc-xyz-$abc'.replace(/([^-]+)abc/g, '$$1biu');
// "$1biu-xyz-$1biu"
'@abc-xyz-$abc'.replace(/([^-]+)abc/g, '$biu');
// "$biu-xyz-$biu"
'@abc-xyz-$abc'.replace(/([^-]+)abc/g, '$$biu');
// "$biu-xyz-$biu"

在不會形成誤會的場景，一個  的效果都是一個  轉義了。

第二個參數是函數

字符串的變量畢竟只能引用，沒法操做。與之相對，函數的表達能力就強多了。

函數的返回值就是要替換的內容。函數若是沒有返回值，默認返回 undefined ，因此替換內容就是 undefined 。

函數的第一個參數，是匹配結果。

'abc-xyz-abc'.replace(/abc/g, (match) => `{${match}}`);
// "{abc}-xyz-{abc}"
'abc-xyz-abc'.replace(/abc/g, (match) => {});
// "undefined-xyz-undefined"

若是有捕獲組，函數的後順位參數與捕獲組一一對應。

'@abc3-xyz-$abc5'.replace(/([^-]+)abc(\d+)/g, (match, $1, $2) => `{${$1}${match}${$2}}`);
// <a href="mailto:{@@abc33}-xyz-{$$abc55}" target="_blank">{@@abc33}-xyz-{$$abc55}</a>

倒數第二個參數是匹配結果在文本中的位置。

'@abc-xyz-$abc'.replace(/([^-]+)abc/g, (match, $1, index) => `{${match}是位置是${index}}`);
// <a href="mailto:{@abc是位置是0}-xyz-{$abc是位置是9}" target="_blank">{@abc是位置是0}-xyz-{$abc是位置是9}</a>

倒數第一個參數是源文本。

'abc-xyz'.replace(/abc/g, (match, index, string) => `{{${match}}屬於{${string}}}`);
// "{{abc}屬於{abc-xyz}}-xyz"

replace方法最經常使用的地方是轉義HTML標籤。

'<p>hello regex</p>'.replace(/</g, '<').replace(/>/g, '>');
// "<p>hello regex</p>"

search

search 是String實例方法。

它的做用是找出首次匹配項的索引。它的功能較單一，性能也更好。

它接受一個正則表達式做爲惟一參數。與match同樣，若是傳入一個非正則表達式，它會調用 new RegExp() 將其轉換成一個正則實例。

'abc-xyz-abc'.search(/xyz/);
// 4
'abc-xyz-abc'.search(/xyz/g);
// 4
'abc-xyz-abc'.search(/mno/);
// -1
'abc-xyz-abc'.search();
// 0
'abc-xyz-abc'.search(/abc/);
// 0

由於只能返回首次匹配的位置，因此全局匹配對它無效。

若是匹配失敗，返回 -1 。

split

split 是String實例方法。

它的做用是根據傳入的分隔符切割源文本。它返回一個由被切割單元組成的數組。

它接受兩個參數。第一個參數能夠是字符串或者正則表達式，它是分隔符；第二個參數可選，限制返回數組的最大長度。

'abc-def_mno+xyz'.split();
// ["abc-def_mno+xyz"]
'abc-def_mno+xyz'.split('-_+');
// ["abc-def_mno+xyz"]
'abc-def_mno+xyz'.split('');
// ["a", "b", "c", "-", "d", "e", "f", "_", "m", "n", "o", "+", "x", "y", "z"]
'abc-def_mno+xyz'.split(/[-_+]/);
// ["abc", "def", "mno", "xyz"]
'abc-def_mno+xyz'.split(/[-_+]/g);
// ["abc", "def", "mno", "xyz"]
'abc-def_mno+xyz'.split(/[-_+]/, 3);
// ["abc", "def", "mno"]
'abc-def_mno+xyz'.split(/[-_+]/, 5);
// ["abc", "def", "mno", "xyz"]

若是第一個參數傳入的是空字符串，則會切割每個字符串。

另外，由於split方法中的正則是用來匹配分隔符，因此全局匹配沒有意義。

exec

exec 是RegExp實例方法。

它的做用是根據參數返回匹配結果，與字符串方法match類似。

/xyz/.exec('abc-xyz-abc');
// ["xyz", index: 4, input: "abc-xyz-abc", groups: undefined]
/mno/.exec('abc-xyz-abc');
// null
/xyz/.exec();
// null

小小的區別在於參數爲空的狀況：exec直接返回 null ；match返回一個空字符串數組。緣由也很好理解，有魚沒有網，最壞也就是沒有收成；有網沒有魚，那但是連奔頭都沒有了。

它們倆最大的區別在於全局匹配的場景。

全局匹配就意味着屢次匹配，RegExp實例有一個 lastIndex 屬性，每匹配一次，這個屬性就會更新爲下一次匹配開始的位置。exec就是根據這個屬性來實現全局匹配的。

const reg = /abc/g;
reg.lastIndex
// 0
reg.exec('abc-xyz-abc');
// ["abc", index: 0, input: "abc-xyz-abc", groups: undefined]
reg.lastIndex
// 3
reg.exec('abc-xyz-abc');
// ["abc", index: 8, input: "abc-xyz-abc", groups: undefined]
reg.lastIndex
// 11
reg.exec('abc-xyz-abc');
// null
reg.lastIndex
// 0
reg.exec('abc-xyz-abc');
// ["abc", index: 0, input: "abc-xyz-abc", groups: undefined]

若是有多個匹配結果，屢次執行就能得到全部的匹配結果。因此exec通常用在循環語句中。

有兩點須要特別注意：

由於 lastIndex 會不斷更新，最終又會歸於0，因此這個匹配過程是能夠無限重複的。
lastIndex 屬性是屬於正則實例的。只有同一個實例的 lastIndex 纔會不斷更新。
知道第二點意味着什麼嗎？

/abc/g.exec('abc-xyz-abc');
// ["abc", index: 0, input: "abc-xyz-abc", groups: undefined]
/abc/g.exec('abc-xyz-abc');
// ["abc", index: 0, input: "abc-xyz-abc", groups: undefined]
/abc/g.exec('abc-xyz-abc');
// ["abc", index: 0, input: "abc-xyz-abc", groups: undefined]
// ...

若是不把正則提取出來，得到它的引用，exec方法就一直在原地打轉，由於每次都是一個新的正則實例，每次 lastIndex 都要從0開始。

test

test 是RegExp實例方法。

它的做用是找出源文本是否有匹配項，與字符串方法search類似。多用於表單驗證中。

/abc/.test('abc-xyz-abc');
// true
/mno/.test('abc-xyz-abc');
// false
/abc/.test();
// false

test方法與search方法的區別主要體如今兩點：

lastIndex
const reg = /abc/g;
reg.lastIndex
// 0
reg.test('abc-xyz-abc');
// true
reg.lastIndex
// 3
歡迎加入全棧開發交流划水交流圈：582735936
面向划水1-3年前端人員
幫助突破划水瓶頸，提高思惟能力
reg.test('abc-xyz-abc');
// true
reg.lastIndex
// 11
reg.test('abc-xyz-abc');
// false
reg.lastIndex
// 0
reg.test('abc-xyz-abc');
// true

修改字符串方法的底層實現

咱們也看到了，一部分處理正則的方法定義在String實例上，一部分處理正則的方法定義在RegExp實例上。爲了將處理正則的方法所有統一到RegExp實例上，ES2015修改了部分字符串方法的底層實現。

具體來講，ES2015爲RegExp實例新增了四個方法，字符串方法 match 、 replace 、 search 、 split 內部調用已經改爲了相應的RegExp實例方法。

RegExp.prototype[Symbol.match]
RegExp.prototype[Symbol.replace]
RegExp.prototype[Symbol.search]
RegExp.prototype[Symbol.split]

Symbol.match 是什麼？ Symbol 是新增的一種基礎數據類型，它有11個內置的值，指向語言內部使用的方法。

RegExp.prototype[Symbol.match] 在使用上和 match 相比，調用者和參數翻轉一下就能夠了。

'abc-mno-xyz'.match(/mno/);
// ["mno", index: 4, input: "abc-mno-xyz", groups: undefined]
/mno/[Symbol.match]('abc-mno-xyz');
// ["mno", index: 4, input: "abc-mno-xyz", groups: undefined]