//定义正则表达式的两种方式，在用构造函数的时候，有些地方是要加转义字符的。
//1、字面量。
var reg = /\bis\b/ig;
var str = "He is a good boy";
console.log(str.replace(reg, 'IS')); //He IS a good boy
//2、构造函数
var reg = new RegExp('\\bis\\b', 'ig'); //加了转义字符
var str = "He is a good boy";
console.log(str.replace(reg, 'IS')); //He IS a good boy
//正则表达式由两种基本字符类型组成：
//1.原义文本字符：代表其本身
//2.元字符：在正则表达式中有特殊含义的非字母字符
//字符类取反：^,注意：^符号只有在[]中才是取反的意思，在[]外面表示开头
//例如
//var reg = /[^\d]/ig;
//var str = '123456dsa';
//str.replace(reg,'m');//123456mmm
//test()方法用于测试字符串是否符合正则表达式，默认只要字符串中有一部分符合，就返回true，不符合返回false。
//加上^和$表示str必须从头到尾完全匹配规则，否则就是false.^表示以xxx开始，$表示以XXX结束
//\b表示单词边界 \B表示非单词边界
// var reg = /abc/ig;
// var str = "abcd";
// reg.test(str);//true
//
//var reg = /^abc$/ig;
//var str = "abcd";
//reg.test(str);//false
//1. 备选字符集：规定某*一位*字符可选的备选文字列表
// 语法：[备选字符列表]
// 强调：无论备选字符集中由有多少字符，都必须且只能选1个,一个[]只代表1位字符！
// 比如：6位数字：[0123456789][0123456789][0123456789][0123456789][0123456789][0123456789]
//2. -：如果备选字符连续，可用-表示"到"
//3. 预定义字符集：专门表示常用的连续的字符集
// \d ==>[0-9] : 1位数字
// \w ==>[0-9a-zA-Z_] : 1位数字，字母或下划线
// \s ==>[空字符] : 代表一位空字符：空格，Tab符
//
var reg = /[abcdefg]/;
var str = "a";
console.log(reg.test(str)); //true
var reg = /[abcdefg]/;
var str = "abl";
console.log(reg.test(str)); //true，因为只匹配一个字符，符合，就返回true，不管后面是怎么样的内容。
var reg = /[abcdefg]/;
var str = "lab";
console.log(reg.test(str)); //true，同上
var reg = /^[abcdefg]$/g;
var str = "ab";
console.log(reg.test(str)); //false，规则是只匹配一个字符，字符串中是两个字符，所以false
var reg = /^[abcdefg]+$/g;
var str = "ab";
console.log(reg.test(str)); //true，规则中的含义是，匹配一个或多个小写字母组成的字符串
// .:除了换行外，其他所有的字符
//
// \D,\W,\S-->除了\d,\w或\s --了解
//4. 量词：规定一个字符集出现的次数:2种
// (1)明确数量：3种：{min,max}:最少min位，最多max位
// {min,}:至少min位
// {n}:必须n位
// 身份证号:15位或者18位
// 18位时后三位: 2位数字+最后一位数字或x X,后三位可有可无，但最多出现1次
// \d{15}(\d{2}[0-9xX])?
//
// (2)不确定数量：3种：
// ? ==>{0,1}: 可有可无，最多1次
// * ==>{0,}:可有可无，多了数量不限
// + ==>{1,}:至少一次，多了数量不限
//g的作用，不加g的时候，虽然有两个 is，但找到一个以后就停止匹配了，g是global的缩写
//var reg = /is/;
//console.log(reg.global);//false
//var reg = /is/g;
//console.log(reg.global);//true
//最简单的正则表达式
var str = "He is a good boy";
var reg = /is/;
console.log(str.replace(reg, 'IS')); //ThIS is a good boy
//这样就会匹配出当前字符串中所有的is
var reg1 = /is/g;
console.log(str.replace(reg1, 'IS')); //ThIS IS a good boy
//只匹配到小写的is，i是ignoreCase的缩写，加上i表示匹配是忽略大小写
//var reg = /is/i;
//console.log(reg.ignoreCase);//true
var reg2 = /is/g;
var str = "This IS a good boy";
console.log(str.replace(reg2, 'o')); //Tho IS a good boy
var reg3 = /is/gi;
var str = "This IS a good boy";
console.log(str.replace(reg3, 'o')); //Tho o a good boy
//贪婪模式
var reg4 = /\d{3,6}/ig;
var str = "12345678";
console.log(str.replace(reg4, 'X')); //X78
//让正则表达式尽可能少的匹配，也就是说一旦成功匹配不再继续尝试，就是非贪婪模式，在量词后面加上?即可
var reg5 = /\d{3,6}?/ig;
var str = "12345678";
console.log(str.replace(reg5, 'X')); //XX78
//前瞻：在正则表达式匹配到规则的时候，向前检查是否符合断言，后顾/后瞻 方向相反
//正则表达式从文本头部向尾部开始解析，文本尾部方向称为"前"，通俗的说，从头开始，向尾部搜索，比喻成走路，尾部就是前方了。
//要找的值满足查询附带的条件，例如，我要找你的哥哥。目标是哥哥，条件是你的哥哥。左面的5是哥哥，右边的5是你
var str = "4d4d4d55";
var reg = /\d(?=\d)/ig; //
str.replace(reg, 'w'); //"4d4d4dw5"
//负向前瞻
var str = "4a4b4c55";
var reg = /\d(?!\d)/ig;
str.replace(reg, 'w'); //"wawbwc5w"
//用()括起来代表分组，从左到右序号递增，对应的变量的值$1,$2,.....$n，注意：只有在字符串满足完整的正则表达式的前提下，才会匹配出子项。通俗的说，就是有了爸爸才能有儿子。
//反向引用
//match获取当前字符串中查询到的所有符合正则的内容，存放到一个数组中。
//exec 方法受参数 g的影响。若指定了 g，则下次调用 exec 时，会从上个匹配的 lastIndex 开始查找。lastIndex是当前表达式匹配内容的最后一个字符的下一个位置。 exec每次只查询字符串中一个符合正则表达式的内容，并返回其值和当前值中的子项，存放在一个数组中。不指定g的时候，索引值不变，不管调用几次，查找的都是字符串中第一个符合正则的值。
var str = "ma name is aa Aa aaa aa";
var reg = /aa/ig;
str.match(reg); //["aa", "Aa", "aa", "aa"]
reg.exec(str); //["aa"]
reg.exec(str); //["Aa"]
reg.exec(str); //["aa"]
reg.exec(str); //["aa"]
reg.exec(str); //null
reg.exec(str); //["aa"]
//test()方法exp.test(str);返回值为true和false，符合返回true，下次调用 test 时会从上个匹配的 lastIndex 开始查找。
var str = "abcd";
var reg = /\w/ig;
reg.test(str); //true,第一个匹配的是a
reg.test(str); //true,第一个匹配的是b
reg.test(str); //true,第一个匹配的是c
reg.test(str); //true,第一个匹配的是d
reg.test(str); //false,未匹配到值
reg.test(str); //true,重新开始匹配a
//加了^$，所以当前规则要求字符串完全符合正则表达式，恰好当前字符串是符合的，于是可以匹配出子项
var str = '2015-08-23';
var reg = /^(\d{4})-(\d{2})-(\d{2})$/ig;
str.replace(reg, '$1/$2/$3'); //2015/08/23
//再看这个，也 加了^$，要求字符串从头到尾完全符合正则表达式，当前字符串不符合，所以匹配不到任何值，也就没有子项。没有爸爸，也就没有儿子了。
var str = 'a2015-08-23a';
var reg = /^(\d{4})-(\d{2})-(\d{2})$/ig;
reg.test(str); //false,也就会没有匹配到任何值
str.replace(reg, '$1/$2/$3'); //"a2015-08-23a"
//去掉了^$，也就不需要字符串从头到尾完全符合正则表达式，于是就匹配到了值
var str = 'a2015-08-23a';
var reg = /(\d{4})-(\d{2})-(\d{2})/ig;
str.replace(reg, '$1/$2/$3'); //"a2015/08/23a"
//那么，我们需要证明一下它的子项有哪些，于是调用了exec函数，这个函数的作用是将匹配到的值和其中的子项放在一个数组里。
var str = 'a2015-08-23a';
var str = 'a2015-08-23a'; //["2015-08-23", "2015", "08", "23", index: 1, input: "a2015-08-23a"]，这是匹配到的字符串和其子项
//于是，我们知道，他的子项$1,$2,$3分别是exec[1],exec[2],exec[3]
str.replace(reg, '$1/$2/$3'); //"a2015/08/23a"
//用子项替换当前字符串中匹配到的值(2015-08-23),也就是"a2015-08-23a"中，将"2015-08-23"替换为2015、08、23，结果为
//"a2015/08/23a"
//如果不希望捕获分组，那么，可以再分组内加上?:，像这样(?:\d{4}),这样，这个分组就不会被捕获了。
var str = 'a2015-08-23a';
var reg = /(?:\d{4})-(\d{2})-(\d{2})/ig;
var match = str.match(reg);
console.log(match); //"2015-08-23"，这样，我们就得到了当前匹配到的字符串。
var exec = reg.exec(str);
console.log(exec); //["2015-08-23", "08", "23"]，匹配到的字符串和其子项中，没有匹配到"2015"这一子项
//他的子项$1,$2分别是exec[1],exec[2]，也就是"08"和"23"
str.replace(reg, '$1/$2'); //"a08/23a"
//这时，如果这样写：
//str.replace(reg,'$1/$2$3');
//匹配到的是"a08/23$3a",因为$3并没有值。
rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/
var str = ‘<html></html>’;
\1就是第一个子项的意思
// .代表所有字符
