JavaScript正则表达式基础

创建正则表达式，一般有两种写法

//定义式创建正则，写法：两个斜杠中间放正则式子
const reg = /abc/;
//new关键字创建正则，写法：两个斜杠中间放正则式子或直接去掉斜杠放字符串式表达式
const regExp = new RegExp('abc')

.test('需要验证的字符')，正则的方法用来验证正则的匹配结果true or false

修饰符

写法：/正则/ 修饰符

示例：/abc/i (匹配字符串abc并且不区分大小)

i：执行对大小写不敏感的匹配（不区分字母的大小写）

g：执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）

m：执行多行匹配

其他：修饰符还有其他的一般用的少，常用的基本就上面三个

正则分类

预定义类

// .的意思是除了换行和回车之外的任意字符
//如果检测的字符串里面包含 除了换行和回车之外的任意字符 那就返回true,否则返回false.
console.log(/./.test("\r"))// false   \r代表return，return表示回到一行的开头
console.log(/./.test("\n"))//false    \n代表newline,新的一行
console.log(/./.test("\r\n"))//false   \r\n表示换行并将光标定位到一行的开头
console.log(/./.test(""))//false
console.log(/./.test("12klk"))//true	
 
// \d表示数字，d是英文digit的意思
console.log(/\d/.test("kjdksj"));//false
console.log(/\d/.test("kj7ksj"));//true	
 
// \D表示非数字的意思
console.log(/\D/.test("kjdksj"));//true
console.log(/\D/.test("k2"));//true
console.log(/\D/.test("12345"));//false	
 
// \s表示表示不可见字符
console.log(/\s/.test("\t"));//true  \t 表示制表符
console.log(/\s/.test("\f"));//true  \t 表示换页符
console.log(/\s/.test("\v"));//true	 \v 表示垂直制表符
console.log(/\s/.test("\n"));//true	 \n 换行符
console.log(/\s/.test("\r"));//true	 \r 回车符
console.log(/\s/.test(" "));//true	
console.log(/\s/.test("jhsjhsdh"));//false	
 
// \S表示表示可见字符 跟小s相反
console.log(/\S/.test("\t"));//false  
console.log(/\S/.test("jinitaimei"));//true  
 
 // \w表示单词字符（所有单词和数字以及下划线_）
 console.log(/\w/.test("rerer3434"));//true  
 console.log(/\w/.test("3434"));//true  
 console.log(/\w/.test("wewewe"));//true  
 console.log(/\w/.test("___	"));//true  
 console.log(/\w/.test("@##$$"));//false  
 
 // \W表示非单词字符（所有非单词和数字以及下划线_）
 console.log(/\W/.test("rerer3434"));//false  
 console.log(/\W/.test("3434"));//false  
 console.log(/\W/.test("wewewe"));//false  
 console.log(/\W/.test("___wewe"));//false  
 console.log(/\W/.test("@##$$"));//true  

自定义类

  console.log(/鸡/.test("鸡霓太美"));//true
  console.log(/鸡/.test("基尼太美"));//false

或跟优先级

	// a|b 表示或,此处表示字母a或者b
	console.log(/a|b/.test("asasas"));//true
	console.log(/a|b/.test("sbbbbbbbb"));//true
	console.log(/a|b/.test("dfdfdfdf"));//false
	
	// q(a|b)q 表示优先计算(a|b)，跟普通的数学运算一样
	console.log(/q(a|b)q/.test("qaq"));//true
	console.log(/q(a|b)q/.test("qbq"));//true
	console.log(/q(a|b)q/.test("qaa"));//false
	console.log(/q(a|b)q/.test("qqqq"));//false

简单类

	// [abc]表示abc中的任意一个
	console.log(/[abc]/.test("qaq"));//true
	console.log(/[abc]/.test("bbbc"));//true
	console.log(/[abc]/.test("cc1213"));//true
	console.log(/[abc]/.test("dddfff"));//false
	console.log(/a[abc]a/.test("aaa"));//true
	console.log(/a[abc]a/.test("aca"));//true
	console.log(/a[abc]a/.test("aa"));//false

 范围类

	// [a-z]表示范围类a到字母z,[0-9]表示范围类0到数字9
	console.log(/[a-z]/.test("qaq"));//true
	console.log(/[a-z]/.test("cc"));//true
	console.log(/[a-z]/.test("2323"));//false
	console.log(/[0-9]/.test("2"));//true
	console.log(/[0-9]/.test("20"));//true
	console.log(/[0-9]/.test("wewe"));//false

负向类

	// [^aa]表示除aa字符以外的任意字符
		console.log(/[^aa]/.test("aa"));//false
		console.log(/[^aa]/.test("vvvvvvvvaa"));//true
		console.log(/[^aa]/.test("wewewe"));//true
		console.log(/[^aa]/.test("12wewea"));//true

组合类

// [^a-d][^1-4],[^a-d]表示字母a-d之外,[^1-4]表示数字1-4之外,两个中括号表示至少要两个字符
console.log(/[^a-d][^1-4]/.test("aa"));//false
console.log(/[^a-d][^1-4]/.test("a5"));//false
console.log(/[^a-d][^1-4]/.test("d"));//false 数量及条件都不满足
console.log(/[^a-d][^1-4]/.test("f"));//false 数量不满足
console.log(/[^a-d][^1-4]/.test("f5"));//true
console.log(/[^a-d]|[^1-4]/.test("f"));//true  中间加了一个条件|(或)
console.log(/[^a-d](11|22)/.test("a11"));//false   
console.log(/[^a-d](11|22)/.test("e12"));//false  
console.log(/[^a-d](11|22)/.test("e11"));//true  

边界与严格匹配 

//  /^a/ ^a表示以a开头的字符, /c$/c$表示以c结尾的字符
console.log(/^a/.test("abc"));//true 
console.log(/^a/.test("Aabc"));//false 
console.log(/c$/.test("abc"));//true 
console.log(/c$/.test("abccc"));//true 
 
//  /^$/表示严格匹配^$两个符号中间的正则,且只能出现一次
console.log(/^ac$/.test("ac"));//true
 // 当^跟$同时出现的时候即为严格匹配两个符号中间的正则而不仅仅是开头跟结尾了 
console.log(/^ac$/.test("abc"));//false 此处正则为严格匹配自定义类ac字符，而非以a开头c结尾
console.log(/^ac$/.test("acac"));//false 严格模式只能出现一次，多次则为false
console.log(/^ac$/.test("acs"));//false 

 量词

// 量词:
// 1.*表示出现零次或者多次 result>=0
// 2.+表示出现一次或者多次 result>=1
// 3.?表示出现零次或一次 result=(0||1)
// 4.{n}表示只能出现n次,n是任意大于等于0的数字
// 5.{n,}表示大于等于n的次数,n是任意大于等于0的数字
// 6.{n,m}表示大于n小于m的次数,n跟m是任意大于等于0的数字
// 此处的多次表示量词前面的正则字符匹配结果
console.log(/^abc*$/.test("abc"));//true  ab符合，c出现了一次，符合严格模式，所以为true
console.log(/^abc*$/.test("ab"));//true  ab符合，c出现了零次，符合严格模式，所以为true
console.log(/^abc*$/.test("ac"));//false a开头符合了,c出现了一次符合了，但是没有b，所以false
console.log(/abc*/.test("ac"));//false a有了,c出现了一次符合了，但是没有b，所以false
console.log(/^abc*$/.test("abcccc"));//true ab都有了且c出现了多次，符合严格模式，所以false
console.log(/^abc*$/.test("abbcccc"));//false ab都有了但没有abc连续，所以false
console.log(/^abc*$/.test("abcabc"));//false  ab符合，c也出现了一次，但不符合严格模式，所以为false
 
console.log(/^abc+$/.test("abc"));//true  ab符合，c出现了一次，符合严格模式，所以为true
console.log(/^abc+$/.test("ab"));//false  ab符合，c出现了零次，所以为false
console.log(/^abc+$/.test("abccc"));//true  ab符合，c出现了多次，所以为true
console.log(/^abc+$/.test("abdccc"));//false  ab符合，但是没有连续的abc,所以为false
console.log(/^abc+$/.test("abcabc"));//false  不符合严格模式
 
console.log(/^abc?$/.test("abc"));//true  ab符合，c出现了一次，符合严格模式，所以为true
console.log(/^abc?$/.test("ab"));//true  ab符合，c出现了零次，符合严格模式，所以为true
console.log(/^abc?$/.test("abcc"));//false  ab符合，c出现了多次，所以为false
 
 
console.log(/^abc{2}$/.test("abcc"));//true  ab符合，c出现了2次，所以为true
console.log(/^abc{2}$/.test("abc"));//false  c只出现了1次，所以为false
console.log(/^abc{2}$/.test("abccc"));//false  c只出现了3次，所以为false
 
console.log(/^abc{2,}$/.test("abccc"));//true  c出现了大于2的次数，所以为true
console.log(/^abc{2,}$/.test("abcc"));//true  c出现了等于2的次数，所以为true
console.log(/^abc{2,}$/.test("abc"));//false  c出现了小于2的次数，所以为false
 
console.log(/^abc{2,4}$/.test("abccc"));//true  c出现了3次在2跟4之间，所以为true
console.log(/^abc{2,4}$/.test("abcc"));//true  c出现了2次在2跟4之间，所以为true
console.log(/^abc{2,4}$/.test("abc"));//false  c出现了小于2的次数，所以为false
console.log(/^(abc){2,4}$/.test("abc"));//false  abc出现了小于2的次数，所以为false
console.log(/^(abc){2,4}$/.test("abcabc"));//true  abc出现了2次在2跟4之间，所以为true

常用正则 

let str = '鸡你太美'
console.log(escape(str));//'%u9E21%u4F60%u592A%u7F8E',使用escape方法可以将汉字转成Unicode编码
console.log(unescape('%u9E21%u4F60%u592A%u7F8E'))//'鸡你太美'，使用unescape方法可以将Unicode编码反向编译
验证汉字:/^[\u4e00-\u9fa5]+$/
验证邮箱:/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/
验证手机:/^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$/
电话号码(座机号码):/^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$/
身份证号码(18位数):/^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$/

正则常用方法

test

用于检测正则的匹配结果，正则身上的方法可直接正则点方法的形式使用，返回一个布尔值，符合正则条件则为true，否则为false，

replace

常用替换正则匹配到的字符

let string = '马老师34878745@qq.com,鸡哥77777@163.com,vandark 100000@aliyun.com'
// replace(翻译有替换的意思)
// 第一个参数为正则表达式,
// 第二个参数为需要替换的字符
// /^\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}$/邮箱正则表达式
// /^$/ 表示严格匹配，只能匹配一次符合条件的，如出现多次结果是匹配失败
let emailRegexp = /\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}/g //g表示字符串中的所有的，全局的
let result = string.replace(emailRegexp,'邮箱');//将匹配的邮箱换成汉字邮箱，
console.log(string,'------',result);

match

可将正则匹配的条件以数组的形式返回

// match(翻译有相配或者相似的意思)
let string = '马老师34878745@qq.com,鸡哥77777@163.com,vandark 100000@aliyun.com'
let emailRegexp = /\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}/g  //匹配字符串中所有的邮箱，g开启全局模式
let result2 = string.match(emailRegexp);//
console.log(result2)
// 打印结果:['34878745@qq.com', '77777@163.com', '100000@aliyun.com']
//返回结果是一个数组，没有找到则返回一个null
 
 
// match分组提取
let emailRegexpGroup = /(\w{3,}(\.\w+)*)@([A-z0-9]+)(\.([A-z]{2,5}){1,2})/
//将相应的正则用括号括起来可以分段提取
'77777@163.com'.match(emailRegexpGroup);//分组示例
console.log(RegExp.$1)//(\w{3,}(\.\w+)*)表示邮箱的前缀---77777
console.log(RegExp.$2)//这个为啥是空的我也不知道
console.log(RegExp.$3)//([A-z0-9]+)表示邮箱@符号后面的邮箱类型---163
console.log(RegExp.$4)//(\.([A-z]{2,5}){1,2})表示的后缀符号---.com
 
 
// 练习
let strValue = 'a=1,b=2,c=3';
console.log(strValue.replace(/\w=\d/g,'结果'));//第二个参数为普通字符
// 打印结果:结果,结果,结果
console.log(strValue.replace(/(\w)=(\d)/g,'$2=$1'));
//将等于号前后的正则匹配条件括起来,参数二换成$n,则可以翻转等于号前后字符
//此处$1表示第一个括号匹配到的条件，此处$2表示第二个括号匹配到的条件，以此类推
// 打印结果:1=a,2=b,3=c

search

用于查找正则条件在字符中出现的位置

// search(翻译有搜索的意思)
let string = '马老师34878745@qq.com,鸡哥77777@163.com,vandark 100000@aliyun.com'
let result3 = string.search( /\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}/);//匹配字符串中所有的基字，g表示替换所有的，全局的
console.log(result3)//返回结果是一个正则匹配结果在字符串中出现的索引
// 打印结果是3,邮箱在字符第一次出现的索引即是3

split

用于将正则条件匹配到的结果为分割将字符变成数组

// split(翻译有分割的意思)
let string = '马老师34878745@qq.com,鸡哥77777@163.com,vandark 100000@aliyun.com'
let result4 = string.split(/[\d\w]+\b@[a-zA-ZA-z0-9]+\.[a-z]+/);//此处正则为邮箱正则
console.log(result4)//返回结果是一个数组：['马老师', ',鸡哥', ',vandark ', '']
// 练习
let maStr = '闪-电-五-连-鞭-'
console.log(maStr.split(/-/))//打印结果：['闪', '电', '五', '连', '鞭', '']
//此处需要注意如果最后一个字符也符合正则匹配条件则数组最后一个为空

exec

有点像查找，但又不像，区别在于exec分次数查找，与test一样是正则身上的方法

// exec()
let string = '马老师34878745@qq.com,鸡哥77777@163.com,vandark 100000@aliyun.com'
let emailRegexp = /[\d\w]+\b@[a-zA-ZA-z0-9]+\.[a-z]+/g
console.log(emailRegexp.exec(string))//返回结果是一个数组，
console.log(emailRegexp.exec(string))//每执行一次则从上一次执行结果的后面继续匹配查找
console.log(emailRegexp.exec(string))//
console.log(emailRegexp.exec(string))//如没有符合的条件时则返回null
// 结果第一个值为匹配到的条件,
// 结果第二个值为我也不知道,
// 结果第三个值为匹配到的条件出现的索引,
// 结果第四个值为传进去的字符串,
// 结果第五个值为,
 
// 可配合while循环使用
let res
while(res = emailRegexp.exec(string)){
	console.log(res[0])
}