正则

龙YY
52 阅读4分钟

正则

创建一个正则表达式

  • 字面量创建
  • const reg = /abc/
  • 构造函数创建
  • const reg1 = new RegExp('abc')

正则的常用方法

  • 1.匹配

  • 语法：正则.test(字符串)

  • 匹配字符串是否符合正则规则

  • 符合----true

  • 不符合----false

  • const str = 'qwertyui'
const str1 = 'qwertyuiabc'
console.log(reg.test(str))  // false
console.log(reg.test(str1))  // true

  • 2.捕获

  • 语法：正则.exec(字符串)

  • 捕获到了

    1.没有小括号也没有g的情况，永远捕获的都是下标0开始的第一个符合条件的

      // 2.1 没有小括号, 也没有 g
        const reg = /\d{3}/
        console.log(reg.exec('z123xc456vb789nm000'))
        console.log(reg.exec('z123xc456vb789nm000'))
        console.log(reg.exec('z123xc456vb789nm000'))

    2.没有小括号，但有g修饰的情况，第一次捕获完成后，第二次开始捕获，会从第一次捕获结束的位置开始

       // 2.2 有修饰符 g
        const reg = /\d{3}/g
        console.log(reg.exec('z123xyyc456vb789nm000'))    // 123
        console.log(reg.exec('z123xc456vb789nm000'))    // 456
        console.log(reg.exec('z123xc456vb789nm000'))    // 789
        console.log(reg.exec('z123xc456vb789nm000'))    // 000
        console.log(reg.exec('z123xc456vb789nm000'))    // null
        console.log(reg.exec('z123xc456vb789nm000'))    // 123

    3.有小括号

     const reg = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/
        const str = '我的身份证号是 411371200411081234; 不信算了!!!'
        console.log(reg.exec(str))

正则表达式里面的符号

元字符 (.; ``; \s; \S; \d; \D; \w; \W)

1.\d 表示一位数字（0--9)

2.\D 表示一位非数字（除了0--9）

3.\w 表示数字（0--9）字母（a--zA--Z)下划线（_)其中的一个

4.\W 表示除了数字（0--9）字母（a--zA--Z)下划线（_)其中的一个

5.\s 表示一位空白字符

6.\S 表示一位非空白字符

  1. . 表示一位非换行的任意字符

  2. \ 表示转义符

    const reg = /\d/    // 表示字符串中 至少包含一个 数字(0~9)
​
        console.log(reg.test('qwertyuiop')) // false
        console.log(reg.test('!@#$%^&*')) // false
        console.log(reg.test('1000')) // true
​
        const reg1 = /\D/   // 表示字符串中 至少出现一个 非数字的内容
        console.log(reg1.test('qwertyuiop')) // true
        console.log(reg1.test('!@#$%^&*')) // true
        console.log(reg1.test('1000')) // false
​
        const reg = /\w/    // 表示字符串中 至少包含一个 数字(0~9)字母(a-zA-Z)下划线(_) 其中的 一个
​
        console.log(reg.test('@#$%^&*'))    // false
        console.log(reg.test('@#$%_^&*'))    // true
        console.log(reg.test('y@#$%^&*'))    // true
        console.log(reg.test('6@#$%^&*'))    // true
        console.log(reg.test('abc_123'))    // true
​
        const reg1 = /\W/   //表示 字符串中 至少出现一个  数字(0~9)字母(a-zA-Z)下划线(_) 以外的 字符
        console.log(reg1.test('@#$%^&*'))    // true
        console.log(reg1.test('@#$%_^&*'))    // true
        console.log(reg1.test('y@#$%^&*'))    // true
        console.log(reg1.test('6@#$%^&*'))    // true
        console.log(reg1.test('abc_123'))    // false
​
        const reg = /\s/    // 表示字符串中 至少出现一个 空白字符
        console.log(reg.test('asd'))    // false
        console.log(reg.test('213'))    // false
        console.log(reg.test('#$%'))    // false
        console.log(reg.test('#$ %'))    // true
​
        const reg1 = /\S/   // 表示字符串 至少出现一个 非空白字符
        console.log(reg1.test('asd'))    // true
        console.log(reg1.test('213'))    // true
        console.log(reg1.test('#$%'))    // true
        console.log(reg1.test('#$ %'))    // true
        console.log(reg1.test(' '))    // false
​
        const reg = /./ // 表示字符串 至少出现一个 非换行的任意字符
        console.log(reg.test('\n')) // false
        console.log(reg.test('123\n')) // true
​
        const reg1 = /./   // 表示字符串中至少出现一个 小数点
        console.log(reg1.test('100'))   // false
        console.log(reg1.test('1.00'))   // true

边界符 (^; &)

  1. ^ 表示开头

  2. $ 表示结尾

     const reg4 = /^\d$/    // 表示字符串只能是一个数字
        console.log(reg4.test('abc123def')) // false
        console.log(reg4.test('123def'))    // false
        console.log(reg4.test('123'))       // false
        console.log(reg4.test('1'))         // true
​

限定符 (*; +; ?; {n}; {n,}; {n, m})

1.* 表示0--正无穷次

2.+ 表示1--正无穷次

  1. ？表示0--1次

  2. {n} 表示 限定n次 不能多也不能少

  3. {n, } 表示最少n次，最多m 次

  4. {n,m} 表示最少n次，最多m次

    const reg1 = /^\d*$/  // 这个字符串的数字只能出现 0~正无穷次
        console.log(reg1.test('1'))   // true
        console.log(reg1.test('1a'))   // false
​
        const reg2 = /^\d+$/ // 这个字符串的数字只能出现1~正无穷
        console.log(reg2.test('100'))    // true
        console.log(reg2.test('qwer'))    // false
        console.log(reg2.test('999qwer'))    // false
​
        const reg3 = /^\d?$/ // 这个字符串的数字只能出现 0~1 次
        console.log(reg3.test('666'))    // false
        console.log(reg3.test('6'))    // true
​
        const reg4 = /^\d{2}$/   // 这个字符串的数字只能出现 2 次
        console.log(reg4.test('666'))    // false
        console.log(reg4.test('66'))    // true
        console.log(reg4.test('6'))    // false
​
        const reg5 = /^\d{2,}$/   // 这个字符串的数字最少出现 2 次
        console.log(reg5.test('666'))    // true
        console.log(reg5.test('66'))    // true
        console.log(reg5.test('6'))    // false
​
        const reg6 = /^\d{2,3}$/   // 这个字符串的数字最少出现 2 次 最多出现3次
        console.log(reg6.test('6666'))    // false
        console.log(reg6.test('666'))    // true
        console.log(reg6.test('66'))    // true
        console.log(reg6.test('6'))    // false

特殊符号 ((); []; [^]; -; |)

  1. ( )

含义1：当成一个整体

含义2：单独捕获

  1. |

或

  1. [ ]

    包含 [abcd] 包含其中一个即可 [ ]实际代表的就算一位字符4.[^]

    非

      到(至)

      通常与 包含 和 非 一起使用

      [0-9] 数字 0~9 中的一个 \d

      [^0-9] 不是数字 0~9 中的 一个 \D

      [a-z] 小写 字母a~z

      [A-Z] 大写 字母A~Z

    const reg = /(abc){2}/  // 表示 abc 这个整体 一定出现 2 次
        console.log(reg.test('abcdef')) // false
        console.log(reg.test('abcab')) // false
        console.log(reg.test('abcabc')) // true
​
        const reg = /(abc|def){2}/  // 这个字符串需要 abc 或者 def 出现两次
        console.log(reg.test('abcabc')) // true
        console.log(reg.test('abcdef')) // true
        console.log(reg.test('defabc')) // true
        console.log(reg.test('defdef')) // true
​
        const reg = /^[a-c]$/   // 这个字符串只能是 a-c 其中的任意一个字符
        console.log(reg.test('abc'))    // false
        console.log(reg.test('a'))    // true
        console.log(reg.test('b'))    // true
        console.log(reg.test('c'))    // true
        console.log(reg.test('@'))    // false
​
        const reg = /^[^a-c]$/  // 这个字符串只能是 a-c 之外的任意一个字符
        console.log(reg.test('abc'))    // false
        console.log(reg.test('a'))    // false
        console.log(reg.test('b'))    // false
        console.log(reg.test('c'))    // false
        console.log(reg.test('@'))    // true

重复元字符 (\数字)

/(abc|def)\1/

小括号 内 为 abc \1 这个位置也需要是 abc

小括号 内 为 def \1 这个位置也需要是 def

标识符 (i; g)

1.i 忽略大小写

 const reg1 = /^[a-c]$/i // 忽略大小写
        console.log(reg1.test('a'))  // true
        console.log(reg1.test('A'))  // true

2.g 全局

把字符串内所有满足正则规则的片段全部获取出来, 并存储到数组中

        console.log(reg.exec(str))
​

正则的两大特性 (懒惰与贪婪)

  1. 懒惰

    正常捕获字符串的时候, 每次都从 下标0开始

    解决方式: 给正则添加一个修饰符 g

    贪婪

    每次在捕获的时候, 会尽可能的多捕获一些东西

    解决:

    在原有的修饰符后添加一个 ? 然后相当于开启 非贪婪模式

    贪婪: 能多拿就多拿

    非贪婪: 能少拿就少拿

    贪婪限定符

    ?

    {n,}

    {n,m}

    非贪婪限定符

    *?

    +?

    ??

    {n,}?

    {n,m}?

      const str = '<div class="box" id="box1"><span></span></div>'
​
        const reg = /<div.*>/   // 贪婪模式
        console.log(reg.exec(str))
​
        const reg1 = /<div.*?>/ // 非贪婪模式
        console.log(reg1.exec(str))
avatar
文章
阅读
粉丝