正则表达式

Posted 2020-10-02 影子疯

1、正则表达式的定义

直接量表达式：包含在一对斜杠直接的字符

 

<script>
    var str = ‘abcd‘;
    var re = /a/;
    console.log(str.match(re));  //["a", index: 0, input: "abcd"]
</script>

 

构造函数new RegExp() -- 两个参数，第一个包含正则表达式的主体部分，第二参数是可选的，也就是修饰符；

<script>
    var str = ‘abcda‘;
    var re = /a/;
    var re2 = new RegExp(‘a‘);

    console.log(re);  ///a/
    console.log(re2);  ///a/
    console.log(str.match(re));  //["a", index: 0, input: "abcd"]
    console.log(str.match(re2))  //["a", index: 0, input: "abcd"]

　　var re3 = new RegExp(‘\\d{5}‘,‘g‘);
　　console.log(re3); //　　/\d{5}/g

</script>

当需要动态创建正则表达式时，必须用构造函数方式

<script>
    var str = ‘abcda‘;
    var value = ‘a‘;
    var re = /value/;
    var re2 = new RegExp(value);

    console.log(re);  ///value/
    console.log(re2);  ///a/  
    console.log(str.match(re));  //null
    console.log(str.match(re2))  //["a", index: 0, input: "abcd"]
</script>

2、修饰符

i -- 执行不区分大小写的匹配

g -- 执行一个全局匹配，简言之，即找到所有的匹配，而不是在找到第一个之后就停止

m -- 多行匹配模式，^匹配一行的开头和字符串的开头，$匹配行的结束和字符串的结束

<script>
    var str = ‘abcAdcaec‘;
    var re = /a/g;
    var re2 = /a/gi;
    console.log(str.match(re));  //["a", "a"]
    console.log(str.match(re2));  //["a", "A", "a"]

    var str2 = ‘Java\nis fun‘;
    var re3 = /java$/gi;
    var re4 = /java$/gim;
    console.log(str2.match(re3));  //null
    console.log(str2.match(re4));  //Java
</script>

3、方法

search() -- 它的参数是一个正则表达式或者字符串（通过RegExp构造函数转成正则表达式），返回第一个与之匹配的子串的起始位置，如果找不到匹配的子串，返回-1.不支持全局检索，忽略正则表达式参数中的修饰符

 

var str = ‘javascript‘;
var re = /script/i;
console.log(str.search(‘Script‘));  //4
console.log(str.search(re));  //4

 

match() -- 唯一参数就是一个正则表达式，返回的是一个由匹配的结果组成的数组。如果正则表达式设置了修饰符g，则返回的数组包含字符传中的所有匹配结果；如果正则表达式没有设置修饰符g，不会进行全局检索，数组的第一个元素就是匹配的字符串，余下的元素则是正则表达式中用圆括号括起来的子表达式

var str = ‘Visit my blog at http://www.example.com/~david‘
var re = /(\w+):\/\/([\w.]+)\/(\S*)/;
var re1 = /(\w+):\/\/([\w.]+)\/(\S*)/g;
console.log(str.match(re));  //["http://www.example.com/~david", "http", "www.example.com", "~david", index: 17, input: "Visit my blog at http://www.example.com/~david"]
console.log(str.match(re1));  //["http://www.example.com/~david"]

test() -- 检测字符串中是否匹配正则表达式，匹配返回true，否则返回false

var re = /a/;
var str = ‘miovketng‘;
var str1 = ‘halai‘;
console.log(re.test(str));  //false
console.log(re.test(str1));  //true

replace() -- 执行检索和替换，第一个参数是正则表达式或者字符串，第二个参数是要替换成的字符串,第二个参数还能传一个函数,函数的第一个参数$0指的是匹配到的字符,函数第二个参数是分组()的信息，可以通过(?:...)设置不捕获分组信息。通过return返回要被替换成的字符串

var str = ‘a1ba2ca33ca44c‘;
var re = /\d/g;
console.log(str.replace(‘a‘,‘+‘));  //只替换一次
var newStr = str.replace(re,‘*‘);  
console.log(newStr);  //a*ba*ca**ca**c
var newStr1 = str.replace(re,function($0,$1){
        console.log($0);  // $0 匹配到的字符
        // if($0 == 1 ){
        //     return $0;
        // }
        return ‘*‘  //// 如果第二参数是一个函数，替换的内容要作为函数的返回值
    });

console.log(newStr1);  //a*ba*ca**ca**c

var str1 = ‘a1ca2ca3ca3a3a123c‘
var re1 = /a(\d)+c/g

var newStr2 = str1.replace(re1,function($0,$1){
    console.log($0,$1);  //$1是分组的信息，也就是(\d)的信息，假如不需要这个信息，可以通过(?:\d),不捕获分组的信息
        return ‘*‘
    })

console.log(newStr2)  //***a3a3*

4、元字符

[...] -- 方括号内的任意字符
[^...] -- 不在方括号内的任意字符
. -- 出换行符和其他Unicode行终止符之外的任意字符
\w -- 任何ASCII字符组成的单词，等价于[a-zA-Z0-9]
\W -- 任何不是ASCII字符组成的单词，等价于[^a-zA-Z0-9]
\s -- 任何Unicode空白符
\S -- 任何非Unicode空白符的字符，注意\w和\S不同
\d -- 任何ASCII数字，等价于[0-9]
\D -- 除了ASCII数组之外的任何字符，等价于[^0-9]

 

<script>
    var str = ‘aacabcadcaecagc‘;
    var re = /a[abcde]c/g;
    var re2 = /a[^abcde]c/g;
    var re3 = /a.c/g;
    var re4 = /\w/g;
    var re5 = /a\wc/g;
    var re6 = /a\Wc/g;
    console.log(str.match(re));  //["aac", "abc", "adc", "aec"]
    console.log(str.match(re2));  //["agc"] 
    console.log(str.match(re3));  //["aac", "abc", "adc", "aec", "agc"]
    console.log(str.match(re4));  //["a", "a", "c", "a", "b", "c", "a", "d", "c", "a", "e", "c", "a", "g", "c"]
    console.log(str.match(re5));  //["aac", "abc", "adc", "aec", "agc"]
    console.log(str.match(re6));  //null

    var str1 = ‘lai hai long‘;
    var re7 = /\s/g;
    var re8 = /\S/g;
    console.log(str1.replace(re7,‘*‘))  //lai*hai*long
    console.log(str1.replace(re8,‘*‘))  //*** *** ****

    var str2 = ‘a1ba2ba333ba4c‘;
    var re9 = /\d/g;
    var re10 = /a\db/g;
    console.log(str2.match(re9));  //["1", "2", "3", "3", "3", "4"]
    console.log(str2.match(re10));  //["a1b", "a2b"]
</script>

 

5、重复

 

{n,m} -- 匹配前一项至少n次，但不能超过m次
{n,} -- 匹配前一项n次或者更多次
{n} -- 匹配前一项n次
？ -- 匹配前一项0次或者1次，也就是说前一项是可选的，等级于{0,1}
+ -- 匹配前一项1次或者多次，等价于{1,}
* -- 匹配前一项0次或者多次，等价于{0,}

<script>
    var str = ‘a1ca11ca111ca1111ca11111cac‘;
    var re = /a\dc/g;
    var re1 = /a\d?c/g;
    var re2 = /a\d*c/g;
    var re3 = /a\d+c/g;
    var re4 = /a\d{2,4}c/g;
    var re5 = /a\d{2,}c/g;
    var re6 = /a\d{2}c/g;

    console.log(str.match(re));  //["a1c"]
    console.log(str.match(re1));  //["a1c", "ac"]
    console.log(str.match(re2));  //["a1c", "a11c", "a111c", "a1111c", "a11111c", "ac"]
    console.log(str.match(re3));  //["a1c", "a11c", "a111c", "a1111c", "a11111c"]
    console.log(str.match(re4));  //["a11c", "a111c", "a1111c"]
    console.log(str.match(re5));  //["a11c", "a111c", "a1111c", "a11111c"]
    console.log(str.match(re6));  //["a11c"]

</script>

6、贪婪和非贪婪匹配模式

 

非贪婪模式：尽可能少的匹配，只需在匹配的字符串后面加一个？，比如 ??、+?、*?、{1,4}？
贪婪模式：尽可能多的匹配

<script>
    var str = ‘aaa‘;
    var re = /a+/g;
    var re1 = /a+?/g;
    console.log(str.match(re));  //["aaa"]
    console.log(str.match(re1));  //["a", "a", "a"]
</script>

7、选择，分组和引用

 

| -- 选择，匹配的是该符号的左边的字表达式或者右边的子表达式，例如/ab|cd|ef/，可以匹配ab，也可以匹配cd，还可以匹配ef
(...) -- 组合，将几个项组合为一个单元，这个单元可以通过‘*‘、‘+‘、‘?‘、‘|‘等符号加以修饰，而且可以记住和这个组合相匹配的字符串以供此后的引用使用
(?:...) -- 只组合，把项组合到一个单元，但不记忆与该组相匹配的字符
\n -- 和第n个分组第一次匹配的字符相匹配，组是苑括号中的子表达式（也有可能是嵌套的），组索引是从左到右的左括号数，‘(?:‘形式的分组不编码

8、指定匹配位置

 

^ -- 匹配字符串的开头，在多行检索中，匹配一行的开头
$ -- 匹配字符串的结尾，在多行检索中，匹配一行的结尾
\b -- 匹配一个词的边界
\B -- 匹配非单词边界的位置
(?=p) -- 零宽正向先行断言，要求接下来的字符都与p匹配，但不能包括匹配p的那些字符
(?!p) -- 零宽负向先行断言，要求接下来的字符不与p匹配

 

<script>
    var str = ‘miaov ke tang‘;
    var re = /\b/g;
    var re2 = /\B/g;

    console.log(str.replace(re,‘|‘));  //|miaov| |ke| |tang|
    console.log(str.replace(re2,‘|‘));  //m|i|a|o|v k|e t|a|n|g

    var str1 = ‘JavaScript:The Definitive Guide‘;
    var str2 = ‘Java in a Nutshell‘;
    var re3 = /[Jj]ava([Ss]cript)?(?=\:)/
    console.log(re3.test(str1));  //true
    console.log(re3.test(str2));  //false  Java后面没有‘:‘

    var str3 = ‘JavaScript‘;
    var str4 = ‘JavaBeans‘;
    var re4 = /Java(?!Script)[A-Z]\w*/g;

    console.log(re4.test(str3));  //false
    console.log(re4.test(str4));  //true
</script>