ES6学习之正则扩展

RegExp正则函数

var reg = new RegExp("abc","igm");
//等价于
var reg = new RegExp(/abc/igm);
//等价于
var reg = /abc/igm;

//ES5不允许但ES6允许
var reg = new RegExp(/xyz/igm, 'i');
//等价于
var reg = /abc/i;

U修饰符（用来处理码点大于FFFF的字符）

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

• 点字符(对于码点大于0xFFFF的 Unicode 字符，点字符不能识别，必须加上u修饰符)

var s = '𠮷';

/^.$/.test(s) // false
/^.$/u.test(s) // true

• Unicode 字符表示法(使用大括号表示 Unicode 字符时必须加上u修饰符，才能识别当中的大括号，否则会被解读为量词)

 

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

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

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

• 预定义模式(只有加了u修饰符，它才能正确匹配码点大于0xFFFF的 Unicode 字符)

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

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

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

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

y修饰符的作用与g修饰符类似，也是全局匹配。y修饰符确保匹配必须从剩余的第一个位置开始。y修饰符号隐含了头部匹配的标志^

var s = 'aaa_aa_a';
var r1 = /a+/g;
var r2 = /a+/y;

r1.exec(s) // ["aaa"]
r2.exec(s) // ["aaa"]

r1.exec(s) // ["aa"]
r2.exec(s) // null
/b/y.exec('aba')
// null

sticky 属性（是否设置了y修饰符）

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

flags属性（返回正则表达式的修饰符）

// ES5 的 source 属性
// 返回正则表达式的正文
/abc/ig.source
// "abc"

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

s修饰符--dotAll 模式（/s修饰符，使得.可以匹配任意单个字符）

const re = /foo.bar/s;

re.test('foo\nbar') // true
re.dotAll // true
re.flags // 's'

先行断言和后行断言

”先行断言“指的是，x只有在y前面才匹配，必须写成/x(?=y)/

”先行否定断言“指的是，x只有不在y前面才匹配，必须写成/x(?!y)/

“后行断言”正好与“先行断言”相反，x只有在y后面才匹配，必须写成/(?<=y)x/

”后行否定断言“则与”先行否定断言“相反，x只有不在y后面才匹配，必须写成/(?<!y)x/

// 先行
/\d+(?=%)/.exec('100% of US presidents have been male')  // ["100"]
/\d+(?!%)/.exec('that’s all 44 of them')                 // ["44"]
// 后行
/(?<=\$)\d+/.exec('Benjamin Franklin is on the $100 bill')  // ["100"]
/(?<!\$)\d+/.exec('it’s is worth about €90')                // ["90"]

Unicode 属性类（\p{...}和\P{...}，允许正则表达式匹配符合 Unicode 某种属性的所有字符，只对 Unicode 有效，所以使用的时候一定要加上u修饰符）

const regexGreekSymbol = /\p{Script=Greek}/u;
regexGreekSymbol.test('π') // true

具名组匹配

// 不具名组匹配
const RE_DATE = /(\d{4})-(\d{2})-(\d{2})/;
const matchObj = RE_DATE.exec('1999-12-31');
const year = matchObj[1]; // 1999
const month = matchObj[2]; // 12
const day = matchObj[3]; // 31
// 具名组匹配
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

解构赋值和替换（有了具名组匹配以后，可以使用解构赋值直接从匹配结果上为变量赋值。）

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

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

let re = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u;

'2015-01-02'.replace(re, '$<day>/$<month>/$<year>')
// '02/01/2015'

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

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