javascript正则表达式总结
文章目录
匹配模式
| Flag | Description |
|---|---|
| g | Global search |
| i | Case-insensitive search |
| m | Multi-line search |
- g 全局搜索,默认搜索到第一个匹配立刻停止
- i 忽略大小写,默认大小写敏感
To include a flag with the regular expression, use this syntax:
var re = /pattern/flags;
or
var re = new RegExp("pattern", "flags");
javascript创建正则表达式两种方式
javascriptvar re1 = new RegExp('abc', 'g'); // equal to var re2 = /abc/g; console.log(re2 instanceof RegExp); //true
完全匹配:
javascriptvar re = /abc/; var str = 'abc'; var res = re.test(str); var arr = re.exec(str); console.log(res); //true console.log(arr); //['abc']
匹配字符串中的一部分:
javascriptvar re = /abc/; var str = '123abcdefg'; var res = re.test(str); var arr = re.exec(str); console.log(res); //true console.log(arr); //['abc']
找不到匹配:
javascriptvar re = /abc/; var str = 'ab'; var res = re.test(str); var arr = re.exec(str); console.log(res); //false console.log(arr); //null
不使用i匹配,默认大小写敏感:
javascriptvar re = /abc/; var str = 'ABC'; var res = re.test(str); var arr = re.exec(str); console.log(res); //false console.log(arr); //null
使用i匹配,忽略大小写:
javascriptvar re = /abc/i; var str = 'ABC'; var res = re.test(str); var arr = re.exec(str); console.log(res); //true console.log(arr); //['ABC']
使用g匹配:
javascriptvar re = /abc/g; var str = 'abc'; console.log(re.lastIndex); //0 var res = re.test(str); //or re.exec(str) console.log(re.lastIndex); //3
不使用g匹配:
javascriptvar re = /abc/; var str = 'abc'; console.log(re.lastIndex); //0 var res = re.test(str); //or re.exec(str) console.log(re.lastIndex); //0
使用全局模式g匹配时,如果使用.test()或.exec()方法匹配时,每次匹配到一个字符串后,lastIndex值会被更新,如果不使用g匹配,索引值lastIndex不会更新。
javascriptvar re = /abc/; var str = 'abc123abc456abc'; //未使用全局匹配时,只匹配到了第一个abc即终止 var arr = re.exec(str); console.log(arr); //['abc'] console.log(re.lastIndex); //0
javascriptvar re = /abc/g; var str = 'abc123abc456abc'; //使用全局匹配时,只匹配到了第一个abc即终止 var arr = re.exec(str); console.log(arr); //['abc'] console.log(re.lastIndex); //3,此时lastIndex指向字符串中的'1'
遍历所有匹配:
javascriptvar re = /abc/g; var str = 'abc123abc456abc'; var arr, list = []; while ( (arr = re.exec(str)) ) { console.log(arr); console.log(re.lastIndex); list.push(arr[0]); } console.log(list); // output // ['abc'] // 3 // ['abc'] // 9 // ['abc'] // 15 // ['abc', 'abc', 'abc']
使用String.prototype.match()
如果使用全局匹配g,String.prototype.match()会返回匹配的所有子串组成的数组
javascriptvar re = /abc/g; var str = 'abc123abc456abc'; var arr = str.match(re); console.log(arr); //['abc', 'abc', 'abc']
javascriptvar re = /[bcf]at/gi; var str = 'a bat ,a Cat,a fAt bat ,a faT cat'; var arr = str.match(re); console.log(arr); //[ "bat", "Cat", "fAt", "bat", "faT", "cat" ]
预定义特殊字符
| Character | Meaning |
|---|---|
| \t | Matches a tab |
| \r | Matches a carriage return(回车) |
| \n | Matches a line feed(换行) |
\. |
匹配.
|
\/ |
匹配/
|
\\ |
匹配\
|
匹配水平制表符
javascriptvar re = /\t/; var str = 'abc\tdef'; var res = re.test(str); var arr = re.exec(str); console.log(res); //true console.log(arr); //[' ']
匹配回车
javascriptvar re = /\r/; var str = 'abc\rdef'; var res = re.test(str); //true
匹配换行
javascriptvar re = /\n/; var str = 'abc\ndef'; var res = re.test(str); //true
- 使用
\.匹配.例如:
javascript/[a-z]\.[0-9]/.test('a.9'); //true
- 使用
\/匹配/例如:
javascript/\//.test('/'); //true /\/+/.test('//'); //true
- 使用
\\匹配\例如:
javascript/\\/.test('\\'); //true 匹配一个'\' /^\\{2}$/.test('\\\\'); //true 匹配两个'\'
集合
| Character | Meaning |
|---|---|
| [xyz] | Character set. |
| [^xyz] | A negated or complemented character set. |
- [xyz] 包含x,y,z任意一个字符的集合
- [a-d] 等价于[abcd],或[a-zA-Z0-9]匹配a-z,A-Z,0-9
- [^xyz] 不包含x,y,z任意一个字符
- [a-z.] 如果方括号中包含
.,仅仅匹配一个.而不是量词的. - [\u4e00-\u9fa5] 匹配单个汉字
javascriptvar re = /[xyz]/; var str = 'ax'; var arr = re.exec(str); console.log(arr); //['x']
javascriptvar re = /[^xyz]/; var str = 'ax'; var arr = re.exec(str); console.log(arr); //['a']
匹配集合中的.
javascriptvar re = /[a-z.]+/; //或 var re = /[\w.]+/ var str = 'test.i.ng'; var arr = re.exec(str); console.log(arr); //['test.i.ng']
javascript/[d-z]/.test('g'); //true /[d-z]/.test('gg'); //true 匹配到第一个'g'立即停止匹配 /[^abc]/.test('g'); //true /[^abc]/.test('gg'); //true 匹配到第一个'g'立即停止匹配 /[^abc]/.test('ga'); //true 匹配到第一个'g'立即停止匹配
量词
| Character | Meaning |
|---|---|
? |
Matches the preceding character 0 or 1 time. Equivalent to {0,1}. |
+ |
Matches the preceding character 1 or more times. Equivalent to {1,}. |
* |
Matches the preceding character 0 or more times. Equivalent to {0,}. |
| {n} | Matches exactly n occurrences of the preceding character. N must be a positive integer. |
| {n,m} | Matches at least n and at most m occurrences of the preceding character.When m is omitted, it's treated as ∞. |
-
{n}匹配n次 -
{n,m}匹配n到m次 -
{n,}最少匹配n次 -
{,m}最多匹配m次
关于{n}的例子:
javascriptvar re = /a{2}/; var str = 'a'; //由于'a'只出现1次,所以无法匹配exec返回null var arr = re.exec(str); console.log(arr); // null
javascriptvar re = /a{2}/; var str = 'aa'; //'a'连续出现两次,匹配'aa' var arr = re.exec(str); console.log(arr); // ['aa']
javascriptvar re = /a{2}/; var str = 'aaa'; //'a'连续出现3次,也只能匹配两个'a' var arr = re.exec(str); console.log(arr); // ['aa']
关于{n,m}的例子
javascriptvar re = /a{2,5}/; var str1 = 'a'; var str2 = 'aa'; var str3 = 'aaaaa'; var str4 = 'aaaaaa'; var arr1 = re.exec(str1); //匹配不到 var arr2 = re.exec(str2); //可以匹配到'aa' var arr3 = re.exec(str3); //可以匹配到'aaaaa' var arr4 = re.exec(str4); //最多只能匹配到5个a console.log(arr1); //null console.log(arr2); //['aa'] console.log(arr3); //['aaaaa'] console.log(arr4); //['aaaaa']
匹配0或1个a
javascriptvar re = /a?/; var str = 'a'; // 匹配到了1个'a' var res = re.test(str); var arr = re.exec(str); console.log(res); // true console.log(arr); // ['a']
javascriptvar re = /a?/; var str = ''; // 匹配到了0个'a' var res = re.test(str); var arr = re.exec(str); console.log(res); // true console.log(arr); // ['']
javascriptvar re = /a+/; var str = 'aaabc'; // 最多匹配1个'a' var arr = re.exec(str); console.log(arr); // ['a']
匹配1或多个a
javascriptvar re = /a+/; var str = 'abc'; // 匹配到了1个'a' var arr = re.exec(str); console.log(arr); // ['a']
javascriptvar re = /a+/; var str = 'aaabc'; // 匹配到了多个'a' var arr = re.exec(str); console.log(arr); // ['aaa']
集合+量词
javascriptvar re = /[a-z]?/; var str = 'aaabc'; // 匹配到了一个'a' var arr = re.exec(str); console.log(arr); // ['a']
javascriptvar re = /[a-z]+/; var str = 'aaabc'; // 匹配整个字符串 var arr = re.exec(str); console.log(arr); // ['aaabc']
javascriptvar re = /[a-z]?/; var str = 'ABCdef'; // 匹配0或1次集合中字符,由于第一个字符不在集合中,所以匹配到了空字符(0个) var arr = re.exec(str); console.log(arr); // ['']
javascriptvar re = /[a-z]?/; var str = 'abcABCdef'; // 匹配0或1次集合中字符,由于第一个字符在集合中,所以最多匹配了一个字符'a' var arr = re.exec(str); console.log(arr); // ['a']
javascriptvar re = /[a-z]+/; var str = 'ABCdefGHijk'; // 匹配1或多次集合中字符,在字符串中找到了最先出现的匹配'def' // 优先匹配多个字符'def',而不是1个字符'd' var arr = re.exec(str); console.log(arr); // ['def']
javascriptvar re = /[a-z]+/; var str = 'aABCdefGHijk'; // 匹配1或多次集合中字符,在字符串中找到了最先出现的匹配'a' // 由于接下来的是'A'所以停止匹配 var arr = re.exec(str); console.log(arr); // ['a']
javascriptvar re = /[a-z]*/; var str = 'ABCdefGHijk'; // 匹配0或多次集合中字符,由于第一个字符不在集合中,所以匹配到了空字符(0个) var arr = re.exec(str); console.log(arr); // ['']
javascriptvar re = /[a-z]*/; var str = 'abcABCdefGHijk'; // 匹配0或多次集合中字符,由于前面的3个字符'abc'在集合中,所以匹配到了'abc' var arr = re.exec(str); console.log(arr); // ['abc']
预定义类
| Character | Meaning |
|---|---|
. |
matches any single character except the newline character. |
| \d | Matches a digit character. Equivalent to [0-9]. |
| \D | Matches any non-digit character. Equivalent to [^0-9]. |
| \s | Matches a single white space character, including space, tab, form feed, line feed(空白符) |
| \S | Matches a single character other than white space(非空白符) |
| \w | Matches any alphanumeric character including the underscore. Equivalent to [A-Za-z0-9_]. |
| \W | Matches any non-word character. Equivalent to [^A-Za-z0-9_]. |
.匹配除了回车和换行之外的所有字符,等价于[^\r\n]
返回用空白符分隔的字符串组成的数组:
javascriptvar re = /\S+/g; var str = 'abc def ghi'; var arr = str.match(re); console.log(arr); //['abc', 'def', 'ghi']
边界
| Character | Meaning |
|---|---|
^ |
Matches beginning of input. |
$ |
Matches end of input. |
| \b | Matches a word boundary |
| \B | Matches a non-word boundary |
javascript/abc/.test('123abc'); //true 匹配到abc /^abc/.test('123abc'); //false 在字符串起始位置未匹配到 /abc/.test('abc123'); //true 匹配到abc /abc/.test('abc123'); //true /abc$/.test('abc123'); //false /abc$/.test('123abc'); //true
-
\b匹配单词边界,指[A-Za-z0-9_]之外的字符 -
\B匹配非单词边界
javascript// 不使用边界\b匹配 var arr1 = '-12w-eefd&efrew'.match(/[\w-]+/g); // 由于[\w-]包含'-',所以匹配出的第一个字符串为'-12w-eefd' console.log(arr1); //["-12w-eefd", "efrew"] // 使用边界\b匹配 var arr2 = '-12w-eefd&efrew'.match(/\b[\w-]+\b/g); // 从第一个[A-Za-z0-9_]之外的字符开始匹配,即从'-'作为起始点匹配,所以第一个匹配出的字符串不包含'-',为'12w-eefd' console.log(arr2); //["12w-eefd", "efrew"]
贪婪模式和惰性模式
- 惰性模式匹配是在量词后面加
?
javascript// 默认情况下为贪婪匹配,{3,5}优先从最大值5匹配 '123456789'.match(/\d{3,5}/g); //["12345", "6789"] // 在量词后面添加?为惰性匹配,{3,5}优先从最小值3匹配,如果匹配到则终止匹配 '123456789'.match(/\d{3,5}?/g); //["123", "456", "789"]
javascript// 贪婪匹配,匹配到整个字符串 'abbbcbbb'.match(/.*bbb/g); //["abbbcbbb"] // 惰性匹配,当匹配到第一个'bbb'即停止匹配 'abbbcbbb'.match(/.*?bbb/g); //["abbb", "cbbb"]
或
| Character | Meaning |
|---|---|
x|y |
Matches either 'x' or 'y'. |
javascript/a|b/.test('a'); //true 只匹配a或b任一个字符 /a|b/.test('c'); //false
javascript/[a|b]/.test('|'); //true 在集合中'|'不代表或,只代表字符'|'
javascript/(a|b|c)+/.test('a'); //true 可以在分组中使用'|'
分组匹配
| Character | Meaning |
|---|---|
(x) |
Matches 'x' and remembers the match |
使用()进行分组匹配
javascript/(foo){3}/.test('foofoofoo'); //true 连续匹配'foo'3次
- 使用
exec(),返回的数组的第0个元素存储匹配的字符串,从第1个元素开始依次存储分组字符串
javascript// 第0个元素为匹配后的字符串"foofoofoo",第1个元素存储分组字符串"foo" /(foo){3}/.exec('foofoofoo'); //["foofoofoo", "foo"] // 第1,2个元素分别存储'foo','bar' /(foo){1}(bar){2}/.exec('foobarbar'); //["foobarbar", "foo", "bar"]
- 使用
String.prototype.match()
不使用g匹配,返回的数组的第0个元素存储匹配的字符串,从第1个元素开始依次存储分组字符串,同exec()的返回结果
javascript'foobarbar'.match(/(foo){1}(bar){2}/); //["foobarbar", "foo", "bar"] 'abc123abcabc456abc'.match(/(abc)+/); //["abc", "abc"]
使用g匹配,match返回的数组只存储匹配的字符串
javascript'foobarbar'.match(/(foo){1}(bar){2}/g); //["foobarbar"] 'abc123abcabc456abc'.match(/(abc)+/g); //["abc", "abcabc", "abc"]
虽然使用g匹配,match的结果没有保存分组信息,但实际上还是捕获到了分组信息,如:
javascript'foobarbar'.match(/(foo){1}(bar){2}/g); //["foobarbar"] // 通过反向引用查看捕获的分组信息 console.log(RegExp.$1); //'foo' console.log(RegExp.$2); //'bar'
分组匹配的一些例子:
javascript'a'.match(/(a)?/); //['a', 'a'],匹配到了'a' 'a'.match(/(a)?/g); //['a', ''],匹配到了'a'和'' 'aa'.match(/(a)?/); //['a', 'a'],匹配到了第一个'a' 'aa'.match(/(a)?/g);//['a', 'a', ''],匹配到了第一个'a',第二个'a',和'' 'a'.match(/(a)+/); //['a', 'a'],匹配到了'a' 'a'.match(/(a)+/g); //['a'],只匹配到了'a' 'aa'.match(/(a)+/); //['aa', 'a'],匹配了'aa' 'aa'.match(/(a)+/g);//['aa'],只匹配到了'aa' 'a'.match(/(a)*/); //['a', 'a'],匹配到了'a' 'a'.match(/(a)*/g); //['a', ''],匹配到了'a'和'' 'aa'.match(/(a)*/); //['aa', 'a'],匹配了'aa' 'aa'.match(/(a)*/g);//['aa', ''],匹配到了'aa'和'' // 第二个参数为最后一次匹配的分组'dad' 'baddad'.match(/([bd]ad?)*/); //["baddad", "dad"] 'baddad'.match(/([bd]ad?)*/g); //["baddad", ""] // 匹配到了ab,第1个元素为最外层分组'ab',第2个元素为内层分组'b' 'ab'.match(/(a(b)?)/); //['ab', 'ab', 'b']
反向引用
- 使用
RegExp.$n
javascript/(foo){3}/.exec('foofoofoo'); //["foofoofoo", "foo"] console.log(RegExp.$1); //'foo' /(foo){1}(bar){2}/.exec('foobarbar'); //["foobarbar", "foo", "bar"] console.log(RegExp.$1); //'foo' console.log(RegExp.$2); //'bar'
- 在正则表达式中使用
\n
javascript/(foo)/.exec('foofoo'); //['foo', 'foo'] // 因为'\1'='foo',所以'/(foo)\1/'等价于'/(foo)foo/' /(foo)\1/.exec('foofoo'); //['foofoo', 'foo'],匹配到了'foofoo'
- 在
String.prototype.replace()中使用反向引用
javascriptvar re = /(\w+)\s(\w+)/; var str = 'John Smith'; str.match(re); //["John Smith", "John", "Smith"] var newstr = str.replace(re, '$2, $1'); console.log(newstr); //Smith, John
非捕获性分组
不记录分组信息,不能创建反向引用的匹配,格式为(?:x)
| Character | Meaning |
|---|---|
(?:x) |
Matches 'x' but does not remember the match. |
javascript// 正常情况下为捕获性分组,匹配字符串'abc',捕获分组字符串'c' 'abc'.match(/(\w){3}/); //["abc", "c"] // 使用非捕获性分组,匹配字符串'abc',未捕获到分组字符串 'abc'.match(/(?:\w){3}/); //["abc"]
javascript// 正常情况下两个分组信息都捕获 '12345.123'.match(/^(\d)+.(\d){3}$/g); console.log(RegExp.$1); //5 console.log(RegExp.$2); //3 // 第一个分组使用非捕获 '12345.123'.match(/^(?:\d)+.(\d){3}$/g); console.log(RegExp.$1); //3 console.log(RegExp.$2); //不存在
前瞻捕获
| Character | Meaning |
|---|---|
x(?=y) |
Matches 'x' only if 'x' is followed by 'y'. This is called a lookahead. |
x(?!y) |
Matches 'x' only if 'x' is not followed by 'y'. This is called a negated lookahead. |
- 正向前瞻匹配
x(?=y),找到x后面紧跟着y的位置,如果找到则匹配这个位置,返回x - 逆向前瞻匹配
x(?!y),找到x后面不是y的位置,如果找到则匹配这个位置,返回x - 括号
()只代表匹配的一个位置,不代表匹配的字符
javascript// 匹配到了位置,在a和1之间,结果匹配到了'a' 'a1'.match(/a(?=1)/); //['a'] // 匹配到了位置,在a和1之间,'\d'匹配了后面的1 'a1'.match(/a(?=1)\d/); //['a1'] // 匹配了第一个a和1之间的位置 'a1bcdefa1'.match(/a(?=1)/); //['a'] // 匹配到了所有的a和1之间的位置(字符串开始和结束的两个'a1') 'a1bcdefa1'.match(/a(?=1)/g); //['a', 'a'] // 在a后面没有找到1,所以没有匹配到a和1之间的位置 'a2'.match(/a(?=1)/); //null
javascript// a后面为2不是1,所以找到了匹配的位置,在a和2之间 'a2'.match(/a(?!1)/); //['a'] // 同上,用'\d'匹配了2 'a2'.match(/a(?!1)\d/); //['a2'] // 这里匹配的位置是'aba'和'a'之间的位置,返回的是[a-b]+匹配的结果 'abaa1'.match(/[a-b]+(?!1)/); //['aba'] // 'abc'共有4个间隔位置,分别是字符串开始和a之间,a和b之间,b和c之间,c和字符串结束之间 // 这里匹配每个位置如果后面的是b则不匹配,不为b则匹配,所以总共匹配了3个位置 'abc'.match(/(?!b)/g); //['', '', '']
以上是我整理的正则学习笔记,参考了api文档和网上的一些资料,会有不全和不对的地方,希望大家提出,我好及时补充和更正。

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论