正则表达式

处理字符串的利器.主要作用是判断字符串中是否含有符合正则表达式匹配规则的片段

创建

方法1：

var reg = /abc/

方法2：

var reg = new RegExp('abc')

正则表达式修饰符

g:全局匹配

var reg1 = /a/;
var reg2 = /a/g;
var str = 'abcda';
str.match(reg1);//结果是一个数组['a']
str.match(reg2);//结果是一个数组['a','a']
//所谓全局匹配就是会匹配整个字符串中所有符合规则的片段,而不只是简简单单的找到第一个符合的字符串片段就结束匹配.

i:忽略大小写

var rge1 = /abc/;
var reg2 = /abc/i;
var str = /aBcd/;
reg1.test(str);//结果为false
reg2.test(str);//结果为true
//所谓忽略大小写就是指匹配规则不受字符大小写影响.

m:多行匹配

var reg1 = /^a/g;
var reg2 = /^a/gm;
var str = 'abcd\na';
str.match(reg1);//结果是一个数组['a']
str.match(reg2);//结果是一个数组['a','a']

[]

一个[]表示一位,[]里面的内容是规定这一位可以取值的范围.例如[1-9]表示这一位的取值范围是1-9数字.

注意:^写在[]表示非的意思,写在[]表示以这个字符开头

var reg1 = /[0-9]/g
var str = 'ab1cd2';
str.match(reg1)//结果是['1','2'];
var reg2 = /[^abc]/g
var str2 = 'abcd';
str2.match(reg2)//结果是['d']

()

var reg = /(abc|bcd)/g;
var str = 'abc';
var str2 = 'ab';
reg.test(str)//结果为true
reg.test(str2)//结果为false

元字符

拥有特殊含义的字符.一个元字符也只代表一位

元字符	描述
.	匹配除了换行符之外的所有字符
\w	匹配数字,字母,下划线
\W	匹配不是数字,字母以及下划线
\d	匹配一个数字
\D	匹配一个非数字的字符
\s	匹配任何空白字符
\S	匹配任何一个非空白字符
\b	匹配单词边界
\B	匹配非单词边界
^	匹配开头
$	匹配结尾
*	匹配连续出现0次到多次的字符
?	匹配连续出现0次到一次的字符
+	匹配连续出现一次到多次的字符
{n}	匹配连续出现n次的字符
{n,}	匹配至少连续出现n次的字符
{n,m}	匹配至少连续出现n次,最多不超过m次的字符

var str = 'abc bcd cde';
var reg = /\bb/;
str.match(reg);//返回的是['b']而且这个b是bcd里面的那个b

exec方法

每一个正则表达式对象都有exec这个方法,它的用法如下:

var str = 'ababab';
var reg = /ab/g;
-----------------------------正则表达式是全局匹配的模式下-------------------------------------
res.exec(str)//结果是一个类数组['ab',index:0,input:'ababab']
res.exec(str)//结果是一个类数组['ab',index:2,input:'ababab']
res.exec(str)//结果是一个类数组['ab',index:4,input:'ababab']
res.exec(str)//结果是null
res.exec(str)//结果是一个类数组['ab',index:0,input:'ababab']
-----------------------------正则表达式不是全局匹配的模式下-----------------------------------
res.exec(str)//结果是一个类数组['ab',index:0,input:'ababab']
res.exec(str)//结果是一个类数组['ab',index:0,input:'ababab']
res.exec(str)//结果是一个类数组['ab',index:0,input:'ababab']
res.exec(str)//结果是一个类数组['ab',index:0,input:'ababab']
res.exec(str)//结果是一个类数组['ab',index:0,input:'ababab']
-----------------------------------------------------------------------------------------这里的index就对应着reg.lastIndex这个属性.

反向引用

反向引用需要使用到分组，分组就是使用()括起来的部分为一个整体，在进行分组匹配时的原则是：由外向内，由左向右.

var str = 'aabb';
var reg = /(\w)\1(\w)\2/g
// \1：表示的是引用第一次匹配到的()括起来的部分
// \2：表示的是引用第二次匹配到的()括起来的部分

题目:将'the-first-name'转换为'theFirstName'

var str = 'the-first-name';
var reg = /-(\w)/g
str.replace(reg,($,$1)=>$1.toUpperCase)
replace方法中的回调函数的第一个参数是正则表达式匹配到的字符串片段,$1是正则表达式第第一次匹配到的()括起来的部分,依次可以有$2,$3....

正向预查

var str = 'abaaaa'
//需求是匹配后面紧跟着的字符是'b'的a
var reg = /a(?=b)/g;//查找后面紧跟的是b的a，括号后面的东西只是为了修饰前面要匹配的主体
//需求是匹配后面紧跟着的字符不是'b'的a
var reg2 = /a(?!b)/g//查找后面不是b的a

贪婪匹配和非贪婪匹配

默认情况是贪婪匹配,要改成非贪婪匹配,在量词后面加一个?

var str = 'aaaaa';
var reg = /a{1,3}/g
str,match(rge);//结果是['aaa','aa']
var reg2 = /a{1,3}?/g
str.match(reg2);//结果是['a','a','a','a','a']

一个有趣的demo

需求:给定一个数字100000000,要求将其转换为100,000,000

var str = '100000000';
var reg = /(?=(\B)(\d{3})+$)/g
str.replace(reg,',')