JavaScript中的正则表达式总结

# JavaScript中的正则表达式总结

## 定义正则表达式的方法

定义正则表达式的方法有两种：**构造函数定义**和**正则表达式直接量**定义。例如：
```javascript
var reg1 = new RegExp('d{5, 11}'); // 通过构造函数定义
var reg2 = /d{5, 12}/; // 通过直接量定义
```

## 正则表达式直接量字符
- o：NUL字符（u0000）
- t：制表符（u0009）
- n：换行符（u000A）
- v：垂直制表符（u000B）
- f：换页符（u000C）
- r：回车符（u000D）
- xnn：由十六进制数nn指定的拉丁字符，例如，x0A等价于n
- uxxxx：由十六进制数xxxx指定的Unicode字符，例如u0009等价于t
- cX：控制字符^X，例如，cJ等价于换行符n

## 正则表达式锚字符
- ^：匹配字符串的开头，在多行检索中，匹配一行的开头
- $：匹配字符串的结尾，在多行检索中，匹配一行的结尾
- b：匹配一个单词的边界，简言之，就是位于字符w和W之间的位置，或位于字符w和字符串的开头或者结尾之间的位置（[b]匹配的是退格符）
- B：匹配非单词边界的位置
- (?=p)：零宽正向先行断言，要求接下来的字符都与p匹配，但不能包括匹配p的那些字符
- (？!p)：零宽负向先行断言，要求接下来的字符串不与p匹配

## 正则表达式的字符类
- [...]：方括号内的任意字符
- [^...]：不在方括号内的任意字符
- .：除换行符和其他Unicode行终止符之外的任意字符
- w：任何ASCII字符组成的单词，等价于[a-zA-Z0-9]
- W：任何不是ASCII字符组成的单词，等价于[^a-zA-Z0-9]
- s：任何Unicode空白符
- S：任何非Unicode空白符的字符，注意w和S不同
- d：任何ASCII数字，等价于[0-9]
- D：除了ASCII数字之外的任何字符，等价于[^0-9]
- [b]：退格直接量（特例）

## 正则表达式的重复字符语法
- {n, m}：匹配前一项至少n次，但不能超过m次
- {n, }：匹配前一项n次或者更多次
- {n}：匹配前一项n次
- ?：匹配前一项0次或者1次，也就是说前一项是可选的，等价于{0, 1}
- +：匹配前一项1次或多次，等价于{1, }
- *：匹配前一项0次或多次，等价于{0, }

## 正则表达式的选择、分组和引用字符
- |：选择，匹配的是该符号左边的子表达式或右边的子表达式
- (…)：组合，将几个项组合为一个单元，这个单元可通过“*”、“+”、“?”和“|”等符号加以修饰，而且可以记住和这个组相匹配的字符串以供此后的任何使用
- (?: …)：只组合，把项组合到一个单元，但是不记忆与改组相匹配的字符
- n：和第n个分组第一次匹配的字符相匹配，组是圆括号中的子表达式（也有可能是嵌套的），组索引是从左到右的左括号数，“(?:”形式的分组不编码
- 正则表达式修饰符
- i：执行不区分大小写的匹配
- g：执行一个全局匹配，简言之，即找到所有的匹配，而不是在找到第一个之后就停止
- m：多行匹配模式，^匹配一行的开头和字符串的开头，$匹配行的结尾和字符串的结尾
- 用于模式匹配的String方法
- search()：它的参数是一个正则表达式，返回第一个与之匹配的子串的起始位置，如果没有匹配的子串就返回-1。如果search()的参数不是正则表达式，则首先会通过RegExp构造函数将它转换为正则表达式，search()不支持全局检索，因为它忽略修饰符g。如：
```javascript
var s = "JavaScript".search(/script/i); // s = 4
```
- replace()：它用来执行检索与替换。接收两个参数，第一个是正则表达式，第二个是要进行替换的字符串。正则表达式如果设置的修饰符g，则进行全局替换，否则只替换匹配的第一个子串。如果第一个参数不是正则表达式，则直接搜索该字符串，而不是将其转换为正则表达式。如：
```javascript
var s = "JavaScript".replace(/java/gi, "Script"); // s =  Script Script
```
- match()：它的参数是一个正则表达式，如果不是则通过RegExp转换，返回的是一个由匹配结果组成的数组。如果设置了修饰符g则进行全局匹配。如：
var d = '55 ff 33 hh 77 tt'.match(/d+/g); // d = ["55", "33", "77"]
split()：这个方法用以将调用它的字符串拆分为一个子串组成的数组，使用的分隔符是split()的参数，它的参数也可以使一个正则表达式。如：
```javascript
var d = '123,31,453,645'.split(','); // d = ["123", "31", "453", "645"]
var d = '21 , 123,  44,  64,  67,  3'.split(/s*,s*/); // d = ["21", "123", "44", "64", "67", "3"]
```

## RegExp对象
每个RegExp对象都有5个属性。
- 属性source是一个只读字符串，包含正则表达式的文本。
- 属性global是一个只读布尔值，用以说明这个正则表达式是否带有修饰符g。
- 属性ignoreCase是一个只读布尔值，用以说明这个正则表达式是否带有修饰符i。
- 属性multiline是一个只读布尔值，用以说明这个正则表达式是否带有修饰符m。
- 属性lastIndex是一个可读可写的整数，如果匹配模式带有g修饰符，这个属性存储整个字符串中下一次检索的开始位置。

RegExp对象有两个方法。
exec()的参数是一个字符串，它的功能与match()相似，exec()方法对一个指定的字符串执行一个正则表达式，也就是在一个字符串中执行匹配检索。如果没有找到任何匹配就返回null，找到了匹配就返回一个数组，这个数组的第一个元素包含的是与正则表达式相匹配的字符串，余下的元素是与圆括号内的子表达式相匹配的子串，不论正则表达式是否有修饰符g，都会返回一样的数组。当调用exec()的正则表达式对象具有修饰符g时，它将把当前正则表达式对象的lastIndex属性设置为紧挨着匹配子串的字符位置。当同一个正则表达式第二次调用exec()时，它将从lastIndex属性所指示的字符串处开始检索，如果exec()没有发现任何匹配结果，它会将lastIndex重置为0。如：
```javascript
var p = /Java/g;
var text = "JavaScript is more fun than Java!"
var r;
while((r = p.exec(text)) != null) {
       console.log(r, 'lastIndex: ' + p.lastIndex);
}
```
另外一个方法是test()，它的参数是一个字符串，用test()对某个字符串进行检查，如果包含正则表达式的一个匹配结果，则返回true否则返回false。如：
```javascript
var p = /java/i;
p.test('javascript'); // true
```

## 创建方式
- var regExp=/正则表达式/gi 【隐式创建】
- var regExp=new RegExp(正则表达式,"gi"); [显式创建]
- g:global （是否执行全局匹配）i:ignore(不区分大小写）
- m：多行标志

## 正则对象的方法

### exec()方法
RegExpObject.exec(string)
用于检索字符串中正则表达式的匹配
返回一个数组，其中存放匹配的结果。如果未找到匹配，则返回值为 null。
如果 exec() 找到了匹配的文本，则返回一个结果数组。否则，返回 null。此数组的第 0 个元素是与正则表达式相匹配的文本

### test()
```javascript
RegExpObject.test(string)
```
方法用于检测一个字符串是否匹配某个模式.
如果字符串 string 中含有与 RegExpObject 匹配的文本，则返回 true，否则返回 false。

## 支持正则表达式的string对象的方法
### search()
```javascript
stringObject.search(regexp)
```
返回第一个与regexp相匹配的子串的起始位置
如果没有找到任何匹配的子串，返回-1
### match()
在字符串内检索指定的值，找到一个或多个正则表达式的匹配
```javascript
stringObject.match(searchvalue)
stringObject.match(regexp)
```
返回匹配结果的始祖，数组内容依赖于regexp是否具有全局标志g。
### replace()
replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。
```javascript
stringObject.replace(regexp/substr,replacement)
```
返回一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的。
### split()
split() 方法用于把一个字符串分割成字符串数组。
```javascript
stringObject.split(separator,howmany)
```
返回一个字符串数组。该数组是通过在separator指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 separator 自身。
但是，如果 separator是包含子表达式的正则表达式，那么返回的数组中包括与这些子表达式匹配的字串（但不包括与整个正则表达式匹配的文本）。

## regexp对象的属性
- index //仅支持ie
- lastindex
- input
- leftContext
- rightContext

## 子表达式和捕获，反向引用的概念

一个子表达式是一个整体，可重复后面引用
- /(d)(d)21/gi; 第二位和第三位相同，第一位和第四位相同
- /(d)1(d)2(d)3(d)4/; aabbccdd形式的数字
- /(d){5}-(d)22(d)33(d)44/gi; 12345-111222333

## 元字符
- 限定符
- 选择匹配符
- 分组组合和反向引用符
- 特殊字符
- 字符匹配符
- 定位符

## 限定符
- `[ ] `用于指定其前面的字符和组合项连续出现多少次
- `[ ]` {n，m}n表示至少出现n次最多出现m次
- `[ ]`“+” 表示出现一次到任意多次，“*”表示出现0次到任意多次，“？”表示出现0次到1次
- `[x] `js在默认匹配中使用的是贪婪匹配的原则，即尽可能匹配多的字符串

## 字符匹配符号
- [a-z]表示可以匹配a-z中任意一个字符
- [^a-z]表示可以匹配不是a-z中的任意一个字符
- [abcd]表示可以匹配到abcd中的任意一个字符
- d 表示可以匹配0-9的任意一个数字，相当于[0-9]
- D 表示可以匹配不是0-9中的任意一个数字，相当于[^0-9]
- w 匹配任意英文字符、数字和下划线，相当于[a-zA-Z0-9_]
- W 相当于[^a-zA-Z0-9_]是w刚好相反。
- s 匹配任何空白字符（空格、制表符等）
- S 匹配任何非空白字符，和s刚好相反
- . 匹配出n之外的所有字符，如果要匹配.本身则需要使用 .
- 需要用到转义符号的字符有 ： . * + () $ / ? [] ^ {}

## 定位符
用于规定匹配的字符串出现的位置
^符号 匹配目标字符串的开始位置
$符号 匹配目标字符串的结束位置

## 选择匹配符
- |

------------
# 其他

```js
1，\
斜杠用于转义，在js正则里，只有一些元字符(*,?,.等)和\本身需要转义，其他的不需要转义，如果其他的字符前面使用了\，可能会产生负面影响，比如\b，\t这些有特殊含义的转义。
此外，在js正则中，\还有一个用处在于使用new RegExp()形式创建正则对象时，比如new RegExp('a\*a'),其中*是乘以的意思，js引擎在解析该正则表达式字符串时，会消耗掉这个斜杠，最后生成的是a*a，这时候我们要这样写'a\\*a'。
2 ^
该元字符比较简单，就是表示该正则是从字符串的首字符开始匹配的，有一个地方需要注意的是，如果该正则表达式加了m标记时，匹配到了行分隔符的时候就会结束。然后会在下一行继续匹配。
'd\nd'.match(/^d/g)    => ['d'], 'd\nd'.match(/^d/mg) =>  ["d", "d"]
3 $
该元字符和^一样，当含义$的正则匹配一个字符串时，他不是直接判断该字符串的结尾，而是以行结束符为分隔，对每一行的结尾进行匹配。
'd\nd'.match(/d$/g)     => ['d'], 'd\nd'.match(/d$/mg)     = > ["d", "d"]
4 * + ?
这三个元字符代表的是匹配0到多个同样的字符组合，a*,a?,a+,分别代表匹配0到多个a，0到1个a,1到多个a。这是一种贪婪的匹配，也就是尽可能多地匹配后面符合条件的字符。
如果在这些元字符后面加上?，那么就代表是非贪婪匹配，也就是尽可能少地匹配。{n,m}和以上的情况类似，也可以在后面加?。
'ddd'.match(/d{1,11}/)    => ddd, 'ddd'.match(/d{1,11}?/) => d。
5 .
匹配除了行分隔符外的所有字符
6 捕获分组(x) \n $n RegExp.$n
()代表捕获分组，x代表的表达式所匹配的内容可以在x所有的正则中或者其他地方使用。
/(x)(y)\1\2/.test('xyxy') => true  /(x)(y)\1\2/.test('xyyy') => false,\n代表的是第n个捕获分组的值。
'xy'.replace(/(x)(y)/, "$1 and $2 ") => x and y, RegExp.$1 = x, RegExp.$2 = y,每次正则执行完后，捕获分组或挂载到RegExp对象上，并且清除上次执行的结果。
$&是一个特殊的变量，他代表是整个正则表达式匹配到的结果。也就是xy。
7 (?:x)
非捕获分组，也就是()中的表达式捕获到分组不可在其他地方使用。'x'.replace(/(?:x)/, "$1") => "$1"
8 x(?=y)
前向断言，断言x后面是y,但y不在捕获分组中，'x'.match(/x(?=y+)/) => null, 'xyy'.match(/x(?=y+)/) => x
9 x(?!y)
同上，断言x后面不是y。
10 [\b]
匹配(U+0008)，键盘中的退格键。
11 \b
匹配单词的边界，如果匹配成功，匹配到内容的结果长度为0，单词边界的定义为，某一个位置，后面或者前面没有单词字符，则是单词边界。其中单词字符的定义为大小写字母+数字+_。其余的都为非单词字符。
/a\b/.test('a~b') => true,~被视为单词边界。/a\b/.test('ab') => false
12 \B
分单词边界，定义类似\b。/a\B/.test('ab') => true, /b\B/.test('ab')  => false,b的后面是''，属于单词边界，所以是false。
13 \w
单词字符，定义为[A-Za-z0-9_]
14 \W
非单词字符，定义为[^A-Za-z0-9_]
15 \s
所有空格，如制表符、垂直分隔符、水平分隔符，定义为[ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]。
16 \S
非空格符，定义为[^ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]。
17 sticky
粘着位类似于全局匹配，当我们使用exec函数时，如果正则表达式中加了g，那么就会下次执行exec函数时就会从上次匹配的结束位置开始。
同样，我们可以通过加y标记来达到这个目的。
var x = /a/; x.exec('aa'), x.exec('aa'); lastIndex为上次匹配的位置，lastIndex为不会变，每次都匹配到第一个a
var x = /a/g; x.exec('aa'), x.exec('aa'); lastIndex会变，第n次匹配会匹配到第n个a
var x = /a/y; x.exec('aa'), x.exec('aa'); lastIndex会变，第n次匹配会匹配到第n个a,粘着位其实就是说上次匹配的位置会粘着（记着）
18 使用new RegExp()
动态生成正则时需要使用这种方式，但是需要对输入进行转义。需要对元字符进行修正，$&为每次匹配到的字符
function fix(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
```

我是Mr-老鬼、QQ1156346325 。交流QQ群：620028786,647082990
**------------------------------------------------版权声明------------------------------------------------------**
 本文版权所有~Mr-老鬼 ~转载请注明原文地址
免责声明：本文所有的教程仅限交流学习使用不得用于违法用途，造成的法律后果本人不承担责任。