js 正则
\b：/\bW3/ 表示"W3"在单词前面，/W3\b/表示"W3"在单词后面。英文解释：A word boundary。
\B：/\BW3/ 表示"W3"不在单词前面，即在中间和在后面都符合，/W3\b/表示"W3"不在单词后面，即在前面和在中间都符合。
\0：NUL值。
\f：换页符。
\v：查找垂直制表符。
\xxx：查找以八进制数 xxx 规定的字符。例：/\127/g表示查找ascII码值为127八进制数，对应的十进制值为87，即是'W'
\xdd：查找以十六进制数 dd 规定的字符。例：/\x57/g表示查找ascII码值为57十六进制数，对应的十进制值为87，即是'W'
\uxxxx：查找以十六进制数 xxxx 规定的 Unicode 字符。例：/\u0057/g表示查找ascII码值为0057十六进制数，对应的十进制值为87，即是'W'
n?：匹配任何包含零个或一个 n 的字符串。
n$：匹配任何结尾为 n 的字符串。例：/is$/g在"Is this his"中，会找到最后那个"is"。
^n：匹配任何开头为 n 的字符串。例：/^Is/g在"Is this his"中，会找到最前那个"is"。
?=n：匹配任何其后紧接指定字符串 n 的字符串。例：/is(?= all)/在"Is this all there is"中，会找到all前面的"is"。
?!n：匹配任何其后没有紧接指定字符串 n 的字符串。例：/is(?! all)/gi在"Is this all there is"中，会找到除了all前面的"is"之外的"is"，这里不区分大小写，所以会找到两个符合条件的字符串，"Is"和"is"。
属性：
globalRegExp 对象是否具有标志 g。
ignoreCaseRegExp 对象是否具有标志 i。
lastIndex一个整数，标示开始下一次匹配的字符位置。
multilineRegExp 对象是否具有标志 m。
source正则表达式的源文本。
$n：第n个符合条件的字符串。
相关方法：
str.match(patt1)
==========================================================================================
str = "For more information, see Chapter 3.4.5.1";
re = /(chapter \d+(\.\d)*)/i;
found = str.match(re);
document.write(found);
==========================================================================================
执行结果：
==========================================================================================
Chapter 3.4.5.1,Chapter 3.4.5.1,.1
==========================================================================================
由结果可以看出，str.match(patt1)返回一个数组，
数组[0]应该是完整匹配结果，
数组[1]是(Chapter \d+(\.\d)*)的匹配结果"Chapter 3.4.5.1"。
数组[2]是(\.\d)的匹配结果".1"
match方法返回数组的额外属性：index、input
index:查找到的字符串第一个字符的下标。
input：匹配的字符串。
RegExp对象的test方法：
==========================================================================================
var str = "The rain in Spain stays mainly in the plain";
var patt1 = /ain/g;
while (patt1.test(str)==true) {
document.write("'ain' found. Index now at: "+patt1.lastIndex);
document.write("<br>");
}
==========================================================================================
执行结果:
==========================================================================================
'ain' found. Index now at: 8
'ain' found. Index now at: 17
'ain' found. Index now at: 28
'ain' found. Index now at: 43
==========================================================================================
从以上的代码和执行结果可知：
test方法找到第1个符合条件的字符串后，第2次执行此方法时，便从第1个符合条件的字符串后的下标位置开始查找。
RegExp对象的exec方法：
==========================================================================================
var r = /(\d+)-(\w+)/g;//RegExp.$1为第一个子匹配（表达式中括号的部分）,最多是$99
var b=r.exec("2013-love-b 11-aa22 d");
document.write("RegExp对象的lastIndex属性：" + (r.lastIndex) + "<br/>");
document.write(("返回：" + b + " $0:"+RegExp.$0 + " $1:" + RegExp.$1 + " $2:"+RegExp.$2 + " $3:"+RegExp.$3) + "<br/>");
var b=r.exec("2013-love-b 11-aa22 d");
document.write("RegExp对象的lastIndex属性：" + (r.lastIndex) + "<br/>");
document.write(("返回：" + b + " $0:"+RegExp.$0 + " $1:" + RegExp.$1 + " $2:"+RegExp.$2 + " $3:"+RegExp.$3) + "<br/>");
//r = /(\d+)-(\w+)/g;//如果重新赋值，下面的test结果就返回true。
b = r.test("1997-good");//返回是否存在满足匹配
document.write("RegExp对象的lastIndex属性：" + (r.lastIndex) + "<br/>");
document.write(("返回：" + b + " $0:"+RegExp.$0 + " $1:" + RegExp.$1 + " $2:"+RegExp.$2 + " $3:"+RegExp.$3) + "<br/>");
==========================================================================================
执行结果：
==========================================================================================
RegExp对象的lastIndex属性：9
返回：2013-love,2013,love $0:undefined $1:2013 $2:love $3:
RegExp对象的lastIndex属性：19
返回：11-aa22,11,aa22 $0:undefined $1:11 $2:aa22 $3:
RegExp对象的lastIndex属性：0
返回：false $0:undefined $1:11 $2:aa22 $3:
==========================================================================================
从结果看出，exec方法和test方法一样，都从字符串的lastIndex位置开始查找，当第二次exec执行后，lastIndex处于19位置，
因此，之后的test方法就返回false。并且lastIndex变回0。
如果用这句r = /(\d+)-(\w+)/g给RegExp对象重新赋值，
就会初始化r的所有属性，lastIndex也会重置，所以，这样之后运行test就返回true。
exec方法返回的是一个数组，
数组[0]应该是完整匹配结果"2013-love"，
数组[1]是(\d+)的匹配结果"2013"。
数组[2]是(\w+)的匹配结果"love"
如果没有匹配字符串，就返回null。
exec方法返回数组的额外属性：index、input
index:查找到的字符串第一个字符的下标。
input：匹配的字符串。
$n是指，正则表达式分组后，与字符串匹配的结果，从执行结果看出，没有$0。
这里的/(\d+)-(\w+)/g表达式分为(\d+)和(\w+)，所以在第一次exec运行后，$1="2013"，$2="love"。
没有第3分组，所以$3=""。
正则表达式分组规则以左括号为准，每个左括号和对应的右括号内的内容为一个分组
比如：
/(((A)B)C) (D)/
就分4组，分别是：
(((A)B)C)
((A)B)
(A)
(D)
反向引用,先看看下面的例子：
==========================================================================================
var str = "1234 5678";
var patt = /(\d{4}) (\d{4})/;
var newStr = str.replace(patt,"$2 $1");
console.log(newStr);
==========================================================================================
得到结果：
==========================================================================================
5678 1234
==========================================================================================
要看懂这个例子，首先要明白，
str.replace(patt,"$2 $1");中的"$1"和"$2"就是str被patt匹配出来的结果字符串"1234"和"5678"。
可以这样理解，运行replace的过程中，还未到平时理解的那样匹配步骤时，已将分组正则匹配出来的结果字符串"1234"和"5678"保存到patt的$1和$2。
到了平时理解的那样匹配步骤时，通过str.replace(patt,"$2 $1")中的patt正常匹配到"1234 5678"，然后替换成"$2 $1"，也就是"5678 1234"。
==========================================================================================
var str='ok ok';
var reg=/(\w+) \1/;
console.log(reg.test(str)); //true
console.log(RegExp.$1);
==========================================================================================
结果：
==========================================================================================
true
ok
==========================================================================================
这里的\1就是指$1，这段代码中得到的"ok"。
后向引用
后向引用用于重复搜索前面某个分组匹配的文本。例如，\1代表分组1匹配的文本。难以理解？请看示例：
\b(\w+)\b\s+\1\b可以用来匹配重复的单词，像go go, 或者kitty kitty。这个表达式首先是一个单词，也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b)，这个单词会被捕获到编号为1的分组中，然后是1个或几个空白符(\s+)，最后是分组1中捕获的内容（也就是前面匹配的那个单词）(\1)。
你也可以自己指定子表达式的组名。要指定一个子表达式的组名，请使用这样的语法：(?<Word>\w+)(或者把尖括号换成'也行：(?'Word'\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容，你可以使用\k<Word>,所以上一个例子也可以写成这样：\b(?<Word>\w+)\b\s+\k<Word>\b。
第三个(?:exp)不会改变正则表达式的处理方式，只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面，也不会拥有组号。
贪婪与懒惰
当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。以这个表达式为例：a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。
有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧：
a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。
懒惰限定符
代码/语法说明
*?重复任意次，但尽可能少重复
+?重复1次或更多次，但尽可能少重复
??重复0次或1次，但尽可能少重复
{n,m}?重复n到m次，但尽可能少重复
{n,}?重复n次以上，但尽可能少重复
为什么第一个匹配是aab（第一到第三个字符）而不是ab（第二到第三个字符）？简单地说，因为正则表达式有另一条规则，比懒惰／贪婪规则的优先级更高：最先开始的匹配拥有最高的优先权——The match that begins earliest wins。
零宽断言
(?=exp)也叫零宽度正预测先行断言，它断言自身出现的位置的后面能匹配表达式exp。比如\b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I'm singing while you're dancing.时，它会匹配sing和danc。
(?<=exp)也叫零宽度正回顾后发断言，它断言自身出现的位置的前面能匹配表达式exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。
零宽度负预测先行断言
(?!exp)，断言此位置的后面不能匹配表达式exp。例如：\d{3}(?!\d)匹配三位数字，而且这三位数字的后面不能是数字；\b((?!abc)\w)+\b匹配不包含连续字符串abc的单词。
同理，我们可以用(?<!exp),零宽度负回顾后发断言来断言此位置的前面不能匹配表达式exp：(?<![a-z])\d{7}匹配前面不是小写字母的七位数字。
注释
小括号的另一种用途是通过语法(?#comment)来包含注释。例如：2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)。
要包含注释的话，最好是启用“忽略模式里的空白符”选项，这样在编写表达式时能任意的添加空格，Tab，换行，而实际使用时这些都将被忽略。启用这个选项后，在#后面到这一行结束的所有文本都将被当成注释忽略掉。例如，我们可以前面的一个表达式写成这样：
(?<= # 断言要匹配的文本的前缀
<(\w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)
) # 前缀结束
.* # 匹配任意文本
(?= # 断言要匹配的文本的后缀
<\/\1> # 查找尖括号括起来的内容：前面是一个"/"，后面是先前捕获的标签
) # 后缀结束
常用的处理选项
名称说明
IgnoreCase(忽略大小写)匹配时不区分大小写。
Multiline(多行模式)更改^和$的含义，使它们分别在任意一行的行首和行尾匹配，而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$的精确含意是:匹配\n之前的位置以及字符串结束前的位置.)
Singleline(单行模式)更改.的含义，使它与每一个字符匹配（包括换行符\n）。
IgnorePatternWhitespace(忽略空白)忽略表达式中的非转义空白并启用由#标记的注释。
ExplicitCapture(显式捕获)仅捕获已被显式命名的组
平衡组/递归匹配
有时我们需要匹配像( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构，这时简单地使用\(.+\)则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式，懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等，比如( 5 / ( 3 + 2 ) ) )，那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的，配对的括号之间的内容呢？
为了避免(和\(把你的大脑彻底搞糊涂，我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把xx <aa <bbb> <bbb> aa> yy这样的字符串里，最长的配对的尖括号内的内容捕获出来？
这里需要用到以下的语法构造：
(?'group') 把捕获的内容命名为group,并压入堆栈(Stack)
(?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
(?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
(?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败。
我们需要做的是每碰到了左括号，就在压入一个"Open",每碰到一个右括号，就弹出一个，到了最后就看看堆栈是否为空－－如果不为空那就证明左括号比右括号多，那匹配就应该失败。正则表达式引擎会进行回溯(放弃最前面或最后面的一些字符)，尽量使整个表达式得到匹配。
< #最外层的左括号
[^<>]* #最外层的左括号后面的不是括号的内容
(
(
(?'Open'<) #碰到了左括号，在黑板上写一个"Open"
[^<>]* #匹配左括号后面的不是括号的内容
)+
(
(?'-Open'>) #碰到了右括号，擦掉一个"Open"
[^<>]* #匹配右括号后面不是括号的内容
)+
)*
(?(Open)(?!)) #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败
> #最外层的右括号
平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配嵌套的<div>标签：<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div>。