正则表达式

最新推荐文章于 2022-08-17 16:01:56 发布

不会说话的爱情

最新推荐文章于 2022-08-17 16:01:56 发布

阅读量129

点赞数

文章标签： javascript

本文链接：https://blog.csdn.net/weixin_45348067/article/details/103897240

版权

判断字符串是否符合规则

    /* var reg=/a/g;
    var reg=new RegExp("a","g"); */
    //两个部分，一个是正则匹配内容，另一个是修饰符部分。
    //i  不区分大小写
    //g  全局  从头查找到尾部
    // m  匹配多行

    /* var str="abcabcafc";
    str=str.replace(/a/i,"z") */
    //reg.flags 就是修饰符
    //reg.source  就是正则匹配内容

    // reg.exec();查找字符串中满足正则匹配的内容，并且返回一个数组，只有一个元素，包括几个属性。群组，索引，字符串本身
    // reg.test();判断字符串是否满足正则匹配内容
    /* console.log(reg.test("abc"))
    var str="abc";
    if (/a/.test(str)) {
        
    } */

    /* //字符串的方法
    var str="abcdefab";
    // str.search()按照正则查找字符串中的内容，返回优先查找到的第一个元素下标
    str.replace();
    str.match();
    // str.split();按照正则表达式匹配内容切割字符串
    console.log(str.search(/a/));
    console.log(str.split(/[cf]/));//c或者f切割，自动全局切割
    console.log(str.match(/a/));
    // console.log(str.replace(/a/g,"z"));//全局替换a为z
    console.log(str.replace(/a/g,function(item,index) {
        if(index===0) return "x";
        return "y";//将字符串a替换成x,下一个替换成y
    }));
    var arr=[];
    str=replace(/a/g,function(item,index) {
        arr.push(index);//查找正则所有匹配的元素
    });
    str=str=replace(/[bdf]/g,"0");//把任何满足正则内容的进行替换
    str.replace(/[abc]/g,function(item,index) {
        switch (item) {
            case a:return "1";

            case b:return "2";
            case c:return "3";

               
        }
    })

    console.log(str.match(/a/g));//如果不加全局可以达到exec的目的，如果加全局就会只返回找到的所有元素；
    // 如果加群组，不加全局，除返回找到的元素外，还返回群组元素 */

元字符

/* /^(?=\D[0-9])(?=.*[a-z])(?=.[A-Z])[a-zA-Z0-9]{8,16}$/;
console.log(“cetcotcat”.match(/c.t/g));
console.log(“cetcotcat”.match(/c[ae]t/g)); */
//[1-31]匹配1,2,3，【】中括号中的点是字符串点写在中括号里面的中括号必须转义

    //.  可以任意匹配一个字符    \转义为字符串    []里面的内容可以任意匹配一个内容
    //反义字符类  在【】中第一位使用^，表示除了^后面的字符外都满足；
    // 不是第一位就是字符串^
    // console.log("abcafcadcaec".match(/a[^f]c/g))  不要f
    // console.log("abcafcadcaec".match(/a[f^a]c/g)) 满足f^a


    /* 基本符号：
    ^  表示匹配字符串的开始位置  (例外  用在中括号中[ ] 时,可以理解为取反,表示不匹配括号中字符串)
    $  表示匹配字符串的结束位置
    *  表示匹配 零次到多次
    +  表示匹配 一次到多次 (至少有一次)
    ?  表示匹配零次或一次
    .  表示匹配单个字符 
    |  表示为或者,两项中取一项
    (  ) 小括号表示匹配括号中全部字符
    [  ] 中括号表示匹配括号中一个字符 范围描述 如[0-9 a-z A-Z]
    {  } 大括号用于限定匹配次数  如 {n}表示匹配n个字符  {n,}表示至少匹配n个字符  {n,m}表示至少n,最多m
    \  转义字符 如上基本符号匹配都需要转义字符   如 \*  表示匹配*号
    \w 表示英文字母和数字  \W  非字母和数字
    \d  表示数字   \D  非数字 */

    /* console.log("c0tcotcat".match(/c.t/g));//c0t,cot,cat
    console.log("cetc.tcat".match(/c\.t/g));//c.t
    console.log("caaaatcbbbt".match(/c...t/g));
    console.log('cetcatcot'.match(/c[eo]t/g));//cet,cot,e或者o
    console.log("abca[]cadcaec".match(/a[\[\]]c/g))//中括号里面的中括号需转义\[\];
    console.log("abcafcadcaec".match(/a[^f]c/g));//中间不要f
    console.log("abcaf^acadcaac".match(/a[f^a]c/g));//^如果在[]不是第一位,就表示字符
    var str=" ac 4 bg12 ed";
    // str=str.replace(/\s/g,"");//去除空白字符
    // str=str.replace(/\S/g,"");//去除非空白字符
    // str=str.replace(/\w/g,"%");
    // str=str.replace(/\W/g,"");
    console.log(str); */

    // console.log("123123".match(/(123){2}/g));//查找匹配两次123的123123
    // console.log("1233123".match(/123{2}/g));1233
    // console.log("aaaaaa".match(/a{0}/g));匹配空字符 ["", "", "", "", "", "", ""]
    // console.log("ababa".match(/b{0}/g)); //["", "", "", "", "", "", ""]

    // console.log("caaaaaatcbbbbbt".match(/a{2,4}/g));["aaaa", "aa"]
    // 最大允许4，最小允许2次,贪婪匹配，先匹配最大的
    // console.log("aaaaaacthhh".match(/a{0,4}/g));["aaaa", "aa", "", "", "", "", "", ""]
    // console.log("caaaaatcbbbbt".match(/c.{4,5}t/g));["caaaaat", "cbbbbt"]
   
    console.log(/colou{0,1}r/.test("color"));//true;
    console.log(/colou{0,1}r/.test("colour"));//true
    console.log("bbbabbbaaabbbbaabbb".match(/a{1,}/g));//["a", "aaa", "aa"]
    console.log("bbbabbbaaabbbbaabbb".match(/a{0,}/g));//["a", "aaa", "aa"]
    //["", "", "", "a", "", "", "", "aaa", "", "", "", "", "aa", "", "", "", ""]
    // ?  {0,1}
    // +  {1,}
    // *  {0,}
    // console.log("sasasasasas".match(/a+/g));//["a", "a", "a", "a", "a"]
    console.log("aasasasasas".match(/a?/g));
    //["a", "a", "", "a", "", "a", "", "a", "", "a", "", ""]
    console.log("aasasasasas".match(/a*/g));
    // ["aa", "", "a", "", "a", "", "a", "", "a", "", ""]

/.*?/ 非贪婪匹配

    console.log("aaaaaaaaaaa".match(/a{2,5}/g));["aaaaa", "aaaaa"]
    console.log("aaaaaaaaaaa".match(/a{2}/g));["aa", "aa", "aa", "aa", "aa"]
    console.log("aaaaaaaaaaa".match(/a.*?/g));["a", "a", "a", "a", "a", "a", "a", "a", "a", "a", "a"]
    console.log("caacataatcbbbbt".match(/c.*?t/g));

/*
var obj={
a:1,
b:2,
cd:10,
efg:11
}
// console.log(JSON.stringify(obj));{“a”:1,“b”:2,“cd”:10,“efg”:11}
var str=JSON.stringify(obj);
console.log(str.match(/".+?"/g)); */

    var str="<div>def<span>ghi<span></div><div><a href='#'>abc</div>";
    console.log(str.match(/<\/?.+?>/g));//匹配0或一个的/加上至少一个以上的任意字符到>结束
    ["<div>", "<span>", "<span>", "</div>", "<div>", "<a href='#'>", "</div>"]
    str=str.replace(/<\/?.+?>/g,function(item){
        console.log(item);
        return  /\//.test(item)?  "</p>" : "<p>";
    });
    console.log(str);
    // <p>def<p>ghi<p></p><p><p>abc</p>

或者，起始，结束

^起始 $结束 ^在[]中表示反义

    // console.log("catdogcetdag".match(/[cd][ao][tg]/g));["cat", "dog", "dag"]
    // console.log("catdogcetdag".match(/[catdog]/g));
    // ["c", "a", "t", "d", "o", "g", "c", "t", "d", "a", "g"]
    // console.log("catdogcetdag".match(/cat|dog/g));["cat", "dog"]
    // 或者,可以用来匹配多个字符或者另外得字符
    // console.log("abcd".match(/c|b/g));["b", "c"]
    // console.log("abcd".match(/[cb]/g));["b", "c"]
    console.log("abcdef".match(/|a|b/g));//如果|得一端没有内容,则认为匹配空字符
    // ["", "", "", "", "", "", ""]
    console.log("abcdef".match(/a||b/g));//如果|得一端没有内容,则认为匹配空字符
    // ["a", "", "", "", "", "", ""]
    console.log("abcdef".match(/a|d|/g));//如果|得一端没有内容,则认为匹配空字符
    // ["a", "", "", "d", "", "", ""]
    console.log("1".match(/[1-9]|[12][0-9]3[01]/g));

列子

在这里插入图片描述
var input,span;
init();
function init() {
input=document.querySelector(“input”);
span=document.querySelector(“span”);
input.addEventListener(“input”,inputHandler);
}
function inputHandler(e) {
if(this.ids) return;
this.ids=setInterval(function(elem) {
clearInterval(input.ids);
elem.ids=null;
change(input.value);
},500,this)
}
function change(txt){
console.log(txt.match(/^{[1-9]$|^[12][0-9]$|}3[01] $if (/^[1-9]$ |¹[0-9] $^3[01]$ /.test(txt)) {
span.textContent=“输入争取”;
}else{
span.textContent=“错误”;
}

群组

    console.log("17487382334".match(/(\d{3})(\d{4})(\d{4})/));
   /*  0: "17487385465"
    1: "174"
    2: "8738"
    3:"2334",*/
    var str="17487382334".match(/(\d{3})(\d{4})(\d{4})/).slice(1).reduce(function(value,item,index) {
        console.log(value,item);
        return index===1 ? value+"****":value+item;
    })
    console.log(str);//174****2334
     // $1就是第一个群组,$2就是第二个群组,$3就是第三个群组
     var str="17487382334".replace(/(\d{3})(\d{4})(\d{4})/,"$1****$3")
     console.log(str);

?= ?! ?<= ?<! 断言

    //  console.log("abcdadef".match(/a(?=d)/g));//满足a后面是d的a
    //  console.log("a0bcd adef a&cd".replace(/a(?=d)/g,"0"));a0bcd 0def a&cd
    // console.log("a0bcd adef a&cd".replace(/a(?=[a-z])|a(?=[0-9])/g,"1"))
    // 10bcd 1def a&cd
    console.log("a0bc adef a&bc".replace(/a(?![a-z])/g,"1"));
    //10bc adef 1&bc   ,相当于不等于
    console.log("a0bc adef a&bc".replace(/(?<=[0-9])b/g,"1"));
    //前置条件 a01c adef a&bc
    console.log("a0bc adef a&bc".replace(/(?<![0-9])b/g,"1"));
    //前置条件不等于 a0bc adef a&1c
    console.log("abcd234".match(/^(?=.*[a-z])(?=.*[0-9])\w+$/));

添加className,和移除

//添加样式
        // \s  空白字符
        // \S  非空白字符
        var div=document.querySelector("div");
        
       /*  function addClass(elem,clas) {
            var arr=(elem.className+""+clas).match(/\S+/g);
            console.log(arr);
            arr.forEach(function(item,index,arr) {
                return arr.indexOf(item,index+1)<0;
            })
            elem.className=arr.join(" ");
        }
        addClass(div,"div3")
        console.log(div); */

        function remove(elem,clas) {
            var arr=elem.className.match(/\S+/g);
            var arr1=clas.match(/\S+/g);
            arr1.forEach(function(item) {
                arr=arr.filter(function(arritem) {
                    console.log(arritem)
                    return arritem!=item;
                })
            });
            elem.className=arr.join(" ");

        }
        remove(div,"div1");
        console.log(div);

正则表达式-- （.?）或（.）
后边多一个？表示懒惰模式。
必须跟在或者+后边用
“<img src=“test.jpg” width=“60px” height=“80px”/“”
如果用正则匹配src中内容非懒惰模式匹配
src="."
匹配结果是：src=“test.jpg” width=“60px” height=“80px”
意思是从="往后匹配，直到最后一个"匹配结束

懒惰模式正则：
src=".*?"
结果：src=“test.jpg”
因为匹配到第一个"就结束了一次匹配。不会继续向后匹配。因为他懒惰嘛。

.表示除\n之外的任意字符
*表示匹配0-无穷

/* var str=" ad sd s s ";
console.log(str.match(/^\s*(.?)\s $KaTeX parse error: Undefined control sequence: \s at position 38: …og(str.match(/^\̲s̲*(.+?)$ /)[1].length);//去除右空格
console.log(str.match(/^(.+?)\s*$/)[1].length);//去除左空格

    console.log(str.match(/^\s*(.*?)\s*$/)[1].length); */
    /* function trim(str) {
        return str.match(/^\s*()\s*$/)[1];
    } */


    //面试题
    var str="3[2[2[abc]3[d]]4[e]]";
    function decodeString(str) {
        if(!/\d+\[[a-zA-Z]+\]/g.test(str)) return str;
        console.log(str.match(/\d+\[[a-zA-Z]\]/g));
        str=str.replace(/\d+\[[a-zA-Z]+\]/g,function(item,index) {
            var arr=item.match(/(\d+)\[([a-zA-Z]+)\]/).slice(1);
            console.log(arr);
            var s=arr[1].repeat(arr[0]);
            return s;
        });
        decodeString(str)
        return str;
    }
    decodeString(str);

abcabcdddabcabcdddeeeeabcabcdddabcabcdddeeeeabcabcdddabcabcdddeeee

12 ↩︎

不会说话的爱情

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
正则表达式

判断字符串是否符合规则 /* var reg=/a/g; var reg=new RegExp("a","g"); */ //两个部分，一个是正则匹配内容，另一个是修饰符部分。 //i 不区分大小写 //g 全局从头查找到尾部 // m 匹配多行 /* var str="abcabcafc"; str=str.replac...
复制链接

扫一扫