Home

Appearance

正则表达式拓展 ​

构造函数修饰符优化 ​

ES5 与 ES6

javascript
var regex = new RegExp('xyz', 'i'); // 第一个参数是：字符串
var regex = new RegExp(/xyz/i); // 第一个参数是：正则表达
var regex = new RegExp(/xyz/, 'i'); // 第一个参数是：正则表达，添加第二个修饰符参数 ，报错 （ES5）
var regex = new RegExp(/abc/ig, 'i'); // 第一个参数是：正则表达，添加第二个修饰符参数，i 覆盖ig （ES6）
var regex = new RegExp('xyz', 'i'); // 第一个参数是：字符串
var regex = new RegExp(/xyz/i); // 第一个参数是：正则表达
var regex = new RegExp(/xyz/, 'i'); // 第一个参数是：正则表达，添加第二个修饰符参数 ，报错 （ES5）
var regex = new RegExp(/abc/ig, 'i'); // 第一个参数是：正则表达，添加第二个修饰符参数，i 覆盖ig （ES6）

u 修饰符 ​

ES6 对正则表达式添加了u修饰符，含义为“Unicode 模式”，用来正确处理大于\uFFFF的 Unicode 字符。也就是说，会正确处理四个字节的 UTF-16 编码。

点字符

javascript
var s = '𠮷';
/^.$/.test(s) // false
/^.$/u.test(s) // true
var s = '𠮷';
/^.$/.test(s) // false
/^.$/u.test(s) // true

上面示例中，点（.）字符在正则表达式中，含义是除了换行符以外的任意单个字符。'𠮷' 对于码点大于0xFFFF的 Unicode 字符，点字符不能识别到，所以第一个返回false，加了u修饰符能够匹配到所以返回true。

Unicode 字符表示法

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

上面代码表示，如果不加u修饰符，正则表达式无法识别\u{61}这种表示法，只会认为这匹配 61 个连续的u。

量词

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

使用u修饰符后，所有量词都会正确识别码点大于0xFFFF的 Unicode 字符。

预定义模式
u修饰符也影响到预定义模式，能否正确识别码点大于0xFFFF的 Unicode 字符。

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

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

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

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

上面代码中，不加u修饰符，就无法识别非规范的K字符。

转义
没有u修饰符的情况下，正则中没有定义的转义（如逗号的转义,）无效，而在u模式会报错。

javascript
/\,/ // /\,/
/\,/u // 报错
/\,/ // /\,/
/\,/u // 报错

上面代码中，没有u修饰符时，逗号前面的反斜杠是无效的，加了u修饰符就报错。

Unicode 属性类 ​

ES2018 引入了一种新的类的写法\p{...}和\P{...}，允许正则表达式匹配符合 Unicode 某种属性的所有字符。

\P{…} 是\p{…}的反向匹配，即匹配不满足条件的字符。 注意，这两种类只对 Unicode 有效，所以使用的时候一定要加上u修饰符。如果不加u修饰符，正则表达式使用\p和\P会报错，ECMAScript 预留了这两个类。

  • Unicode 属性类要指定属性名和属性值。
  • 对于某些属性，可以只写属性名，或者只写属性值。
\p{UnicodePropertyName=UnicodePropertyValue}
\p{UnicodePropertyName}
\p{UnicodePropertyValue}
\p{UnicodePropertyName=UnicodePropertyValue}
\p{UnicodePropertyName}
\p{UnicodePropertyValue}
javascript
const regexGreekSymbol = /\p{Script=Greek}/u; // 匹配一个希腊文字母
regexGreekSymbol.test('π') // true

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

const regexArrows = /^\p{Block=Arrows}+$/u; // 匹配所有的箭头字符
regexArrows.test('←↑→↓↔↕↖↗↘↙⇏⇐⇑⇒⇓⇔⇕⇖⇗⇘⇙⇧⇩') // true
const regexGreekSymbol = /\p{Script=Greek}/u; // 匹配一个希腊文字母
regexGreekSymbol.test('π') // true

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

const regexArrows = /^\p{Block=Arrows}+$/u; // 匹配所有的箭头字符
regexArrows.test('←↑→↓↔↕↖↗↘↙⇏⇐⇑⇒⇓⇔⇕⇖⇗⇘⇙⇧⇩') // true

具名组匹配 ​

正则表达式里面有三组圆括号。使用exec方法，就可以将这三组匹配结果提取出来。

javascript
const str = '1999-12-31';
const regExp = /(\d{4})-(\d{2})-(\d{2})/;
const date = regExp.exec(str);
const year = date[1];   // 1999
const month = date[2];  // 12
const day = date[3];    // 31
const str = '1999-12-31';
const regExp = /(\d{4})-(\d{2})-(\d{2})/;
const date = regExp.exec(str);
const year = date[1];   // 1999
const month = date[2];  // 12
const day = date[3];    // 31

组匹配的一个问题是，每一组的匹配含义不容易看出来，而且只能用数字序号（比如matchObj[1]）引用，要是组的顺序变了，引用的时候就必须修改序号。

ES2018 引入了具名组匹配（Named Capture Groups），允许为每一个组匹配指定一个名字，既便于阅读代码，又便于引用。

  • “具名组匹配”在圆括号内部，模式的头部添加“问号 + 尖括号 + 组名” --> （?<year>）。然后就可以在exec方法返回结果的groups属性上引用该组名。同时，数字序号（matchObj[1]）依然有效。
  • 具名组匹配等于为每一组匹配加上了 ID，便于描述匹配的目的。如果组的顺序变了，也不用改变匹配后的处理代码。
  • 如果具名组没有匹配，那么对应的groups对象属性会是undefined。键名在groups是始终存在的。
  • 如果要在正则表达式内部引用某个“具名组匹配”，可以使用\k<组名>的写法。
javascript
const str = '1999-12-31';
const regExp = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const date = regExp.exec(str);
const year = date.groups.year;    // 1999
const month = date.groups.month;  // 12
const day = date.groups.day;      // 31
const str = '1999-12-31';
const regExp = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const date = regExp.exec(str);
const year = date.groups.year;    // 1999
const month = date.groups.month;  // 12
const day = date.groups.day;      // 31

解构赋值和替换

javascript
let {groups: {one, two}} = /^(?<one>.*):(?<two>.*)$/u.exec('foo:bar');
one  // foo
two  // bar
let {groups: {one, two}} = /^(?<one>.*):(?<two>.*)$/u.exec('foo:bar');
one  // foo
two  // bar

具名组外部引用
字符串替换时，使用$<组名>引用具名组。

javascript
const str = '1999-12-31';
let regExp = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u;
str.replace(regExp,'$<year>年$<month>月$<day>日')
// str：1999年12月31日
const str = '1999-12-31';
let regExp = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u;
str.replace(regExp,'$<year>年$<month>月$<day>日')
// str：1999年12月31日

具名组内部引用
如果要在正则表达式内部引用某个“具名组匹配”，可以使用\k<组名>的写法。数字引用（\1）依然有效。

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

s 修饰符（dotAll 模式） ​

正则表达式中，点（.）是一个特殊字符，代表任意的单个字符，但是有两个例外。一个是四个字节的 UTF-16 字符，这个可以用u修饰符解决；另一个是行终止符 （以下四个）

U+000A 换行符（\n）
U+000D 回车符（\r）
U+2028 行分隔符（line separator）
U+2029 段分隔符（paragraph separator）

javascript
/foo.bar/.test('foo\nbar') // false 
// 上面代码中，因为.不匹配\n，所以正则表达式返回false。

/foo[^]bar/.test('foo\nbar') // true
// 很多时候我们希望匹配的是任意单个字符，这是一种变通的写法。（不太符合语义化）
/foo.bar/.test('foo\nbar') // false 
// 上面代码中，因为.不匹配\n，所以正则表达式返回false。

/foo[^]bar/.test('foo\nbar') // true
// 很多时候我们希望匹配的是任意单个字符，这是一种变通的写法。（不太符合语义化）

ES2018 引入s修饰符，使得.可以匹配任意单个字符。

  • 这被称为dotAll模式，即点（dot）代表一切字符。所以，正则表达式还引入了一个dotAll属性，返回一个布尔值，表示该正则表达式是否处在dotAll模式。
  • /s修饰符和多行修饰符/m不冲突，两者一起使用的情况下，.匹配所有字符，而^和$匹配每一行的行首和行尾。

后行断言 ​

JavaScript 语言的正则表达式，只支持先行断言（lookahead）和先行否定断言（negative lookahead），不支持后行断言（lookbehind）和后行否定断言（negative lookbehind）。ES2018 引入后行断言先行断言

  • 先行断言指的是，x只有在y前面才匹配，必须写成/x(?=y)/；
  • 先行否定断言指的是，x只有不在y前面才匹配，必须写成/x(?!y)/；
javascript
/\d+(?=%)/.exec('100% of US presidents have been male')  // ["100"]
/\d+(?!%)/.exec('that’s all 44 of them')                 // ["44"]
/\d+(?=%)/.exec('100% of US presidents have been male')  // ["100"]
/\d+(?!%)/.exec('that’s all 44 of them')                 // ["44"]

“先行断言” 括号之中的部分(?=%)，是不计入返回结果的。

后行断言

  • 后行断言指的是，x只有在y后面才匹配，必须写成/(?<=y)x/；
  • 后行否定断言指的是，x只有不在y后面才匹配，必须写成/(?<!y)x/；
javascript
/(?<=\$)\d+/.exec('Benjamin Franklin is on the $100 bill')  // ["100"]
/(?<!\$)\d+/.exec('it’s is worth about €90')                // ["90"]
/(?<=\$)\d+/.exec('Benjamin Franklin is on the $100 bill')  // ["100"]
/(?<!\$)\d+/.exec('it’s is worth about €90')                // ["90"]

“后行断言” 括号之中的部分(?<=\$)，也是不计入返回结果。

注意后行断言匹配步骤

“后行断言”的实现，需要先匹配/(?<=y)x/的x，然后再回到左边，匹配y的部分。这种“先右后左”的执行顺序，与所有其他正则操作相反，导致了一些不符合预期的行为。

  1. 首先，后行断言的组匹配，与正常情况下结果是不一样的。
javascript
/(?<=(\d+)(\d+))$/.exec('1053') // ["", "1", "053"]
/^(\d+)(\d+)$/.exec('1053') // ["1053", "105", "3"]
/(?<=(\d+)(\d+))$/.exec('1053') // ["", "1", "053"]
/^(\d+)(\d+)$/.exec('1053') // ["1053", "105", "3"]

上面代码中，需要捕捉两个组匹配。没有“后行断言”时，第一个括号是贪婪模式，第二个括号只能捕获一个字符，所以结果是105和3。而“后行断言”时，由于执行顺序是从右到左，第二个括号是贪婪模式，第一个括号只能捕获一个字符，所以结果是1和053。

  1. 其次，“后行断言”的反斜杠引用，也与通常的顺序相反，必须放在对应的那个括号之前。
javascript
/(?<=(o)d\1)r/.exec('hodor')  // null
/(?<=\1d(o))r/.exec('hodor')  // ["r", "o"]
/(?<=(o)d\1)r/.exec('hodor')  // null
/(?<=\1d(o))r/.exec('hodor')  // ["r", "o"]

上面代码中，如果后行断言的反斜杠引用（\1）放在括号的后面，就不会得到匹配结果，必须放在前面才可以。因为后行断言是先从左到右扫描，发现匹配以后再回过头，从右到左完成反斜杠引用。

正则匹配索引 ​

整理ing...

字符串的正则方法 ​

  • 字符串对象共有 4 个方法，可以使用正则表达式：match()、replace()、search()、split()。
  • 在语言内部全部调用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]

实例方法和属性 ​

  • String.prototype.matchAll()
  • RegExp.prototype.unicode：表示是否设置了u修饰符。
  • RegExp.prototype.sticky：表示是否设置了y修饰符。
  • RegExp.prototype.flags：会返回正则表达式的修饰符。