正则表达式

正则表达式

一、理解转义

转义即转换意义，改变意义

1、转义符号 \

2、转义字符 \ 字符（把原有的字符转换意义）

        var str='你是一个很\'牛逼\'的人';
        console.log(str);  //你是一个很'牛逼'的人

        var str='你是一个很\\牛逼\\的人';
        console.log(str);  //你是一个很\牛逼\的人

有一些规定好的转义字符

\n 换行

\t 制表符

\r 回车

二、正则表达式

2.1、什么是正则表达式

正则表达式是字符串的一种匹配模式，专门为简化字符串操作而生，简单点说就是为了检索字符串中特定字符的规则，正则并不是单纯的字符串，而是一种逻辑公式

2.2、创建正则表达式

创建正则的两种方式

1、通过构造函数创建

var reg=new RegExp();

2、字面量的方式创建

var reg=/ /;

      	//1、创建正则表达式
        console.log(RegExp);  //ƒ RegExp() { [native code] }

				//1.1 构造函数创建正则
        let regExp=new RegExp('a');
        console.log(regExp);  ///text/
        
        let str='bcadaef';
        console.log(str.split(regExp));  //["bc", "d", "ef"]

        //1.2  字面量创建正则
        let reg=/a/;
        console.log(reg);  ///text/

        let str2='bcadaef';
        console.log(str.split(reg));  //["bc", "d", "ef"]

2.3、构造函数创建正则

js给我们提供了一个内置构造函数用来创建正则RegExp

RegExp其实是由两个单词构成的，regular expression 正规的表达式

正则表达式是一个通过内置的构造函数构造出来的对象

var  reg =new RegExp('text'); //实例化一个正则对象

构造函数参数

1、第一参数是正则

2、第二个参数是修饰符 i 、g 、m 

2.4、正则表达式的方法

1、test

正则对象的一个方法，它表示该字符串（参数）是否匹配我们的正则规则

使用方法：reg.test(str)

参数：str是需要查询（匹配）的字符串

返回值：布尔值

        let reg=/hello/;
        var str='hello world';
        //str是我们要查询的字符串，判断str字符串是否匹配我们reg规则
        console.log(reg.test(str));  //true

        let res=reg.test(str);
        if(res){
            console.log('匹配成功');
        }else{
            console.log('匹配失败');
        }

2、exec

提前匹配成功的子字符串

使用方法：reg.exec(str);

参数：str：是需要查询（匹配）的字符串

返回值：布尔值

如果正则没有全局匹配，那么exec方法和字符串的match方法结果一模一样。如果有子项，也会匹配到子项

        let reg=/text/;
        let str='this is ex aa text and text and text';
        console.log(reg.exec(str)); 
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XQVDfCJZ-1635345429039)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904143605335.png)]

如果有全局匹配，那么exec方法也不会发生变化，但是match方法将会把所有匹配成功的项组成数组，此时会忽略子项匹配

        let reg=/text/g;
        let str='this is ex aa text and text and text';
        console.log(reg.exec(str)); 
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GIL53tE5-1635345429041)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904143643787.png)]

    let reg = /t(ex)t/

    let str = 'this is ex aa text and text and text'

    let res = reg.exec(str)
    console.log(res)

    let res2 = str.match(reg)
    console.log(res2)


    let str3 = 'ab1cd2ef3ghg'
    console.log(str3.split(/\d/))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kcThelyC-1635345429043)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904144139752.png)]

可以使用正则的字符串方法

1、search() 获取字符在字符串中的位置

2、split 字符串转化成数组

3、replace 字符串替换

3、修饰符

1、i

表示不区分大小 ignoreCase：字符串片段，大小写默认敏感。默认区分大小写

        let reg=new RegExp('Text','i');
        console.log(reg);

        //不区分大小写
        let reg1=new RegExp('Text');
        var str1='This is text';
        console.log(reg1.test(str1));  //如果没有找到任何匹配的文本， match() 将返回 null

        //区分大小写
        let reg2=new RegExp('Text','i');
        var str2='This is text';
        console.log(reg2.test(str2));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PEsOSLD5-1635345429045)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904151105997.png)]

2、g

表示全局匹配 global：不加g，默认值匹配一个

        //不加全局匹配：值匹配一个
        let reg=new RegExp('text');
        let str='this is a text and text and text';
        console.log(str.match(reg)); 

        //加全局匹配：匹配全部
        let reg2=new RegExp('text','g');
        let str2='this is a text and text and text';
        console.log(str.match(reg2));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CDaz9CbV-1635345429046)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904151848017.png)]

3、m

表示换行匹配 multiline

        var reg = new RegExp('^Text');  // 实例化一个正则对象
        var str = 'This is a \nText and';
        console.log(str.match(reg));  // null

        // 多行匹配
        var reg = new RegExp('^Text','m');  // 实例化一个正则对象
        var str = 'This is a \nText and';
        console.log(str.match(reg));// ["Text", index: 11, input: "This is a ↵Text and", groups: undefined]

三、正则表达式的特殊语法

3.1、特殊字符

正则表达式有普通字符和特殊字符（元字符）组成

普通字符：字母（abcABC…）、数字（123…）等等

元字符：()、{}、^、$、*、? 、\ 、| 、+、 .

普通字符我们可以拿来直接用，但是，特殊字符是一定要转义，因为特殊字符在正则有特殊意义

  let reg=/\^a/;
  console.log(reg.test('bb^acc')); //true

// 匹配\m
var reg = /\\m/;    // 特殊字符要转义
console.log(reg.test('asdf\\msadfasd'));    // 字符串中反斜杠要转义

3.2、预定义的特殊字符

\t /\t/ 制表符

\n /\n/ 回车符

\f /\f/ 换页符

\b /\b/ 与回退字符

// 匹配制表符
var str = 'a  b';
var reg = /\t/;
console.log(reg.test(str));

// 匹配回车符
var str2 = `a\nb`;
var reg2 = /\n/;
console.log(str2)
console.log(reg2.test(str2));

四、字符集

JavaScript的正则表达式中有四类字符集

4.1、[…]

简单类：

它是一一对应的字符组成的集合，通过[]包裹住，来表示这几个字母组成的一个集合

如：[abDF45] 表示由abDF45六个字符组成的一个集合

        let str='abcdefg';
        let reg=/[dqqqq]/;
        console.log(reg.test(str));  //true

        let str='ab1cd2ef3gh';
        let reg=/[123]/;
        console.log(str.split(reg)); //(4) ["ab", "cd", "ef", "gh"]

        let str='ab1cd2ef3gh';
        let reg=/[123af]/g;
        console.log(str.match(reg));  // ["a", "1", "2", "f", "3"]

范围类

通过首位字母以及-组成的一个范围集合

如：[a-z]：表示a-z的小写字母集合，[A-Z]：表示A-Z的大写字母集合，[0-9]：表示0-9的数字集合，[i-y]：表示小写字母i到y的集合

可以从小到大，不能从大到小

        let str = 'ab1cd2ef3gh';
        let reg=/[a-cg-z]/g;
        console.log(str.match(reg));  //(5) ["a", "b", "c", "g", "h"]
        let reg2=/[a-zA-Z0-9]/g;
        console.log(str.match(reg2));//11) ["a", "b", "1", "c", "d", "2", "e", "f", "3", "g", "h"]

负向类

通过在[]内部最前面添加^来表示不包含该集合的字符集，就是取反的意思

        let str='ab1cd2ef3gh';
        let reg=/[^a-z]/g;  //表示不包含a-z的字符集合
        console.log(str.match(reg)); //(3) ["1", "2", "3"]


        let str='fabcdef';
        let reg=/[^f]/g; //表示不包含f字符
        console.log(str.match(reg)); //(5) ["a", "b", "c", "d", "e"]

组合类

通过[]将几个集合拼接在一起表示一个组合的集合

如：[a-zA-z0-9]：表示大小写字母以及数字的结合

        let str='ab1cd2ef3gh';
        let reg=/[0-9af]/g;
        console.log(str.match(reg)); //(5) ["a", "1", "2", "f", "3"]

注意

1、中括号的字符集里面无论你写多少个字符只会匹配其中一个

2、特殊的中文字符集： [\u4e00-\u9fa5] 表示中文集

        let str = "abaef我sdf喜sdf欢sd音fds乐dsf";
        let reg=/[\u4e00-\u9fa5]/g;
        console.log(str.match(reg)); //(5) ["我", "喜", "欢", "音", "乐"]
        console.log(str.match(reg).join('')); //我喜欢音乐

4.2、界定符

1、首尾界定符 ^ 、$

字符串的起始位置我们用 ^

如：/^abc/：判断字符串是否以abc开始的

字符串的结束位置我们用$表示

如：[xyz$]：判断字符串是否是以xyz结尾

 let url = "http://www.baidu.com/"
    let reg = /^http/
    console.log(reg.test(url))


    let img = "http://www.baidu.com/jpg/xx/aa.jpg"
    let reg = /jpg$/
    console.log(reg.test(img))


    let str = 'aabb'
    let reg = /^aabb$/
    console.log(reg.test(str))

2、匹配后面跟的字符

(?=n) 匹配到后面金跟着字符n的字符

(?!n) 匹配到后面没有紧跟着字符n的字符

        let str="abacadacaf";
        let reg=/a(?=c)/g;  //a后面紧跟着c
        console.log(str.match(reg)); //(2) ["a", "a"]

        let reg2=/a(?!c)/g;  //a后面没有紧跟着c
        console.log(str.match(reg2)); //(3) ["a", "a", "a"]

4.3、预定义的类（元字符）

就是特殊的转移字符，把一些字母转成特殊意义的字符

. [^\n\r]

除了换行和回车之外的任意字符

        let str="ab*a+c\nad\ra12caf";
        let reg=/./g;
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nqXbhzuE-1635345429048)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904164945944.png)]

\d [0-9]

数字字符

        let str="a1b2+c3d4";
        let reg=/\d/g;
        let reg2=/[0-9]/g;
        console.log(str.match(reg));
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wFmXk8Gj-1635345429049)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904165205015.png)]

\D [^0-9]

非数字字符

        let str="a1b2+c3d4";
        let reg=/\D/g;
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PlUfiana-1635345429050)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904165342773.png)]

\s [空格 \t\n\f\r ]

空白字符

        let str="a b\nc\td\fb\r";
        let reg=/\s/g;
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PT1nqodw-1635345429050)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904165542591.png)]

\S [^ \t\n\f\r ]

非空白字符

        let str="a b\nc\td\fb\r";
        let reg=/\S/g;
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GcKjt81i-1635345429051)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904165611908.png)]

\w [a-zA-Z0-9_]

单词字符(所有的字母)

        let str='ab12ER+*_$@';
        let reg=/\w/g;
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ivhjoqfg-1635345429051)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904165711572.png)]

\W [^a-zA-Z_0-9]

非单词字符

        let str='呜呜呜ab12ER+*_$@';
        let reg=/\W/g;
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sxvhxsSY-1635345429052)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904165749651.png)]

4.4、量词 {}

无论字符集还是元字符，都只能匹配到一个字符，无法匹配多个字符，所以引入量词的概念，用来设置匹配到字符的个数

如：需要匹配重复10个数子 /d{10}/

1、量词普通写法

{n} n个

        let str='ab1235ef';
        let reg=/\d{2}/g;
        console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yGU1Hzu2-1635345429052)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904170702104.png)]

        let str='ab1235ef';
        let reg=/\d{2}/g;
        console.log(str.split(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mX89kKmr-1635345429053)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904170743728.png)]

        let str='ab12cd3ef34gh45dd';
        let reg=/\d{2}/g;
        console.log(str.split(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q8oCoz5P-1635345429053)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904171044739.png)]

{n,m} n~m个，包含n也包含m

        let str='ab12cd3ef340gh45678dd';
        let reg=/\d{2,5}/g;
        console.log(str.split(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Sx7ly3e-1635345429054)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904171304047.png)]

{n,} n~无穷大个，包含n

        let str='ab12cd235ef344564564654564536gh45dd';
        let reg=/\d{2,}/g;
        console.log(str.split(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q3kylpmo-1635345429054)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904171404593.png)]

2、量词特殊写法

{1,} 可由 + 代替

  //[1,无穷]
    let str = 'ab12cd235ef344564564654564536gh45dd'
      // let reg = /\d{1,}/g
    let reg = /\d+/g
    console.log(str.split(reg))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CJgF41ro-1635345429055)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904172149649.png)]

{0,} 可由 * 代替

        //[0,无穷]
        let str = 'ab12cd235ef344564564654564536gh45dd'
        // let reg = /\d{0,}/g
        let reg = /\d*/g
        console.log(str.split(reg))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QG5bFIgO-1635345429056)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904172113070.png)]

{0,1} 可由 ? 代替

 //[0,1]
    let str = 'ab12cd235ef344564564654564536gh45dd'
      // let reg = /\d{0,1}/g
    let reg = /\d?/g
    console.log(str.split(reg))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jJTB6cFV-1635345429057)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904172024013.png)]

3、贪婪与惰性

量词+默认贪婪匹配，就是说尽量往指定范围类最大的匹配，在量词后面加上 ? 符号，变为惰性匹配，也就是尽量少的去匹配。

4.5、子项

定义正则时，可以用（）将部分规则包裹起来，这样在使用match或者exec做匹配的时候，能在得到的结果里面拿到该部分匹配的内容

            let str='abcd12ef';
            let reg=/d(\d+)/;  //d+(0到9的连续多个数字)
            console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hGFtnJUq-1635345429058)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904173655950.png)]

            let str = "xiaoming:13275014321";
            let reg=/\w+:1[356789]\d{9}/;
            console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xRnwZk3N-1635345429058)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904173412876.png)]

            let str = "xiaoming:13275014321";
            let reg=/(\w+)+:(1[356789]\d{9})/;
            console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4bmg1Tnn-1635345429059)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904173549600.png)]

注意一点加全局匹配g ,match方法就不包含子项了

            let str='abcd12ef';
            let reg=/d(\d+)/g;  //d+(0到9的连续多个数字)
            console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OKM12hbM-1635345429059)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904173832635.png)]

4.6、子项反项引用

也叫捕获组

            let str="ccsdbbcc99d";
            let reg=/([a-z])\1/g;
            console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r0MDBRkD-1635345429060)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904174201638.png)]

            let str='abcdeaababbabfadfsdbebe';
            let reg=/(\w{2})\1/g;
            console.log(str.match(reg));

            let str='abcdeaababbabfadfsdbebe';
            let reg=/(\w)(\w)\1\2/g;
            console.log(str.match(reg));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SqzMCAFG-1635345429061)(C:\Users\web\AppData\Roaming\Typora\typora-user-images\image-20210904174441220.png)]

4.7、或者 |

在正则中 | 表示或者

            let str = 'abcdef'
            let reg = /[ace]/g
            console.log(str.match(reg))

            let str = 'abcdef'
            let reg = /a|c|e/g
            console.log(str.match(reg))

可以和子项结合使用

            let str = 'abcdef'
            let reg = /[ace]d/g
            console.log(str.match(reg))

            let str = 'abcdef'
            let reg = /(a|c|e)d/g
            console.log(str.match(reg))

如果放在字符集里面就只是表示普通的竖线

            let str = 'abcdef'
            let reg = /[a|c]d/g
            console.log(str.match(reg))