- y修饰符。
> ES6为正则表达式添加了y修饰符,叫做“粘连”(sticky)修饰符。
>> y修饰符的作用与g修饰符类似,也是全局匹配,后一次匹配都从上一次匹配成功的下一个位置开始。不同之处在于,g修饰符只要剩余位置中存在匹配就可,而y修饰符确保匹配必须从剩余的第一个位置开始,这也就是“粘连”的涵义。
>>> 其实y修饰符就是要求下一次匹配的lastIndex位置必须是对应匹配到的元素(粘连)。而g修饰符是lastIndex后拥有匹配到即可。
>>>> 进一步说, y修饰符号隐含了头部匹配的标志 ^ 。
- sticky 模式在正则匹配过程中只会影响两件事:
1. 匹配必须从 re.lastIndex 开始(相当于正则表达中的 ^)
2. 如果匹配到会修改 re.lastIndex(相当于 g 模式)
- u修饰符。
1. ES6新增了使用大括号表示Unicode字符,这种表示法在正则表达式中必须加上u修饰符,才能识别
2. 点(.)字符在正则表达式中,含义是除了换行符以外的任意单个字符。对于码点大于 0xFFFF 的 Unicode 字符,点字符不能识别,必须加上u修饰符。
3. 使用u修饰符后,所有量词都会正确识别码点大于0xFFFF的Unicode字符。
4. 预定义模式。
5. i修饰符。
> ES6为正则表达式添加了u修饰符,含义为“Unicode模式”,用来正确处理大于 \uFFFF 的Unicode字符。也就是说,会正确处理四个字节的UTF-16编码。
```
const s = 'aaa_aa_a'
复制代码
const r1 = /a+/g const 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修饰符就会返回结果了。
const s = 'aaa_aa_a' const r = /a+_/y
r.exec(s) // ["aaa_"] r.exec(s) // ["aa_"] // 上面代码每次匹配, 都是从剩余字符串的头部开始。
// 使用lastIndex属性, 可以更好地说明y修饰符。
const regexp = /a/g
// 指定从2号位置(y)开始匹配 regexp.lastIndex = 2
// 匹配成功 const match = regexp.exec('xaya')
// 在3号位置匹配成功 console.log(match.index) // 3
// 下一次匹配从4号位开始 console.log(regexp.lastIndex) // 4
// 4号位开始匹配失败 regexp.exec('xaxa') // null // 上面代码中, lastIndex属性指定每次搜索的开始位置, g修饰符从这个位置开始向后搜索, 直到发现匹配为止。
// y修饰符同样遵守lastIndex属性, 但是要求必须在lastIndex指定的位置发现匹配。
const regexp = /a/y
// 指定从2号位置开始匹配 regexp.lastIndex = 2
// 不是粘连,匹配失败 regexp.exec('xaya') // null
// 指定从3号位置开始匹配 regexp.lastIndex = 3
// 3号位置是粘连,匹配成功 const match = regexp.exec('xaxa') console.log(match.index) // 3 console.log(regexp.lastIndex) // 4 // 进一步说, y修饰符号隐含了头部匹配的标志 ^ 。
const reg = /b/y reg.exec('aba') // null // console.log(reg.lastIndex)
// u修饰符 // (1) 点字符
// 点(.)字符在正则表达式中,含义是除了换行符以外的任意单个字符。对于码点大于 0xFFFF 的 Unicode 字符,点字符不能识别,必须加上u修饰符。
let s = '𠮷'
/
^
.$ / .test(s) // false
/
^
.$ / u.test(s) // true
// 上面代码表示,如果不添加u修饰符,正则表达式就会认为字符串为两个字符,从而匹配失败。
// TIP
// '𠮷'这个字读 jí,是'吉'字的异形体,Unicode 码点 U+20BB7
// (2) Unicode字符表示法
// ES6新增了使用大括号表示Unicode字符,这种表示法在正则表达式中必须加上u修饰符,才能识别。
/
\u {
61
}
复制代码
/.test('a') / / false
/
\u {
61
}
复制代码
/u.test('a') / / true
/
\u {
20 BB7
}
复制代码
/u.test('𠮷') / / true // 上面代码表示,如果不加u修饰符,正则表达式无法识别\u{61}这种表示法,只会认为这匹配61个连续的u。
// (3) 量词
// 使用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修饰符,所以大括号被解读为量词。加上u修饰符,就会被解读为Unicode表达式。
/
\u {
20 BB7
} {
2
}
复制代码
/u.test('𠮷𠮷') / / true // 使用 u 修饰符之后 Unicode 表达式+量词也是可以的。
// (4) 预定义模式
// u修饰符也影响到预定义模式,能否正确识别码点大于0xFFFF的Unicode字符。
/
^
\S$ / .test('𠮷') // false
/
^
\S$ / u.test('𠮷') // true
复制代码
// 上面代码的\S是预定义模式,匹配所有不是空格的字符。只有加了u修饰符,它才能正确匹配码点大于0xFFFF的Unicode字符。
// 利用这一点,可以写出一个正确返回字符串长度的函数。
function codePointLength(text) { const result = text.match(/[\s\S]/gu) return result ? result.length : 0 }
const s = '𠮷𠮷'
s.length // 4 codePointLength(s) // 2 // (5) i修饰符
// 有些Unicode字符的编码不同,但是字型很相近,比如,\u004B与\u212A都是大写的K。
/
[a - z] / i.test('\u212A') // false
/
[a - z] / iu.test('\u212A') // true
```
复制代码