正则基本详解

/^开首，末端$/
* 婚配0次或屡次
+ 婚配1-n次
？婚配0次或1次；  当?跟在 * + {n}  {n,m} {n,} 背面时，婚配形式黑白贪欲的
{n} 婚配确定是n次，n非负数
.  婚配除了换行符\n之外的任何字符 包括点自身
(?:pattern) 小括号中的内容只婚配不捕捉
(?=pattern) 正向预查
(?!pattern) 负向预查
x|y 婚配x或许y
[xyz] 婚配xyz中任何一个
[^xyz]婚配未包括xyz的恣意字符
[a-z]婚配指定局限的字符
[^a-z]婚配不在a到z局限内的恣意字符

\b 婚配一个单词的边境 /er\b/ 能婚配 never 中的er  不能婚配 verb 中的er
\B 婚配非单词边境

\d  恣意一个数字
\D  恣意一个非数字

\w 婚配包括下划线的恣意字符  [a-zA-Z0-9]
\W 婚配任何非单词字符

\s 空缺字符
\S 非空缺字符

\n 婚配恣意一个换行字符
\r 回车

reg.exec(str) 返回一个数组
[  0: 婚配到的大正则,  1: 婚配到的小分组1,  2: 小分组2，  3: 婚配到的第一个字符的索引,  4:input:全部str  ]

reg.test(str) 返回true/false


   // 1.反向援用  /(捕捉的小分组)\数字/
    var reg=/(\w)(\w)\2\1/;// \2 第二个小分组婚配到的内容,\1 第一个小分组婚配到的内容
    var str="woow";
    console.log(reg.exec(str));// ["woow", "w", "o", index: 0, input: "woow"]
 //
 //  var reg = /(捕捉的小分组)\数字/；  \数字 代表的是反向援用，示意 第几个括号内的子正则表达式所捕捉的内容，假如小分组加了(?:=pattern)，那末反向援用就不管用了。

    //2.小分组只婚配不捕捉  (?:=pattern)
    var reg1=/^(?:b|c).+/;
    var str1="bbs.www.baidu.cn";
    console.log(reg1.exec(str1));//  小分组只婚配不捕捉  (?:=pattern)
    //["bbs.www.baidu.cn", index: 0, input: "bbs.www.baidu.cn"]

    //3.正向预查(?=pattern) 请求婚配的时刻满足括号中的前提
    //  反向预查 (?!pattern) 请求婚配的时刻不满足括号中的前提
    //  小括号中的内容只婚配不捕捉
    var reg3=/cai(?=8)/;
    var str3="cai9";
    var str4="cai8";
    console.log(reg3.exec(str3));// null
    console.log(reg3.exec(str4));// ["cai", index: 0, input: "cai8"]
    var reg4=/zhufeng(?!shanshang)/;
    var string="zhufengshanshang";
    var string1="zhufengshanshang";
    console.log(reg4.exec(string));// null
    console.log(reg4.exec(string1));//  ["zhufeng", index: 0, input: "zhufengshanshang"]


    //4. 婚配元字符 * +  ？ .  就是它们自身就有特别意义的，须要转义 \
    var reg5=/c\*/;
    var str05="c*";
    console.log(reg5.exec(str05));//["c*", index: 0, input: "c*"]

    //5.全局修饰符 ，g  不辨别大小写 i ，行首行尾 m

    //6.[abc] a或b或c 中的恣意一个
    //  [^] 一切的非空字符 不是空格, ^在/^/是以...开首的意义。在[^]黑白的意义
    // [1-13] 从1到1或从1到3  不是1-13
    //[元字符] 示意元字符自身的意义，如 [.]示意点自身，不是 除了/n之外的任何字符

    //7. | 或许
    var reg06=/^(z|0).+/;
    var s="zhufeng";
    console.log(reg06.exec(s));// ["zhufeng", "z", index: 0, input: "zhufeng"]

    // 8.贪婪婚配：在正当的情况下，正则会只管多的去婚配字符，能婚配到4个，绝不会婚配3个
    //   非贪婪婚配：?  如 {n,}?  *?  +?  {m,n}?

    //9.c{n} 婚配牢固n个
    //  c{m,n} 婚配m到n个
    //  c{n,} 起码婚配n个，最多不限定

    //10.exec 与 全局修饰符g
    // 假如没加全局修饰符g，实行多少次都一样
    // 须要手动屡次实行，每次实行都邑举行新的婚配， 改变了正则的lastIndex的值
    var reg07=/(\w)(\w)(\w)/;
    var s1="bbs.baidu.cn";
    var result1=reg07.exec(s1);
    var result2=reg07.exec(s1);
    console.log(result1);// 假如没加全局修饰符g，实行多少次都一样
    console.log(result2);//["bbs", "b", "b", "s", index: 0, input: "bbs.baidu.cn"]

    var reg08=/(\w)(\w)(\w)/g;//须要手动屡次实行 改变了正则的lastIndex的值
    var result3=reg08.exec(s1);
    var result4=reg08.exec(s1);
    console.log(result3);//["bbs", "b", "b", "s", index: 0, input: "bbs.baidu.cn"]
    console.log(result4);//["zhu", "z", "h", "u", index: 4, input: "bbs.baidu.cn"]

    //11.match 字符串类要领  str.match(reg)
    //设置了全局修饰符g，会自动举行屡次婚配，并把婚配到的效果放入到数组中，注重没有index和input属性
    //match在没有分组的情况下可以更快速的把屡次婚配到的内容保存到数组中
    //exec正则类要领 reg.exec(str)  注重 两者写法完整不一样

    var reg09=/[bz]/;//不设置全局修饰符，效果和exec一样
    var s3="bbs.baidu.cn";
    console.log(s3.match(reg09));//["b", index: 0, input: "bbs.baidu.cn"]

    var regg=/[bz]/g;//设置了全局修饰符，会自动举行屡次婚配，并把婚配到的效果放入到数组中，注重没有index和input属性
    var res=s3.match(regg);
    console.log(res);//["b", "b", "z"]
    //12.replace(参数1：正则表达式 被替代的内容，参数2：字符串/函数 用来替代第一个参数婚配到的内容)
    //字符串要领 查找并替代  ，返回值 一个新的字符串
    //假如reg中有全局标志g，那末将替代一切婚配到的子串，不然，它只替代第一个婚配子串
    //当第二个参数不是字符串，是函数的时刻，每次婚配都挪用该函数，将这个函数返回的字符串 作为替代文本运用，这个函数自定义替代划定规矩
    //当第二参数是函数时，不仅自动实行此函数，还要给这个函数传3个参数
    //1.当正则没有分组时，传进去的第一个实参是正则捕捉到的内容，第二个参数是捕捉到的内容在原字符串中的索引位置，第三个参数是原字符串
    //2.当正则有分组的时刻，第一个参数是大正则查找到的内容，背面依次是子正则查找到的内容
    //3.传完查找到的内容以后，再把总正则查找到的内容在原字符串中的索引传进，末了传入原字符串
    var ostring="XaZZcUdFe";
    var oreg=/[a-z]/g;
    ostring=ostring.replace(oreg,function () {
      return arguments[0]+"("+arguments[1]+")";
    });
    console.log(ostring);// Xa(1)ZZc(4)Ud(6)Fe(8)
    //不加()小分组，arguments:[ 0:婚配到的字符，1：查找到的内容在str中的索引，2：原字符串 ]
    var ostr="456a89b72cs";
    var oreg11=/(\d)(\d)/g;
    ostr=ostr.replace(oreg11,function () {
      return  Number(arguments[1])+Number(arguments[2]);
    });
    console.log(ostr);//96a17b9cs

    var astr="a1b2c3d4";
    var rr=/[a-z]/g;
    astr=astr.replace(rr,function (result,position,string) {
      return `在${position}的位置找到了${result}，原字符串是${string};`;
    });
    console.log(astr);//在0的位置找到了a，原字符串是a1b2c3d4;
    // 在2的位置找到了b，原字符串是a1b2c3d4;2在4的位置找到了c，原字符串是a1b2c3d4;3在6的位置找到了d，原字符串是a1b2c3d4;4

str.search(reg)
str.split(reg,"")

未完待续。。。。