JS正则表达式基本语法与实例

匹配模式

	i------------------------------------------------------------------ ignoreCase 忽略大小写
	g------------------------------------------------------------------ global 全局匹配
	m------------------------------------------------------------------ multiline 是否多行匹配
	y------------------------------------------------------------------ sticky 搜索是否具有粘性

比较常用的这些匹配模式中，g是指在匹配到结果后的下一次匹配是否从前次结束位置开始，lastIndex用来标记上次结束的索引
例如

var str = 'decades'
//匹配字符为d的部分，进行全局匹配
var pattern = /d/g
//第一次匹配
console.log(pattern.exec(str))
//第二次匹配
console.log(pattern.exec(str))
//第三次匹配
console.log(pattern.exec(str))

结果为

[ 'd', index: 0, input: 'decades', groups: undefined ]
[ 'd', index: 4, input: 'decades', groups: undefined ]
null

在全局匹配的正则表达式应用时，正则表达式实例原型中的方法exec和test维护的都是同一个lastIndex，比如在test过后使用exec，由于test先执行过一次，让lastIndex有了新值，因此再执行exec会从test赋好的lastIndex开始。

正则表达式元素

直接量

字符、数字

/abc/

var test1 = 'test1'
var p1 = /test1/
console.log(p1.exec(test1))
//结果为
[ 'test1', index: 0, input: 'test1', groups: undefined ]

字符类

		[abc] –匹配abc中的任意字符
		[^abc] – 匹配不是abc的任意字符
		. –除了换行符之外的任意字符
		\w 任意ascii码值等价于[a-zA-Z0-9]
		\W 相当于[^a-zA-Z0-9]
		\s 任意空白符
		\S 任意非空白符
		\d 任意数字
		\D 任意非数字

//字符类
var test2 = 'javascript is g000000000d'
//匹配一个符合 j a v a 中任意字母的字符，预期结果 j
var p2_1 =  /[java]/  
//匹配一个不符合 j a v a 中任意字母的字符，预期结果 j
var p2_2 = /[^script]/	
//匹配一个普通的字符，预期结果 j
var p2_3 = /\w/
//匹配一个非字符，预期结果" "
var p2_4 = /\W/
//匹配一个空白字符，预期结果" "
var p2_5 = /\s/
//匹配一个非空白字符，预期结果 j
var p2_6 = /\S/
//匹配一个数字，预期结果 0 
var p2_7 = /\d/
//匹配一个非数字，预期结果 j
var p2_8 = /\D/
console.log(p2_1.exec(test2))
console.log(p2_2.exec(test2))
console.log(p2_3.exec(test2))
console.log(p2_4.exec(test2))
console.log(p2_5.exec(test2))
console.log(p2_6.exec(test2))
console.log(p2_7.exec(test2))
console.log(p2_8.exec(test2))

//结果为（只保留了返回数组的第一项，即匹配结果）
'j',
'j',
'j',
' ',
' ',
'j',
'0',
'j',

数量词

应用在正则表达式的子表达式后 /\w{3}/ 任意三个字符
{3} 严格出现三次
{1，3}一到三次
{1，}一到多次
+ 一到多次
？0到1次
*0到多次
默认贪婪匹配，在数量词后添加一个？变为非贪婪匹配
贪婪匹配：

//贪婪
var test3 = '212233112'
//匹配数字，数量1 到 5个
var p3 = /\d{1,5}/
console.log(p3.exec(test3))
//返回
[ '21223', index: 0, input: '212233112', groups: undefined ]

//非贪婪
var test3_2 = '212233112'
//匹配数字，数量1 到 5个
var p3_2 = /\d{1,5}?/
console.log(p3_2.exec(test3_2))
//返回
[ '2', index: 0, input: '212233112', groups: undefined ]

选择

通过 | 分割
/ab|bc|cd/

var test4 = 'abcdef'
var p4 = /z|v|d|b/
console.log(p4.exec(test4))
//结果为
[ 'b', index: 1, input: 'abcdef', groups: undefined ]

分组

通过“（）”分组 使用 \n 匹配第n组的内容 n为正整数
（协议）：//（（ip）| （域名））：（端口）
Exec执行后返回数组res：res[0]为整体结果 res[1]为第一组的内容，即为协议，以此类推

var test5 = 'ab345ab ab123ba'
// \1 匹配时按第一组的内容即ab进行匹配
var p5 = /(ab)\d+\1/
console.log(p5.exec(test5))
//结果为
[
  'ab345ab',
  'ab',
  index: 0,
  input: 'ab345ab ab123ba',
  groups: undefined
]

引用

多行匹配 flags—m
匹配一行的开始 ^ （当^在[]中时代表非）
匹配一行的结束 $
正则表达式的使用场合多种多样
在JS String.prototype中有一些参数为正则表达式的方法，下面列举一些比较常用的方法

String.prototype.search(regexp)
参数：正则表达式、字符串（字符串会转换为正则表达式）
作用：返回第一个符合要求的串的首字符索引
返回值：索引或者-1（不支持全局匹配）
String.prototype.match()
参数：正则表达式、字符串
返回值：
如果不使用g（全局匹配），返回数组，数组中的第一个元素为整个正则匹配的结果，第二个元素为第一个分组匹配的结果…… 与exec执行的结果返回值相同
如果使用g，返回全局匹配的结果
String.prototype.replace(regexp，newStr)
参数：regexp正则表达式表示要替换的字符串，newStr为新串
返回值：替换后的结果
String.prototype.split()
参数：正则表达式，字符串
返回值：数组
Eg： var str=’2020-08-17’
str.split(/-/) 返回[‘2020’,’08’,’17’]