创建正则表达式
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} 可以匹配包含大写字母，小写字母，数字