正则表达式

//定义正则表达式的两种方式，在用构造函数的时候，有些地方是要加转义字符的。

//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 = ‘’;

\1就是第一个子项的意思

// .代表所有字符