js正则表达式

1. 元字符  
2. 元字符是表达式语法的一部分，在正则表达式中用到的所有元字符有：{ [ ( \ ^ $ | ) ] } ? * + -  
3. 如匹配一个问号：var reQMark = /\?/; 或 var reQMark = new RegExp("\\?"); //注意这里是两个反斜杠，双重转义  
4.   
5. \xxx 查找以八进制数 xxx 规定的字符，如：/\142/为字符b  
6. \xdd 查找以十六进制数 dd 规定的字符，如：/\x62/为字符b  
7. \uxxxx 查找以十六进制数 xxxx 规定的 Unicode 字符，如：/\u0062/为字符b  
8. \r 查找回车符  
9. \n 查找换行符  
10. \f 查找换页符  
11. \t 查找制表符  
12. \v 查找垂直制表符  
13. \a 查找alert字符  
14. \e 查找escape字符  
15. \cX 查找与X相对应的控制字符  
16. \0 查找 NULL 字符  
17.   
18. . 查找单个字符，除了换行和行结束符，等同于[^\n\r]  
19. \w 查找单词字符，等同于[a-zA-Z_0-9]  
20. \W 查找非单词字符，等同于[^a-zA-Z_0-9]  
21. \d 查找数字，等同于[0-9]  
22. \D 查找非数字字符，等同于[^0-9]  
23. \s 查找空白字符，等同于[ \t\n\x0B\f\r]，\x0B为垂直tab和\t一样  
24. \S 查找非空白字符，等同于[^ \t\n\x0B\f\r]  

1. 方括号  
2. [abc] 查找方括号之间的任何字符  
3. [^abc] 查找任何不在方括号之间的字符  
4. [0-9] 查找任何从 0 至 9 的数字  
5. [a-z] 查找任何从小写 a 到小写 z 的字符  
6. [A-Z] 查找任何从大写 A 到大写 Z 的字符  
7. [A-z] 查找任何从大写 A 到小写 z 的字符  
8. [adgk] 查找给定集合内的任何字符  
9. [^adgk] 查找给定集合外的任何字符  

1. 量词  
2. ? 匹配任何包含零个或一个的字符串，如：ba?d匹配bd、bad  
3. + 匹配任何包含至少一个的字符串，如：ba+d匹配bad、baad  
4. * 匹配任何包含零个或多个的字符串，如：ba*d匹配bd、bad、baad  
5. {n} 匹配包含恰好出现n次的序列的字符串，如：ba{1}d匹配bad  
6. {n,m} 匹配包含至少n次但不超过m次 的序列的字符串，如：ba{0,1}d匹配bd、bad  
7. {n,} 匹配包含至少出现n次的序列的字符串，如：ba{0,}匹配bd、bad、baad、baaad  
8.   
9. 贪婪量词：先看整个的字符串是否匹配，如果发现没有匹配，去年该字符串中的最后一个字符并再次尝试，如：?、+、*、{n}、{n, m}、{n, }，默认就为贪婪量词  
10. 惰性量词：先看字符串中的第一个字母是否匹配，如果单独这一个字符还不够，就读入下一个字符，组成两个字符的字符串，与贪婪量词的工作方式恰好相反，如：??、+?、*?、{n}?、{n, m}?、{n, }?  
11. 支配量词：只尝试匹配整个字符串，如果整个字符串不能产生匹配，不做进一步尝试，如：?+、++、*+、{n}+、{n, m}+、{n, }+  
12.   
13. var sToMatch = "abbbaabbbaaabbb1234";  
14. var re1 = /.*bbb/g;  //匹配结果为"abbbaabbbaaabbb"  
15. var re2 = /.*?bbb/g; //只有惰性量词才能匹配成功，匹配结果为"abbb","aabbb","aaabbb"  
16. var re3 = /.*+bbb/g;  //匹配不了，直接报错  

1. 复杂模式之分组：通过一系列括号包围一系列字符、字符类以及量词来使用的  
2. /(dog){2}/  匹配"dogdog"  
3. /([bd]ad?)*/  匹配空, "ba", "da", "bad", "dad"  
4. /(mom( and dad)?)/  匹配"mom", "mom and dad"  
5. /^\s*(.*?)\s+$/  匹配首尾的空白字符，也可以用/^\s+|\s+$/g  

1. 复杂模式之反向引用：也叫捕获性分组，按照从左到右遇到的左括号字符的顺序进行创建和编号的，例如表达式(A?(B?(C?)))将产生编号从1-3的三个反向引用：(A?(B?(C?)))、(B?(C?))、(C?)  
2. 反向引用有几种不同的使用方法：  
3. 首先，使用正则表达式对象的test()、match()或search()方法后，反向引用的值可以从RegExp构造函数中获得，如：  
4. var sToMatch = "#123456789";  
5. var reNumbers = /#(\d+)/;  
6. reNumbers.test(sToMatch);   
7. alert(RegExp.$1);  //"123456789"，$1保存了第一个反向引用，依次可以用$2,$3...  
8. 然后，可以直接在定义分组的表达式中包含反向引用，通过使用特殊转义序列如\1、\2等实现  
9. var sToMatch = "dogdog";  
10. var reDogdog = /(dog)\1/;  //等同于/dogdog/  
11. alert(reDogdog.test(sToMatch));  //true  
12. 第三，反向引用可以用在String对象的replace()方法中，通过使用特殊字符序列如$1、$2等实现  
13. var sToChange = "1234 5678";  
14. var reMatch = /(\d{4}) (\d{4})/;  
15. alert(sToChange.replace(reMatch, "$2 $1"));  //"5678 1234"  

1. 复杂模式之候选：使用管道符(|)放在两个单独的模式之间  
2. var reBadWords = /badword | anotherbadword/gi;  
3. var sUserInput = "This is a String using badword1 and badword2.";  
4. var sFinalText = sUserInput.replace(reBadWords, function(sMatch){  
5.     return sMatch.replace(/./g, "*");  //用星号替换敏感词中的每一个字母  
6. });  

1. 复杂模式之非捕获性分组：相比捕获性分组，不会创建反向引用，在较长的正则表达式中，存储反向引用会降低匹配速度，通过使用非捕获性分组，仍然可以拥有与匹配字符串序列同样的能力，而无需存储结果的开销  
2. var sToMatch = "#123456789";  
3. var reNumbers = /#(?:\d+)/;  //只需要在左括号的后面加上一个问号和一个紧跟的冒号就可创建一个非捕获性分组  
4. reNumbers.test(sToMatch);   
5. alert(RegExp.$1);  //""，输出空字符串是因为该分组是非捕获性的  
6. alert(sToMatch.replace(reNumbers, "abcd$1"));  //输出结果是"abcd$1"而不是"abcd123456789"，不能使用任何反向引用  
7. 又如：  
8. String.prototype.stripHTML = function(){  
9.     var reTag = /<(?:.|\s)*?>/g;  //匹配所有的HTML标签，防止插入恶意HTML代码  
10.     return this.replace(reTag, "");  
11. }  

1. 复杂模式之前瞻：告诉正则表达式运算器向前看一些字符而不移动其位置，存在正向前瞻(检查接下来出现的是不是某个特定字符集)和负向前瞻(检查接下来的不应该出现的特定字符集)  
2. 正向前瞻(?=n) 匹配任何其后紧接指定字符串 n 的但不包括 n的字符串，注意这里的括号不是分组  
3. 负向前瞻(?!n) 匹配任何其后没有紧接指定字符串 n 的字符串，如：  
4.   
5. var sToMatch1 = "bedroom";  
6. var sToMatch2 = "bedding";  
7. var reBed1 = /(bed(?=room))/;  
8. var reBed2 = /(bed(?!room))/;  
9. alert(reBed1.test(sToMatch1));  //true  
10. alert(RegExt.$1);  //输出"bed"而不是"bedroom"  
11. alert(reBed1.test(sToMatch2));  //false  
12. alert(reBed2.test(sToMatch1));  //false  
13. alert(reBed2.test(sToMatch2));  //true  
14. alert(RegExt.$1);  //输出的也是"bed"  

1. 复杂模式之边界：用于正则表达式中表示模式的位置  
2. n$ 匹配任何结尾为 n 的字符串，如：/(\w+)\.$/匹配行尾单词"one.","two."等  
3. ^n 匹配任何开头为 n 的字符串，如：/^(.+?)\b/匹配起始位置后的一个或多个单词字符  
4. \b 查找位于单词的开头或结尾的匹配，如：/\b(\S+?)\b/g 或 /(\w+)/g匹配从字符串中抽取单词  
5. \B 查找不处在单词的开头或结尾的匹配  

1. 复杂模式之多行模式：  
2. var sToMatch = "First second\nthird fourth\nfifth sixth";  
3. var reLastWordOnLine = /(\w+)$/gm;  
4. alert(sToMatch.match(reLastWordOnLine));  //输出["second", "fourth", "sixth"]而不只是"sixth"  

1. RegExp对象的属性和方法：  
2. global  //RegExp 对象是否具有标志 g  
3. ignoreCase  //RegExp 对象是否具有标志 i  
4. multiline  //RegExp 对象是否具有标志 m  
5. source  //正则表达式的源文本  
6. lastIndex  //一个整数，标示下一次匹配钭会从哪个字符位置开始(只有当使用exec()和test()函数才会填入，否则为0)  
7. 真正使用到的是lastIndex，如：  
8.   
9. var sToMatch = "bbq is short for barbecue";  
10. var reB = /b/g;  
11. reB.exec(sToMatch);    
12. alert(reB.lastIndex);  //1，匹配位置是0，lastIndex为1  
13. reB.exec(sToMatch);    
14. alert(reB.lastIndex);  //2  
15. reB.exec(sToMatch);    
16. alert(reB.lastIndex);  //18  
17. reB.lastIndex = 0;  //重头开始匹配  
18. reB.exec(sToMatch);    
19. alert(reB.lastIndex);  //1而不是21  

1. 静态属性  
2. input，短名为$_，最后用于匹配的字符串(传递给exec()或test()的字符串)  
3. leftContext，短名为$^，在上次匹配的前面的子串  
4. rightContext，短名为$^，在上次匹配之后的子串  
5. lastMatch，短名为$&，最后匹配的字符  
6. lastParen，短名为$+，最后匹配的分组  
7. multiline，短名为$*，用于指定是否所有的表达式都使用多行模式的布尔值，不同于其它属性，不依赖最后一次执行的匹配，它可以设置所有的正则表达式的m选项，RegExp.multiline = "true";，注意IE和Opera不运行它  
8.     var sToMatch = "this has been a short, short summer";  
9.     var reShort = /(s)hort/g;  
10.     reShort.test(sToMatch);   
11.     alert(RegExg.input);  //"this has been a short, short summer";  
12.     alert(RegExg.leftContext);  //"this has been a ";  
13.     alert(RegExg.rightContext);  //", short summer";  
14.     alert(RegExg.lastMatch);  //"short"  
15.     alert(RegExg.lastParen);  //"s"  
16.   
17. compile()  //编译正则表达式  
18. alert(reCat.exec("a cat, a Cat, a cAt caT"));  //返回一个数组，数组中的第一个条目是第一个匹配，其他的是反向引用  
19. alert(reCat.test("cat"));  //true，检索字符串中指定的值，返回 true 或 false。   

1. 支持正则表达式的String对象的方法  
2. var sToMatch = "a bat, a Cat, a fAt, a faT cat";  
3. var reAt = /at/gi;  
4. alert(sToMatch.match(reAt));  //返回一个包含在字符串中的所有匹配的数组  
5. alert(sToMatch.search(reAt));  //输出第一次在字符串中出现的位置3，全局匹配g在search()时不起作用  
6. alert(sToMatch.replace(reAt, "Dog"));  //替换与正则表达式匹配的子串  
7. alert(sToMatch.replace(reAt, function(sMatch){  
8.     return "Dog";  
9. }));    
10. alert(sToMatch.split(/\,/));  //把字符串分割为字符串数组  

1. 常用模式  
2. 日期：/(?:0[1-9]|[12][0-9]|3[01])\/(?:0[1-9]|1[0-2])\/(?:19|20\d{2})/  
3. URL：/^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$/  
4. E-mail地址：/^(?:\w+\.?)*\w+@(?:\w+\.?)*\w+$/  
5. 国内电话号码：d{3}-d{8}|d{4}-d{7}  
6. 腾讯QQ号：[1-9][0-9]{4,}  
7. 邮政编码：[1-9]d{5}(?!d)  
8. 身份证：d{15}|d{18}  
9. ip地址：d+.d+.d+.d+  
10. 中文字符： [u4e00-u9fa5]  
11. 双字节字符(包括汉字在内)：[^x00-xff]  
12.     String.prototype.len=function(){return this.replace([^x00-xff]/g,"aa").length;}  
13. 全角字符：/[^uFF00-uFFFF]/g  
14. 匹配特定数字：  
15. ^[1-9]\d*$　 　 //匹配正整数  
16. ^-[1-9]\d*$ 　 //匹配负整数  
17. ^-?[1-9]\d*$　　 //匹配整数  
18. ^[1-9]\d*|0$　 //匹配非负整数（正整数 + 0）  
19. ^-[1-9]\d*|0$　　 //匹配非正整数（负整数 + 0）  
20. ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$　　 //匹配正浮点数  
21. ^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$　 //匹配负浮点数  
22. ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$　 //匹配浮点数  
23. ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$　　 //匹配非负浮点数（正浮点数 + 0）  
24. ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$　　//匹配非正浮点数（负浮点数 + 0）  

转至：http://blog.csdn.net/zzq58157383/article/details/8725348