var reCat = new RegExp("cat", "gi"); //RegExp构造函数可以带一个或两个参数，第一个参数描述需要进行匹配的模式字符串，第二个参数指定了额外的处理命令 
var reCat = /cat/gi; //使用Perl风格的语法 
 
 i：执行对大小写不敏感的匹配 
 g：执行全局匹配(查找所有匹配而非在找到第一个匹配后停止) 
 m：执行多行匹配 

\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 = /.*"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 = /#(""，输出空字符串是因为该分组是非捕获性的 
alert(sToMatch.replace(reNumbers, "abcd$1")); //输出结果是"abcd$1"而不是"abcd123456789"，不能使用任何反向引用 

String.prototype.stripHTML = function(){ 
 var reTag = /<(""); 
} 

var sToMatch1 = "bedroom"; 
var sToMatch2 = "bedding"; 
var reBed1 = /(bed("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）