正则表达式

发表于

正则的用法

  1. 验证字符串是否符合正则所制定的规则，如
    • 注册输入用户名密码
  2. 把符合规则的部分从字符串中捕捕获，如：
    • 从名字中获取到姓
  • ps：基本就是用来操作字符串的

    字面量和实例创建正则的区别：

  1. 如果使用实例创建，特殊元字符\d需要在创建的时刻

    1
    2
    var reg1 = new RegExp('\\d',i); //=》第二个参数就是修饰符，实例的方式可以传入变量参数
    var reg  = /\d/i; //=>在匹配的时候忽略大小写，不能写入变量
    • i:ignoreCase 忽略大小写
    • m:multiline多行匹配
    • g:global 全局全文（一般用于捕获exec）
  2. 实例创建，new的过程中的第二个参数就是修饰符；
  3. 只要正则中有需要变量的时刻，那么就只能使用实例的创建方式；

    正则的方法

  4. reg.test(‘’);验证

  5. reg.exec(‘’);捕获

    特殊的元字符

  • \d 0-9之间的任意一个数字
  • \w 数字、字母、下划线（0-9、a-z、A-Z、_）
  • \s 空格或者空白
  • \b 边界,不占位–>边界不一定是字符串的开始或结束，一些特殊字符的两边
  • \n 匹配一个换行的
  • . 匹配任意字符，但是除了\n
  • \ 转义符 ==>把特殊意义的字符转变成本来的意思
  • ^ 以什么开始，不占位
  • $ 以什么结束，不占位
  • . ‘.’本身
  • \B 匹配非单词边界
  • \D 除了/d
  • \W 除了/w
  • \S 除了\s
    1
    2
    var reg = /^\d$/; //如果^、$、同时出现，那么对这个字符串的个数就限制了
    var reg1 = /a/i; //字面量 =》 只要字符串中包含字母a就可以 ==》在正则的后边加一个i的时候，忽略正则中的大小写

正则中的量词：放在修饰的元字符的后面=》修饰前面的元字符出现的次数

  • + 1到多个
  • * 0到多个
  • ?
    • 量词
    • (?:\d…) 放在一个分组的开头，匹配不捕获，破坏分组
  • {n} 出现n个
  • {n,} 至少n个
  • {n,m} 出现n到m个
    1
    var phoneReg=/^1\d{10}$/;

正则中的或者：

  1. x|y|z x或者y或者z中的一个

    1
    2
    var reg = /^(18|19)$/; //由于或者干洗是满足其中一个就可以，
    //所以处理或者关系的时候我们不妨用()去改变运算的优先级

  2. [xyz] x或者y或者z中的一个

  3. [^xyz] 除了xyz,返回值是false的时候，字符串中只能有xyz
  4. [+-] ‘+’或者’-‘中的一个
  5. [\d\w] 数字字母中还有下划线中的一个
  6. \w [0-9a-zA-Z] ‘-‘表示的是到的意思
  7. [.] “.”代表的不是任意字符，而是代表的.本身
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //简单的有效数字验证
        var reg =/^[+-]?\d+(\.\d+)?$/;
        console.log(reg.test('-6.666'));
    // 文本框的非空验证
        var input = document.getElementById('input');
        //获得焦点  onfocus
        // 失去焦点 onblur
        input.onblur = function () {//失去焦点判断是否输入
            var str = this.value; //value塑性就是获取的输入到文本框的内容
            var reg = /^\s*$/;
            if (reg.test(str)) {
                console.log('输入不能为空')
            }
        };
        //简单的邮箱判断
        var reg1 =/^\w{1,16}(@[0-9a-zA-Z]{2,20}(\.[a-zA-Z]{2,3}){1,2})$/;

正则中的exec方法

  1. 捕获结果

    • 返回一个数组：[正则捕获回来的结果,index:捕获开始位置的索引,input:原有字符串]
      1
      2
      3
      4
      5
      6
      7
      8
      var str = 'zhu2017feng20000aaaaa1231231';
      var reg = /\d+/g;   //g：global
      var ary = [];
      var text = null;
      while (text = reg.exec(str)) {
          ary.push(text[0]);
      }
      text = null;

  2. reg.lastIndex属性 =》 下次捕获从哪个索引开始，当捕获结果为null，这个属性值会重新赋值为0，然后就又从开始捕获。

    正则中的match方法:str.match(reg)

  3. 返回一个数组
  4. 会把所有符合要求的的匹配一块返回
    1
    2
    3
    4
    var str = 'a222b333';
    var reg = /\d+/g;
    var res = str.match(reg)
    console.log(res)  //--> ["222","333"]=

正则中的分组和分组中的引用:想获取到字符串中的一部分那么可以使用分组 =》在正则中使用小括号；

  1. 分组影响捕获结果：exec返回的结果数组，从第二项开始分别是分组捕获到的内容

    1
    2
    3
    var id = '211224198602108210';
      var reg =/^\d{6}(\d{4})\d{6}(\d)(?:\d|X)$/; //?:
      console.log((reg.exec(id))) // -》["211224198602108210", "1986", "1", index: 0, input: "211224198602108210"]

  2. 括号从左到右依次出现的顺序作为分组的顺序，RegExp.$1-RegExp.$9,保存着正则实例最后的一次被使用的分组的内容

  • /(\d)(\d)\1\2/ ->abab

    split和replace

  1. split的用法：split的参数可以是一个正则，拆分字符串的时刻会把正则匹配到的位置全部拆分

    1
    2
    3
    var str = 'a b-c d';
    var res = str.split(/[ -]/); //空格或者-拆分
    console.log(res)

  2. replace的用法：(会在原字符串的副本上进行操作)

  • 将副本返回
  • 如果第二个参数是一个函数，是这个函数的返回值return来替换第一个参数所匹配到的内容。=》函数执行的次数取决于第一个参数成功匹配的次数
  • 第二个参数是一个函数的话，其中的arguments:[总正则在当次执行匹配到的内容,从第二项开始分别是分组n…,index,input]
  • 当第二个参数是”$1”字符串，如果有分组那么代表就是分组
    1
    2
    3
    4
    5
    6
    var str ='53124';
    var str2='零一二三四五';
    str=str.replace(/\d/g,function(){
        return str2.charAt(arguments[0]);
        return str2[Number(arguments[0])];
    })
1
2
3
4
5
6
7
8
var str ="asdafawfwaf? wd = 几哈哈 && kw =xx"
String.prototype.s=function(){
        var obj={};
        this.replace(/([^?&=]+)=([^?&=]+)/g,function(){
            obj[arguments[1]]=arguments[2];
        });
        return obj;
    }

正向预查和负向预查

  1. ?= 正向预查： zero-width-lookahead
    • 必须是什么,肯定,不参与捕获
  2. ?! 负向预查: zero-width-lookbehind
    • 不能是什么,否定,不参与捕获