关于正则

--------------------------正则的作用--------------------------

正则：就是一个规则，用来处理字符串的一个规则（正则是用来处理字符串的）

处理：

1>匹配  判断一个字符串是否符合我们制定的规则

var reg = /\d/;

console.log(reg.test("张"));

console.log(reg.test("张3"));

2>捕获  把字符串中符合我们正则规则的内容捕获到

var reg = /\d/;

console.log(reg.exec("张"));

console.log(reg.exec("张3"));

创建一个正则  正则两种创建方式是有区别的

var reg=/\d/;

var reg=new RegExp("");

如何来学习正则？

RegExp.prototype

----------------------------------正则的元字符和一些简单的应用------------------------------------------

每一个正则表达式都是由元字符和修饰符组成的

元字符:在//之间具有意义的一些字符

1、具有特殊意义的字符

\:转义字符，转译后面字符所代表的含义

^:以某一个元字符开始

$:以某一个元字符结尾

\n:匹配一个换行符

.:除了\n以外的任意字符

x|y：x或者y中的一个

[xyz]：x或者y或者z中的一个字符

[^xyz]除了x y z以外的任意字符

[a-z]:a-z之间任意一个字符

[^a-z]:除了a-z之间的任何一个字符

\d:0-9之间数字

\D除了0-9之间的数字以外的任何字符

\b:匹配一个边界符  var str=”we  we  rrt  y”;

\w：数字、字母、下划线中的任意一个字符[(0-9)(a-z)(A-Z)(_)]

\n换行

\s:匹配一个空白符 空格....

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

*:出现0到多次

+：出现1到多次

?:出现零次或1次

{n}出现n次

{n,}出现n到多次

{n,m}出现n到m次

思考：

var reg = /\d/;

console.log(reg.test('fsdf3432'));

var reg = /^\d$/;

console.log(reg.test('0'));

var reg = /^\d+$/;

console.log(reg.test('44465'));

var reg = /^0\.2$/;

console.log(reg.test('0.2'));

var reg=/^[+-]$/;

console.log(reg.test('-'));

验证简单的手机号

var reg = /^1\d{10}$/;

()：分组：把一个大正则本身划分为几个小的正则

var reg=/^(\d+)勿忘初心(\d+)$/;  （分成了两组）

console.log(reg.test('2017勿忘初心2017'));

[]：在中括号中出现的所有字符都是代表本身意思的字符

var reg=/^[.]$/;

console.log(reg.test(‘.’));

[]:不识别两位数

var reg = /^[12]$/;代表的是1或者2中的一个

var reg = /^[\w-]$/;数字、字母、下划线、中划线中的任意一个

var reg = /^[12-68]$/  （1、2-8中的一个、8）三个中的一个

分组的作用：改变x|y的优先级

var reg=18|19;//18 19 181 18 19

var reg=(18|19); //18 19

思考：检测是否为有效数字

1、可以出现小数点，也可以不出现小数点，但是出现小数点后面必须跟着一位或多位数字

2、可以出现+或者-，也可以不出现

3、整数部分可以是一位整数，也可以是多位整数，但是多位整数一定不能以0开头

检测是否为有效数字：var reg=/^[+-]?(\d|([1-9]\d+))(\.\d+)?$/;

-------------------------------------正则方式创建的区别--------------------------------------

创建正则的两种方式

var name = 'zhangsan';

var reg = /^\d+"+name+"\d+$/;

console.log(reg.test('123zhangsan234'));

var reg2 = new RegExp('^\\d+' + name + '\\d+$');

console.log(reg2.test('123zhangsan234'));

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

字面量方式中直接写\d就可以，而在实例中需要把它转译\\d

-------------------------------------------编写简单的正则表达式--------------------------------------

1、年龄介于18-65之间

var reg = /^(1[8-9]|[2-5]\d|6[0-5])$/;

2、验证邮箱(简版)

12324322@qq.com  2434432@163.com    zhang-23423_san@zhangsan.com

var reg=/^[\w.-]+@[0-9a-zA-Z]+(\.[a-zA-Z]{2,4}){1,2}$/;

3、验证身份证（简版）

var reg=/^\d{17}(\d|X)$/;

----------------------------------------懒惰性和贪婪性-----------------------------------------

正则捕获：exec

思考：

var reg=/\d+/;

var str='zhangsan2015lisi2016';

var res=reg.exec(str);

console.log(res);

每一次捕获的时候都是先进行默认的匹配，如果没有匹配成功的，捕获的结果是null，只有有匹配的内容我们才能捕获到，而且捕获到的内容是一个数组

打印出来的结果捕获的内容格式：

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

数组中的第一项：是当前大正则捕获的内容

Index：捕获内容在字符串中开始索引的位置

Input:捕获的原始字符串

正则捕获的特点：懒惰性每一次执行exec只捕获第一个匹配的内容，在不配合任何处理的情况下在执行，在执行多次捕获，捕获的还是第一个匹配的内容

lastIndex：是正则每一次捕获在字符串中开始查找的位置，默认值是0

如何解决懒惰性？在正则的末尾添加一个修饰符”g”

global(g):全局匹配

ignoreCase(i)忽略大小写

multiline(m)多行匹配

自己编写正则获取正则捕获的所有内容（不要忘记加g）

原理：加了全局修饰符g，正则每次捕获结束后，下一次捕获继续查找，一直找到null

var reg = /\d+/g;

var str = 'zhangsan2015lisi2016';

var res = reg.exec(str);

var arr=[];

while(res){

arr.push(res[0])

res = reg.exec(str);

}

console.log(arr);

思考：

var reg = /\d+/g;

var str = 'zhangsan2015lisi2016';

console.log(reg.exec(str));

贪婪性 正则每一次捕获都是按照最长的结果捕获的，捕获的是2015

解决贪婪性--->在量词元字符后面添加一个?即可

？在正则中有很多作用：

1>放在普通的元字符后面代表是出现0-1次数字，数字可能出现可能不出现

2>放在量词元字符后面，取消捕获时候的贪婪性

正则中提供了exec的方法，字符串中提供了match方法，也可以捕获

字符串中的match方法（和exec原理一样，就是执行的次数不一样），把所有和正则匹配的字符都获取到

var reg = /\d+/g;

var str = 'zhangsan2015lisi2016';

var ary=str.match(reg);

console.log(ary);

match虽然好用但是在分组捕获的情况下，match只能捕获到大正则匹配的内容，而对于小正则捕获的内容是无法获取的

---------------------------分组捕获-----------------------------------------

思考1：

var reg = /^(\w)\1(\w)\2$/;

var str='ffzz';

console.log(reg.test(str));

正则分组：

1、改变优先级

2、分组引用

\2代表和第二个分组出现一模一样的内容

\1代表和第一个分组出现一模一样的内容

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

(?:)在分组中?:的意思是只匹配不捕获

var reg = /^(\d)(\d)$/;可以捕获到1、3

var reg = /^(\d)(?:\d)$/;只能捕获到1

console.log(reg.exec(‘13’));

如果都是正则都是分组这中情况下：match()和exec()捕获到的结果是一样的

以下案例就是math和exec的不一样的情况

var reg = /zhangsan(\d+)/g;

var str='zhangsan123zhangsan456zhangsan789';

console.log(reg.exec(str));

console.log(reg.exec(str));

console.log(reg.exec(str));

console.log(str.match(reg));

exec执行三次，每一次执行不仅仅把大正则的获取到，而且可以获取第一个分组匹配的内容

math只能捕获到大正则匹配的内容

-------------------------------replace---------------------------------------------

var str = 'zhangsan2016zhangsan2017';

str = str.replace(/zhangsan/g, 'lisi');

replace实现的原理是：首先和exec捕获一样，把所有和我们正则匹配的都捕获到，然后把捕获的内容替换成我们需要替换的新内容

第一个值是正则

第二个参数替换成一个函数

1>匿名函数执行多少次，取决于正则能在字符串中捕获多少次--->正则捕获两次，所以我们的匿名函数也执行两次

2>每次执行的匿名函数，里面传递的参数值arguments和我们自己通过exec捕获到的结果是一样的（即使有分组我们也可以通过arguments获取到分组捕获的内容）

3> return返回的结果是啥，就相当于把当前这一次大正则捕获的内容替换成你返回的内容

思考1：

str = str.replace(/zhangsan/g, function () {

console.log(arguments);

return 'lisi';

});

console.log(str);

思考2：

var str = 'zhangsan2015zhangsan2016';

str = str.replace(/(\d+)/g, function () {

console.log(arguments[1]);

//arguments[0]大正则捕获的内容，arguments[1]正则捕获到的第一个分组（小正则）的内容

return 'aaa';

});

思考3：20132014替换成二零一三二零一四

var str = '20132014';

var ary = ["零", "一", "二", "三", "四"];

str = str.replace(/\d/g, function () {

return ary[arguments[0]];

});

console.log(str);

总结：

replace：将原有的字符替换成我们的新的字符

1> 在不使用正则的情况下，执行一次replace只能替换字符串中的一个

2>replace是支持正则的，在replace中我们可以一次批量的把所有正则匹配的内容都替换掉

原理：先按照正则制定的规则，到我们字符串中把正则匹配的内容捕获到，然后在每一次捕获之后，都把捕获的内容替换成新的内容

1>我们的正则表达式捕获到几次，对应的function就要执行几次

2>每一次执行function的时候我们都可以获取我们捕获的内容----->和我们单独执行一次exec的内容一致

arguments[0]---->exec捕获数组的第一项---->大正则捕获的内容

arguments[1]---->exec捕获数组的index----->开始捕获的索引

arguments[2]---->exec捕获数组的input------>捕获的原始字符串

不仅如此，我们小分组捕获的内容也同样可以获取到。

3>我们的function中，通过return来返回我们要替换的内容--->return是啥就把大正则捕获的内容进行替换

不写return，默认是用undefined来进行替换的

如果不想实现替换的话，捕获的内容是啥，我们就返回啥------>return argument[0]

案例1：将小写数字替换成大写数字

var str = '这周我走了3600步';

var ary = ["零", "一", "二", "三", "四", "五", "六"];

str = str.replace(/\d/g, function () {

return ary[arguments[0]];

});

console.log(str);

案例2：var str = 'zhangaaaaa';字符串中挑出出现频率最高的字符和出现了多少次

var obj = {};

1、获取每一个字符出现的次数存放到了obj中

str = str.replace(/[a-z]/gi, function () {

var val = arguments[0];

if (obj[val] >= 1) {

obj[val] += 1;

} else {

obj[val] = 1;

}

});

2、出现最多的次数

var max = 0;

for (var key in obj) {

if (max < obj[key]) {

max = obj[key];

}

}

3、把最大次数对应的key值放到数组中

var ary = [];

for (var key in obj) {

if (obj[key] == max) {

ary.push(key);

}

}

console.log(ary.toString()+'出现了'+max+'次数');

:案例3：

var str = "my name is {0},my age is {1},i come from {2},i love {3}";

var ary = ["小红", 18, "中国", "吃饭"];

把{0}{1}{2}{3}分别替换成"小红", 18, "中国", "吃饭"

str = str.replace(/{(\d+)}/g, function () {

return ary[arguments[1]];

});

案例4：

将var str = "http://www.baidu.com/index.html?mid=1000&cid=13213&app=1.0";转换为

obj={

mid:1000,

cid:13213,

app:1.0

}

答案：

var reg = /([^?&=]+)=([^?&=]+)/g;

var obj = {};

str = str.replace(reg, function () {

obj[arguments[1]] = arguments[2];

});

案例5 ：字符串首字母大写

var str = "wo shi xiao hong";

var reg = /\b([a-z])/g;

str = str.replace(reg, function () {

return arguments[1].toUpperCase();

});

console.log(str);

案例6：将var str = "2010-8-22 13:10:00";，转换为2010年8月22日13时10分00秒