JS正则表达式语法⼤全（⾮常详细）
正则表达式是⼀种通⽤的⼯具，在 Script、、Java、、等⼏乎所有的编程语⾔中都能使⽤；但是，不同编程语⾔对正则表达式语法的⽀持不尽相同，有的编程语⾔⽀持所有的语法，有的仅⽀持⼀个⼦集。本节讲到的正则表达式语法适⽤于 JavaScript。
正则表达式的语法体现在字符模式上。字符模式是⼀组特殊格式的字符串，它由⼀系列特殊字符和普通字符构成，其中每个特殊字符都包含⼀定的语义和功能。
描述字符
根据正则表达式语法规则，⼤部分字符仅能够描述⾃⾝，这些字符被称为普通字符，如所有的字母、数字等。
元字符就是拥有特动功能的特殊字符，⼤部分需要加反斜杠进⾏标识，以便于普通字符进⾏区别，⽽少数元字符，需要加反斜杠，以便转译为普通字符使⽤。JavaScript 正则表达式⽀持的元字符如表所⽰。
元字符
元字符描述
.查单个字符，除了换⾏和⾏结束符
\w查单词字符
\W查⾮单词字符
\d查数字
\D查⾮数字字符
\s查空⽩字符
\S查⾮空⽩字符
\b匹配单词边界
\B匹配⾮单词边界
\0查 NUL字符
\n查换⾏符
\f查换页符
\r查回车符
\t查制表符
\v查垂直制表符
\xxx查以⼋进制数 xxxx 规定的字符
\xdd查以⼗六进制数 dd 规定的字符
\uxxxx查以⼗六进制 xxxx规定的 Unicode 字符
表⽰字符的⽅法有多种，除了可以直接使⽤字符本⾝外，还可以使⽤ ASCII 编码或者 Unicode 编码来表⽰。
⽰例1
下⾯使⽤ ASCII 编码定义正则表达式直接量。
1. var r = /\x61/;
2. var s = "JavaScript";
3. var a = s.match(s);
由于字母 a 的 ASCII 编码为 97，被转换为⼗六进制数值后为 61，因此如果要匹配字符 a，就应该在前⾯添加“\x”前缀，以提⽰它为 ASCII 编码。
⽰例2
除了⼗六进制外，还可以直接使⽤⼋进制数值表⽰字符。
1. var r = /\141/;
2. var s = "JavaScript";
3. var a = s.match(r);
使⽤⼗六进制需要添加“\x”前缀，主要是为了避免语义混淆，⽽⼋进制则不需要添加前缀。
⽰例3
ASCII 编码只能够匹配有限的单字节字符，使⽤ Unicode 编码可以表⽰双字节字符。Unicode 编码⽅式：“\u”前缀加上 4 位⼗六进制值。
1. var r = "/\u0061/";
2. var s = "JavaScript";
3. var a = s.match(s);
在 RegExp() 构造函数中使⽤元字符时，应使⽤双斜杠。
1. var r = new RegExp("\\u0061");
RegExp() 构造函数的参数只接受字符串，⽽不是字符模式。在字符串中，任何字符加反斜杠还表⽰字符本⾝，如字符串“\u”就被解释为 u 本⾝，所以对于“\u0061”字符串来说，在转换为字符模式时，就被解释为“u0061”，⽽不是“\u0061”，此时反斜杠就失去转义功能。解决⽅法：在字符 u 前⾯加双反斜杠。
描述字符范围
在正则表达式语法中，放括号表⽰字符范围。在⽅括号中可以包含多个字符，表⽰匹配其中任意⼀个字符。如果多个字符的编码顺序是连续的，可以仅指定开头和结尾字符，省略中间字符，仅使⽤连字符~表⽰。如果在⽅括号内添加脱字符^前缀，还可以表⽰范围之外的字符。例如：
[abc]：查⽅括号内任意⼀个字符。
[^abc]：查不在⽅括号内的字符。
[0-9]：查从 0 ⾄ 9 范围内的数字，即查数字。
[a-z]：查从⼩写 a 到⼩写 z 范围内的字符，即查⼩写字母。
[A-Z]：查从⼤写 A 到⼤写 Z 范围内的字符，即查⼤写字母。
[A-z]：查从⼤写 A 到⼩写 z 范围内的字符，即所有⼤⼩写的字母。
⽰例1
字符范围遵循字符编码的顺序进⾏匹配。如果将要匹配的字符恰好在字符编码表中特定区域内，就可以使⽤这种⽅式表⽰。
如果匹配任意 ASCII 字符：
1. var r = /[\u0000-\u00ff]/g;
如果匹配任意双字节的汉字：
1. var r = /[^\u0000-\u00ff]/g;
如果匹配任意⼤⼩写字母和数字：
1. var r = /[a-zA-Z0-9]/g;
使⽤ Unicode 编码设计，匹配数字：
1. var r = /[\u0030-\u0039]/g;
使⽤下⾯字符模式可以匹配任意⼤写字母：
1. var r = /[\u0041-\u004A]/g;
使⽤下⾯字符模式可以匹配任意⼩写字母：
1. var r = /[\u0061-\u007A]/g;
⽰例2
在字符范围内可以混⽤各种字符模式。
1. var s = "abcdez"; //字符串直接量
2. var r = /[abce-z]/g; //字符a、b、c，以及从e~z之间的任意字符
3. var a = s.match(r); //返回数组["a","b","c","e","z"]
⽰例3
在中括号内不要有空格，否则会误解为还要匹配空格。
1. var r = /[0-9]/g;
⽰例4
字符范围可以组合使⽤，以便设计更灵活的匹配模式。
1. var s = "abc4 abd6 abe3 abf1 abg7"; //字符串直接量
2. var r = /ab[c-g][1-7]/g; //前两个字符为ab，第三个字符为从c到g，第四个字符为1~7的任意数字
3. var a = s.match(r); //返回数组["abc4","abd6","abe3","abf1","abg7"]
⽰例5
使⽤反义字符范围可以匹配很多⽆法直接描述的字符，达到以少应多的⽬的。
1. var r = /[^0123456789]/g;
javascript说明在这个正则表达式中，将会匹配除了数字以外任意的字符。反义字符类⽐简单字符类的功能更强⼤和实⽤。
选择匹配
选择匹配类似于 JavaScript 的逻辑与运算，使⽤竖线|描述，表⽰在两个⼦模式的匹配结果中任选⼀个。例如：
1) 匹配任意数字或字母
1. var r = /\w+|\d+/;
2) 可以定义多重选择模式。设计⽅法：在多个⼦模式之间加⼊选择操作符。
1. var r = /(abc)|(efg)|(123)|(456)/;
为了避免歧义，应该为选择操作的多个⼦模式加上⼩括号。
⽰例
设计对提交的表单字符串进⾏敏感词过滤。先设计⼀个敏感词列表，然后使⽤竖线把它们连接在⼀起，定义选择匹配模式，最后使⽤字符串的 replace() ⽅法把所有敏感字符替换为可以显⽰的编码格式。代码如下：
1. var s = '<meta charset="utf-8">'; //待过滤的表单提交信息
2. var r = /\'|\"|\<|\>/gi; //过滤敏感字符的正则表达式
3. function f() { //替换函数
4. ////把敏感字符替换为对应的⽹页显⽰的编码格式
5. return "&#" + arguments[0].charCodeAt(0) + ";";
6. }
7. var a =s.replace(r,f); //执⾏过滤替换
8. document.write(a); //在⽹页中显⽰正常的字符信息
9. console.log(a);
显⽰结果如下：
重复匹配
在正则表达式语法中，定义了⼀组重复类量词，如表所⽰。它们定义了重复匹配字符的确数或约数。
重复类量词列表
量词描述
n+匹配任何包含⾄少⼀个 n 的字符串
n*匹配任何包含零个或多个 n 的字符串
n?匹配任何包含零个或⼀个 n 的字符串
n{x}匹配包含 x 个 n 的序列的字符串
n{x,y}匹配包含最少 x 个、最多 y 个 n 的序列的字符串
n{x,}匹配包含⾄少 x 个 n 的序列的字符串
⽰例
下⾯结合⽰例进⾏演⽰说明，先设计⼀个字符串：
1. var s = "ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
1) 如果仅匹配单词 ggle 和 gogle，可以设计：
1. var r = /go?gle/g;
2. var a = s.match(r);
量词表⽰前⾯字符或⼦表达式为可有可⽆，等效于：
1. var r = /go{0,1}gle/g;
2. var a = s.match(r);
2) 如果匹配第 4 个单词 gooogle，可以设计：
1. var r = /go{3}gle/g;
2. var a = s.match(r);
等效于：
1. var r = /gooogle/g;
2. var a = s.match(r);
3) 如果匹配第 4 个到第 6 个之间的单词，可以设计：
1. var r = /go{3,5}gle/g;
2. var a = s.match(r);
4) 如果匹配所有单词，可以设计：
1. var r = /go*gle/g;
2. var a = s.match(r);
量词*表⽰前⾯字符或表达式可以不出现，或者重复出现任意多次。等效于：
1. var r = /go(0,)gle/g;
2. var a = s.match(r);
5) 如果匹配包含字符“o”的所有词，可以设计：
1. var r = /go+gle/g;
2. var a = s.match(r);
量词+表⽰前⾯字符或⼦表达式⾄少出现 1 次，最多重复次数不限。等效于：
1. var r = /go{1,}gle/g;
2. var a = s.match(r);
重复类量词总是出现在它们所作⽤的字符或⼦表达式后⾯。如果想作⽤于多个字符，需要使⽤⼩括号把它们包裹在⼀起形成⼀个⼦表达式。惰性匹配
重复类量词都具有贪婪性，在条件允许的前提下，会匹配尽可能多的字符。
、{n} 和 {n,m} 重复类具有弱贪婪性，表现为贪婪的有限性。
*、+ 和 {n,} 重复类具有强贪婪性，表现为贪婪的⽆限性。
⽰例1
越是排在左侧的重复类量词匹配优先级越⾼。下⾯⽰例显⽰当多个重复类量词同时满⾜条件时，会在保证右侧重复类量词最低匹配次数基础上，使最左侧的重复类量词尽可能占有所有字符。
1. var s = "<html><head><title></title></head><body></body></html>";
2. var r = /(<.*>)(<.*>)/
3. var a = s.match(r);
4. //左侧表达式匹配"<html><head><title></title></head><body></body></html>"
5. console.log(a[1])；
6. console.log(a[2]); //右侧表达式匹配“</html>”
与贪婪匹配相反，惰性匹配将遵循另⼀种算法：在满⾜条件的前提下，尽可能少的匹配字符。定义惰性匹配的⽅法：在重复类量词后⾯添加问号?限制词。贪婪匹配体现了最⼤化匹配原则，惰性匹配则体现最⼩化匹配原则。
⽰例2
下⾯⽰例演⽰了如何定义匹配模式。
1. var s = "<html><head><title></title></head><body></body></html>";
2. var r = /<.*?>/
3. var a = s.match(r); //返回单个元素数组["<html>"]
在上⾯⽰例中，对于正则表达式 /<.*?>/ 来说，它可以返回匹配字符串 "<>"，但是为了能够确保匹配条件成⽴，在执⾏中还是匹配了带有
4 个字符的字符串“html”。惰性取值不能够以违反模式限定的条件⽽返回，除⾮没有到符合条件的字符串，否则必须满⾜它。
针对 6 种重复类惰性匹配的简单描述如下：
{n,m}?：尽量匹配 n 次，但是为了满⾜限定条件也可能最多重复 m 次。
{n}?：尽量匹配 n 次。
{n,}?：尽量匹配 n 次，但是为了满⾜限定条件也可能匹配任意次。
：尽量匹配，但是为了满⾜限定条件也可能最多匹配 1 次，相当于 {0,1}?。
+?：尽量匹配 1 次，但是为了满⾜限定条件也可能匹配任意次，相当于 {1,}?。
*? ：尽量不匹配，但是为了满⾜限定条件也可能匹配任意次，相当于 {0,}?。
边界量词
边界就是确定匹配模式的位置，如字符串的头部或尾部，具体说明如表所⽰。
JavaScript 正则表达式⽀持的边界量词
量词说明
^匹配开头，在多⾏检测中，会匹配⼀⾏的开头
$匹配结尾，在多⾏检测中，会匹配⼀⾏的结尾
下⾯代码演⽰如何使⽤边界量词。先定义字符串：
1. var s = "how are you"
1) 匹配最后⼀个单词
1. var r = /\w+$/;
2. var a = s.match(r); //返回数组["you"]
2) 匹配第⼀个单词
1. var r = /^\w+/;
2. var a = s.match(r); //返回数组["how"]
3) 匹配每⼀个单词
1. var r = /\w+/g;
2. var a = s.match(r); //返回数组["how","are","you"]
声明词量

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。