javaScript----正则表达式

一.什么是正则表达式

正则表达式就是一种表达文本模式(即字符串结构)的方法,有点像字符串的模板,常常用来按照“给定模式”匹配文本
简而言之就是是一种模板,用这个模板来匹配字符串

二.如何创建一个表达式

  1. 使用字面量

    var reg = /xy/igm;
    xy表示要匹配的字符串
    igm是修饰符,意思分别是
    i ---- ignoreCase 忽略大小写
    g ----global 全局匹配
    m ---- multiline 多行匹配

  2. 使用RegExp()构造函数
    var reg = new RegExp(‘xy’,‘igm’);

两种方式是一样的,区别是 字面量的方式在编译时创建表达式,构造函数是在运行时创建表达式,因此字面量的效率高一些,建议使用字面量

三.实例属性,方法及匹配规则

  1. 实例属性
    修饰符有关
    ignoreCase 返回值 true/false ,是否设置了 i 标识符
    global 返回值 true/false ,是否设置了 g 标识符
    multiline 返回值 true/false ,是否设置了 m 标识符
    flags 返回值 是该正则表达式所设置的标识符 ,按照字母排序
    修饰符无关
    lastIndex 下一次开始搜索的位置
    source 返回正则表达式的字符串形式,不包括 //
		var regex = /xy/ig;
        // 等同于
        // var regex = new RegExp('xy','ig');
        
        // !!!!实例属性
        // 1.修饰符相关 只读
        // true  正则表达式是否设置了 i 属性
        console.log('regex.ignoreCase',regex.ignoreCase);
        // true  正则表达式是否设置了 g 属性
        console.log('regex.global',regex.global);
        // false 正则表达式是否设置了 m 属性
        console.log('regex.multiline',regex.multiline);
        // 正则表达式的所有已设置的属性,按字母排序
        console.log('regex.flags',regex.flags);
        
        // 2.修饰符无关 
        // 0 下次搜索开始的位置 可读写 lastIndex下一次开始搜索的位置
        console.log('regex.lastIndex',regex.lastIndex);
        // 'xy',string     source 返回正则表达式的字符串形式,不包括 反斜杠,只读
        console.log('regex.source,typeof regex.source',regex.source,typeof regex.source);
  1. 实例方法
    正则表达式里的实例方法
    test() 检查字符串里是否有满足正则表达式的字符串,返回值是 true/false
    exec() 返回的是符合 正则表达式的字符串 数组,否则返回 null
    exec() 返回的数组里还包括---- index 匹配成功开始的位置 ----input 原字符串
    字符串里关于正则表达式的实例方法
    match() 返回的是符合正则表达式的字符串数组,否则返回 null,与exec()类似,不同之处在于 当含有 g 修饰符时,match()返回的是所有匹配的子字符串,每次匹配都是从头开始,而exec()则是每次匹配一个
    search() 返回的是字符串开始匹配成功的下标,否则返回-1
    replace() 返回的是替换后的字符串,参数1是需要替换的内容,参数2是替换的内容
    split() 返回的是 分隔符分割后的字符串数组
        //!!!!实例方法
        // test()检查字符串里是否有满足正则表达式的字符串,返回值是 true/false
        // ture
        console.log('test()',/cat/.test('cats and dogs'));
        // 正则表达式为空,则匹配所有字符串
        // true
        console.log('new RegExp("")',new RegExp('').test('this is a test'));

        // exec()返回的是符合 正则表达式的字符串 数组,否则返回 null
        // index 整个模式首先匹配成功的开始位置
        // input 原字符串
        // ['cat']
        var reg = /cat/ig;
        console.log('exec()',reg.exec('cat and bat and Cat'));
        // ['Cat']  使用了 g ,记录了上次匹配结束的位置
        // 当匹配结果为 null 时,下一次匹配会重头开始 ,lastIndex 会重置为0
        console.log(reg.exec('cat and bat and Cat'));
		// !!!! 字符串中关于正则表达式的实例方法
        // match() 返回的是数组,成员是所有匹配的子字符串,否则返回null,与 exec() 类似
        // 不同: 当含有 g 修饰符时,返回的是所有匹配的子字符串,每次匹配都是从头开始
        // ['cat']
        console.log('match()','cat and bat and Cat'.match(/cat/ig));
        // search() 返回的是整数,表示第一个匹配开始的位置,否则返回 -1
        // 0
        console.log('search()','cat and bat and Cat'.search(/cat/));
        // repalce() 返回的是替换后的字符串 ,参数1 是需要替换的内容, 参数2 是替换的内容
        // dog and bat and Cat
        console.log('replace()','cat and bat and Cat'.replace(/cat/,'dog'));
        // dog and bat and dog
        console.log('replace()','cat and bat and Cat'.replace(/cat/ig,'dog'));
        // split() 以分隔符返回分隔字符串后的数组
        // 正则默认是贪婪匹配
        // [ "c", "t ", "nd b", "t ", "nd C", "t" ]
        console.log('split()','cat and bat and Cat'.split(/a/));    
        // [ "c", "a", "t ", "a", "nd b", "a", "t ", "a", "nd C", "a","t"]
        // 如果正则表达式里有 括号 ,则括号里匹配的内容也会返回
        console.log('split()','cat and bat and Cat'.split(/(a)/));   
  1. 匹配规则
  • 字面量字符,字符就是它本身没有其他含义

  • 元字符,有特殊含义的字符

  1. 点字符(.)
    可以匹配除 回车(\r) 换行(\n) 行分隔符(\u2028) 段分隔符(\u2029) 以外的所有字符,一个点字符 匹配一个字符
		// [ "cat", "cbt", "cct", "c t", "c=t" ]
        console.log('点字符','cat cbt cct cddt c t c=t'.match(/c.t/g));
        // ["cddt"]
        console.log('两个点字符','cat cbt cct cddt c t c=t'.match(/c..t/g))
  1. 位置字符(^ $)
    字符出现的位置
    ^ 字符串的开始位置
    $ 字符串的结束位置
		// null 
        console.log('^ match()','at cbt cct cddt c t c=t'.match(/^cat/));
        // true 
        console.log('^ test()',/^cat/.test('cat cbt cct cddt c t c=t'));
        // ["c=t"]
        console.log('$ match','cat cbt cct cddt c t c=t'.match('c=t$'));
        // true
        console.log('$ test()',/c=t$/.test('cat cbt cct cddt c t c=t'));
        // true /^cat$/表示字符串只能是 cat
        console.log("^ $",/^cat$/.test('cat'));
        // false 
        console.log("^ $",/^cat$/.test('cat cat'));
  1. 选择符(|)
    或关系,匹配其中一个, | 会匹配前后的多个字符,要想只匹配指定的字符个数可以使用 圆括号
    比如/ab|cd/指的是匹配ab或者cd,而不是指匹配b或者c。如果想修改这个行为,可以使用圆括号。
    /a( |\t)b/.test(‘a\tb’) true 代码指的是,a和b之间有一个空格或者一个制表符。

  2. 转义符(\)
    有特殊含义的字符想要匹配自身时必须使用转义字符
    正则表达式中需要转义的字符有12个 ^ $ . ( ) [ | * + ? {
    注意 使用RegExp函数生成正则表达式时,需要加 两个斜杠, 因为字符串内部会先转义一次

		// 报错 missing ) after argument list
        // console.log('\',new RegExp('1\.1').test('1.1'));
        // true
        console.log('RegExp',new RegExp('1\\.1').test('1.1'));
  1. 特殊字符
    正则表达式对一些不能打印的特殊字符,提供了表达方法。
    \cX 表示Ctrl-[X],其中的X是A-Z之中任一个英文字母,用来匹配控制字符。
    [\b] 匹配退格键(U+0008),不要与\b混淆。
    \n 匹配换行键。
    \r 匹配回车键。
    \t 匹配制表符 tab(U+0009)。
    \v 匹配垂直制表符(U+000B)。
    \f 匹配换页符(U+000C)。
    \0 匹配null字符(U+0000)。
    \xhh 匹配一个以两位十六进制数(\x00-\xFF)表示的字符。
    \uhhhh 匹配一个以四位十六进制数(\u0000-\uFFFF)表示的 Unicode 字符。
  2. 字符类([])
    表示有一列字符可供选择,只要匹配其中一个就可以了
    6.1 脱字符 (^ 只有在字符类的第一个位置才有特殊含义)
    [^] 表示除了 字符类之外的其他字符都可以匹配,包括换行符 例如[^xyz]表示除了 x,y,z 剩下的都可以匹配
    6.2 连字符(-)(匹配前后的一个字符)
    连续序列的字符 的简写,只包含前后的一个字符 如 [1-9] 表示1,2,3…9
		// false  字符串中没有 abc 的任意一个
        console.log('字符类 test()',/[abc]/.test('ddddddddddddd'));
        // true   字符串中出现了 a
        console.log('字符类 test()',/[abc]/.test('adddddddddddd'));
            // 6.1 脱字符 (^ 只有在字符类的第一个位置才有特殊含义)
            // [^] 表示除了 字符类之外的其他字符都可以匹配,包括换行符 例如[^xyz]表示除了 x,y,z 剩下的都可以匹配
            // true
            console.log('[^]',/[^cat]/.test('cat bdefghijklmnopqrsuvwxyz'));
            // false 除了 cat 在没其他字符因此 false
            console.log('[^]',/[^cat]/.test('catcatcatcatcatatatcatat'));
            // 换行符
            // false 点字符不能匹配换行符
            console.log('换行符使用 . 匹配',/good.*day/.test('today is a good\n day'));
            // true [^]可以匹配换行符
            console.log('换行符使用 [^] 匹配',/good[^]*day/.test('today is a good\n day'));
            // 6.2 连字符(-)
            // 连续序列的字符 的简写,只包含前后的一个字符 如 [1-9] 表示1,2,3...9
            // false 
            console.log('-不在[]里',/a-c/.test('abc'));
            // true 
            console.log('-在[]里',/[a-c]/.test('abc'));
            // 注意 [1-31] 表示 1-3
  1. 预定义模式
    常见模式的简写
    \d 表示0-9的任一数字,相当于 [0-9]
    \D 表示除0-9之外的所有字符,相当于 [^0-9]
    \w 表示匹配任意的字母,数字,下划线,相当于 [0-9a-zA-Z_]
    \W 表示除字母,数字,下划线之外的所有字符,相当于 [^0-9a-zA-Z_]
    \s 匹配空格(包括换行符,制表符,空格符等等),相当于 [\t\r\n\v\f]
    \S 匹配非空格的字符,相当于 [^\t\r\n\v\f]
    \b 匹配词的边界,在匹配的开始则 只有该字符串在词首独立时才能匹配成功,在匹配的结束则 只有该字符串在词尾独立时才能匹配成功
    \B 匹配非词边界,即在词的内部
		// \b 的例子
		/\bworld/.test('hello world') // true
		/\bworld/.test('hello-world') // true
		/\bworld/.test('helloworld') // false
		
		// \B 的例子
		/\Bworld/.test('hello-world') // false
		/\Bworld/.test('helloworld') // true
  1. 重复类({})
    模式的精确匹配次数
    {n} 恰好重复n次
    {n,} 至少重复n次
    {n,m} n <= 重复次数 <= m
		// 指定 c 出现 2~6 次
        console.log('{n,m}',/abc{2,6}d/.test('abcccdd'));
  1. 量词符
    设置某个模式出现的次数
    ? 0 或 1,{0,1}
    * 0 或 多次,{0,}
    + 1 或 多次,{1,}
  2. 贪婪模式
    默认情况下最大可能匹配,即匹配到下一个规则不满足为止
    ?? 匹配 0 或 1,采用非贪婪模式
    *? 匹配 0 或 多,采用非贪婪模式
    +? 匹配 1 或 多,采用非贪婪模式
			// [ "aaaaaa" ]
            console.log('贪婪模式',/a*/.exec('aaaaaab'));
            // 改   为非贪婪模式
            // ?? 匹配 0 或 1,采用非贪婪模式
            // *? 匹配 0 或 多,采用非贪婪模式
            // +? 匹配 1 或 多,采用非贪婪模式
            // [ "" ]
            console.log('?? 非贪婪模式',/a??/.exec('aaaaaab'));
            // [ "" ]
            console.log('*? 非贪婪模式',/a*?/.exec('aaaaaab'));
            // [ "a" ]
            console.log('+? 非贪婪模式',/a+?/.exec('aaaaaab'));
  1. 组匹配( () )
    正则表达式中使用圆括号(),则返回的数组会包含多个成员。第一个成员是整体匹配的结果,第二个是第一个圆括号里匹配的结果,第三个是第二个圆括号里匹配的结果
    正则表达式内部还可以用 \n 引用括号匹配的内容 n 是从 1 开始的自然数
    例如 \1 表示第一个括号匹配的内容
			// true \1匹配的是 a \2匹配的是 c
            console.log('组匹配里 \n',/(.)b(.)\1b\2/.test('abcabc'));
  1. 非捕获组(?:x)
    能匹配,但不返回该组匹配的内容,即 x
			// [ "abcabc", "abc" ]
            console.log('非捕获组','abcabc'.match(/(abc){1,2}/));
            // [ "abcabc" ]
            console.log('非捕获组','abcabc'.match(/(?:abc){1,2}/))
  1. 先行断言(x(?=y))
    x只有在 y 前面才会被匹配,y 不会计入返回结果
			// null
            console.log('先行断言','a不在c的前面','abc'.match(/a(?=c)/));
            // [ "a" ]
            console.log('先行断言','a在c的前面','ac'.match(/a(?=c)/));
  1. 先行否定断言(x(?!y))
    x 只有不在 y 前面才会被匹配
			// null
            console.log('先行否定断言','a在c的前面','ac'.match(/a(?!c)/));
            // [ "a" ]
            console.log('先行否定断言','a不在c的前面','bca'.match(/a(?!c)/));
相关推荐
©️2020 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页