一 正则表达式概述
1. 正则表达式定义
正则表达式是用来匹配一串文本中符合规则的子串的字符组合。一段用于匹配的正则表达式通常称为一个模式。JavaScript中，正则表达式可以通过字面量来定义，使用时会被包装为一个RegExp对象。
2. 正则表达式范围
一种语言对正则表达式的支持分为两个部分：
- 正则表达式本身的语法支持
- 正则表达式的运行与匹配支持，在JavaScript中，主要是RegExp对象的方法和String对象的部分方法。
用马哲的风格来讲：
第一种对语法的支持是绝对的，不以语言不同而转移，第二种运行支持是相对的，要依赖正则语法和程序语言支持。
3. 简单模式
简单模式就是直接由想要匹配的字符串组成。也仅仅能严格匹配到相等的字符串，这里区分大小写和字符顺序。
|
1
|
/Str/.exec('strStrsTR') // Str |
JavaScript中，一般情况下，如果一个参数的要求是正则表达式，而实际接收到了一个字符串，那么字符串会被转化成简单模式的正则表达式。
4. 元字符概述
如果想要匹配模式更加灵活，必须依赖元字符。元字符也是一组字符串，但是不再表达本身字符的意思。元字符分可以有很多种，为方便理解，我把元字符分为下述几种：
- 简单字符
- 字符集
- 量词
- 位置
- 文本简写字符
- 文本控制字符
二 元字符
1. 简单字符
简单字符概述
简单匹配字符作用于单个字符上。
|
匹配字符 |
描述 |
|---|---|
|
|
匹配除了换行符外的任意单个字符 |
|
| |
或运算符 |
|
\ |
转义运算符，用于匹配保留的字符[] () . * + ? ^ $ \ | |
点号
|
1
|
/./.exec('jsx') // j |
或运算符
|
1
2
|
// exec()方法只执行一次，match方法可以通过g标志，实现全局匹配'SsDdDk'.match(/s|D/g) // s,D,D, |
转义运算符
|
1
|
/\//.exec('s//d/k') // /, |
2. 字符集
字符集概述
字符集用于匹配集合内的所有字符。默认情况下，严格区分大小写。
|
字符集 |
描述 |
|---|---|
|
|
字符集，匹配方括号内的任意字符，如[xyz]就是匹配x，y，z中任意一个字符 |
|
[^] |
否定字符集，匹配除了方括号里的任意字符 |
常用字符集包括:
- [a-z]: 匹配a-z之间任意字符，也就是匹配所有小写字母
[A-Z]: 匹配A-Z之间任意字符，也就是匹配所有大写字母[0-9]: 匹配0-9之间任意字符，也就是匹配所有数字
字符集
|
1
|
/[uH2]/.exec('UH34') // H |
否定字符集
|
1
|
/[^Uh3]/.exec('Uh23') // 2 |
3. 量词
量词概述
量词用于规定匹配的次数。默认情况下，每一个规则或者说元字符，仅仅匹配一次，且只作用于单个字符上。可以通过量词来描述期望的匹配次数。
|
量词
|
描述
|
|---|---|
| * | 匹配星号前的字符或子模式，大于等于0次。隐藏的一个问题，如果一串字符的开头不匹配，那么也不会往下继续匹配，因为规则上允许匹配0次 |
| + | 匹配加号前的字符或子模式，大于等于1次。隐藏的一个含义，如果当前没匹配到子串，就回继续查找，如果匹配到一段符合规则的子串，会继续往后，直到查到第一个不符合规则的子串的时候结束 |
| {n} | 匹配n次花括号前的字符或子模式 |
| {n,} | 匹配大于等于n次花括号前的字符或子模式 |
| {n,m} | 匹配num个花括号前的字符，num大于等于n且小于等于m |
星号
|
1
2
3
4
5
6
7
8
9
|
// 匹配大于等于0个星号之前的字符或子模式。关联字符时，只关联模式串中的星号前一个字符，之前的字符会按照相应的匹配规则// 第一个规则，模式串前半部分的字符是简单模式，也就是要求严格匹配// 第二个规则，匹配方括号字符集里面的任意一个，// 由于默认的匹配类型是贪婪匹配，因此会尽可能多的向后匹配，直到遇到不匹配的字符// 第三个规则，意思为匹配a-z之间的小写字母，也就是所有的小写字母，但第二个字符是大写S，因此只匹配了第一个字符/Sd*/.exec('sdSdddK') // Sddd/[sSD]*/.exec('sSDSkDdk') // sSDS/[a-z]*/.exec('sSDSDdk') // s |
加号
|
1
2
3
4
|
// 下面的正则要求匹配一次及以上的字符d// 由于加号至少要求匹配一次，因此，第一个字母不是d，不满足条件，会继续向后找，匹配到ddd// ddd匹配完后，已经具备了匹配到一个子串的要求，因此，发现k不符合规则后，直接返回/d+/.exec('sdddk') // ddd |
花括号
|
1
2
3
4
5
6
|
// 匹配一次/D{1}/.exec('sDDDDk') // D// 匹配大于等于一次/D{1,}/.exec('sDDDDk') // DDDD// 大于等于1次，小于等于3次/D{1,3}/.exec('sDDDDk') // DDD |
4. 位置
位置概述
|
位置
|
描述
|
|---|---|
| ^ | 匹配字符串开头 |
| $ | 匹配字符串结尾 |
| \b | 匹配一个词的边界 |
| \B | 匹配一个非单词边界 |
如何理解边界？
一个词的边界就是不跟随其他词的字符的位置。如单词之间的空格，一行文字的开头和结尾，以及不算“字”的字符等等。
JavaScript中的“字”，或“词”，与我们日常理解的有些不同。
JavaScript中的字只包含大写字母，小写字母，十进制数字，下划线。
除此之外的字符，都可以算作打断一个单词。
位置元字符，只提供位置的约束和规则，不匹配字符。
开头
|
1
2
3
4
5
|
// 匹配字符串开头的一个斜杠// 斜杠是 \/匹配到的，^匹配的是位置规则。/^\//.exec('//s/d/k') // /// 由于开头的字符不是/，而是s，因此匹配不到/^\//.exec('s/d/k') // null |
结尾
|
1
2
3
4
|
// 匹配字符串结尾的一个斜杠/\/$/.exec('sd/k//') // /// 由于结尾的字符是k，不是斜杠，因此匹配不到/\/$/.exec('sd/k') // null |
边界
|
1
2
3
4
5
6
7
8
9
10
11
12
|
// 第一个规则匹配一个在结尾边界前的字符，在这里就是b/\w\b/.exec('ab') // b// 这个规则匹配一个开始边界后的字符，在这里就是a/\b\w/.exec('a b') // a// 这个规则匹配全局匹配一个开始边界后的字符，d前有c，不是开始边界后的字符，因此没有匹配到'a b-cd'.match(/\b\w/g) // a,b,c,// 这段规则什么也匹配不了，因为位置元字符不匹配字符，因此，这段规则可以简化成下面的规则:// \w\w，匹配两个连起来的字母，数字，下划线，但是又要求这两个字符之间存在边界，这显然是不存在的/\w\b\w/.exec('a b') // null |
非边界
|
1
2
3
4
5
6
|
// 匹配一个不是开头边界的字符，这里a是，c是，只有b不是'ab-c'.match(/\B\w/g) // b// 这条规则什么也匹配不到，因为之前说过，位置元字符只匹配位置，不匹配字符// 不存在一个字符，既是边界，又不是边界'ab-c'.match(/\b\B\w/g) // null |
5. 文本匹配字符
|
文本匹配字符
|
描述
|
|---|---|
| \w | 匹配字母，数字和下划线 |
| \W | 匹配非字母,数字和下划线 |
| \d | 匹配数字 |
| \D | 匹配非数字 |
| \s | 匹配所有空白符 相当于[\t\n\f\r\p{Z}] |
| \S | 匹配所有非空白符 |
\w 和 \W
\w 和 \W
|
1
2
|
/\w+/.exec('J2s_皆X') // J2s_/\W+/.exec('df好卡啊z卡') // 好卡啊 |
\d 和 \D
|
1
2
|
/\d/.exec('g2') // 2/\D+/.exec('12san4') // san |
\s 和 \S
|
1
2
|
/\s/.exec('1 7 ') // [空格] 由于只有一个\s，因此只匹配一个空格/\S+/.exec(' Jk') // Jk |
6. 文本控制字符
|
文本控制字符
|
描述
|
|---|---|
| \f | 匹配一个换页符 |
| \n | 匹配一个换行符 |
| \r | 匹配一个回车符 |
| \t | 匹配一个制表符 |
| \v | 匹配一个垂直制表符 |
| \p | 匹配DOS命令行终止符，相当于\r\n |
三 零宽断言
1. 零宽断言概述
普通元字符用来匹配某个特定的字符，而零宽断言用来匹配特定的_位置_，指明匹配的字符前后必定有满足断言规则的内容。它包含两个概念：
- 断言: 即断定某件事，某种情况，必定发生。这里的断言，用来判断某个字符的前后，是否符合某种特定格式。
- 零宽: 即不占用宽度。也就是说，断言匹配的是字符前后的位置，不占据字符。如果断言前后还有其他规则，不会跳过断言匹配的字符。断言规则在匹配结果中也不返回
注: 在断言规则的写法上，先行断言是与断言前面的模式组合，后发断言与断言后面的模式组合
2. 零宽断言种类
|
零宽断言 |
描述 |
|---|---|
|
|
正先行断言。正，正向，理解为真，即匹配符合规则的位置，先行，即匹配断言规则前面的字符 |
|
|
负先行断言。负，反向，理解为假，即匹配不符合规则的位置，先行，即匹配断言规则前面的字符 |
|
|
正，正向，理解为真，即匹配符合规则的位置，后发，即匹配断言规则后面的字符 |
|
|
负，反向，理解为假，即匹配不符合规则的位置，后发，即匹配断言规则后面的字符 |
3. 正先行断言
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
// 正先行断言// 正，正向，理解为真，即匹配符合规则的位置，先行，即匹配断言规则前面的字符// 下面的匹配由若干数字开头，结尾是dk的字符串，再去掉断言规则本身，返回的是233/\d+(?=dk)/.exec('sdkS233dk') // 233// 下面两个例子为了验证零宽// 零宽的意思是，断言不占据位置，断言规则不会过滤掉字符，// 也就是说，如果匹配到了一段符合规则的子串，断言返回的子串不包含断言规则匹配的部分// 但如果后续还有正则规则，会从断言规则前的位置开始// 第二个返回1d，第三个返回1，可以看出，d是由\w匹配到的，因为断言本身不占据位置，所以\w从1后面的d开始匹配/1(?=d)\w/.exec('1d_') // 1d/1(?=d)/.exec('1d_') // 1 |
4. 负先行断言
|
1
2
3
4
5
6
7
8
|
// 负先行断言// 负，反向，理解为假，即匹配不符合规则的位置，先行，即匹配断言规则前面的字符// 这里的匹配规则为：前方有若干字符（字母，数字，下划线），后面跟着两个井号。// 从左向右匹配，第一个不符合规则的位置为d_k2D，因为这串字符后面跟着的是K而不是##// 最后，断言不匹配规则本身，因此返回的值为d_k2D/\w+(?!##)K/.exec('##d_k2DK##$DK') // d_k2DK |
5. 正后发断言
|
1
2
3
4
5
6
7
8
9
|
// 正后发断言// 正，正向，理解为真，即匹配符合规则的位置，后发，即匹配断言规则后面的字符// 第一个规则，匹配两个井号(##)开头，后面跟若干数字的字符串，匹配结果不含井号/(?<=##)\d+/.exec('1##233###4#') // 233// 第二个规则，匹配两个$#开头，且后续跟若干数字的字符串，// 由于后发断言规则前仍有正则规则，因此前面的字符被其他的规则匹配到，返回$#233/\$#(?<=\$#)\d+/.exec('1$#233###4#') // $#233 |
6. 负后发断言
|
1
2
3
4
5
|
// 负后发断言// 负，反向，理解为假，即匹配不符合规则的位置，后发，即匹配断言规则后面的字符// 匹配一个不以两个井号开头的若干数字组成的字符串，返回45/(?<!##)\d+/.exec('##2#45#') // 45 |
四 标记
1. 标记概述
标记用来修改正则表达式的一些默认行为，包括是否忽略大小写(i)，是否全局搜索(g)，是否多行搜索(m)。
标记不属于元字符，因此不写在正则规则里面，而是写在规则后面。
|
1
2
|
// 全局匹配所有的字母，数字，或下划线/\w/g.exec('sdk') // sdk |
|
标记 |
描述 |
|---|---|
|
|
忽略大小写 |
|
|
全局查询搜索匹配 |
|
|
多行标记m可以让开头和结尾的标记符^, $在多行使用，同样的，全局匹配多次的话，需要加上全局标记g |
2. 忽略大小写
|
1
2
|
// 匹配至少两个或以上的小写字母，忽略了大小写，因此大写字母也能匹配的到/[a-z]{2,}/i.exec('sDK') // sDK |
3. 全局搜索
|
1
2
|
// 这条规则匹配若干数字，字母，或下划线，后面紧跟一个空白符，而sdk后面没有空白符，因此匹配不到"s sd sdk".match(/\w+\s/g) // s ,sd , |
4. 多行匹配
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
// 全局查询，且多行查询，规则要求前面若干字符，后续跟一个井号，且井号不返回` sdk# sDK# SDK!`.match(/\w+(?=#)/gm) // sdk,sDK// 匹配到最后一个字符，并且这个字符要是井号，且多行匹配，但只匹配一次` sdk! sDK# sDK# SDK@`.match(/#$/m) // # |
五 贪婪匹配和懒惰匹配
1. 概述
正则表达式默认情况下是贪婪匹配。意味着正则会尽可能地匹配多的符合规则地字符。这包含这以下几个意思:
- 对于单个匹配字符，字符集等，不加量词的情况下，如\w，它的作用是匹配一个数字，字母，或下划线。因此，即便存在再多地字母，也只会匹配一个字母。
- 贪婪的地方在于，会尽可能的在某一个已经匹配规则的子串后面，如果下一个字符符合规则，会继续匹配相邻的下一个字符，否则就返回现有字符。而不是会匹配到整个字符串所有符合规则的字符串（此时需要用全局标记g）。
- 懒惰的地方在于，只匹配刚好满足规则的子串，不进行过多匹配。
2. 惰性匹配
在元字符，或者子模式后使用{{?}}将紧邻的前面的规则修饰为惰性匹配
|
1
2
3
4
5
|
// 贪婪匹配/\w+/.exec('sdk_ s') // sdk_// 惰性匹配/\w+?/.exec('sdk_ s') // s |
六 子模式
子模式是用括号()括起来的一组规则。子模式会被记忆下来，使用带全局标记的exec()和不带全局标记的match()匹配时会单独匹配一份。
|
1
2
3
4
5
6
7
8
9
10
11
|
// 这个规则匹配一个数字后跟随多个字符，并且最后要有至少一个井号#const reg = /(\d\w+)#+/g;const str = '2d3c-#5g##8ff';// exec()方法会将正则执行一次，如果正则给出了全局标志位g，那么返回的数据是可迭代的// 可以多次运行获取后面的所有匹配结果reg.exec(str);// ["5g##", "5g", index: 6, input: "2d3c-#5g##8ff", groups: undefined]// 可以看出，exec()，执行一次的返回结果的前两个数组索引处，都是匹配的结果// 第一个是整个模式串匹配的结果，第二个位置是子模式单独匹配的结果 |
除了exec()方法以外，子模式主要起到的就是一个分组的作用。也就是说，默认的情况下，一个修饰符或者一个量词，只修饰前面的一个字符。比如说，\w\d+这个规则要求只匹配一个字符，这个字符后面跟着至少一个数字。如果想要改成匹配字符和数字的多个组合呢？就可以使用子模式：
|
1
|
'2d3f4--f6s'.match(/(\w\d)+/g) // ["d3f4", "f6"] |
七 JavaScript中如何运行正则
JavaScript中主要使用String对象和RegExp对象提供的方法来运行正则表达式。
1. RegExp对象的方法
|
方法名(RegExp.prototype.) |
描述 |
|---|---|
|
exec(string) => array |
|
|
|
|
2. String对象的方法
|
方法名(String.prototype.) |
描述 |
|---|---|
|
|
|
|
search(reg | str) => index | -1 |
search()方法接收一个正则对象或一个字符串(字符串会转换成简单模式的正则表达式)，用来查找调用字符串中符合规则的子串的位置，匹配到了就返回第一次出现的索引，否则返回-1 |
|
replace(reg | str, newStr | fn) => replacedStr |
replace()方法接收两个参数，第一个参数是用来匹配调用字符串的正则表达式（字符串会被转化成简单模式的正则规则），第二个参数表示要替换的字符串或者返回字符串的函数。replace()方法不改变源字符串。 |
|
split(reg | str, limit) => array |
split()方法接收两个参数，第一个是一个正则或字符串，表示将要匹配并用于切分的字符，使用第一个参数匹配调用字符串，在符合规则的位置将字符串切分未为数组，并返回。第二个参数限制分割的片段数量。 |