婚配形式
| 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文档和网上的一些材料，会有不全和不对的处所，愿望人人提出，我好实时补充和改正。
