正则难点摘录

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>。