javascript正则表达式总结(test|match|search|replace|split|exec)

exec ：对string进行正则处理,并返回匹配结果.array[0]为原字符串,array[i]为匹配在整个被搜索字符串中的位置。
test ：测试string是否包含有匹配结果，包含返回true，不包含返回false。
match (pattern) ：根据pattern进行正则匹配,如果匹配到,返回匹配结果,如匹配不到返回null
search (pattern) ：根据pattern进行正则匹配,如果匹配到一个结果,则返回它的索引数;否则返回-1
replace (pattern,replacement) ：根据pattern进行正则匹配,把匹配结果替换为replacement
split (pattern) ：根据pattern进行正则分割,返回一个分割的数组

用法介绍

注：pattern 为RegExp的实例, str 为String的实例

用法	说明	返回值
pattern.test(str)	判断str是否包含匹配结果	包含返回true，不包含返回false。
pattern.exec(str)	根据pattern对str进行正则匹配	返回匹配结果数组,如匹配不到返回null
str.match(pattern)	根据pattern对str进行正则匹配	返回匹配结果数组,如匹配不到返回null
str.replace(pattern, replacement)	根据pattern进行正则匹配,把匹配结果替换为replacement	一个新的字符串

RegExp对象方法

test()

字符串的test方法，比较常用在判断语句中，最简单的RegExp方法了，用于检测一个字符串是否匹配某个模式：

RegExpObject.test(string)

如果字符串 string 中含有与 RegExpObject 匹配的文本，则返回 true，否则返回 false：

/\d/.test('asdf2') // --true   检测字符串`'asdf2'`中是否函数数字

exec()

exec()方法功能非常强大，它是一个通用的方法方法，用于比较复杂的模式匹配或者是说你为你提供更多的信息：

RegExpObject.exec(string)

如果在string中找到了匹配的文本，则返回一个包含这些文本的数组，否侧返回null。这里有几个注意的地方：

1. 返回的数组的第一个元素是与整个正则匹配的文本
   然后数组的第二个元素是与整个正则的第一个子表达式(分组)相匹配的文本
   数组的第三个元素整个正则的第二个子表达式(分组)相匹配的文本，以此类推。

```
var result = /(\d+)-(\w+)/.exec('12-ab');
console.log(result) // --> ["12-ab", "12", "ab", index: 0, input: "12-ab"] 
//为什么上面返回的“数组”是那么奇怪，按照[w3school][2]的说法就是：exec() 都会把完整的细节添加到它返回的数组中，这里的细节指的就是index和input
```

整个正则表达式匹配的文本：`"12-ab"`
第一个子表达式匹配的文本：`"12"`
第二个子表达式匹配的文本：`"ab"`

1. 从上面返回的数组结果可知，数组添加了两个额外的属性，分别是：index, input
index: 匹配文本的第一个字符的位置.
   input: 顾名思义，就是指输入的整体的文本了.

   ```
   console.log(result.index) // --> 0
   console.log(result.input) // --> '12-ab'
   ```
   

2. 执行exec函数时，尽管是全局匹配的正则表达式，但是exec方法只对指定的字符串进行一次匹配，
   获取字符串中第一个与正则表达式想匹配的内容，并且将匹配内容和子匹配的结果存储到返回的数组中,
   例如：/\d/g.exec('a22') ，返回的结果和上面的结果一样： ["2"]

       /\d/g.exec('a22') // -->["2"]
   

深入了解 exec()

深入前看看RegExp的实例有哪些属性：

• global: 布尔值，表示是否设置了 g 标志

• ignoreCase: 布尔值，表示是否设置了 i 标志

• lastIndex: 搜索下一个匹配项时开始的位置，从0开始

• multiline: 布尔值，表示是否设置了 m 标志

• source: 正则表达式的字符串表示

这里稍微陌生一点的就是lastIndex属性了，因为我们不会显示的需要用到它。但它还是挺重要的：

例1：非全局匹配

var reg = /\d/;
//第一次匹配
console.log(reg.exec('a123'));
console.log(reg.lastIndex);
//输出
["1"]
  0
  
第二次匹配
console.log(reg.exec('a123'));
console.log(reg.lastIndex);
//输出
["1"]
  0 

结论：

1. 同一正则表达式，在非全局匹配模式下，每次实例的lastIndex属性的值总是不变的(为第一次找到匹配文本所在的位置，上面为0 )；

2. 每次的匹配查找都是将lastIndex作为起始位置的

例2：全局匹配

var reg = /\d/g;
//第一次匹配
console.log(reg.exec('a123'));
console.log(reg.lastIndex);
//输出
["1"]
  2
  
第二次匹配
console.log(reg.exec('a123'));
console.log(reg.lastIndex);
//输出
["2"]
  3 

第三次匹配
console.log(reg.exec('a123'));
console.log(reg.lastIndex);
//输出
["3"]
  4 

第四匹配
console.log(reg.exec('a123'));
console.log(reg.lastIndex);
//输出
null
  0

结论：

1. 同一正则表达式，在全局匹配模式下，每次实例的lastIndex属性的值为匹配文本最后一个字符的下一个位置，上面例子中第一次匹配的时候最后一个字符位置为1，则下一个位置为：2

2. 当 exec() 再也找不到匹配的文本时，它将返回 null，并把 lastIndex 属性重置为 0。

那当要获取全局匹配的全部匹配项时，可以通过循环来获取：

var reg = /\d/g,
    result = [],
    crt;
while((crt = reg.exec('a123')) !== null){
    result = result.concat(crt)
};
result; //["1", "2", "3"]

String对象方法

1. match()

match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。在一定程度上它与上面的exec()有些相似，看一下吧：

例1：非全局匹配

var a = 'aaaa'.match(/\w/);
console.log(a); // ["a", index: 0, input: "aaaa"]

可以看到，和exec()一样，在数组中返回了index 和 input属性。

例2：全局匹配

var a = 'aaaa'.match(/\w/g);
console.log(a); // ["a", "a", "a", "a"]

全局匹配就和exec方法有很大的不同了，他直接返回了所有符合匹配的子字符串的数组，另外，index和input属性也不在其中了，所以这个方法效率可能会高一些，但是如果你需要更多的信息，则用exec()吧

2. replace()

这也是一个比较灵活常用的方法，它用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

这个方法接收两个必须的参数：

• pattern: 这个参数可以是字符串或是RegExp对象

• replacement： 替换匹配项的字符串或处理函数的返回值

返回结果：

1. 当未找到匹配项的时候，返回原始字符串。

       'aaaa'.replace('bbb', 'b')     //"aaaa"
      

2. 当pattern为字符串或者为非全局的RegExp对象的时候，只替换找到的第一项匹配项。

       'aaaa'.replace('a', 'b')     //"baaa"
       'aaaa'.replace(/\w/, 'b')    //"baaa"
   

3. 当pattern为全局的RegExp对象的时候，替换每一项匹配项。

       'aaaa'.replace(/\w/g, 'b')    //"bbbb"
   

replacement：为函数时：

'aaaa'.replace(/\w/g, function() {
    return 'b';
}); // "bbbb"

'aaaa'.replace(/\w/g, function(value) {
    return value.toUpperCase();
}); // "AAAA"

结论：

1. 函数的返回值将作为替换字符串

2. 函数的第一个参数的值是每一个匹配项,当然还有第二个参数，它的值是每个匹配项在原始字符串的中位置，从0开始

特殊的 $:

replacement 中的 $ 字符具有特定的含义。如下表所示，它说明从模式匹配得到的字符串将用于替换。

字符	替换文本
1、 2、...、$99	与 regexp 中的第 1 到第 99 个子表达式相匹配的文本。
$&	与 regexp 相匹配的子串
$`	位于匹配子串左侧的文本
$'	位于匹配子串右侧的文本
$$	直接量符号

来一发：

//第一种情况：
'aa11AA'.replace(/([a-z]+)(\d+)([A-Z]+)/g, '$1'); // "aa"
'aa11AA'.replace(/([a-z]+)(\d+)([A-Z]+)/g, '$2'); // "11"
'aa11AA'.replace(/([a-z]+)(\d+)([A-Z]+)/g, '$3'); // "AA"
    //猜想 如果是 $4 回事什么呢？ undefined ? 
    'aa11AA'.replace(/([a-z]+)(\d+)([A-Z]+)/g, '$4'); // "$4"
    //所以，要是没有该子项，则当成普通字符串处理了
    
//第二种情况：
'aa11AA'.replace(/([a-z]+)(\d+)([A-Z]+)/g, '$&'); //"aa11AA"

//第三种情况：
'aa11AA'.replace(/(\d+)/g, '$`'); //"aaaaAA"

//第四种情况：
'aa11AA'.replace(/(\d+)/g, "$'"); //"aaAAAA"

//第五种情况：
'aa11AA'.replace(/(\d+)/g, '$$'); //"aa$AA"

定义和用法
test() 方法用于检测一个字符串是否匹配某个模式.

语法
RegExpObject.test(string)参数 描述 
string 必需。要检测的字符串。

返回值
如果字符串 string 中含有与 RegExpObject 匹配的文本，则返回 true，否则返回 false。

说明
调用 RegExp 对象 r 的 test() 方法，并为它传递字符串 s，与这个表示式是等价的：(r.exec(s) != null)。

1） test  检查指定的字符串是否存在

代码如下	复制代码
var data = "123123";        var reCat = /123/gi;        alert(reCat.test(data));  //true

     
       //检查字符是否存在  g 继续往下走  i 不区分大小写

2） exec 返回查询值 exec() 方法用于检索字符串中的正则表达式的匹配。

代码如下	复制代码
var data = "123123,213,12312,312,3,Cat,cat,dsfsdfs,";        var reCat = /cat/i;        alert(reCat.exec(data));  //Cat

说明
exec() 方法的功能非常强大，它是一个通用的方法，而且使用起来也比 test() 方法以及支持正则表达式的 String 对象的方法更为复杂。

如果 exec() 找到了匹配的文本，则返回一个结果数组。否则，返回 null。此数组的第 0 个元素是与正则表达式相匹配的文本，第 1 个元素是与 RegExpObject 的第 1 个子表达式相匹配的文本（如果有的话），第 2 个元素是与 RegExpObject 的第 2 个子表达式相匹配的文本（如果有的话），以此类推。除了数组元素和 length 属性之外，exec() 方法还返回两个属性。index 属性声明的是匹配文本的第一个字符的位置。input 属性则存放的是被检索的字符串 string。我们可以看得出，在调用非全局的 RegExp 对象的 exec() 方法时，返回的数组与调用方法 String.match() 返回的数组是相同的。

但是，当 RegExpObject 是一个全局正则表达式时，exec() 的行为就稍微复杂一些。它会在 RegExpObject 的 lastIndex 属性指定的字符处开始检索字符串 string。当 exec() 找到了与表达式相匹配的文本时，在匹配后，它将把 RegExpObject 的 lastIndex 属性设置为匹配文本的最后一个字符的下一个位置。这就是说，您可以通过反复调用 exec() 方法来遍历字符串中的所有匹配文本。当 exec() 再也找不到匹配的文本时，它将返回 null，并把 lastIndex 属性重置为 0。

3）match  得到查询数组

match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。

该方法类似 indexOf() 和 lastIndexOf()，但是它返回指定的值，而不是字符串的位置。

代码如下	复制代码
var data = "123123,213,12312,312,3,Cat,cat,dsfsdfs,";        var reCat = /cat/gi;        var arrMactches = data.match(reCat)        for (var i=0;i < arrMactches.length ; i++)        {             alert(arrMactches[i]);   //Cat  cat        }

match() 方法将检索字符串 stringObject，以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。

如果 regexp 没有标志 g，那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本， match() 将返回 null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。该数组的第 0 个元素存放的是匹配文本，而其余的元素存放的是与正则表达式的子表达式匹配的文本。除了这些常规的数组元素之外，返回的数组还含有两个对象属性。index 属性声明的是匹配文本的起始字符在 stringObject 中的位置，input 属性声明的是对 stringObject 的引用。

如果 regexp 具有标志 g，则 match() 方法将执行全局检索，找到 stringObject 中的所有匹配子字符串。若没有找到任何匹配的子串，则返回 null。如果找到了一个或多个匹配子串，则返回一个数组。不过全局匹配返回的数组的内容与前者大不相同，它的数组元素中存放的是 stringObject 中所有的匹配子串，而且也没有 index 属性或 input 属性。

4） search  返回搜索位置  类似于indexof

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

代码如下	复制代码
var data = "123123,213,12312,312,3,Cat,cat,dsfsdfs,"; var reCat = /cat/gi; alert(data.search(reCat));  //23

说明
search() 方法不执行全局匹配，它将忽略标志 g。它同时忽略 regexp 的 lastIndex 属性，并且总是从字符串的开始进行检索，这意味着它总是返回 stringObject 的第一个匹配的位置。

 5） replace  替换字符  利用正则替换

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

语法

stringObject.replace(regexp/substr,replacement)

例

代码如下	复制代码
var data = "123123,213,12312,312,3,Cat,cat,dsfsdfs,";        var reCat = /cat/gi;        alert(data.replace(reCat,"libinqq"));

字符串 stringObject 的 replace() 方法执行的是查找并替换的操作。它将在 stringObject 中查找与 regexp 相匹配的子字符串，然后用 replacement 来替换这些子串。如果 regexp 具有全局标志 g，那么 replace() 方法将替换所有匹配的子串。否则，它只替换第一个匹配子串。

replacement 可以是字符串，也可以是函数。如果它是字符串，那么每个匹配都将由字符串替换。但是 replacement 中的 $ 字符具有特定的含义。如下表所示，它说明从模式匹配得到的字符串将用于替换。

 

6）split   方法用于把一个字符串分割成字符串数组。

代码如下	复制代码
var data = "123123,213,12312,312,3,Cat,cat,dsfsdfs,";        var reCat = /,/;        var arrdata = data.split(reCat);        for (var i = 0; i < arrdata.length; i++)        {             alert(arrdata[i]);        }

返回值
一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 separator 自身。

但是，如果 separator 是包含子表达式的正则表达式，那么返回的数组中包括与这些子表达式匹配的字串（但不包括与整个正则表达式匹配的文本）。
提示和注释
注释：如果把空字符串 ("") 用作 separator，那么 stringObject 中的每个字符之间都会被分割。

注释：String.split() 执行的操作与 Array.join 执行的操作是相反的

3  学习下  简单类   负向类  范围类  组合类

代码如下

复制代码

//简单类        var data = "1libinqq,2libinqq,3libinqq,4libinqq";        var reCat = /[123]libinqq/gi;        var arrdata = data.match(reCat);        for (var i = 0; i < arrdata.length; i++)        {             alert(arrdata[i]);  // 1libinqq 2libinqq  3libinqq        }        //负向类        var data = "alibinqq,1libinqq,2libinqq,3libinqq,4libinqq";  //u0062cf        var reCat = /[^a123]libinqq/gi;        var arrdata = data.match(reCat);        for (var i = 0; i < arrdata.length; i++)        {             alert(arrdata[i]);  //4libinqq        }        //范围类        var data = "libinqq1,libinqq2,libinqq3,libinqq4,libinqq5";  //u0062cf        var reCat = /libinqq[2-3]/gi;        var arrdata = data.match(reCat);        for (var i = 0; i < arrdata.length; i++)        {             alert(arrdata[i]);   // libinqq2  libinqq3        }        //组合类       var data = "a,b,c,w,1,2,3,5";  //u0062cf        var reCat = /[a-q1-4n]/gi;        var arrdata = data.match(reCat);        for (var i = 0; i < arrdata.length; i++)        {             alert(arrdata[i]);  // a b c 1 2 3        }

test 方法

返回一个 Boolean 值，它指出在被查找的字符串中是否匹配给出的正则表达式。 
rgexp.test(str)

参数

rgexp 
必选项。包含正则表达式模式或可用标志的正则表达式对象。 
str 
必选项。要在其上测试查找的字符串。 
说明 
test 方法检查字符串是否与给出的正则表达式模式相匹配，如果是则返回 true，否则就返回 false。

每个正则表达式都有一个 lastIndex 属性，用于记录上一次匹配结束的位置

代码如下	复制代码
var re = /^[1-9]d{4,10}$/gi; var str = "123456"; alert(re.test(str));      //返回true

// 执行上面的 test 之后
我们可以弹出

代码如下	复制代码
alert(re.lastIndex); // 弹出6

即表示上一次在第6个字符之后结束

那么下一次再调用 test 的时候， 就会从第6个字符之后继续搜索

解决办法，将正则表达式的 lastIndex 属性设置为0

具体代码如下：

代码如下	复制代码
<script type="text/javascript"> var re = /^[1-9]d{4,10}$/gi; var str = "123456"; alert(re.test(str));      //返回true str = "1234567"; re.lastIndex=0; alert(re.test(str));      //返回true </script>

例2

代码如下	复制代码
function testDemo(){  var r, re; // 声明变量。  var s = "I";  re = /I/ig; // 创建正则表达式模式。  document.write(re.test(s) + "<br/>"); // 返回 Boolean 结果。  document.write(re.test(s) + "<br/>");  document.write(re.test(s));  }  testDemo(); 输出结果：   true  false  true

JavaScript表单验证email邮箱，判断一个输入量是否为邮箱email，通过正则表达式实现。
//检查email邮箱

代码如下

复制代码

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> <HTML> <HEAD> <TITLE>JavaScript表单验证email邮箱</TITLE> </HEAD> <BODY> <script language="javascript"> function check(){ var email=document.getElementById("email").value; var isemail=/^w+([-.]w+)*@w+([.-]w+)*.w{2,4}$/; if (email=="") {       alert("请输入您的邮箱!");       return false;     } if (email.length>25){      alert("长度太长");      return false } if (!isemail.test(email)){      alert("不是邮箱");     return false; } } </script> <FORM METHOD=POST ACTION="" οnsubmit="return check()"> <INPUT TYPE="text" NAME="email"><INPUT TYPE="submit"> </FORM> </BODY> </HTML>