正则难点摘录

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

相关推荐