正则表达式使用详解

最新推荐文章于 2024-04-16 15:29:39 发布

小学徒666

最新推荐文章于 2024-04-16 15:29:39 发布

阅读量2.5k

点赞数 7

分类专栏：嵌入式 LINUX 文章标签：正则表达式

原文链接：https://www.zhihu.com/question/48219401/answer/742444326

版权

嵌入式同时被 2 个专栏收录

56 篇文章 17 订阅

订阅专栏

LINUX

16 篇文章 2 订阅

订阅专栏

转载：https://www.zhihu.com/question/48219401/answer/742444326

正则表达式在几乎所有语言中都可以使用，无论是前端的JavaScript、还是后端的Java、c#。他们都提供相应的接口/函数支持正则表达式。

但很神奇的是：无论你大学选择哪一门计算机语言，都没有关于正则表达式的课程给你修，在你学会正则之前，你只能看着那些正则大师们，写了一串外星文似的字符串，替代了你用一大篇幅的if else代码来做一些数据校验。

既然喜欢，那就动手学呗，可当你百度出一一堆相关资料时，你发现无一不例外的枯燥至极，难以学习。

本文旨在用最通俗的语言讲述最枯燥的基本知识！

正则基础知识点：

1.元字符

万物皆有缘，正则也是如此，元字符是构造正则表达式的一种基本元素。
我们先来记几个常用的元字符：

有了元字符之后，我们就可以利用这些元字符来写一些简单的正则表达式了，
比如：

匹配有abc开头的字符串：

1   \babc或者^abc

2. 匹配8位数字的QQ号码：

1   ^\d\d\d\d\d\d\d\d$

3. 匹配1开头11位数字的手机号码：

1   ^1\d\d\d\d\d\d\d\d\d\d$

2. 重复限定符

有了元字符就可以写不少的正则表达式了，但细心的你们可能会发现：别人写的正则简洁明了，而不理君写的正则一堆乱七八糟而且重复的元字符组成的。正则没提供办法处理这些重复的元字符吗？

答案是有的！
为了处理这些重复问题，正则表达式中一些重复限定符，把重复部分用合适的限定符替代，下面我们来看一些限定符：

有了这些限定符之后，我们就可以对之前的正则表达式进行改造了，比如：

1. 匹配8位数字的QQ号码：

1   ^\d{8}$

2. 匹配1开头11位数字的手机号码：

1   ^1\d{10}$

3. 匹配银行卡号是14~18位的数字：

1   ^\d{14,18}$

4. 匹配以a开头的，0个或多个b结尾的字符串

1   ^ab*$

3. 分组

从上面的例子（4）中看到，*限定符是作用在与他左边最近的一个字符，那么问题来了，如果我想要ab同时被*限定那怎么办呢？

正则表达式中用小括号()来做分组，也就是括号中的内容作为一个整体。

因此当我们要匹配多个ab时，我们可以这样
如：匹配字符串中包含0到多个ab开头：

1   ^(ab)*

4. 转义

我们看到正则表达式用小括号来做分组，那么问题来了：

如果要匹配的字符串中本身就包含小括号，那是不是冲突？应该怎么办？

针对这种情况，正则提供了转义的方式，也就是要把这些元字符、限定符或者关键字转义成普通的字符，做法很简答，就是在要转义的字符前面加个斜杠，也就是\即可。
如：要匹配以(ab)开头：

1   ^(\(ab\))*

5. 条件或

回到我们刚才的手机号匹配，我们都知道：国内号码都来自三大网，它们都有属于自己的号段，比如联通有130/131/132/155/156/185/186/145/176等号段，假如让我们匹配一个联通的号码，那按照我们目前所学到的正则，应该无从下手的，因为这里包含了一些并列的条件，也就是“或”，那么在正则中是如何表示“或”的呢？

正则用符号 | 来表示或，也叫做分支条件，当满足正则里的分支条件的任何一种条件时，都会当成是匹配成功。

那么我们就可以用或条件来处理这个问题

1   ^(130|131|132|155|156|185|186|145|176)\d{8}$

6. 区间

看到上面的例子，是不是看到有什么规律？是不是还有一种想要简化的冲动？
实际是有的

正则提供一个元字符中括号 [] 来表示区间条件。

限定0到9 可以写成[0-9]
限定A-Z 写成[A-Z]
限定某些数字 [165]

那上面的正则我们还改成这样：

1   ^((13[0-2])|(15[56])|(18[5-6])|145|176)\d{8}$

好了，正则表达式的基本用法就讲到这里了，其实它还有非常多的知识点以及元字符，我们在此只列举了部分元字符和语法来讲，旨在给那些不懂正则或者想学正则但有看不下去文档的人做一个快速入门级的教程，看完本教程，即使你不能写出高大上的正则，至少也能写一些简单的正则或者看得懂别人写的正则了。

正则进阶知识点：

1. 零宽断言

无论是零宽还是断言，听起来都古古怪怪的，
那先解释一下这两个词。

断言：俗话的断言就是“我断定什么什么”，而正则中的断言，就是说正则可以指明在指定的内容的前面或后面会出现满足指定规则的内容，
意思正则也可以像人类那样断定什么什么，比如"ss1aa2bb3",正则可以用断言找出aa2前面有bb3，也可以找出aa2后面有ss1.
零宽：就是没有宽度，在正则中，断言只是匹配位置，不占字符，也就是说，匹配结果里是不会返回断言本身。

意思是讲明白了，那他有什么用呢？
我们来举个栗子：
假设我们要用爬虫抓取csdn里的文章阅读量。通过查看源代码可以看到文章阅读量这个内容是这样的结构

1   "<span class="read-count">阅读数：641</span>"

其中也就‘641’这个是变量，也就是说不同文章不同的值，当我们拿到这个字符串时，需要获得这里边的‘641’有很多种办法，但如果正则应该怎么匹配呢？

下面先来讲几种类型的断言：

正向先行断言（正前瞻）：

语法：（?=pattern）
作用：匹配pattern表达式的前面内容，不返回本身。

这样子说，还是一脸懵逼，好吧，回归刚才那个栗子，要取到阅读量，在正则表达式中就意味着要能匹配到‘</span>’前面的数字内容
按照上所说的正向先行断言可以匹配表达式前面的内容，那意思就是:(?=</span>) 就可以匹配到前面的内容了。
匹配什么内容呢？如果要所有内容那就是：

 1   String reg=".+(?=</span>)";
 2
 3   String test = "<span class=\"read-count\">阅读数：641</span>";
 4   Pattern pattern = Pattern.compile(reg);
 5   Matcher mc=    pattern.matcher(test);
 6   while(mc.find()){
 7    System.out.println("匹配结果：")
 8    System.out.println(mc.group());
 9   }
10
11   //匹配结果：
12   //<span class="read-count">阅读数：641

可是老哥我们要的只是前面的数字呀，那也简单咯，匹配数字 \d,那可以改成：

1   String reg="\\d+(?=</span>)";
2   String test = "<span class=\"read-count\">阅读数：641</span>";
3   Pattern pattern = Pattern.compile(reg);
4   Matcher mc=    pattern.matcher(test);
5   while(mc.find()){
6     System.out.println(mc.group());
7   }
8   //匹配结果：
9   //641

大功告成！

2. 正向后行断言（正后顾）:

语法：（?<=pattern）
作用：匹配pattern表达式的后面的内容，不返回本身。

有先行就有后行，先行是匹配前面的内容，那后行就是匹配后面的内容啦。
上面的栗子，我们也可以用后行断言来处理.

 1   //(?<=<span class="read-count">阅读数：)\d+
 2   String reg="(?<=<span class=\"read-count\">阅读数：)\\d+";
 3
 4   String test = "<span class=\"read-count\">阅读数：641</span>";
 5   Pattern pattern = Pattern.compile(reg);
 6   Matcher mc=    pattern.matcher(test);
 7        while(mc.find()){
 8          System.out.println(mc.group());
 9        }
10   //匹配结果：
11   //641

就这么简单。

3. 负向先行断言（负前瞻）

语法：(?!pattern)
作用：匹配非pattern表达式的前面内容，不返回本身。

有正向也有负向，负向在这里其实就是非的意思。
举个栗子：比如有一句 “我爱祖国，我是祖国的花朵”
现在要找到不是'的花朵'前面的祖国
用正则就可以这样写：

1   祖国(?!的花朵)

4. 负向后行断言（负后顾）

语法：(?<!pattern)
作用：匹配非pattern表达式的后面内容，不返回本身。

2. 捕获和非捕获

单纯说到捕获，他的意思是匹配表达式，但捕获通常和分组联系在一起，也就是“捕获组”

捕获组：匹配子表达式的内容，把匹配结果保存到内存中中数字编号或显示命名的组里，以深度优先进行编号，之后可以通过序号或名称来使用这些匹配结果。

而根据命名方式的不同，又可以分为两种组：

1. 数字编号捕获组：
语法：(exp)
解释：从表达式左侧开始，每出现一个左括号和它对应的右括号之间的内容为一个分组，在分组中，第0组为整个表达式，第一组开始为分组。
比如固定电话的：020-85653333
他的正则表达式为：(0\d{2})-(\d{8})
按照左括号的顺序，这个表达式有如下分组：

我们用Java来验证一下：

 1   String test = "020-85653333";
 2        String reg="(0\\d{2})-(\\d{8})";
 3        Pattern pattern = Pattern.compile(reg);
 4        Matcher mc= pattern.matcher(test);
 5        if(mc.find()){
 6          System.out.println("分组的个数有："+mc.groupCount());
 7            for(int i=0;i<=mc.groupCount();i++){
 8                System.out.println("第"+i+"个分组为："+mc.group(i));
 9            }
10        }

输出结果：

1   分组的个数有：2
2   第0个分组为：020-85653333
3   第1个分组为：020
4   第2个分组为：85653333

可见，分组个数是2，但是因为第0个为整个表达式本身，因此也一起输出了。

2. 命名编号捕获组：
语法：(?<name>exp)
解释：分组的命名由表达式中的name指定
比如区号也可以这样写:(?<quhao>\0\d{2})-(?<haoma>\d{8})
按照左括号的顺序，这个表达式有如下分组：

用代码来验证一下：

1   String test = "020-85653333";
2        String reg="(?<quhao>0\\d{2})-(?<haoma>\\d{8})";
3        Pattern pattern = Pattern.compile(reg);
4        Matcher mc= pattern.matcher(test);
5        if(mc.find()){
6            System.out.println("分组的个数有："+mc.groupCount());
7            System.out.println(mc.group("quhao"));
8            System.out.println(mc.group("haoma"));
9        }

输出结果：

1   分组的个数有：2
2   分组名称为:quhao,匹配内容为：020
3   分组名称为:haoma,匹配内容为：85653333

3. 非捕获组：
语法：(?:exp)
解释：和捕获组刚好相反，它用来标识那些不需要捕获的分组，说的通俗一点，就是你可以根据需要去保存你的分组。

比如上面的正则表达式，程序不需要用到第一个分组，那就可以这样写：

1   (?:\0\d{2})-(\d{8})

验证一下：

 1   String test = "020-85653333";
 2        String reg="(?:0\\d{2})-(\\d{8})";
 3        Pattern pattern = Pattern.compile(reg);
 4        Matcher mc= pattern.matcher(test);
 5        if(mc.find()){
 6                System.out.println("分组的个数有："+mc.groupCount());
 7                for(int i=0;i<=mc.groupCount();i++){
 8                    System.out.println("第"+i+"个分组为："+mc.group(i));
 9                }
10        }

输出结果：

1   分组的个数有：1
2   第0个分组为：020-85653333
3   第1个分组为：85653333

3. 反向引用

上面讲到捕获，我们知道：捕获会返回一个捕获组，这个分组是保存在内存中，不仅可以在正则表达式外部通过程序进行引用，也可以在正则表达式内部进行引用，这种引用方式就是反向引用。

根据捕获组的命名规则，反向引用可分为：

数字编号组反向引用：\k
或\number
命名编号组反向引用：\k
或者\'name'

好了讲完了，懂吗？不懂！！！
可能连前面讲的捕获有什么用都还不懂吧？
其实只是看完捕获不懂不会用是很正常的！
因为捕获组通常是和反向引用一起使用的

上面说到捕获组是匹配子表达式的内容按序号或者命名保存起来以便使用
注意两个字眼：“内容” 和 “使用”
这里所说的“内容”，是匹配结果，而不是子表达式本身，强调这个有什么用？嗯，先记住
那这里所说的“使用”是怎样使用呢？

因为它的作用主要是用来查找一些重复的内容或者做替换指定字符。

还是举栗子吧：
比如要查找一串字母"aabbbbgbddesddfiid"里成对的字母
如果按照我们之前学到的正则，什么区间啊限定啊断言啊可能是办不到的，
现在我们先用程序思维理一下思路：

1）匹配到一个字母
2）匹配第下一个字母，检查是否和上一个字母是否一样
3）如果一样，则匹配成功，否则失败

这里的思路2中匹配下一个字母时，需要用到上一个字母，那怎么记住上一个字母呢？？？
这下子捕获就有用处啦，我们可以利用捕获把上一个匹配成功的内容用来作为本次匹配的条件
好了，有思路就要实践
首先匹配一个字母：\w
我们需要做成分组才能捕获，因此写成这样：(\w)

那这个表达式就有一个捕获组：（\w）
然后我们要用这个捕获组作为条件，那就可以：(\w)\1
这样就大功告成了
可能有人不明白了，\1是什么意思呢？
还记得捕获组有两种命名方式吗，一种是是根据捕获分组顺序命名，一种是自定义命名来作为捕获组的命名
在默认情况下都是以数字来命名，而且数字命名的顺序是从1开始的
因此要引用第一个捕获组，根据反向引用的数字命名规则就需要 \k<1>或者\1
当然，通常都是是后者。
我们来测试一下：

1   String test = "aabbbbgbddesddfiid";
2        Pattern pattern = Pattern.compile("(\\w)\\1");
3        Matcher mc= pattern.matcher(test);
4        while(mc.find()){
5            System.out.println(mc.group());
6
7        }

输出结果：

1   aa
2   bb
3   bb
4   dd
5   dd
6   ii

嗯，这就是我们想要的了。

在举个替换的例子，假如想要把字符串中abc换成a

1   String test = "abcbbabcbcgbddesddfiid";
2   String reg="(a)(b)c";
3   System.out.println(test.replaceAll(reg, "$1"));;

输出结果：

1   abbabcgbddesddfiid

4. 贪婪和非贪婪

1.贪婪

我们都知道，贪婪就是不满足，尽可能多的要。
在正则中，贪婪也是差不多的意思:

贪婪匹配：当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符，这匹配方式叫做贪婪匹配。
特性：一次性读入整个字符串进行匹配，每当不匹配就舍弃最右边一个字符，继续匹配，依次匹配和舍弃（这种匹配-舍弃的方式也叫做回溯），直到匹配成功或者把整个字符串舍弃完为止，因此它是一种最大化的数据返回，能多不会少。

前面我们讲过重复限定符，其实这些限定符就是贪婪量词，比如表达式：

1   \d{3,6}

用来匹配3到6位数字，在这种情况下，它是一种贪婪模式的匹配，也就是假如字符串里有6个个数字可以匹配，那它就是全部匹配到。
如

1   String reg="\\d{3,6}";        
2   String test="61762828 176 2991 871";
3   System.out.println("文本："+test);
4   System.out.println("贪婪模式："+reg);
5   Pattern p1 =Pattern.compile(reg);
6   Matcher m1 = p1.matcher(test);
7    while(m1.find()){
8      System.out.println("匹配结果："+m1.group(0));
9   }

输出结果：

1   文本：61762828 176 2991 44 871
2   贪婪模式：\d{3,6}
3   匹配结果：617628
4   匹配结果：176
5   匹配结果：2991
6   匹配结果：871

由结果可见：本来字符串中的“61762828”这一段，其实只需要出现3个（617）就已经匹配成功了的，但是他并不满足，而是匹配到了最大能匹配的字符，也就是6个。
一个量词就如此贪婪了，
那有人会问，如果多个贪婪量词凑在一起，那他们是如何支配自己的匹配权的呢？

是这样的，多个贪婪在一起时，如果字符串能满足他们各自最大程度的匹配时，就互不干扰，但如果不能满足时，会根据深度优先原则，也就是从左到右的每一个贪婪量词，优先最大数量的满足，剩余再分配下一个量词匹配。

1   String reg="(\\d{1,2})(\\d{3,4})";        
2   String test="61762828 176 2991 87321";
3   System.out.println("文本："+test);
4   System.out.println("贪婪模式："+reg);
5   Pattern p1 =Pattern.compile(reg);
6   Matcher m1 = p1.matcher(test);
7    while(m1.find()){
8      System.out.println("匹配结果："+m1.group(0));
9     }

输出结果：

1   文本：61762828 176 2991 87321
2   贪婪模式：(\d{1,2})(\d{3,4})
3   匹配结果：617628
4   匹配结果：2991
5   匹配结果：87321

“617628” 是前面的\d{1,2}匹配出了61，后面的匹配出了7628
"2991" 是前面的\d{1,2}匹配出了29 ，后面的匹配出了91
"87321"是前面的\d{1,2}匹配出了87，后面的匹配出了321

2. 懒惰（非贪婪）

懒惰匹配：当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能少的字符，这匹配方式叫做懒惰匹配。
特性：从左到右，从字符串的最左边开始匹配，每次试图不读入字符匹配，匹配成功，则完成匹配，否则读入一个字符再匹配，依此循环（读入字符、匹配）直到匹配成功或者把字符串的字符匹配完为止。

懒惰量词是在贪婪量词后面加个“？”

1   String reg="(\\d{1,2}?)(\\d{3,4})";        
2        String test="61762828 176 2991 87321";
3        System.out.println("文本："+test);
4        System.out.println("贪婪模式："+reg);
5        Pattern p1 =Pattern.compile(reg);
6        Matcher m1 = p1.matcher(test);
7        while(m1.find()){
8            System.out.println("匹配结果："+m1.group(0));
9        }

输出结果：

1   文本：61762828 176 2991 87321
2   贪婪模式：(\d{1,2}?)(\d{3,4})
3   匹配结果：61762
4   匹配结果：2991
5   匹配结果：87321

解答：

“61762” 是左边的懒惰匹配出6，右边的贪婪匹配出1762
"2991" 是左边的懒惰匹配出2，右边的贪婪匹配出991
"87321" 左边的懒惰匹配出8，右边的贪婪匹配出7321

5. 反义

前面说到元字符的都是要匹配什么什么，当然如果你想反着来，不想匹配某些字符，正则也提供了一些常用的反义元字符：

正则进阶知识就讲到这里，正则是一门博大精深的语言，其实学会它的一些语法和知识点还算不太难，但想要做到真正学以致用能写出非常6的正则，还有很远的距离，只有真正对它感兴趣的，并且经常研究和使用它，才会渐渐的理解它的博大精深之处，我就带你们走到这，剩下的，靠自己啦。

原作者姓名：假不理

原出处：掘金

原文链接：https://juejin.im/post/5b96a8e2e51d450e6a2de115

编辑于 04-27

赞同 5473148 条评论

收藏喜欢收起

继续浏览内容

知乎

发现更大的世界

打开

Chrome

继续

更多回答

尤雨溪

前端开发等 3 个话题下的优秀回答者

952 人赞同了该回答

赞同

@郑海波

，除了自己实现一遍，剩下的也就是『无他，唯手熟尔』

另外工具方面推荐一个将 JS 正则可视化的工具：https://regexper.com/

对于理解别人源码里的（或者自己的，哈哈）复杂正则很有帮助：

发布于 2016-10-22

赞同 95231 条评论

收藏喜欢

继续浏览内容

知乎

发现更大的世界

打开

Chrome

继续

腾讯技术工程

已认证的官方帐号

2,310 人赞同了该回答

分享一篇腾讯前端开发工程师@mathe写的正则表达式教程。

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

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 分析其中的匹配过程，后续的一个章节有关于 RegexBuddy 的使用介绍。

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

正则引擎先匹配 a。
正则引擎尽可能多地(贪婪)匹配 b。
正则引擎匹配 c，完成匹配。

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

3.2.2 有正则回溯的正则

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

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

正则引擎先匹配 a。
正则引擎尽可能多地(贪婪)匹配 b{1,3}中的 b。
正则引擎去匹配 b，发现没 b 了，糟糕！赶紧回溯！
返回 b{1,3}这一步，不能这么贪婪，少匹配个 b。
正则引擎去匹配 b。
正则引擎去匹配 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 执行步骤如下图所示：

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

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

3.3.3 分组

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

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

正则引擎匹配 a。
正则引擎匹配 b。
正则引擎匹配 c。
正则引擎匹配 d。
正则引擎匹配 e，糟糕！下一个并不是 e，赶紧回溯！
上一个分支走不通，切换分支，第二个分支正则引擎匹配 a。
第二个分支正则引擎匹配 b。
第二个分支正则引擎匹配 c，匹配成功！

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

4. 正则的分析与调试

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

4.1 安装分析调试工具

可以在 RegexBuddy 的官方网站下载及获取 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 的正则库内置了很多常用正则，日常编码过程中需要的很多正则表达式都能在该正则库中找到。

4.6 更多工具推荐

5. 正则性能优化

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

5.1 避免量词嵌套

举个简单的例子对比：

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

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

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

贪婪匹配
回溯
直至发现匹配失败

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

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

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

5.2 使用非捕获组

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

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

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

// 捕获组与非捕获组
() => (?:)

5.3 分支优化

分支也是导致正则回溯的重要原因，所以，针对正则分支，我们也需要作出必要的优化。

5.3.1 减少分支数量

首先，需要减少分支数量。比如不少正则在匹配 http 和 https 的时候喜欢写成：

/^http|https/

其实上面完全可以优化成：

/^https?/

这样就能减少没必要的分支回溯

5.3.2 缩小分支内的内容

缩小分支中的内容也是很有必要的，例如我们需要匹配 this 和 that ，我们也许会写成：

/this|that/

但上面其实完全可以优化成

/th(?:is|at)/

有人可能认为以上没啥区别，实践出真知，让我们用以上两个正则表达式去匹配一下 that。

我们会发现第一个正则的执行步骤比第一个正则多两步，那是因为第一个正则的回溯路径比第二个正则的回溯路径更长了，最终导致执行步骤变长。

5.4 锚点优化

在能使用锚点的情况下尽量使用锚点。大部分正则引擎会在编译阶段做些额外分析, 判断是否存在成功匹配必须的字符或者字符串。类似^、$ 这类锚点匹配能给正则引擎更多的优化信息。

例如正则表达式 hello(hi)?$ 在匹配过程中只可能从字符串末尾倒数第 7 个字符开始, 所以正则引擎能够分析跳到那个位置, 略过目标字符串中许多可能的字符, 大大提升匹配速度。

6. 结语

曾经有一次因为写一个性能恶劣的正则表达式，导致代码执行过程因为性能问题挂掉。于是下定决心要把正则表达式搞明白，看了不少文章书籍，做了不少练习之后，总算摸到了些门道，也真真切切体会到正则表达式的优美和强大。写下此文，记录下一些学习心得和总结，望批评指正，共同进步。

7. 参考

小学徒666

关注

7
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
正则表达式使用详解

转载：https://www.zhihu.com/question/48219401/answer/742444326作者：老刘链接：https://www.zhihu.com/question/48219401/answer/742444326来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。正则表达式在几乎所有语言中都可以使用，无论是前端的JavaScript、还是后端的Java、c#。他们都提供相应的接口/函数支持正则表达式。但很神奇的是：无论你大学选.
复制链接

扫一扫