正则笔记

正则：

正则就是一个规则，用来处理字符串的规则
1.正则匹配
编写一个规则，验证某个字符串是否符合这个规则，正则匹配使用的test方法
2.正则捕获
编写一个规则，在一个字符串中把符合规则的内容都获取到，正则捕获使用的方法：正则的exec方法、字符串中的split、replace、match等方法都支持正则

var reg =/^$/;   //两个斜杠中间包含一些内容就是正则，两个斜杠之间包含的全部内容就是元字符

正则的创建方式：

1.通过字面量方式创建的正则，不能引用变量所存储的值
    var name = "zhufeng";
    var reg = /\d+"+name+"+/;
    //    var str = "12zhufeng";
    //    console.log(reg.test(str));// false;
    var str1 = '12""nameeeee""';
    console.log(reg.test(str1));// true;
    //    var  str = "ab"+name+"cd";
 2.实例创建： new  + 正则类，返回一个正则的实例，
    // 1.要在转义字符前再加上一个转义字符，那么第二个转义字符才有转义的功能
    // 2. 实例创建的正则可以放入变量
    var reg = new RegExp("\\d" + name + "\\d");
    //    console.log(reg.test("12"));// true
    console.log(reg);
    console.log(reg.test("1name3"));// false
    console.log(reg.test("1zhufeng3"));// true

正则的方法:

test :匹配 在RegExp这个类上的原型上;
如果里面有符合的内容返回true 不符合返回false
exec:捕获 把字符串中符合正则的字符找到并以数组的形式返回
返回值:
1.代表捕获的内容
2.代表当前被捕获字符串的索引
3.代表当前整个字符串

replace:替换
match：字符串中的正则捕获

        var str = "zfpx1zfpx2zfpx3";
        var a =str.replace("zfpx","珠峰培训").replace("zfpx","珠峰培训");//“珠峰培训1珠峰培训2zfpx3”
        var b =str.replace("zfpx","珠峰培训")
      var str = "zhufeng1zhufeng2zhufeng3";
var a   =str.replace("zhufeng","zhufengpeixun").replace("zhufeng","zhufengpeixun");  //“zhufengpeixunpeixun1zhufeng2zhufeng3”
          var b =str.replace("zhufeng","zhufengpeixun")
replace 的第一个参数可以是正则
    var  str = "zhufeng1zhufeng2";   //    console.log(str.replace(/zhufeng/g, "珠峰培训"));
    str.replace(/zhufeng/g,function () {
        // 匹配几次，当前回调函数执行几次
        // arguments[0]代表当前正则在这个字符串中捕获的内容
        // arguments[1] 代表正则在字符串中捕获开始的索引位置；
        console.log(arguments); 
        })

replace实战一：

需求：把字符串中的数字，替换成大写
    var date = "20171129";
    var data = ["零","壹","贰","叁","肆","伍","陆","柒","捌","玖","拾"];


   var newDate=date.replace(/\d/g,function(){
       console.log(arguments);     //["2", 0, "20171129", callee: ƒ, Symbol(Symbol.iterator): ƒ]
       return data[arguments[0]]
   });
    console.log(newDate);

replace替换的原理：

1.replace(“old”,”new”); replace(/reg/,”new”):用新的字符串替换正则捕获 的内容
2.replace(/正则/，function(){

1). arguments[0] : 捕获的内容 arguments[1] : 捕获的内容的索引 arguments[2] : 整个字符串
2).return +内容 ： 替换正则捕获到的内容

})

replace实战二：

    var str = "2017-11-29 12:12:30";
    // 把这个字符创变成2017年10月17日  12时56分30秒;
    var  data = ["年","月","日","时","分","秒"];
    var newStr = "";
    var i=0;
    var a =str.replace(/\d+/g,function () {
        newStr+=arguments[0]+data[i];
        i++;
    });
    console.log(newStr);

replace实战三：

  var str = "my name is niu xiao xin, i am 26 years old";
  //把单词首字母变成大写
     var a =str.replace(/\b[a-z]/g, function () {
        return  arguments[0].toUpperCase();
    })
    console.log(a);
    //或者:
     var c=str.replace(/[a-z]+/ig,function () {
        var a =arguments[0].substr(0,1).toUpperCase();
        var b =arguments[0].substr(1);
        return a+b;
    })
    console.log(c);

match

 var  str = "123.678";
    var reg = /^[+-]?(\d|([1-9]\d+))(\.\d+)?$/;
    //    console.log(reg.exec(str));
    // match : 字符串原型上的方法
    console.log(str.match(reg));   //["123.678", "123", "123", ".678", index: 0, input: "123.678"];

正则的千分符：

 var str = "869169886383468";// "8,169,886,383,468";
    var  reg = /^(\d{1,3})?((\d{3})+)$/;
    var newStr = "";
    str.replace(/^(\d{1,3})?((\d{3})+)$/g,function () {
        var part1 = arguments[1];
        var part2 = arguments[2];
        newStr += part1+","+ part2.replace(/\d{3}(?!\b)/g,function () {
                return arguments[0]+",";
            });
    });
    console.log(newStr);   // "8,169,886,383,468";

正则的特性：懒惰性和贪婪性

 1.捕获的懒惰性
     正则捕获取消懒惰性的原理：
     reg.lastIndex : 属性值是下一次捕获索引开始的位置，当捕获一次完成后，那么正则会默认记录当前捕获到的位置，下一次进行捕获时，从当前索引开始；
          console.log(reg.test("123"));// true
         console.log(reg.exec("zhufeng123peixun456"));//["123", index: 7, input: "zhufeng123"]
      索引0 是代表捕获内容  index ： 捕获内容开始的索引位置  input ： 要对谁进行捕获的整个内容
     ["123", index: 7, input: "zhufeng123peixun456"]
        console.log(reg.exec("zhufeng123peixun456"));
         var reg = /\d+/g;
         console.log(reg.lastIndex);      //0
         console.log(reg.exec("zhufeng123peixun456"));//["123", index: 7, input: "zhufeng123peixun456"]
          console.log(reg.lastIndex);      //10
          console.log(reg.exec("zhufeng123peixun456"));//["456", index: 16, input: "zhufeng123peixun456"]
 2.贪婪性
    var reg = /\d+?/g;
      ? 问号放在量词的后面，取消正则捕获的贪婪性；
    console.log(reg.lastIndex);         //0
    console.log(reg.exec("zhufeng123peixun4568898"));  //["123", index: 7, input: "zhufeng123peixun456"]
    console.log(reg.lastIndex);         //10
    console.log(reg.exec("zhufeng123peixun456"));

正则的元字符和修饰符

任何一个正则都是由元字符和修饰符组成的；修饰符可以没有元字符至少要有一个

修饰符

g(global):全局匹配
i(ignoreCase):忽略大小写匹配
m(multiline):多行匹配

元字符
量词元字符：
+：让前面的元字符出现一到多次
？：让前面的元字符出现零或一次
*：让前面的元字符出现零到多次
{n}：让前面的元字符出现n次
{n，}：让前面的元字符出现n到多次
{n，m}：让前面的元字符出现n到m次

特殊意义的元字符：
\：转义字符(把一个普通字符转变为有特殊意义的字符，或者把一个有意义的字符转化为普通的字符)
.：除了\n(换行符)以外的任意字符
\d：匹配一个0-9之间的数字
\D：匹配任意一个非0-9之间的数字（大写字母和小写字母的组合正好是反向的）
\w：匹配一个0-9或字母或_之间的字符
\s：匹配一个任意的空白字符
\b：匹配一个边界符
x|y:匹配x或者y中的一个
[a-z]：匹配a-z中的任意一个字符
0[^a-z]:和上面的相反，匹配任意一个非a-z的字符
[xyz]：匹配x或者y或者z中的任意字符
[^xyz]：匹配出了xyz以外的任意字符
()：正则的小分组，匹配一个小分组（小分组可以理解为大正则中的一个小正则）
^：以某一个元字符开始(在中括号里面的^表示非)
$：以某一个元字符结束
?: ：只匹配不捕获
?= ：正向预查：匹配符合才捕获
?!：负向预查：匹配不符合就捕获
….
除了以上特殊元字符和量词元字符，其余的都叫普通元字符：代表本身意义的元字符

元字符的详细解读

^ $开始符和结尾符

var reg =/\d+/;  //出现一到多个连续出现的数字
var str ="珠峰2017培训2018";
reg.test(str)  =>true

var str ="珠峰2017培训2018";
reg =/^\d+/;   //以一到多个数字开头
reg.test(str)  =>false

reg =/^\d+$/;  //以一到多个数字开头以一到多个数字结尾
`如果在//中加了^$两个表示只能是中间的字符`在这里表示中间只能是数字
var str ="珠峰2017培训2018"
reg.test(str)  =>false
var str ="2017"
reg.test(str)   =>true
var str ="2"
reg.test(str)   =>true 

`^或者$只是一个修饰或者声明，不会占据字符串的位置，当字符串中^$都不加，表示只要包含某某某即可`

\转义字符：

经常用于本来有特殊含义但是我们想要转化为普通的字符，只对\右边的字符起作用；在正则里面出现\就只是斜杠，不是转义字符的意思

var reg =/^2.3$/   .在正则中的意思：匹配除了\n以外的任意字符,而不是单纯的小数点
reg.test('2.3')   =>true
reg.test('2+3')   =true

var reg =/^2\.3$/  在.前面加了\表示使用转义字符把点转化为了小数点的意思
reg.test('2.3')   =>true
reg.test('2+3')   =false

x|y匹配x或者y中的一个:经常配合()使用

var reg=/^0|1$/  //以0或者1开始或者结束
reg.test('0')   =>true
reg.test('1')   =>true
reg.test('01')  =>true

var reg=/^18|19$/ //以18或者19开始或者结束；以1开始以9结束，中间是8或者1
reg.test('18')  =>true
reg.test('189')  =>true
reg.test('819')  =>true
reg.test('1819')  =>true
reg.test('18珠峰')  =>true

var reg =/^(18|19)$/  //此时只有18或者19符合我们的规则了
reg.test('18')  =>true
reg.test('19')  =>true
reg.test('819')  =>false
reg.test('1819')  =>false
reg.test('18珠峰')  =>false

()：小分组

1、正则中的分组，也可以理解为一个大正则中的一个小正则（包起来的部分是一个整体）；
小分组的作用：

改变一些默认的优先级
分组引用
分组捕获

2、分组引用：\1 或者 \2 … \N 出现和第N个分组一模一样的内容

var reg =/^([a-z]([a-z])\2([a-z]))$/; =>以a-z开始以a-z结束，中间出现两一样的a-z的字母
reg.test('food')  =>true
reg.test('foad')  =>false
reg.test('week')  =>true
reg.test('oppo')  =>true

3、分组捕获：捕获时不仅对大正则进行捕获，小正则也会进行捕获一次

var reg =/^-?(\d|([1-9]\d+))(\.\d+)?$/
reg.exec("13.88")    // ["13.88", "13", "13", ".88", index: 0, input: "13.88"]
//想要小正则不捕获到可以用?:
//?:放在小括号的前面，只匹配不捕获
var reg =/^-?(?:\d|(?:[1-9]\d+))(?:\.\d+)?$/
reg.exec("13.88")    // ["13.88", index: 0, input: "13.88"]
reg.test("13.88")    //true

[]

[]中出现^表示非

\w：数字字母下划线中的任意一个字符
var reg =/^[a-zA-Z0-9_]$/;   =>等价于 \w 

[]中出现的元字符一般都代表本身的含义
[]中不识别两位数

var reg =/^[.?+&]+$/
中括号里面的元字符都是本身的含义。例如：点就是小数点，不是所谓的出\n以外的任意字符了

//需求：描述样式类名的规则（数字、字母、下划线、-;并且不能以-开头）
var reg =/^[\w-]$/
var reg =/^[0-9a-zA-Z_-]+$/;  //没有处理以-开头的情况
var reg =/^\w[\w-]*$/;  //这个是标准的样式类名的规则

在中括号中想要-本身的含义，只需要让-只有一面有东西即可

//需求：验证18到65之间的年龄
var reg =/^[18-65]$/  =>1或者8-6或者5中的任意一个字符，中括号中出现的18不是数字18，而是1或者8，当前正则是非法的；因为不能设置8-6这种范围；范围只能从小到大，不能从大到小
//当前需求应分三阶段处理：
//18或者19   (18|19)
// 20-59    ([2-5][0-9]) 或者([2-5]\d)
// 60-65    (6[0-5])
var  reg =/^((18|19)|([2-5]\d) |(6[0-5]))$/

?: ?!正负向预查

 ?=  ： 正向预查 : 必须满足正则中的条件才可以捕获到内容，而且只对小括号外面的内容进行捕获，里面的内容只匹配不捕获；如果捕获不到内容返回，返回null；
    var reg = /zhufeng/;
    console.log(reg.exec("zhufeng8"));//["zhufeng", index: 0, input: "zhufeng8"]
    var reg = /zhufeng(?=peixun)/;
    console.log(reg.exec("zhufeng8"))//null
    var reg = /zhufeng(?=peixun)/;
    console.log(reg.exec("zhufengpeixun8"))// "zhufeng"
 ?!: 只要不是括号中的条件才可以捕获到内容，否则就是null；
    var reg = /zhufeng(?!js)/;
    console.log(reg.exec("zhufeng123"));

常用的正则表达式编写：

验证是否为有效数字：

//可能是正数，可能是负数
//整数或者小数
//只要出现小数点，后面至少要跟一位数字
//小数点前面必须有数字
var reg =/^-?(\d|([1-9]\d+))(\.\d+)?$/;
//  -?  负号-可有可无
//  (\d|([1-9]\d+))  \d 一位数可以是任何值
//  ([1-9]\d+)   多位数不能以0开头
//  (\.\d+)?     小数部分可有可无，有的话.后面必须跟一位数字

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