正则查询

d匹配一个0-9的数字相当于[0-9]，和它相反的
\D匹配一个除了0-9的任意字符相当于【】 

\w匹配一个0-9、a-z、A-Z_ 的数字或字符，相当于[0-9a-zA-Z_]  、

\s匹配一个空白字符（空格、制表符。。。）

\b匹配一个单词的边界 “w100 w000”

\t匹配一个制表符

\n匹配一个换行

. 匹配一个除了\n以外的任意字符

^ 以某一个元字符开头

$ 以某一个元字符结尾

\ 转译字符

x|y  x或者y的一个

[xyz] x、y、z、中的任意一个

[^xyz]除了x、y、z、中的任意一个

[a-z] -> 匹配a-z中的任意一个字符

[^a-z] -> 匹配除了a-z中的任意一个字符

() 正则中的分组

量词：

*  0到多个

+  1到多个

?  0到1个   

？在正则中的意义比较多

    放在一个非量词元字符后面代表出现0-1次  例如/^\d?$/出现0-9直接的数0到1次

    放在一个量词元字符后面，取消捕获时候的贪婪性  /^\d+?$/捕获的时候只是把第一个捕获的数字获取 "2015"--->2

    (?:)分组值匹配不捕获

    (?=)正向预查

    (?!)负向预查

()的作用

1)改变默认的优先级

2)可以进行分组捕获

3)分组引用

 

{n}出现n次

{n,}出现n到多次

{n,m}出现n到m次

普通元字符

任何字符在正则中除了以上有特殊意义的，其他的都是代表本身意思的普通元字符

修饰符：

i：忽略字母的大小写

m：multiline 多行匹配

g：global全局匹配

3
项目中经常使用的正则

1）判断是有效数字的正则

   有效数字是指：正数、负数、零、小数

第一部分：可能出现加减或者没有

第二部分：一位数可以是0，多位数不能以0开头

第三部分：可以有小数也可以没有小数，但是一旦出现小数点，后面至少跟一位数字

var reg =/^[+-]?(\d|[1-9]\d+)(\.\d+)?$/;

有效的正整数（包含0）：/^[+]?(\d|[1-9]\d+)$/;

有效的负整数（包含0）：/^-(\d|[1-9]\d+)$/;

4
细节知识点

[]里面出现的任何字符都是代表本身意义的，例如：[.]中的”.“就是代表一个小数点而不是除了\n以外的任意字符

[]里面出现18不是数字18而是1或者8，例如[18-65]是1或者8-6或者5中任选一个

 

5
1、exec正则的捕获方法--->先匹配，然后把匹配的内容捕获

如果字符串没有匹配这个正则，捕获的返结果是null

如果和正则匹配，返回的结果是一个数组

例子

var str ="2015zhufeng2016peixun"

var reg = /\d+/;

 

第一项是我们捕获的内容

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

input：捕获的原始字符串

6
2、正则的捕获是懒惰的

正则的每一次捕获都从lastIndex值开始，第一次捕获的时候，lastIndex=0，从原始字符串索引为0的位置开始查找捕获，而默认的情况下，第一次捕获完成，lastIndex的值并没有发生改变，还是0，所以第二次捕获还是从原始字符串索引为0处开始查找，这样找到的还是第一次捕获的内容

  解决办法：添加全局修饰符g--->加上g后，第一次捕获完成后，lastIndex的值发生了改变，变为第一次捕获内容后的第一个字符的开始索引，第二次捕获是继续向后查找的...

  疑问：不用全局修饰符g每次捕获完成后手动修改lastIndex的值不可以么？

不可以，虽然手动修改了lastIndex，确实把lastIndex的值进行改变了，但是正则查找的时候还是从索引0开始的

var str = "zhufeng2015peixun2016";

    var reg = /\d+/g;

例子

    为了防止没有加全局修饰符g导致的死循环,我们在处理之前,对于没有添加g的手动给添加一个g

    RegExp.prototype.myExecAll = function myExecAll() {

        var _this = this, str = arguments[0], ary = [], res = null;

        !_this.global ? _this = eval(_this.toString() + "g") : null;

        res = _this.exec(str);

        while (res) {

            ary[ary.length] = res[0];

            res = _this.exec(str);

        }

        return ary;

    };

    var ary = reg.myExecAll(str);

    console.log(ary);

 

        console.log(reg.lastIndex);//->0

        var res = reg.exec(str);

        console.log(res);

 

        console.log(reg.lastIndex);//->11

        res = reg.exec(str);

        console.log(res);

 

        console.log(reg.lastIndex);//->21

        res = reg.exec(str);

        console.log(res);//->null

7
3、match:捕获字符串中存在一个叫做match的方法也可以实现捕获，而且只要我们取消了正则的懒惰性，执行一次match方法就可以捕获到所有内容了

    var str = "zhufeng2015peixun2016";

    var reg = /\d+/g;

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

    疑问:那我们都用match来替换exec多好啊?

 

8
4、正则的分组捕获

每一次捕获的时候，不仅仅可以把大正则匹配的内容捕获到，而且还可以把每一个小分组（子正则）匹配的内容单独的捕获到

        var str = "zhufeng[2015]peixun[2016]";

        var reg = /\[(\d)(\d+)\]/g;

        var res = reg.exec(str);

        console.log(res);

        ["[2015]", "2", "015", index: 7, input: "zhufeng[2015]peixun[2016]"]

第一项是大正则捕获的内容 res[0]

第二项是第一个分组捕获的内容 res[1]

第三项是第二个分组捕获的内容 rex[2]

。。。。。

 

 分组的只匹配不捕获:我们如果执行把分组内容进行匹配但是不进行捕获的话,只需要在分组的前面加上?:即可

      var str = "zhufeng[2015]peixun[2016]";

      var reg = /\[(?:\d)(\d+)\]/g;

      var res = reg.exec(str);

      console.log(res);

      ["[2015]", "015"...]

      数组中的第一项是大正则捕获的内容 res[0]

      数组中的第二项是第二个分组捕获的内容 res[1]

      第一个分组添加了?:,所以只匹配不捕获

9
5、exec和match的区别

match只能捕获大正则匹配的内容，对于分组捕获中，是无法获取分组匹配的内容的，所以如果捕获的时候不需要捕获分组的内容，我们直接用match更方便，如果需要捕获分组的内容，我们只能使用exec来一个个捕获

var str = "zhufeng[2015]peixun[2016]";    var reg = /\[(\d+)\]/g;    //console.log(str.match(reg));//->["[2015]", "[2016]"]    var ary = [];    var res = reg.exec(str);    while (res) {        //ary.push(res[1]);        ary.push(RegExp.$1);//RegExp.$1获取当前正则第一个分组捕获的内容，（可能在部分IE浏览器下捕获不到值）        res = reg.exec(str);    }    console.log(ary);

10
6、正则的贪婪性：在每一次的捕获的时候，总是按照正则匹配的最长结果捕获

    var str = "zhufeng2015peixun2016";

        var reg = /\d+/g;

        console.log(reg.myExecAll(str));//-->["2015","2016"]

    var str = "zhufeng2015peixun2016";

    var reg = /\d+?/g;

    console.log(reg.myExecAll(str));//-->["2", "0", "1", "5", "2", "0", "1", "6"]

 

11
7、分组引用

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

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

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

    "woow"、"1221"...

12
8、字符串方法---->replace：把一个字符串中的某个字符替换成新的内容

1)在不使用正则的情况下

执行一次replace只能替换字符串中的一个，需要替换多个同样需要执行多次

var str = "zhufeng2015 zhufeng2016";

    "zhufeng" -> "珠峰"

    str = str.replace("zhufeng", "珠峰").replace("zhufeng", "珠峰");

 

    有些时候即使执行多次,也实现不了替换

    "zhufeng" -> "zhufengpeixun"

    str = str.replace("zhufeng", "zhufengpeixun").replace("zhufeng", "zhufengpeixun");

 

    [第一个参数可以是一个正则] 把所有和正则匹配的内容进行替换(但是和捕获一样默认是懒惰的,只有加上全局修饰符g才可以)

        var str = "zhufeng2015 zhufeng2016";

        str = str.replace(/zhufeng/g, "zhufengpeixun");

        console.log(str);

 

    1)执行和执行次数问题

    其实和exec捕获的原理是一模一样的

    例如：我们第二个参数如果传递的是一个函数,每当正则在字符串中捕获一次当前的这个函数就执行一次 ->本题中一共捕获了两次,所以函数执行了两次

    var str = "zhufeng2015 zhufeng2016";

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

     2)参数问题

      console.dir(arguments);

      不仅仅是执行function,而且还给我们的函数传递了参数,并且传递的参数和每一次exec捕获的内容是一模一样的

      如果是第一次exec捕获->["zhufeng",index:0,input:"原始字符串"]

      第一次执行函数里面的参数

      arguments[0] -> "zhufeng"/**/

      arguments[1] -> 0  相当于exec中的index 开始捕获的索引位置

      arguments[2] -> "原始字符串" 相当于exec中的input

 

     3)返回值问题

      return返回的是什么,就相当于把当前捕获的内容替换成什么

      return "zhufengpeixun";

    });

    console.log(str);

END
常用表达式
判断是有效数字的正则

   有效数字是指：正数、负数、零、小数

第一部分：可能出现加减或者没有

第二部分：一位数可以是0，多位数不能以0开头

第三部分：可以有小数也可以没有小数，但是一旦出现小数点，后面至少跟一位数字

var reg =/^[+-]?(\d|[1-9]\d+)(\.\d+)?$/;

有效的正整数（包含0）：/^[+]?(\d|[1-9]\d+)$/;

有效的负整数（包含0）：/^-(\d|[1-9]\d+)$/;

判断手机号（简单版）：

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

判断邮箱

第一部分：数字、字母、下划线、- 一到多位

第二部分：@

第三部分：数字、字母、 一到多位

第四部分：(.两到四位) .com   .cn   .net   ..      .com.cn

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

 

判断年龄在18到65之间的

18-19/20-59/60-65

var  reg =/^((18|19)|([2-5]\d)|(6[0-5]))$/

真实有效的中华人民共和国姓名 2-4 位汉字

var reg = /^[\u4e00-\u9fa5]{2,4}$/;

身份证号码

前六位是省->市->县（区）

四位年 两位月 两位日

简单版

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

    130828199012040617

复杂版

    var reg = /^(\d{2})(\d{4})(\d{4})(\d{2})(\d{2})(?:\d{2})(\d)(?:\d|X)$/;
第一个：0-99999（包含零）的整数 

/^(0|\+?[1-9][0-9]{0,4})$/

第二个：0-99999（包含零）带有两位小数

/^(0|\+?[1-9][0-9]{0,4})(\.\d{1,2})?$/（这里可能会有点问题 0.00不会校验）

第三个：0-9999（不包含0和0.00）带有两位小数

/^(0\.\d{0,1}[1-9]|\+?[1-9][0-9]{0,3})(\.\d{1,2})?$/

第四个：1-99999的整数

/^([1-9][0-9]{0,4})$/

第五个 ：1-99999 带有两位小数

/^(\d|[1-9]\d|99999)(\.\d{1,2})?$/

第六个：0-100保留两位小数

/^(\d{1,2}(\.\d{1,2})?|100)$/