ES6 正则表达式

·  阅读 1689

1. 正则修饰符

修饰符是影响正则表达式规则的特殊符号,会对匹配的结果产生不同的效果, 正则表达式中包含三个修饰符:

i(intensity):大小写不敏感
g(global):全局查找,对于一些特定的函数,将迭代完整的字符串,获得所有的匹配结果,而不仅仅在得到第一个匹配后就停止进行
m(multiple):检测字符串中的换行符,主要是影响字符串开始标识符^和结束标识符$的使用
u(unicode): ES6添加,用来正确处理大于\uFFFF的Unicode字符。也就是说,会正确处理四个字节的UTF-16编码
y(sticky): ES6添加,与g修饰符类似,也是全局匹配,后一次匹配都从上一次匹配成功的下一个位置开始。不同之处在于,g修饰符只要剩余位置中存在匹配就可,而y修饰符确保匹配必须从剩余的第一个位置开始,这也就是“粘连”的涵义。
复制代码

i修饰符

let s1 = 'Hello';
let s2 = 'hello';
let p1 = /Hello/;
let p2 = /Hello/i;

p1.test(s1); //true
p1.test(s2); //false
p2.test(s1); //true
p2.test(s2); //true
复制代码

g修饰符

let p1 = /hello/;
let p2 = /hello/g;
let str = 'hello world, hello world';

str.match(p1); // ['hello']
str.match(p2); // ['hello', 'hello']
复制代码

m修饰符

let str = 'hello world,\nhello world';
let p1 = /^hello/g;
let p2 = /^hello/gm;

str.match(p1); //['hello']
str.match(p2); //['hello', 'hello']
复制代码

u修饰符:处理超出\uFFFF的4字节字符,能正确识别

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

复制代码

u修饰符与点字符:正则中的点字符用来匹配换行符以外的任意字符,但是对于超过\uFFFF的字符,点字符不能正确识别,此时可以带u修饰符用以修正。

let s = '𠮷';

/^.$/.test(s) // false
/^.$/u.test(s) // true
复制代码

u修饰符Unicode字符表示法:ES6新增了使用大括号表示Unicode字符,这种表示法在正则表达式中必须加上u修饰符,才能识别。

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

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

/a{2}/.test('aa') // true
/a{2}/u.test('aa') // true
/𠮷{2}/.test('𠮷𠮷') // false
/𠮷{2}/u.test('𠮷𠮷') // true
复制代码

u修饰符的情况下,Unicode表达式当中的大括号才会被正确解读,否则会被解读为量词。

/^\u{3}$/.test('uuu') // true
复制代码

u修饰符预定义符:能否正确识别码点大于0xFFFF的Unicode字符。

/^\S$/.test('𠮷') // false
/^\S$/u.test('𠮷') // true
复制代码

利用这一点,可以写出一个正确返回字符串长度的函数。

function codePointLength(text) {
  var result = text.match(/[\s\S]/gu);
  return result ? result.length : 0;
}

var s = '𠮷𠮷';

s.length // 4
codePointLength(s) // 2
复制代码

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
复制代码

上面代码有两个正则表达式,一个使用g修饰符,另一个使用y修饰符。这两个正则表达式各执行了两次,第一次执行的时候,两者行为相同,剩余字符串都是_aa_a。由于g修饰没有位置要求,所以第二次执行会返回结果,而y修饰符要求匹配必须从头部开始,所以返回null。

如果改一下正则表达式,保证每次都能头部匹配,y修饰符就会返回结果了。

var s = 'aaa_aa_a';
var r = /a+_/y;

r.exec(s) // ["aaa_"]
r.exec(s) // ["aa_"]
复制代码

进一步说,y修饰符号隐含了头部匹配的标志^,y修饰符的设计本意,就是让头部匹配的标志^在全局匹配中都有效。

/b/y.exec('aba')
// null

'x##'.split(/#/y)
// [ 'x##' ]

'##x'.split(/#/y)
// [ '', '', 'x' ]

'#x#'.split(/#/y)
// [ '', 'x#' ]

'##'.split(/#/y)
// [ '', '', '' ]
复制代码

下面是字符串对象的replace方法的例子。

const REGEX = /a/gy;
'aaxa'.replace(REGEX, '-') // '--xa'
复制代码
'a1a2a3'.match(/a\d/y) // ["a1"]
'a1a2a3'.match(/a\d/gy) // ["a1", "a2", "a3"]
复制代码

y修饰符的一个应用,是从字符串提取token(词元),y修饰符确保了匹配之间不会有漏掉的字符。

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' ]

function tokenize(TOKEN_REGEX, str) {
  let result = [];
  let match;
  while (match = TOKEN_REGEX.exec(str)) {
    result.push(match[1]);
  }
  return result;
}
复制代码

上面代码中,如果字符串里面没有非法字符,y修饰符与g修饰符的提取结果是一样的。但是,一旦出现非法字符,两者的行为就不一样了。g修饰符会忽略非法字符,而y修饰符不会,这样就很容易发现错误。

tokenize(TOKEN_Y, '3x + 4')
// [ '3' ]
tokenize(TOKEN_G, '3x + 4')
// [ '3', '+', '4' ]
复制代码

2. flags属性

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

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

// ES6的flags属性
// 返回正则表达式的修饰符
/abc/ig.flags
// 'gi'
复制代码
分类:
前端
分类:
前端