正则表达式深入学习

正则表达式深入学习
。

原文链接：https://blog.csdn.net/weixin_34144450/article/details/87941336?utm_source=app

目录

第一章正则表达式字符匹配攻略

第二章正则表达式位置匹配攻略

第三章正则表达式括号的作用

下面简单地说说每一章都讨论了什么？

正则是匹配模式，要么匹配字符，要么匹配位置。

第1章和第2章以这个角度去讲解了正则的基础。

在正则中可以使用括号捕获数据，要么在API中进行分组引用，要么在正则里进行反向引用。

这是第3章的主题，讲解了正则中括号的作用。

=====================================================================================

第一章正则表达式字符匹配攻略

正则表达式是匹配模式，要么匹配字符，要么匹配位置。请记住这句话。

内容：
1. 两种模糊匹配
2. 字符组
3. 量词
4. 分支结构
5. 案例分析
1 两种模糊匹配

如果正则只有精确匹配是没多大意义的，比如/hello/，也只能匹配字符串中的"hello"这个子串。
```
var regex = /hello/;
console.log( regex.test("hello") ); //true
```
正则表达式之所以强大，是因为其能实现模糊匹配。

而模糊匹配，有两个方向上的“模糊”：横向模糊和纵向模糊。

1.1 横向模糊匹配

横向模糊指的是，一个正则可匹配的字符串的长度不是固定的，可以是多种情况的。

其实现的方式是使用量词。譬如{m,n}，表示连续出现最少m次，最多n次。

比如/ab{2,5}c/表示匹配这样一个字符串：第一个字符是“a”，接下来是2到5个字符“b”，最后是字符“c”。测试如下：
```
var regex = /ab{2,5}c/g;
var string = "abc abbc abbbc abbbbc abbbbbc abbbbbbc";
console.log(string.match(regex));
//["abbc", "abbbc", "abbbbc", "abbbbbc"]
```
去掉g的情况（只匹配一次）
```
var regex = /ab{2,5}c/;
var string = "abc abbc abbbc abbbbc abbbbbc abbbbbbc";
console.log(string.match(regex));
//["abbc", index: 4, input: "abc abbc abbbc abbbbc abbbbbc abbbbbbc", groups: undefined]
```
1.2 纵向模糊匹配

纵向模糊指的是，一个正则匹配的字符串，具体到某一位字符时，它可以不是某个确定的字符，可以有多种可能。

其实现的方式是使用字符组。譬如[abc]，表示该字符是可以字符“a”、“b”、“c”中的任何一个。

比如/a[123]b/可以匹配如下三种字符串："a1b"、"a2b"、"a3b"。测试如下：
```
var regex = /a[123]b/g;
var string = "a0b a1b a2b a3b a4b";
console.log( string.match(regex) );
// ["a1b", "a2b", "a3b"]
```
2. 字符组

需要强调的是，虽叫字符组（字符类），但只是其中一个字符。例如[abc]，表示匹配一个字符，它可以是“a”、“b”、“c”之一。

2.1 范围表示法

如果字符组里的字符特别多的话，怎么办？可以使用范围表示法。

比如[123456abcdefGHIJKLM]，可以写成[1-6a-fG-M]。用连字符-来省略和简写。

因为连字符有特殊用途，那么要匹配“a”、“-”、“z”这三者中任意一个字符，该怎么做呢？

不能写成[a-z]，因为其表示小写字符中的任何一个字符。

可以写成如下的方式：[-az]或[az-]或[a-z]。即要么放在开头，要么放在结尾，要么转义。总之不会让引擎认为是范围表示法就行了。

2.2 排除字符组

纵向模糊匹配，还有一种情形就是，某位字符可以是任何东西，但就不能是"a"、"b"、"c"。

此时就是排除字符组（反义字符组）的概念。例如[^abc]，表示是一个除"a"、"b"、"c"之外的任意一个字符。字符组的第一位放^（脱字符），表示求反的概念。

当然，也有相应的范围表示法。

2.3 常见的简写形式

有了字符组的概念后，一些常见的符号我们也就理解了。因为它们都是系统自带的简写形式。
```
d就是[0-9]。表示是一位数字。记忆方式：其英文是digit（数字）。

D就是[^0-9]。表示除数字外的任意字符。

w就是[0-9a-zA-Z_]。表示数字、大小写字母和下划线。记忆方式：w是word的简写，也称单词字符。

W是[^0-9a-zA-Z_]。非单词字符。

s是[ 	v

f]。表示空白符，包括空格、水平制表符、垂直制表符、换行符、回车符、换页符。记忆方式：s是space character的首字母。

S是[^ 	v

f]。 非空白符。

.就是[^

u2028u2029]。通配符，表示几乎任意字符。换行符、回车符、行分隔符和段分隔符除外。记忆方式：想想省略号...中的每个点，都可以理解成占位符，表示任何类似的东西。
```
如果要匹配任意字符怎么办？可以使用[dD]、[wW]、[sS]和[^]中任何的一个。

3. 量词

量词也称重复。掌握{m,n}的准确含义后，只需要记住一些简写形式。

3.1 简写形式
```
{m,} 表示至少出现m次。

{m} 等价于{m,m}，表示出现m次。

? 等价于{0,1}，表示出现或者不出现。记忆方式：问号的意思表示，有吗？

+ 等价于{1,}，表示出现至少一次。记忆方式：加号是追加的意思，得先有一个，然后才考虑追加。

* 等价于{0,}，表示出现任意次，有可能不出现。记忆方式：看看天上的星星，可能一颗没有，可能零散有几颗，可能数也数不过来。
```
3.2 贪婪匹配和惰性匹配

看如下的例子：
```
var regex = /d{2,5}/g;
var string = "123 1234 12345 123456";
console.log( string.match(regex) ); 
// ["123", "1234", "12345", "12345"]
```
其中正则/d{2,5}/，表示数字连续出现2到5次。会匹配2位、3位、4位、5位连续数字。

但是其是贪婪的，它会尽可能多的匹配。你能给我6个，我就要5个。你能给我3个，我就3要个。反正只要在能力范围内，越多越好。

我们知道有时贪婪不是一件好事（请看文章最后一个例子）。而惰性匹配，就是尽可能少的匹配：
```
var regex = /d{2,5}?/g;
var string = "123 1234 12345 123456";
console.log( string.match(regex) );
// ["12", "12", "34", "12", "34", "12", "34", "56"]
```
其中/d{2,5}?/表示，虽然2到5次都行，当2个就够的时候，就不在往下尝试了。

通过在量词后面加个问号就能实现惰性匹配，因此所有惰性匹配情形如下：
```
{m,n}?
{m,}?
??
+?
*?
```
对惰性匹配的记忆方式是：量词后面加个问号，问一问你知足了吗，你很贪婪吗？

4. 多选分支

一个模式可以实现横向和纵向模糊匹配。而多选分支可以支持多个子模式任选其一。

具体形式如下：(p1|p2|p3)，其中p1、p2和p3是子模式，用|（管道符）分隔，表示其中任何之一。

例如要匹配"good"和"nice"可以使用/good|nice/。测试如下：
```
var regex = /good|nice/g;
var string = "good idea, nice try.";
console.log( string.match(regex) ); 
// ["good", "nice"]
```
但有个事实我们应该注意，比如我用/good|goodbye/，去匹配"goodbye"字符串时，结果是"good"：
```
var regex = /good|goodbye/g;
var string = "goodbye";
console.log( string.match(regex) ); 
//["good"]
```
而把正则改成/goodbye|good/，结果是：
```
var regex = /goodbye|good/g;
var string = "goodbye";
console.log( string.match(regex) ); 
//["goodbye"]
```
也就是说，分支结构也是惰性的，即当前面的匹配上了，后面的就不再尝试了。

第二章正则表达式位置匹配攻略

正则表达式是匹配模式，要么匹配字符，要么匹配位置。请记住这句话。

然而大部分人学习正则时，对于匹配位置的重视程度没有那么高。

本章讲讲正则匹配位置的总总。

内容包括：
1. 什么是位置？
2. 如何匹配位置？
3. 位置的特性
4. 几个应用实例分析
1. 什么是位置呢？

位置是相邻字符之间的位置。

2. 如何匹配位置呢？

在ES5中，共有6个锚字符：
```
^ $  B (?=p) (?!p)
```
2.1 ^和$　

^（脱字符）匹配开头，在多行匹配中匹配行开头。

$（美元符号）匹配结尾，在多行匹配中匹配行结尾。

比如我们把字符串的开头和结尾用"#"替换（位置可以替换成字符的！）
```
var result = "hello".replace(/^|$/g, '#');
console.log(result);
// #hello#
```
多行匹配模式时，二者是行的概念，这个需要我们的注意：
```
var result = "I
love
javascript".replace(/^|$/gm, '#');
console.log(result);
/**
*#I#
*#love#
*#javascript#
*/
```
2.2 和B

是单词边界，具体就是w和W之间的位置，也包括w和^之间的位置，也包括w和$之间的位置。

比如一个文件名是"[JS] Lesson_01.mp4"中的，如下：
```
var result = "[JS] Lesson_01.mp4".replace(//g, '#');
console.log(result);
//[#JS#] #Lesson_01#.#mp4#
```
知道了的概念后，那么B也就相对好理解了。

B就是的反面的意思，非单词边界。例如在字符串中所有位置中，扣掉，剩下的都是B的。

具体说来就是w与w、W与W、^与W，W与$之间的位置。

比如上面的例子，把所有B替换成"#"：
```
var result = "[JS] Lesson_01.mp4".replace(/B/g, '#');
console.log(result);
// #[J#S]# L#e#s#s#o#n#_#0#1.m#p#4
```
2.3 (?=p)和(?!p)

(?=p)，其中p是一个子模式，即p前面的位置。

比如(?=l)，表示'l'字符前面的位置，例如：
```
var result = "hello".replace(/(?=l)/g, '#');
console.log(result); 
// he#l#lo
```
而(?!p)就是(?=p)的反面意思，比如：
```
var result = "hello".replace(/(?!l)/g, '#');
 
console.log(result);
//  #h#ell#o#
```
3. 位置的特性

对于位置的理解，我们可以理解成空字符""。

比如"hello"字符串等价于如下的形式：
```
"hello" == "" + "h" + "" + "e" + "" + "l" + "" + "l" + "o" + "";
```
也等价于：
```
"hello" == "" + "" + "hello"
```
因此，把/^hello$/写成/^^hello$$$/，是没有任何问题的：
```
var result = /^^hello$$$/.test("hello");
console.log(result); 
// true
```
4. 相关案例

4.1 不匹配任何东西的正则
```
/.^/
```
4.2 数字的千位分隔符表示法

比如把"12345678"，变成"12,345,678"。

可见是需要把相应的位置替换成","。

思路是什么呢？

4.2.1 弄出最后一个逗号

使用(?=d{3}$)就可以做到：
```
var result = "12345678".replace(/(?=d{3}$)/g, ',')
console.log(result); 
// 12345,678
```
4.2.2 弄出所有的逗号

因为逗号出现的位置，要求后面3个数字一组，也就是d{3}至少出现一次。

此时可以使用量词+：
```
var result = "12345678".replace(/(?=(d{3})+$)/g, ',')
console.log(result);
// 12,345,678
```
4.2.3 匹配其余案例

写完正则后，要多验证几个案例，此时我们会发现问题：
```
var result = "123456789".replace(/(?=(d{3})+$)/g, ',')
console.log(result);
// ,123,456,789
```
因为上面的正则，仅仅表示把从结尾向前数，一但是3的倍数，就把其前面的位置替换成逗号。因此才会出现这个问题。

怎么解决呢？我们要求匹配的到这个位置不能是开头。

我们知道匹配开头可以使用^，但要求这个位置不是开头怎么办？

easy，(?!^)，你想到了吗？测试如下：
```
var string1 = "12345678",
string2 = "123456789";
reg = /(?!^)(?=(d{3})+$)/g;
 
var result = string1.replace(reg, ',')
var result2 = string2.replace(reg,",")
console.log(result); // 12,345,678
console.log(result2); // 123,456,789
```
第三章正则表达式括号的作用

括号的使用是否得心应手，是衡量对正则的掌握水平的一个侧面标准。

括号的作用，其实三言两语就能说明白，括号提供了分组，便于我们引用它。

引用某个分组，会有两种情形：在JavaScript里引用它，在正则表达式里引用它。

本章内容虽相对简单，但我也要写长点。

内容包括：
1. 分组和分支结构
2. 捕获分组
3. 反向引用
4. 非捕获分组
5. 相关案例
1. 分组和分支结构

这二者是括号最直觉的作用，也是最原始的功能。

1.1 分组

我们知道/a+/匹配连续出现的“a”，而要匹配连续出现的“ab”时，需要使用/(ab)+/。

其中括号是提供分组功能，使量词+作用于“ab”这个整体，测试如下：
```
var regex = /(ab)+/g;
var string = "ababa abbb ababab";
console.log( string.match(regex) );
// ["abab", "ab", "ababab"]
```
1.2 分支结构

而在多选分支结构(p1|p2)中，此处括号的作用也是不言而喻的，提供了子表达式的所有可能。

比如，要匹配如下的字符串：
```
I love JavaScript

I love Regular Expression
```
```
var regex = /^I love (JavaScript|Regular Expression)$/;
console.log( regex.test("I love JavaScript") );
console.log( regex.test("I love Regular Expression") );
// => true
```
如果去掉正则中的括号，即/^I love JavaScript|Regular Expression$/，匹配字符串是"I love JavaScript"和"Regular Expression"，当然这不是我们想要的。

2. 引用分组

这是括号一个重要的作用，有了它，我们就可以进行数据提取，以及更强大的替换操作。

而要使用它带来的好处，必须配合使用实现环境的API。

以日期为例。假设格式是yyyy-mm-dd的，我们可以先写一个简单的正则：
```
var regex = /d{4}-d{2}-d{2}/;
```
然后再修改成括号版的：

var regex = /(d{4})-(d{2})-(d{2})/;

为什么要使用这个正则呢？

比如提取出年、月、日，可以这么做：
```
var regex = /(d{4})-(d{2})-(d{2})/;
var string = "2017-06-12";
console.log( string.match(regex) ); 
// ["2017-06-12", "2017", "06", "12", index: 0, input: "2017-06-12", groups: undefined]
```
match返回的一个数组，第一个元素是整体匹配结果，然后是各个分组（括号里）匹配的内容，然后是匹配下标，最后是输入的文本。（注意：如果正则是否有修饰符g，match返回的数组格式是不一样的）。

另外也可以使用正则对象的exec方法：
```
var regex = /(d{4})-(d{2})-(d{2})/;
var string = "2017-06-12";
console.log( regex.exec(string) );
// ["2017-06-12", "2017", "06", "12", index: 0, input: "2017-06-12", groups: undefined]
```
同时，也可以使用构造函数的全局属性$1至$9来获取：
```
var regex = /(d{4})-(d{2})-(d{2})/;
var string = "2017-06-12";
 
regex.test(string); // 正则操作即可，例如
//regex.exec(string);
//string.match(regex);
 
console.log(RegExp.$1); // "2017"
console.log(RegExp.$2); // "06"
console.log(RegExp.$3); // "12"
```
2.2 替换

比如，想把yyyy-mm-dd格式，替换成mm/dd/yyyy怎么做？
```
var regex = /(d{4})-(d{2})-(d{2})/;
var string = "2017-06-12";
var result = string.replace(regex, "$2/$3/$1");
console.log(result); 
//  06/12/2017
```
其中replace中的，第二个参数里用$1、$2、$3指代相应的分组。等价于如下的形式：
```
var regex = /(d{4})-(d{2})-(d{2})/;
var string = "2017-06-12";
var result = string.replace(regex, function() {
    return RegExp.$2 + "/" + RegExp.$3 + "/" + RegExp.$1;
});
console.log(result); 
// 06/12/2017
```
也等价于：
```
var regex = /(d{4})-(d{2})-(d{2})/;
var string = "2017-06-12";
var result = string.replace(regex, function(match, year, month, day) {
    return month + "/" + day + "/" + year;
});
console.log(result);
// 06/12/2017
```
3. 反向引用

除了使用相应API来引用分组，也可以在正则本身里引用分组。但只能引用之前出现的分组，即反向引用。

还是以日期为例。

比如要写一个正则支持匹配如下三种格式：
```
2016-06-12

2016/06/12

2016.06.12
```
最先可能想到的正则是:
```
var regex = /d{4}(-|/|.)d{2}(-|/|.)d{2}/;
var string1 = "2017-06-12";
var string2 = "2017/06/12";
var string3 = "2017.06.12";
var string4 = "2016-06/12";
console.log( regex.test(string1) ); // true
console.log( regex.test(string2) ); // true
console.log( regex.test(string3) ); // true
console.log( regex.test(string4) ); // true
```
其中/和.需要转义。虽然匹配了要求的情况，但也匹配"2016-06/12"这样的数据。

假设我们想要求分割符前后一致怎么办？此时需要使用反向引用：
```
var regex = /d{4}(-|/|.)d{2}1d{2}/;
var string1 = "2017-06-12";
var string2 = "2017/06/12";
var string3 = "2017.06.12";
var string4 = "2016-06/12";
console.log( regex.test(string1) ); // true
console.log( regex.test(string2) ); // true
console.log( regex.test(string3) ); // true
console.log( regex.test(string4) ); // false
```
注意里面的1，表示的引用之前的那个分组(-|/|.)。不管它匹配到什么（比如-），1都匹配那个同样的具体某个字符。

我们知道了1的含义后，那么2和3的概念也就理解了，即分别指代第二个和第三个分组。

看到这里，此时，恐怕你会有三个问题。

3.1 括号嵌套怎么办？

以左括号（开括号）为准。比如：
```
var regex = /^((d)(d(d)))1234$/;
var string = "1231231233";
console.log( regex.test(string) ); // true
console.log( RegExp.$1 ); // 123
console.log( RegExp.$2 ); // 1
console.log( RegExp.$3 ); // 23
console.log( RegExp.$4 ); // 3
```
3.2 10表示什么呢？

另外一个疑问可能是，即10是表示第10个分组，还是1和0呢？

答案是前者，虽然一个正则里出现10比较罕见。测试如下：
```
var regex = /(1)(2)(3)(4)(5)(6)(7)(8)(9)(#) 10+/;
var string = "123456789# ######"
console.log( regex.test(string) );//true
```
3.3 引用不存在的分组会怎样？

因为反向引用，是引用前面的分组，但我们在正则里引用了不存在的分组时，此时正则不会报错，只是匹配反向引用的字符本身。例如2，就匹配"2"。注意"2"表示对"2"进行了转意。
```
var regex = /123456789/;
console.log( regex.test("123456789") ); //true
console.log( "123456789".split("") );//["", "", "", "", "", "", "", "8", "9"]
```
4. 非捕获分组

之前文中出现的分组，都会捕获它们匹配到的数据，以便后续引用，因此也称他们是捕获型分组。

如果只想要括号最原始的功能，但不会引用它，即，既不在API里引用，也不在正则里反向引用。此时可以使用非捕获分组(?:p)，例如本文第一个例子可以修改为：
```
var regex = /(?:ab)+/g;
var string = "ababa abbb ababab";
console.log( string.match(regex) );
// ["abab", "ab", "ababab"]
```
。
相关阅读:
PHP中文字符串编码转换
 html表单样式, table隔行高亮, 长字符串自动换行
 PHP带重试功能的curl
redis+crontab+php异步处理任务
 emoji表情初探
 iptables进行DNAT（目标地址转换）
Linux作为路由器（一）
nginx正向代理http（一）
Linux Shell sort排序常用命令（转载）
Zabbix添加自定义监控项（一）
原文地址：https://www.cnblogs.com/fqh123/p/14052037.html

正则表达式深入学习

目录

第一章 正则表达式字符匹配攻略

第二章 正则表达式位置匹配攻略

第三章 正则表达式括号的作用

第一章 正则表达式字符匹配攻略

1 两种模糊匹配

2. 字符组

3. 量词

4. 多选分支

第二章 正则表达式位置匹配攻略

1. 什么是位置呢？

2. 如何匹配位置呢？

3. 位置的特性

4. 相关案例

第三章 正则表达式括号的作用

1. 分组和分支结构

2. 引用分组

3. 反向引用

4. 非捕获分组

第一章正则表达式字符匹配攻略

第二章正则表达式位置匹配攻略

第三章正则表达式括号的作用

第一章正则表达式字符匹配攻略

第二章正则表达式位置匹配攻略

第三章正则表达式括号的作用