前言： 请你熟悉基本的正则表达式之后再来看此文章

首先回一下正则的定义方法

• 正则的定义

	let regExp = new RegExp('xyz', 'i');// 等价于let regExp = /xyz/i;

如上，创建了一个正则构造函数，第一个参数是匹配的字符串，第二个参数为修饰符

还有一种是参数可以直接是正则表达式

	let regExp = new RegExp(/xyz/i);// 等价于let regExp = /xyz/i;

但是，这样写了之后，你的参数在es5中就不能写第二个参数了，否则报错。

es6恰巧完善了该写法、

	let regExp = new RegExp(/syz/igm, 'i')

此时前面的(igm)修饰符就会被第二个参数，(i)修饰符替换掉

• 字符串的正则方法

  match()、replace()、search()、split()

  这四个方法，都定义在正则对象上

   String.prototype.match 调用 RegExp.prototype[Symbol.match]String.prototype.replace 调用 RegExp.prototype[Symbol.replace]String.prototype.search 调用 RegExp.prototype[Symbol.search]String.prototype.split 调用 RegExp.prototype[Symbol.split]
  

• 新增的U修饰符

  含义就是unicode模式，用来处理大于/uFFFF的Unicode字符，会正确处理四个字节的Utf-16编码

	let str = '\uD83D\uDC2A';// 四个字节的utf-16let reg = /^\uD83D/u;let oldReg = /^\uD83D/;reg.test(str);// false; oldReg.test(str);// true;

es5中不支持四个字节的UTF-16，会识别为2个字符，导致不加u的正则匹配为true。
加了就会识别为一个字符，所以加了u修饰符的为false。

一旦加了u修饰符就会更改一些正则的行为

1. 点字符

   点（.）在正则中表示除了换行以外任意单个字符，对于码点大于0xFFFF点字符不能识别，必须加上u修饰符

	let s = '𠮷';/^./.test(s);// false/^./u.test(s);// true

2. unicode表示法

   es6新增大括号表示unicode字符，这种在正则中必须使用u修饰符，否则会被识别为量词

	/\u{61}/.test('a');// false/\u{61}/u.test('a');// true/\u{20BB7}/u.test('𠮷');// true

如果上面的u{61}不加u修饰符，程序就会认为这是匹配了61个连续的u

3. 量词

   使用u修饰符，程序都会识别大于0xFFFF的unicode编码

	/a{2}/.test('aa');// true/a{2}/u.test('aa');// true/𠮷{2}/.test('𠮷𠮷');// false/𠮷{2}/u..test('𠮷𠮷')；// true

a不大于0xFFFF，但𠮷大于，所以不使用u修饰符的时候会匹配不到2个

4. 预定义模式

   能否正确的识别大于UxFFFF的unicode字符。

	/^\S$/.test('𠮷');// false/^\S$/u.test('𠮷');// true

\S是预定义模式，只有加上u修饰符它才能正确的匹配大于UxFFFF的Unicode字符

利用这一点，可以写出一个正确返回字符串长度的函数。

	function codePointLength(text) {var result = text.match(/[\s\S]/gu);return result ? result.length : 0;}var s = '𠮷𠮷';s.length // 4codePointLength(s) // 2

5. i修饰符

   有些 Unicode 字符的编码不同，但是字型很相近，比如，\u004B与\u212A都是大写的K。

	/[a-z]/i.test('\u212A')// false/[a-z]/iu.test('\u212A')// true

上面的\u212A就是非规范的K,
不加u就无法识别非规范的k

6. 转义

   没有u修饰符的正则中（,）的转义会失效,在u模式会报错

	/\,/// /\,//\,/u// error

没有u是,是无效的，加上u会报错

• RegExp.prototype.unicode属性

  正则实例对象新增的属性，表示当前实例是否设置了u修饰符

	let r1 = /hello/;let r2 = /hello/u;r1.unicode;// falser2.unicode;// true

• Y修饰符

  y修饰符和g修饰符的作用是一样的，都是全局匹配。
  但是y修饰符属于链贴性，g每次匹配只要剩余部分有符合的就可以。
  但y每次匹配都是从剩余的第一个位置开始，如果匹配不到就会返回null

	let str = 'aaa_aa_a';let r1 = /a+/g;let r2 = /a+/y;r1.exac(str);// ['aaa']r2.exac(str);// ['aaa']r1.exac(str);// ['aa'];r2.exac(str);// null

上面代码都是用了全局修饰符，一共匹配的两次。
但是y和g有一点区别
第一次匹配都可以匹配到aaa，但是第二次的时候。
g修饰符只要能匹配到就可以不会管位置在哪，所以可以匹配到aa，
但是y修饰符是从剩余第一个开始，所以匹配的其实是_aa
结果匹配不到a+，所以返回null

可以手动更改，来达到可以每次都能匹配后成功

	let str = 'aaa_aa_a';let r1 = /a+_/y;r1.exac(str);// ['aaa_']r1.exac(str);// ['aa_']

y修饰符隐含了头部匹配(^)

	/b/y.test('abc');// null

y修饰符本意就是让头部匹配的标志在全局匹配中都有效

在使用y修饰符时，再使用replace方法。

	let reg = /a/y;'aaxa'.repleace(reg, '-');// --xa// 最后一个a没有被替换，原因就是y的匹配机制导致的a没有被替换掉。

match方法

	'a1a2a3'.match(/a\d/y);// ['a1']'a1a2a3'.match(/a\d/gy);// ['a1', 'a2', 'a3']

由于y修饰符使用match方式的同时，只能返回第一个匹配，所以要搭配g修饰符一起使用

• RegExp.prototype.sticky属性

实例是否设置y修饰符

	let r = /hello/y;r.sticky// true

• RegExp.prototype.flags属性

  返回当前实例正在使用的修饰符

	let r = /hello/igy;r.flags// igy

• s修饰符

  正则表达式中，点（.）是一个特殊字符，代表任意的单个字符，但是有两个例外。

  一个是四个字节的 UTF-16 字符，这个可以用u修饰符解决；另一个是行终止符（line terminator character）。

  所谓行终止符，就是该字符表示一行的终结。以下四个字符属于“行终止符”。

  U + 000A 换行符 \n
  U + 000D 回车符 \r
  U + 2028 行分隔符
  U + 2029 段分隔符

	/foo.bar/.test('foo\nbar')// false

但是(.)不匹配\n，所以返回false

有一种机制可以解决

	/foo[^]bar/.test('foo\nbar');// true

但这样并不直管，这时s修饰符就诞生了！
es2018引入s修饰符，使其可以匹配任意单个字符

	/foo.bar/s.test('foo\nbar')// true

这被称为dotAll模式，即点（dot）代表一切字符，所以，正则表达式还引入一个dotAll属性，返回一个布尔值，检测是否处于dotAll模式

	let r = /foo.bar/s;// 另一种写发let regExp = new RegExp(/foo.bar/, 's');r.test('foo\nbar');// truer.dotAll// truer.flags// s

s修饰符，与m修饰符不冲突，两者一起使用，点（.）匹配所有字符,而^和$匹配每一行的行首和行尾

• 后行断言

  JavaScript 语言的正则表达式，只支持先行断言（lookahead）和先行否定断言（negative lookahead)

  不支持后行断言（lookbehind）和后行否定断言（negative lookbehind）。

  “先行断言”指的是，x只有在y前面才匹配，必须写成/x(?=y)/。比如，只匹配百分号之前的数字，要写成/\d+(?=%)/。

  “先行否定断言”指的是，x只有不在y前面才匹配，必须写成/x(?!y)/。比如，只匹配不在百分号之前的数字，要写成/\d+(?!%)/。

  下面写一个例子来验证

	let reg = /\d+(?=%)/;// 只匹配%前面的数字let reg = /\d+(?!%)/;// 只匹配%之后的数字reg.test('1000% and %2000');// 1000reg.test('2000% and %5000');// 5000

先行断言中的(?=%和?!%)部分不会计入到返回结果

“后行断言”正好与“先行断言”相反，x只有在y后面才匹配，必须写成/(?<=y)x/。比如，只匹配美元符号之后的数字，要写成/(?<=$)\d+/。

“后行否定断言”则与“先行否定断言”相反，x只有不在y后面才匹配，必须写成/(?<!y)x/。比如，只匹配不在美元符号后面的数字，要写成/(?<!$)\d+/。

下面写一个例子简述一下

	let r1 = /(?<=\$)\d+/;let r2 = /(?<!\$)\d+/;r1.exec('welcome to beijing tiananmen doar $100');// 100r2.exec('Are you ready,about 200$');// 200

后行断言的表达式也是不计入的

	let reg = /(?<=\$)foo/g;'$foo, %foo, foo'.replace(reg, 'bar');// $bar, %foo, foo

只有$后面跟foo的才能匹配到

“后行断言”的实现，需要先匹配/(?<=y)x/的x，然后再回到左边，匹配y的部分。

这种“先右后左”的执行顺序，与所有其他正则操作相反，导致了一些不符合预期的行为。

首先，后行断言的组匹配，与正常情况下结果是不一样的。

	/(?<=(\d+)(\d+))$/.exec('1053');// ['', '1', '053']

上面代码中进行了两组匹配，没有后行断言时，第一个括号是贪婪模式，所以会不配105，第二个只能捕获一个字符。

但此时是后行断言，所以从右向左的顺序匹配第二个括号是贪婪模式，而第一个只能匹配单个字符，所以是1和053

• 具名组匹配

  使用圆括号进行组匹配

let reg = /(\d{4})-(\d{2})-(\d{2})/;let match = reg.exec('2019-12-31');// ['2019', '12', '31']let year = match[1];let month = match[2];let day = match[3];

这种并不好，一旦数组顺序发生变化，引用时还需要修改序号

此时就具名组匹配就配上了用场

	let reg = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/let match = reg.exec('2020-5-18');let year = match.groups.year;let month = match.groups.month;let day = match.groups.day;

上面代码中具名组匹配在圆括号中，模式的头部问号，尖括号，组名 ?, 然后就可以在exec方法返回结果的groups属性上引用改组名。每一个组名都是键值。

这种方法好用，并且有标记，而且还可以使用数组索引的方式match[i]

如果具名组没有匹配，那么对应的groups对象属性会是undefined,但键名依然存在

	let reg = /^(?<name>s+)?$/;let match = reg.exec('');match.groups.name// undefined'name' in match.groups// true

• 正则匹配索引

  在以前的版本匹配正则的开始位置和结束位置并不是很方便
  正则中exec()方法，放回结果有一个index属性，可以获得整个匹配结果的开始位置，但是遇到组匹配开始位置就很难拿到。

  现在有一个提案，在exec()方法的返回结果上加入in
  dices属性，此属性可以匹配到开始位置和结束位置

	let str = 'cabcccc';let reg = /ab/;let exec = reg.exec(str);// exec.index// 1// exec.indices// [1, 3]

上面代码拿到了匹配后的结果exec, 使用exec()方法的index只能拿到开始位置，也就是索引的第一位，（a）。

使用了exec()方法的indices属性后，会匹配开始及结束位置，indices属性返回的是一个数组，由于改实例没有组匹配，所以只返回一个数组，即数组的开始位置和数组的结束位置对应的就是a和c.

a代表着开始匹配的位置，c代表结束匹配的位置，匹配成功的是ab，

注意： 结束位置不包含匹配结果之中

如果包含多个组匹配，那么就会形成多个数组

	let str = 'cabccbde';let reg = /ab+(cb)/;let exec = reg.exec(str);exec.indices // [[1, 6], [4, 6]]

因为有了组匹配所以会形成一个二维数组，包含多个匹配结果。
首先第一个成员是（abccb）结果就是索引1 - 6
第二个成员是组匹配（cb）结果就是索引4 - 6

下面是一个包含多个匹配的例子

	let str = 'cabccedad';let reg = /ab+(ed(ad))/;let exec = reg.exec(str);exec.indices// [[1, 9], [5, 9], [7, 9]]

上面第一次匹配（abccedad）索引位 1 - 9 形成一个数组
第二次匹配（edad）索引5 - 9 形成一个数组
第三次匹配（ad）索引7 - 9 形成一个数组

如果正则包含具名组匹配，indices属性数组还有一个groups属性，该属性是一个对象。

用来表示具名组的开始结束位置

	let str = 'cabeedcs';let reg = /ab+(?<name>dc)/;let exec = reg.exec(str);exec.indices.groups// 表示该实例的具名组匹配开始结束位置// {name: [5, 7]}

indice.groups设计为一个对象，可以很好的利用key来找到对应的具名组匹配信息，作者强的一批

如果匹配不成功，indices数组为undefined，groups也为undefined

	let str = 'cabedc';let reg = /ab+(?<name>cd)/;let exec = reg.exec(str);exec.indices[1] // undefinedexec.indices.grops // undefined

此功能还在提案，仅供此时参考！

• String.prototype.matchAll()

  如果正则要匹配一段字符串里多个规则，需要用到y和g

	let reg = /t(e)(st(\d?)/g;let str = 'test1test2test3';let arr = [];let match;for (match = reg.exec(str)) {arr.push(match)}arr/*[['test', 'e', 'st1', '1', index: 0, input: 'test1test2test3', groups: undefined],['test', 'e', 'st2', '2', index: 5, input: 'test1test2test3', groups: undefined],['test', 'e', 'st3', '3', index: 10, input: 'test1test2test3', groups: undefined]]*/

上面采用while循环逐一匹配

String.prototype.matchAll()方法一次性取出所有匹配
他返回的就是一个Iterator遍历器对象

	let str = 'test1test2test3';let reg = /t(e)(st(\d?))/;for (let value of str.matchAll(reg)) {console.log(value);}// ["test1", "e", "st1", "1", index: 0, input: "test1test2test3"]// ["test2", "e", "st2", "2", index: 5, input: "test1test2test3"]// ["test3", "e", "st3", "3", index: 10, input: "test1test2test3"]

由于matchAll(), 返回的就是一个遍历器对象，所以可以使用for循环

然后再把这个遍历器转为数组，只要使用扩展运算符(…)或者Array.form()就可以

	// 方法一[...string.matchAll(RegExp)];// 方法二Array.from(string.matchAll(RegExp))

看完对你有帮助，我就算有收获！