我所理解的正则表达式

摘要：关于，新手理解起来可能比较困难，尤其是一些很牛逼的预查正则表达式。非贪婪与贪婪的问题贪婪出现在这种不确定数量的匹配中，所谓的贪婪，表示正则表达式在匹配的时候，尽可能多的匹配符合条件的内容。

学习了半年的正则表达式，也不能说一直学习吧，就是和它一直在打交道，如何用正则表达式解决自己的问题，并且还要考虑如何在匹配大量的文本时去优化它。慢慢的觉得正则已经成为自己的一项技能，逐渐的从一个正则表达式小白变成一个伪精通者。

那么，我不打算详细介绍正则表达式的使用，或者说这篇文章并不是入门教程，所以如果你对正则表达式一无所知或者处于入门阶段，建议你还是先去看看下面这些正则表达式入门的文章。

阮一峰老师的正则教程
MDN 正则介绍
胡子哥正则表达式 30 分钟入门
阮一峰 ES6 正则表达式扩展
百度百科 正则表达式 很详细，可以当作手册参考

当然正则的教程很多，不限于此，如果你对正则已经了解了，那么可以开始下面的内容了，文章中可能还会涉及一些效率的问题。

如果写过 Python 的同学，都一定会知道 Python 中可以在字符串前面加个小写的 r ，来表示防止转义。防止转义的意思就是说：str = r" " 等价于 str = " "，加了 r 会防止 被转义。

为什么要介绍这个，因为这就是 new RegExp 和 // 的区别，因为我们知道在正则表达式中会频繁的使用转义字符 wsd 等，但是它们在内存中的是以 wsd 存储的，看个例子：

//推荐写法
var regex1 = /w+/g;
regex1 // /w+/g
//RegExp 写法
var regex2 = new RegExp("w+","g");
regex2 // /w+/g
//错误写法
var regex3 = new RegExp("w+","g");
regex3 // /w+/g

你也看出来了，错误写法只能匹配 wwwww 这样的字符串，曾经我就见过有人把他们弄混了，还说第一个第三个没有区别。第二种方法的输出，还是 /w+/g，中间还是要转换，所以推荐第一种写法。

当然，还有比较奇葩的：

var regex4 = new RegExp(/w+/g);
regex4 // /w+/g

MSDN 上关于 RegExp 的介绍。

那么，如何能像 Python 的 r"" 那样，实现一个防转义的功能呢？我这里有一种很蹩脚的方法(仅供娱乐！)：

var str1 = "dws";
str1; // "dws"
var str2 = /dws/;
str2.source; // "dws"

没错，就是 srouce，不知道 source 的同学快去面壁吧。(这方法确实很抠脚！)

这几个修饰符只是针对 JS 来说的，像 Python 中还有 re.S 表示 . 可以匹配换行符。

对于 i 表示忽略字母大小写，不是很常用，因为它有很多替代品，比如：/[a-zA-Z]/ 可以用来替代 /[a-z]/i，至于两者处理长文本的时间效率，我自己没有研究过，不下定论。

使用 i 需要注意的地方，就是 i 会对正则表达式的每一个字母都忽略大小写，当我们需要部分单词的时候，可以考虑一下/(?:t|T)he boy/。

g 表示全局匹配，在印象中，可能很多人会觉得全局匹配就是当使用 match 的时候，把所有符合正则表达式的文本全部匹配出来，这个用途确实很广泛，不过 g 还有其他更有意思的用途，那就是 lastIndex 参数。

var str = "1a2b3c4d5e6f",
    reg = /dwd/g;
str.match(reg); //["1a2", "3c4", "5e6"]

为什么不包括2b3,4d5，因为正则表达式匹配的时候，会用 lastIndex 来标记上次匹配的位置，正常情况下，已经匹配过的内容是不会参与到下次匹配中的。带有 g 修饰符时，可以通过正则对象的 lastIndex 属性指定开始搜索的位置，当然这仅仅局限于函数 exec 和 test(replace 没研究过，没听说过可以控制 lastIndex，match 返回的是数组，无法控制 lastIndex)，针对这个题目修改如下：

var str = "1a2b3c4d5e6f",
  reg = /dwd/g;
var a;
var arr = [];
while(a = reg.exec(str)){
  arr.push(a[0]);
  reg.lastIndex -= 1;
}
arr //["1a2", "2b3", "3c4", "4d5", "5e6"]

m 表示多行匹配，我发现很多人介绍 m 都只是一行略过，其实关于 m 还是很有意思的。首先，来了解一下单行模式，我们知道 JavaScript 正则表达式中的 . 是无法匹配 (换行，各个系统使用不一样) 的，像 Python 提供 re.S 表示 . 可以匹配任意字符，包括 ，在 JS 中如果想要表示匹配任意字符，只能用[sS] 这种蹩脚的方式了（还有更蹩脚的 [dD],[.s]）。这种模式叫做开启或关闭单行模式，可惜 JS 中无法来控制。

多行模式跟 ^ $ 两兄弟有关，如果你的正则表达式没有 ^$,即时你开启多行模式也是没用的。正常的理解/^123$/只能匹配字符串123，而开启多行模式/^123$/g能匹配["123"," 123","123 "," 123 "]，相对于 ^$ 可以匹配 了。

var str = "
a";
/^a/.test(str); //false
/^a/m.test(str); //true

有人说，m 没用。其实在某些特殊的格式下，你知道你要匹配的内容会紧接着 或以 结尾，这个时候 m 就非常有用，比如 HTTP 协议中的请求和响应，都是以 划分每一行的，响应头和响应体之间以 来划分，我们需要匹配的内容就在开头，通过多行匹配，可以很明显的提高匹配效率。

原理性的东西，我们还是要知道的，万一以后会用到。

在正则表达式中，括号不能乱用，因为括号就代表分组，在最终的匹配结果中，会被算入字匹配中，而 (?:) 就是来解决这个问题的，它的别名叫做非捕获分组。

var str = "Hello world!";
var regex = /Hello (w+)/;
regex.exec(str); //["Hello world", "world"]
var regex2 = /Hello (?:w+)/;
regex2.exec(str); //["Hello world"]
//replace 也一样
var regex3 = /(?:ab)(cd)/
"abcd".replace(regex3,"$1") //"cd"

可以看到 (?:) 并不会把括号里的内容计入到子分组中。

关于 (?=)，新手理解起来可能比较困难，尤其是一些很牛逼的预查正则表达式。其实还有个 (?!)，不过它和 (?=) 是属于一类的，叫做正向肯定(否定)预查，它还有很多别名比如零宽度正预测先行断言。但我觉得最重要的只要记住这两点，预查和非捕获。

预查的意思就是在之前匹配成功的基础上，在向后预查，看看是否符合预查的内容。正因为是预查，lastIndex 不会改变，且不会被捕获到总分组，更不会被捕获到子分组。

var str = "Hello world!";
var regex = /Hello (?=w+)/;
regex.exec(str); //["Hello "]

和 (?:) 区别是：我习惯的会把匹配的总结果叫做总分组，match 函数返回数组每一项都是总分组，exec 函数的返回数组的第一项是总分组。(?:) 会把括号里的内容计入总分组，(?=) 不会把括号里的内容计入总分组。

说白了，还是强大的 lastIndex 在起作用。(?:) 和 (?=) 差别是有的，使用的时候要合适的取舍。

说了这么多关于 (?=) 的内容，下面来点进阶吧！现在的需求是一串数字表示钱 "10000000"，但是在国际化的表示方法中，应该是隔三位有个逗号 "10,000,000"，给你一串没有逗号的，替换成有逗号的。

var str = "10000000";
var regex = /d(?=(d{3})+$)/g;
str.replace(regex, "$&,"); //"10,000,000"

我们分析一下 regex，/d(?=(d{3})+$)/g 它是全局 g，实际上它匹配的内容只有一个 d，(?=(d{3})+$) 是预判的内容，之前说过，预判的内容不计入匹配结果，lastIndex 还是停留在 d 的位置。(?=(d{3})+$) 到结尾有至少一组 3 个在一起的数字，才算预判成功。

d = 1 的时候，不满足预判，向后移一位，d = 0，满足预判，replace。

(?=) 和 (?!) 叫做正向预查，但往往是正向这个词把我们的思维给束缚住了。正向给人的感觉是只能在正则表达式后面来预判，那么预判为什么不能放在前面呢。下面这个例子也非常有意思。

一个简单密码的验证，要保证至少包含大写字母、小写字母、数字中的两种，且长度 8~20。

如果可以写多个正则，这个题目很简单，思路就是：/^[a-zA-Zd]{8,20}$/ && !(/[a-z]+/) && !(/[A-Z]+/) && !(/d+/)，看着眼都花了，好长一串。

下面用 (?!) 前瞻判断来实现：

var regex = /^(?![a-z]+$)(?![A-Z]+$)(?!d+$)[a-zA-Zd]{8,12}$/;
regex.test("12345678"); //false
regex.test("1234567a"); //true

分析一下，因为像 (?!) 预判不消耗 lastIndex，完全可以放到前面进行前瞻。(?![a-z]+$) 的意思就是从当前 lastIndex (就是^)开始一直到 $，不能全是小写字母，(?![A-Z]+$) 不能全是大写字母，(?!d+$) 不能全是数字，[a-zA-Zd]{8,12}$ 这个是主体，判断到这里的时候，lastIndex 的位置仍然是 0，这就是 (?!) 前瞻带来的效率。

我们都知道，JS 中的正则表达式是不支持正回顾后发断言的 (?<=)，当然也不支持 (?。有时候会觉得这种正回顾后发断言确实很有帮助，它可以让我们的思维更清晰，哪些是真正匹配的正则，哪些是断言的正则。在 Python 中我们就可以轻松的使用 (?<=)，但是在 JS 中不行。

var str = "a1b2c3d";
//var regex = /(?<=w)dw/g
//str.match(regex) => ["1b","2c","3d"]
var regex2 = /(?:w)dw/g
str.match(regex2); //["a1b", "c3d"]

var str = "a1b2c3d";
var regex = /(?:w)(dw)/g;
var m,arr = [];
while(m = regex.exec(str)){
  arr.push(m[1]);
  regex.lastIndex --;
}
arr; //["1b", "2c", "3d"]

RegExp对象 - 阮一峰
MSDN RegExp 
进阶正则表达式