var test = "He is a good boy. This is a nice day";
test;
"He is a good boy. This is a nice day"
test.replace(/is/, "IS");
"He IS a good boy. This is a nice day"
//g代表global全局
test.replace(/is/g, "IS");
"He IS a good boy. ThIS IS a nice day"
// \b代表整个单词
test.replace(/\bis\b/g, "IS");
"He IS a good boy. This IS a nice day"
//构造函数
var reg = new RegExp('\bis\b');
test.replace(reg, "IS");
"He IS a good boy. This is a nice day"
//构造函数
reg = new RegExp('\bis\b', 'g');
test.replace(reg, "IS");
"He IS a good boy. This IS a nice day"
//修饰符
// g:global全文搜索，不添加，搜索到第一个匹配停止
// i:ignore case忽略大小写，默认大小写敏感
test = "He Is a good boy.\n This is a nice day";
test.replace(/\bis\b/ig, "not is");
"He not is a good boy.
This not is a nice day"
// m:multiple lines多行搜索
undefined
/元字符/
//正则表达式由两种基本字符类型组成：
// .原义文本字符
// .元字符
//元字符是在正则表达式中有特殊含义的非字母字符
// + ? $ ^ . | \ ( ) { } [ ]
// 字符 含义
// \t 水平制表符
// \v 垂直制表符
// \n 换行符
// \r 回车符
// \0 空字符
// \f 换页符
// \cX 与X对应的控制字符（Ctrl + X）
undefined
//字符类
//一般情况下正则表达式一个字符对应字符串的一个字符。
//表达式 ab\t 表示一个字符a一个字符b加上一个水平制表符
//如果要匹配一类字符，可以使用元字符[]来构建一个简单的类
//所谓的类是指符合某些特征的对象，一个泛指，而不是特指某个字符
//表达式[abc]把字符a或b或c归为一类，表达式可以匹配这类字符。
"a1b2c3d4".replace(/[abc]/g, "X");
"X1X2X3d4"
//字符类取反
//使用元字符^创建 反向类/负向类
"a1b2c3d4".replace(/[^abc]/g, "X");
"aXbXcXXX"
"aXbXcXXX"
//范围类
//使用 [a-z] 来连接两个字符表示从a到z的任意字符
//这是一个闭区间，包含a和z本身
"a1b2c3d4x5i6".replace(/[a-z]/g, "X");
"X1X2X3X4X5X6"
"a1b2c3d4x5I6".replace(/[a-zA-Z]/g, "X");
"X1X2X3X4X5X6"
"2017-11-21".replace(/[0-9]/g, "X");
"XXXX-XX-XX"
"2017-11-21".replace(/[0-9-]/g, "X");
"XXXXXXXXXX"
"2017-11-21".replace(/[-0-9]/g, "X");
"XXXXXXXXXX"
//预定义类
// 字符 等价类 含义
// . [^\r\n] 除去回车符和换行符之外的所有字符
// \d [0-9] 数字字符
// \D [^0-9] 非数字字符
// \s [\t\n\x0B\f\r] 空白字符
// \S [^\t\n\x0B\f\r] 非空白字符
// \w [a-zA-Z_0-9] 单词字符(字母、数字下划线)
// \W [^a-zA-Z_0-9] 非单词字符
undefined
"2017-11-21".replace(/\d/g, "X");
"XXXX-XX-XX"
"2017-11- 21".replace(/\s/g, "");
"2017-11-21"
//边界
// 字符 含义
// ^ 以xxxx开始
// $ 以xxxxx结束
// \b 单词边界
// \B 非单词边界
undefined
"@67@678@99@".replace(/^@./g, "X");
"X7@678@99@"
test = "@67\n@678\n@99@";
test;
"@67
@678
@99@"
test.replace(/^@./g, "Q");
"Q7
@678
@99@"
//m:multiple lines多行搜索
test.replace(/^@./gm, "Q");
"Q7
Q78
Q9@"
//量词
//匹配一个连续出现 20次 数字的字符串
// 字符 含义
// ? 出现零次或一次（最多出现一次）
// + 出现一次或多次（至少出现一次）
// 出现零次或多次（任意次）
// {n} 出现n次
// {n, m} 出现n次到m次
// {n,} 至少出现n次
undefined
"22017-11-21 b 2017-11-21".replace(/(\d{4})-(\d{2})-(\d{2})/g, "$1/$2/$3");
"22017/11/21 b 2017/11/21"
//贪婪模式
"123456789".replace(/^\d{3,6}/g, "X");
"X789"
"123456789".replace(/\d{3,6}/g, "X");
"XX"
//非贪婪模式
//让正则表达式尽可能少的匹配，也就说一旦成功匹配不在继续。
"123456789".replace(/^\d{3,6}?/g, "X");
"X456789"
"123456789".match(/\d{3,6}?/g);
(3) ["123", "456", "789"]
//分组
//使用()可以达到分组的功能，使量词作用于分组
"a1b2c3d4".replace(/([a-z]\d){3}/g, "X");
"Xd4"
//或
//使用 | 可以达到或的效果
"wangpeng".replace(/(an|en)g/g, "ABC");
"wABCpABC"
//反向引用
"2017-11-21".replace(/(\d{4})-(\d{2})-(\d{2})/g, "$2/$3/$1");
"11/21/2017"
//忽略分组
//不希望捕获某些分组，只需要在分组内加上?:就可以了
//(?:Byron).(ok)
"2017-11-21".replace(/(?:\d{4})-(\d{2})-(\d{2})/g, "$2/$3/$1");
"21/$3/11"
//前瞻
//正则表达式从文本头部向尾部开始解析，文本尾部方向成为“前”
//前瞻就是向前检查是否符合断言，后顾/后瞻方向相反
//（当匹配到“张三”时向前匹配它的儿子是否是“王二”）
//JavaScript不支持后顾
// 名称 正则 含义
//正向前瞻 exp(?=assert)
//负向前瞻 exp(?!=assert)
//正向后顾 exp(?<=assert) JavaScript不支持
//正向后顾 exp(?<!assert) JavaScript不支持
"a234v8".replace(/\w(?=\d)/g , 'X');
"X2X4X8"
"a234vv".replace(/\w(?=\d)/g , 'X');
"X2X4vv"
"a234vv".replace(/\w(?!\d)/g , 'X');
"aX3XXX"
//对象属性
//global:是否全文搜索，默认false
//ignore case:是否大小写敏感，默认false
//multiline:多行搜索，默认值false
//lastIndex:是在当前表达式匹配内容的最后一个字符的下一个位置
//source:正则表达式的文本字符串
var reg1 = /\w/;
var reg2 = /\w/gim;
undefined
reg1.global;
false
reg2.global;
true
reg2.source;
"\w"
reg1.source;
"\w"
/test和exec方法/
//RegExp.prototype.test(str)
//
//.用于测试字符串参数中是否存在匹配正则表达式模式的字符串
//.如果存在则返回true，否则返回false
var reg1 = /\w/;
var reg2 = /\w/g;
undefined
reg1.test('a');
true
reg1.test('$');
false
reg2.test('ab');
true
reg2.test('ab');
true
reg2.test('ab');
false
//当执行第三遍是出现false，是因为lastIndex导致的。
reg2.test('ab');
true
reg2.test('ab');
true
reg2.test('ab');
false
while(reg2.test('ab')){
console.log(reg2.lastIndex);
}
VM577:2 1
VM577:2 2
undefined
//RegExp.prototype.exec(str)
//
//.使用正则表达式模式对字符串执行搜索，并将更新全局RegExp对象的属性以反映匹配的结果。
//.如果没有匹配的文本则返回null，否则返回一个结果数组：
// --index声明匹配文本的第一个字符的位置
// --input存放被检索的字符串string
//非全局调用
//调用非全局的RegExp对象的exec()时，返回数组
//第一个元素是与正则表达式相匹配的文本
//第二个元素是与RegExpObject的第一个子表达式相匹配的文本（如果有的话）
//第三个元素是与RegExp对象的第二个子表达式相匹配的文本（如果有的话），以此类推。
var reg3 = /\d(\w)\d/;
var reg4 = /\d(\w)\d/g;
var ts = '1a2b3c4d5e';
var ret = reg3.exec(ts);
console.log(reg3.lastIndex + '\t' + ret.index + '\t' + ret.toString());
console.log(reg3.lastIndex + '\t' + ret.index + '\t' + ret.toString());
VM578:17 0 0 1a2,a
VM578:18 0 0 1a2,a
undefined
var reg3 = /\d(\w)\d/;
var reg4 = /\d(\w)\d/g;
var ts = '$1a2b3c4d5e';
var ret = reg3.exec(ts);
console.log(reg3.lastIndex + '\t' + ret.index + '\t' + ret.toString());
console.log(reg3.lastIndex + '\t' + ret.index + '\t' + ret.toString());
VM580:5 0 1 1a2,a
VM580:6 0 1 1a2,a
undefined
ret
(2) ["1a2", "a", index: 1, input: "$1a2b3c4d5e"]
//eg3.lastIndex = 0,是因为lastIndex在非全局下不生效
var reg3 = /\d(\w)(\w)\d/;
var reg4 = /\d(\w)(\w)\d/g;
var ts = '$1aq2bw3ck4do5ep';
var ret = reg3.exec(ts);
console.log(reg3.lastIndex + '\t' + ret.index + '\t' + ret.toString());
console.log(reg3.lastIndex + '\t' + ret.index + '\t' + ret.toString());
VM593:5 0 1 1aq2,a,q
VM593:6 0 1 1aq2,a,q
undefined
while(ret = reg4.exec(ts)){
console.log(reg4.lastIndex + '\t' + ret.index + '\t' + ret.toString());
}
VM595:2 5 1 1aq2,a,q
VM595:2 11 7 3ck4,c,k
undefined
/字符串对象方法/
//Stringl.prototype.search(reg)
//.search()方法用于检测字符串中指定的子字符串，或检测与正则表达式相匹配的子字符串
//.方法返回的第一个匹配结果index，查找不到返回-1
//.search()方法不执行全局匹配，它将忽略标志g，并且总是从字符串的开始进行检索
"a1b2c3d1".search(/1/);
1
//Stringl.prototype.match(reg)
//.match()方法将检索字符串，以找到一个或多个与regex匹配的文本
//.regexp是否具有标志g对结果影响很大
//非全局调用
//如果regexp没有标志g，那么match()方法就只有在字符串中执行一次匹配
//如果没有找到任何匹配的文本，将返回null
//否则它将返回一个数组，其中存放了与它找到的匹配文本有关的信息
//返回数组的第一个元素存放的是匹配文本，而其余的元素存放的是与正则表达式的子表达式匹配的文本
//除了常规的数组元素之外，返回的数组还含有2个对象属性
// --index声明匹配文本的起始字符在字符串的位置
// --input声明对stringObject的引用
var reg3 = /\d(\w)\d/;
var reg4 = /\d(\w)\d/g;
var ts = '$1a2b3c4d5e';
var ret = ts.match(reg3);
console.log(ret);
console.log(ret.index + '\t' + reg3.lastIndex);
VM598:19 (2) ["1a2", "a", index: 1, input: "$1a2b3c4d5e"]
VM598:20 1 0
undefined
//全局调用
//如果regexp具有标志g，那么match()方法将执行全局检索，找到字符串中的所有匹配子字符串
//如果没有找到任何匹配的文本，将返回null
//如果找到了一个或多个匹配子串，则返回一个数组
//数组元素中存放的是字符串中所有的匹配子串，而且也没有index属性或input属性
var ret = ts.match(reg4);
console.log(ret);
console.log(ret.index + '\t' + reg4.lastIndex);
VM600:8 (2) ["1a2", "3c4"]
VM600:9 undefined 0
undefined
//String.prototype.split(reg)
'a1b2c3d4e5'.split(/\d/g);
(6) ["a", "b", "c", "d", "e", ""]
'a,b,c,d,e'.split(/,/);
(5) ["a", "b", "c", "d", "e"]
'a,b|c,d|e'.split(/[,|]/);
(5) ["a", "b", "c", "d", "e"]
//String.prototype.replace(str, replaceStr)
//String.prototype.replace(reg, replaceStr)
//String.prototype.replace(reg, function)
//function会在每次匹配替换的时候调用，有四个参数
//1.匹配字符串
//2.正则表达式分组内容，没有分组则没有该参数
//3.匹配项在字符串中的index
//4.原字符串
'a1b2c3d4e5'.replace(/\d/g, function(match, index, origin){
console.log(index);
return parseInt(match)+1;
});
VM778:2 1
VM778:2 3
VM778:2 5
VM778:2 7
VM778:2 9
"a2b3c4d5e6"
'a1b2c3d4e5'.replace(/(\d)(\w)(\d)/g, function(match, group1, group2, group3, index, origin){
console.log(match);
return group1+group2;
});
VM780:2 1b2
VM780:2 3d4
"a1bc3de5"