正则基础之——逆序环视深入

最新推荐文章于 2024-03-18 09:39:25 发布

kingdom_0

最新推荐文章于 2024-03-18 09:39:25 发布

阅读量522

点赞数

分类专栏： Regex 相关文章标签：正则表达式 regex 引擎 string 工作

Regex 相关专栏收录该内容

14 篇文章 1 订阅

订阅专栏

说明
：部
分内容有待进一步研究和修正，因为最近工作太忙，暂时抽不出时间来，未研究过的可以跳过这一篇，想研究的不要被我的思路所左右了，有研究清楚的还请指正

1 问题引出

前几天在 CSDN 论坛遇到这样一个问题：

var str="8912341253789";

需要将这个字符串中的重复的数字给去掉，也就是结果 89123457 。

首先需要说明的是，这种需求并不适合用正则来实现，至少，正则不是最好的实现方式。

这个问题本身不是本文讨论的重点，本文所要讨论的，主要是由这一问题的解决方案而引出的另一个正则匹配原理问题。

先看一下针对这一问题本身给出的解决方案。

string str = "8912341253789" ;

Regex reg = new Regex (@"((/d)/d*?)/2" );

while (str != (str = reg.Replace(str, "$1" ))) { }

richTextBox2.Text = str;

/*-------- 输出--------

89123457

基于此有朋友提出另一个疑问，为什么使用下面的正则没有效果

“ (?<=(?<value>/d).*?)/k<value> ”

由此也引出本文所要讨论的逆序环视更深入的一些细节，涉及到逆序环视的匹配原理和匹配过程。前面的两篇博客中虽然也有介绍，但还不够深入，参考 正则基础之 —— 环视和 正则应用之 —— 逆序环视探索 。本文将以逆序环视和反向引用结合这种复杂应用场景，对逆序环视进行深入探讨。

先把问题简化和抽象一下，上面的正则中用到了命名捕获组和命名捕捉组的反向引用，这在一定程度上增加了问题的复杂度，写成普通捕获组，并且用“ /d ”代替范围过大的“ . ”，如下

“ (?<=(/d)/d*?)/1 ”

需要匹配的字符串，抽象一下，取两种典型字符串如下。

源字符串一： 878

源字符串二： 9878

与上面正则表达式类似，正则表达式相应的也有四种形式

正则表达式一： (?<=(/d)/d*)/1

正则表达式二： (?<=(/d)/d*?)/1

正则表达式三： (?<=(/d))/d*/1

正则表达式四： (?<=(/d))/d*?/1

先看一下匹配结果：

string [] source = new string [] {"878" , "9878" };

List <Regex > regs = new List <Regex >();

regs.Add(new Regex (@"(?<=(/d)/d*)/1" ));

regs.Add(new Regex (@"(?<=(/d)/d*?)/1" ));

regs.Add(new Regex (@"(?<=(/d))/d*/1" ));

regs.Add(new Regex (@"(?<=(/d))/d*?/1" ));

foreach (string s in source)

{

foreach (Regex r in regs)

{

richTextBox2.Text += " 源字符串： " + s.PadRight(8, ' ' );

richTextBox2.Text += " 正则表达式： " + r.ToString().PadRight(18, ' ' );

richTextBox2.Text += " 匹配结果： " + r.Match(s).Value + "/n------------------------/n" ;

}

richTextBox2.Text += "------------------------/n" ;

}

/*-------- 输出--------

源字符串： 878 正则表达式： (?<=(/d)/d*)/1 匹配结果： 8

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

源字符串： 878 正则表达式： (?<=(/d)/d*?)/1 匹配结果：

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

源字符串： 878 正则表达式： (?<=(/d))/d*/1 匹配结果： 78

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

源字符串： 878 正则表达式： (?<=(/d))/d*?/1 匹配结果： 78

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

源字符串： 9878 正则表达式： (?<=(/d)/d*)/1 匹配结果：

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

源字符串： 9878 正则表达式： (?<=(/d)/d*?)/1 匹配结果：

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

源字符串： 9878 正则表达式： (?<=(/d))/d*/1 匹配结果： 78

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

源字符串： 9878 正则表达式： (?<=(/d))/d*?/1 匹配结果： 78

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

这个结果也许会出乎很多人的意料之外，刚开始接触这个问题时，我也一样感到迷惑，放了两天后，才灵机一触，想通了问题的关键所在，下面将展开讨论。

在此之前，可能还需要做两点说明：

1、下面讨论的话题已经与本文开始提到的问题没有多大关联了，最初的问题主要是为了引出本文的话题，问题本身不在讨论范围之内，而本文也主要是纯理论的探讨。

2、本文适合有一定正则基础的读者。如果您对上面几个正则的匹配结果和匹配过程感到费解，没关系，下面就将为您解惑；但是如果您对上面几个正则中元字符和语法代表的意义都不清楚的话，还是先从基础看起吧。

2 逆序环视匹配原理深入

正则表达式一： (?<=(/d)/d*)/1

正则表达式二： (?<=(/d)/d*?)/1

正则表达式三： (?<=(/d))/d*/1

正则表达式四： (?<=(/d))/d*?/1

上面的几个正则表达式，可以最终抽象为“ (?<=SubExp1)SubExp2 ”这样的表达式，在做逆序环视原理分析时，根据“ SubExp1 ”的特点，可以归纳为三类：

1、逆序环视中的子表达式“ SubExp1 ”长度固定，正则表达式三和四属于这一类，当然，这一类里是包括“ ? ”这一量词的，但也仅限于这一个量词。

2、逆序环视中的子表达式“ SubExp1 ”长度不固定，其中包含忽略优先量词，如“ *? ”、“ +? ”、“ {m,}? ”等，也就是通常所说的非贪婪模式，正则表达式二属于这一类。

3、逆序环视中的子表达式“ SubExp1 ”长度不固定，其中包含匹配优先量词，“ * ”、“ + ”、“ {m,} ”等，也就是通常所说的贪婪模式，正则表达式一属于这一类。

下面针对这三类正则表达式进行匹配过程的分析。

2.1 固定长度子表达式匹配过程分析

2.1.1 源字符串一 + 正则表达式三匹配过程

源字符串一： 878

正则表达式三： (?<=(/d))/d*/1

首先在位置 0 处开始尝试匹配，由“ (?<=(/d)) ”取得控制权，长度固定，只有一位，由位置 0 处向左查找一位，失败，“ (?<=(/d)) ”匹配失败，导致第一轮匹配尝试失败。

正则引擎传动装置向前传动，由位置 1 处尝试匹配，控制权交给“ (?<=(/d)) ”，向左查找一位，接着将控制权交给“ (/d) ”，更进一步的将控制权交给“ /d ”。“ /d ”取得控制权后，向右尝试匹配，匹配“ 8 ”成功，此时“ (?<=(/d)) ”匹配成功，匹配结果为位置 1 ，捕获组 1 匹配到的内容就是“ 8 ”，控制权交给“ /d* ”。由于“ /d* ”为贪婪模式，会优先尝试匹配位置 1 后面的“ 7 ”和“ 8 ”，匹配成功，记录回溯状态，控制权交给“ /1 ”。由于前面捕获组 1 捕获到的内容是“ 8 ”，所以“ /1 ”要匹配到“ 8 ”才能匹配成功，而此时已到达字符串结尾处，匹配失败，“ /d* ”回溯，让出最后的字符“ 8 ”，再将控制权交给“ /1 ”，由“ /1 ”匹配最后的“ 8 ”成功，此时整个表达式匹配成功。由于“ (?<=(/d)) ”只匹配位置，不占有字符，所以整个表达式匹配到的结果为“ 78 ”，其中“ /d* ”匹配到的是“ 7 ”，“ /1 ”匹配到的是“ 8 ”。

2.1.2 源字符串二 + 正则表达式三匹配过程

源字符串二： 9878

正则表达式三： (?<=(/d))/d*/1

这一组合的匹配过程，与 2.1.1 节的匹配过程基本类似，只不过多了一轮匹配尝试而已，这里不再赘述。

2.1.3 源字符串一 + 正则表达式四匹配过程

源字符串一： 878

正则表达式四： (?<=(/d))/d*?/1

正则引擎传动装置向前传动，由位置 1 处尝试匹配，控制权交给“ (?<=(/d)) ”，向左查找一位，接着将控制权交给“ (/d) ”，更进一步的将控制权交给“ /d ”。“ /d ”取得控制权后，向右尝试匹配，匹配“ 8 ”成功，此时“ (?<=(/d)) ”匹配成功，匹配结是果为位置 1 ，捕获组 1 匹配到的内容就是“ 8 ”，控制权交给“ /d*? ”。由于“ /d*? ”为非贪婪模式，会优先尝试忽略匹配，记录回溯状态，控制权交给“ /1 ”。由于前面捕获组 1 捕获到的内容是“ 8 ”，所以“ /1 ”要匹配到“ 8 ”才能匹配成功，而此时位置 1 后面的字符是“ 7 ”，匹配失败，“ /d*? ”回溯，尝试匹配位置 1 后面的字符“ 7 ”，再将控制权交给“ /1 ”，由“ /1 ”匹配最后的“ 8 ”成功，此时整个表达式匹配成功。由于“ (?<=(/d)) ”只匹配位置，不占有字符，所以整个表达式匹配到的结果为“ 78 ”，其中“ /d*? ”匹配到的是“ 7 ”，“ /1 ”匹配到的是最后的“ 8 ”。

这与 2.1.1 节组合的匹配过程基本一致，只不过就是“ /d* ”和“ /d*? ”匹配与回溯过程有所区别而已。

2.1.4 源字符串二 + 正则表达式四匹配过程

源字符串二： 9878

正则表达式四： (?<=(/d))/d*?/1

这一组合的匹配过程，与 2.1.3 节的匹配过程基本类似，这里不再赘述。

2.2 非贪婪模式子表达式匹配过程分析

2.2.1 源字符串一 + 正则表达式二匹配过程

源字符串一： 878

正则表达式二： (?<=(/d)/d*?)/1

首先在位置 0 处开始尝试匹配，由“ (?<=(/d)/d*?) ”取得控制权，长度不固定，至少一位，由位置 0 处向左查找一位，失败，“ (?<=(/d)/d*?) ”匹配失败，导致第一轮匹配尝试失败。

正则引擎传动装置向前传动，由位置 1 处尝试匹配，控制权交给“ (?<=(/d)/d*?) ”，向左查找一位，接着将控制权交给“ (/d) ”，更进一步的将控制权交给“ /d ”。“ /d ”取得控制权后，向右尝试匹配，匹配“ 8 ”成功，将控制权交给“ /d*? ”，由于“ /d*? ”为非贪婪模式，会优先尝试忽略匹配，即不匹配任何内容，并记录回溯状态，此时“ (/d)/d*? ”匹配成功，那么“ (?<=(/d)/d*?) ”也就匹配成功，匹配结果为位置 1 ，由于此处的子表达式“ (/d)/d*? ”为非贪婪模式，取得一个成功匹配项后，即交出控制权，同时丢弃所有回溯状态。由于前面捕获组 1 捕获到的内容是“ 8 ”，所以“ /1 ”要匹配到“ 8 ”才能匹配成功，而此时位置 1 后面的字符是“ 7 ”，此时已无可供回溯的状态，整个表达式在位置 1 处匹配失败。

正则引擎传动装置向前传动，由位置 2 处尝试匹配，控制权交给“ (?<=(/d)/d*?) ”，向左查找一位，接着将控制权交给“ (/d) ”，更进一步的将控制权交给“ /d ”。“ /d ”取得控制权后，向右尝试匹配，匹配“ 7 ”成功，将控制权交给“ /d*? ”，由于“ /d*? ”为非贪婪模式，会优先尝试忽略匹配，即不匹配任何内容，并记录回溯状态，此时“ (/d)/d*? ”匹配成功，那么“ (?<=(/d)/d*?) ”也就匹配成功，匹配结果为位置 2 ，由于此处的子表达式“ (/d)/d*? ”为非贪婪模式，取得一个成功匹配项后，即交出控制权，同时丢弃所有回溯状态。由于前面捕获组 1 捕获到的内容是“ 7 ”，所以“ /1 ”要匹配到“ 7 ”才能匹配成功，而此时位置 2 后面的字符是“ 7 ”，此时已无可供回溯的状态，整个表达式在位置 2 处匹配失败。

位置 3 处的匹配过程也同样道理，最后“ /1 ”因无字符可匹配，导致整个表达式匹配失败。

此时已尝试了字符串所有位置，均匹配失败，所以整个表达式匹配失败，未取得任何有效匹配结果。

2.2.2 源字符串二 + 正则表达式二匹配过程

源字符串一： 9878

正则表达式二： (?<=(/d)/d*?)/1

这一组合的匹配过程，与 2.2.1 节的匹配过程基本类似，这里不再赘述。

2.3 贪婪模式子表达式匹配过程分析

2.3.1 源字符串一 + 正则表达式一匹配过程

源字符串一： 878

正则表达式二： (?<=(/d)/d*)/1

首先在位置 0 处开始尝试匹配，由“ (?<=(/d)/d*) ”取得控制权，长度不固定，至少一位，由位置 0 处向左查找一位，失败，“ (?<=(/d)/d*) ”匹配失败，导致第一轮匹配尝试失败。

正则引擎传动装置向前传动，由位置 1 处尝试匹配，控制权交给“ (?<=(/d)/d*) ”，向左查找一位，接着将控制权交给“ (/d) ”，更进一步的将控制权交给“ /d ”。“ /d ”取得控制权后，向右尝试匹配，匹配“ 8 ”成功，将控制权交给“ /d* ”，由于“ /d* ”为贪婪模式，会优先尝试匹配，并记录回溯状态，但此时已没有可用于匹配的字符，所以匹配失败，回溯，不匹配任何内容，丢弃回溯状态，此时“ (/d)/d* ”匹配成功，匹配内容为“ 8 ”，那么“ (?<=(/d)/d*) ”也就匹配成功，匹配结果是位置 1 ，由于此处的子表达式为贪婪模式，“ (/d)/d* ”取得一个成功匹配项后，需要查找是否还有更长匹配，找到最长匹配后，才会交出控制权。再向左查找，已没有字符，“ 8 ”已是最长匹配，此时交出控制权，同时丢弃所有回溯状态。由于前面捕获组 1 捕获到的内容是“ 8 ”，所以“ /1 ”要匹配到“ 8 ”才能匹配成功，而此时位置 1 后面的字符是“ 7 ”，此时已无可供回溯的状态，整个表达式在位置 1 处匹配失败。

正则引擎传动装置向前传动，由位置 2 处尝试匹配，控制权交给“ (?<=(/d)/d*) ”，向左查找一位，接着将控制权交给“ (/d) ”，更进一步的将控制权交给“ /d ”。“ /d ”取得控制权后，向右尝试匹配，匹配“ 7 ”成功，将控制权交给“ /d* ”，由于“ /d* ”为贪婪模式，会优先尝试匹配，并记录回溯状态，但此时已没有可用于匹配的字符，所以匹配失败，回溯，不匹配任何内容，丢弃回溯状态，此时“ (/d)/d* ”匹配成功，匹配内容为“ 7 ”，那么“ (?<=(/d)/d*) ”也就匹配成功，匹配结果是位置 2 ，由于此处的子表达式为贪婪模式，“ (/d)/d* ”取得一个成功匹配项后，需要查找是否还有更长匹配，找到最长匹配后，才会交出控制权。再向左查找，由位置 0 处向右尝试匹配，“ /d ”取得控制权后，匹配位置 0 处的“ 8 ”成功，将控制权交给“ /d* ”，由于“ /d* ”为贪婪模式，会优先尝试匹配，并记录回溯状态，匹配位置 1 处的“ 7 ”成功，此时“ (/d)/d* ”匹配成功，那么“ (/d)/d* ”又找到了一个成功匹配项，匹配内容为“ 87 ”，其中捕获组 1 匹配到的是“ 8 ”。再向左查找，已没有字符，“ 87 ”已是最长匹配，此时交出控制权，同时丢弃所有回溯状态。由于前面捕获组 1 捕获到的内容是“ 8 ”，所以“ /1 ”匹配位置 2 处的“ 8 ”匹配成功，此时整个有达式匹配成功。

演示例程中用的是 Match ，只取一次匹配项，事实上如果用的是 Matches ，正则表达式是需要尝试所有位置的，对于这一组合，同样道理，在位置 3 处，由于“ /1 ”没有字符可供匹配，所以匹配一定是失败的。

至此，这一组合的匹配完成，有一个成功匹配项，匹配结果为“ 8 ”，匹配开始位置为位置 2 ，也就是匹配到的内容为第二个“ 8 ”。

2.3.2 源字符串二 + 正则表达式一匹配过程

源字符串二： 9878

正则表达式二： (?<=(/d)/d*)/1

正则引擎传动装置向前传动，由位置 1 处尝试匹配，这一轮的匹配过程与 2.3.1 节的组合在位置 1 处的匹配过程类似，只不过“ (/d)/d* ”匹配到的是“ 9 ”，捕获组 1 匹配到的也是“ 9 ”，因此“ /1 ”匹配失败，导致整个表达式在位置 1 处匹配失败。

正则引擎传动装置向前传动，由位置 2 处尝试匹配，这一轮的匹配过程与 2.3.1 节的组合在位置 2 处的匹配过程类似。首先“ (/d)/d* ”找到一个成功匹配项，匹配到的内容是“ 8 ”，捕捉组 1 匹配到的内容也是“ 8 ”，此时再向左尝试匹配，又找到一个成功匹配项，匹配到的内容是“ 98 ”，捕捉组 1 匹配到的内容也是“ 9 ”，再向左查找时，已无字符，所以“ 98 ”就是最长匹配项，“ (?<=(/d)/d*) ”匹配成功，匹配结果是位置 2 。由于此时捕获组 1 匹配的内容是“ 9 ”，所以“ /1 ”在位置 2 处匹配失败，导致整个表达式在位置 2 处匹配失败。

正则引擎传动装置向前传动，由位置 3 处尝试匹配，这一轮的匹配过程与上一轮在位置 2 处的匹配过程类似。首先“ (/d)/d* ”找到一个成功匹配项“ 7 ”，继续向左尝试，又找到一个成功匹配项“ 87 ”，再向左尝试，又找到一个成功匹配项“ 987 ”，此时已为最长匹配，交出控制权，并丢弃所有回溯状态。此时捕获组 1 匹配的内容是“ 9 ” 所以“ /1 ”在位置 3 处匹配失败，导致整个表达式在位置 3 处匹配失败。