在JavaScript中，正则表达式由RegExp对象表示。RegExp对象呢，又可以通过直接量和构造函数RegExp两种方式创建，分别如下：
//直接量 var re = /pattern/[g | i | m];
//构造函数 var re = new RegExp(["pattern", ["g" | "i" | "m"]]);
其中，末尾的可选字符（g、i和m）分别表示：
g： 模式执行一个全局匹配。简而言之，就是找到所有匹配，而不是在找到第一个之后就停止。
i： 模式执行不区分大小写的匹配。
m: 多行模式，^和$锚除了匹配字符串的开头和结尾外，还匹配每行的开头和结尾。例如，模式/Java$/m匹配"Java"和"Java\nScript"。
| 基础篇 |
--特殊字符--
在正则表达式中，所有的字母字符和数字都可以按照直接量与自身匹配，如/JavaScript/匹配的就是字符串"JavaScript"，但是有些特殊字符呢？如换行符。所以在JavaScript中规定以反斜杠（\）开头的转义序列支持这些特殊字符。常用的特殊字符如下：
|
转义字符 |
匹配 |
|
\n |
换行符 |
|
\r |
回车 |
|
\f |
换页符 |
|
\t |
制表符 |
|
\v |
垂直制表符 |
--字符类--
在正则表达式中，倘若将单独的字符放入方括号（[ ]）中，就可以组合成字符类。应用到匹配字符串中，我们可以将其看成一个漏斗，当字符串中的每个字符通过它时，都查找是否在这个类里面，如若在，就匹配成功，否则out。如下：
/*
match为字符串的方法，它的唯一参数就是一个正则表达式，
如果该正则表达式设置了标志g，该方法返回的数组包含的就是出现在字符串中的所有匹配。
详细的用法将在下面“正则表达式在String中的应用”细讲
*/
"abc".match(/[abc]/g);
匹配结果为：
如果我们的意愿是，想匹配除字符a、b、c之外的字符呢？我们可以定义一个否定类，只需将^符号放入[ ]中作为开头就OK啦。如下：
"abc".match(/[^abc]/g);
由于某些字符类经常用到，固JavaScript的正则表达式就用反斜杠（\）与一些特殊字符组合起来表示这些常用类，而不必再需要我们自行添加，如\d。
常用正则字符类如下：
|
字符类 |
匹配 |
例子 |
|
[ …] |
位于方括号之中的任意字符 |
/M[onke]y/ 匹配 "Moy" |
|
[ ^…] |
除包含在方括号之中的任意字符 |
/M[^onke]y/ 匹配 "May" |
|
. |
除换行符之外的任意字符 |
/../ 匹配 "Mo" |
|
\w |
字母、数字或下划线 |
/1\w/ 匹配 "1A" |
|
\W |
除字母、数字和下划线之外的字符 |
/1\W/ 匹配 "1%" |
|
\s |
单个空白字符 |
/M\sK/ 匹配 "M K" |
|
\S |
单个非空白字符 |
/M\SK/ 匹配 "M_K" |
|
\d |
0到9的数字 |
/\d/ 匹配 "1" |
|
\D |
非数字 |
/\D/ 匹配 "M" |
--重复匹配--
当我们需要匹配三位数字时，我们可以这样：/\d\d\d/，但是当我们需要匹配10位或者更多时呢？考虑到这一点，正则表达式为我们提供了重复字符{ n, m }，表示匹配前一项至少n次，但是不能超过m次。例如，刚才我们所说的匹配三位数字时，我们可以利用重复字符这样啦：/\d{3}/。
由于某些重复类型经常用到，so，正则规定一些特殊字符表示这些重复类型。
正则重复字符，详情见下：
|
字符 |
含义 |
例子 |
|
{n, m} |
匹配前一项至少n次，但不能超过m次 |
/\d{2,3}/ 匹配"12" |
|
{n, } |
匹配前一项至少n次，或者更多 |
/\d{2, }/ 匹配"123" |
|
{n} |
匹配前一项恰好n次 |
/\d{2}/ 匹配"12" |
|
？ |
匹配前一项0次或者1次，等价于{0,1} |
/\d?/ 匹配"2" |
|
+ |
匹配前一项1次或者多次，等价于{1, } |
/\d+/ 匹配"12" |
|
* |
匹配前一项0次或者多次，等价于{0, } |
/\d*/ 匹配"12" |
另，以上重复字符重复规则为：尽可能多的匹配，即俗称的“贪婪匹配”，如："aaaa".match(/a+/);匹配的就是整个字符串"aaaa"，而不是匹配到第一个字符a时，就放弃匹配。
那么，有所谓的"贪婪匹配"，就有"非贪婪匹配"，它的规则嘛，肯定与"贪婪匹配"相反咯，即：尽可能少的匹配。
那么，怎么才能触发非贪婪模式呢？
只需要在重复字符后加入?，就ok啦，如（{1, 4}?、+?等），如"aaaa".match(/a+?/);就只会匹配首个字符a咯。
注意，是尽可能少的匹配，而不是少的匹配哦。
神马意思？如下：
"aaab".match(/a*b/);
"aaab".match(/a*?b/);
！匹配结果都是"aaab"！
有没有点诧异，为什么"aaab".match(/a*?b/);的匹配结果会是"aaab"，而不是"ab"呢？
那是因为正则匹配都是从左往右的，就"aaab".match(/a*?b/);而言，当遇到首字符a时，它会继续往下匹配，直到能符合匹配模式/a*?b/为止，这就是为什么说是尽可能少的匹配，前提是满足匹配规则。
如"abbb".match(/ab*?/)的匹配结果就是"a"啦。
--字符 |、( )、(?: …)--
1.1、字符" | " 用于分隔，表示或。
什么意思？
举个栗子，如/ab | cd | ef/就可以匹配字符串"ab"或者"cd"或者"ef"。
是不是和字符类[ ]很像啊？
是的，如/a | b | c/和/[abc]/匹配效果是一样的哦。
But，字符类[ ]仅针对单个字符而言，而分隔字符" | "涉及更广，可以针对多个字符而言，如上述所说的/ab | cd | ef/，字符类就不行咯。
你可能会说，如果我想对利用" | "组装的类进行多次匹配呢？
加个括号就是啦。如：
/(ab | cd |ef)+/
好滴，说到括号，我们再来看看它的作用。非常强大哦。
--------------------------------------分割线 --------------------------------------
Linux 基础入门教程----正则表达式基础 http://www.linuxidc.com/Linux/2015-08/121441.htm
Linux正则表达式sed 详述 http://www.linuxidc.com/Linux/2015-04/116309.htm
Linux正则表达式特性及BRE与ERE的区别 http://www.linuxidc.com/Linux/2014-03/99152.htm
grep使用简明及正则表达式 http://www.linuxidc.com/Linux/2013-08/88534.htm
正则表达式的用法 http://www.linuxidc.com/Linux/2013-03/81897.htm
正则表达式之零宽断言 http://www.linuxidc.com/Linux/2013-03/81897.htm
Linux中正则表达式与文件格式化处理命令(awk/grep/sed) http://www.linuxidc.com/Linux/2013-03/81018.htm
基础正则表达式 http://www.linuxidc.com/Linux/2014-09/106296.htm
常用正则表达式整理 http://www.linuxidc.com/Linux/2014-10/108076.htm
--------------------------------------分割线 --------------------------------------
1.2、括号"( )"
括号的作用如下：
1、我们可以将一个单独的项目组合成一个子表达式，以便我们可以用|、*等来处理它。如，上诉所示的/(ab | cd | ef)+/。
2、利用括号括起来的部分，我们可以在正则表达式的后面引用前面用括号括起来的子表达式的匹配结果，注意是结果，而不是括起来的正则表达式。
针对第二点，有什么用呢？如我们有个需求，我想匹配在单引号或者双引号中的数字（’12345’）时，我们就可轻而易举利用这第二点，写好正则表达式，如下：
/([‘"])\d*\1/
测试结果如下：
好了，就第二点作用而言，结合上述demo，我们再来看看它的具体引用法则吧：
----以反斜杠\加数字的方式，引用前面带括号的子表达式，而这个数字呢指的就是第几个子表达式，计算规则为从左往右，计算遇到的左括号" ( "，到想引用的地方位置为止，无论在括号中还嵌套不嵌套括号。
测试Demo如下：
咦，倘若我只想让括号的作用为分组，而不想在后面计入引用呢？毕竟括号多了，不好计算呢。
那么，我们就来看看字符(?: …)咯。
1.3、(?: …)
(?: …)的作用就是，规定括号只用于分组，而不计入后面的引用，不好理解，看个demo就明白啦。如下：
/(Java(?:Script))(nice)/
如果我想在末尾引用子表达式nice，那么是\2，而不是\3咯，因为用(?: …)来分组滴，只管分组，而不引用，切记切记。
对(?: …)的测试demo如下：
--匹配位置--
在前面我们提到，创建正则对象时，可选字符m表示：多行模式，^和$锚除了匹配字符串的开头和结尾外，还匹配每行的开头和结尾。
那么这个^和$就是正则为我们提供的匹配位置，即所谓的锚。
例如：
将/JavaScript/变为/^JavaScript/，就只匹配字符串中开头为JavaScript的啦，如匹配"JavaScriptxxx"中的JavaScript，而不匹配"xxxJavaScript"中的JavaScript。
正则表达式中的锚字符详情见下：
|
字符 |
含义 |
|
^ |
匹配字符串的开头 |
|
$ |
匹配字符串的结尾 |
|
\b |
匹配一个词语的边界，指[a-zA-Z_0-9]之外的字符 |
|
\B |
匹配非词语边界位置 |
|
(? = p) |
正前向声明，exp1(?=exp2)，匹配后面是exp2的exp1 |
|
(? ! p) |
反前向声明，exp1(?!exp2)，匹配后面不是exp2的exp1 |
^和$好理解，但是\b、(?=)、(?!)可能比较陌生，结合上表，我们再来看看下面的demo就好啦。
对于\b的Demo如下：
对于(? = p)的Demo如下：
对于(? ! p)的Demo如下：
具体应用见 下一页
更多详情见请继续阅读下一页的精彩内容： http://www.linuxidc.com/Linux/2016-08/134160p2.htm
在JavaScript中，正则表达式由RegExp对象表示。RegExp对象呢，又可以通过直接量和构造函数RegExp两种方式创建，分别如下：
//直接量 var re = /pattern/[g | i | m];
//构造函数 var re = new RegExp(["pattern", ["g" | "i" | "m"]]);
其中，末尾的可选字符（g、i和m）分别表示：
g： 模式执行一个全局匹配。简而言之，就是找到所有匹配，而不是在找到第一个之后就停止。
i： 模式执行不区分大小写的匹配。
m: 多行模式，^和$锚除了匹配字符串的开头和结尾外，还匹配每行的开头和结尾。例如，模式/Java$/m匹配"Java"和"Java\nScript"。
| 基础篇 |
--特殊字符--
在正则表达式中，所有的字母字符和数字都可以按照直接量与自身匹配，如/JavaScript/匹配的就是字符串"JavaScript"，但是有些特殊字符呢？如换行符。所以在JavaScript中规定以反斜杠（\）开头的转义序列支持这些特殊字符。常用的特殊字符如下：
|
转义字符 |
匹配 |
|
\n |
换行符 |
|
\r |
回车 |
|
\f |
换页符 |
|
\t |
制表符 |
|
\v |
垂直制表符 |
--字符类--
在正则表达式中，倘若将单独的字符放入方括号（[ ]）中，就可以组合成字符类。应用到匹配字符串中，我们可以将其看成一个漏斗，当字符串中的每个字符通过它时，都查找是否在这个类里面，如若在，就匹配成功，否则out。如下：
/*
match为字符串的方法，它的唯一参数就是一个正则表达式，
如果该正则表达式设置了标志g，该方法返回的数组包含的就是出现在字符串中的所有匹配。
详细的用法将在下面“正则表达式在String中的应用”细讲
*/
"abc".match(/[abc]/g);
匹配结果为：
如果我们的意愿是，想匹配除字符a、b、c之外的字符呢？我们可以定义一个否定类，只需将^符号放入[ ]中作为开头就OK啦。如下：
"abc".match(/[^abc]/g);
由于某些字符类经常用到，固JavaScript的正则表达式就用反斜杠（\）与一些特殊字符组合起来表示这些常用类，而不必再需要我们自行添加，如\d。
常用正则字符类如下：
|
字符类 |
匹配 |
例子 |
|
[ …] |
位于方括号之中的任意字符 |
/M[onke]y/ 匹配 "Moy" |
|
[ ^…] |
除包含在方括号之中的任意字符 |
/M[^onke]y/ 匹配 "May" |
|
. |
除换行符之外的任意字符 |
/../ 匹配 "Mo" |
|
\w |
字母、数字或下划线 |
/1\w/ 匹配 "1A" |
|
\W |
除字母、数字和下划线之外的字符 |
/1\W/ 匹配 "1%" |
|
\s |
单个空白字符 |
/M\sK/ 匹配 "M K" |
|
\S |
单个非空白字符 |
/M\SK/ 匹配 "M_K" |
|
\d |
0到9的数字 |
/\d/ 匹配 "1" |
|
\D |
非数字 |
/\D/ 匹配 "M" |
--重复匹配--
当我们需要匹配三位数字时，我们可以这样：/\d\d\d/，但是当我们需要匹配10位或者更多时呢？考虑到这一点，正则表达式为我们提供了重复字符{ n, m }，表示匹配前一项至少n次，但是不能超过m次。例如，刚才我们所说的匹配三位数字时，我们可以利用重复字符这样啦：/\d{3}/。
由于某些重复类型经常用到，so，正则规定一些特殊字符表示这些重复类型。
正则重复字符，详情见下：
|
字符 |
含义 |
例子 |
|
{n, m} |
匹配前一项至少n次，但不能超过m次 |
/\d{2,3}/ 匹配"12" |
|
{n, } |
匹配前一项至少n次，或者更多 |
/\d{2, }/ 匹配"123" |
|
{n} |
匹配前一项恰好n次 |
/\d{2}/ 匹配"12" |
|
？ |
匹配前一项0次或者1次，等价于{0,1} |
/\d?/ 匹配"2" |
|
+ |
匹配前一项1次或者多次，等价于{1, } |
/\d+/ 匹配"12" |
|
* |
匹配前一项0次或者多次，等价于{0, } |
/\d*/ 匹配"12" |
另，以上重复字符重复规则为：尽可能多的匹配，即俗称的“贪婪匹配”，如："aaaa".match(/a+/);匹配的就是整个字符串"aaaa"，而不是匹配到第一个字符a时，就放弃匹配。
那么，有所谓的"贪婪匹配"，就有"非贪婪匹配"，它的规则嘛，肯定与"贪婪匹配"相反咯，即：尽可能少的匹配。
那么，怎么才能触发非贪婪模式呢？
只需要在重复字符后加入?，就ok啦，如（{1, 4}?、+?等），如"aaaa".match(/a+?/);就只会匹配首个字符a咯。
注意，是尽可能少的匹配，而不是少的匹配哦。
神马意思？如下：
"aaab".match(/a*b/);
"aaab".match(/a*?b/);
！匹配结果都是"aaab"！
有没有点诧异，为什么"aaab".match(/a*?b/);的匹配结果会是"aaab"，而不是"ab"呢？
那是因为正则匹配都是从左往右的，就"aaab".match(/a*?b/);而言，当遇到首字符a时，它会继续往下匹配，直到能符合匹配模式/a*?b/为止，这就是为什么说是尽可能少的匹配，前提是满足匹配规则。
如"abbb".match(/ab*?/)的匹配结果就是"a"啦。
--字符 |、( )、(?: …)--
1.1、字符" | " 用于分隔，表示或。
什么意思？
举个栗子，如/ab | cd | ef/就可以匹配字符串"ab"或者"cd"或者"ef"。
是不是和字符类[ ]很像啊？
是的，如/a | b | c/和/[abc]/匹配效果是一样的哦。
But，字符类[ ]仅针对单个字符而言，而分隔字符" | "涉及更广，可以针对多个字符而言，如上述所说的/ab | cd | ef/，字符类就不行咯。
你可能会说，如果我想对利用" | "组装的类进行多次匹配呢？
加个括号就是啦。如：
/(ab | cd |ef)+/
好滴，说到括号，我们再来看看它的作用。非常强大哦。
--------------------------------------分割线 --------------------------------------
Linux 基础入门教程----正则表达式基础 http://www.linuxidc.com/Linux/2015-08/121441.htm
Linux正则表达式sed 详述 http://www.linuxidc.com/Linux/2015-04/116309.htm
Linux正则表达式特性及BRE与ERE的区别 http://www.linuxidc.com/Linux/2014-03/99152.htm
grep使用简明及正则表达式 http://www.linuxidc.com/Linux/2013-08/88534.htm
正则表达式的用法 http://www.linuxidc.com/Linux/2013-03/81897.htm
正则表达式之零宽断言 http://www.linuxidc.com/Linux/2013-03/81897.htm
Linux中正则表达式与文件格式化处理命令(awk/grep/sed) http://www.linuxidc.com/Linux/2013-03/81018.htm
基础正则表达式 http://www.linuxidc.com/Linux/2014-09/106296.htm
常用正则表达式整理 http://www.linuxidc.com/Linux/2014-10/108076.htm
--------------------------------------分割线 --------------------------------------
1.2、括号"( )"
括号的作用如下：
1、我们可以将一个单独的项目组合成一个子表达式，以便我们可以用|、*等来处理它。如，上诉所示的/(ab | cd | ef)+/。
2、利用括号括起来的部分，我们可以在正则表达式的后面引用前面用括号括起来的子表达式的匹配结果，注意是结果，而不是括起来的正则表达式。
针对第二点，有什么用呢？如我们有个需求，我想匹配在单引号或者双引号中的数字（’12345’）时，我们就可轻而易举利用这第二点，写好正则表达式，如下：
/([‘"])\d*\1/
测试结果如下：
好了，就第二点作用而言，结合上述demo，我们再来看看它的具体引用法则吧：
----以反斜杠\加数字的方式，引用前面带括号的子表达式，而这个数字呢指的就是第几个子表达式，计算规则为从左往右，计算遇到的左括号" ( "，到想引用的地方位置为止，无论在括号中还嵌套不嵌套括号。
测试Demo如下：
咦，倘若我只想让括号的作用为分组，而不想在后面计入引用呢？毕竟括号多了，不好计算呢。
那么，我们就来看看字符(?: …)咯。
1.3、(?: …)
(?: …)的作用就是，规定括号只用于分组，而不计入后面的引用，不好理解，看个demo就明白啦。如下：
/(Java(?:Script))(nice)/
如果我想在末尾引用子表达式nice，那么是\2，而不是\3咯，因为用(?: …)来分组滴，只管分组，而不引用，切记切记。
对(?: …)的测试demo如下：
--匹配位置--
在前面我们提到，创建正则对象时，可选字符m表示：多行模式，^和$锚除了匹配字符串的开头和结尾外，还匹配每行的开头和结尾。
那么这个^和$就是正则为我们提供的匹配位置，即所谓的锚。
例如：
将/JavaScript/变为/^JavaScript/，就只匹配字符串中开头为JavaScript的啦，如匹配"JavaScriptxxx"中的JavaScript，而不匹配"xxxJavaScript"中的JavaScript。
正则表达式中的锚字符详情见下：
|
字符 |
含义 |
|
^ |
匹配字符串的开头 |
|
$ |
匹配字符串的结尾 |
|
\b |
匹配一个词语的边界，指[a-zA-Z_0-9]之外的字符 |
|
\B |
匹配非词语边界位置 |
|
(? = p) |
正前向声明，exp1(?=exp2)，匹配后面是exp2的exp1 |
|
(? ! p) |
反前向声明，exp1(?!exp2)，匹配后面不是exp2的exp1 |
^和$好理解，但是\b、(?=)、(?!)可能比较陌生，结合上表，我们再来看看下面的demo就好啦。
对于\b的Demo如下：
对于(? = p)的Demo如下：
对于(? ! p)的Demo如下：
具体应用见 下一页
更多详情见请继续阅读下一页的精彩内容： http://www.linuxidc.com/Linux/2016-08/134160p2.htm
| 正则在String类中的应用 |
类String支持四种利用正则表达式的方法。分别是search、replace、match和split方法。下面将一一讲述。
--String.search(regexp)--
search相对于其他三个方法，是应用正则最简单的方法啦，作用就是根据参数regexp查找相应匹配模式。
具体如下：
方法search中的参数为正则表达式对象，倘若我们赋予的值不是正则表达式对象，而是字符串，那么search在内部首先得将传入的字符串转换成正则表达式对象，然后再给予匹配。匹配始终从字符串的初始位置开始，当找到第一个与正则表达式相匹配的字符时，就停止匹配，并返回匹配到的子串的起始位置。如果没有找到就返回-1。
注意：search找到第一个匹配结果后，就停止，并不会继续查找，so，标志g对它无效！
Demo如下：
--String.split(delimiter, limit)--
方法split，根据传入的delimiter参数，分割字符串，并返回一个分割后的字符串数组。
例如：
指定的分隔符delimiter，可以是字符串，也可以是正则表达式。如上所示。
咦，不是还有一个参数limit吗？它的作用为啥子呢？
这个可选参数limit，为整数，限定返回数组的最大长度。如下：
--String.replace(match, replacement)--
replace方法的作用为：根据match指定的规则，查找字符串，如果找到匹配结果，就用第二个参数replacement去替换。倘若match为regexp对象，并指定了全局搜索标志g，那么将对全局查找替换，而不是在找到第一个匹配后，就停止操作。
So，参数match可以是RegExp对象，也可以是字符串，但是字符串因为没有规定全局搜索标志，所以如果match为字符串，那么当找到第一个匹配替换后，就停止查找。
例如：
你以为replace方法就这么结束了？No，No，No。
还记得在前面一页中提到的括弧（）的作用么？
括弧可以将需要在后续使用的内容，作为子表达式括起来，在正则表达式中可以利用反斜杠\加数字，对前面的子表达式引用。replace方法也有这么一功能，当然前提是参数match为RegExp对象，它是使用美元符$加相应的数字来引用，数字计算规则不变。
如下：
另，replace的第二个参数replacement不仅可以为字符串，还可以是函数哦。当字符串中与参数match匹配成功后，就调用这个replacement回调函数。
如我想将字符串中的所有单词的第一个字母都大写，那么利用replacement函数可以这样：
是不是很屌。
我们再细看看，这个回调函数的参数都有哪些，如下：
第一个参数就是匹配字符串，如上面的demo；
第二个参数是正则表达式中的子表达式（括号啦），没有子表达式，则没有该参数
第三个参数是整数，声明了匹配项出现在字符串中的位置；
第四个参数则是原字符串
--String.match(regexp)--
match方法返回与regexp相匹配结果的数组。参数regexp为RegExp对象，如果传入的参数不为RegExp对象，则match内部首先将其转换成RegExp对象。
注意：match方法返回的数组，与传入的参数regexp带不带全局搜索标志g，区别是非常大的。下面将进行说明。
1、 如果regexp不带标志g，那么match方法根据参数regexp匹配到首个子串后，就将停止继续往下查找匹配；如果一个匹配也没找到就返回null。
如下：
你以为就这么结束了么？No，No，No。
强大之处在于：如果你正则表达式中有子表达式（括号啦），那么返回的数组arr中，还包括这些与子表达式匹配的结果哦。arr[0]为匹配的文本，arr[1]为匹配的第一个子表达式，如此类推。
如下：
2、 如果regexp带有执行全局搜索标志g，那么match方法将返回所有与参数regexp匹配的所有结果的数组。
如下：
| RegExp对象中exec和test方法 |
RegExp对象定义了两个用于执行模式匹配操作的方法：exec和test。下面将一一讲述。
--RegExp.exec(string)--
exec方法检索参数string，当有匹配结果时，返回一个数组。没有找到匹配结果时，则返回null。exec方法的调用分为两种：
1、 当RegExp中没有全局搜索标志g时，那么返回结果和String.match方法一样：返回的数组arr中，arr[0]为匹配的文本，如果有子表达式，那么arr[1]…就表示这些子表达式。并且将lastIndex置为0。注：lastIndex为RegExp对象的属性。
如下：
2、 当RegExp中有全局搜索标志g时，那么返回的结果还是和String.match一样。咦，什么套路？
不过，区别在于它会将RegExp对象的属性lastIndex置为紧接着上次找到匹配文本的字符位置，而不是为0。
如下：
那这点不同有什么用呢？
那就得看看lastIndex的作用咯。每次当，利用exec或者test方法检索字符串时，他们都是从lastIndex的位置为起点向后检索。
如下：
所以，当RegExp中有全局搜索标志g时，它将lastIndex置为紧接着上次找到匹配文本的字符位置，那么我们就可以循环检索字符串了。
如下：
--RegExp.test(string)--
test方法检测参数string字符串，是否含有匹配文本，如果有，则返回true，否则为false。RegExp中带没带全局搜索标志g的区别在于，对象的属性lastIndex。如果不带g，则lastIndex为0，否则将lastIndex置为紧接着上次找到匹配文本的字符位置。
如下：
好了，梳理JavaScipt中的正则表达式就到此结束啦~
本文永久更新链接地址：http://www.linuxidc.com/Linux/2016-08/134160.htm