正则表达式学习与总结

之前或多或少接触过正则表达式，期间为了开发，封装了ICU关于正则表达式的一部分接口。每次都是需要的时候查查资料看看书，基本能写出几个满足需求的正则表达式，但每次重新捡起来，又需要花一部分时间；今天疼下一刀，深入研究下。

这篇文章主要是总结了其他人的一些资料，以及翻看了一些文档总结出来的。

正则表达式在线测试工具：http://tool.chinaz.com/regex/

经常在互联网开发方面吃摸打滚的人应该都有接触到正则表达式，简单的例子就是浏览器的输入框，浏览器如何判定输入的Url是合法的Url，这样能减少发送错误链接的几率。

如下这段代码是一段比较基础的判定Url合法的正则表达式的判定：

<span style="font-size:14px;">function IsValidUrl(str) {
    var regu = "^(https?://)"
             + "?(([0-9a-z_!~*'().&=+$%-]+: )?[0-9a-z_!~*'().&=+$%-]+@)?"
             + "(([0-9]{1,3}.){3}[0-9]{1,3}"
             + "|"
             + "([0-9a-z_!~*'()-]+.)*"
             + "([0-9a-z][0-9a-z-]{0,61})?[0-9a-z]."
             + "[a-z]{2,6})"
             + "(:[0-9]{1,4})?"
             + "((/?)|"
             + "(/[0-9a-z_!~*'().;?:@&=+$,%#-]+)+/?)$";
    var re = new RegExp(regu);
    if (!re.test(str)) {
        return false;
    }
    return true;
}</span>

是不是看的有点迷惑，比如：

"(:[0-9]{1,4})?"

我们先留这么一个悬念在此。开始正则表达式的旅程。

1. 元字符

也许我们经常能看到一些这样的字样，如b,.,*，还有d. 正则表达式里还有更多的元字符，比如s匹配任意的空白符，包括空格，制表符(Tab)，换行符，中文全角空格等。w匹配字母或数字或下划线或汉字等。

下面来看看更多的例子：

baw*b匹配以字母a开头的单词——先是某个单词开始处(b)，然后是字 母a,然后是任意数量的字母或数字(w*)， 最后是单词结束处(b)。

好吧，现在我们说说正则表达式里的单词是什么意思吧：就是不少于一个的连续的w。不错，这与学习英文时要背的成千上万个同名的东西的确关系不大 :)

d+匹配1个或更多连续的数字。 这里的+是和*类似的元字符，不同的是*匹配重复任意次(可能是0次)，而+则匹配重复1次或更多次。

bw{6}b 匹配刚好6个字符的 单词。

基本的元字符都在上面这个表里：

w：只匹配字母或数字或下划线或汉字，比如你希望你的输入是a开头，b结尾，中间都是字母或数字或下划线或汉字，那么就可以写成：

<span style="font-size:14px;">^aw+b$</span>

d：匹配数字，比如你匹配一个大于0的整数，那么用^d+,

b：匹配单词的开始或者结束，匹配一个单词边界，也就是指单词和空格间的位置。例如， 'erb' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。那么比如现在我要抽取this is a test中的test单词，就可以用stb；

^：^exp,表示以exp开头的字符串

$：exp$，表示以exo结尾的字符串。

比如抓取以th开头的以st结尾的一串文字，那么用^(th)w+(st)$,记住用()包起来，不然就只是以单个字符去匹配了。

我们也可以称^$bB为定位符：用来描述字符串或单词的边界，^和$分别指字符串的开始与结束，b描述单词的前或后边界，B表示非单词边界。不能对定位符使用限定符。

/terb/ 可匹配chapter，而不能terminal 
Bapt/ 可匹配chapter，而不能aptitude 

正则表达式引擎通常会提供一个“测试指定的字符串是否匹配一个正则表达式”的方法，如JavaScript里的 RegExp.test()方法或.NET里的Regex.IsMatch()方法。这里的匹配是指是字符串里有没有符合表达式规则的部分。如果不使用^和$的话，对于d{5,12}而言，使用这样的方法就只能保证字符串里包含5到 12连续位数字，而不是整个字符串就是5到12位数字。

元字符^（和数字6在同一个键位上的符号）和$都 匹配一个位置，这和b有点类似。^匹配你 要用来查找的字符串的开头，$匹配结尾。这两个代码在验证输入的内容时非常有用，比如一个网站如果 要求你填写的QQ号必须为5位到12位数字时，可以使用：^d{5,12}$。

这里的{5,12}和前面介绍过的{2}是 类似的，只不过{2}匹配只能不多不少重复2次，{5,12}则是重复的次数不能少于5次，不能多于12次， 否则都不匹配。

因为使用了^和$，所以输入 的整个字符串都要用来和d{5,12}来匹配，也就是说整个输入必须是5到12个数字，因此如果输入的QQ号能匹配这个正则表达式的话，那就符合要求了。

和忽略大小写的选项类似，有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项，^和$的意义就变成了匹配行的开始处和结束处。

2. 转义字符与非打印字符

通常用linux终端的人经常会碰到，应为一些字符在正则表达式里是有特殊含义的，如果这个字符作为正则表达式的要匹配的内容，那么就必须要转义了。

比如要查找一段文字里，包含/和(的字符串，那么就需要写成'/' '('；

除了正则表达式里面要用到的特殊意义的字符外，还需要了解一下非打印字符

3. 重复

初次看重复这部分的介绍时，还是感觉很怪异，以为这个重复的定义很奇怪。

比如你写一个w+或者w*，这之间有什么区别啊。

+表示重复至少一次，*表示重复至少0次。

那么你如果用如下一段代码：this is class name where;

用'classw+'就取不到任何信息，因为w+表示class后面必须跟上一个字符；

而用'classw*'就可以取到class,因为w*表示w可以出现0次，也就是class后面可以不带任何信息。

你已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是 正则表达式中所有的限定符(指定数量的代码，例如*,{5,12}等)：

比如现在写一个电话号码的匹配，必须是138开头的，那么就必须是'138[0-9]{8}; {8}表示后面必须是8位0-9的任一一个。

如果是QQ： 比如限制长度是5-11位，那么设置如下‘^[1-9][0-9]{4,10}；其中必须是1-9开头。

4. 选择与分支

|: 表示或者的意思，通常用于分支，比如：

电话号码可能是3位区号，8位号码或者4位区号7位号码，那么就得用分支区分成这样：^[0-9]{3}-[0-9]{7} | [0-9]{4}-[0-9]{8}；

手机号码："^1[3|4|5|8][0-9]d{8}$"；这里d代替了[0-9]，意思也是数字。

[xyz] 表示的是包含任何一个字母都行，而不是一个xyz的单词。

a-z] 表示a-z的一个范围；比如：

只能输入由数字和26个英文字母组成的字符串：("^[A-Za-z0-9]+$") ;

5. 特殊字符?

?在正则表达式里德组合比较多；因此专门抠出来总结一下：

(1) 在正则表达式中有特殊的含义，所以如果想匹配?本身，则需要转义，?
(2) 问号可以表示重复前面内容的0次或一次，也就要么不出现，要么出现一次。比如[0-9]? 表示要么没有要么出现一个数字；
(3) 用于非贪婪匹配：当通过正则表达式获取内容时，默认情况下是匹配尽可能长的字符串，采用贪婪匹配，接下来是别人写的一段关于贪婪和非贪婪的比较：

string pattern1 = @"a.*c";   // 作者注：greedy match 
Regex regex = new Regex(pattern1);
regex.Match("abcabc"); // 作者注：return "abcabc"

非贪婪匹配

string pattern1 = @"a.*?c";   // non-greedy match 
Regex regex = new Regex(pattern1);
regex.Match("abcabc"); // return "abc"

(4). 其他组合 模式修正符

以(?)开头的非捕获组除了零宽度断言之外，还有模式修正符。

正则表达式中常用的模式修正符有i、g、m、s、x、e等。它们之间可以组合搭配使用。

(?imnsx-imnsx: ) 应用或禁用子表达式中指定的选项。例如，(?i-s: ) 将打开不区分大小写并禁用单行模式。关闭不区分大小写的开关可以使用(?-i)。有关更多信息，请参阅正则表达式选项。

【例1】(?i)ab

表示对(?i)后的所有字符都开启不区分大小写的开关。故它可以匹配ab、aB、Ab、AB

【例2】(?i:a)b

它表示只对a开启不区分大小写的开关。故它可以匹配ab和Ab。不能匹配aB和AB。

(5). (?>Pattern)等同于侵占模式

匹配成功不进行回溯，这个比较复杂，与侵占量词“+”可以通用，比如：d++ 可以写为 (?>d+)。

【例】将一些多位的小数截短到三位小数：d+.dd[1-9]?d+

在这种条件下 6.625 能进行匹配，这样做没有必要，因为它本身就是三位小数。最后一个“5”本来是给 [1-9] 匹配的，但是后面还有一个 d+ 所以，[1-9] 由于是“?”可以不匹配所以只能放弃当前的匹配，将这个“5”送给 d+ 去匹配，如果改为：

d+.dd[1-9]?+d+

的侵占形式，在“5”匹配到 [1-9] 时，由于是侵占式的，所以不会进行回溯，后面的 d+ 就匹配不到任东西了，所以导致 6.625 匹配失败。

这种情况，在替换时就有效了，比如把数字截短到小数点后三位，如果正好是三位小数的，就可以不用替换了，可以提高效率，侵占量词基本上就是用来提高匹配效率的。

把 d+.dd[1-9]?+d+ 改为 d+.dd(?>[1-9]?)d+ 这样是一样的。

6. 反义

有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外，其它任意字符都行的情况，这时需要用到反义：

例子：

S+匹配不包含空白符的字符串。

<a[^>]+>匹配用 尖括号括起来的以a开头的字符串。[^>]表示a后面附带的所有非>的字符，+表示重复一次或者更多，>表示匹配结尾；

特别要注意[^aeiou] 中的aeiou不是单词，而是字符，表示这些字符外的任意字符；

7. 分组

在ICU的Regrex中提供了Group的概念。其实原理还是正则表达式里的分组；

我们已经提到了怎么重复单个字符（直接在字符后面加上限定符就行了）；但如果想要重复多个字符又该怎么办？你可以用小括号来指定子表达式(也叫做分组)，然后你就可以指定这个子表达 式的重复次数了，你也可以对子表达式进行其它一些操作(后面会有介绍)。

例子1 IP地址
(d{1,3}.){3}d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式，请按下列顺序分析它：d{1,3}匹 配1到3位的数字，(d{1,3}.){3}匹 配三位数字加上一个英文句号(这个整体也就是这个分组)重 复3次，最后再加上一个一到三位的数字(d{1,3})。

当然IP地址中每个数字都不能大于255，因此需要修改一下。如果能使用算术比较的话，或许能简单地解决这个问题，但是正则表达式中并不提供关于数学的任何功能，所以只能使用冗长的分组，选择，字符类来描述一个 正确的IP地址：

((2[0-4]d|25[0-5]|[01]?dd?).){3}(2[0-4]d|25[0-5]|[01]?dd?)。

2[0-4]d|25[0-5]|[01]?dd? 解析：

这个式子分为三个分支：

第一个2[0-4]d表示，如果是三位数，且十位数上是0-4,也就是只能是200到249的范围；

第二个25[0-5]，这个限定了范围是在250-255，因为分段最大值是255；

第三个是[01]?dd?，[01]?表示百位上只能出现0和1，或者没有，而后面那个d?也表示只能出现1次或者没有，那么整个[01]?dd?，连起来就是数字最大值是，199， 而最小情况下，[01]不存在最后一个d不存在，只有中间的d表示个位从[0-9]。因此范围是0-199。

然后.表示小数点.的转义，也就是前面有三组，后面再跟上一组。

这就就形成了，xxx.xxx.xxx.xxx。

分组可以分为两种形式，捕获组和非捕获组。

7.1. 捕获组

捕获组可以通过从左到右计算其开括号来编号。例如，在表达式(A)(B(C))中，存在四个这样的组：

组零始终代表整个表达式

之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过Back 引用（反向引用，后文介绍）在表达式中使用，也可以在匹配操作完成后从匹配器检索。

Back 引用 是说在后面的表达式中我们可以使用组的编号来引用前面的表达式所捕获到的文本序列。注意：反向引用，引用的是前面捕获组中的文本而不是正则，也就是说反向引用处匹配的文本应和前面捕获组中的文本相同，这一点很重要。

【例】([" ']).*1

其中使用了分组，1就是对引号这个分组的引用，它匹配包含在两个引号或者两个单引号中的所有字符串，如，"abc" 或 " '" 或 '"' ，但是请注意，它并不会对" a'或者 'a"匹配。原因上面已经说明，Back引用只是引用文本而不是表达式。

7.2. 非捕获组

以(?)开头的组是纯的非捕获组，它不捕获文本，也不针对组合计进行计数。就是说，如果小括号中以?号开头，那么这个分组就不会捕获文本，当然也不会有组的编号，因此也不存在Back 引用。

我们通过捕获组就能够得到我们想要匹配的内容了，那为什么还要有非捕获组呢？原因是捕获组捕获的内容是被存储在内存中，可供以后使用，比如反向引用就是引用的内存中存储的捕获组中捕获的内容。而非捕获组则不会捕获文本，也不会将它匹配到的内容单独分组来放到内存中。所以，使用非捕获组较使用捕获组更节省内存。在实际情况中我们要酌情选用。

比如：

(1) 非捕获组(?:Pattern)

它的作用就是匹配Pattern字符，好处就是不捕获文本，不将匹配到的字符存储到内存中，从而节省内存。

【例】匹配indestry或者indestries

我们可以使用indestr(y|ies)或者indestr(?y|ies)

【例】(?:a|A)123(?:b)可以匹配a123b或者A123b

非捕获组有很多种形式，其中包括：零宽度断言和模式修正符

(2) 零宽度断言 在后面详述

之前的分组一节中我们提到了分组的概念，通过()能使得匹配的文本以分组的形式存在；

使用小括号指定一个子表达式后，匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它 程序中作进一步的处理。默认情况下，每个分组会自动拥有一个组号，规则是：从左向右，以分组的左括 号为标志，第一个出现的分组的组号为1，第二个为2，以此类推。

后向引用用于重复搜索前面某个分组匹配的文本。例如，1代表分组1匹配的文本。难以理解？请看示例：

b(w+)bs+1b可以用来匹配重复的单词，像go go,或者kitty kitty。这个表达式首先是一个单词， 也就是单词开始处和结束处之间的多于一个的字母或数字(b(w+)b)， 这个单词会被捕获到编号为1的分组中，然后是1个或几个空白符(s+)，最后是分组1中捕获的内容（也就是前面匹配的那个单词）(1)。

你也可以自己指定子表达式的组名。要指定一个子表达式的组名，请使用这样的语法：(?<Word>w+)(或者把尖括号换成'也 行：(?'Word'w+)),这样就把w+的 组名指定为Word了。要反向引用这个分组捕获的 内容，你可以使用k<Word>,所以上一个例子也可以写成这样：b(?<Word>w+)bs+k<Word>b。

使用小括号的时候，还有很多特定用途的语法。下面列出了最常用的一些：

我们已经讨论了前两种语法。第三个(?:exp)不会改变正则表达式的处理方式，只 是这样的组匹配的内容不会像前两种那样被捕获到某个组里面，也不会拥有组号。“我为什么会想要这样 做？”——好问题，你觉得为什么呢？

8.1. 零宽断言

地球人，是不是觉得这些术语名称太复杂，太难记了？我也有同感。知道有这么一种东西就行了，它叫什么，随它去 吧！人若无名，便可专心练剑；物若无名，便可随意取舍……

接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像b,^,$那样用于指定一个位置，这个位置应该满足一定的 条件(即断言)，因此它们也被称为零宽断言。最好还是拿例子来说明吧：

断言用来声明一个应该为真的事实。正则表达式中只有当断言为真时才会继续进行匹配。

(?=exp)也叫零宽度正预测先行断言， 它断言自身出现的位置的后面能匹配表达式exp。比如bw+(?=ingb)， 匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I'm singing while you're dancing.时，它会匹配sing和danc。

(?<=exp)也叫零宽度正回顾后 发断言，它断言自身出现的位置的前面能匹配表达式exp。比如(?<=bre)w+b会匹配以re开头的单词的后半部 分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。

上面都是理论性的介绍，这里就使用一些例子来说明一下问题：

假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：((?<=d)d{3})+b，用它对1234567890进 行查找时结果是234567890。

下面这个例子同时使用了这两种断言：(?<=s)d+(?=s)匹配以空白符间隔的数字(再次强调，不包括这些空白符)。

【例1】正则表达式 (?<!4)56(?=9)

含义：匹配后面的文本56前面不能是4，后面必须是9组成。因此，可以匹配如下文本 5569 ，与4569不匹配。

通过grep -oP '(?<!4)56(?=9)' 2569 获取到的是56；

那么之前做过一个类似的获取两个单词之间的文本，就可以用grep -oP '(?<=begin).*(?=end)';begin和end就是你要判定的单词

【例2】提取字符串da12bka3434bdca4343bdca234bm中包含在字符a和b之间的数字，但是这个a之前的字符不能是c；b后面的字符必须是d才能提取。

显然，这里就只有3434这个数字满足要求。那么我们怎么提取呢？

首先，我们写出含有捕获组的正则表达式：[^c]ad*bd

然后我们再将其变为非捕获组的正则表达式：(?<=[^c]a)d*(?=bd)

8.2. 负向零宽断言

前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确 保某个字符没有出现，但并不想去匹配它时怎么办？例如，如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样：

bw*q[^u]w*b匹配包含后 面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐，直接就观察出来了)，你会发现，如果q出现在单词 的结尾的话，像Iraq,Benq，这个表达式就会出错。这是因为[^u]总要匹配一个字符，所以如果q是单词的最后一个字符的话，后面的[^u]将 会匹配q后面的单词分隔符(可能是空格，或者是句号或其它的什么)，后面的w*b将会匹配下一 个单词，于是bw*q[^u]w*b就能匹配整个Iraq fighting。负向零宽断言能解决这 样的问题，因为它只匹配一个位置，并不消费任何字符。现在，我们可以这样来解决这个问题：bw*q(?!u)w*b。

也就是Iraq,Benq在bw*q[^u]w*b不能匹配成功，但是在bw*q(?!u)w*b能匹配成功。

零宽度负预测先行断言(?!exp)，断言此位置的后面不能匹配表达式exp。例如：d{3}(?!d)匹 配三位数字，而且这三位数字的后面不能是数字；b((?!abc)w)+b匹 配不包含连续字符串abc的单词。

同理，我们可以用(?<!exp),零 宽度负回顾后发断言来断言此位置的前面不能匹配表达式exp：(?<![a-z])d{7}匹配前面不是小写字母的七位数 字。

请详细分析表达式(?<=<(w+)>).*(?=</1>)， 这个表达式最能表现零宽断言的真正用途。

一个更复杂的例子：(?<=<(w+)>).*(?=</1>)匹 配不包含属性的简单HTML标签内里的内容。(<?(w+)>)指 定了这样的前缀：被尖括号括起来的单词(比 如可能是<b>)，然后是.*(任意的字符串),最后是一个后缀(?=</1>)。注意后缀里的/，它用到了前面提过的字符转义；1则是一个反向 引用，引用的正是捕获的第一组，前面的(w+)匹 配的内容，这样如果前缀实际上是<b>的话，后缀就是</b>了。整个表达式匹配的是<b>和</b> 之间的内容(再次提醒，不包括前缀和后缀本身)。这个很吊吧

9. 注释

小括号的另一种用途是通过语法(?#comment)来包含注释。例如：2[0-4]d(?#200-249)|25[0-5](?#250-255)|[01]?dd?(?#0-199)。

要包含注释的话，最好是启用“忽略模式里的空白符”选项，这样在编写表达式时能任意的添加空格，Tab，换行，而实际使用时这些都将被忽 略。启用这个选项后，在#后面到这一行结束的所有文本都将被当成注释忽略掉。例如，我们可以前面的一个表达式写成这样：

      (?<=    # 断言要匹配的文本的前缀
      <(w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)
      )       # 前缀结束
      .*      # 匹配任意文本
      (?=     # 断言要匹配的文本的后缀
      </1>  # 查找尖括号括起来的内容：前面是一个"/"，后面是先前捕获的标签
      )       # 后缀结束

10. 贪婪与懒惰

当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的 字符。以这个表达式为例：a.*b，它将会匹配最长的以 a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。

有时，我们更需要懒惰匹配，也就是匹配尽可能少的 字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提 下使用最少的重复。现在看看懒惰版的例子吧：

a.*?b匹配最短的，以a开始，以b结 束的字符串。如果把它应用于aabab的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。

为什么第一个匹配是aab（第一到第三个字符）而不是ab（第二到第三个字符）？简单地说，因为正则表达式有另 一条规则，比懒惰／贪婪规则的优先级更高：最先开始的匹配拥有最高的优先权——The match that begins earliest wins。

11. 平衡组与递归匹配

这里介绍的平衡组语法是由.Net Framework支持的；其它语言／库不一定支持这种功能，或者支持此功能但需要使用不同的语法。

有时我们需要匹配像( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构， 这时简单地使用(.+)则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论 的是贪婪模式，懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等，比如( 5 / ( 3 + 2 ) ) )，那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的，配对的括号之间的 内容呢？

为了避免(和(把你的大脑 彻底搞糊涂，我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把xx <aa <bbb> <bbb> aa> yy这样的字符串里，最长的配对的尖括号内的内容捕获出来？

这里需要用到以下的语法构造：

• (?'group') 把捕获的内容命名为group,并压入堆栈(Stack)
• (?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
• (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
• (?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败

如果你不是一个程序员（或者你自称程序员但是不知道堆栈是什么东西），你就这样理解上面的三种语法吧：第一个就 是在黑板上写一个"group"，第二个就是从黑板上擦掉一个"group"，第三个就是看黑板上写的还有没有"group"，如果有就继续匹配yes部 分，否则就匹配no部分。

我们需要做的是每碰到了左括号，就在压入一个"Open",每碰到一个右括号，就弹出一个，到了最后就看看堆栈是否为空－－如果不为空那就 证明左括号比右括号多，那匹配就应该失败。正则表达式引擎会进行回溯(放弃最前面或最后面的一些字符)，尽量使整个表达式得到匹配。

<                         #最外层的左括号
    [^<>]*                #最外层的左括号后面的不是括号的内容
    (
        (
            (?'Open'<)    #碰到了左括号，在黑板上写一个"Open"
            [^<>]*       #匹配左括号后面的不是括号的内容
        )+
        (
            (?'-Open'>)   #碰到了右括号，擦掉一个"Open"
            [^<>]*        #匹配右括号后面不是括号的内容
        )+
    )*
    (?(Open)(?!))         #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败

>                         #最外层的右括号

平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配嵌套的<div>标签：<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div>.

1.关于分组的匹配问题还是没怎么清楚；

2. 要多补充一些例子；

3. 后面2章没有深入；

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!