1、正则表达式
一套规则，一般用来处理字符串的查询和替换
1.1 创建正则规则
- 字面量写法：/正则表达式的规则/
- 通过正则的构造函数来生成一个对象：new RegExp(字符串)
这里的字符串就是规则
1.2 正则表达式的方法
-
test()：匹配成功返回true，匹配失败返回false
语法：正则规则.test(源字符串) -
match()：返回匹配规则的内容
语法：源字符.match(正则规则) -
replace()：字符串方法，接受两个参数，替换
语法：源字符.replace(正则规则,字符串/函数)- 第一个参数：正则或者是字符串（一般使用正则）
- 第二个参数：字符串或者是function，但是必须返回用于替换
-
位置置换：
-
exec()：依次执行，超过就是null
语法：正则规则.exec(源字符串)
const str = "魔道祖师真好看";
// 字面量写法
const reg1 = /魔道祖师/; //这里不能匹配。因为两个斜杠之间就是规则
// 正则构造函数
const reg2 = new RegExp("魔道祖师");
console.log(reg1.test(str)); // true
console.log(reg2.test(str)); // true
1.3 特殊字符
-
1、转义符： \ 对后面的字符的转译，转义可能发生改变，可能不会
\n：换行
\t：空格
\ \：双转义符号，后面一个被转义为一个普通的斜杠 -
2、元字符
\d：转义d，判定数字0-9
\D：转义D，非数字
\s：转义s，空格
\S：转义S，非空格
\w：转义w，字符（数字，字母，_）
\W：转义W，非字符（除了w以外的所有东西）
\b：转义b，判断独立部分（单词边界，起始，结束，连词符（除了\w之外的属于连词符））
\D：转义D，非独立部分 -
3、量词：默认是贪婪匹配，以最高次匹配
- 语法：{min, max}
最少出现min次，最多出现max次 - 特殊的量词写法：
{0,1} 最少出现0次，最多出现1次 = ?
{0,} 最少出现0次，最多出现无数次 = *
{1,} 最少出现1次，最多出现无数次 = +
- 语法：{min, max}
-
4、标识符
g：全局匹配 i：不区分大小写 m: 换行匹配 .：匹配所有的字符，除开\n \r \t -
5、起始符、结束符
^：起始符，行首
$：终止符，行尾
// test()方法
let obj = "{\"a\", 1}";
console.log(obj); // {"a", 1}
const str = "83151561";
const str2 = "asdsds";
const reg = /\d/;
const reg2 = /\D/;
console.log(reg.test(str)); // true
console.log(reg2.test(str2)); // false
const str = "good good study day day up";
const str2 = "good good study day day_up";
const str3 = "good good study day day=up";
const reg = /\bday\b/;
const reg2 = /\bday_\b/;
const reg3 = /\bday=\b/;
console.log(reg.test(str)); // true
console.log(reg2.test(str2)); // false
console.log(reg3.test(str3)); // true
const str = "123456789";
const reg = /\d\d\d/; // 匹配三个连续的数字
const reg2 = /\d{0,1}/; // 量词的写法
console.log(reg2.test(str)); // true
// match()方法
const str = "111111114564564111151515";
const reg = /1+/g; // 在全局匹配数字1无限次
console.log(str.match(reg)); // ["11111111", "1111", "1", "1"]
const str = "1111Abc456abc111a51b51c5";
const reg1 = /abc/; //区分大小写
const reg2 = /abc/i; // 不区分大小写
console.log(str.match(reg1));
// ["abc", index: 10, input: "1111Abc456abc111a51b51c5", groups: undefined]
console.log(str.match(reg2));
// ["Abc", index: 4, input: "1111Abc456abc111a51b51c5", groups: undefined]
const str = "32\n12"
const reg = /^12/m; // ^起始符
console.log(str.match(reg));
//["12", index: 3, input: "32↵12", groups: undefined]
const str = "asdwjifwef";
const reg1 = /^asdwjifwef$/;
const reg = /^a\w*f$/; // 以a开头，f结尾的所有的字符串
console.log(str.match(reg));
const str = "123A456";
const reg = /\d+a/gi; // 数字无穷，a结尾，全局不区分大小写
console.log(str.match(reg));
const str = "123abc456";
const str2 = "abc";
const arr = str.match(str2);
console.log(arr);
console.log(arr.index); // 出现的位置
console.log(arr.input); // 母字符串
1.3 贪婪匹配、非贪婪匹配
- 贪婪匹配：直接写量词就是贪婪，会从最高次开始匹配
- 非贪婪匹配：在量词后面加?，从最少次次数开始匹配
const str = "AAaaaa123456";
// 贪婪匹配
const reg = /a{0,5}/gi;
// 非贪婪匹配
const reg2 = /a{1,10}?/gi;
console.log(str.match(reg));
// ["AAaaa", "a", "", "", "", "", "", "", ""]
console.log(str.match(reg2));
// ["A", "A", "a", "a", "a", "a"]
- 子集：() 子集（一个整体），被括号包裹起来的就是一个整体
- 或者：| 竖线
- 范围词：[] 有或者的意思
- 匹配汉字：\u4e00-\u9fa5
- \1：转义1必须子集搭配使用
const str = "AB aabbba bb";
const reg1 = /ab+/gi;
const reg2 = /(ab)+/gi;
console.log(str.match(reg1)); // ["AB", "abbb"]
console.log(str.match(reg2)); // ["AB", "ab"]
const str = "abcdefAdsdbfgFH";
const reg = /a|b|g/gi;
const reg2 = /[a-z]/g;
console.log(str.match(reg)); // ["a", "b", "A", "b", "g"]
console.log(str.match(reg2)); // ["a", "b", "c", "d", "e", "f", "d", "s", "d", "b", "f", "g"]
const str = "魔道祖师 so nice";
const reg = /[\u4e00-\u9fa5]/g;
console.log(str.match(reg)); // ["魔", "道", "祖", "师"]
// replace()
const str = "魔道祖师有15集";
const reg = /\d+/g;
// replace()第二个参数字符串的写法
console.log(str.replace(reg, "十五")); // 魔道祖师有十五集
// replace()第二个参数函数的写法
console.log(str.replace(reg, function (){
return "十五";
})); // 魔道祖师有十五集
const str = "A1B2C3A1B2";
const reg = /(A1)|(B2)/g;
console.log(str.replace(reg, function (){
return "a1"; // 所有A1 B2的被替换成a1
})); // a1a1C3a1a1
// replace() 位置置换
const str = "伴她 小机器人 可乐";
const reg = /(伴她)\s(小机器人)\s(可乐)/
console.log(str.replace(reg, "$2 $3 $1")); // 小机器人 可乐 伴她
// $1代表第一个子集，$2代表第二个子集，以此类推
const str = "A1B2C3";
const reg = /(A1)/g;
console.log(str.replace(reg, function(a,b,c,d){
console.log(a); // 返回的是匹配成功的A1
console.log(b); // 返回的是子集里面的A1
console.log(c); // 下标
console.log(d); // 源字符串
})); // A1 A1 0 A1B2C3
const str = "aaabbbcccdddeeefff";
const reg = /(\w)\1+/g;
// 贪婪匹配从最高次数匹配，子集转义\w匹配到小写字母，后面\1是转义前面的\w转义内容重复就累加在后面
console.log(str.match(reg));//["aaa", "bbb", "ccc", "ddd", "eee", "fff"]
const str = "abc";
const reg = /\w/g;
console.log(reg.exec(str)); // ["a", index: 0, input: "abc", groups: undefined]
console.log(reg.exec(str)); // ["b", index: 1, input: "abc", groups: undefined]
console.log(reg.exec(str)); // ["c", index: 2, input: "abc", groups: undefined]
console.log(reg.exec(str)); // null
