js 正则表达式

RegExp.test()

函数返回boolean。

匹配多少次

const str = '1212abcdsf11abc11dfsd11abc12';
const reg = /abc/g;
let n = 0;
while(reg.test(str)){
    n++
}
console.log(`匹配了${n}次`);

• 正则表达式默认是贪婪模式
• 在量词后面加上？，启动非贪婪模式 如+？，？？，*？。

RegExp.exec()

返回的匹配结果，是一个真数组，判断一个数组是不是真数组，Array.isArray().

const str = '1212abcdsf11abc11dfsd11abc12';
const reg = /abc/g;

console.log(reg.exec(str));

• 0：匹配的结果
• index:匹配到的结果在原始字符串的位置
• input：原始字符串

得到匹配结果和位置

const str = '1212abcdsf11abc11dfsd11abc12';
const reg = /abc/g;

// 得到匹配结果和位置
let res;
while(res = reg.exec(str)){
    console.log(`匹配结果：${res[0]} 匹配位置:${res.index}`)
}

字符串中有关正则的方法

String.prototype.match()

返回一个匹配的数组

const str = '1212abcdsf11abc11dfsd11abc12';
const reg = /abc/g;

console.log(str.match(reg));

String.prototype.search()

得到整个字符串第一次匹配的下标

const str = '1212abcdsf11abc11dfsd11abc12';
const reg = /abc/g;

console.log(str.search(reg)); //4

String.prototype.split()

按照正则表达式匹配的规则分割
[字符范围] //匹配一个字符

const str = 'sdfds-213 sdf,sdfs,sfdf?sdfsdf';

// 将字符串按照，- ？空格进行分割
console.log(str.split(/[,\- ?]/g))

String.prototype.replace()

替换，返回一个新的字符串，不会改变原来的字符串。

String.replace(a,b);

• 参数a可以是字符串，但是只匹配一次，因为将其转化为new RegExp(a)。
• 参数b可以为替换的字符串，可以是一个函数

const str = 'hello world';

 const newStr = str.replace(/\b[a-z]/g,function(match){
    //  match为匹配到的字符 
    // return 返回的是将原来的字符串变为匹配到的
    return match.toUpperCase();
 })
 console.log(newStr); // 'Hello World'

const str = 'hello world   js';
const newStr = str.replace(/\s*\b[a-z]\s*/g,function(match){
    return match.toUpperCase().trim();
})
console.log(newStr);//HelloWorldJs

敏感词汇替换

function getResult(str,rep){    
    const senWordArr = ['色情','牛逼'];
    // /(色情|牛逼)+/g
    const reg = new RegExp(`(${senWordArr.join('|')})+`,'g');
    return str.replace(reg,rep);
}
// ssdfsd**sdfsdf**是对方
console.log(getResult('ssdfsd色情色情sdfsdf牛逼是对方','**'));

捕获组

用小括号包裹的部分叫做捕获组，捕获组会出现在匹配结果中

捕获组可以命名，叫做具名捕获组

var reg = /(\d[a-z])([a-z]+)/g;
var s = "2afsdf-5fdgdfg-9asddf";
while (result = reg.exec(s)) {
            console.log(result);
}

• 0:是匹配的结果
• 0后面的数字是 捕获组匹配的结果

const str = '2012-09-23,2021-4-1,2019-2-22';

const reg = /(\d{4})-(\d{1,2})-(\d{1,2})/g;

while(res = reg.exec(str)){
    console.log(`${res[0]} 年${res[1]} 月${res[2]} 日${res[3]}`);
}

具名捕获组

const str = '2012-09-23,2021-4-1,2019-2-22';

// 具名捕获组 (?<捕获组的名字>) 可以通过res.groups.捕获组名字来获取
const reg = /(?<year>\d{4})-(?<month>\d{1,2})-(?<day>\d{1,2})/g;

while(res = reg.exec(str)){
    // console.log(`${res[0]} 年${res[1]} 月${res[2]} 日${res[3]}`);
    console.log(`${res[0]} 年${res.groups.year} 月${res.groups.month} 日${res.groups.day}`);
}

非捕获组

(?:)
小括号作为整体，不去捕获组，提高性能。groups中就不会存在值了。

捕获组和String.prototype.replace()结合

const str = '2012-09-23,2021-4-1,2019-2-22';
const reg = /(\d{4})-(\d{1,2})-(\d{1,2})/g;

//g1,g2,g3 就是捕获组的结果
const s = str.replace(reg,function(match,g1,g2,g3){
    return `${g1}/${g2}/${g3}`;
})
// 2012/09/23,2021/4/1,2019/2/22
console.log(s);

//第二个参数可以是一个字符串，$1表示第一个捕获组
const s = str.replace(reg,'$1/$2/$3');

反向引用

在正则表达式中，使用某个捕获组，\捕获组编号

const reg = /(\d{2})\1/;

上面这正则的意思就是，捕获组1捕获的结果，在出现一次。

若是捕获组捕获到’13’，那么这个正则表示式最后要匹配’1313’。

应用

找出字符串连续出现的字符

const str = 'aaaabbbbccccdfdsssssa';
const reg = /(\w)\1+/g;
while(res = reg.exec(str)){
	console.log(res[1]); //a b c s
}

正向预查

检查某个字符后面的字符是否满足某个规则，该规则不成为匹配结果，并且不称为捕获组

const str = 'asdfaASDFsT123123asdfa212112sfsdfn32131';

// 找到有面有数字的一个字符 
// （?=）只是起到一个预查的作用
const reg = /[a-z|A-Z](?=\d+)/g;
while(res = reg.exec(str)){
    // T a n
    console.log(res[0]);
}

应用

const str = '1334234344234234235';
const reg = /\B(?=(\d{3})+$)/g;
const newStr = str.replace(reg,',');
console.log(newStr);
//1,334,234,344,234,234,235

负向断言(预查)

检查某个字符后面的字符是否不满足某个规则，该规则不成为匹配结果，并且不称为捕获组

const str = 'ts121as2112ns342';
// 找到后面不是数字的字符
const reg = /[a-zA-Z](?!\d+)/g;

while(res = reg.exec(str)){
	// t a n
    console.log(res[0]);
}

判断密码强度

要求密码中必须出现小写字母、大写字母、数字、特殊字符（!?@.)，6-12位。

const reg = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!?@.]).{6,12}$/g;

console.log(reg.test('sdfA12?'))

例题

• 密码长度为6-12位
• 出现小写字母、大写字母、数字、特殊字符(!?.@) ->强
• 出现小写字母、大写字母、数字 ->中
• 出现小写字母、大写字母 ->弱
• 其它 ->不满足要求

function judgePassWord(str){
    if(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!?@.]).{6,12}$/.test(str)){
        return '强'
    } else if(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{6,12}$/.test(str)){
        return '中';
    } else if(/^(?=.*[a-z])(?=.*[A-Z]).{6,12}$/.test(str)){
        return '弱';
    } else {
        return '不满要求';
    }
}