/*    表达式的创建

 // new RegExp()    方式创建

     var pattern = new RegExp('Reg');//创建一个模式，括号中的字符串就是模式字符串，它是将要检测数据的规范

     alert(pattern);        //输出结果是：/Reg/ 两个反斜杠就是字面量创建形式，中间是表达式

 //第二个可选参数为模式可选符，总共三个字符 i,g,m 顺序无所谓，不带有任何分隔符

 //模式可选字符代表的意义：i：忽略大小写，g：全文匹配，m：多行匹配(不写的话是只匹配第一行)

     var pattern = new RegExp('Reg',"igm");

     alert(pattern);    //  /Reg/gim    //可选修饰符无论怎么写都是按照 gim 的顺序输出的

     //var pattern = new RegExp('Reg',"i,gm");    //error,这个参数只能是由 gim 组成的无序字符串

     var pattern = new RegExp('Reg',"mig");

     alert(pattern);    //  /Reg/gim

 //字面量创建方式    用两个反斜杠括起来，中间就写要匹配的表达式模式，第二个反斜杠后面跟上模式可选字符，同样不能用其他字符

     var pattern = /Reg/;    //创建一个模式字符串，注两个反斜杠中没有引号

     alert(pattern);    // /Reg/

     pattern=/Reg/im;

     alert(pattern);    //    /Reg/im

     pattern = /"Reg"/gim;

     alert(pattern);    //  /"Reg"/gim

 //测试正则表达式    将需要检测的字符串用正则表达式进行收索匹配，看字符串中是否包含复合表达式规则的结果，

 // pattern.test(string);//test方法是测试字符串string中是否包含符合表达式的值，包含就返回true,否则返回false

     var pattern = new RegExp('Reg');

     var str='regexp';

     alert(pattern.test(str));//false    //因为表达式中是大写的 'Reg'

     var pattern =new RegExp("Reg",'i');// i 表示忽略大小写

     var str="regexp";

     alert(pattern.test(str));//true 因为表达式中的模式选择符说明了忽略大小写，字符串中包含小写的 'reg'，故匹配成功

     var pattern=new RegExp("Reg",'i');

     var str="this is regexp!";

     alert(pattern.test(str));//true

     var pattern=/Reg/i;    //使用字面量创建表达式，设置模式为忽略大小写

     var str="This Is REGEXP !";

     alert(pattern.test(str));

 //使用字面量的方式一句话简化创建测试正则表达式        不推荐，容易误读，含义表达不清晰

     alert(/Reg/i.test("this is rgeohi "));//false

     alert(/Reg/i.test("this is regexp "));//true

 // pattern.exec() 方法  匹配成功后返回的是一个数组，匹配不成功返回的是null

     var pattern=/Reg/i;    //忽略大小写

     var str='abcdreghigkReghh';//这里面包含两个 reg 子字符串

     alert(pattern.exec(str));//reg

     alert(typeof pattern.exec(str));    //object    数组的类型是object类型

     str='abcdegr';

     alert(pattern.exec(str));    //null

     alert(typeof pattern.exec(str));    // object    Null类型的字符串返回值为object

     var a=null;

     alert(typeof a);//object

 */

 /*    使用字符串的正则表达式方法   这些方法是String类型提供的，故使用方式上稍稍和上面两个方法不同

 //str.match(pattern);方法是字符串提供的匹配模式，然后以数组的形式返回匹配的所有结果(子字符串或者null)

     var pattern=/Box/ig;                //全局的忽略大小写的

     var str="this is a box,that is a Box??";

     alert(typeof str.match(pattern));// object    说明是数组

     alert(str.match(pattern));//box,Box

     pattern=/Box/i;                        //忽略大小写  非全局的

     alert(str.match(pattern));//box

     pattern=/Box/g;                        //全局的 区别大小写的

     alert(str.match(pattern));//Box

 //str.search(pattern); 返回的是字符串中匹配到的模式的子字符串的起始位置(下标为0开始的索引)

 //search方法是查找及返回  无需要全局

     var pattern=/Box/ig;

     var str="this is a box!This is a Box!!";

     alert(typeof str.search(pattern));    //number

     alert(str.search(pattern));            //10

     pattern=/Box/i;    //不全局匹配,忽略大小写

     alert(str.search(pattern));            //10

     pattern=/Box/g;    //区分大小写，匹配全局

     alert(str.search(pattern));            //24

 //没有查找到返回-1

     var pattern=/Bbx/ig;

     var str="this is a box!This is a Box!!";

     alert(typeof str.search(pattern));    //number

     alert(str.search(pattern));            //-1    没有查到

 //str.replace(patter,replacement)；将字符串按照pattern模式进行匹配，然后将匹配到的子字符串替换成replacement子字符串

 //replace方法不会改变原来的原来的字符串的值

     var pattern =/Box/ig;

     var str ="this is box,that is a Box;;";

     alert(typeof str.replace(pattern,'XBox'));//string

     alert(str);                                  //"this is Box,that is a box;;"

     alert(str.replace(pattern,'XBox'));          //"this is XBox,that is a XBox;;"

     pattern=/Box/i;//不全局匹配,忽略大小写

     alert(str.replace(pattern,'XBox'));          //"this is XBox,that is a Box;;"

     pattern=/Box/g;    //区分大小写，匹配全局

     alert(str.replace(pattern,'XBox'));          //"this is box,that is a XBox;;"

 //str.split(pattern);方法是将字符串按照pattern模式进行匹配然后按照匹配的子

 //字符串为分隔符对源字符串进行分割，返回分割后的数组，元字符穿不会改变

     var pattern =/Box/ig;

     var str ="this is box!!that is a Box!!";

     alert(typeof str.split(pattern));//object

     alert(str.split(pattern));        //"this is ,!!that is a Box,!!";

     alert(str);                        //"this is box!!that is a Box!!"

     alert(str.split(pattern).length);//3    分割成3块

 */

 /* RegExp 对象的一些静态属性和实例属性

 //静态属性是可以不实例化的属性，但是在这之前需要执行以下正则表达式，

 //用短名操作的时候是写在中括号中用引号括气来的

 //Opera浏览器只是支持 leftContext和rightContext  IE不支持multiline

     var pattern=/google/ig;

     var str="This Google is google ? Yes !";

     alert(RegExp.input);        //输出为空

     pattern.test(str);            //执行以下正则表达式    //其实这个测试是只要匹配一个就返回

     //RegExp.input  返回的是当前被匹配的源字符串  $_ 是input的短名，效果是一样的

     alert(RegExp.input);        //This Google is google ? Yes !

     //用短名操作只是 input才可以用点的形式

     alert(RegExp['$_']);        //This Google is google ? Yes !

     alert(RegExp.$_);            //This Google is google ? Yes !

     //RegExp.lastMatch 返回的是最后被匹配到的字符串

     alert(RegExp.lastMatch);    //Google

     alert(RegExp['$&']);

     //返回最后一次匹配之前和之后的内容

     alert(RegExp.leftContext);    //This 后面还有一个空格

     alert(RegExp['$`']);

     alert(RegExp.rightContext); // is google ? Yes !;

     alert(RegExp['$\'']);

     //用于指定是否所有的表达式都用于多行的布尔值

     alert(RegExp.multiline);    //undefined        IE不支持  在火狐中返回的时候false

     alert(RegExp['$*']);

     pattern=/(g)oogle/ig;

     pattern.test(str);

     //最后一对圆括号内匹配的字符串

     alert(RegExp.lastParen);    //G

     alert(RegExp['$+']);

 //下面是对象的实例属性    基本上没有用

     var pattern =/Box/ig;

     alert(pattern.global);        // true        是否设置为全局匹配        表示 g 是否已经设置

     alert(pattern.ignoreCase);    // true        是否设置为忽略大小写    表示 i 是否已经设置

     alert(pattern.multiline);    // false    是否设置为多行匹配        表示 m 是否已经设置

     alert(pattern.source);        // Box        返回的是正则表达式的源字符串形式

   //lastIndex在获取下一次匹配位置上IE和其他浏览器有偏差，主要表现在全局匹配上面

     var pattern =/Box/ig;

     var str = "box and Box and box";

     //test一次只是匹配一条数据就返回

     pattern.test(str);

     alert(pattern.lastIndex);    //3        上一条语句执行后匹配了一个box从这后面开始的第一个字符串，下标为3

     pattern.test(str);            //在执行一次  匹配第二个box 后面的字符的索引为11

     alert(pattern.lastIndex);    //11

     pattern.lastIndex=13;        //设置下一次开始匹配的起始位置

     alert(pattern.lastIndex);    //13

     var pattern =/Box/ig;

     var str = "box and Box and box";

     //exec()一次只是匹配一条数据就返回

     pattern.exec(str);

     alert(pattern.lastIndex);    //3        上一条语句执行后匹配了一个box从这后面开始的第一个字符串，下标为3

     pattern.exec(str);            //再执行一次  匹配第二个box 后面的字符的索引为11

     alert(pattern.lastIndex);    //11

     pattern.lastIndex=13;        //设置下一次开始匹配的起始位置

     alert(pattern.lastIndex);    //13

 */

 /*    提取字符    简单的元字符匹配就省略了  主要是针对分组

     var pattern=/goo gle/;        //直接用空格去匹配字符中的空格

     var str='goo gle';

     alert(pattern.test(str));//true

     var pattern=/goo\sgle/;        //用\s来匹配空格、制表符等

     var str='goo gle';

     alert(pattern.test(str));//true

 //    \b 表示到达边界

     var pattern=/google\b/;        //\b表示到达边界  和开始结束符 ^、$功能类似

     var str='googleg';

     alert(pattern.test(str));    //false

     str='google';

     alert(pattern.test(str));    //true

     pattern=/\bgoogle/;

     alert(pattern.test(str));    //true

     alert(pattern.test('ggoogle'));//false

 // | 或匹配选择模式符

     var pattern=/google|baidu|bing/;    // | 表示或匹配选择模式   是一个分组符

     var str="this is baidu";    //匹配概念：是包含的意思  而不是相等的意思

     alert(pattern.test(str));    //true

     alert(pattern.test('soso'));//false

 //{4,8}表示的是前面这个字符或者说是分组分组匹配的次数

     var pattern=/google{4,8}/;    //表示匹配e的4到8次

     var str='googleeeeee';

     alert(pattern.test(str));    //true

     var patter=/(google){4,8}/;        // google 使用括号括起来的，是一个分组，可以看成一个字符

     var str='googlegooglegooglegoogle';    //表示 google 4-8次

     alert(pattern.test(str));//true

     var pattern=/8.*8/;

     var str='this is a 8google8';

     alert(pattern.test(str)); // true

 // 一个括号代表一个分组，组可以用 $1,$2等来代替，编号是从1开始，而不是0开始

 //当执行正则表达式后，$1 就代表的是第一个分组匹配的内容

     var pattern=/8(.*)8/;

     var str='this is a 8google8';

     alert(pattern.test(str)); // true

     alert(RegExp.$1);    //google    RegExp.$1表示获取模式中第一个分组对应的匹配字符串

     document.write(str.replace(pattern,'<strong>$1</strong>'));

 //通过分组进行交换内容

     var pattern=/(.*)\s(.*)/;    //两个分组

     var str='google baidu';

     alert(pattern.test(str));    //true

     alert(str.replace(pattern,'$2 $1'));//交换位置  baidu google

 */

 /*

 在使用修饰匹配次数的特殊符号时，有几种表示方法可以使同一个表达式能够匹配不同的次数，

 比如："{m,n}", "{m,}", "?", "*", "+"，具体匹配的次数随被匹配的字符串而定。这种重复

 匹配不定次数的表达式在匹配过程中，总是尽可能多的匹配。比如，针对文本 "dxxxdxxxd"，

 就是贪婪模式

 */

 /*    贪婪非贪婪模式(惰性模式)    贪婪:尽可能的多匹配一点  非贪婪：少匹配一点，让后面的尽快匹配

 //对于贪婪模式解决的时候再后面添加一个 ? 就变成了非贪婪的模式了

     var pattern=/[a-z]+/;    // + 就是一个贪婪模式

     var str='abcd';

     alert(str.replace(pattern,1));//1    贪婪下将所有的字符都给匹配上了，然后视为一个分组

     var pattern=/[a-z]+?/;    // +? 非贪婪模式

     var str='abcd';

     alert(str.replace(pattern,1));//1bcd    非贪婪模式，只是匹配了第一个字符

     var pattern=/[a-z]+?/g;    // +? 非贪婪模式 但是开启了全局

     var str='abcd';

     alert(str.replace(pattern,1));//1111    

 //贪婪模式下的结果

     var pattern=/8(.*)8/;

     var str= '8google8 8google8 8google8';    //匹配到了google8 8google8 8google

     alert(str.replace(pattern,'<strong>$1</strong>'));

     //结果是：<strong>google8 8google8 8google</strong>

     //因为在匹配的过程中， . 元字符又可以表示任意的字符，而 * 又是一个贪婪模式匹配

 //使用惰性模式  为开启全局

     var pattern=/8(.*?)8/;

     var str= '8google8 8google8 8google8';

     alert(str.replace(pattern,'<strong>$1</strong>'));//<strong>google</strong> 8google8 8google

     document.write(str.replace(pattern,'<strong>$1</strong>'));

     //尽可能的让后面的匹配  故这次只是匹配了一个 8google8

 //使用惰性模式  开启了全局后  正确

     var pattern=/8(.*?)8/g;        //开启全局

     var str= '8google8 8google8 8google8';

     alert(str.replace(pattern,'<strong>$1</strong>'));

     document.write(str.replace(pattern,'<strong>$1</strong>'));

     //<strong>google</strong> <strong>google</strong> <strong>google</strong>

 //另外一种惰性  屏蔽了8的匹配，也就是两边包含字符

     var pattern=/8([^8]*)8/g;        //开启全局

     var str= '8google8 8google8 8google8';

     alert(str.replace(pattern,'<strong>$1</strong>'));

     document.write(str.replace(pattern,'<strong>$1</strong>'));

     //<strong>google</strong> <strong>google</strong> <strong>google</strong>

 //{m,n}{n}{n,}也是贪婪模式

     var pattern=/[a-z]{2,5}/;//{2,5}也是贪婪模式  会尽可能的匹配到5个字符

     var str='abcdefg';

     alert(str.replace(pattern,'1'));    //1fg

     var pattern=/[a-z]{3}/;//{3}也是贪婪模式  会尽可能的匹配到5个字符

     var str='abcdefg';

     alert(str.replace(pattern,'1'));    //1defg

     var pattern=/[a-z]{3}/g;//{3}也是贪婪模式  会尽可能的匹配到5个字符

     var str='abcdefg';

     alert(str.replace(pattern,'1'));    //11g

     var pattern=/[a-b]?/;//{2,5}也是贪婪模式  会尽可能的匹配到5个字符

     var str='abcdefg';

     alert(str.replace(pattern,'1'));    //1fg

 */

 /*    用 exec() 返回数组

 //如果没有分组的时候返回的是整个匹配的字符串  其实就是返回的数组第1个元素

     var pattern=/^[a-z]+\s[0-9]{4}$/;

     var str='google 2014';

     alert(pattern.exec(str));//gogle 2014

     alert(pattern.exec(str)[0]);//gogle 2014

     var pattern=/[a-z]+/i;

     var str='123abcdefg234';

     alert(pattern.exec(str));//abcdefg

     alert(pattern.exec(str)[0]);//abcdefg

 //返回的数组中 res[0]是匹配的整个字符串内容，res[1]开始一直往后是按照分组顺序来返回的

     var pattern=/^([a-z]+)\s([0-9]{3,})([A-Z]+)$/;

     var str='abcd 12345EFJH';

     var res=pattern.exec(str)//

     alert(res);//abcd 12345EFJH,abcd,12345,EFJH

     alert(res.length);//4

     alert(res[0]);    //abcd 12345EFJH    匹配的字符串

     alert(res[1]);    //abcd    第一个分组

     alert(res[2]);    //12345    第二个分组

     alert(res[3]);    //EFJH    第三个分组

 */

 /*    捕获性分组和非捕获性分组    分组后需要返回匹配的分组信息，称为捕获分组，非捕获就是不需要返回，效率较高

     var pattern=/(\d+)([a-z]+)/;    //返回所有的分组信息  为捕获性分组

     var str='1234ahcd';

     alert(pattern.exec(str));//1234ahcd,1234,ahcd

     alert(pattern.exec(str).length);//3

     var pattern=/(\d+)(?:[a-z]+)/;    //不需要返回的分组中前面加一个 ?: 就是非捕获性分组

     var str='1234ahcd';

     alert(pattern.exec(str));//1234ahcd,1234

     alert(pattern.exec(str).length);//2

 */

 /*    分组嵌套   外层分组中在添加两层分组，捕获的时候先外后里

 //分析的时候从外向里分许，分析外层分组的时候，可以把里层分组的括号先去掉

     var pattern=/(A+(B+(C+)))/;

     var str='AABBCC';

     alert(pattern.exec(str));        //AABBCC,AABBCC,BBCC,CC

     alert(pattern.exec(str).length);//4

     var res=pattern.exec(str);

     alert(res[0]);    //AABBCC    匹配的字符串

     alert(res[1]);    //AABBCC    返回的是匹配的第1个分组，从上面字符串来看就是外层分组，相当于是把里面两层分组给去掉的结果

     alert(res[2]);    //BBCC        返回的是匹配的第二个分组，从上面字符串来看是第二层分组，相当于把最里面的一层分组给去掉的结果

     alert(res[3]);    //CC        返回的是匹配的第三个分组，从上面字符串来看是最里面的一个分组

 */

 /*    使用前瞻匹配    就是模式的某些字符后面必须更上一些特定的内容才能够匹配

     var pattern=/goo/;        //非前瞻性匹配的正则表达式，只要包含goo都能够匹配

     var str='this google';

     alert(pattern.test(str));    //true

     alert(pattern.exec(str));    //goo

     str='this goo123';

     alert(pattern.test(str));    //true

     alert(pattern.exec(str));    //goo

     pattern=/goo(?=gle)/;        //前瞻性匹配的正则表达式，goo后面必须是gle

     var str='this google';

     alert(pattern.test(str));    //true

     alert(pattern.exec(str));    //goo

     str='this goo123';

     alert(pattern.test(str));    //false

     alert(pattern.exec(str));    //null

     var pattern=/^[a-z]{3}([0-9]{4})/;

     var str='cbadefg12345';

     alert(pattern.test(str));//false

     str='abc1234';

     alert(pattern.test(str));//true

     alert(pattern.exec(str));//abc1234,1234

     pattern=/^[a-z]{3}(?=0)([0-9]{2,})/;    //前瞻性匹配  要求在字符后面必须跟上一个0然后在是三个数值

     alert(pattern.test(str));//false

     alert(pattern.exec(str));

 */

 /*    特殊字符   需要使用转义字符 \ 

     var pattern=/\.\[\/b\]/;//通过转义字符是 .、[、]不再是特殊的字符，而是匹配的字符串中包含的字符

     var str='.[/b]';

     alert(pattern.test(str));//true

     alert(pattern.exec(str));//.[/b]

     str='h8b8';

     alert(pattern.test(str));//false

 */

 /*    使用换行匹配    主要是在读取文本的 时候  需要开启多行以及全局匹配才行

     var pattern=/^(\d)+/;    //用一个数子开头

     str='1.baidu\n2.google\n3.bing';

     alert(pattern.test(str));

     alert(str.replace(pattern,'#'));

     patter=/^(\d)+/g;

     alert(str.replace(pattern,'#'));

     pattern=/^(\d)+/m;

     alert(str.replace(pattern,'#'));

     //上面的结果都是一下   只是替换了首行

     //#.baidu

     //2.google

     //3.bing

     pattern=/^(\d)+/gm;

     alert(str.replace(pattern,'#'));

     //开启了全局和多行后替换了全部的数子

     //#.baidu

     //#.google

     //#.bing

 */