Regular Expression notes - a94940b/white-mysterious-wall GitHub Wiki

JavaScript 正则表达式笔记

https://regexper.com/ 一个正则表达式的在线图形化工具网页

1. RegExp对象

JavaScript通过内置RegExp对象来支持正则表达式 JavaScript有两种方法实例化RegExp对象

字面量
构造函数

1.1 字面量

var reg = /\bis\b/g;

1.2 构造函数

var reg = new RegExp('\\bis\\b','g');

2. 修饰符

g：global，表示全文搜索；如果不加g，搜索到第一个时匹配停止。
i：ignore case，表示忽略大小写；如果不加i，默认大小写敏感。
m：multiple lines，表示多行搜索；

3.元字符

正则表达式由两种基本字符类型组成
- 原义文本字符
- 元字符
元字符是在正则表达式中有特殊含义的非字母字符
```
*  +  ?  $  ^  .  |  \  ( ) { } [ ]
```

\t 水平制表符 table
\v 垂直制表符 vertical
\n 换行符 new line
\r 回车符 return
\0 空字符零
\f 换页符 form feed
\cX 与X对应的控制字符（Ctrl+X）

4. 字符类

我们可以用元字符[ ]来构建一个简单的类 [abc]
字符类取反[^]，[^abc]表示不是字符a或b或c的内容

5.范围类

我们可以使用[a-z]表示从a到z的任意字符，这是个闭区间，也就是包含a和z本身
在[]组成的类内部是可以连写的 [a-zA-Z]表示从a到z 或者从A到Z 的任意字符如果想要匹配到 - 这个字符，直接在后面加上 - 即可 [a-zA-Z-]

6.预定义类

字符      等价类             含义

 .      [^\r\n]             除了回车符和换行符之外的所有字符
 \d     [0-9]               数字字符 digital
 \D     [^0-9]              非数字字符
 \s     [\t\n\x0B\f\r]      空白符  space   （\x0B 表示垂直制表符）
 \S     [^\t\n\x0B\f\r]     非空白符   
 \w     [a-zA-Z_0-9]        单词字符（字母、数字、下划线） word
 \W     [^a-zA-Z_0-9]       非单词字符

7. 边界

^   以XXX开始
$   以XXX结束
\b  单词边界 boundary
\B  非单词边界

8. 量词

?       出现零次或一次 （至多出现一次）
+       出现一次或多次（至少出现一次）
*       出现零次或多次（出现任意次）
{n}     出现n次
{n,m}   出现n到m次
{n,}    至少出现n次 n为1时，与+的意义相同
{0,n}   至多出现n次

9. JS正则贪婪模式与非贪婪模式

9.1 贪婪模式(默认模式，让正则表达式尽可能多的匹配)

> '12345678'.replace(/\d{3,6}/g,'X')
< "X78"

9.2 非贪婪模式（让正则表达式尽可能少的匹配）

在量词后加上 ? 即可

> '12345678'.replace(/\d{3,6}?/g,'X')
< "XX78"

10. 分组

使用（）可以达到分组的功能，使量词作用于分组。

> 'a1b2c3d4'.replace(/([a-z]\d){3}/g,'X')
< "Xd4"

10.1 或

使用 | 可以达到或的效果

> 'BoHan'.replace(/Bo|Han/g,'X')
< "XX"

分组在或中的使用

> 'Boan&BHan'.replace(/B(o|H)an/g,'X')
< "X&X"

10.2 反向引用

在分组时，默认捕获了分组的内容。$1表示被捕获的第1个分组的内容，以此类推。

将年月日，转换为月日年表示，并将分隔符换成/，写法为：

> '2018-07-11'.replace(/(\d{4})-(\d{2})-(\d{2})/g,'$2/$3/$1')
< "07/11/2018"

10.3 忽略分组

像刚才分组在或中的使用的例子，我们必须利用分组的性质，但是我们又不打算捕获分组的内容，这时我们就可以通过在分组内加上 ?: 来忽略分组。

未忽略分组时：

> 'Boan&BHan'.replace(/B(o|H)an/g,'$1')
< "o&H"

忽略分组时，由于没有分组内容$1，所以会把$1看做一般字符

> 'Boan&BHan'.replace(/B(?:o|H)an/g,'$1')
< "$1&$1"

11. 前瞻

正则表达式从文本头部向尾部开始解析，文本尾部方向，称为“前”

前瞻就是在正则表达式匹配到规则的时候，向前检查是否符合断言assert。后顾的方向正相反

JavaScript不支持后顾，此处不再讨论。

符合和不符合特定断言，称为肯定/正向匹配和否定/负向匹配。

断言不参与到规则内容部分，只是做一个判断用

11.1 正向前瞻 exp(?=assert)

一个单词字符，且后面是跟着一个数字的。

> 'a2*3'.replace(/\w(?=\d)/g,'X')
< "X2*3"

11.2 负向前瞻 exp(?!assert)

一个单词字符，且后面不是跟着一个数字的。

> 'a2*3'.replace(/\w(?!\d)/g,'X')
< "aX*X"

12. JS正则表达式RegExp对象的属性（只读，不能修改）

global：是否全文搜索，默认值false
ignoreCase：是否忽略大小写，默认值false
multiline：多行搜索，默认值false
lastIndex：是当前表达式匹配内容的最后一个字符的下一个位置，即指向下一次匹配的开始位置。
source：正则表达式的文本字符串

13. JS正则表达式RegExp对象的方法

13.1 RegExp.prototype.test(str)

用于测试字符串参数中是否存在匹配正则表达式模式的字符串
如果存在则返回true,否则返回false

13.1.1 非全局调用

不加g标志，测试结果恒定，true或者false：

> var reg1 = /\w/;
> reg1.test('abc')
< true
> reg1.test('#')
< false

13.1.2 全局调用

加g标志的情况下,在这里例子中，输出2次true后，第3次会输出false：

> var reg2 = /\w/g;
> reg2.test('ab')
< true
> reg2.test('ab')
< true
> reg2.test('ab')
< false

发生这种现象的原因在于每次调用test方法的时候，每次都会影响lastIndex这个属性。过程是：第1次匹配到a后，定位到a的后面一个字符位置，a的索引位置是0，所以在第一次输出中，test方法输出true，lastIndex属性输出1；第2次初始匹配位置在a的后面，匹配到b后，定位到b的后面一个字符位置，b的索引位置是1，所以在第二次输出中，test方法输出true，lastIndex属性输出2；第3次匹配的起始位置在b的后面，找不到能匹配的元素了，所以在第3次输出中，test方法输出false，而lastIndex属性输出0，即下一次进行匹配的起始位置又重置回零。这就是为什么第4次执行的时候，test方法又会输出true，lastIndex属性输出1。

> while(reg2.test('ab')){
    console.log(reg2.lastIndex)
  }
< 1
< 2

所以如果我们只是想测试字符串是否有匹配上时，就不要加g。如果想了解匹配的位置和具体字符，就用下面的exec方法

13.2 RegExp.prototype.exec(str)

使用正则表达式模式对字符串执行搜索，并将更新全局RegExp对象的属性以反映匹配结果。
如果没有匹配的文本则返回null，否则返回一个结果数组。
调用过exec()方法后，会生成两个新的属性：
- index声明匹配文本的第一个字符的位置
- input存放被检索的字符串string

13.2.1 非全局调用

调用非全局的RegExp对象的exec()方法时，返回数组
- 第一个元素是与正则表达式想匹配的文本
- 第二个元素食欲RegExpObject的第一个子表达式相匹配的文本（如果有的话）
- 第三个元素是与RegExp对象的第二个子表达式相匹配的文本（如果有的话），以此类推。

输入：

var reg3 = /\d(\w)(\w)\d/;
var ts = '$1az2b3cy4d5e';

var ret = reg3.exec(ts);

console.log(reg3.lastIndex + '\t' + ret.index + '\t' + ret.toString());
console.log(reg3.lastIndex + '\t' + ret.index + '\t' + ret.toString());
console.log(ret);

输出：

0   1   1az2,a,z
0   1   1az2,a,z
["1az2", "a", "z", index: 1, input: "$1az2b3cy4d5e"]

非全局调用的时候，lastIndex属性永远是0
ret.index 第一次和第二次执行，均为1
ret是一个数组，输出了三个成员： 1az2 a z
非全局调用只能找出第一个匹配的元素，如果需要全部找出，需要全局调用。

13.2.2 全局调用

输入：

var reg4 = /\d(\w)(\w)\d/g;
var ts = '$1az2b3cy4d5e';
while(ret = reg4.exec(ts)){
    console.log(reg4.lastIndex + '\t' +ret.index + '\t' + ret.toString());
}

输出：

5   1   1az2,a,z
10  6   3cy4,c,y

14. 字符串对象方法

14.1 String.protatype.search(reg)

search()方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串
方法返回第一个匹配结果index，查找不到返回-1
search()方法不执行全局匹配，它将忽略标志 g ，并且总是从字符串的开始进行检索

> 'a2b3c4d1f5'.search(1)
< 7
> 'a2b3c4d1f5'.search('1')
< 7
> 'a2b3c4d1f5'.search(/1/)
< 7

> 'a2b3c4d1f5'.search(/10/)
< -1

无论是数字、字符串、或者是正则表达式，执行多遍，其结果仍然不变，始终是7。

14.2 String.prototype.match(reg)

match()方法将检索字符串，以找到一个或多个与regexp相匹配的文本
regexp是否具有标志 g 对结果影响很大

14.2.1 非全局调用

如果RegExp没有标志g，那么match()方法只能在字符串中执行一次匹配
如果没有找到任何匹配的文本，将返回null
否则它将返回一个数组，其中存放了与它找到的匹配文本有关的信息
这个返回值和正则表达式的exec方法在非全局下调用的返回值一样

输入：

var reg3 = /\d(\w)\d/;
var ts = '$a12b3c4d5e';

var ret = ts.match(reg3);

console.log(ret);
console.log(ret.index + '\t' + reg3.lastIndex);

输出：

["2b3", "b", index: 3, input: "$a12b3c4d5e"]
3   0

14.2.2 全局调用

如果RegExp有标志g，那么match()方法将执行全局检索，找到字符串中的所有匹配子字符串
- 如果没有找到任何匹配的文本，将返回null
- 如果找到了一个或多个匹配子串，则返回一个数组
数组元素中存放的是字符串中所有的匹配子串，而且也没有index属性或者input属性

输入：

var reg4 = /\d(\w)\d/g;
var ts = '$a12b3c4d5e';

var ret = ts.match(reg4);

console.log(ret);
console.log(ret.index + '\t' + reg4.lastIndex);

输出：

["2b3", "4d5"]
undefined   0

14.3 String.prototype.split(reg)

我们经常使用split方法把字符串分割为字符数组
- 'a,b,c,d'.split(','); //["a","b","c","d"]
在一些复杂的分割情况下我们可以使用正则表达式解决
- 'a1b2c3d'.split(/\d/g); //["a","b","c","d"]

14.4 String.prototype.replace(reg)

String.prototype.replace(str,replaceStr)
String.prototype.replace(reg,replaceStr)
String.prototype.replace(reg,function)

> 'a1b1c1'.replace(/1/g,2)
< "a2b2c2"

String.prototype.replace(reg,function)

这个function函数有四个参数 1.匹配字符串 1.正则表达式分组内容，没有分组则没有该参数 1.匹配项在字符串中的index 1.原字符串

我们想把数字-字母-数字这样的组合中间的字母给去掉，可以这样写：

输入：

'a1b2c3d4e5'.replace(/(\d)(\w)(\d)/g,function(match,group1,group2,group3,index,orgin){
    console.log(match);
    return group1 + group3;
    })

输出：

"a12c34e5"