19、javascript正则表达式详解（二）

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

stringObject.search (regexp )

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

返回stringObject 中第一个与 regexp 相匹配的子串的起始位置。如果没有找到任何匹配的子串，则返回 -1。

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

stringObject.replace (regexp,replacement )

第一个参数可以是字符串，也可以是正则式。

如果 regexp 具有全局标志 g，那么 replace() 方法将替换所有匹配的子串 。否则，它只替换第一个匹配子串。

replacement 可以是字符串，也可以是函数。
replacement 中的 $ 字符具有特定的含义。如下表所示：

 

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

 

注意：ECMAScript v3 规定，replace() 方法的参数 replacement 可以是函数而不是字符串。在这种情况下，每个匹配都调用该函数，它返回的字符串将作为替换文本使用。该函数的第一个参数是匹配模式的字符串。接下来的参数是与模式中的子表达式匹配的字符串，可以有 0 个或多个这样的参数。接下来的参数是一个整数，声明了匹配在 stringObject 中出现的位置。最后一个参数是 stringObject 本身。

var str = '1234';
var regExp = /((\d{2})(\d{2}))/g;
function replaceFun(){
	for(var i = 0; i < arguments.length; i++){
		//依次打印:1234 1234 12 34 0 1234
		alert(arguments[i]);
	}
}
str.replace(regExp,replaceFun);

 

//----------------------------------------stringObject.replace()
function testStringRep(){
    
    //--replace all spaces
    var str = ' 32  ';
    alert(str.replace(/^\s*(.*?)\s*$/, "$1")); //32
    
    //--双引号换成单引号
    str = '"a", "b"';
    alert(str.replace(/"([^"]*)"/g, "'$1'")); //'a','b'
    
    //--互换
    str = "Doe, John";    
    alert(str.replace(/(\w+)\s*, \s*(\w+)/, "$2 $1"));//John Doe
    
    //--首字母大写，转换采用函数
    str = 'hello world';
    alert(str.replace(/\b\w+\b/g, function(word){
        return word.substring(0,1).toUpperCase()+word.substring(1);}
        ));//Hello World
    
    //--'$ \'替换成'\ $'
    /*java中 '$ \' 转 '\ $':因为\与$在替换时有特殊意思，$是引用捕获组，
        而\则又是转义$用的，所以如果要替换\需要用'\\\\'代替，$用'\\$'代替
        但javascript好像不需要
        String str = "$ \\";
        System.out.println(str.replaceAll("\\$(\\W)\\\\", "\\\\$1\\$"));
    */    
    str = '$ \\';
    alert(str.replace(/\$(\W)\\/,'\\$1$'));//\ $
    
    //-- $&
    str = "1,2";
    alert(str.replace(/\d+/g,'$&$&'));//11,22
    
    //-- $` $'
    str = "Doe John";
    alert(str.replace(/(\W)+/,"$'$1$`"));//DonJohn DonJohn
    
    //-- $$ (只用一个也是可以的)
    str = "?";
    alert(str.replace(/\?/,'$$'));//$
    
    //--去掉粗暴的单词并用相同个数*替换
    var str = 'fuck you, fuck a duck, sex ';    
    alert(str.replace(/fuck|sex/g, function(word){
        return word.replace(/./g,'*');}
    ));//**** you, **** a duck, ***    
}
testStringRep();

stringObject.split (separator,howmany )

参数	描述
separator	必需。字符串或正则表达式，从该参数指定的地方分割 stringObject 。
howmany	可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

var str="How are you doing today?"     
document.write(str.split(" ") + "<br />")     
document.write(str.split("") + "<br />")     
document.write(str.split(" ",3))     
  
/*  
How,are,you,doing,today? H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,? How,are,you   
*/  
  
//把单词分割为字母，或者把字符串分割为字符     
"hello".split("") //可返回 ["h", "e", "l", "l", "o"]     
  
//只需要返回一部分字符，请使用 howmany 参数     
"hello".split("", 3) //可返回 ["h", "e", "l"]    

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

stringObject.match (regexp )

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

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

 

function testStringMatch(){
    var str = "aabbccddeeffgghh";

    //不加全局标示g时
    var regexp = /(([a-z]{2})([a-z]{2}))/;
    
    //第一次匹配
    var arr = str.match(regexp);
    /*
        此属性为IE、FireFox标准属性，但是IE输出4、fireFox输出0，
        IE不是太标准，因为此非全局正则式，所以应该为0
    */
    alert(regexp.lastIndex);
    for(name in arr){
        alert('arr[' + name + ']='+ arr[name]);
    }    
    /*输出：
        arr[input]=aabbccddeeffgghh
        arr[index]=0
        arr[lastIndex]=4//注：FireFox上运行时返回数组没有此属性(非标准属性)，IE上有
        arr[0]=aabb//数组的0元素包含了完整的匹配，
        arr[1]=aabb//而第1到n元素中包含的是匹配中出现的任意一个子匹配。个数为括号数量
        arr[2]=aa
        arr[3]=bb
    */
    alert('------------------');
    //match()方法执行后会更新RegExp对象，RegExp.$1..9 ，此静态属性也为标准属性，一般浏览都有
    alert('RegExp.$1 = ' + RegExp.$1);//aabb
    alert('RegExp.$2 = ' + RegExp.$2);//aa
    alert('RegExp.$3 = ' + RegExp.$3);//bb
    
    alert('------------------');
    //第二次匹配
    arr =str.match(regexp);
    //可以看出还是从头开始匹配的
    alert(regexp.lastIndex);//4
    for(name in arr){
        alert('arr[' + name + ']='+ arr[name]);
    }
    /*输出：注，match()方法每次会从头匹配，而不管是否有G标示
        arr[input]=aabbccddeeffgghh
        arr[index]=0
        arr[lastIndex]=4
        arr[0]=aabb
        arr[1]=aabb
        arr[2]=aa
        arr[3]=bb
    */
    alert('RegExp.$1 = ' + RegExp.$1);//aabb
    alert('RegExp.$2 = ' + RegExp.$2);//aa
    alert('RegExp.$3 = ' + RegExp.$3);//bb
}
testStringMatch();

 

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

注意：在全局检索模式下，match() 即不提供与子表达式匹配的文本的信息，也不存储每个匹配子串的位置。如果您需要这些全局检索的信息，可以使用 RegExp.exec()。

G标示对stringObject.match()匹配没有影响，第二次匹配时还是从字符串的第一个字符开始匹配 。在IE中 只是 匹配后修改正则式的lastIndex属性值。

function testStringMatchG(){
    var str = "aabbccddeeffgghh";
    //加全局标示g时
    var regexp = /(([a-z]{2})([a-z]{2}))/g;
    
    //第一次匹配
    var arr = str.match(regexp);
    
    //IE 输出:16 ，为最后一个匹配字符的下一位置
    //FireFox还是输出:0，即string.match(全局正则式)不影响正则式对象的lastIndex
    alert('first -- ' + regexp.lastIndex);
    
    for(name in arr){
        alert('arr[' + name + ']='+ arr[name]);
    }
    /*输出：注，在firFox上返回数组中没有input、index、lastIndex项。
        arr[input]=aabbccddeeffgghh
        arr[index]=12
        arr[lastIndex]=16
        arr[0]=aabb//全局正则式返回数组的第一个元素为第一个子表达
                   //式匹配的值，而不像非全局正则式那样存储完全匹配项
        arr[1]=ccdd
        arr[2]=eeff
        arr[3]=gghh
    */
    alert('------------------');
    //match()方法执行全局正则式后，RegExp.$1..9存储的为最后一次匹配各子表达项的值
    alert('RegExp.$1 = ' + RegExp.$1);//gghh
    alert('RegExp.$2 = ' + RegExp.$2);//gg
    alert('RegExp.$3 = ' + RegExp.$3);//hh
    alert('------------------');
    //IE输出：16 firFox输出 0
    alert('second -- '+regexp.lastIndex);
    //第二次匹配时，但还是从第一个字符开始，
    arr = str.match(regexp);
    //IE输出：16  firFox输出 0
    alert('third -- '+regexp.lastIndex);
    for(name in arr){
        alert('arr[' + name + ']='+ arr[name]);
    }

    /*输出：注，在firFox上返回数组中没有input、index、lastIndex项。
        arr[input]=aabbccddeeffgghh
        arr[index]=12
        arr[lastIndex]=16
        arr[0]=aabb //注，还是从头重新匹配
        arr[1]=ccdd
        arr[2]=eeff
        arr[3]=gghh
    */
    alert('RegExp.$1 = ' + RegExp.$1);//gghh
    alert('RegExp.$2 = ' + RegExp.$2);//gg
    alert('RegExp.$3 = ' + RegExp.$3);//hh
    
}
testStringMatchG();

 

总之，G标示不会影响每次匹配的开始位置（按标准也不会影响正则式对象的lastIndex属性，但在IE下却影响了），不管是否有G标示，每次还是从字符开头起匹配，G标示只是影响返回的结果数组所在存储的信息，如果是非全局匹配，则只会匹配一次，并且返回的数组会结果数组中除第0个为整匹配项外，从索引为1开始的数组元素存储的为各子匹配式所匹配的值，数组个数为分组的个数；如果是全局匹配，则会搜索整个字符串，找出所有与整个表达式匹配的各个匹配项，此时返回的结果数组每个元素存储的值为每次找到的整体匹配项的值，且从数组第0个元素开始。还有一点就是IE与Firefox上不同的是，不管是否是全局匹配，IE上返回的结果数组中都存储了input、index、lastIndex属性的值，但在全局匹配模式下Firefox上没有这三个属性，但在非全局匹配模式下有input与index属性却没有lastIndex。

RegExpObject.lastIndex

该属性存放一个整数，它存储的是上一次匹配文本之后的第一个字符的位置。    
   
上次匹配的结果是由方法RegExp.exec()和RegExp.test()（注，IE上的String对象的match()方法也会影响，但Firefox上不会影响该正则式对象属性）找到的，它们都以lastIndex属性所指的位置作为下次检索的起始点。这样，就可以通过反复调 用这两个方法来遍历一个字符串中的所有匹配文本。
   
该属性是可读可写的。只要目标字符串的下一次搜索开始，就可以对它进行设置。当方法exec()或test()再也找不到可以匹配的文本时，它们会自动把lastIndex属性重置为0。
        
重要事项：不具有标志g和不表示全局模式的RegExp对象不能使用lastIndex属性 。
    
提示：如果在成功地匹配了某个字符串之后就开始检索另一个新的字符串，需要手动地把这个属性设置为0，除非重新构造另一新的正则式。

function testRegExpLastIndex(){
    var str = "The rain in Spain stays mainly in the plain";
    var regexp = new RegExp("ain", "g");
    
    alert(regexp.test(str));//true
    //Match found. index now at: 8
    alert("Match found. index now at: " + regexp.lastIndex);    
    //ain
    alert(regexp.exec(str));
    //Match found. index now at: 17
    alert("Match found. index now at: " + regexp.lastIndex);    
}
testRegExpLastIndex();

RegExp 对象的方法

RegExpObject.exec (string )

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

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

 

function testExec(){
    var str = "aabbccdd";
    //var arr = str.match(/[a-z]{2}/);
    //不加全局标示g时
    var regexp = /(([a-z]{2})([a-z]{2}))/;
    //第一次匹配
    var arr =regexp.exec(str);    
    /*
        此属性为IE FireFox的标准属性 但是IE输出4 fireFox输出0 ，
        输出0是因为为非全局正则式，如果是全局的将会输出4，
    */
    alert(regexp.lastIndex );
    for(name in arr){
        alert('arr[' + name + ']='+ arr[name]);
    }    
    /*输出：
        arr[input]=aabbccdd
        arr[index]=0
        arr[lastIndex]=4//注：FireFox上运行时返回数组没有此属性(非标准属性)，IE上有
        arr[0]=aabb//数组的0元素包含了完整的匹配，
        arr[1]=aabb//而第1到n元素中包含的是匹配中出现的任意一个子匹配。个数为括号数量
        arr[2]=aa
        arr[3]=bb
    */
    //exec方法执行后会更新RegExp对象，RegExp.$1..9 ，为正则式静态标准属性
    alert('RegExp.$1 = ' + RegExp.$1);//aabb
    alert('RegExp.$2 = ' + RegExp.$2);//aa
    alert('RegExp.$3 = ' + RegExp.$3);//bb
    alert('------------------');
    //第二次匹配
    arr =regexp.exec(str);
    //IE上输出4，Firefox输出0
    alert(regexp.lastIndex );
    for(name in arr){
        alert('arr[' + name + ']='+ arr[name]);
    }
    /*输出：因为正则式未加上全局标示g，所以第二匹配时还是从0开始
        arr[input]=aabbccdd
        arr[index]=0
        arr[lastIndex]=4//注：FireFox上运行时返回数组没有此属性(非标准属性)，IE上有
        arr[0]=aabb
        arr[1]=aabb
        arr[2]=aa
        arr[3]=bb
    */    
    alert('------------------');
    //exec方法执行后会更新RegExp对象，RegExp.$1..9 ，为正则式静态标准属性
    alert('RegExp.$1 = ' + RegExp.$1);//aabb
    alert('RegExp.$2 = ' + RegExp.$2);//aa
    alert('RegExp.$3 = ' + RegExp.$3);//bb
}
testExec();

 

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

 

function testExecG(){
    var str = "aabbccdd";
    //加全局标示g时
    var regexp = /(([a-z]{2})([a-z]{2}))/g;
    //第一次匹配
    var arr =regexp.exec(str);    
    
    //IE FireFox都有此标准属性，都输出:4
    alert(regexp.lastIndex);
    
    for(name in arr){
        alert('arr[' + name + ']='+ arr[name]);
    }
    /*输出：
        arr[input]=aabbccdd
        arr[index]=0
        arr[lastIndex]=4//非标准属性，Firefox上还是没有
        arr[0]=aabb//全局正则式返回数组的第一元素还是存储的整体匹配结果
        arr[1]=aabb
        arr[2]=aa
        arr[3]=bb
    */
    
    alert('RegExp.$1 = ' + RegExp.$1);//aabb
    alert('RegExp.$2 = ' + RegExp.$2);//aa
    alert('RegExp.$3 = ' + RegExp.$3);//bb


    alert('------------------');
    //第二次匹配
    arr =regexp.exec(str);
   //IE FireFox都输出:8
    alert(regexp.lastIndex);
    for(name in arr){
        alert('arr[' + name + ']='+ arr[name]);
    }

    /*输出：因为有全局标示g，所以从lastIndex开始匹配
        arr[input]=aabbccdd
        arr[index]=4
        arr[lastIndex]=8//非标准属性，Firefox上还是没有
        arr[0]=ccdd
        arr[1]=ccdd
        arr[2]=cc
        arr[3]=dd
    */
    alert('RegExp.$1 = ' + RegExp.$1);//ccdd
    alert('RegExp.$2 = ' + RegExp.$2);//cc
    alert('RegExp.$3 = ' + RegExp.$3);//dd
}
testExecG();

重要事项：如果在一个字符串中完成了一次模式匹配之后要开始检索新的字符串，就必须手动地把 lastIndex 属性重置为 0。

提示：请注意，无论 RegExpObject 是否是全局模式，exec() 都会把完整的细节添加到它返回的数组中。这就是 exec() 与 String.match() 的不同之处，后者在全局模式下返回的信息要少得多。因此我们可以这么说，在循环中反复地调用 exec() 方法是唯一一种获得全局模式的完整模式匹配信息的方法 。

 

调用 正则式对象的 exec()时， g标示只影响正则式的lastIndex属性，带与不带g两种方法返回的数组结果都是一样，都会存储匹配的完整细节信息。

 

//使用exec查找出所有匹配项时，需循环使用全局正则式进行匹配
function testExecMatchAll(){
    var src = "The rain in Spain falls mainly in the plain.";
    var re = /\w+/g;//找出所有匹配时一定要加上全局标示g
    var arr;
    while ((arr = re.exec(src)) != null)
    alert(arr[0]);
}

RegExpObject.test (string )

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

 

//test()非全局正则式测试
function testRegExpTest(){
    var str = "aabbccdd";
    //不加全局标示g时
    var regexp = /(([a-z]{2})([a-z]{2}))/;
    //第一次匹配
    alert(regexp.test(str));//true
    /*
        IE FireFox都有此标准属性 但是IE输出4 fireFox输出0 ，
        输出0是因为为非全局正则式，如果是全局的将会输出4，
    */
    alert(regexp.lastIndex );
    
    alert('------------------');
    //test方法执行后会更新RegExp对象，RegExp.$1..9 ，为标准属性
    alert('RegExp.$1 = ' + RegExp.$1);//aabb
    alert('RegExp.$2 = ' + RegExp.$2);//aa
    alert('RegExp.$3 = ' + RegExp.$3);//bb
    
    alert('------------------');
    //第二次匹配
    alert(regexp.test(str));//true
    //IE输出4，Firefox输出0
    alert(regexp.lastIndex );

    alert('------------------');
    //IE上的test()尽管受lastIndex影响，但非全局正则式，所以还是从头匹配
    alert('RegExp.$1 = ' + RegExp.$1);//aabb
    alert('RegExp.$2 = ' + RegExp.$2);//aa
    alert('RegExp.$3 = ' + RegExp.$3);//bb
}
testRegExpTest();

 

调用正则式对象的test()方法时，g标示影响正则式的lastIndex属性，而且一下次匹配的位置从lastIndex属性的值开始。

 

//test()全局正则式测试
function testRegExpTestG(){
    var str = "aabbccdd";
    //加全局标示g时
    var regexp = /(([a-z]{2})([a-z]{2}))/g;
    //第一次匹配
    alert(regexp.test(str));//true

    //IE FireFox都会输出4
    alert(regexp.lastIndex );
    
    alert('------------------');
    //test方法执行后会更新RegExp对象，RegExp.$1..9 ，为标准属性
    alert('RegExp.$1 = ' + RegExp.$1);//aabb
    alert('RegExp.$2 = ' + RegExp.$2);//aa
    alert('RegExp.$3 = ' + RegExp.$3);//bb
    

    //第二次匹配
    alert(regexp.test(str));//true
		//IE FireFox都会输出8
    alert(regexp.lastIndex );
    alert('------------------');
    //test()方法受全局标示g影响，第二次匹配的位置为上次匹配位置后面。
    alert('RegExp.$1 = ' + RegExp.$1);//ccdd
    alert('RegExp.$2 = ' + RegExp.$2);//cc
    alert('RegExp.$3 = ' + RegExp.$3);//dd
}
testRegExpTestG();

 

正则式的test()方法返回布尔型，一般用于完全匹配或者是验证是否含有其他非法字符。而exec()方法返回所有匹配结果，包括子表达式，一般除用于验证是否含有非法字符外，还用于查找出字符串所有匹配项。

function testRegExpMethod(){
        //----test match
        var regexp = /^(\d{2})+$/;
        var str = '123456';
        //test -- match
        if(regexp.test(str)){
                alert('test -- match');
        }else{
                alert('test -- no match');
        }
        
        //test()方法执行后也会更新RegExp对象，RegExp.$1..9 ，为标准属性
        alert('RegExp.$1 = ' + RegExp.$1);//56
    
        //----test valid
        regexp = /[\/\\]/;
        str = '123/45\\6';
        //test -- invalid
        if(regexp.test(str)){
                alert('test -- invalid');
        }else{
                alert('test -- valid');
        }
        
        //----exec invalid char
        regexp = /[\/\\]/g;
        str = '123/45\\6';
        var resultArr = regexp.exec(str);
        if(resultArr != null){
            alert('exec -- invalid');
        }
        
        //exec invalid char -- /
        //exec invalid char -- \
        while(resultArr != null){
            alert('exec invalid char -- ' + resultArr[0]);
            resultArr = regexp.exec(str);
        }
}

其他测试：

/*
 *  RegExpObject.lastIndex自动清零测试
 */
function testResetLastIndex(){
    var str = "a+";
    //一定要加上全局标示G，否则每次匹配都会从头开始，测试没有意思
    var regexp = /a/g;
    alert(regexp.exec(str));//a
    alert(regexp.lastIndex);//1
    alert(regexp.exec(str));//null 未匹配到
    alert(regexp.lastIndex);//0 未匹配到时自动清零
    alert('------------------');
    regexp = /a/g;
    alert(regexp.test(str));//true
    alert(regexp.lastIndex);//1
    alert(regexp.test(str));//false 未匹配到
    alert(regexp.lastIndex);//0 未匹配到时自动清零
    alert('------------------');
    regexp = /a\+/g;
    alert(regexp.exec(str));//a+
    alert(regexp.lastIndex);//2 当全部匹配后，lastIndex不会清零，除非下次未匹配后开始
    alert(regexp.exec(str));//null 因为第一次就完全匹配了，所以第二次未匹配到 
    alert(regexp.lastIndex);//0 第二次未匹配到时自动清零
    alert(regexp.exec(str));//a+ //清零后第三次继续从头开始重新匹配
    alert(regexp.lastIndex);//2
    alert('------------------');
    regexp = /a\+/g;
    alert(regexp.test(str));//true
    alert(regexp.lastIndex);//2
    alert(regexp.test(str));//false 未匹配到
    alert(regexp.lastIndex);//0 未匹配到时自动清零
}
testResetLastIndex();

 

/*
 * exec方法返回数组中存储的子表达式匹配项个数问题测试
 */
function testMatchArr(){
    var str = "aabbccdd";
    var regexp = /(([a-z]{2}){2})/;//注：这里是两个子表达式，而不是三个，量词对子表达式不起作用
    var arr =regexp.exec(str);
    alert(arr[0]);//aabb 注：不管正则式是否加上了全局标示g，第一个元素都是全匹配串                            
    alert(arr[1]);//aabb 从第二个数组元素开始，存放与括号顺序号模式匹配的串
    alert(arr[2]);//bb 注意：([a-z]{2}){2}匹配aabb中的bb，而不是aa
    
    alert('------------------');
    //exec方法执行后会更新RegExp对象，RegExp.$1..9 ，为标准属性
    alert('RegExp.$1 = ' + RegExp.$1);//aabb
    alert('RegExp.$2 = ' + RegExp.$2);//bb    注：这里与arr[2]是一样的，不会输出aa
    alert('RegExp.$3 = ' + RegExp.$3);//什么也不输出，因为只有两个子表达式
    
    alert('------------------');
    regexp = /[a-z]{2}/;
    arr = regexp.exec(str);
    alert(arr[0]);//aa
    alert(arr[1]);//undefied 如果正则试中没有括号子表达式，则返回结果数组只有一个元素
    alert('------------------');
    regexp = /[a-z]{2}/g;
    arr = regexp.exec(str);
    /*
        加上全局标示g的正则式只是影响exec下一次匹配的开始位置，而不像String对象的match，
        会找出所有匹配的串。如果要用exec方法匹配出所有串，则要使用带g标示的正则式进行多
        次匹配。
    */
    alert(arr.length);//1    
    alert(arr[0]);//aa    
}