零JS筆記 | 正則基礎

var str = 'abc'
var re = /a[a-z]c/
console.log(re.test(str))  //，一共3位，對應上所以是true

//如果str = 'abcd'，只會對應前3位，對應不是，所以是false
所以，如果需要多個匹配,+表示[a-z]有多位，可以中間一直匹配，當無法匹配時，再找最後一位匹配

var str = 'abcsdfsdfsdfsdfsdfsdfsf'
var re = re = /a[a-z]+c/ 
console.log(re.test(str))   //true

//所以，過濾html標籤正則是：

var re = /<[^>]+>/g; 
str.replace(re, '');  //應用正則替換為空

</td>
</tr>
<tr>

<td>.</td>
<td>正則中 . 表示任意字符，而匹配真正的點：\.   與一般相反</td>

</tr>

<tr>

<td>\1、 \2、\3</td>
<td>重複的第1、2、3個子項[配合()]; 如/(a)(b)(c)\1/===/(a)(b)(c)a/;表示兩個要完全相同，應用比如匹配p標籤配對</td>

</tr>

</table>

test();

var str = 'abcdef';
var re1 = /b/;
var re2 = /w/;
var re3 = /bc/;
var re4 = /bd/;
alert(re1.test(str)); //true
alert(re2.test(str)); //false
alert(re3.test(str)); //true
alert(re4.test(str)); //false

var str = '473t9487306';
var re = /\D/;
if (re.test(str)) {
  alert('不全是数字');
} else {
  alert('全是数字');
}

var str = 'abcdef';
var re1 = /bcd/;
var re2 = /w/;
var re3 = /B/;
var re4 = /B/i;
var re5 = new RegExp('B', 'i'); //这一行的写法与上面一行的写法，意义完全一样
alert(str.search(re1)); //弹出1 弹的是匹配的首字母的位置
alert(str.search(re2)); //弹出-1
alert(str.search(re3)); //弹出-1 //正则默认下是区分大小写的
alert(str.search(re4)); //弹出1
alert(str.search(re5)); //弹出1

var str = 'sdogh3woiehgxfkjb789paf34dj4pgdfhgdorg43';
var re1 = /\d/;
var re2 = /\d/g;
var re3 = /\d\d/g;
var re4 = /\d\d\d/g;
var re5 = /\d\d\d\d/g;
var re6 = /\d+/g; //这里说明前面的反斜杠d至少出现一次，多则不限
alert(str.match(re1)); //[3] 返回的是找到的第一个数字
alert(str.match(re2)); // [3, 7, 8, 9, 3, 4, 4, 4, 3]
alert(str.match(re3)); //[78, 34, 43]
alert(str.match(re4)); //[789]
alert(str.match(re5)); // null
alert(str.match(re6)); //[3, 789, 34, 4, 43]

replace: 替換所有匹配：

返回替换后的字符串

字符串.replace(正则,想替换的)

例子：敏感词过滤

匹配子项

例子：日期格式化

replace的写法 : 字符串.replace(正则, 新的字符串)

var str1 = 'aaa';
var str2 = 'aaa';
var str3 = 'aaa';
var re1 = /a/;
var re2 = /a/g;
var re3 = /a+/g;
str1 = str1.replace(re1, 'b');
alert(str1); //'baa'
str2 = str2.replace(re2, 'b');
alert(str2); //'bbb'
str3 = str3.replace(re3, 'b');
alert(str3); //'b'            特別留意此處；所有匹配到的都換成b,a+表示匹配多個a，如果匹配到，則替換成b

函数的第一个参数：就是匹配成功的字符,每次匹配到的字符不同，不同長度返回不同*號

aT[1].value = aT[0].value.replace(re, function (str) { //函数的第一个参数：就是匹配成功的字符
  //alert(str);
  var result = '';
  for (var i = 0; i < str.length; i++) {
    result += '*';
  }
  return result;
});

匹配子项

// 匹配子项 : 小括号 () （还有另外一个意思：分组操作）
//把正则的整体叫做（母亲）
// 然后把左边第一个小括号里面的正则，叫做这个第一个子项（母亲的第一个孩子）
// 第二个小括号就是第二个孩子
var str1 = '2013-6-7';
var str2 = '2013-6-7';
var str3 = '2013-6-7';
var str4 = '2013-6-7';
var str5 = '2013-6-7';
var re1 = /\d+-/g;  //+匹配d
var re2 = /\d-+/g; //一个数字加至少一个横杠   +匹配d-
var re3 = /(\d-)+/g;
var re4 = /(\d+)(-)/g;
var re5 = /(\d+)(-)/g;
// str1.replace(re1, function($0){
//  alert($0); //2013- 和 6-
// })
// str2.replace(re2, function($0){
//  alert($0); //3- 和 6-
// })
// str3.replace(re3, function($0){
//  alert($0); //3-6-
// })
/*
        str4.replace(re4, function($0, $1, $2){
            // 第一个参数 : $0 （母亲）       /(\d+)(-)/g;
            // 第二个参数 : $1 （第一个孩子）  (\d+)
            // 第三个参数 : $2 （第二个孩子）  (-)
            // 以此类推
            alert($0); //2013- , 6-
            alert($1); //2013 , 6
            alert($2); // - , -
            //运行一次弹出：2013-, 2013, -, 6-, 6, -
        })
        */
str5 = str5.replace(re5, function ($0, $1, $2) {
  // return $0.substring(0, $0.length - 1) + '.';
  return $1 + '.'; //2013.6.7
})
alert(str5); //2013.6.7

match方法中的匹配子项

var str1 = 'abc';
var re1 = /abc/;
var str2 = 'abc';
var re2 = /(a)(b)(c)/;
var str3 = 'abc';
var re3 = /(a)(b)(c)/g;
alert(str1.match(re1)); //[abc]
alert(str2.match(re2)); //[abc, a, b, c]（当match不加g的时候才可以获取到匹配子项的集合）
alert(str3.match(re3)); //[abc] //这里因为re里面加个g，就不会获得上面那一句的结果了

正則表達式字符類

[abc]

例子：o[usb]t——obt、ost、out

字符类 : 一组相似的元素或字符

//字符类 : 用中括号表示，中括号的整体代表一个字符

//字符类 : 一组相似的元素或字符
//字符类 : 用中括号表示，中括号的整体代表一个字符

var str1 = 'abc';
var re1 = /a[bde]c/;
alert(re1.test(str1)); //true
var str2 = 'aec';
var re2 = /a[bde]c/;
alert(re2.test(str2)); //true
var str3 = 'abdc';
var re3 = /a[bde]c/;
alert(re3.test(str3)); //false

//排除 : ^ 如果^写在[]里面的话，就代表排除的意思
var str4 = 'abc';
var re4 = /a[^bde]c/;
alert(re4.test(str4)); //false
var str5 = 'awc';
var re5 = /a[^bde]c/;
alert(re5.test(str5)); //true

//范围 : - 如果-写在[]里面的话，就代表范围，范围一定是从小到大的
var str6 = 'abc';
var re6 = /a[e-j]c/;
alert(re6.test(str6)); //false
var str7 = 'afc';
var re7 = /a[e-j]c/;
alert(re7.test(str7)); //true
var str8 = 'a3c';
var re8 = /a[a-z0-9A-Z]c/;
alert(re8.test(str8)); //true
var str9 = 'a3eJ86Xc';

var re9 = /a[a-z0-9A-Z]+c/; //在中括号外面添加了+，代表可以多位
alert(re9.test(str9)); //true

字符类实例，过滤标签

        var str1 = 'a你c';
        var re1 = /a.c/;

        alert(re1.test(str1)); //true

        var str2 = 'a你c';
        var re2 = /a\.c/;
        alert(re2.test(str2)); //false

        // \b : 独立的部分（起始、结束、空格）
        // \B : 非独立的部分

        var str3 = 'onetwo';
        var re3 = /one/;
        alert(re3.test(str3)); //true;

        var str4 = 'onetwo';
        var re4 = /\bone/; //代表字母o前面必须是独立部分，o前面是起始位置
        alert(re4.test(str4)); //true;

        var str5 = 'onetwo';
        var re5 = /one\b/; //e后面是个t，不是个独立部分
        alert(re5.test(str5)); //false; 

        var str6 = 'one two';
        var re6 = /one\b/; //e后面是个空格，是独立部分
        alert(re6.test(str6)); //true;

        var str7 = 'onetwo';
        var re7 = /\bone\b/; //前面满足后面不满足，整体也就不满足
        alert(re7.test(str7)); //false;

当正则需要传参时，一定要用全称的写法，如var re = new RegExp('\b'+sClass+'\b')，這裏也一定要雙\,字符串當中特殊的字符想輸入，必須再加，如輸出單引號'

var str = 'sddfdsfdsfdsfdsfdddddd'
//先排在一起
var arr = str.split('')
str = arr.sort().join('')
var value = ''
var index = 0;
var re = /(\w)\1+/g;
str.replace(re, function (_0,_1) {
    console.log(_0);
console.log('_1'+_1);
if(index<_0.length){
    index = _0.length;
    value = _1;
}
console.log('最多的字符為：' + value + '出現次數為：' + index);
})

前項聲明,反前項聲明

        var s =  'abacad'
        var re = /a(?=b)/g;    //匹配 ab，但只替換匹配到的ab中的a，b不替換；
        s =  s.replace(re,'*')
        console.log(s);  //*bacad

        var s =  'abacad'
        var re = /a(?!b)/g;    //匹配 ab，a後面不能匹配到b,其他可以匹配
        s =  s.replace(re,'*')
        console.log(s);  //ab*c*d

所以，過濾html標籤，但保留li標籤： re = /<²+>/g;