超全的js正则表达式整理笔记

\xxx 查找以八进制数 xxx 规定的字符，如：/\142/为字符b

\xdd 查找以十六进制数 dd 规定的字符，如：/\x62/为字符b

\uxxxx 查找以十六进制数 xxxx 规定的 Unicode 字符，如：/\u0062/为字符b

\r 查找回车符

\n 查找换行符

\f 查找换页符

\t 查找制表符

\v 查找垂直制表符

\a 查找alert字符

\e 查找escape字符

\cX 查找与X相对应的控制字符

\0 查找 NULL 字符

 

. 查找单个字符，除了换行和行结束符，等同于[^\n\r]

\w 查找单词字符，等同于[a-zA-Z_0-9]

\W 查找非单词字符，等同于[^a-zA-Z_0-9]

\d 查找数字，等同于[0-9]

\D 查找非数字字符，等同于[^0-9]

\s 查找空白字符，等同于[ \t\n\x0B\f\r]，\x0B为垂直tab和\t一样

\S 查找非空白字符，等同于[^ \t\n\x0B\f\r]

[abc] 查找方括号之间的任何字符

[^abc] 查找任何不在方括号之间的字符

[0-9] 查找任何从 0 至 9 的数字

[a-z] 查找任何从小写 a 到小写 z 的字符

[A-Z] 查找任何从大写 A 到大写 Z 的字符

[A-z] 查找任何从大写 A 到小写 z 的字符

[adgk] 查找给定集合内的任何字符

[^adgk] 查找给定集合外的任何字符

var sToMatch = "abbbaabbbaaabbb1234";

var re1 = /.*bbb/g; //匹配结果为"abbbaabbbaaabbb"

var re2 = /.*?bbb/g; //只有惰性量词才能匹配成功，匹配结果为"abbb","aabbb","aaabbb"

var re3 = /.*+bbb/g; //匹配不了，直接报错

var sToMatch = "#123456789";

var reNumbers = /#(\d+)/;

reNumbers.test(sToMatch);

alert(RegExp.$1); //"123456789"，$1保存了第一个反向引用，依次可以用$2,$3...

var sToMatch = "dogdog";

var reDogdog = /(dog)\1/; //等同于/dogdog/

alert(reDogdog.test(sToMatch)); //true

var sToChange = "1234 5678";

var reMatch = /(\d{4}) (\d{4})/;

alert(sToChange.replace(reMatch, "$2 $1")); //"5678 1234"

var reBadWords = /badword | anotherbadword/gi;

var sUserInput = "This is a String using badword1 and badword2.";

var sFinalText = sUserInput.replace(reBadWords, function(sMatch){

 return sMatch.replace(/./g, "*"); //用星号替换敏感词中的每一个字母

});

var sToMatch = "#123456789";

var reNumbers = /#(?:\d+)/; //只需要在左括号的后面加上一个问号和一个紧跟的冒号就可创建一个非捕获性分组

reNumbers.test(sToMatch);

alert(RegExp.$1); //""，输出空字符串是因为该分组是非捕获性的

alert(sToMatch.replace(reNumbers, "abcd$1")); //输出结果是"abcd$1"而不是"abcd123456789"，不能使用任何反向引用

String.prototype.stripHTML = function(){

 var reTag = /<(?:.|\s)*?>/g; //匹配所有的HTML标签，防止插入恶意HTML代码

 return this.replace(reTag, "");

}

var sToMatch1 = "bedroom";

var sToMatch2 = "bedding";

var reBed1 = /(bed(?=room))/;

var reBed2 = /(bed(?!room))/;

alert(reBed1.test(sToMatch1)); //true

alert(RegExt.$1); //输出"bed"而不是"bedroom"

alert(reBed1.test(sToMatch2)); //false

alert(reBed2.test(sToMatch1)); //false

alert(reBed2.test(sToMatch2)); //true

alert(RegExt.$1); //输出的也是"bed"

var sToMatch = "First second\nthird fourth\nfifth sixth";

var reLastWordOnLine = /(\w+)$/gm;

alert(sToMatch.match(reLastWordOnLine)); //输出["second", "fourth", "sixth"]而不只是"sixth"

var sToMatch = "bbq is short for barbecue";

var reB = /b/g;

reB.exec(sToMatch);

alert(reB.lastIndex); //1，匹配位置是0，lastIndex为1

reB.exec(sToMatch);

alert(reB.lastIndex); //2

reB.exec(sToMatch);

alert(reB.lastIndex); //18

reB.lastIndex = 0; //重头开始匹配

reB.exec(sToMatch);

alert(reB.lastIndex); //1而不是21

var sToMatch = "this has been a short, short summer";

 var reShort = /(s)hort/g;

 reShort.test(sToMatch);

 alert(RegExg.input); //"this has been a short, short summer";

 alert(RegExg.leftContext); //"this has been a ";

 alert(RegExg.rightContext); //", short summer";

 alert(RegExg.lastMatch); //"short"

 alert(RegExg.lastParen); //"s"

 

compile() //编译正则表达式

alert(reCat.exec("a cat, a Cat, a cAt caT")); //返回一个数组，数组中的第一个条目是第一个匹配，其他的是反向引用

alert(reCat.test("cat")); //true，检索字符串中指定的值，返回 true 或 false。

var sToMatch = "a bat, a Cat, a fAt, a faT cat";

var reAt = /at/gi;

alert(sToMatch.match(reAt)); //返回一个包含在字符串中的所有匹配的数组

alert(sToMatch.search(reAt)); //输出第一次在字符串中出现的位置3，全局匹配g在search()时不起作用

alert(sToMatch.replace(reAt, "Dog")); //替换与正则表达式匹配的子串

alert(sToMatch.replace(reAt, function(sMatch){

 return "Dog";

}));

alert(sToMatch.split(/\,/)); //把字符串分割为字符串数组

^[1-9]\d*$　 　 //匹配正整数

^-[1-9]\d*$ 　 //匹配负整数

^-?[1-9]\d*$　　 //匹配整数

^[1-9]\d*|0$　 //匹配非负整数（正整数 + 0）

^-[1-9]\d*|0$　　 //匹配非正整数（负整数 + 0）

^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$　　 //匹配正浮点数

^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$　 //匹配负浮点数

^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$　 //匹配浮点数

^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$　　 //匹配非负浮点数（正浮点数 + 0）

^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$　　//匹配非正浮点数（负浮点数 + 0）