正则表达式

正则表达式一般用来匹配字符串模版。

1. 表示方式

正则表达式有两种表示方式。下面两种方式调用的时候,都相当于新建了一个正则表达式。

1. RegExp对象表示法(知道就行)

new RegExp(‘a‘, ‘i‘); //相当于/a/i
// 这种表示法的特殊之处在于,第一个参数是字符串,对于\的处理,需要转译
new RegExp(‘\\+a‘, ‘i‘); // 相当于/\+a/i
// 另外第一个参数也可以直接写另一种正则表达式
new RegExp(/a/i); // 相当于/a/i的拷贝,ES5中不允许有第二个参数
// ES6中可以有第二个参数
new RegExp(/a/ig, ‘i‘); // 可相当于/a/i, 第二个参数覆盖第一个参数的修饰符

2. 斜杠开始和结束(用这个)

因为这个写法在编译阶段就新建一个正则表达式,效率更高,也更直观。

/a/i

2. 实例属性

实例属性基本对应了正则表示式的修饰符,只有lastIndex是可写属性,其他都是只读属性。

在原型对象上的属性。

1.修饰符属性

只有u修饰符可以识别大于0xFFFF的字符,其他的修饰符都不行!

1.RegExp.prototype.ignoreCase对应i修饰符,忽略大小写

var reg = /xyz/i;
reg.test(‘XYZ‘); // true
reg.ignoreCase; // true

2.RegExp.prototype.global对应g修饰符,全局匹配

var regG = /x/g; 
var reg = /x/;
‘x-x-x‘.replace(regG, ‘y‘); //‘y-y-y‘
‘x-x-x‘.replace(reg, ‘y‘); // y-x-x
regG.global;// true

3.RegExp.prototype.multiline对应m修饰符

使位置字符(^,$)可以匹配行终止符(/r,/n,\u2028行分隔符,\u2029段分隔符)

var reg = /^test$/;
var regM = /^test$/m;
reg.test(‘test\n‘); // false
regM.test(‘\rtest\n‘); // true
regM.test(‘\u2028test\u2029‘);// true
regM.multiline; //true

4.RegExp.prototype.unicode ES6 对应u修饰符,匹配大于0xFFFF的字符。

1)当同时使用u修饰符,其他修饰符也可以识别四个字节的字符,当成一个字符

var str = ‘??‘;
var reg = /^.$/;
var regU = /^.$/u;
reg.test(str); // fasle 将其处理成两个字符,不匹配一个字符的正则表达式
regU.test(str); // true 识别成一个字符
regU.unicode; //true

// 量词,匹配识别成两个字符后的第二个字符
/??{2}/.test(‘????‘); // false 
/??{2}/u.test(‘????‘); // true

// 字符形式一样,字符编码不同, 如‘\u004B‘,‘\u212A‘都表示大写K
(/[a-z]/i).test(‘\u004b‘);//true 只能识别ASCII码为75的K
(/[a-z]/i).test(‘\u212A‘); // false
(/[a-z]/iu).test(‘\u004b‘); // true
(/[a-z]/iu).test(‘\u212A‘); // true

2)可以识别unicode字符的大括号表示法

var reg = /\u{61}/; //相当于匹配反斜杠和61个u
var regU = /\u{61}/u; //相当于码点0x61 == 97
reg.test(‘\\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu‘); //true
regU.test(‘\u{61}‘); // true
regU.test(‘a‘);  // true

3)无效的转译会报错

var reg=/\,/;
var regU=/\,/u;
reg.test(‘,‘);// true \无效
regU.test(‘,‘); // 报错,Invalid escape

5.RegExp.prototype.sticky ES6 对应y修饰符,test,exec方法中基本和g一致。有两点重要区别

1)y修饰符有“粘连”属性,就是每次开始匹配位置的值就必须符合匹配规则

var regY = /a/y;
var regG = /a/g;

regY.lastIndex; //0
regY.test(‘_a_a_a‘);// false 位置0的字符不符合匹配规则

regG.lastIndex; //0
regG.test(‘_a_a_a‘); // true

2)在字符串匹配方法中,y修饰符只返回第一个匹配结果,想返回所有的需要配合g修饰符

var regY = /a/y;
var regG = /a/g;
var str = ‘a_a_‘;

str.match(regY); // [‘a‘]
str.match(regG); // [‘a‘,‘a‘]

str.replace(regY, ‘y‘); // ‘a_a_‘ 第一次不替换
str.replace(regY, ‘y‘); // ‘y_a_‘ 第二次替换
str.replace(regG, ‘y‘); //‘y_y_‘

6.RegExp.prototype.dotAll ES2018 对应s修饰符,使元字符(.)可以匹配任意字符

即可以匹配“行终止符”

var reg=/^.$/;
var regS = /^.$/s;
reg.test(‘\n‘); //false
regS.test(‘\n‘); //true
regS.dotAll; //true

2. 其他属性

1. RegExp.prototype.lastIndex属性--可写属性

主要配合test,exex使用,用于查找或者设置查询起始位置

该属性起作用,主要在使用了g修饰符时。

2. RegExp.prototype.source属性--返回正则表达式内容

(/[a-z]/g).source;//  "[a-z]" 除了//之外的字符串

3. RegExp.prototype.flags属性--返回使用过的修饰符

(/[a-z]/ig).flags; //‘gi‘

3. 实例方法

1. RegExp.prototype.test()

返回布尔值,表示是否匹配成功。

如果使用g修饰符,同一个表达式每次匹配都从上一次匹配结束的位置开始。

如果不使用g修饰符,则每次都从开始位置匹配。匹配位置可以用lastIndex表示。

var reg = /a/;
var regG = /a/g;

reg.lastIndex; // 0
reg.test(‘a_a_‘); // true 
reg.lastIndex; // 0
reg.test(‘a_a_‘); // true 

regG.lastIndex;// 0
regG.test(‘a_a_‘); // true
regG.lastIndex;// 1
regG.test(‘a_a_‘); // true

还可以设置lastIndex的值来指定开始匹配的位置。

var regG = /a/g;

regG.lastIndex = 3;
regG.test(‘aabc‘); // false

2.RegExp.prototype.exec()

返回数组。返回匹配结果,包含组匹配。

和test类似。如果使用g修饰符,每次从上次匹配结束位置后开始。

var regG = /a/g;

regG.exec(‘a_a_‘); // ["a"]

4. 元字符

在正则表达式中代表特殊含义的字符叫做“元字符”。

这些字符如果要匹配本身,需要加上转译字符,如\.,表示点

1.点字符(.)

代表除了“行终止符(\r\n\u2088\u2089)”之外的所有字符。

2.位置字符(^  $)

^代表起始字符;$代表终止字符

/^test$/.test(‘test‘); // true 只能有一个test

3. 选择字符(|)

选择字符表示“或关系”,包括符号前后的多个字符

/fred|berry/.test(‘fred‘); // true

4.字符类字符([])

表示只要匹配[]中的一个字符就可以了。

/[xyz]/.test(‘x‘); //true

字符类有两个特殊字符。这两个特殊字符在字符类之外,按照普通字符解释

1)脱字符(^)

表示否定关系。只能用在[]起始位置。[^]表示所有字符

/[^a-z]/.test(‘A‘); //true 匹配所有不是a-z的字符

2)连字符(-)

表示连续的字符。只在[]内表示该含义。

/[1-31]/.test(1);// true 表示1-3和1,匹配任意一个
/1-31/.test(‘1-31‘); // true

5. 重复类({ })

表示字符重复的个数。这个类只作用于前面的一个字符。

{n}--n次  {n,m} -- 重复n-m次  {n, }--至少重复n次

/lo{2}k/.test(‘look‘); //true

6. 量词符--出现0或者1次(?)

相当于{0, 1}

/a?/.test(‘‘);  //true

7.量词符--出现0或者多次(*)

相当于{0, }; 默认贪婪匹配,匹配到不符合规则结束;

可以和?一起,表示非贪婪模式(*?),匹配0个成功就结束

/a*/.exec(‘aaaabc‘); // [‘aaaa‘]
/a*?/.exec(‘aaaabc‘); // [""]  出现0次

8. 量词符--出现1或者多次(+)

相当于{1, },默认贪婪匹配。

可以和?一起,表示非贪婪模式(+?), 匹配一个成功就结束

/a+/.exec(‘aaaabc‘); // [‘aaaa‘]
/a+?/.exec(‘aaaabc‘); //[‘a‘]

9. 反斜杠(\\)

表示反斜杆,一个表示转译

10. 组匹配(())

1)含义

组匹配可以匹配分组的内容,并捕获括号内的匹配。

/fred+/.test(‘freddddd‘); // true
/(fred)+/.test(‘fredfred‘); // true

组匹配一般不和g修饰符一起,如果想要一起,可以遍历exec实现;或者matchAll

‘abc‘.match(/(.)b(.)/g); // ["abc"] 不返回组匹配

在正则表达式中,可以使用\N,即\加上一个数字,来表示匹配的第N个组匹配。

应用:用于html标签匹配

/(.)b(.)\1b\2/.test(‘abcabc‘); // true
// 如果有括号嵌套,外层括号是\1,内层括号是\2

ES2018引入了具名组匹配。具名组匹配不需要考虑组匹配的顺序。

即给组匹配指定了变量名,相当于key值,表示<?name>

只要使用了具名组匹配,在匹配结果的groups属性上就会有变量名。

一般match和exec的方法的匹配结果含有groups属性。

var reg = /(\d{4})-(\d{2})-(\d{2})/;
var regName=/(?<year>\d{4})-(?<month>\d{2})-(?<date>\d{2})/;
‘1999-12-31‘.match(reg).groups; // undefined
‘1999-12-31‘.match(regName).groups; // {date: "31", month: "12", year: "1999"}

reg.exec(‘1999-12-31‘).groups; // undefined
regName.exec(‘1999-12-31‘).groups; // {date: "31", month: "12", year: "1999"}

正则表达式中,具名组匹配可以用\k<组名>来表示某个组匹配。和\N性质类似。

2)非捕获组匹配(?:XXX)

组匹配中加入?:符号,表示该组匹配不返回。不能和具名组匹配一起使用。

var regName=/(?:\d{4})-(\d{2})-(\d{2})/;
regName.exec(‘1999-12-31‘); // [‘1999-12-31‘,‘12‘,‘31‘] 

3)先行断言(X(?=Y)

X只有在Y前面才匹配。返回匹配的X的值,不返回Y。

/\d(?=%)/.exec(‘he 100%‘); // ["100"]

4) 先行否定断言(X(?!Y)

X只有不在Y的前面才匹配。返回X的值,不返回Y。

/\d(?!%)/.exec(‘this\‘s 50 that\‘s 80%‘); //["5"] \d只表示一个数字

5)ES2018后行断言((?<=Y)X

X只有在Y的后面才匹配。而且后行断言,从右到左运行。

即右结合运算符。另外还有=,?:也是右结合运算符。

/(?<=(\d+))(\d+)/.exec(‘hehe 12343‘); // ["2343", "1", "2343"] 右结合
/(\d+)(\d+)/.exec(‘hehe 12343‘); // [‘12343‘, ‘1234‘, ‘3‘]

5. 预定义模式

1)\d---[0-9]  数字

2)\D---[^0-9] 非数字

3)\w---[A-Za-z0-9_] 字母、数字、下划线

4)\W---[^A-Za-z0-9_]非字母、数字、下划线

5)\s---[ \r\n\f\t\v] 空白字符: 空格、制表符、终止符

6)\S---[^ \r\n\f\t\v] 非空白字符

7)\b---词的边界

8)\B---词非边界

ES2018 

9)\p{...}---匹配某种属性的所有字符

(/\p{Script=Greek}/u).test(‘π‘);// 匹配希腊字体
(/\p{Number}/u).test(‘???‘); // 匹配各种数字

10)\P{...}---不满足匹配的某种属性

相关文章