正则表达式的知识点

(function() {
    //正则表达式定义
    //var expression = / pattern / flags;
    //每个正则表达式可以带一个或多个标志（flags）： g全局模式、i不区分大小写、m多行模式
    var strtest = "abcdefjghijklmnopqrstuvwxyz1234567890shannonliang";
    var parttern1 = /shannonliang/g; //全局查找字符串
    var parttern1_1 = new RegExp("shannonliang", "g");
    var results = parttern1.test(strtest);
    console.log(results);
    var parttern2 = /an/g;
    results = parttern2.test(strtest);
    console.log(results);
    var parttern3 = /[1i]An/i; //匹配第一个1an 或 ian 不区分大小写
    var parttern3_1 = new RegExp("[1i]An", "g");
    results = parttern3.test(strtest);
    console.log(results);
    //  ([{\^$|?*+.}])  这些元字符需要进行转义
    parttern1 = /\[1i\]An/gi; //全局匹配  [1i]An 不区分大小写
    parttern1_1 = new RegExp("\\[1i\\]An", "g");
    results = parttern1.test(strtest);
    console.log(results);

    //多行模式
    var re = /[a-z]$/;
    var str = "ab\ncdef";
    console.log(str.replace(re, "#")); //ab\ncde#  
    re = /[a-z]$/m;
    console.log(str.replace(re, "#")); //a#\ncde#  
    /*
     * 
     *模式的基本属性
     * global  : 布尔值，是否设置了g标志
     * ignoreCase : 布尔值，是否设置了i标志
     * lastIndex : 整数 开始搜索下一个匹配项的字符位置，从0开始
     * multiline : 布尔值 是否设置了m标志
     * source ： 正则表达式的字符串，字面量的形式，不包括标志，parttern模式
     * 
     * 
     * 
     * 
     */
    console.log("///////模式的基本属性/////////////");
    console.log(parttern1.global); //true
    console.log(parttern1.ignoreCase); //true
    with(parttern1) {
        console.log(multiline); // false
        console.log(lastIndex); //0
        console.log(source); ///  \[1i\]An
    }
    console.log(parttern1_1.source); // \[1i\]An
    console.log(parttern3.lastIndex); //0
    /*
     * RegExp 实例方法
     * 
     * exec()  主要使用的捕获组   返回的是Array的实例  有两个额外的属性 index 和input
     * test()  只是测试是否匹配
     */
    strtest = "mom and dad and baby";
    parttern1 = /mom( and dad( and baby)?)?/gi; //？ 表示  0 或1 即有和没有两种情况
    var matches = parttern1.exec(strtest); // 这个返回值会有3个捕获组 ，每一个括号就是一个捕获组，整体就是一个捕获组。第一个捕获组是整体，然后一层一层剥落
    console.log(matches);
    console.log(matches instanceof Array); //true

    console.log(parttern1.lastIndex); //20 下一次执行匹配的位置(索引)
    console.log(strtest.length);
    parttern1 = /and/g; //全局的匹配每次匹配完成后，lastIndex会存入下次匹配的开始位置，如果不是全局的话，lastIndex就一直会存0
    matches = parttern1.exec(strtest); //第一次匹配
    console.log(matches);
    console.log(parttern1.lastIndex); //下次匹配的开始位置
    matches = parttern1.exec(strtest);
    console.log(matches); //第二次匹配
    console.log(parttern1.lastIndex);
    matches = parttern1.exec(strtest);
    console.log(matches); //只有2个and所以第三次匹配的时候，返回null
    console.log(parttern1.lastIndex); //第三次返回0
    matches = parttern1.exec(strtest); //第四次匹配
    console.log(matches);
    console.log(parttern1.lastIndex); //从头开始匹配
    parttern1 = /and/;
    matches = parttern1.exec(strtest);
    console.log(matches);
    console.log(parttern1.lastIndex); //0
    matches = parttern1.exec(strtest);
    console.log(matches);
    console.log(parttern1.lastIndex); //0

    var str = "000-00-0000";
    var partternstr = /\d{3}-\d{2}-\d{4}/;
    console.log(partternstr.test(str)); //true

    str = "15810280292";
    partternstr = /1[358]\d{9}/; //中括号中取的或值并且可以是范围值   大括号中取的是个数
    console.log(partternstr.test(str)); //true

    str = "3456";
    partternstr = /[3-6]{4}/;
    console.log(partternstr.test(str)); //true

    /*
     * RegExp 构造函数中的静态属性
     * 
     */
    console.clear();
    str = "this has been a short summer";
    partternstr = /(.)hort/g; //有一个捕获组
    console.log(partternstr.test(str));
    console.log("长属性名：");
    console.log(RegExp.input); //最近匹配的字符串
    console.log(RegExp.lastMatch); //最近匹配的项
    console.log(RegExp.lastParen); //最近的一次捕获组
    console.log(RegExp.leftContext); //input 字符串中lastMatch之前的文本
    console.log(RegExp.rightContext); //input 字符串中lastMatch之后的文本
    console.log(RegExp.multiline);
    //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/n
    console.log("短属性名：")
    console.log(RegExp.$_);
    console.log(RegExp["$&"]); //不是有效的ES标识符
    console.log(RegExp["$+"]);
    console.log(RegExp["$`"]);
    console.log(RegExp["$‘"]);
    console.log(RegExp["$*"]);

    console.log("短属性名的捕获组：") // $1 ---- $9
    partternstr = /(.)(..)(s)( )/g;
    console.log(partternstr.test(str));
    console.log(RegExp.$1);
    console.log(RegExp.$2);
    console.log(RegExp.$3);
    console.log(RegExp.$4);
    console.log(RegExp.$5);
    console.log(partternstr.test(str));
    console.log(RegExp.$1);
    console.log(RegExp.$2);
    console.log(RegExp.$3);
    console.log(RegExp.$4);
    console.log(RegExp.$5);
    console.log(partternstr.lastIndex);
    console.clear();
    var regstr = "red blue green ,black orange";
    var parttern = /red|blue/i; //匹配red 或 blue
    var s = parttern.test(regstr);
    console.log(s);
    /* \b 之前或之后是结束的单词符
     * moon
     *  /\bm/ 匹配 "moon" 中的 ‘m‘；

        /oo\b/ 不匹配 "moon" 中的 ‘oo‘，因为 ‘oo‘ 后面的 ‘n‘ 是一个单词字符；

        /oon\b/ 匹配 "moon" 中的 ‘oon‘，因为 ‘oon‘ 位于字符串的末端，后面没有单词字符；

        /\w\b\w/ 不匹配任何字符，因为单词字符之后绝不会同时紧跟着非单词字符和单词字符。
     */

    parttern = /\s*\b\w+\b\s*/gim; //查找单词
    var m = parttern.exec(regstr);
    while (m && m[0]) {
        console.log(m[0]);
        m = parttern.exec(regstr);
    }
    /*
     * match   replace  split  三个字符串方法
     */
    var match = regstr.match(parttern); //单词的数组；
    console.log(match);
    console.log(match.length);

    var l = regstr.replace(/[^\x00-\xFF]/g, ‘**‘).length; //求字符串的字节数
    console.log(l);

    var pattern = /^1[358]\d{9}$/;
    console.log(parttern.test("13022678765"));

    str = "1025161262@qq.com.cn";
    parttern = /^\d+@qq\.com\.cn$/;
    console.log(parttern.test(str));

    //构建一个验证电子邮箱地址有效性的正则表达式。电子邮箱地址有效性要求(我们姑且这样定义)：用户名只能包含字母数字以及下划线，最少一位，最多25位，
    //用户名后面紧跟@，后面是域名，域名名称要求只能包含字母数字和减号（-），并且不能以减号开头或结尾，然后后面是域名后缀（可以有多个），
    //域名后缀必须是点号连上2-4位英文字母

    var re = /^\w{1,15}(?:@(?!-))(?:(?:[a-z0-9-]*)(?:[a-z0-9](?!-))(?:\.(?!-)))+[a-z]{2,4}$/;

    //反向引用
    str = "aa11bb22cc33";
    str.replace(/(\d+)/g, "[$1]");
    console.log(str);

    var testString = "aabbcc";
    var regex = new RegExp(/(a)\1/g);
    var resultString = testString.replace(regex, "<img src=\"$1.png\"></img>");
    console.log(resultString);

    var name = "Doe, John";
    console.log(name.replace(/(\w+)\s*, \s*(\w+)/, "$2 $1"));

    //贪婪模式与非贪婪模式
    //添加修饰匹配次数的量词，默认为贪婪模式，尽可能多地匹配；
    //而非贪婪模式，是在修饰匹配次数的特殊符号后再加上一个 "?" 号，则可以使匹配次数不定的表达式尽可能少的匹配。   *?

    //验证数字是否有重复
    var test = ["1,2,3,123,32,13", "12,56,89,123,56,98", "8,2,9,10,38,29,2,9", "8,3,9,238,93,23"];
    pattern = /\b(\d+)\b.*?\b\1\b/;

    test.forEach(function(item, index, array) {
        matches = pattern.exec(item);
        if (matches != null) {
            console.log(matches);
        }
    });
    //匹配最长的字符串重复内容
    var t = "aabecd1efghiejksabcd13";
    console.log("/////////////////////");
    for (i = 1; i < t.length; i++) {
        var obj = new RegExp(".*?(\\w{"+i+"}).*?\\1.*?","g");
        matches = obj.exec(t);
        if(matches == null){
            break;
        }
        console.log(obj.toString());
        console.log(matches);
    }
    
})();