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文档和网上的一些资料,会有不全和不对的地方,希望大家提出,我好及时补充和更正。

评论

暂无评论