ECMA Script 6_RegExp 正则表达式

在 ES5 中

RegExp 构造函数的参数有两种状况

• RegExp(字符串, 正则表达式的修饰符)
• RegExp(正则表达式);

• var regex = new RegExp('xyz', 'i');
  
  // 等价于
  var regex = new RegExp(/xyz/i);    // 不能再有 第二参数修饰符，不然会报错 // 等价于
  var regex = /xyz/i;

• lastIndex 属性 指定每次搜索的开始位置，g 修饰符从这个位置开始向后搜索，直到发现匹配为止
  

• const REGEX = /a/g;
  
  REGEX.lastIndex = 2;    // 指定从2号位置（y）开始匹配
  const match = REGEX.exec('xaya');    // 匹配成功
  match.index;     // 3    // 在3号位置匹配成功
  
  
  REGEX.lastIndex;    // 4    // 下一次匹配从4号位开始
  REGEX.exec('xaya');    // null    // 4号位开始匹配失败

在 ES6 中

若是 RegExp 构造函数第一个参数是一个正则对象，那么仍是可使用第二个参数指定修饰符。

并且，返回的正则表达式会忽略原有的正则表达式的修饰符，只使用新指定的修饰符

• new RegExp(/abc/ig, 'i').flags // "i" 而不是 'ig'

• 字符串的正则方法

字符串对象共有 4 个方法，可使用正则表达式：match()、replace()、search() 和 split()

ES6 将这 4 个方法，在语言内部所有调用 RegExp 的实例方法，从而作到全部与正则相关的方法，全都定义在 RegExp 对象上

• 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 编码

• /^\uD83D/u.test('\uD83D\uDC2A');    // false
  /^\uD83D/.test('\uD83D\uDC2A');    // true

• 必须加 u 修饰符 的状况
• ES6 新增了使用大括号表示 Unicode 字符，这种表示法在正则表达式中必须加上u修饰符，才能识别当中的大括号，不然会被解读为量词

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

• \S 是预约义模式，匹配全部非空白字符。只有加了u修饰符，它才能正确匹配码点大于0xFFFF的 Unicode 字符

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

利用这个特性，封装一个绝对正确地返回字符串长度的函数

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

• 正则实例对象新增 unicode 属性

表示是否设置了u修饰符

RegExp.prototype.unicode

• const r1 = /hello/;
  const r2 = /hello/u;
  
  r1.unicode;    // false
  r2.unicode;    // true

• y 修饰符——“粘连”（sticky）修饰符

做用与 g 修饰符相似，也是全局匹配，后一次匹配都从上一次匹配成功的下一个位置开始。

不一样之处在于，g 修饰符 只要 剩余位置中存在匹配 就可，

而 y 修饰符 确保匹配必须从剩余的第一个位置开始，这也就是“粘连”的涵义

• y 修饰符一样遵照 lastIndex 属性，可是要求必须在 lastIndex 指定的位置发现匹配

• const REGEX = /a/y;
  
  REGEX.lastIndex = 2;    // 指定从2号位置开始匹配
  REGEX.exec('xaya');    // null    不是粘连，匹配失败
  REGEX.lastIndex = 3;    // 指定从3号位置开始匹配
  
  const match = REGEX.exec('xaya');    // 3号位置是粘连，
  match.index;    // 3    匹配成功
  REGEX.lastIndex;    // 4

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

• /b/y.exec('aba');    // null    因为不能保证头部匹配 b，因此返回null
  
  const REGEX = /a/gy;
  'aaxa'.replace(REGEX, '-');    // '--xa'   最后一个由于不是出如今下一次匹配的头部，因此不会被替换a

• 单单一个y修饰符对 match 方法，只能返回第一个匹配，必须与 g 修饰符联用，才能返回全部匹配

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

• 应用

从字符串提取 token（词元），y 修饰符确保了匹配之间不会有漏掉的字符

• function tokenize(TOKEN_REGEX, str) {
      let result = [];
      let match;
      while (match = TOKEN_REGEX.exec(str)) {
          result.push(match[1]);
      };
      return result;
  };
  
  
  const TOKEN_Y = /\s*(\+|[0-9]+)\s*/y;
  const TOKEN_G  = /\s*(\+|[0-9]+)\s*/g;
  
  tokenize(TOKEN_Y, '3 + 4');    // [ '3', '+', '4' ]
  tokenize(TOKEN_G, '3 + 4');    // [ '3', '+', '4' ]
  
  // g修饰符会忽略非法字符，而 y 修饰符不会
  tokenize(TOKEN_Y, '3x + 4');    // [ '3', '+', '4' ]
  tokenize(TOKEN_G, '3x + 4');    // ['3']    不是咱们想要的现象

RegExp.prototype.sticky

是否设置了 y 修饰符

• var r = /hello\d/y;
  r.sticky;    // true    var r = /hello\d/y;
  r.sticky;    // true

• ES6 为正则表达式新增了 flags 属性，会返回正则表达式的修饰符

• // ES5 的 source 属性
  // 返回正则表达式的正文
  /abc/ig.source    // "abc"
  
  // ES6 的 flags 属性
  // 返回正则表达式的修饰符
  /abc/ig.flags    // 'gi'

• s 修饰

dotAll 模式，即 点（dot）表明一切字符。

s修饰符，使得 . 能够匹配任意单个字符

RegExp.prototype.dotAll

返回一个布尔值，表示该正则表达式是否处在dotAll模式

• const re = /foo.bar/s;
  
  // 另外一种写法
  // const re = new RegExp('foo.bar', 's');
  
  re.test('foo\nbar');     // true    正确地将 \n 识别了出来
   re.dotAll; // true
  re.flags;     // 's'

JavaScript 语言的正则表达式 断言

以前只支持

• 先行断言（lookahead）

x 只有在 y 前面才匹配，必须写成/x(?=y)/

好比，只匹配百分号以前的数字，要写成/\d+(?=%)/

• 先行否认断言（negative lookahead）

x 只有不在 y 前面才匹配，必须写成/x(?!y)/

好比，只匹配不在百分号以前的数字，要写成/\d+(?!%)/

• /\d+(?=%)/.exec('100% of US presidents have been male');    // ["100"]
  /\d+(?!%)/.exec('that’s all 44 of them');    // ["44"]

ES6 引入

• 后行断言（lookbehind）

x 只有在 y 后面才匹配，必须写成/(?<=y)x/

比如，只匹配美圆符号以后的数字，要写成/(?<=\$)\d+/

• 后行否认断言（negative lookbehind）

x 只有不在 y 后面才匹配，必须写成/(?<!y)x/

好比，只匹配不在美圆符号后面的数字，要写成/(?<!\$)\d+/

• /(?<=\$)\d+/.exec('Benjamin Franklin is on the $100 bill');    // ["100"]
  /(?<!\$)\d+/.exec('it’s is worth about €90');    // ["90"]

Unicode 属性类

 

\p{UnicodePropertyName=UnicodePropertyValue}

一种新的类的写法 \p{...} 和 \P{...}，容许正则表达式匹配符合 Unicode 某种属性的全部字符

这两种类只对 Unicode 有效，因此使用的时候必定要加上u修饰符。

若是不加u修饰符，正则表达式使用 \p 和 \P 会报错，ECMAScript 预留了这两个类

• 对于某些属性，能够只写属性名，或者只写属性值

• \p{UnicodePropertyName}
  \p{UnicodePropertyValue}

\P{…} 是 \p{…} 的反向匹配，即匹配不知足条件的字符

• 属性类指定匹配全部十进制字符，能够看到各类字型的十进制字符都会匹配成功
  

• const regex = /^\p{Decimal_Number}+$/u;
  regex.test('𝟏𝟐𝟑𝟜𝟝𝟞𝟩𝟪𝟫𝟬𝟭𝟮𝟯𝟺𝟻𝟼');    // true

• \p{Number} 甚至能匹配罗马数字

• // 匹配全部数字
  const regex = /^\p{Number}+$/u;
  regex.test('²³¹¼½¾');    // true
  regex.test('㉛㉜㉝');    // true
  regex.test('ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫ');    // true

• // 匹配全部空格 \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

具名组匹配（Named Capture Groups）

容许为每个组匹配指定一个名字，/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/

既便于阅读代码，又便于引用

• 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

同时，数字序号（matchObj[1]）依然有效

若是具名组没有匹配，那么对应的 groups 对象属性会是 undefined

具名组 as 没有找到匹配，那么 matchObj.groups.as 属性值就是 undefined，而且 as 这个键名在 groups 是始终存在的

• 若是要在正则表达式内部引用某个“具名组匹配”，可使用 \k<组名> 的写法

• const RE_TWICE = /^(?<word>[a-z]+)!\k<word>$/;
  RE_TWICE.test('abc!abc');    // true
  RE_TWICE.test('abc!ab');    // false

• 数字引用（\1）依然有效

• const RE_TWICE = /^(?<word>[a-z]+)!\1$/;
  RE_TWICE.test('abc!abc');    // true
  RE_TWICE.test('abc!ab');    // false

• 两种引用语法还能够同时使用

• const RE_TWICE = /^(?<word>[a-z]+)!\k<word>!\1$/;
  RE_TWICE.test('abc!abc!abc');    // true
  RE_TWICE.test('abc!abc!ab');    // false

String.prototype.matchAll()

能够一次性取出全部匹配。

不过，它返回的是一个遍历器（Iterator），而不是数组

相对于返回数组，返回遍历器的好处在于，若是匹配结果是一个很大的数组，那么遍历器比较节省资源

• 遍历器转为数组是很是简单的，使用 ...运算符 和 Array.from() 方法就能够了
  

• // 转为数组方法一
  [...string.matchAll(regex)]
  
  // 转为数组方法二
  Array.from(string.matchAll(regex));