一篇文章搞定 javascript 正则表达式

前言

正则表达式在平时工做中很是常见，可是它的神奇对于不少程序员可能一直像魔法同样的存在，工做中用到的大部分正则都是去网上搜索得来的，再复杂一点看着文档费时费力的拼凑一下。是否是深有感触了？一次在网上看到有关正则的视频，让我收货颇多，当时认真记录了笔记和本身的感悟，也但愿给更多须要的童鞋带来帮助。文章从零开始讲正则，致使有点长，能够收藏零碎时间慢慢看，认真看完绝对受益不浅。文章首发于个人博客，如下是正文：

Regular Expression 使用单个字符串来描述、匹配一系列符合某个语法规则的字符串。说简单了就是按照某种规则去匹配符合条件的字符串。这里先推荐一个学习正则表达式的在线工具：regexper.com/，网站利用图像和英文解…^\d{4}[/-]\d{2}[/-]\d{2}$在工具中是这样显示的：

是否是很是直观~

RegExp对象

javaScript中经过内置对象 RegExp 支持正则表达式，有两种方法实例化 RegExp 对象：

1. 字面量
2. 构造函数

1. 字面量

假设你须要把一句英文里面的小写is匹配成大写的 IS，你能够这样作：

var reg = /\bis\b/;
var text = 'He is a boy, This is a dog. Where is she?';
var result = text.replace(reg,'IS');
console.log(result) //He IS a boy, This is a dog. Where is she?
复制代码

这样就把第一个英文单词'is'替换成了'IS'，假如你想把该句中全部的单词'is'都替换成'IS',应该这样写：

var reg = /\bis\b/g;
var text = 'He is a boy, This is a dog. Where is she?';
var result = text.replace(reg,'IS');
console.log(result) //He IS a boy, This IS a dog. Where IS she?
复制代码

在正则的末尾加上'g'就好，'g'表示global，是全局匹配的意思。'g'是正则表达式的一个修饰符，修饰符有:

• 'g': global 全文搜索，不添加，搜索到第一个中止
• 'i': ignore case 忽略大小写，默认大小写敏感
• 'm': multiple 多行搜索 ，检测字符串中的换行符，主要是影响字符串开始标识符^和结束标识符$的使用

可能你会想，为何句子中的'This'中的is没有被匹配成功呢，这就是咱们'\b'的功劳了。

'\b':匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b”能够匹配“never”中的“er”，但不能匹配“verb”中的“er”。

这里的正则在'is'的先后都有'\b'，这样就只能匹配单词'is'了。

构造函数

假若你须要使用构造函数的方式实例化正则，则上面的字面量形式能够改为这样：

var reg = new RegExp('\\bis\\b','g');
var text = 'He is a boy, This is a dog. Where is she?';
var result = text.replace(reg,'IS');
console.log(result) //He IS a boy, This IS a dog. Where IS she?
复制代码

用这种方式就不须要'/'符号开始和结尾以表示是正则了。可是里面的'\'等特殊字符须要用'\'转义。

'\':将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“n”匹配字符“n”。“\n”匹配一个换行符。串行“\\”匹配“\”而“\(”则匹配“(”。

元字符

正则表达式由两种基本字符类型组成：

• 原义文本字符，即表明它本来含义的字符
• 元字符，元字符是在正则表达式中有特殊含义的非字母字符，例如上文提到的'\b'，表示匹配单词边界，并非匹配'\b'，在正则中主要存在这些特殊字符：*,+,?,$,^,.,|,\,(,),{,},[,]

字符类（字符集合）

通常状况下，正则表达式一个字符对应字符串一个字符，例如：ab\t就是匹配字符串'ab'+'tab'

可是更多的时候，咱们匹配的并非某个字符，而是符合一系列特征的字符串。这时候，咱们就可使用元字符'[]'来构建一个简单的类，所谓类是指符合某些特性的对象，一个泛指，而不是特指某个字符，例如：表达式'[abc]'把字符a或b或c归为一类，表达式能够匹配这样的字符。

var reg = /[abc]/g;
var text = 'a1b2c3d4';
var result = text.replace(reg,'X');
console.log(result); //X1X2X3d4
复制代码

这样咱们匹配的就是否是abc这样三个字符了，而是abc中任何一个字符，这就是元字符的一个应用。

字符类取反

使用元字符'^'建立 反向类/负向类。

反向类的意思是不属于类的内容，表达式'[^abc]'表示不是字符a或b或c的内容,例如：

var reg = /[^abc]/g;
var text = 'a1b2c3d4';
var result = text.replace(reg,'X');
console.log(result); //aXbXcXXX
复制代码

范围类

假若咱们须要用字符类匹配数字，按照前面的匹配方式，书写可能会很麻烦，须要这样：'[0123456789]'，对于 a 到 z 的字符更是如此。

为此，正则表达式给咱们提供了范围类，咱们可使用[a-z]来链接两个字符，表示从a到z的任意字符，这是一个闭区间，包含 a 和 z 自己。

var reg = /[a-z]/g;
var text = 'a1b2c3d4z9';
var result = text.replace(reg,'Q');
console.log(result); //Q1Q2Q3Q4Q9
复制代码

能够发现，这样就方便了许多。

此外，在'[]'组成的类的内部是能够连写的[a-zA-Z]，这样就造成了大写字母小写字母彻底匹配:

var reg = /[a-zA-Z]/g;
var text = 'a1b2c3d4z9ASDFHDFH';
var result = text.replace(reg,'Q');
console.log(result); //Q1Q2Q3Q4Q9QQQQQQQQ
复制代码

有些童鞋可能会想，我想连范围类里面的'-'字符也一块儿匹配了，咱们该怎么作？

其实也很简单，例如：

var reg = /[0-9]/g; //这样是跟前面同样的结果，不行
var text = '2018-05-13';
var result = text.replace(reg,'Q');
console.log(result); //QQQQ-QQ-QQ

var reg = /[0-9-]/g; //只要在后面另外加一个‘-’符号就能够了
var text = '2018-05-13';
var result1 = text.replace(reg,'Q');
console.log(result1); //QQQQQQQQQQ
复制代码

预约义类及边界

预约义类

正则表达式提供预预约义类来匹配常见的字符类，让咱们书写更方便。

字符	等价类	含义
.	[^\r\n]	除了回车符和换行符以外的全部字符
\d	[0-9]	数字字符
\D	[^0-9]	非数字字符
\s	[\t\n\x0B\f\r]	空白符
\S	[^\t\n\x0B\f\r]	非空白符
\w	[a-zA-Z_0-9]	单词字符（字母、数字、下划线）
\W	[^a-zA-Z_0-9]	非单词字符

digit 数字 '\d'， space空白 '\s'，word字母 '\w',大写取反，妈妈不再用担忧我记错了

来看一个实际的例子，匹配一个 ab+数字+任意字符 的字符串：

var reg = /ab\d./; //以前咱们可能会这样写：ab[0-9][^\r\n]
var text = 'absdlkjflab91323';
var result = text.replace(reg,'AAAA');
console.log(result); //absdlkjflAAAA323
复制代码

边界

除了预约义类，正则表达式还提供了几个经常使用的边界字符。

字符	等价类
^	以xxx开始
$	以xxx结束
\b	单词边界
\B	非单词边界

咱们在第一个例子中用到过'\b'单词边界，这里咱们作一个跟上面第一个例子相反的，只把'This'中的'is'替换为'IS'

var reg = /\Bis\b/g;
var text = 'He is a boy, This is a dog. Where is she?';
var result = text.replace(reg,'IS');
console.log(result) //He is a boy, ThIS is a dog. Where is she?
复制代码

而后咱们在说一下'^'和'$',在类'[]'中'^'表示取反，可是不在类中的时候'^'表示以xxx开始，'$'表示以xxx结束，这两个边界字符通常放在正则的开始和结束位置。

//先看没加^或$的状况
var reg = /@./g;
var text = '@123@ab@A';
var result = text.replace(reg,'Q');
console.log(result); //Q23QbQ

//添加^的状况
var reg = /^@./g;
var text = '@123@ab@A';
var result1 = text.replace(reg,'Q');
console.log(result1); //Q23@ab@A

//添加$的状况
var reg = /@.$/g;
var text = '@123@ab@A';
var result1 = text.replace(reg,'Q');
console.log(result1); //@123@abQ
复制代码

上面的例子，若是'^'和'$'都加上的话，是匹配不成功的，由于没有符号的字符串能够匹配成功，童鞋们能够本身试试。

这里再结合多行匹配举一个例子：

var reg = /^@\d./g;
var text= '@123\n@456\n@789';
var result = text.replace(reg,'Q');
console.log(result);// Q3 @456 @789
复制代码

这里你会发现，并无像咱们预期的把三行中符合预期的字符都替换成功，只有第一行成功匹配替换了，这是为何呢？

这是由于，换行符在咱们看来是换了一行写而已，可是对于程序处理字符串的时候，换行符就是一个普通的字符，并不算是咱们认为的新的一行。这时候咱们的修饰符'm'就能够大展身手了：

var reg = /^@\d./gm;
var text= '@123\n@456\n@789';
var result = text.replace(reg,'Q');
console.log(result);// Q3 @6 @9
复制代码

量词

假若咱们但愿匹配一个连续出现20次的数字的字符串，经过咱们以前学习的知识，咱们可能会写出连续20个'\d'。假如20次你还能够接受，那100次，1000次，甚至更屡次，你怎么办？

为了解决这个问题，正则表达式引入了量词的概念，下面是一些量词和他们的含义：

字符	含义
？	出现零次或一次（最多出现一次）
+	出现一次或者屡次（至少出现一次）
*	出现零次或者屡次（任意次）
{n}	出现n次
{n,m}	出现n到m次
{n,}	至少出现n次

咱们能够拿文章开始的日期正则举个栗子：

var reg = /\d{4}[/-]\d{2}[/-]\d{2}/g;
var text = '2018-02-23，2018/02/24，2018~02/25';
var result = text.replace(reg,'匹配正确日期格式');
console.log(result);//匹配正确日期格式，匹配正确日期格式，2018~02/25
复制代码

贪婪模式

正则表达式默认是贪婪模式，即每次匹配都尽量的匹配多的字符，直到匹配失败为止。

举个栗子：

var reg = /\d{3,6}/g;
var text = '12345678';
var result = text.replace(reg,'X');
console.log(result);//X78
复制代码

从上面能够看出，正则表达式匹配了'123456'，而不是'123','1234','12345'，尽量多的匹配了6次，即贪婪模式。

假若咱们但愿它只匹配3次，即尽量少的匹配，一旦匹配成功再也不继续尝试，即非贪婪模式须要怎么作呢？

很简单，在量词后面加上'?'便可,咱们再用刚才的例子试一下：

var reg = /\d{3,6}?/g;
var text = '12345678';
var result = text.replace(reg,'X');
console.log(result);//XX78
复制代码

分组

假如咱们有这么一个场景：匹配字符串 Byron 连续出现3次的场景，根据前面所学，咱们可能会这样写：Byron{3}。

可是这样是错误的，试试你会发现只有Byronnn才能匹配成功，即最后的n重复了3次，并不能匹配整个单词重复三次的状况：

var reg = /Byron{3}/g;
var text = 'ByronByronByronnn';
var result = text.replace(reg,'0');
console.log(result);//ByronByron0
复制代码

那么，咱们要怎么匹配Byron连续出现3次的状况呢，这时候，正则表达式的分组'()'就帮咱们解决了这个问题：

var reg = /(Byron){3}/g;
var text = 'ByronByronByronnn';
var result = text.replace(reg,'0');
console.log(result);//0nn
复制代码

或

有时候，咱们可能会须要在匹配时用到或者的关系，利用以前的'[]'字符类（字符集合）可能只能匹配单个字符的或者关系，好比匹配a或b，你能够这样写：'[ab]'，可是若是你须要匹配的是一整个单词的或者关系呢，可能'[]'就很差使了。这时候，咱们用'|'能够达到或的效果：

//匹配单词Byron或者Casper
var reg = /Byron|Casper/g;
var text = 'ByronCasper'
var result = text.replace(reg,'X');
console.log(result);//XX

//匹配Byr+on或Ca+sper
var reg = /Byr(on|Ca)sper/g;
var text = 'ByronsperByrCasper'
var result1 = text.replace(reg,'X');
console.log(result1);//XX
复制代码

反向引用

假如咱们有这样一个需求：把日期'2015-12-25'替换成'12/25/2015',若是是你，你如今会怎么作呢？

你可能会这样写：

var reg = /\d{4}-\d{2}-\d{2}/g;
var text = '2015-12-25'
var result = text.replace(reg,'12/25/2015');
console.log(result);//12/25/2015
复制代码

可是上面这样的写法，你只可以匹配到'2015-12-25'了，不能再匹配别的日期了，'2015-12-25'是会变的，这样就达不到需求了。

这时候，正则的反向引用就能够取到做用了。表达式在匹配时，表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录（分组捕获）下来。在获取匹配结果的时候，小括号包含的表达式所匹配到的字符串能够单独获取。

在js中正则匹配成功的字符串能够用$1表示第一次匹配成功，$3表示第三次匹配成功的字符，以此类推至$99）。因而，上面的例子就能够这样写了：

var reg = /(\d{4})-(\d{2})-(\d{2})/g;
var text = '2015-12-25'
var result = text.replace(reg,'$2/$3/$1');
console.log(result);//12/25/2015
复制代码

忽略分组

在上面的反向引用中，咱们默认是根据'()'所有捕获记录为$1~$99的，假若咱们想忽略某个捕获要怎么办呢？

不但愿捕获某些分组，只须要在分组内加上'?:'就能够了。

var reg = /(?:Byron)(\d{4})-(\d{2})-(\d{2})/g;
var text = 'Byron2016-12-05'
var result = text.replace(reg,'$2/$3/$1');
console.log(result);//12/05/2016
复制代码

这时候的$1不是Byron，而是2016了。

前瞻

正则表达式从文本头部向尾部开始解析，文本尾部方向称为“前”，前瞻就是在正则表达式匹配到规则的时候，向前检查是否符合断言，后顾/后瞻方向相反。

符合和不符合断言称为确定/正向匹配和否认/负向匹配。

上面是前瞻的概念，是否是看完有点晕？我看完也有点晕...我来解释一下：假如你须要匹配一个名字叫“张三”的人，之前咱们多是从一堆人中找出名字是“张三”的揪出来就好了，可是前瞻就是要求你，揪出的人的名字叫“张三”还不够，还必须“张三”的父亲必须叫“张二”或者其它特定条件，这样就是前瞻了，相似的，后瞻就是名字是张三还不够，儿子还必须叫“小张”等。

是否是有点明白了？不过须要注意的是，在javascript中是不支持后顾/后瞻的，因此咱们也不须要关心了。(这里纠正一下，在 ES2018(ES9) 中已经支持后瞻和命名分组了)

至于符合/不符合断言，能够解释为：好比匹配要求名字叫“张三”，而且呢他父亲不叫“张二”，对于符合的咱们就叫正向/确定匹配，不符合的就叫负向/否认匹配。

咱们再用表格说明一下：

名称	正则	含义
正向前瞻	exp(?=assert)	咱们匹配符合了exp部分的表达式，而后还不算完，必须也匹配断言部分（'()'内部，'='后面的正则），才算成功
负向前瞻	exp(?!assert)	咱们匹配符合了exp部分的表达式，而后还不算完，必须也匹配断言部分（'()'内部，'！'后面的正则），才算成功
正向后顾	exp(?<=assert)	javascript不支持
负向后顾	exp(?<!assert)	javascript不支持

如今是否是清楚了？若是还不够明白，没事，咱们再举个栗子：

var reg = /\w(?=\d)/g;
var text = 'a2*3';
var result = text.replace(reg,'X');
console.log(result);//X2*3
复制代码

须要注意，咱们断言里面内容只是做为匹配的条件之一，也是必须的条件，可是匹配的本质只匹配"()"前面的正则，因此上面的结果为：'X2*3',而不是'X*3'。若是要匹配结果为后者，咱们按原来的写法就好了var reg = /\w\d/g;，不是吗?

对象属性

咱们在用正则表达式相关的方法时，常常会用到正则表达式相关的一些对象属性，下面咱们总结一下正则表达式相关的对象属性：

• golbal: 是否全文搜索，默认false
• ignore case: 是否大小写敏感，默认false
• multiline: 多行搜索，默认false
• lastIndex: 是当前表达式匹配内容的最后一个字符的下一个位置
• source: 正则表达式的文本字符串

其中前面三个咱们在上文中已经提到过了，source的话，咱们一块儿结合起来看看代码：

var reg1 = /\w/;
var reg2 = /\w/gim;

console.log(reg1.global);//false
console.log(reg1.ignoreCase);//false
console.log(reg1.multiline);//false

console.log(reg2.global);//true
console.log(reg2.ignoreCase);//true
console.log(reg2.multiline);//true

console.log(reg1.source);//\w
console.log(reg2.source);//\w
复制代码

golbal、ignore case、multiline默认都是false,而source就是你写的正则字符串文本了。

至于lastIndex，咱们先来看一个例子：

var reg1 = /\w/;
var reg2 = /\w/g;

console.log(reg1.test('a'));//true
console.log(reg1.test('a'));//true
console.log(reg1.test('a'));//true
//... 无论执行多少次都是true

console.log(reg2.test('ab'));//true
console.log(reg2.test('ab'));//true
console.log(reg2.test('ab'));//false
console.log(reg2.test('ab'));//true
console.log(reg2.test('ab'));//true
console.log(reg2.test('ab'));//false
//... 循环true true false
复制代码

对于上面的结果，是否是很奇怪？这就是'lastIndex'做用的结果了，（至于test方法，不懂的童鞋能够往下翻一番）。咱们来输出'lastIndex'试试:

var reg2 = /\w/g;
while(reg2.test('ab')){
  console.log(reg2.lastIndex); // 1 2
}
复制代码

能够发现，'lastIndex'是在不断发生变化的，即当前匹配结果的最后一个字符的下一个位置，这里第一次匹配到'a'字符，匹配结果的最后一位字符也是'a','a'字符的下一个位置的index就是1了。相似的第二次匹配'b'，匹配结果的最后一位字符也是'b','b'字符的下一个位置的index就是2。如今再看看概念，是否是明白了许多？

因此说，正则每次匹配并非从头开始的，而是从上次的结果日后找，看看后面还有没有，有的话继续匹配，固然这必须是在'g'全局匹配的基础上，否则每次匹配都是从头开始的。

正则表达式RegExp对象自己的方法

RegExp对象自带的方法总共有三个：

1. test： 检索字符串中指定的值。返回 true 或 false
2. exec： 检索字符串中指定的值。返回找到的值，并肯定其位置
3. compile： 编译正则表达式（不经常使用）

test方法

test() 方法用于测试字符串参数中是否存在匹配正则表达式模式的字符串，若是存在则返回 true ,不然返回 false 。

语法为RegExpObject.test(string)，若是字符串 string 中含有与 RegExpObject 匹配的文本，则返回 true，不然返回 false。

举个栗子:

var str = "good good study, day day up";
var reg = new RegExp("study");
var result = reg.test(str);
console.log(result);//true
复制代码

exec方法

exec() 方法用于使用正则表达式模式对字符串执行搜索，并将更新全局 RegExp 对象的属性以反映匹配结果。

语法为RegExpObject.exec(string),若是字符串 string 中含有与 RegExpObject 匹配的文本,则返回一个数组，其中存放匹配的结果。若是未找到匹配，则返回值为 null。

而且，数组存在两个额外的属性：

1. index: 声明匹配文本的第一个字符的位置
2. input: 存放被检索的字符串 String

exec()方法比较复杂，全局调用和非全局调用的结果不一样：

非全局（即不带'g'）调用：

• 调用非全局的 RegExp 对象的exec()时，返回数组
• 数组中第一个元素是正则表达式匹配的文本
• 数组中第二个元素是与 RegExpObject 的第一个子表达式相匹配的文本（若是有的话）
• 数组中第三个元素是与 RegExp 对象的第二个子表达式相匹配的文本（若是有的话，以此类推

看起来是否是又有点晕？不怕，咱们来看看例子：

var reg3 = /\d(\w)\d/;
var str = '1a2b3c4d5e';
var arr = reg3.exec(str);
console.log(reg3.lastIndex + '\t' + arr.index + '\t' + arr.toString());//0 0 1a2,a
复制代码

即输出结果为： lastIndex(这里为0是由于非全局匹配下lastIndex实际上是不生效的),匹配文本的第一个字符的位置(额外属性index,这里第一个字符为'1')和匹配结果数组('1a2'为匹配文本，'a'为子表达式'(\w)'的匹配结果，这里不存在第二个子表达式'()'，因此数组里面没有第三个匹配结果的值)。是否是清楚了许多？

全局调用：

• exec() 会在 RegExpObject 的 lastIndex 属性指定的字符处开始检索字符串 string。
• 当 exec() 找到了与表达式相匹配的文本时，在匹配后，它将把 RegExpObject 的 lastIndex 属性设置为匹配文本的最后一个字符的下一个位置。
• 这就是说，你能够经过反复调用 exec() 方法来遍历字符串中的全部匹配文本。
• 当 exec() 再也找不到匹配的文本时，它将返回 null，并把 lastIndex 属性重置为 0。
• 注意：若是在一个字符串中完成了一次模式匹配以后要开始检索新的字符串，就必须手动地把 lastIndex 属性重置为 0。

咱们一样来举个栗子：

var reg4 = /\d(\w)(\w)\d/g;
var str = '$1az2bb3cy4dd5ee';

while(arr = reg4.exec(str)){
  console.log(reg4.lastIndex + '\t' + arr.index + '\t' + arr.toString());
  //5 1 1az2,a,z
  //11 7 3cy4,c,y
}
复制代码

这里我就不在解释结果的含义了，相信童鞋们看完上面的非全局的解释就能够理解这里全局的状况了。

compile方法

compile() 方法用于在脚本执行过程当中编译正则表达式，也可用于改变和从新编译正则表达式。这个咱们在平时工做中通常不会用到（我至今没看到过...）;

它的语法为：RegExpObject.compile(regexp,modifier)，其中参数'regexp'为正则表达式，参数'modifier'为规定匹配的类型。"g" 用于全局匹配，"i" 用于区分大小写，"gi" 用于全局区分大小写的匹配（摘录于W3C）。

咱们来看一个例子：

var str = "Every man in the world! Every woman on earth!";
var reg = /man/g;
var str2 = str.replace(reg,"person");
console.log(str2)

var reg2=/(wo)?man/g;
reg.compile(reg2);
console.log(reg.source);//(wo)?man 这里能够看到reg经过compile编译为reg2同样了
var str2=str.replace(reg,"person");
console.log(str2);
复制代码

上面的意思就是：在字符串中全局搜索 "man"，并用 "person" 替换。而后经过 compile() 方法，改变正则表达式reg为reg2，并继续利用正则改变后的正则表达式reg，用 "person" 替换 "man" 或 "woman"。

至于为何用compile动态改正则，那跟新建有啥区别呢？

我查了查资料是这么说的：若是指定的正则表达式须要屡次重复使用，那么编译正则表达式将会提升代码的执行效率，不过若是仅仅执行一次或者少数几回，那么将不会有明显的效果，compile提升了正则表达式的适应性！

支持正则表达式的 String 对象的方法

支持正则表达式的 String 对象的方法有：

• search： 检索与正则表达式相匹配的值
• match： 找到一个或多个正则表达式的匹配。
• replace： 替换与正则表达式匹配的子串。
• split： 把字符串分割为字符串数组。

search

search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式匹配的子字符串

语法为stringObject.search(regexp),结果返回 stringObject 中第一个与 regexp 相匹配的子串的起始位置index，若是没有找到任何匹配的子串，则返回 -1。

须要注意的是，search() 方法不执行全局匹配，它将忽略修饰符'g',而且老是从字符串的开始进行检索。

来看一个例子：

var str = 'a1b2c3d4';
console.log(str.search('1')); //1
console.log(str.search('10')); //-1
console.log(str.search(/b2/)); //2
console.log(str.search(/\w\d/g)); //0
console.log(str.search(/\w\d/g)); //0 忽略'g',执行屡次未返回不一样结果
复制代码

match

match() 方法将检索字符串，以找到一个或多个与 RegExp 匹配的文本，在 RegExp 是否有修饰符'g'影响很大。该方法相似 indexOf() 和 lastIndexOf()，可是它返回指定的值，而不是字符串的位置。

语法为stringObject.match(searchvalue)或stringObject.match(regexp)，结果返回存放匹配结果的数组。该数组的内容依赖于 regexp 是否具备全局标志 g。

match() 方法也分全局调用和非全局调用：

非全局调用

• 若是 regexp 没有标志 g ，那么 match() 方法就只能在字符串中执行匹配一次
• 若是没有找到任何匹配文本，返回 null
• 不然它将返回一个数组，其中存放了与它找到的匹配文本有关的信息：
• 数组的第 0 个元素存放的是匹配文本，而其他的元素存放的是与正则表达式的子表达式匹配的文本。（这里与前面说的exec()方法相似）

而且，数组也存在两个额外的属性（与 exec() 方法基本相同）：

1. index: 声明匹配文本的第一个字符的位置
2. input: 声明对 stringObject 的引用

下面是举例：

var reg3 = /\d(\w)\d/;
var str = '1a2b3c4d5e';
var arr = str.match(reg3);
console.log(reg3.lastIndex + '\t' + arr.index + '\t' + arr.toString());//0 0 1a2,a
复制代码

能够看到结果都与 exec() 方法同样，只是字符串和正则的位置交换了一下。

全局调用

全局调用就和 exec() 不一样了：

• 若是 regexp 具备标志 g 则 match() 方法将执行全局检索，找到字符串中全部匹配的子字符串
• 没有找到任何匹配的子字符串则返回 null
• 若是找到了一个或者多个匹配字串，则返回一个数组
• 数组元素中存放的是字符串中全部匹配的字串，并且也没有index属性和input属性

简单的说，就是返回一个数组，数组中放着全部匹配结果。

var reg4 = /\d(\w)(\w)\d/g;
var str = '$1az2bb3cy4dd5ee';
var arr = str.match(reg4)
console.log(arr); // ["1az2", "3cy4"]
console.log(reg4.lastIndex + '\t' + arr.index) //0 undefined
复制代码

能够看出，match() 方法功能没有 exec() 方法返回那么多各类信息，可是若是只要结果数组，match() 方法效率会高一些。

split

对于split()方法我就不详细说明了，咱们常常用它把字符串分割为数组。

var str = 'a,b,c,d';
var arr = str.split(',');
console.log(arr); //['a','b','c','d']
复制代码

可是你可能不知道，咱们在一些复杂状况下咱们可使用正则表达式解决

var str = 'a1b2c3d';
var arr = str.split(/\d/);
console.log(arr); //['a','b','c','d']
复制代码

上面可能还看不出 spilt() 方法用正则分割的有点，可是若是复杂一点的分割呢，好比：

var str = 'a1b&c|d&e';
var arr = str.split(/[\d|&]/);
console.log(arr); //['a','b','c','d','e']
复制代码

这样是否是看出了用正则的优点呢？

小知识：其实，咱们在用 split() 分割字符','的时候，split() 方法也是把',' 隐士转换成正则'/,/'的, search() 方法和 replace() 方法也是同样的。

replace

replace() 方法用于在字符串中用一些字符替换另外一些字符，或替换一个与正则表达式匹配的子串。

语法为stringObject.replace(regexp/substr,replacement),结果返回一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或全部匹配以后获得的。

对于 replace() 方法，它有三种使用方式：

1. String.prototype.replace(str,replaceStr);
2. String.prototype.replace(reg,replaceStr);
3. String.prototype.replace(reg,function);

1和2两种的使用我就再也不多举例了，相信若是你认真看完前面的文章，确定最熟悉的就是 replace() 方法了的1、二两种用法了。 这里就提一下第3种使用方法。

先说一下String.prototype.replace(reg,function);中 function 的参数含义,function 会在每次匹配替换的时候调用，有四个参数（第二个参数不固定）：

1. 匹配字符串
2. 正则表达式的分组内容，没有分组则没有该参数、
3. 匹配项在字符串中的 index
4. 原字符串

照例来举两个个栗子看看：

var str = 'a1b2c3d4e5';
var reg = /\d/g;
var arr = str.replace(reg,function(match, index, origin){
  console.log(index);// 1 3 5 7 9
  return parseInt(match) + 1;
})
console.log(arr);//a2b3c4d5e6 把每次匹配到的结果+1替换


var str = 'a1b2c3d4e5';
var reg = /(\d)(\w)(\d)/g;
var arr = str.replace(reg,function(match, group1, group2, group3, index, origin){
  console.log(match);// 1b2 3d4
  return group1 + group3;
})
console.log(arr);//a12c34e5 去除了每次匹配到的group2
复制代码

文章到这里就所有结束了,每一个例子都是实际测试输出结果,码了很久很久......但愿文章对您有帮助，我就心满意足了~~