正则表达式学习记录

作者：假不理
链接：https://juejin.cn/post/6844903680349585422
来源：稀土掘金

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

正则基础知识点：

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

元字符	说明
.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线或汉字
\s	匹配任意的空白符
\d	匹配数字
\b	匹配单词的开始和结束
^	匹配字符串的开始
$	匹配字符串的结束

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

（1）匹配有abc开头的字符串：

\babc或者^abc

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

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

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

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

2. 重复限定符
有了元字符就可以写不少的正则表达式了，但细心的你们可能会发现：别人写的正则简洁明了，而上面写的正则表达式中有很多重复的元字符。为了处理元字符重复的问题，正则表达式中的重复限定符把重复部分用合适的限定符替代，下面我们来看一些限定符：

语法	说明
*	重复零次或更多次
+	重复一次或更多次
？	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次

有了这些限定符之后，我们就可以对之前的正则表达式进行改造了，比如：
（1）匹配8位数字的QQ号码：

^\d{8}$

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

^1\d{10}$

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

^\d{14,18}$

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

^ab*$

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

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

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

^(ab)*

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

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

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

^(\(ab\))*

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

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

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

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

6. 区间
看到上面的例子，是不是看到有什么规律？是不是还有一种想要简化的冲动？实际是有的，正则提供一个元字符中括号 [] 来表示区间条件。

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

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

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

进阶知识点：

1. 零宽断言

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

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

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

举个栗子：假设我们要用爬虫抓取csdn里的文章阅读量。通过查看源代码可以看到文章阅读量这个内容是这样的结构。

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

使用正向先行断言的方式：

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

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

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

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

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

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

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

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

String regex = "祖国(?!的花朵)";
String orignal = "我爱祖国，我是祖国的花朵。";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while(mc.find()) {
	System.out.println(mc.group());
}
// 匹配结果：祖国

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

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

String regex = "(?<!我爱)祖国";
String orignal = "我爱祖国，我是祖国的花朵。";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while(mc.find()) {
	System.out.println(mc.group());
}
// 匹配结果：祖国

2. 捕获和非捕获

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

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

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

（1）数字编号捕获组：

• 语法：(exp)
• 解释：从表达式左侧开始，每出现一个左括号和它对应的右括号之间的内容为一个分组，在分组中，第0组为整个表达式，第一组开始为分组。

比如固定电话的：020-85653333，他的正则表达式为：(0\d{2})-(\d{8})，按照左括号的顺序，这个表达式有如下分组：

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

String regex = "(0\\d{2})-(\\d{8})";
String orignal = "020-85653333";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while (mc.find()) {
	System.out.println("分组的个数有：" + mc.groupCount() + "个");
	for (int i = 0; i <= mc.groupCount(); i++) {
		System.out.println("第" + i + "个分组为：" + mc.group(i));
	}
}

输出结果：

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

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

（2）命名编号捕获组：

• 语法：(?<name>exp)
• 解释：分组的命名由表达式中的name指定

比如区号也可以这样写:(?<quhao>0\d{2})-(?<haoma>\d{8})，按照左括号的顺序，这个表达式有如下分组：

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

String regex = "(?<quhao>0\\d{2})-(?<haoma>\\d{8})";
String orignal = "020-85653333";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while (mc.find()) {
	System.out.println("分组的个数有：" + mc.groupCount() + "个");
	for (int i = 0; i <= mc.groupCount(); i++) {
		System.out.println("第" + i + "个分组为：" + mc.group(i));
	}
	System.out.println("组名为quhao的组:" + mc.group("quhao"));
	System.out.println("组名为haoma的组:" + mc.group("haoma"));
}

输出结果：

//	分组的个数有：2个
//	第0个分组为：020-85653333
//	第1个分组为：020
//	第2个分组为：85653333
//	组名为quhao的组:020
//	组名为haoma的组:85653333

（3）非捕获组

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

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

String regex = "(?:0\\d{2})-(\\d{8})";
String orignal = "020-85653333";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while (mc.find()) {
	System.out.println("分组的个数有：" + mc.groupCount() + "个");
	for (int i = 0; i <= mc.groupCount(); i++) {
		System.out.println("第" + i + "个分组为：" + mc.group(i));
	}
} 

输出结果：

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

3. 反向引用

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

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

• 数字编号组反向引用：\k<number>，通常简写为\number
• 命名编号组反向引用：\k<name>或者\k’name’

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

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

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

这里的思路2中匹配下一个字母时，需要用到上一个字母，那怎么记住上一个字母呢？这下子捕获就有用处啦，我们可以利用捕获把上一个匹配成功的内容用来作为本次匹配的条件。

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

A，查找成对的字母：

String regex = "(\\w)\\1";
String orignal = "aabbbbgbddesddfiid";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while (mc.find()) {
	System.out.println(mc.group());
}

输出结果：

//	aa
//	bb
//	bb
//	dd
//	dd
//	ii

B，查找AABB的字母：

// 查找成对的字母
String regex = "(\\w)\\1(\\w)\\2";
String orignal = "aabbbbgbddesddfiid";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while (mc.find()) {
	System.out.println(mc.group());
}

输出结果：

//	aabb

C，查找ABAB的字母：

// 查找成对的字母
String regex = "(\\w)(\\w)\\1\\2";
String orignal = "ababbbbgbddesddfiid";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while (mc.find()) {
	System.out.println(mc.group());
}

输出结果：

//	abab

以此类推：

// AABB
(.)\1(.)\2
// AAAB
(.)\1\1.
// ABBB
.(.)\1\1
// ABAB
(.)(.)\1\2

以上都是认为A和B可以相同的，如果A和B要求不同

// AABB
(.)\1((?!\1).)\2
// AAAB
(.)\1\1(?!\1).
// ABBB
(.)((?!\1).)\2\2
// ABAB
(.)((?!\1).)\1\2

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

String regex = "(a)(b)c";
String orignal = "abcbbabcbcgbddesddfiid";
System.out.println(orignal.replaceAll(regex, "a"));

输出结果：

// abbabcgbddesddfiid

4. 贪婪和非贪婪

（1）贪婪

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

重复限定符，其实这些限定符就是贪婪量词，比如表达式：

\d{3, 6}

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

String regex = "\\d{3,6}";
String orignal = "61762828 176 2991 871";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while (mc.find()) {
	System.out.println(mc.group());
}

输出结果：

// 617628
// 176
// 2991
// 871

由结果可见：本来字符串中的“61762828”这一段，其实只需要出现3个数字（617）就已经匹配成功了的，但是他并不满足，而是匹配到了最大能匹配的字符，也就是6个数字。

如果多个贪婪量词凑在一起，那他们是如何支配自己的匹配权的呢？

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

String regex = "(\\d{1,2})(\\d{3,4})";
String orignal = "61762828 176 2991 87321";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while (mc.find()) {
	System.out.println(mc.group());
}

输出结果：

// 617628
// 2991
// 87321

结果解析：

1. “617628” 是前面的\d{1,2}匹配出了61，后面的匹配出了7628
2. “2991” 是前面的\d{1,2}匹配出了2，后面的匹配出了991(满足匹配优先，再最大程度的贪婪)
3. "87321"是前面的\d{1,2}匹配出了87，后面的匹配出了321

（2）懒惰（非贪婪）

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

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

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

String regex = "(\\d{1,2}?)(\\d{3,4})";
String orignal = "61762828 176 2991 87321";
Pattern p = Pattern.compile(regex);
Matcher mc = p.matcher(orignal);
while (mc.find()) {
	System.out.println(mc.group());
}

输出结果：

// 61762
// 2991
// 87321

结果解析：

1. “61762” 是前面的\d{1,2}?懒惰匹配出了6，后面的匹配出了1762
2. “2991” 是前面的\d{1,2}?懒惰匹配出了2，后面的匹配出了991
3. "87321"是前面的\d{1,2}?懒惰匹配出了8，后面的匹配出了7321

5.反义

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

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

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