正则基础知识回顾

常用的元字符

字符	描述
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\w	匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'
\W	匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'
\s	匹配任何空白字符，包括空格、制表符、换页符
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]
.	匹配除换行符（\n、\r）之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用像"(.
\f	匹配一个换页符。
\n	匹配一个换行符。
\r	匹配一个回车符。
\t	匹配一个制表符。
\v	匹配一个垂直制表符。
^	匹配输入字符串开始的位置。
$	匹配输入字符串结尾的位置
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	与 \b 相反：er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。

匹配11位数的中国手机号：

var reg = /1\d\d\d\d\d\d\d\d\d\d/
var num = '1781538390100'
reg.exec(num)//["17815383901", index: 0, input: "1781538390100", groups: undefined]

区间

[-\w.+] 区间，表示 匹配符号 -，或字母、数字、下划线，或符号 . ，或符号 +
除此之外的常见用法还有：

字符	描述
[0-9]	匹配 0-9 之间的数字
[A-Z]	匹配 A-Z 之间的字母，也可以组合 [A-Za-z0-9]

.在区间里表示就表示. ,在正则表达式里表示除了换行之外的任意字符。

var reg1 = /[.]/
reg1.exec('hell.h')//[".", index: 4, input: "hell.h", groups: undefined]
var reg2 = /./
reg2.exec('hell.h')j's["h", index: 0, input: "hell.h", groups: undefined]

限定符

* 表示出现，匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"
除此之外的限定符还有：

字符	描述
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 、 "does" 中的 "does" 、 "doxy" 中的 "do" 。? 等价于 {0,1}
{n}	n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o
{n,}	n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格

*等价于{0,}

/z{0,}/.exec('zzzzzo')//["zzzzz", index: 0, input: "zzzzzo", groups: undefined]
/z*/.exec('zzzzzo')//["zzzzz", index: 0, input: "zzzzzo", groups: undefined]

匹配9位数的QQ邮箱：

[0-9]{9}@qq.com

3.身份证号：

\d{17}[0-9Xx]|\d{15}

ip地址：

\d{0,3}.\d{0,3}.\d{0,3}.\d{0,3}

普通字符和转义

对于正则中的限定符，匹配时需要转义。

如：https:\/\/baidu\.com

子表达式

用圆括号组成一个比较复杂的匹配模式，那么一个圆括号的部分我们可以看作是一个子表达式。

举例 var reg = /(\d+)([a-z]+)/g;

(\d+)就是第一个子表达式
([a-z]+) 是第二个子表达式

var reg = /(\d+)([a-z]+)/g;
var str = '123abc'
if (reg.test(str)) { 
    //捕获到表达式的内容
    console.log(RegExp.$1);//123
    console.log(RegExp.$2);//abc
    console.log(RegExp.$3);//空
}

捕获 & 反捕获

多个子表达式所匹配到的内容按顺序出现在内存的缓冲区中捕获数组，这个我们称为捕获

使用RegExp.$n获取捕获到的内容。

反捕获与捕获相反，标记不需要捕获的内容 ,使用?:

var reg = /(?:\d+)([a-z]+)/g;
var str = '123abc'
if (reg.test(str)) { 
    console.log(RegExp.$1);//abc
    console.log(RegExp.$2);//空
}

反向引用

圆括号的内容被捕获后，可以在这个括号后被使用，从而写出一个比较实用的匹配模式，这个我们称为反向引用

可以用于替换内容。

var reg = /(?:\d+)([a-z]+)/g;
var str = '123abc'
if (reg.test(str)) { 
    var res = str.replace(reg, '$2$1')
    console.log(res);//abc123
}

贪婪

贪婪匹配：当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符，这匹配方式叫做贪婪匹配。

let s = 'jsssss'
let r = /js+/gi
console.log(s.match(r));//[ 'jsssss' ]

懒惰 / 非贪婪

当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能少的字符，这匹配方式叫做懒惰匹配。

懒惰量词是在贪婪量词后面加个?

let s = 'jsssss'
let r = /js+?/gi
console.log(s.match(r));//[ 'js' ]

代码	说明
*?	重复多次，但尽可能少重复
+?	重复1次、多次，但尽可能少重复
??	重复0次、1次，但尽可能少重复
{n,m}?	重复n~m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

//贪婪
let s = 'jsssss'
let r = /js{1,4}/gi
console.log(s.match(r));//[ 'jsssss' ]

//非贪婪
let s = 'jsssss'
let r = /js{1,4}?/gi
console.log(s.match(r));//[ 'js' ]