正则表达式 - RegExp 对象

文章仅记录了es5及之前的用法，es6新增加的部分可参考：阮一峰正则的文章

RegExp 对象

正则表达式是描述字符模式的对象。

正则表达式用于对字符串模式匹配及检索替换，是对字符串执行模式匹配的强大工具。

语法

正则表达式 ：/正则表达式主体/修饰符(可选)

pattern（模式）

modifiers(修饰符)

    var patt=new RegExp(pattern,modifiers);
    // 或者更简单的方式:
    var patt=/pattern/modifiers;

修饰符

修饰符	描述
i	忽略大小写，并只作用第一个匹配的元素
g	全局匹配所有行的元素
m（Multiline）	执行多行匹配。

    // i 和 g
    let str = "OneLine Runoob runoob runoob! \nrunoob runoob ";
    let partten1 = /runoob/i;
    let partten2 = /runoob/g;
    let val1 = str.replace(partten1, "lwx");
    let val2 = str.replace(partten2, "lwx");
    console.log(val1); // OneLine lwx runoob runoob! runoob runoob  忽略大小写并只作用第一个匹配的元素
    console.log(val2); // OneLine Runoob lwx lwx! lwx lwx全局匹配所有行的元素

    // 着重说下 m 修饰符
    var str = "This is an\n antzone good";
    var reg1 = /an/;
    var reg2 = /an/m;
    var reg3 = /an$/; // $量词: 匹配结尾的字符串 $量词要跟m修饰符搭配，不然$作用失效
    var reg4 = /an$/m;
    console.log(str.match(reg1)); // ['an', index: 8, input: 'This is an\n antzone good', groups: undefined]
    console.log(str.match(reg2)); // ['an', index: 8, input: 'This is an\n antzone good', groups: undefined]
    console.log(str.match(reg3)); // null
    console.log(str.match(reg4)); // ['an', index: 8, input: 'This is an\n antzone good', groups: undefined]

字符串方法

    let str1 = "Visit Runoob!";
    let str2 = "Visit Runoob runoob!";
    var pattern = new RegExp("runoob", "i"); //同 var pattern = /runoob/i;

    // 字符串方法：search
    let n = str1.search(pattern); // 使用正则表达式
    console.log(n); // 下标:6

    let m = str1.search('sit'); // 使用字符串
    console.log(m); // 下标:2

    // 字符串方法：replace
    let a = str1.replace(pattern, "Hourse"); // 使用正则表达式
    console.log(a); // "Visit Hourse!"

    let b = str1.replace("Runoob", "Hourse"); // 使用字符串
    console.log(b); // "Visit Hourse!"

    // 字符串方法：match
    var pattern2 = /runoob/gi;
    let f = str2.match(pattern2); // 使用正则表达式
    console.log(f); //['Runoob', 'runoob']     如果匹配不到就返回null
    let c = str2.match("Runoob"); // 使用字符串
    console.log(c, c instanceof Array); // ['Runoob', index: 6, input: 'Visit Runoob runoob!', groups: undefined] true

    // 字符串方法：split
    var pattern2 = /runoob/ig
    let d = str2.split(pattern2); // 使用正则表达式
    console.log(d); // ['Visit ', ' ', '!']
    let e = str2.split("Runoob"); // 使用字符串
    console.log(e); // ['Visit ', ' runoob!']

补充下replace的用法，真香：

replace的参数有点特殊:
1.当有括号匹配时,有v1和v2等,这个长度取决于有多少个()，可以使用$1、$2这样的写法
2.当没有括号时,没有v的参数，不可以使用$1、$2这样的写法，因为比如$1匹配的是正则的第1个子正则的数据

// 参数无括号的情况下：
const camelToKebab1 = (str) => str.replace(/[A-Z]/g, (match, pos, val) => {
    return '-' + match.toLowerCase()
});
let res1 = camelToKebab1('backgroundColor');
console.log(res1); // 'background-color'

// 参数有括号的情况下：
const camelToKebab1 = (str) => str.replace(/([a-zA-Z])([A-Z])/g, (match, v1, v2, pos, val) => {
    return v1 + '-' + v2.toLowerCase()
});
let res1 = camelToKebab1('backgroundColor');
console.log(res1); // 'background-color'

const camelToKebab2 = (str) => str.replace(/([a-zA-Z])([A-Z])/g, '$1-$2').toLowerCase();
let res2 = camelToKebab2('backgroundColor');
console.log(res2); // 'background-color'

正则表达式方法

    let str = "Visit Runoob runoob!";
    var pattern = /runoob/i;
    // 正则表达式方法：test()
    let a = pattern.test(str)
    console.log(a);  // true

    // 正则表达式方法：exec()
    let b = pattern.exec(str)
    console.log(b,b instanceof Array);  // ['Runoob', index: 6, input: 'Visit Runoob!', groups: undefined] true
    //返回一个数组,index、input、groups等这是数组的属性,但信总任然由疑惑，数组还能长这样??

    // 正则表达式方法：toString()
    let c = pattern.toString()
    console.log(c); // "/runoob/i"

方括号(查找某个范围内的字符)

表达式	描述
[abc]	查找方括号之间的任何字符。
[^abc]	查找任何不在方括号之间的字符。(注意：取反^是在方括号之内使用才生效)
[0-9]	查找任何从 0 至 9 的数字。
[a-z]	查找任何从小写 a 到小写 z 的字符。
[A-Z]	查找任何从大写 A 到大写 Z 的字符。
[A-z]	查找任何从大写 A 到小写 z 的字符。
[adgk]	查找给定集合内的任何字符。
[^adgk]	查找给定集合外的任何字符。
(red|blue|green)	查找任何指定的选项。

    // 举个例子：
    var str = "Is this all there is?";
    var patt = /[a-h]/g;
    var res = str.replace(patt, '--')
    console.log(res); // Is t--is --ll t----r-- is?

元字符（代表特殊含义的字符）

元字符	描述
.	查找单个字符，除了换行和行结束符。
\w	查找数字、字母及下划线。 (w 是 word 的缩写，就是字母 a-z，数字 0-9，不包括逗号、句号、加减乘除号、括号等)
\W	查找非单词字符。
\d	查找数字。(d 是 digit 这个单词的缩写，它的中文意思就是「数字」)
\D	查找非数字字符。
\s	查找空白字符。(s 是 space 的缩写，就是空白的意思)
\S	查找非空白字符。
\b	匹配单词边界。 (b 是 boundary 的缩写，中文就是边界的意思)
\B	匹配非单词边界。
\n	查找换行符。(n 是 newline 的缩写，中文就是换行)
\f	查找换页符。
\r	查找回车符。(r 就是 return 的缩写，回车在这里就是它的中文意思)
\t	查找制表符。(tab 键打出来的一串用以缩进的空白字符)
\v	查找垂直制表符。
\xxx	查找以八进制数 xxx 规定的字符。
\xdd	查找以十六进制数 dd 规定的字符。
\uxxxx	查找以十六进制数 xxxx 规定的 Unicode 字符。

    // 举个例子：
    var str = "That's hot!";
    var patt = /h.t/g;
    var res = str.replace(patt, '--')
    console.log(res); // T--'s --!  匹配的时hat和hot

量词

量词	描述
n+	匹配任何包含至少一个 n 的字符串。例如，/a+/ 匹配 "candy" 中的 "a"，"caaaaaaandy" 中所有的 "a"。
n*	匹配任何包含零个或多个 n 的字符串。例如，/bo*/ 匹配 "A ghost booooed" 中的 "boooo"，"A bird warbled" 中的 "b"，但是不匹配 "A goat grunted"。
n?	匹配任何包含零个或一个 n 的字符串。例如，/e?le?/ 匹配 "angel" 中的 "el"，"angle" 中的 "le"。
n{X}	匹配包含 X 个 n 的序列的字符串。例如，/a{2}/ 不匹配 "candy," 中的 "a"，但是匹配 "caandy," 中的两个 "a"，且匹配 "caaandy." 中的前两个 "a"。
n{X,}	X 是一个正整数。前面的模式 n 连续出现至少 X 次时匹配。例如，/a{2,}/ 不匹配 "candy" 中的 "a"，但是匹配 "caandy" 和 "caaaaaaandy." 中所有的 "a"。
n{X,Y}	X 和 Y 为正整数。前面的模式 n 连续出现至少 X 次，至多 Y 次时匹配。例如，/a{1,3}/ 不匹配 "cndy"，匹配 "candy," 中的 "a"，"caandy," 中的两个 "a"，匹配 "caaaaaaandy" 中的前面三个 "a"。注意，当匹配 "caaaaaaandy" 时，即使原始字符串拥有更多的 "a"，匹配项也是 "aaa"。
n$	匹配任何结尾为 n 的字符串。
^n	匹配任何开头为 n 的字符串。
?=n	匹配任何其后紧接指定字符串 n 的字符串。
?!n	匹配任何其后没有紧接指定字符串 n 的字符串。

    // 举个例子：
    var str = "Hellooo World! Hello Runoob!";
    var patt = /o+/g;
    var res = str.replace(patt, '--')
    console.log(res); // Hell-- W--rld! Hell-- Run--b! 

RegExp 对象属性

属性	描述
constructor	返回一个函数，该函数是一个创建 RegExp 对象的原型。
global	判断是否设置了 "g" 修饰符
ignoreCase	判断是否设置了 "i" 修饰符
lastIndex	用于规定下次匹配的起始位置
multiline	判断是否设置了 "m" 修饰符
source	返回正则表达式的匹配模式

属性介绍不做赘述，请自行查看官网！！！

自行测试用法

一个很容易错误的点，构造函数的写法中，引号中遇到\时需要在前面加\进行转义

// 1.字面量创建 正则
let reg1 = new RegExp("^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[^]{8,16}$"); // reg1 写法错误，引号内的 \ 需要加 \ 进行转义
let reg2 = new RegExp("^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[^]{8,16}$"); // 正确写法
// 2.构造函数创建 正则
let reg3 = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[^]{8,16}$/; // 正确写法

let res1 = reg1.test("testTest123")
let res2 = reg2.test("testTest123")
let res3 = reg3.test("testTest123")
console.log(res1); // false
console.log(res2); // true
console.log(res3); // true