----------------------------------正则的作用-------------------------------------------
正则：就是一个规则，用来处理字符串的一个规则（正则是用来处理字符串的）
处理：
 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秒