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));

 

posted @ 2018-12-15 17:14  耶梦加德  阅读(300)  评论(0)  编辑  收藏  举报