正则基础知识

创建正则表达式

1.使用new来创建

 var exp = new RegExp('box' , 'gi' );

　　

g	全局匹配
i	忽略大小写
m	多行匹配

　　

2.使用字面量

var exp =/box/gi;

　　

直接用2个 / ;

在俩个斜杠后加上模式修饰符；

俩种创建方式比较:

1.使用字面量方式创建用的更加广泛;

2.当要匹配的内容是变量时,只能使用new来创建.

正则表达式的测试

1.test( )

正则表达式对象.test(字符串)

参数：要匹配的字符串

返回值：匹配成功返回true，失败返回false

例1:
var exp = /Box/i;
var str = 'box' ;
alert(exp.test(str));
=>   true     忽略大小写 ；

　　

例2:
var exp = /abc/g;
var str = 'abcab';
var res = exp.test(str);
console.log(res);
console.log(exp.test(str));
console.log(exp.test(str));
=>   true       //从第一个开始匹配,匹配到了abc 返回true;   
=>   false      //由于开启了全局匹配,所以从上次匹配之后的位置开始匹配(也就是从第二个a开始);   若没有g 则每次都会从头开始匹配
=>   true       //由于上次匹配是false并且已经将字符串str查找完了,所以又从头开始匹配

　　

注:

​ 开启了全局匹配g后,正则表达式内部有一个lastIndex的属性,用以记录下次开始查找的下标,保证其每次从lastIndex的位置开始查找

例3:
var exp = /abc/g;                   //同一正则表达式匹配不同字符串
var str1 = 'abc';
var str2 = 'abcab';
console.log(exp.test(str1));
console.log(exp.test(str2));
=>   true;              //从str1的0位开始匹配,匹配到了abc,返回true,  此时lastIndex为3
=>   false;             //从str2中lastIndex的位置开始匹配,也就是从第二个a开始

　　

例4:
var exp1 = /abc/g;                  //不同正则表达式匹配同一字符串
var exp2 = /abc/g;
var str = 'abc';
console.log(exp1.test(str));
console.log(exp2.test(str));
=>   true;              //从str1的0位开始匹配,匹配到了abc,返回true
=>   true;              //从str1的0位开始匹配,返回true

　　

2.exec( )

exec(字符串)：该方法为专门为捕获组而设计的

参数：要匹配的字符串

返回值：返回的是一个数组。如果不匹配则返回null

关于返回值数组的说明：

它确实是Array的实例。

但是这个数组有两个额外的属性：index和 input

index：表示匹配的字符串在源字符串中的索引

input：表示匹配的源字符串。

数组的第一项是与整个模式匹配的字符串，其他项是与模式中捕获组匹配的字符串

如果没有捕获组，则数组中只有第一项。关于捕获组的概念以后再说

例1:
        var exp = /abc/gi;
        var str = "aaabcccdabcAbcAdaBc";
        var strNew = "";
        while (strNew=exp.exec(str)){           //使用while循环,将所有匹配到字符串输出来
            console.log(strNew[0])              //由于返回的是一个带有很多属性的数组,所以我们只要数组中的字符串,也就是索引为0.
        }

　　

正则表达式的规则

字符类:单个字母数字下划线
.                                   //匹配除换行符外的任意字符(当点放在[]中是，没有特殊意义)
var exp = /d/g;                    // [0-9]
var exp = /D/g;                    //[^0-9]
var exp = /w/g;                    //[a-zA-Z0-9_];
var exp = /W/g;                    //[^a-zA-Z0-9_];

　　

字符类:空白字符
                             匹配null 字符
                             匹配退格字符

                             匹配换行符

                             匹配回车字符
	                             匹配制表符
s                             匹配空白字符、空格、制表符和换行符
S                             匹配非空白字符

　　

单词边界

示例
/cat/  匹配到cat这个单词

　　

/B 非单词边界

　　

元字符/元符号                    匹配情况
^                             行首匹配
$                             行尾匹配

　　

字符类：重复字符
元字符/元符号                                匹配情况
?  例如（x?）                            匹配0个或1 个x
*  例如（x*）                            匹配0个或任意多个x
+  例如（x+）                            匹配至少一个x
(xyz)+                                     匹配至少一个(xyz)
{m,n} 例如x{m,n}  n>=次数>=m            匹配最少m个、最多n个x
{n}                                        匹配前一项n次     
{n,}                                    匹配前一项n次，或者多次

　　

1.[ ]

匹配[ ]内的任意一个字符

var exp = /[abc]/gi;                // []内代表匹配其中的一个字符: a 或 b 或 c
var exp = /[a-zA-Z0-9_$]/g;         //匹配26个大小写字母,0-9数字,下划线_  美元符$ 中的任意一个;
var exp = /[^a-zA-Z]/g              //匹配任意不在括号中的字符集中的字符;
[ ]也可以配合? * + {} 来使用; 如[a-z]+ 匹配至少一个[a-z]范围内的任意一个;

　　

2. ^

俩种用法:

1.放在[ ] 内 表示非

var exp = /[^a-zA-Z]/g              //匹配任意不在括号中的字符集中的字符;

2.放在[ ] 外,表示行首匹配

var exp = /^d/g;                   //规定行首必须是数字     
var str = '123qq';                  
console.log(exp.test(str));         //行首为数字1,返回true;  
console.log(exp.lastIndex);         //此时lastIndex 为1
console.log(exp.test(str));         //从下标为1的位置开始匹配,虽然下标为1的位置是数字,但却不是行首,返回false;

　　

3. $

表示行尾匹配,用法与^ 相近

^ 和 $ 合用

var exp = /^dd$/g;                //规定行首和行尾必须是数字
var str = '12';
var str2 = '123';
        console.log(exp.test(str));     // true
        console.log(exp.lastIndex);     // 2
        console.log(exp.test(str));     //false
        console.log(exp.lastIndex);     //0
        console.log(exp.test(str));     //true
        console.log(exp.test(str2));    //false     //exp中规定了行首行尾为数字,中间无内容

　　

4. .

匹配除换行符外的任意字符(当点放在[ ]中是，没有特殊意义)

var exp = /./g;
var str = 'a';
console.log(exp.test(str));
=>    true

　　若想匹配它本身.

var exp = /./g;

　　

5. |

择一匹配(管道符号) 表示或

var exp = /a|b/g;
var str = 'a';
console.log(exp.test(str));
=>    true

　　数量词的匹配:默认都是贪婪匹配

6. ?

匹配0个或者1个

7. *

匹配0个或者多个

var exp = /a*/g;
var str = 'aaaaa';
    console.log(exp.test(str));         //true
    console.log(exp.test(str));         //true

　　

8. +

匹配1个或多个

var exp = /a+/g;
var str = 'aaaaa';
    console.log(exp.test(str));         //true
    console.log(exp.test(str));         //false

　　

9. {n}

匹配n个,只能是n个

10. {n,}

匹配至少n个

11. {n,m}

匹配至少n个,最多m个

基本的正则表达式验证

写一个正在表达式,判断手机号是否合法
var exp = /1[34578]d{9}$/g;
var str = '13979318939';
    console.log(exp.test(str));
=> true
写一个正在表达式,判断邮箱是否合法
var exp = /^w{3,15}@[w-]+.(com|cn|net|org|edu|com.cn)$/gi;
var str = '133_d@cn.com.cn';
    console.log(exp.exec(str)[0]);
=>  133_d@cn.com.cn   
写一个正则表达式,判断图片的地址是否合法
var exp = /^(http|https)://.+.(jpg|jpeg|gif|png)$/gi;
var str = 'http://3323498dsfledf.png';
    console.log(exp.exec(str)[0]);
=>  http://3323498dsfledf.png
写一个正则表达式,爬取一堆字符串中的所有图片地址
var exp = /http://[^:]+.(jpg|jpeg|gif|png)/gi;
写一个正则表达式,将字符串中的重复去掉
var exp = /(.)1+/gi;
var str = "aabbccdd";   
    console.log(str.replace(exp,'$1'));
=>  abc

　　

分组
其中分组体现在：所有以(和)元字符所包含的正则表达式被分为一组，每一个分组都是一个子表达式，它也是构成高级正则表达式的基础。如果只是使用简单的(regex)匹配语法本质上和不分组是一样的，如果要发挥它强大的作用，往往要结合回溯引用的方式。

var str = '123-mm';
var strReg = str.replace(/(d+)-([A-Za-z]+)/g,'$2');
console.log(strReg)//mm  上面那段$2这个就是表示正则第二组个匹配到的内容

　　

方法

1.search( )

str.search(exp);

检索与正则表达式相匹配的第一个匹配项的索引。

返回值: 索引 ,没有返回-1;

　　注:search( )不支持全局,每次调用总是从0开始查找.加不加g都一样

2.match( )

str.match(exp);

把满足正则表达式的所有字符串一起返回

返回值: 数组 ,没有返回null;

var str = "abc134ABC244co9";
    console.log(str.match(/d+/gi));            //获取str中的所有数字的数组
=>  ["134","244","9"]

　　注:如果想获取所有的满足的,应该使用全局g,使用全局的时候,分组的信息则拿不到

3.replace( )

str.replace(exp,newStr);

将正则表达式替换

返回值: 替换之后的字符串

var str = "123aaa244";
    console.log(str.replace(/d/gi,""));        //将str中的数字全部去掉
=>  aaa     


写一个正则表达式,将字符串中的重复去掉
var exp = /(.)1+/gi;
var str = "aabbccdd";   
    console.log(str.replace(exp,'$1'));
=>  abc  

　　

4.split( )

str.split(exp,length);

length:可选参,切出来的数组的最大长度

使用split 拆分成字符串数组

返回替换之后的字符串



var str = "102dsfe00dfefsf55";
var exp = /D+/gi;                              //用所有非数字来切割
    console.log(str.split(exp));    
=>  ["102","00","55"]

　https://www.cnblogs.com/moqing/archive/2016/07/13/5665126.html

/**
 * @description:万能判断
 * @param {type}
 * value/判断的焦点
 * type:   1/false(默认undefind也是false) 2/与焦点比对类型(小写)
 * @return:1/焦点类型(小写)                2/boolean
 */
function checkType(value, type) {
  const prototypeString = Object.prototype.toString.call(value)
  const typeString = prototypeString.replace(/S*s|]/gi, '').toLowerCase()
  return type ? type == typeString : typeString
}
export default checkType

　　

匹配出现a或者b组合一起至少3次以上/(a|b){3,}/,匹配aaa,bbb,aab,baa,bba,bab等等

　　

 

正则表达式------捕获性分组，非捕获性分组，前瞻，后瞻


捕获性分组
javascript中捕获性分组是以小括号()来实现，捕获性分组工作模式()会把每个分组里匹配的值保存起来。

比如利用捕获性分组把 hello world 互换成 world hello：

方法一：通过exec函数

var str = 'hello world';            //首先创建好字符串
var pattern = /([a-z]+)s([a-z]+)/; //先通过正则匹配这个字符串，用分组模式来获取这两个单词
var arr = pattern.exec(str); // exec方法返回的是一个数组，包含匹配到的字符串以及分组(也称子串)里的值

console.log(arr); //['hello world','hello','world']  
console.log(arr[0]); //'hello world' 匹配到的字符串
console.log(arr[1]); //'hello' 第一个分组([a-z]+)的值
console.log(arr[2]); //'world' 第二个分组([a-z]+)的值

//这时候两个分组的值都得到了,接下来用字符串拼接法实现互换
var n_str = arr[2]+' '+arr[1];
console.log(n_str) //world hello


方法二：通过属性$1-9


var str = 'hello world';            
var pattern = /([a-z]+)s([a-z]+)/; 
pattern.test(str); //这个地方必须运行正则匹配一次，方式不限，可以是test()、exec()、以及String的正则方式

console.log(RegExp.$1) //'hello' 第一个分组([a-z]+)的值
console.log(RegExp.$2) //'world' 第二个分组([a-z]+)的值

var n_str = RegExp.$2+' '+RegExp.$1;
console.log(n_str) //world hello


方法三：通过String的replace()

var str = 'hello world'; 
var pattern = /([a-z]+)s([a-z]+)/; 
var n_str = str.replace(pattern,"$2 $1"); //这里的$1、$2与方法二里的RegExp.$1、RegExp.$2作用是相同的。
console.log(n_str) //world hello

非捕获性分组：(?:)
非捕获性分组工作模式下分组(?:)会作为匹配校验，并出现在匹配结果字符里面，但不作为子匹配返回。

比如利用非捕获性分组获取字符串000aaa111，而且只返回一个值为aaa111的数组：


//先看用捕获性分组匹配会返回什么
var str1 = '000aaa111';             
var pattern = /([a-z]+)(d+)/; //捕获性分组匹配
var arr = pattern.exec(str1);  
console.log(arr) //['aaa111','aaa','111']   结果子串也获取到了，这并不是我们想要的结果


//非捕获性分组
var str2 = '000aaa111';
var pattern2 = /(?:[a-z]+)(?:d+)/; //非捕获性分组匹配
var arr2 = pattern.exec(str2);  
console.log(arr2) //['aaa111']  结果正确  

前瞻：(?=)和(?!)
前瞻分为正向前瞻和反(负)向前瞻，正向前瞻(?=表达式)表示后面要有什么，反向前瞻(?!表达式)表示后面不能有什么。

前瞻分组会作为匹配校验，但不出现在匹配结果字符里面，而且不作为子匹配返回。

正向前瞻匹配一批图片格式：
//正向前瞻，匹配.jpg后缀文件名
var str = '123.jpg,456.gif,abc.jpg';
var partern = /w+(?=.jpg)/g; //正向前瞻匹配
console.log(str.match(partern)); //['123', 'abc']   返回结果正确，没有匹配456.gif


反向前瞻匹配一批字母加数字：
//反向前瞻，匹配3个及以上的a，而且后面不能有000的字符
var str = 'aaa000 aaaa111 aaaaaaa222';
var partern = /a{3,}(?!000)/g; //反向前瞻匹配
console.log(str.match(partern)); //['aaaa', 'aaaaaaa']   返回结果正确，没有匹配aaa000


前瞻,可以放在位置不固定，可前匹配和后匹配，如：/(?=.jpg)w+/g;

后顾：(?<=)和(?<!) —JavaScript不支持
后顾分为正向后顾和反(负)向后顾，正向后顾(?<=表达式)表示前面要有什么，反向后顾(?<!表达式)表示前面不能有什么。
/正向后顾
(?<=abc) //前面需要有abc

//反向后顾
(?<!abc) //前面不能有abc


名词解释:

前瞻 = 先行断言
(?=) 正向前瞻 = 正向零宽先行断言
(?!) 反向前瞻 = 负向前瞻 = 负向零宽先行断言

后顾 = 后发断言
(?<=) 正向后顾 = 正向零宽后发断言
(?<!) 反向后顾 = 负向后顾 = 负向零宽后发断言

备注，总结
可以通过多个前瞻组合一块控制，字符串里边必须包含指定字符。
示例：
(?=.[0-9].)(?=.[A-Z].)(?=.[a-z].).{6,20} 可以匹配包含大写字母，小写字母，数字