javascript正则表达式速查

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

作用

数据有效性验证
替换文本
提取文本

声明方式

字面量的声明方式

示例：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 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
	n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
	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对象

方法

test(),返回一个 Boolean 值，它指出在被查找的字符串中是否存在模式。如果存在则返回 true，否则就返回 false。
```
var str = "Visit W3School",
    patt1 = new RegExp("W3School"),
    result = patt1.test(str);
document.write(result);    //true
```
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
}
```

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!

属性

实例的属性

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

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

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);    //分别输出：8、17、28、43
```
global,RegExp 对象是否具有标志 g。
ignoreCase,RegExp 对象是否具有标志 i。
multiline,RegExp 对象是否具有标志 m。

对象的属性

$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

input、RegExp["$_"],返回执行规范表述查找的字符串。只读。
lastMatch、RegExp["$_"],返回任何正则表达式搜索过程中的最后匹配的字符。只读。
lastParen、RegExp["$+"],如果有的话，返回任何正则表达式查找过程中最后括的子匹配。只读。
leftContext、RegExp["$`"],返回被查找的字符串中从字符串开始位置到最后匹配之前的位置之间的字符。只读。
rightContext、RegExp["$'"],返回被搜索的字符串中从最后一个匹配位置开始到字符串结尾之间的字符。只读。
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对象的正则方法

search,检索与正则表达式相匹配的值，返回第一个与正则相匹配的子串的起始位置
```
var str="Visit W3School!";
document.write(str.search(/W3School/)); //6  
```
match,找到一个或多个正则表达式的匹配,返回匹配结果的数组。该数组的内容依赖于 regexp 是否具有全局标志 g。
```
var str="1 plus 2 equal 3";
document.write(str.match(/\d+/g));  //1,2,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

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

参考

posted @ 2014-10-11 14:12 前端小尚阅读(1730) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部