此次不会说个人正则教程没写全了吧？？

时间 2019-11-05

原文原文链接

因为上一篇文章：《正则表达式真的很骚，惋惜你不会写！！！》发表以后，很多网友说怎么没讲断言没讲反向没讲贪婪….，甚至有老铁说我裤子都脱了你就给讲了一点，哈哈哈，好吧，趁着山竹台风被迫放假在家的时间，把正则剩余的一些知识点给讲一下，但愿你们喜欢，但愿此次脱裤子阅读的老铁能够畅快的操做了。html

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

文章提纲：正则表达式

零宽断言

捕获和非捕获

反向引用

贪婪和非贪婪

反义

1. 零宽断言

不管是零宽仍是断言，听起来都古古怪怪的，
那先解释一下这两个词。编程

断言：俗话的断言就是“我判定什么什么”，而正则中的断言，就是说正则能够指明在指定的内容的前面或后面会出现知足指定规则的内容，
意思正则也能够像人类那样判定什么什么，好比"ss1aa2bb3",正则能够用断言找出aa2前面有bb3，也能够找出aa2后面有ss1.

零宽：就是没有宽度，在正则中，断言只是匹配位置，不占字符，也就是说，匹配结果里是不会返回断言自己。

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

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

其中只有‘641’这个是一个变量，也就是不一样文章有不一样的值，当咱们拿到这个字符串时，须要得到这里边的‘641’有不少种办法，但若是使用正则应该怎么匹配呢？app

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

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

语法：（?=pattern）

做用：匹配pattern表达式的前面内容，不返回自己。

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

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

但是老哥咱们要的只是前面的数字呀，那也简单咯，匹配数字 \d,那能够改为：ui

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

大功告成！spa

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

语法：（?<=pattern）

做用：匹配pattern表达式的后面的内容，不返回自己。

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

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

就这么简单。

负向先行断言（负前瞻）

语法：(?!pattern)

做用：匹配非pattern表达式的前面内容，不返回自己。

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

1祖国(?!的花朵)
复制代码

负向后行断言（负后顾）

语法：(?<!pattern)

做用：匹配非pattern表达式的后面内容，不返回自己。

2. 捕获和非捕获

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

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

而根据命名方式的不一样，又能够分为两种组：

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

序号	编号	分组	内容
0	0	(0\d{2})-(\d{8})	020-85653333
1	1	(0\d{2})	020
2	2	(\d{8})	85653333

咱们用Java来验证一下：

 1String 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个为整个表达式自己，所以也一块儿输出了。

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

序号	名称	分组	内容
0	0	(0\d{2})-(\d{8})	020-85653333
1	quhao	(0\d{2})	020
2	haoma	(\d{8})	85653333

用代码来验证一下：

1String 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
复制代码

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

好比上面的正则表达式，程序不须要用到第一个分组，那就能够这样写：

1(?:\0\d{2})-(\d{8})
复制代码

序号	编号	分组	内容
0	0	(0\d{2})-(\d{8})	020-85653333
1	1	(\d{8})	85653333

验证一下：

 1String 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
固然，一般都是是后者。
咱们来测试一下：

1String 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        }
复制代码

输出结果：

1aa
2bb
3bb
4dd
5dd
6ii
复制代码

嗯，这就是咱们想要的了。
在举个替换的例子，假如想要把字符串中abc换成a

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

输出结果：

1abbabcgbddesddfiid
复制代码

4. 贪婪和非贪婪

1.贪婪

咱们都知道，贪婪就是不知足，尽量多的要。
在正则中，贪婪也是差很少的意思:

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

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

1\d{3,6}
复制代码

用来匹配3到6位数字，在这种状况下，它是一种贪婪模式的匹配，也就是假如字符串里有6个个数字能够匹配，那它就是所有匹配到。
如

1String reg="\\d{3,6}";        
2String test="61762828 176 2991 871";
3System.out.println("文本："+test);
4System.out.println("贪婪模式："+reg);
5Pattern p1 =Pattern.compile(reg);
6Matcher 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个。
一个量词就如此贪婪了，
那有人会问，若是多个贪婪量词凑在一块儿，那他们是如何支配本身的匹配权的呢？

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

1String reg="(\\d{1,2})(\\d{3,4})";        
2String test="61762828 176 2991 87321";
3System.out.println("文本："+test);
4System.out.println("贪婪模式："+reg);
5Pattern p1 =Pattern.compile(reg);
6Matcher 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}匹配出了2 ，后面的匹配出了991(知足匹配优先，再最大程度的贪婪)

"87321"是前面的\d{1,2}匹配出了87，后面的匹配出了321

2. 懒惰（非贪婪）

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

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

代码	说明
*?	重复任意次，但尽量少重复
+?	重复1次或更屡次，但尽量少重复
??	重复0次或1次，但尽量少重复
{n,m}?	重复n到m次，但尽量少重复
{n,}?	重复n次以上，但尽量少重复

1String 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. 反义

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

元字符	解释
\W	匹配任意不是字母，数字，下划线，汉字的字符
\S	匹配任意不是空白符的字符
\D	匹配任意非数字的字符
\B	匹配不是单词开头或结束的位置
[^x]	匹配除了x之外的任意字符
[^aeiou]	匹配除了aeiou这几个字母之外的任意字符

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

以为本文对你有帮助？请分享给更多人关注「编程无界」，提高装逼技能