正则、捕获组、断言、常用正则

正则表达式

初步认识

        let str = "会涉8及12758星际 378少_女ad09nj5n"
        console.log( fn (str) )

        function fn(str){
            let arr = []   // arr接收s传来的数据
            let s = ""     // 相当于符合条件数据的暂存站
            for (let i=0;i<str.length;i++){   //  遍历字符串str
                let thischar = str[i]        
                if(isNaN(thischar)){         // 若当前数据为非数字，则为true，否则为false
                    s && arr.push(s)      // s 存在，将s传入数组arr
                    s = ""                // s传入后，将s清空
                } else {
                    s = thischar            // 将当前数据赋值给s 
                    s && arr.push(s)       // 传入数组
                }
            }              
            return(arr)
        }					// 打印 ["8", "8", "1", "2", "7", "5", "8", "8", " ", "3", "7", "8", "8", "0", "9", "9", "5", "5"]

        // 以上代码可简化为
        // function fn (){
        //     return str.match(/\d/g)
        // }

        let str = "会涉8及12758星际 378少_女ad09nj5n"
        console.log( fn (str) )

        function fn(str){
            let arr = []   // arr接收s传来的数据
            let s = ""     // 相当于符合条件数据的暂存站
            for (let i=0;i<str.length;i++){   //  遍历字符串str
                let thischar = str[i]        
                if(isNaN(thischar)){         // 若当前数据为非数字，则为true，否则为false
                    s && arr.push(s)      // s 存在，将s传入数组arr
                    s = ""                // s传入后，将s清空
                } else {
                    s += thischar            // 将当前数据赋值给s 
                    s && arr.push(s)       // 传入数组
                }
            }              
            return(arr)  // 打印["8", "8", "1", "12", "127", "1275", "12758", "12758", " ", " 3", " 37", " 378", " 378", "0", "09", "09", "5", "5"]
        }

        let str = "会涉8及12758星际 378少_女ad09nj5n"
        console.log( fn (str) )

        function fn(str){
            let arr = []   // arr接收s传来的数据
            let s = ""     // 相当于符合条件数据的暂存站
            for (let i=0;i<str.length;i++){   //  遍历字符串str
                let thischar = str[i]        
                if(isNaN(thischar)){         // 若当前数据为非数字，则为true，否则为false
                    s && arr.push(s)      // s 存在，将s传入数组arr
                    s = ""                // s传入后，将s清空
                } else {
                    s += thischar            // 将当前数据赋值给s 
                }
            }
            s && arr.push(s)       // 传入数组
            return(arr)    // 打印 ["8", "12758", " 378", "09", "5"]
        }

        // 以上代码可简化为
        // function fn (){
        //     return str.match(/\d+/g)
        // }

1、转义符号—\

所有的ASCII都可以用转义字符+数字(一般都是八进制数字)来表示，之所以称之为转义，是因为加上转移字符后，其意义与加之前的意义不同。

正则表达式中的特殊符号：/、\、{、}、+、?、*、(、)、[、]、^、$、|、. ，这些字符在匹配时，要加转义符

转义字符	描述
.	匹配所有字符，除\n、\r
\a	响铃
\b	单词边界(起止位置，汉字自带边界，不用加)
\B	非单词边界
\f	换页
\n	换行
\r	回车
\t	制表符(table键)
\v	垂直制表符
转义符 \	反斜线字符“\”
转义符 "	一个双引号
转义符 ’	一个单引号
?	问号
\0	空字符NULL
\w	字母、数字、下划线字符
\W	非字母、数字、下划线字符
\d	单个数字字符
\D	非数字字符
\s	空白字符(空格、制表、回车、换行、垂直换行、换页)
\S	非空白字符(非空格、制表、回车、换行、垂直换行、换页))
\xxx	以八进制数xxx规定的字符
\xdd	以十六进制dd规定的字符
\uxxxx	以十六进制xxxx规定的Unicod字符

        let r = new RegExp("admin")  // 等同于  let r = /admin/  RegExp对象：正则表达式，用于字符串模式匹配
        let s = "djnsadmindjsk"
        console.log( r.test(s) );  // true  检测字符串s中有无r,结果为布尔值

二、量词

量词	描述
n+	匹配任何包含至少一个n的字符串，相当于 n{1,}
n*	任何包含零个或多个n的字符串, 相当于 n{0,}
n?	任何包含零个或一个n的字符串 ,相当于 n{0,1},当不确定n有无时，用?。
n{x}	包含x个n的序列的字符串
n{x,y}	包含至少x个，至多y个n的序列的字符串
n{x,}	包含至少x个n的序列的字符串
$	结束字符
^	开始字符
?=n	匹配任何其后紧跟指定字符n的字符串
?!n	匹配任何其后没有紧跟指定字符n的字符串

        // 代码一
        let str = "17847632987"
        let reg1 = /\d{11}/g    // 全局匹配11位数字
        console.log(str.match(reg1));
        // 打印 ["17847632987", index: 0, input: "17847632987", groups: undefined]0: "17847632987"groups: undefinedindex: 0input: "17847632987"length: 1__proto__: Array(0)
        let reg2 = /\d{12}/g      // 全局匹配11位数字
        console.log(str.match(reg2));    // null

        // 代码二
        let str = "abd1637ks790"
        let reg = /\d{1,7}/g   // 匹配至少一位，至多七位数字，且是连续的
        console.log(str.match(reg));
        // ["1637", index: 3, input: "abd1637ks790", groups: undefined]0: "1637"groups: undefinedindex: 3input: "abd1637ks790"length: 1__proto__: Array(0)

        // 代码三
        let str = "ahsbjsnjs"
        let reg = /[d]{0,1}/g       // ""
        // let reg = /ahsbjd?snjs/g    // "ahsbjsnjs"
        console.log(str.match(reg)); 

        // 代码四
        let str = "ahsbjsnjs"
        // let reg = /^sbjs$/g       // null
        let reg = /^ahsbjsnjs$/g    // "ahsbjsnjs"
        console.log(str.match(reg));

三、常用方法

方法	描述
test	reg.test(str) 从字符串str中匹配 reg,有则为true，无为false
match	str.match(reg) 从字符串str中匹配reg,有则返回匹配完的数据，无则为null
replace	str.replace(reg,replacestr) 替换正则匹配成功的字段
split	分割字符串

        let str = "两只老虎，两只老虎，跑得快"
        let reg = /老虎/g
        let newStr = str.replace(reg, "老鼠")
        console.log(newStr);                    // 两只老鼠，两只老鼠，跑得快

        // 脏字过滤
        let str = "笨蛋，傻逼，恶心，你好"
        let reg = /傻逼|尼玛|垃圾|废物|恶心|笨蛋/g
        let newStr = str.replace(reg,"**")
        console.log(newStr);                // **，**，**，你好

        // 脏字过滤,根据字数来确定*个数
        let str = "笨蛋，傻逼，恶心，你好,草，你大爷"
        let reg = /傻逼|尼玛|垃圾|废物|恶心|笨蛋|草|你大爷/g
        let newStr = str.replace(reg, (a) => {
            // 多个形参
            // 第一个形参：每次匹配的整体内容
            // 第二个形参：第一个子项
            // 第三个形参：第二个子项
            return "*".replace(a.length)
        })
        console.log(newStr);                // **，**，**，你好,*，***

        let str = "属性1加上2新技术3肯定4"
        let newStr = str.split(/\d+/)
        console.log(newStr);   ["属性", "加上", "新技术", "肯定", ""]

四、修饰符

修饰符	描述
i	不区分大小写匹配
g	全局匹配
m	换行匹配

五、方括号意义(在方括号中，-和转义符、. 、[、]有特殊意义)

表达式	描述
[abc]	查找方括号内的任意字符，查找a或b或c
[^abc]	查找任何不在方括号内的字符，如查找d或e
[0-9]	匹配数字0到9
[a-z]	匹配小写字母a到z
[A-Z]	匹配大写字母A到Z
[A-z]	匹配大写字母A到小写字母z，ASCII英文字母是从大写开始的
(sky|blue)	匹配指定选项，匹配sky或者blue

        // 代码五
        let str = "ahsbjsnjs"
        // let reg = /[a-k]/g    // ["a", "h", "b", "j", "j"]
        // let reg = /[A-K]/g    // null
        // let reg = /[A-K]/ig      // ["a", "h", "b", "j", "j"]
        let reg = /[A-K]/i       // ["a", index: 0, input: "ahsbjsnjs", groups: undefined]
        console.log(str.match(reg)); 

        // 代码六
        let str = "0482736119734518ajsn"
        // let reg = /[1-9]\d{4,10}/g       //["48273611973", index: 0, input: "482736119734518", groups: undefined]  第一位是1到9任意一个，其后是至少4个，至多10个数字
        // let reg = /^[1-9]\d{4,10}$/g       // null
        // let reg = /[3-7]/g                   //  ["4", "7", "3", "6", "7", "3", "4", "5"]
        // let reg = /[1-5]+/g               // ["4", "2", "3", "11", "3451"]
        // let reg = /[^\d]/g                   // ["a", "j", "s", "n"]
        // let reg = /[^\d]+/g                  //  ["ajsn"]
        // let reg = /[891]ajsn/g                // ["8ajsn"]  8或9或1的任意一个
        let reg = /[391]ajsn/g                // null
        console.log(str.match(reg)); 

        // 代码七
        let str = "abcd\n\r\t"
        // let reg = /abc|d/g            // ["abc", "d"]  匹配abc或者d
        // let reg = /ab(c|d)/g          // ["abc"]
        // let reg = /ab(d|c)/g          // ["abc"]
        // let reg = /ab(c|d)/          //  ["abc", "c", index: 0, input: "abcd", groups: undefined]
        let reg = /./g                  // ["a", "b", "c", "d", " "]  . 不匹配\n、\r
        console.log(str.match(reg)); 

六、子项和捕获组(\+数字，代表对子项的重复)

        // 代码八
        let str = "abcdjcjabckc"
        let reg = /abc+/g                // ["abc", "abc"]        无
        // let reg = /(abc)+/g               // ["abc", "abc"]      abc
        console.log(str.match(reg));  
        console.dir(RegExp.$1)

        // 代码九
        let str = "123321"
        // let reg = /(\d{3}){2}/g                // ["123321"] 量词是把正则规则重复
        let reg = /(\d{3})\1/g                     // null
        console.log(str.match(reg));
        let str = "123123"
        let reg = /(\d{3})\1/g                     // ["123123"] 捕获组是把匹配结果重复
        console.log(str.match(reg));

        // 代码十
        let str = "2020-12-27"
        let reg = /(\d{4})-(\d{2}-(\d\d))/g                // ["2020-12-27"],捕获组分为普通捕获组和命名捕获组。一般是指普通捕获组，捕获组就是把正则表达式中子项匹配的内容，保存到内存中以数字编号或显式命名的组里，方便后面引用。此处 (\d{4})-(\d{2}-(\d\d)) 编号为0，(\d{4})编号为1，(\d{2}-(\d\d))编号为2，(\d\d)编号为3
        console.log(str.match(reg));

		// 代码十一
        let str = "123sjzaj321"
        let reg = /(\d{3})sjzaj(\d{3})/   //会将子项分离出来，并编码
        console.log(str.match(reg));  
        // (3) ["123sjzaj321", "123", "321", index: 0, input: "123sjzaj321", groups: undefined]0: "123sjzaj321"1: "123"2: "321"groups: undefinedindex: 0input: "123sjzaj321"length: 3__proto__: Array(0)
        console.log(RegExp.$1);      // 123
        console.log(RegExp.$2);      // 321

		// 代码十二
        let str = "123sjzaj123"
        let reg = /(\d{3})sjzaj\1/   // \1被称为捕获组，将前面一个子项重复一遍
        console.log(str.match(reg));  
        // (3) ["123sjzaj321", "123", "123", index: 0, input: "123sjzaj123", groups: undefined]0: "123sjzaj123"1: "123"2: "123"groups: undefinedindex: 0input: "123sjzaj123"length: 3__proto__: Array(0)

七、断言(想要匹配某个规则，但不想结果有这个规则)

1.正向断言

        // let str = "windows2000"          // 只匹配windows后为2000的字符串 ["windows"]结果不带2000，且无子项
        let str = "windows98"               // null
        let reg = /windows(?=2000)/         
        console.log(str.match(reg));

        // let str = "winows2000"          // null
        let str = "windows98"               // 匹配windows后不为2000的字符串  ["windows"]
        let reg = /windows(?!2000)/         
        console.log(str.match(reg));

        let str = "我98岁"
        // let reg = /我(?=98岁)/g                 // 才没有98岁
        let reg = /(?=98岁)/g                       // 我才没有98岁
        console.log(str.replace (reg,"才没有"))

2.反向断言

        let str = "1919"
        let reg = /(?<=19)19/              // ["19"]
        console.log(str.match(reg));

        // let str = "2119"         // ["19"]
        let str = "2019"            // null
        // let str = "1919"            // ["19"]
        let reg = /(?<!20)19/
        console.log(str.match(reg));

八、常用正则

        let reg = {
            // 匹配整段内容都要加起止符
            // QQ  5-10位数字，不可以0开头
            qq: /^[1-9]\d{4-9}$/,
            // 用户名 数字、字母、下划线，长度一般为6-12，不以数字开头.当规定要有两种字符时，可先判断是否有两种字符，再根据正则匹配，或者用 | 来一直写，可读性不高
            user: /^[a-z_]\w{5,11}$/i,
            // 密码  8-16位，数字、字母、特殊字符除\外
            password: /^[\w<>,?/:；|!@#$%&*()+"'{}\[\]\.\-]{8,16}$/,
            //  手机号 11位  第一位是1，第二位不能是0、1和2，
            tel: /^1[3-9]\d{9}$/,
            // 邮箱   ...@xx.com.cn
            email: /^\w+@[a-z0-9]+(\.[a-z]{2,}){1,2}$/i  
        }
        
        // 密码满足规则判断
        if(/^\d+$/.test(str)){
            console.log("密码不能为纯数字");
        } else if(/^[a-z]$/i.test(str)) {
            console.log("密码不能为纯字母");
        } else if(reg.password.test(str)){
            console.log("满足规则");
        } else {
            console.log("不满足规则");
        }