正则

定义：用来处理字符串的规则

1、匹配：判断一个字符串是否符合我们制定的规则->test:reg.test(str)

2、捕获： 把字符串中符合我们正则规则的内容捕获到->reg.exec(str)

var reg=/\d/;
console.log(reg.exec('1'));//['1',index:0,input:'1'];

创建正则的两种方式：

• 1、字面量创建：

var reg=/\d/;

• 2、实例创建方式：

var reg=new RegExp('');

两种创建方式的区别？

• １、字面量方式中出现的一切都是元字符，所以不能进行变量值的拼接，而实例创建的方式是可以的

var reg=/^\d+"+name+"\d+$/g;
reg.test('2000""nameeee"2001');//true;

每个正则表达式都是由元字符和修饰符组成的（在//之间有意义的一些字符）

1、具有特殊意义的元字符

• \ :转义字符，转义后面字符所代表的含义
• ^:以某一个元字符开始
• $:以某一个元字符结尾
• 点.：代表处理\n以外的任意字符
• \n:匹配一个换行符

var reg=/^0.2$/;//以0开头，以2结尾，中间可以是除了\n的任意字符
reg.test('0-2');//true
reg.test('0.2');//true

• ():分组 ->把一个大正则划分成几个小正则
• \w:数字、字母、下滑下中的任意一个字符-> [0-9a-zA-Z_]
• \s:匹配一个空白字符 空格、一个指标符、换页符

var reg=/^(\d+)abcd(\d+)$/;

- x|y:x或者y中的一个字符
- [xyz]:x y z中的其中一个字符
- [^xyz]:除了xyz中的任意一个字符
- [a-z]:a-z之间的任何一个字符
- [^a-z]:除了a-z之间的任何一个字符
- \d:一个0-9之间的数字  \D:除了0-9之间的数字以外的任何字符
- \b:一个边界符 'a1 b2 c3'
> []中的字符不需要转义，但是\w除外，[]中不能出现两位数

年龄介于18~65之间；
var reg=/[18-65]/;//这样写肯定不行
var reg1=/^1[8-9]|[2-5][0-9]|6[0-5]/;
reg1.test('18');//true

2、代表出现次数的量词元字符

• *：出现零次或多次
• +：出现一次到多次
• ？：出现零次或者一次
• {n}：正好出现n次
• {n,}:出现n到多次
• {n,m}出现n到m次

邮箱验证
左边：数字、字母、下划线、.、-
var reg=/^[\w.-]+@[0-9a-zA-Z]+(\.[a-zA-Z]{2,4}){1,2}$/;
reg.test('liubingqun163@163.com');//true;

3、分组的作用一：改变x|y的默认的优先级

var reg=/^18|19$/;
reg.test('189');//true;
var reg1=/^(18|19)$/;
reg1.test('189');//false;

exec正则的捕获

捕获的内容格式：

1、捕获到的内容是一个数组

• 数组中的第一项是当前大正则捕获的内容
• index ：捕获内容在字符串中开始的索引位置
• input：捕获的原始字符串

var reg=/\d+/;
var str='luck2017byby2016';
var res=reg.exec(str);
console.log(res);
//['2017',index:4,input:'luck2017byby2016'];
res=reg.exec(str);
console.log(res);
//['2017',index:4,input:'luck2017byby2016'];

为什么会出现上面的情况呢？因为正则的懒惰型

2、正则捕获的特点：

• 懒惰型->每一次执行exec只捕获第一个匹配的内容，不进行任何处理的情况下，在执行多次捕获，捕获的还是第一个匹配的内容
• lastIndex：是正则每一次捕获在字符串中开始查找的位置，默认值是0；它跟懒惰型有直接关系

var reg=/\d+/;
var str='luck2017byby2016';
var res=reg.exec(str);
console.log(reg.lastIndex); //8
console.log(res);
//['2017',index:4,input:'luck2017byby2016'];
res=reg.exec(str);
console.log(reg.lastIndex); //8
console.log(res);
//['2017',index:4,input:'luck2017byby2016'];

我们能看出来lastIndex每次都一样，那么该怎么处理呢
在正则后面加上字符g

修饰符：g(全局)、i（ignoreCase忽略大小写）、m（multiline多行匹配）

var reg=/\d+/g;
var str='luck2017byby2016';
var res=reg.exec(str);
console.log(reg.lastIndex); //8
console.log(res);
//['2017',index:4,input:'luck2017byby2016'];
res=reg.exec(str);
console.log(reg.lastIndex); //16
console.log(res);
//["2016", index: 12, input: "luck2017byby2016"];

原理：加了全局修饰符g，正则每一次捕获结束后，我们的lastIndex的值都变为了最新的值，下一次捕获从最新的位置开始查找，这样就可以把所有需要捕获的内容都获取到了

3、自己编写程序获取正则获取的所有的内容（一定不能忘记加g）

var reg=/\d+/g;
var str='luck2017byby2016';
var ary=[];
var res=reg.exec(str);
while(res){
    ary.push(res[0]);
    res=reg.exec(str);
}
console.log(ary);//['2016','2017']

4、正则的贪婪性

• 如果我只想捕获到2017中的2，那该怎么办？
• 正则在匹配的时候，是按照最长的匹配结果来匹配的，这就是它的贪婪性。例如：2和2017都复合上面demo的reg，但是捕获的是2017,。
• 解决正则贪婪性的方法和解决懒惰型的方法一样简单，在==量词元字符==后面加一个？即可，问号代表了取消捕获时候的贪婪性

var reg=/\d+?/g;
var str='luck2017byby2016';
var ary=[];
var res=reg.exec(str);
while(res){
    ary.push(res[0]);
    res=reg.exec(str);
}
console.log(ary);
//["2", "0", "1", "7", "2", "0", "1", "6"]

字符串中的match方法->把所有和正则匹配的字符都获取到

看下面的match方法

var reg=/\d+/g;
var str='luck2017byby2016';
var ary=str.match(reg)
console.log(ary);//["2017", "2016"]

var reg=/\d+?/g;
var str='luck2017byby2016';
var ary=str.match(reg)
console.log(ary);//["2", "0", "1", "7", "2", "0", "1", "6"]

从示例中能看出match比exec简洁很多，但是match中存在一些自己处理不了的问题

在分组捕获时，match只能捕获到大正则匹配的内容，无法捕获到小正则的内容，下面学习分组

正则分组

• 1、改变优先级
• 2、分组引用

var reg=/^(\w)\1(\w)\2$/;
console.log(reg.test('aaff'));//true
console.log(reg.test('a0f_'));//false
\1代表和第一个分组出现一模一样的内容；\2代表和第二个分组出现一模一样的内容

• 3、分组捕获 ->正则在捕获的时候，不仅仅把大正则匹配的内容捕获到，而且还可以把小分组匹配的内容捕获到

var reg=/^(\d{2})(\d{4})$/;
var str='122344';
console.log(reg.exec(str));
//["122344", "12", "2344", index: 0, input: "122344"]
数组中的第一项：大正则捕获到的内容
        第二项：第一个小正捕获到的内容
        第三项：第二个小正则捕获到的内容
        第四项：捕获的开始项
        第五项：原始的输入

如果正则中出现了 ?: ,代表只匹配，不捕获

var reg=/^(\d{2})(?:\d{4})$/;
var str='122344';
console.log(reg.exec(str));
//["122344", "12", index: 0, input: "122344"]

下面我们再讲讲match的梗；

var reg=/(\d{2})(\d{4})$/;
var str='122344';
console.log(str.match(reg));
//["122344", "12", "2344", index: 0, input: "122344"]

what?竟然和exec一样的，到底区别在哪？来看下面的代码,原因是只捕获一次就捕获到了所有的内容，那么match和exec作用一样，那什么时候作用不一样呢？

var reg=/abc(\d+)/g;
var str='abc123abc456abc789'
console.log(reg.exec(str));//["abc123", "123", index: 0, input: "abc123abc456abc789"]
console.log(reg.exec(str))//["abc456", "456", index: 6, input: "abc123abc456abc789"]
console.log(reg.exec(str));//["abc456", "456", index: 6, input: "abc123abc456abc789"]
console.log(str.match(reg));//["abc123", "abc456", "abc789"]

我们能明显的看到在全局g下，match捕获到的是大正则匹配的内容，没有小分组。如果没有全局g,再看看代码的执行情况

var reg=/abc(\d+)/g;
var str='abc123abc456abc789'
console.log(reg.exec(str));//["abc123", "123", index: 0, input: "abc123abc456abc789"]
console.log(reg.exec(str))//["abc123", "123", index: 0, input: "abc123abc456abc789"]
console.log(reg.exec(str));//[["abc123", "123", index: 0, input: "abc123abc456abc789"]
console.log(str.match(reg));//["abc123", "123", index: 0, input: "abc123abc456abc789"]

replace

如果我先替换掉字符串时，

var str='ab12ab23';
str=str.replace('ab','abcd');
console.log(str);//'abcd12ab23'

我们看到了replace只替换了一次，如果用正则替换呢？

var str='ab12ab23';
str=str.replace(/ab/g,'abcd');
console.log(str);//'abcd12abcd23'

功能已经实现，但是怎么实现的呢？

var str='ab12ab23';
str=str.replace(/ab/g,function(){
    console.log(arguments);
    return 'abcd'
})
str;//'abcd12abcd23'
arguments;//["ab", 0, "ab12ab23"]
          //["ab", 4, "ab12ab23"]

• 1、首先我们和exec捕获一样，把所有和我们正则匹配的都捕获到，让后把捕获的内容替换成我们需要替换的新内容
• 2、每次执行匿名函数，里面传递的参数值arguments和我们自己通过exec捕获到的结果非常类似（即使正则有分组，我们同样可以通过arguments获取到分组捕获的内容）
• 3、return 返回的结果，相当于把当前这一次==大正则==捕获的内容替换掉

如果正则中存在小分组时，结果怎样呢？

var str='ab12ab23';
str=str.replace(/a(b)/g,function(){
    console.log(arguments);
    return 'abcd'
})
str;//'abcd12abcd23'
arguments;//["ab", "b", 0, "ab12ab23"]
          //["ab", "b", 4, "ab12ab23"]
str没有变化， 只是arguments发生了变化。