在 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));
扫一扫
1632
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
