【分享】正则平衡组应用场景分析及性能优化

-过客- 2009-08-03 07:51:21

加精

为了获得更好的阅读效果，可以到我的博客查看
.NET正则基础之——平衡组

声明一：本帖不是散分帖，只对找出错误，提供改进建议，进行技术讨论，阅读后给出个人见解的回复给分，其余回复不给分，请尽量看过帖子后再回复。

声明二：本帖给出的只是一些方法和思路，不是模板，我也一直不推荐把正则套模板来用。对于部分实现，认为不适合用正则来解决的朋友，请给出更优的实现，不要只是泛泛的说“这个不适合用正则来实现”。

声明三：本帖可能比较长，主要是因为偏重应用场景分析的缘故，如果对正则和平衡组感兴趣，可以先收起来慢慢看^_^

1 概述

平衡组是微软在.NET中提出的一个概念，主要是结合几种正则语法规则，提供对配对出现的嵌套结构的匹配。.NET是目前对正则支持最完备、功能最强大的语言平台之一，而平衡组正是其强大功能的外在表现，也是比较实用的文本处理功能，目前只有.NET支持，相信后续其它语言会提供支持。
平衡组可以有狭义和广义两种定义，狭义平衡组指.NET中定义的(?<Close-Open>Expression)语法，广义平衡组并不是固定的语法规则，而是几种语法规则的综合运用，我们平时所说的平衡组通常指的是广义平衡组。本文中如无特殊说明，平衡组这种简写指的是广义平衡组。
正是由于平衡组功能的强大，所以带来了一些神秘色彩，其实平衡组并不难掌握。下面就平衡组的匹配原理、应用场景以及性能调优展开讨论。

2 平衡组匹配原理
2.1 预备知识

平衡组通常是由量词，分支结构，命名捕获组，狭义平衡组，条件判断结构组成的，量词和分支结构这里不做介绍，这里只对命名捕获组，狭义平衡组和条件判断结构做下说明。

2.1.1 命名捕获组

语法：(?<name>Expression)
(?’name’Expression)
以上两种写法在..NET中是等价的，都是将“Expression”子表达式匹配到的内容，保存到以“name”命名的组里，以供后续引用。
对于命名捕获组的应用，这里不做重点介绍，只是需要澄清一点，平时使用捕获组时，一般反向引用或Group对象使用得比较多，可能会有一种误解，那就是捕获组只保留一个匹配结果，即使一个捕获组可以先后匹配多个子串，也只保留最后一个匹配到的子串。但事实是这样吗？
举例来说：
源字符串：abcdefghijkl
正则表达式：(?<chars>[a-z]{2})+
命名捕获组chars最终捕获的是什么？

string test = "abcdefghijkl";

Regex reg = new Regex(@"(?<chars>[a-z]{2})+");

Match m = reg.Match(test);

if (m.Success)

{

      richTextBox2.Text += "匹配结果：" + m.Value + "\n";

      richTextBox2.Text += "Group：" + m.Groups["chars"].Value + "\n";

}

//输出

匹配结果：abcdefghijkl

Group：kl

从m.Groups["chars"].Value的输出上看，似乎确实是只保留了一个匹配内容，但却忽略了一个事实，Group实际上是Capture的一个集合

string test = "abcdefghijkl";

Regex reg = new Regex(@"(?<chars>[a-z]{2})+");

Match m = reg.Match(test);

if (m.Success)

{

     richTextBox2.Text += "匹配结果：" + m.Value + "\n";

     richTextBox2.Text += "Group：" + m.Groups["chars"].Value + "\n--------------\n";

     foreach (Capture c in m.Groups["chars"].Captures)

     {

           richTextBox2.Text += "Capture：" + c + "\n";

     }

}

//输出

匹配结果：abcdefghijkl

Group：kl

--------------

Capture：ab

Capture：cd

Capture：ef

Capture：gh

Capture：ij

Capture：kl

平时应用时可能会忽略这一点，因为很少遇到一个捕获组先后匹配多个子串的情况，而在一个捕获组只匹配一个子串时，Group集合中就只有一个Capture元素，所以内容是一样的。

string test = "abcdefghijkl";

Regex reg = new Regex(@"(?<chars>[a-z]{2})");

Match m = reg.Match(test);

if (m.Success)

{

     richTextBox2.Text += "匹配结果：" + m.Value + "\n";

     richTextBox2.Text += "Group：" + m.Groups["chars"].Value + "\n--------------\n";

     foreach (Capture c in m.Groups["chars"].Captures)

     {

          richTextBox2.Text += "Capture：" + c + "\n";

     }

}

//输出

匹配结果：ab

Group：ab

--------------

Capture：ab

捕获组保存的是一个集合，而不只是一个元素，这一知识点对于理解平衡组的匹配原理是有帮助的。

2.1.2 狭义平衡组

语法：(?<Close-Open>Expression)
其中“Close”是命名捕获组的组名，也就是“(?<name>Expression)”中的“name”，可以省略，通常应用时并不关注，所以一般都是省略的，写作“(?<-Open>Expression)”。作用就是当此处的“Expression”子表达式匹配成功时，则将最近匹配成功到的命名为“Open”组出栈，如果此前不存在匹配成功的“Open”组，那么就报告“(?<-Open>Expression)”匹配失败，整个表达式在这一位置也是匹配失败的。

2.1.3 条件判断结构

语法：(?(Expression)yes|no)
(?(name)yes|no)
对于“(?(Expression)yes|no)”，它是“(?(?=Expression)yes|no)”的简写形式，相当于三元运算符
(?=Expression) ? yes : no
表示如果子表达式“(?=Expression)”匹配成功，则匹配“yes”子表达式，否则匹配“no”子表达式。如果“Expression”与可能出现的命名捕获组的组名相同，为避免混淆，可以采用“(?(?=Expression)yes|no)”方式显示声明“Expression”为子表达式，而不是捕获组名。
“(?=Expression)”验证当前位置右侧是否能够匹配“Expression”，属于顺序环视结构，是零宽度的，所以它只参与判断，即使匹配成功，也不会占有字符。
举例来说：
源字符串：abc
正则表达式：(?(?=a)\w{2}|\w)
当前位置右侧如果是字符“a” ，则匹配两个“\w”，否则匹配一个“\w”。

string test = "abc";

Regex reg = new Regex(@"(?(?=a)\w{2}|\w)");

MatchCollection mc = reg.Matches(test);

foreach(Match m in mc)

{

     richTextBox2.Text += m.Value + "\n";

}

//输出

ab

c

对于“(?(name)yes|no)”，如果命名捕获组“name”有捕获，则匹配“yes”子表达式，否则匹配“no”子表达式。这一语法最典型的一种应用是平衡组。
当然，以上两种语法中，“yes”和“no都是可以省略的，但同一时间只能省略一个，不能一起省略。平衡组的应用中就是省略了“no”子表达式。

2.2 平衡组的匹配原理

平衡组的匹配原理可以用堆栈来解释，先举个例子，再根据例子进行解释。
源字符串：a+(b*(c+d))/e+f-(g/(h-i))*j
正则表达式：\(((?<Open>\()|(?<-Open>\))|[^()])*(?(Open)(?!))\)
需求说明：匹配成对出现的()中的内容

string test = "a+(b*(c+d))/e+f-(g/(h-i))*j";

Regex reg = new Regex(@"\(((?<Open>\()|(?<-Open>\))|[^()])*(?(Open)(?!))\)");

MatchCollection mc = reg.Matches(test);

foreach (Match m in mc)

{

     richTextBox2.Text += m.Value + "\n";

}

//输出

(b*(c+d))

(g/(h-i))

下面来考察一下这个正则，为了阅读方便，写成宽松模式。

Regex reg = new Regex(@"\(             #普通字符“(”

                            (                       #分组构造，用来限定量词“*”修饰范围

                                (?<Open>\()         #命名捕获组，遇到开括弧’Open’计数加1

                            |                   #分支结构

                                (?<-Open>\))        #狭义平衡组，遇到闭括弧’Open’计数减1

                            |                   #分支结构

                                [^()]+              #非括弧的其它任意字符

                            )*                      #以上子串出现0次或任意多次

                            (?(Open)(?!))           #判断是否还有’Open’，有则说明不配对，什么都不匹配

                        \)                          #普通闭括弧

                     ", RegexOptions.IgnorePatternWhitespace);

对于一个嵌套结构而言，开始和结束标记都是确定的，对于本例开始为“(”，结束为“)”，那么接下来就是考察中间的结构，中间的字符可以划分为三类，一类是“(”，一类是“)”，其余的就是除这两个字符以外的任意字符。
那么平衡组的匹配原理就是这样的：
1. 先找到第一个“(”，作为匹配的开始
2. 在第1步以后，每匹配到一个“(”，就入栈一个Open捕获组，计数加1
3. 在第1步以后，每匹配到一个“)”，就出栈最近入栈的Open捕获组，计数减1
4. 后面的(?(Open)(?!))用来保证堆栈中Open捕获组计数是否为0，也就是“(”和“)”是配对出现的
5. 最后的“)”，作为匹配的结束
匹配过程（以下匹配过程，如果觉得难以理解，可以暂时跳过，先学会如何使用，再研究为什么可以这样用吧）
首先匹配第一个“(”，然后一直匹配，直到出现以下两种情况之一：
a) 堆栈中Open计数已为0，此时再遇到“)”
b) 匹配到字符串结束符
这时控制权交给(?(Open)(?!))，判断Open是否有匹配，由于此时计数为0，没有匹配，那么就匹配“no”分支，由于这个条件判断结构中没有“no”分支，所以什么都不做，把控制权交给接下来的“\)”
如果上面遇到的是情况a)，那么此时“\)”可以匹配接下来的“\)”，匹配成功；如果上面遇到的是情况b)，那么此时会进行回溯，直到“\)”匹配成功为止，否则报告整个表达式匹配失败。
由于.NET中的狭义平衡组“(?<Close-Open>Expression)”结构，可以动态的对堆栈中捕获组进行计数，匹配到一个开始标记，入栈，计数加1，匹配到一个结束标记，出栈，计数减1，最后再判断堆栈中是否还有Open，有则说明开始和结束标记不配对出现，不匹配，进行回溯或报告匹配失败；如果没有，则说明开始和结束标记配对出现，继续进行后面子表达式的匹配。
需要对“(?!)”进行一下说明，它属于顺序否定环视，完整的语法是“(?!Expression)”。由于这里的“Expression”不存在，表示这里不是一个位置，所以试图尝试匹配总是失败的，作用就是在Open不配对出现时，报告匹配失败。

3 平衡组的应用及优化

平衡组提供了嵌套结构的匹配功能，这一创新是很让人兴奋的，因为此前正则对于嵌套结构的匹配是无能为力的。然而功能的强大，自然也带来了实现的复杂，正则书写得不好，可能会存在效率陷阱，甚至导致程序崩溃，这里介绍一些基本的优化方法。

3.1 单字符嵌套结构平衡组优化

单字符的嵌套结构指的是开始和结束标记都单个字符的嵌套结构，这种嵌套相对来说比较简单，优化起来也比较容易。先从上面提到的例子开始。

3.1.1 贪婪与非贪婪模式

上面给的例子是一种做了部分优化的常规写法，算作是版本1吧，它做了哪些优化呢，先来看下完全没有做过优化的版本0吧。

string test = "a+(b*(c+d))/e+f-(g/(h-i))*j";

Regex reg0 = new Regex(@"\(                     #普通字符“(”

                            (                       #分组构造，用来限定量词“*”修饰范围

                                (?<Open>\()         #命名捕获组，遇到开括弧Open计数加1

                            |                   #分支结构

                                (?<-Open>\))        #狭义平衡组，遇到闭括弧Open计数减1

                            |                   #分支结构

                                .                   #任意字符

                            )*?                     #以上子串出现0次或任意多次，非贪婪模式

                            (?(Open)(?!))           #判断是否还有'OPEN'，有则说明不配对，什么都不匹配

                        \)                          #普通闭括弧

                       ", RegexOptions.IgnorePatternWhitespace);

MatchCollection mc = reg0.Matches(test);

foreach (Match m in mc)

{

     richTextBox2.Text += m.Value + "\n";

}

//输出

(b*(c+d))

(g/(h-i))

接下来对比一下版本1。

Regex reg1 = new Regex(@"\(                          #普通字符“(”

                            (                       #分组构造，用来限定量词“*”修饰范围

                                (?<Open>\()         #命名捕获组，遇到开括弧’Open’计数加1

                            |                   #分支结构

                                (?<-Open>\))        #狭义平衡组，遇到闭括弧’Open’计数减1

                            |                   #分支结构

                                [^()]+              #非括弧的其它任意字符

                            )*                      #以上子串出现0次或任意多次

                            (?(Open)(?!))           #判断是否还有’Open’，有则说明不配对，什么都不匹配

                        \)                          #普通闭括弧

                     ", RegexOptions.IgnorePatternWhitespace);

看到区别了吗？版本1对版本0的改进主要有两个地方，一个是用“[^()]+”来代替“.”，另一个是用“*”来代替“*?”，也就是用贪婪模式来代替非贪婪模式。
如果使用了小数点“.”，那么为什么不能在分组内使用“.+”，后面又为什么不能用“*”呢？只要在上面的正则中使用并运行一下代码就可以知道了，匹配的结果是
(b*(c+d))/e+f-(g/(h-i))
而不是
(b*(c+d))
(g/(h-i))
因为无论是分组内使用“.+”还是后面使用“*”，都是贪婪模式，所以小数点会一直匹配下去，直到匹配到字符串的结束符才会停止，然后进行回溯匹配。为了取得正确结果，必须使用非贪婪模式“*?”。
这就类似于用“\(.+\)”去匹配“(abc)def(ghi)”一样，得到的结果是“(abc)def(ghi)”，而不是通常我们希望的“(abc)”和“(ghi)”。这时要用非贪婪模式“\(.+?\)”来得到正确的结果。
贪婪模式和非贪婪模式在匹配失败时，回溯的次数基本上是一样的，效率上没有多大区别，但是在匹配成功时，贪婪模式比非贪婪模式回溯的次数要少得多，效率要高得多。
对于“\(.+\)”如果既要得到正确的匹配结果，又要提高匹配效率，可以使用排除型捕获组+贪婪模式的方式，即“\([^()]+\)”。
版本0的平衡组也是一样，可以使用排除字符组“[^()]+”和贪婪模式“*”结合的方式，提高匹配效率，得到的就是版本1的平衡组。
相对于版本0，或许你会认为版本1的写法是很自然的，但是如果不了解这样一个演进过程，那么在字符序列嵌套结构平衡组优化时，就不会是那么自然的一件事了。

...全文