从零开始学习正则表达式及正则表达式测试工具。

正则表达式具有伟大技术发明的一切特点,它简单、优美、功能强大、妙用无穷。对于很多实际工作来讲,正则表达式简直是灵丹妙药,能够成百倍地提高开发效率和程序质量。

1. 正则常见规则

1.1 字符匹配

1.2 位置匹配

1.3 组

1.4 先行断言

1.5 后行断言

1.6 量词和分支

以下都是惰性匹配
{m,n}?
{m,}?
??
+?
*?

1.7 分支

1.8 修饰符

2. 运算符优先级

3. 正则回溯

3.1 什么是回溯算法

以下是来自摘自维基百科的部分解释:

回溯法是一种通用的计算机算法,用于查找某些计算问题的所有(或某些)解决方案,特别是约束满足问题,逐步构建候选解决方案,并在确定候选不可能时立即放弃候选("回溯")完成有效的解决方案。

回溯法通常用最简单的递归方法来实现,在反复重复上述的步骤后可能出现两种情况:
  • 找到一个可能存在的正确的答案
  • 在尝试了所有可能的分步方法后宣告该问题没有答案
在最坏的情况下,回溯法会导致一次复杂度为指数时间的计算。

3.2 什么是正则回溯

正则引擎主要可以分为两大类:一种是 DFA(Deterministic finite automaton 确定型有穷自动机),另一种是 NFA(NFA Non-deterministic finite automaton  非确定型有穷自动机)。NFA 速度较 DFA 更慢,并且实现复杂,但是它又有着比 DFA 强大的多的功能,比如支持反向引用等。像 javaScript、java、php、python、c#等语言的正则引擎都是 NFA 型,NFA 正则引擎的实现过程中使用了回溯。

3.2.1 没有回溯的正则

举一个网上常见的例子,正则表达式/ab{1,3}c/g 去匹配文本'abbc',我们接下来会通过 RegexBuddy 分析其中的匹配过程,后续的一个章节4,有关于 RegexBuddy 的使用介绍。

可以先下载一下:下载及获取 RegexBuddy

如上图所示,让我们一步一步分解匹配过程:

  1. 正则引擎先匹配 a。
  2. 正则引擎尽可能多地(贪婪)匹配 b。
  3. 正则引擎匹配 c,完成匹配。

在这之中,匹配过程都很顺利,并没发生意外(回溯)。

3.2.2 有正则回溯的正则

让我们把上面的正则修改一下,/ab{1,3}c/g 改成/ab{1,3}bc/g,接下再通过 RegexBuddy 查看分析结果。

我们再一步一步分解匹配过程:

  1. 正则引擎先匹配 a。
  2. 正则引擎尽可能多地(贪婪)匹配 b{1,3}中的 b。
  3. 正则引擎去匹配 b,发现没 b 了,糟糕!赶紧回溯!
  4. 返回 b{1,3}这一步,不能这么贪婪,少匹配个 b。
  5. 正则引擎去匹配 b。
  6. 正则引擎去匹配 c,完成匹配。

以上,就是一个简单的回溯过程。

3.3 正则回溯的几种常见形式

从上面发生正则回溯的例子可以看出来,正则回溯的过程就是一个试错的过程,这也是回溯算法的精髓所在。回溯会增加匹配的步骤,势必会影响文本匹配的性能,所以,要想提升正则表达式的匹配性能,了解回溯出现的场景(形式)是非常关键的。

3.3.1 贪婪量词

在 NFA 正则引擎中,量词默认都是贪婪的。当正则表达式中使用了下表所示的量词,正则引擎一开始会尽可能贪婪的去匹配满足量词的文本。当遇到匹配不下去的情况,就会发生回溯,不断试错,直至失败或者成功。

ble data-draft-node="block" data-draft-type="table" data-size="normal" data-row-style="normal">

当多个贪婪量词挨着存在,并相互有冲突时,秉持的是"先到先得"的原则,如下所示:

let string = "12345";

let regex = /(\d{1,3})(\d{1,3})/;
console.log( string.match(regex) );
// => ["12345", "123", "45", index: 0, input: "12345"]

3.3.2 惰性量词

贪婪是导致回溯的重要原因,那我们尽量以懒惰匹配的方式去匹配文本,是否就能避免回溯了呢?答案是否定的。

让我们还是看回最初的例子,/ab{1,3}c/g 去匹配 abbc。接下来,我们再把正则修改一下,改成/ab{1,3}?c/g 去匹配 abbc,以懒惰匹配的方式去匹配文本,RegexBuddy 执行步骤如下图所示:

  1. 正则引擎先匹配 a。
  2. 正则引擎尽可能少地(懒惰)匹配 b{1,3}中的 b。
  3. 正则引擎去匹配 c,糟糕!怎么有个 b 挡着,匹配不了 c 啊!赶紧回溯!
  4. 返回 b{1,3}这一步,不能这么懒惰,多匹配个 b。
  5. 正则引擎再去匹配 c,糟糕!怎么还有 b 挡着,匹配不了 c 啊!赶紧回溯!
  6. 返回 b{1,3}这一步,不能这么懒惰,再多匹配个 b。
  7. 正则引擎再去匹配 c,匹配成功,棒棒哒!

本来是好端端不会发生回溯的正则,因为使用了惰性量词进行懒惰匹配后,反而产生了回溯了。所以说,惰性量词也不能瞎用,关键还是要看场景。

3.3.3 分组

分支的匹配规则是:按照分支的顺序逐个匹配,当前面的分支满足要求了,则舍弃后面的分支。

举个简单的分支栗子,使用正则表达式去匹配 /abcde|abc/g 文本 abcd,还是通过 RegexBuddy 查看执行步骤:

  1. 正则引擎匹配 a。
  2. 正则引擎匹配 b。
  3. 正则引擎匹配 c。
  4. 正则引擎匹配 d。
  5. 正则引擎匹配 e,糟糕!下一个并不是 e,赶紧回溯!
  6. 上一个分支走不通,切换分支,第二个分支正则引擎匹配 a。
  7. 第二个分支正则引擎匹配 b。
  8. 第二个分支正则引擎匹配 c,匹配成功!

由此,可以看出,分组匹配的过程,也是个试错的过程,中间是可能产生回溯的。

4. 正则的分析与调试

RegexBuddy 是个十分强大的正则表达式学习、分析及调试工具。RegexBuddy 支持 C++、Java、JavaScript、Python 等十几种主流编程语言。通过 RegexBuddy,能看到正则一步步创建的过程。结合测试文本,你能看到正则一步步执行匹配的过程,这对于理解正则回溯和对正则进行进一步优化,都有极大的帮助。

4.1 安装分析调试工具

下载及获取 RegexBuddy

下载完后,一步步点击安装即可。

4.2 工具界面介绍

下图便是 RegexBuddy 界面的各个面板及相关功能。

4.3 创建正则

为了方便使用,可以在布局设置那里将布局设置成 Side by Side Layout。

在正则输入区输入你的正则 regex1,查看 Create 面板,就会发现面板上显示了正则的创建过程(或者说是匹配规则),在 Test 面板区域输入你的测试文本,满足 regex1 匹配规则的部分会高亮显示,如下图所示。

4.4 使用 RegexBuddy 的 Debug 功能

选中测试文本,点击 debug 就可以进入 RegexBuddy 的 debug 模式,个人觉得这是 RegexBuddy 最强大地方,因为它可以让你清楚地知道你输入的正则对测试文本的匹配过程,执行了多少步,哪里发生了回溯,哪里需要优化,你都能一目了然。

4.5 使用 RegexBuddy 的 Library 功能

RegexBuddy 的正则库内置了很多常用正则,日常编码过程中需要的很多正则表达式都能在该正则库中找到。

5. 正则性能优化

正则是个很好用的利器,如果使用得当,如有神助,能省掉大量代码。当如果使用不当,则是处处埋坑。所以,本章节的重点就是总结如何写一个高性能的正则表达式。

5.1 避免量词嵌套

举个简单的例子对比:

我们使用正则表达式/a*b/去匹配字符串 aaaaa,看下图 RegexBuddy 的执行过程:

我们将以上正则修改成/(a*)*b/去匹配字符串 aaaaa,再看看 RegexBuddy 的执行结果过程:

以上两个正则的基本执行步骤可以简单认为是:

  1. 贪婪匹配
  2. 回溯
  3. 直至发现匹配失败

但令人惊奇的是,第一个正则的从开始匹配到匹配失败这个过程只有 14 步。而第二个正则却有 128 步之多。可想而知,嵌套量词会大大增加正则的执行过程。因为这其中进行了两层回溯,这个执行步骤增加的过程就如同算法复杂度从 O(n)上升到 O(n^2)的过程一般。

所以,面对量词嵌套,我们需作出适当的转化消除这些嵌套:

(a*)* <=> (a+)* <=> (a*)+ <=> a*
(a+)+ <=> a+

5.2 使用非捕获组

NFA 正则引擎中的括号主要有两个作用:

  1. 主流功能,提升括号中内容的运算优先级
  2. 反向引用

反向引用这个功能很强大,强大的代价是消耗性能。所以,当我们如果不需要用到括号反向引用的功能时,我们应该尽量使用非捕获组,也就是:

// 捕获组与非捕获组
() => (?:)
展开阅读全文

本文系作者在时代Java发表,未经许可,不得转载。

如有侵权,请联系nowjava@qq.com删除。

编辑于

关注时代Java

关注时代Java