javascript正则表达式速查

声明：本文为原创文章，如需转载，请注明来源并保留原文连接前端小尚，谢谢！

做用

---

1. 数据有效性验证
2. 替换文本
3. 提取文本

声明方式

---

字面量的声明方式

示例：var re = /a/gi;

RegExp声明方式

var re = new RegExp();  //RegExp是一个对象,和Aarray同样
//但这样没有任何效果,须要将正则表达式的内容做为字符串传递进去

re =new RegExp("a");    //最简单的正则表达式,将匹配字母a
re=new RegExp("a","i"); //第二个参数,表示匹配时不分大小写

RegExp构造函数第一个参数为正则表达式的文本内容，而第二个参数则为可选项标志.标志能够组合使用,两个参数都是字符串。

建立这个字符串时要多加当心，由于反斜杠在正则表达式和在字符串字面量中有一些不一样的含义。一般须要双写反斜杠,以及对引号进行转义。(表如今低版本浏览器上)

var str='a/b\\c';
var reg=/^a\/b\\c$/;

document.write(str+'<br />');               //==>a/b\c

document.write(reg.test(str)+'<br />');     //==>true

var reg1=new RegExp('^a/b\\\\c$');
var reg2=new RegExp('^a/b\\\\c$');
document.write(reg1.test(str)+'<br />');     //==>true，低版本浏览器为false
document.write(reg2.test(str)+'<br />');     //==>true，这才是正确写法

正则表达式的定义

---

一个正则表达式就是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式做为一个模板，将某个字符模式与所搜索的字符串进行匹配。

修饰符

---

• g（全文查找）
• i（忽略大小写）
• m（多行查找）

示例：

var re = new RegExp("a","gi");  //匹配全部的a或A
var re=/a/gi;                   //同上

字符类

//简单类
var re = /[abc123]/;//将匹配abc123这6个字符中一个
//负向类
re = /[^abc]/;//将匹配除abc以外的一个字符
//范围类
re = /[a-b]/;//将匹配小写a-b 26个字母
re = /[^0-9]/;//将匹配除0-9 10个字符之处的一个字符
//组合类
re = /[a-b0-9A-Z_]/;//将匹配字母，数字和下划线

元字符

特殊字符	描述	预约义类	描述	等同于
\n	换行符	.	匹配除换行符以外的任何一个字符	IE下[^\n]，其它[^\n\r]
\r	回车符	\d	匹配数字	[0-9]
\t	制表符	\D	匹配非数字字符	[^0-9]
\f	换页符（Tab）	\s	匹配一个空白字符	[ \n\r\t\f\x0B]
\cX	与X对应的控制字符	\S	匹配一个非空白字符	[^ \n\r\t\f\x0B]
\b	退格符(BackSpace)	\w	匹配字母数字和下划线	[a-zA-Z0-9_]
\v	垂直制表符	\W	匹配除字母数字下划线以外的字符	[^a-zA-Z0-9_]
\0	空字符("")

查看更多

量词

代码	描述
*	匹配前面的子表达式零次或屡次。例如，zo* 能匹配 "z" 以及 "zoo"。 * 等价于{0,}。
+	匹配前面的子表达式一次或屡次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 能够匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配肯定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，可是能匹配 "food" 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的全部 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。刘， "o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。

贪婪量词与惰性量词

用贪婪量词进行匹配时，它首先会将整会字符串当成一个匹配，若是匹配的话就退出，若是不匹配，就截去最后一个字符进行匹配，若是不匹配，继续将最后一个字符截去进行匹配，直到有匹配为止。直到如今咱们遇到的量词都是贪婪量词

用惰性量词进行匹配时，它首先将第一个字符当成一个匹配，若是成功则退出，若是失败，则测试前两个字符，依些增长，直到遇到合适的匹配为止

var str = "abc";
var re = /\w+/; //将匹配abc
re = /\w+?/;    //将匹配a

转义

下列字符是须要转义的字符：
\ / [ ] ( ) { } ? + * | . ^ $

使用前须要反斜杠，例如：

var str='ab+c',
    reg=/^ab\+c$/;
reg.test(str);      //true

分支（也就是所说的“或”）

一个正则表达式分支包含一个或多个正则表达式序列。这些序列被|（竖线）字符分隔。若是这些序列中的任何一项符合匹配条件，那么这个选择就被匹配。它尝试按顺序依次匹配这些序列项。因此，当前者被匹配后，后面就不会再被匹配了。

re = /^a|bc$/;//将匹配开始位置的a或结束位置的bc
str ="add";
alert(re.test(str));//true
re = /^(a|bc)$/;//将匹配a或bc
str ="bc";
alert(re.test(str));//true

分组与非捕获性分组

re = /abc{2}/;//将匹配abcc
re = /(abc){2}/;//将匹配abcabc
//上面的分组都是捕获性分组
str = "abcabc ###";
arr = re.exec(str);
alert(arr[1]);//abc
alert(RegExp.$1);//abc
//非捕获性分组 (?:)
re = /(?:abc){2}/;
arr = re.exec(str);
alert(arr[1]);//undefined

正/负向前瞻

正向前瞻,用来捕获出如今特定字符以前的字符,只有当字符后面跟着某个特定字符才去捕获它。
与正向前瞻对应的有负向前瞻，它用匹配只有当字符后面不跟着某个特定字符时才去匹配它。

在执行前瞻和负向前瞻之类的运算时，正则表达式引擎会留意字符串后面的部分，然而却不移动index。

//正向前瞻
re = /([a-z]+(?=\d))/i;
//咱们要匹配后面跟一个数字的单词，而后将单词返回，而不要返回数字
str = "abc every1 abc";
alert(re.test(str));//true
alert(RegExp.$1);//every
alert(re.lastIndex);//使用前瞻的好处是,前瞻的内容(?=\d)并不会当成一次匹配，下次匹配仍从它开始
//负向前瞻(?!)
re = /([a-z](?!\d))/;i
//将匹配后面不包含数字的字母,而且不会返回(?!\d)中的内容
str = "abc1 one";
alert(re.test(str));
alert(RegExp.$1);//one

多行模式

var re = /[a-z]$/;
var str = "ab\ncdef";
alert(str.replace(re,"#"));//ab\ncde#
re =/[a-z]$/m;
alert(str.replace(re,"#"));//a#\ncde#

RegExp对象

---

方法

1. test(),返回一个 Boolean 值，它指出在被查找的字符串中是否存在模式。若是存在则返回 true，不然就返回 false。

   var str = "Visit W3School",
       patt1 = new RegExp("W3School"),
       result = patt1.test(str);
   document.write(result);    //true

2. exec(),返回一个数组，其中存放匹配的结果。若是未找到匹配，则返回值为 null。

   若是 exec() 找到了匹配的文本，则返回一个结果数组。不然，返回 null。此数组的第 0 个元素是与正则表达式相匹配的文本，第 1 个元素是与 RegExpObject 的第 1 个子表达式相匹配的文本（若是有的话），第 2 个元素是与 RegExpObject 的第 2 个子表达式相匹配的文本（若是有的话），以此类推。除了数组元素和 length 属性以外，exec() 方法还返回两个属性。index 属性声明的是匹配文本的第一个字符的位置。input 属性则存放的是被检索的字符串 string。咱们能够看得出，在调用非全局的 RegExp 对象的 exec() 方法时，返回的数组与调用方法 String.match() 返回的数组是相同的。

   可是，当 RegExpObject 是一个全局正则表达式时，exec() 的行为就稍微复杂一些。它会在 RegExpObject 的 lastIndex 属性指定的字符处开始检索字符串 string。当 exec() 找到了与表达式相匹配的文本时，在匹配后，它将把 RegExpObject 的 lastIndex 属性设置为匹配文本的最后一个字符的下一个位置。这就是说，您能够经过反复调用 exec() 方法来遍历字符串中的全部匹配文本。当 exec() 再也找不到匹配的文本时，它将返回 null，并把 lastIndex 属性重置为 0。

   var str = "Visit W3School",
       patt = new RegExp("(W3)School", "g"),
       result;
   while ((result = patt.exec(str)) != null) {
       document.write(result);     //W3School,W3
       document.write("<br />");
       document.write(patt.lastIndex); //14
   }

3. compile(),用于改变和从新编译正则表达式。

   var str="Every man in the world! Every woman on earth!";
   
   patt=/man/g;
   str2=str.replace(patt,"person");
   document.write(str2+"<br />");
   //Every person in the world! Every woperson on earth!
   
   patt=/(wo)?man/g;
   patt.compile(patt);
   str2=str.replace(patt,"person");
   document.write(str2);
   //Every person in the world! Every person on earth!

属性

实例的属性

1. source,返回正则表达式的源文本。

   var str = "Visit W3School.com.cn",
       patt1 = new RegExp("W3S","g");
   document.write(patt1.source);   //W3S

2. lastIndex,返回一个整数，标示开始下一次匹配的字符位置。

   上次匹配的结果是由方法 RegExp.exec() 和 RegExp.test() 找到的，它们都以 lastIndex 属性所指的位置做为下次检索的起始点。这样，就能够经过反复调用这两个方法来遍历一个字符串中的全部匹配文本。

   该属性是可读可写的。只要目标字符串的下一次搜索开始，就能够对它进行设置。当方法 exec() 或 test() 再也找不到能够匹配的文本时，它们会自动把 lastIndex 属性重置为 0。

   var str = "The rain in Spain stays mainly in the plain";
   var patt1 = new RegExp("ain", "g");
   
   patt1.test(str);
   document.write(patt1.lastIndex);    //分别输出：八、1七、2八、43

3. global,RegExp 对象是否具备标志 g。
4. ignoreCase,RegExp 对象是否具备标志 i。

5. multiline,RegExp 对象是否具备标志 m。

对象的属性

1. $1...$9,返回九个在模式匹配期间找到的、最近保存的部分。只读。

   当包含分组的正则表达式进行过test,match,search这些方法以后，每一个分组都被放在一个特殊的地方以备未来使用，这些存储是分组中的特殊值，咱们称之为反向引用。

   var re = /(A?(B?(C?)))/;
   /*上面的正则表达式将依次产生三个分组
   (A?(B?(C?))) 最外面的
   (B?(C?))
   (C?)*/
   str = "ABC";
   re.test(str);//反向引用被存储在RegExp对象的静态属性$1—$9中
   alert(RegExp.$1+"\n"+RegExp.$2+"\n"+RegExp.$3);
   //反向引用也能够在正则表达式中使用\1 ,\2...这类的形式使用
   re = /\d+(\D)\d+\1\d+/;
   str = "2008-1-1";
   alert(re.test(str));//true
   str = "2008-4_3";
   alert(re.test(str));//false

2. input、RegExp["$_"],返回执行规范表述查找的字符串。只读。
3. lastMatch、RegExp["$_"],返回任何正则表达式搜索过程当中的最后匹配的字符。只读。
4. lastParen、RegExp["$+"],若是有的话，返回任何正则表达式查找过程当中最后括的子匹配。只读。
5. leftContext、RegExp["$`"],返回被查找的字符串中从字符串开始位置到最后匹配以前的位置之间的字符。只读。
6. rightContext、RegExp["$'"],返回被搜索的字符串中从最后一个匹配位置开始到字符串结尾之间的字符。只读。

7. RegExp["$&"],匹配regexp的字串

示例：

var text='this has been a short summer';
var pattern=/(.)hort/g;

if(pattern.test(text)){
    //test()为true，返回执行规范表述查找的字符串，不然为空
    console.log(RegExp['$_']);  //this has been a short summer
    //返回正则表达式匹配项前面的字符串
    console.log(RegExp['$`']);  //this has been a 
    //返回正则表达式匹配项后面的字符串
    console.log(RegExp["$'"]);  // summer
    //返回正则表达式匹配项的字符串
    console.log(RegExp['$&']);  //short
     //？
    console.log(RegExp['$*']);  //false
};

String对象的正则方法

---

1. search,检索与正则表达式相匹配的值，返回第一个与正则相匹配的子串的起始位置

   var str="Visit W3School!";
   document.write(str.search(/W3School/)); //6

2. match,找到一个或多个正则表达式的匹配,返回匹配结果的数组。该数组的内容依赖于 regexp 是否具备全局标志 g。

   var str="1 plus 2 equal 3";
   document.write(str.match(/\d+/g));  //1,2,3

3. replace,用于在字符串中用一些字符替换另外一些字符，或替换一个与正则表达式匹配的子串。返回替换结果。

   text = "javascript Tutorial";
   text.replace(/javascript/i, "JavaScript");      //JavaScript Tutorial
   
   name = "Doe, John";
   name.replace(/(\w+)\s*, \s*(\w+)/, "$2 $1");    //John Doe

4. split,把字符串分割为字符串数组。

   var str="How are you doing today?"
   document.write(str.split(" ") + "<br />");  //How,are,you,doing,today?
   document.write(str.split(/\s+/) + "<br />");//同上
   document.write(str.split("") + "<br />");   //H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?
   document.write(str.split(" ",3));           //How,are,you
   
   var name = 'aaa bbb ccc';
   var uw=name.replace(/\b\w+\b/g, function(word){
       return word.substring(0,1).toUpperCase()+word.substring(1);}
   );
   document.write (uw);        //Aaa Bbb Ccc

参考

---

1. 精通 JS正则表达式 (精通?标题党)
2. W3School
3. 《 javascript语言精粹 》