正则表达式(上)

本篇主要聊一聊关于JavaScript正则表达式的一些基础,下一篇再分享项目中常用的正则表达式.

元字符

元字符 说明 示例 示例说明
* 紧跟前面的一个或一组字符出现 0-N 次 123* 3 可出现 0-N 次
1(23)* 23 可出现 0-N 次
+ 紧跟前面的一个或一组字符出现 1-N 次 123+ 3 可出现 1-N 次
1(23)+ 23 可出现 1-N 次
? 紧跟前面的一个或一组字符出现 0-1 次 123? 3 可出现 0-1 次
1(23)? 23 可出现 0-1 次
(13|) 13 可出现 0-1 次
| 或(优先级最低) 允许多个字符的匹配 foot|food|fooc 返回其中一个
^ 必须以 xxx 开头 ^a 必须以 a 开头
^[0-9] 必须 0-9 开头
$ 必须以 xxx 结尾 a$ 必须以 a 结尾
[0-9]$ 必须 0-9 结尾
() 分组 和 提高优先级 foo(t|d) food 或 foot
{} 紧跟在 {} 前面的一个或一组字符出现指定次数 (ab){2} ab 可以出现 2 次
a{1,3} a 可以出现 1-3 次
a{1,} a 可以出现 1-N 次
- 连字符(如果ASCII编码是连续的 可以用 ‘-‘ 连字符) [0-9] 表示 0-9 之间的数字
\ 转义字符,后面紧跟一个元字符 \[\] []
\s [ \t\v\n\r\f]空白字符,包括空格、tab、回车、换行等
\S [^ \t\v\n\r\f]非空白字符
\w [0-9a-zA-Z_]字母、数字、下划线(非汉字)JS中和其它语言略有不同
\W [^0-9a-zA-Z_]非字符
\d [0-9]数字 0-9
\D [^0-9]非数字
. [^\n\r\u2028\u2029]通配符,表示几乎任意字符。换行符、回车符、行分隔符和段分隔符除外

匹配模式

标志 说明
g 表示该表达式将用来在输入字符串中查找所有可能的匹配,返回的结果可以是多个。如果不加/g最多只会匹配一个
i 表示匹配的时候不区分大小写
m 表示多行匹配,什么是多行匹配呢?就是匹配换行符两端的潜在匹配。影响正则中的^$符号

正则表达式对象

由正则表达式创建的对象,该对象可以进行 匹配,提取、查找 和 替换

  • 创建正则表达式对象

    1. 构造函数
      1
      2
      // const regex = new RegExp( 正则表达式[匹配模式(可选)]);
      const regex = new RegExp(/^[\d][\w]$/g);
    2. 字面量
      1
      2
      3
      // const regex = /正则表达式/;
      const regex1 = /^[\d][\w]$/;
      const regex2 = /^[\d][\w]$/g;
  • 使用正则匹配(test)

    对一段符串进行正则匹配,匹配结果返回 true或 false.

    语法:正则对象.test(字符串);

    1
    2
    3
    4
    5
    const str = 'Welcome to my Blog!';      // 任意字符串
    const reg1 = new RegExp('Blog'); // 创建正则对象
    const reg2 = /Blog/; // or 创建正则对象
    const result = reg2.test(str); // 在字符串 str 里面匹配
    console.log(result); // true
  • 使用正则提取(exec)

    对一段符串进行正则提取,提取结果以数组返回.

    语法:正则对象.exec(字符串);
    返回值说明: [“提取到的值”, 提取到第一个字符的下标, “原始字符串”]

    1
    2
    3
    4
    const str = '今天是2020-10-10日,星期六。';      // 任意字符串
    const reg = /\d+/; // 创建正则对象
    const result = reg.exec(str); // 在字符串 str 里面进行提取
    console.log(result); // ["2020", index: 3, input: "今天是2020-10-10日,星期六。", groups: undefined]

    循环提取
    调用exec首先获得第一个匹配项,再重复调用,直到最后全部匹配完成返回 null.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    const str = '今天是2020-10-10日,星期六。';      // 任意字符串
    const reg = /\d+/g; // 创建正则对象, 加个g全局匹配
    for(let result = !0; result;){
    result = reg.exec(str);
    console.log(result); // 循环输出提取结果
    }
    // ["2020", index: 3, input: "今天是2020-10-10日,星期六。", groups: undefined]
    // ["10", index: 8, input: "今天是2020-10-10日,星期六。", groups: undefined]
    // ["10", index: 11, input: "今天是2020-10-10日,星期六。", groups: undefined]
    // null

    分组提取
    分组规则:找对应的()圆括号.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    const str = 'xiaoming@163.com, xiaohong@126.com';               // 邮箱字符串
    const reg = /([a-zA-Z\d]+)@([a-zA-Z\d]+(\.[a-zA-Z\d]+)+)/g; // 创建正则对象, 用()分组,加个g全局匹配
    for(let result = !0; result;){
    result = reg.exec(str);
    console.log(result); // 循环输出提取结果
    }

    // ["xiaoming@163.com", "xiaoming", "163.com", ".com", index: 0, input: "xiaoming@163.com, xiaohong@126.com", groups: undefined]
    // ["xiaohong@126.com", "xiaohong", "126.com", ".com", index: 18, input: "xiaoming@163.com, xiaohong@126.com", groups: undefined]
    // nul

    // 返回捕获的结果
    [
    0: "xiaoming@163.com" // 返回的所有匹配项
    1: "xiaoming" // 返回第一组匹配结果, 正则:([a-zA-Z\d]+)
    2: "163.com" // 返回第二组匹配结果, 正则:([a-zA-Z\d]+(\.[a-zA-Z\d]+)+)
    3: ".com" // 返回第三组匹配结果, 正则:(\.[a-zA-Z\d]+)
    groups: undefined
    index: 0 // 匹配第一个结果的下标
    input: "xiaoming@163.com, xiaohong@126.com" // 原始字符串
    length: 4
    ]

    反向引用
    截取字符串中的一个html标签

    1
    2
    3
    4
    5
    const str = '<div>Hellow</div><p></p>Word<span>!</span>';
    const reg = /<(\w+).*<\/\1>/g;
    const result = reg.exec(str);
    console.log(result);
    // ["<div>Hellow</div>", "div", index: 0, input: "<div>Hellow</div><p></p>Word<span>!</span>", groups: undefined]

    分析:
    \w+匹配查找至少一个\w的字符串
    \/因为/为特殊字符,所以需要用转义符
    \1反向引用(\w+)

    贪婪模式
    凡是再正则表达式中,涉及次数限定的,一般默认都尽可能的多匹配 贪婪性能 高于 非贪婪模式
    取消贪婪模式: 在次数限定符后面加上一个?问号
    <(\w+)>.*?<\/1>
    多个贪婪在一起的强度

    1
    2
    3
    4
    5
    6
    /(\d+)(\d+)(\d+)/.exec('1234567')          // ["1234567", "12345", "6", "7"]
    /(\d+)(\d+)(\d+?)/.exec('1234567') // ["1234567", "12345", "6", "7"]
    /(\d+)(\d+?)(\d+)/.exec('1234567') // ["1234567", "12345", "6", "7"]
    /(\d+?)(\d+)(\d+)/.exec('1234567') // ["1234567", "1", "23456", "7"]
    /(\d+?)(\d+?)(\d+)/.exec('1234567') // ["1234567", "1", "2", "34567"]
    /(\d+?)(\d+?)(\d+?)/.exec('1234567') // ["123", "1", "2", "3"]

    分析:

      数组第 0 项 为捕获的所有结果
      第 1 项  为分组1 即 $1
      第 2 项  为分组2 即 $2
      第 3 项  为分组3 即 $3
  • 匹配但不捕获

    语法:(?: 忽略捕获该匹配项 )

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    const str = 'xiaoming@163.com, xiaohong@126.com';               // 邮箱字符串
    const reg = /([a-zA-Z\d]+)@([a-zA-Z\d]+(?:\.[a-zA-Z\d]+)+)/g; // 创建正则对象, 用()分组,加个g全局匹配
    for(let result = !0; result;){
    result = reg.exec(str);
    console.log(result); // 循环输出提取结果
    }

    // ["xiaoming@163.com", "xiaoming", "163.com", index: 0, input: "xiaoming@163.com, xiaohong@126.com", groups: undefined]
    // ["xiaohong@126.com", "xiaohong", "126.com", index: 18, input: "xiaoming@163.com, xiaohong@126.com", groups: undefined]
    // nul

    // 返回捕获的结果
    [
    0: "xiaoming@163.com" // 返回的所有匹配项
    1: "xiaoming" // 返回第一组匹配结果, 正则:([a-zA-Z\d]+)
    2: "163.com" // 返回第二组匹配结果, 正则:([a-zA-Z\d]+(\.[a-zA-Z\d]+)+)
    // 3: ".com" // 返回第三组匹配结果, 正则:( ?: \.[a-zA-Z\d]+) 该项捕获被忽略结果不会放到数组
    groups: undefined
    index: 0 // 匹配第一个结果的下标
    input: "xiaoming@163.com, xiaohong@126.com" // 原始字符串
    length: 4
    ]
  • 正则替换 (replace)

    1. 基础参数用法

      字符串.replace ( 正则表达式,字符串 ),返回字符串。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      var  str = 'aaa-----bbb------ccc'
      console.log(str.replace(/-+/,'-')); // aaa-bbb------ccc 替换一项
      console.log(str.replace(/-+/g,'-')); // aaa-bbb-ccc 全局替换
      // 基本替换
      'abc123'.replace(/(\d+)/,'d'); // abcd
      // 分组替换
      'abc123'.replace(/(\d+)/,'d$1'); // abcd123 $1 得到前捕获的结果
      // 组引用 (日期引用)
      '1991-2-26'.replace (/(\d+)-(\d+)-(\d+)/, '$1年$2月$3日'); // 1991年2月26日
      '1991-2-26'.replace (/(\d+)-(\d+)-(\d+)/, '$3/$2/$1'); // 26/2/1991
    2. 函数参数的用法

      字符串.replace ( 正则表达式,函数 ),返回字符串。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      /**
      * 将用户名 变成 x*******@163.com、x*******@126.com 的形式
      * result:返回所有结果
      * $1:第一个分组的结果
      * $2:第二个分组的结果
      * $3:第三个分组的结果
      **/
      const str = 'xiaoming@163.com, xiaohong@126.com';
      str.replace(/(\w+)@(\w+(\.\w+)+)/g, function(result, $1, $2, $3){
      var first = $1.charAt(0);
      var star = [];
      for(var i = 0; i < $1.length; i++){
      star.push('*');
      }
      return first + star.join('')+'@'+$2;
      });
      // "x********@163.com, x********@126.com"

      下一篇分享项目常用的正则表达式.