源自：https://es6.ruanyifeng.com/
RegExp 構(gòu)造函數(shù)
在 ES5 中，RegExp構(gòu)造函數(shù)的參數(shù)有兩種情況。
第一種情況是，參數(shù)是字符串，這時(shí)第二個(gè)參數(shù)表示正則表達(dá)式的修飾符（flag）。
var regex = new RegExp('xyz', 'i');
// 等價(jià)于
var regex = /xyz/i;
第二種情況是，參數(shù)是一個(gè)正則表示式，這時(shí)會(huì)返回一個(gè)原有正則表達(dá)式的拷貝。
var regex = new RegExp(/xyz/i);
// 等價(jià)于
var regex = /xyz/i;
但是，ES5 不允許此時(shí)使用第二個(gè)參數(shù)添加修飾符，否則會(huì)報(bào)錯(cuò)。
var regex = new RegExp(/xyz/, 'i');
// Uncaught TypeError: Cannot supply flags when constructing one RegExp from another
ES6 改變了這種行為。如果RegExp構(gòu)造函數(shù)第一個(gè)參數(shù)是一個(gè)正則對(duì)象，那么可以使用第二個(gè)參數(shù)指定修飾符。而且，返回的正則表達(dá)式會(huì)忽略原有的正則表達(dá)式的修飾符，只使用新指定的修飾符。
new RegExp(/abc/ig, 'i').flags
// "i"
上面代碼中，原有正則對(duì)象的修飾符是ig，它會(huì)被第二個(gè)參數(shù)i覆蓋。
字符串的正則方法
字符串對(duì)象共有 4 個(gè)方法，可以使用正則表達(dá)式：match()、replace()、search()和split()。
ES6 將這 4 個(gè)方法，在語言內(nèi)部全部調(diào)用RegExp的實(shí)例方法，從而做到所有與正則相關(guān)的方法，全都定義在RegExp對(duì)象上。
u 修飾符
ES6 對(duì)正則表達(dá)式添加了u修飾符，含義為“Unicode 模式”，用來正確處理大于\uFFFF的 Unicode 字符。也就是說，會(huì)正確處理四個(gè)字節(jié)的 UTF-16 編碼。
/^\uD83D/u.test('\uD83D\uDC2A') // false
/^\uD83D/.test('\uD83D\uDC2A') // true
上面代碼中，\uD83D\uDC2A是一個(gè)四個(gè)字節(jié)的 UTF-16 編碼，代表一個(gè)字符。但是，ES5 不支持四個(gè)字節(jié)的 UTF-16 編碼，會(huì)將其識(shí)別為兩個(gè)字符，導(dǎo)致第二行代碼結(jié)果為true。加了u修飾符以后，ES6 就會(huì)識(shí)別其為一個(gè)字符，所以第一行代碼結(jié)果為false。
一旦加上u修飾符號(hào)，就會(huì)修改下面這些正則表達(dá)式的行為。
（1）點(diǎn)字符
點(diǎn)（.）字符在正則表達(dá)式中，含義是除了換行符以外的任意單個(gè)字符。對(duì)于碼點(diǎn)大于0xFFFF的 Unicode 字符，點(diǎn)字符不能識(shí)別，必須加上u修飾符。
var s = '??';
/^.$/.test(s) // false
/^.$/u.test(s) // true
上面代碼表示，如果不添加u修飾符，正則表達(dá)式就會(huì)認(rèn)為字符串為兩個(gè)字符，從而匹配失敗。
（2）Unicode 字符表示法
ES6 新增了使用大括號(hào)表示 Unicode 字符，這種表示法在正則表達(dá)式中必須加上u修飾符，才能識(shí)別當(dāng)中的大括號(hào)，否則會(huì)被解讀為量詞。
/\u{61}/.test('a') // false
/\u{61}/u.test('a') // true
/\u{20BB7}/u.test('??') // true
上面代碼表示，如果不加u修飾符，正則表達(dá)式無法識(shí)別\u{61}這種表示法，只會(huì)認(rèn)為這匹配 61 個(gè)連續(xù)的u。
（3）量詞
使用u修飾符后，所有量詞都會(huì)正確識(shí)別碼點(diǎn)大于0xFFFF的 Unicode 字符。
/a{2}/.test('aa') // true
/a{2}/u.test('aa') // true
/??{2}/.test('????') // false
/??{2}/u.test('????') // true
（4）預(yù)定義模式
u修飾符也影響到預(yù)定義模式，能否正確識(shí)別碼點(diǎn)大于0xFFFF的 Unicode 字符。
/^\S$/.test('??') // false
/^\S$/u.test('??') // true
上面代碼的\S是預(yù)定義模式，匹配所有非空白字符。只有加了u修飾符，它才能正確匹配碼點(diǎn)大于0xFFFF的 Unicode 字符。
利用這一點(diǎn)，可以寫出一個(gè)正確返回字符串長度的函數(shù)。
function codePointLength(text) {
var result = text.match(/[\s\S]/gu);
return result ? result.length : 0;
}
var s = '????';
s.length // 4
codePointLength(s) // 2
（5）i 修飾符
有些 Unicode 字符的編碼不同，但是字型很相近，比如，\u004B與\u212A都是大寫的K。
/[a-z]/i.test('\u212A') // false
/[a-z]/iu.test('\u212A') // true
上面代碼中，不加u修飾符，就無法識(shí)別非規(guī)范的K字符。
（6）轉(zhuǎn)義
沒有u修飾符的情況下，正則中沒有定義的轉(zhuǎn)義（如逗號(hào)的轉(zhuǎn)義\,）無效，而在u模式會(huì)報(bào)錯(cuò)。
/\,/ // /\,/
/\,/u // 報(bào)錯(cuò)
上面代碼中，沒有u修飾符時(shí)，逗號(hào)前面的反斜杠是無效的，加了u修飾符就報(bào)錯(cuò)。
RegExp.prototype.unicode 屬性
正則實(shí)例對(duì)象新增unicode屬性，表示是否設(shè)置了u修飾符。
const r1 = /hello/;
const r2 = /hello/u;
r1.unicode // false
r2.unicode // true
上面代碼中，正則表達(dá)式是否設(shè)置了u修飾符，可以從unicode屬性看出來。
y 修飾符
除了u修飾符，ES6 還為正則表達(dá)式添加了y修飾符，叫做“粘連”（sticky）修飾符。
y修飾符的作用與g修飾符類似，也是全局匹配，后一次匹配都從上一次匹配成功的下一個(gè)位置開始。不同之處在于，g修飾符只要剩余位置中存在匹配就可，而y修飾符確保匹配必須從剩余的第一個(gè)位置開始，這也就是“粘連”的涵義。
使用lastIndex屬性，可以更好地說明y修飾符。
const REGEX = /a/g;
// 指定從2號(hào)位置（y）開始匹配
REGEX.lastIndex = 2;
// 匹配成功
const match = REGEX.exec('xaya');
// 在3號(hào)位置匹配成功
match.index // 3
// 下一次匹配從4號(hào)位開始
REGEX.lastIndex // 4
// 4號(hào)位開始匹配失敗
REGEX.exec('xaya') // null
上面代碼中，lastIndex屬性指定每次搜索的開始位置，g修飾符從這個(gè)位置開始向后搜索，直到發(fā)現(xiàn)匹配為止。
下面是字符串對(duì)象的replace方法的例子。
const REGEX = /a/gy;
'aaxa'.replace(REGEX, '-') // '--xa'
上面代碼中，最后一個(gè)a因?yàn)椴皇浅霈F(xiàn)在下一次匹配的頭部，所以不會(huì)被替換。
單單一個(gè)y修飾符對(duì)match方法，只能返回第一個(gè)匹配，必須與g修飾符聯(lián)用，才能返回所有匹配。
'a1a2a3'.match(/a\d/y) // ["a1"]
'a1a2a3'.match(/a\d/gy) // ["a1", "a2", "a3"]
RegExp.prototype.sticky 屬性
與y修飾符相匹配，ES6 的正則實(shí)例對(duì)象多了sticky屬性，表示是否設(shè)置了y修飾符。
var r = /hello\d/y;
r.sticky // true
RegExp.prototype.flags 屬性
ES6 為正則表達(dá)式新增了flags屬性，會(huì)返回正則表達(dá)式的修飾符。
// ES5 的 source 屬性
// 返回正則表達(dá)式的正文
/abc/ig.source
// "abc"
// ES6 的 flags 屬性
// 返回正則表達(dá)式的修飾符
/abc/ig.flags
// 'gi'
s 修飾符：dotAll 模式
正則表達(dá)式中，點(diǎn)（.）是一個(gè)特殊字符，代表任意的單個(gè)字符，但是有兩個(gè)例外。一個(gè)是四個(gè)字節(jié)的 UTF-16 字符，這個(gè)可以用u修飾符解決；另一個(gè)是行終止符（line terminator character）。
所謂行終止符，就是該字符表示一行的終結(jié)。以下四個(gè)字符屬于“行終止符”。
U+000A 換行符（
\n）U+000D 回車符（
\r）U+2028 行分隔符（line separator）
U+2029 段分隔符（paragraph separator）
后行斷言
JavaScript 語言的正則表達(dá)式，只支持先行斷言（lookahead）和先行否定斷言（negative lookahead），不支持后行斷言（lookbehind）和后行否定斷言（negative lookbehind）。ES2018 引入后行斷言，V8 引擎 4.9 版（Chrome 62）已經(jīng)支持。
“先行斷言”指的是，x只有在y前面才匹配，必須寫成/x(?=y)/。比如，只匹配百分號(hào)之前的數(shù)字，要寫成/\d+(?=%)/?！跋刃蟹穸〝嘌浴敝傅氖?，x只有不在y前面才匹配，必須寫成/x(?!y)/。比如，只匹配不在百分號(hào)之前的數(shù)字，要寫成/\d+(?!%)/。
“后行斷言”正好與“先行斷言”相反，x只有在y后面才匹配，必須寫成/(?<=y)x/。比如，只匹配美元符號(hào)之后的數(shù)字，要寫成/(?<=\$)\d+/?！昂笮蟹穸〝嘌浴眲t與“先行否定斷言”相反，x只有不在y后面才匹配，必須寫成/(?。比如，只匹配不在美元符號(hào)后面的數(shù)字，要寫成/(?。
“后行斷言”的實(shí)現(xiàn)，需要先匹配/(?<=y)x/的x，然后再回到左邊，匹配y的部分。這種“先右后左”的執(zhí)行順序，與所有其他正則操作相反，導(dǎo)致了一些不符合預(yù)期的行為。
Unicode 屬性類
ES2018 引入了一種新的類的寫法\p{...}和\P{...}，允許正則表達(dá)式匹配符合 Unicode 某種屬性的所有字符。
const regexGreekSymbol = /\p{Script=Greek}/u;
regexGreekSymbol.test('π') // true
上面代碼中，\p{Script=Greek}指定匹配一個(gè)希臘文字母，所以匹配π成功。
Unicode 屬性類要指定屬性名和屬性值。
\p{UnicodePropertyName=UnicodePropertyValue}
對(duì)于某些屬性，可以只寫屬性名，或者只寫屬性值。
\p{UnicodePropertyName}
\p{UnicodePropertyValue}
\P{…}是\p{…}的反向匹配，即匹配不滿足條件的字符。
由于 Unicode 的各種屬性非常多，所以這種新的類的表達(dá)能力非常強(qiáng)。
const regex = /^\p{Decimal_Number}+$/u;
regex.test('????????????????????????????????') // true
上面代碼中，屬性類指定匹配所有十進(jìn)制字符，可以看到各種字型的十進(jìn)制字符都會(huì)匹配成功。
其他例子：
// 匹配所有空格
\p{White_Space}
// 匹配各種文字的所有字母，等同于 Unicode 版的 \w
[\p{Alphabetic}\p{Mark}\p{Decimal_Number}\p{Connector_Punctuation}\p{Join_Control}]
// 匹配各種文字的所有非字母的字符，等同于 Unicode 版的 \W
[^\p{Alphabetic}\p{Mark}\p{Decimal_Number}\p{Connector_Punctuation}\p{Join_Control}]
// 匹配 Emoji
/\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F/gu
// 匹配所有的箭頭字符
const regexArrows = /^\p{Block=Arrows}+$/u;
regexArrows.test('←↑→↓??↖↗↘↙?????????????') // true
具名組匹配
正則表達(dá)式使用圓括號(hào)進(jìn)行組匹配。
const RE_DATE = /(\d{4})-(\d{2})-(\d{2})/;
上面代碼中，正則表達(dá)式里面有三組圓括號(hào)。使用exec方法，就可以將這三組匹配結(jié)果提取出來。
ES2018 引入了具名組匹配（Named Capture Groups），允許為每一個(gè)組匹配指定一個(gè)名字，既便于閱讀代碼，又便于引用。
const RE_DATE = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const matchObj = RE_DATE.exec('1999-12-31');
const year = matchObj.groups.year; // 1999
const month = matchObj.groups.month; // 12
const day = matchObj.groups.day; // 31
上面代碼中，“具名組匹配”在圓括號(hào)內(nèi)部，模式的頭部添加“問號(hào) + 尖括號(hào) + 組名”（?），然后就可以在exec方法返回結(jié)果的groups屬性上引用該組名。同時(shí)，數(shù)字序號(hào)（matchObj[1]）依然有效。
具名組匹配等于為每一組匹配加上了 ID，便于描述匹配的目的。如果組的順序變了，也不用改變匹配后的處理代碼。
如果具名組沒有匹配，那么對(duì)應(yīng)的groups對(duì)象屬性會(huì)是undefined。
解構(gòu)賦值和替換
有了具名組匹配以后，可以使用解構(gòu)賦值直接從匹配結(jié)果上為變量賦值。
let {groups: {one, two}} = /^(?<one>.*):(?<two>.*)$/u.exec('foo:bar');
one // foo
two // bar
字符串替換時(shí)，使用$<組名>引用具名組。
let re = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u;
'2015-01-02'.replace(re, '$<day>/$<month>/$<year>')
// '02/01/2015'
上面代碼中，replace方法的第二個(gè)參數(shù)是一個(gè)字符串，而不是正則表達(dá)式。
replace方法的第二個(gè)參數(shù)也可以是函數(shù)。
引用
如果要在正則表達(dá)式內(nèi)部引用某個(gè)“具名組匹配”，可以使用\k<組名>的寫法。
const RE_TWICE = /^(?<word>[a-z]+)!\k<word>$/;
RE_TWICE.test('abc!abc') // true
RE_TWICE.test('abc!ab') // false
數(shù)字引用（\1）依然有效。
const RE_TWICE = /^(?<word>[a-z]+)!\1$/;
RE_TWICE.test('abc!abc') // true
RE_TWICE.test('abc!ab') // false
這兩種引用語法還可以同時(shí)使用。
正則匹配索引
正則匹配結(jié)果的開始位置和結(jié)束位置，目前獲取并不是很方便。正則實(shí)例的exec()方法，返回結(jié)果有一個(gè)index屬性，可以獲取整個(gè)匹配結(jié)果的開始位置，但是如果包含組匹配，每個(gè)組匹配的開始位置，很難拿到。
現(xiàn)在有一個(gè)第三階段提案，為exec()方法的返回結(jié)果加上indices屬性，在這個(gè)屬性上面可以拿到匹配的開始位置和結(jié)束位置。
如果正則表達(dá)式包含組匹配，那么indices屬性對(duì)應(yīng)的數(shù)組就會(huì)包含多個(gè)成員，提供每個(gè)組匹配的開始位置和結(jié)束位置。
如果正則表達(dá)式包含具名組匹配，indices屬性數(shù)組還會(huì)有一個(gè)groups屬性。該屬性是一個(gè)對(duì)象，可以從該對(duì)象獲取具名組匹配的開始位置和結(jié)束位置。
如果獲取組匹配不成功，indices屬性數(shù)組的對(duì)應(yīng)成員則為undefined，indices.groups屬性對(duì)象的對(duì)應(yīng)成員也是undefined。
String.prototype.matchAll()
如果一個(gè)正則表達(dá)式在字符串里面有多個(gè)匹配，現(xiàn)在一般使用g修飾符或y修飾符，在循環(huán)里面逐一取出。
ES2020增加了String.prototype.matchAll()方法，可以一次性取出所有匹配。不過，它返回的是一個(gè)遍歷器（Iterator），而不是數(shù)組。
const string = 'test1test2test3';
const regex = /t(e)(st(\d?))/g;
for (const match of string.matchAll(regex)) {
console.log(match);
}
// ["test1", "e", "st1", "1", index: 0, input: "test1test2test3"]
// ["test2", "e", "st2", "2", index: 5, input: "test1test2test3"]
// ["test3", "e", "st3", "3", index: 10, input: "test1test2test3"]
上面代碼中，由于string.matchAll(regex)返回的是遍歷器，所以可以用for...of循環(huán)取出。相對(duì)于返回?cái)?shù)組，返回遍歷器的好處在于，如果匹配結(jié)果是一個(gè)很大的數(shù)組，那么遍歷器比較節(jié)省資源。
遍歷器轉(zhuǎn)為數(shù)組是非常簡單的，使用...運(yùn)算符和Array.from()方法就可以了。
// 轉(zhuǎn)為數(shù)組的方法一
[...string.matchAll(regex)]
// 轉(zhuǎn)為數(shù)組的方法二
Array.from(string.matchAll(regex))
