正则表达式常用学习

0.简介

regular expression,规则表达式,是一种用来处理字符串的规则,巧妙的正则表达式可以节省很多判断代码.

1.组成

• 元字符
  • 特殊元字符

\ 转义字符 => 普通字符 <=> 特殊字符
. 点 => 代表除了\n 以外的任意字符(字符字符字符)
^ => 以哪个元字符开始
$ => 以哪个元字符作为结束
\n 任意一个换行符
\d 0-9之间的一个数字
\D 除了0-9之间的任意字符
\w 数字字母下划线中的任意一个字符
\W
\s 一个空白字符 空格 制表符 换页符等
\t 一个制表符 4个空格
\b 单词边界
x | y 或者
[xyz] => x | y | z
[^xy] => 除了 x | y 的任意字符
[a-z]
[^a-z]
(正则中的分组符号)
(?😃 => 只匹配不捕获
(?=) => 正向预查
(?!) => 负向预查

• 量词元字符

* => 0-多次
+ => 1-多次
? => 0 - 1次
{n} => 出现n次
{n,m} => 出现n-m次

• 普通元字符

/abc/ 匹配abc

• 修饰符

1. i ignoreCase
   忽略单词大小写
2. m multiLine
   进行多行匹配
3. g global
   全局匹配

2.贪婪性

    let str = 'ab2020nb',
    // 贪婪性:默认情况下,捕获的时候,按照当前正则匹配的最长结果来获取
    reg = /\d+?/g
    console.log(str.match(reg))  
    // 在量词后面设置? 取消捕获时候的贪婪性 按照正则匹配的最短结果来获取
    
    /*
      * 问号的作用
      * 问号左边是非量词元字符:则此时问号本身代表两次元字符出现0-1次
      * 问号左边是量词元字符:取消捕获时候的贪婪性  /\d+?/g
      * (?:) 只匹配不捕获
      * (?=) 正向预查
      * (!=) 负向预查
    */

3.懒惰型

   /*
       * 基于exec的捕获
       * 捕获到的结果是一个数组或者null
       * 第一项:本次捕获到的内容
       * 其余项:对应小分组本次单独捕获的内容
       * 当前捕获内容在字符串中的索引
       * input:原始字符串
       * 每执行一次exec只能捕获到一个符合正则规则的字符串,默认情况下执行多次也只能匹配第一次捕获的结果  => 正则捕获的懒惰型
       * 懒惰产生的原因:每一次匹配的lastIndex值不变 只能通过全局修饰符才能改变这一特性
       * lastIndex : 当前正则匹配下一次匹配的起始索引位置
       *
       * 设置全局匹配符g之后第一次匹配完成之后会自动修改lastIndex的值
       * 此时可以进行循环多次进行匹配
       *
       */
      let str = 'nb13奥利给6666aaaa',
        reg = /\d+/g
 

4.举例几个简单正则表达式

• 1).验证手机号

     //  \^abc0$\  只能是abc0
 
      // 验证手机号
      let tel = /^1\d{10}$/ //1后面十位数字
 
      let reg1 = /^2.3$/ //=> 只能匹配2中间一个除了换行之外的任意字符 3
      console.log(reg1.test('2.3'))
      console.log(reg1.test('253'))
      console.log(reg1.test('2@3'))
      let reg2 = /^2\.3$/ //=> 只能是2.3
      console.log(reg2.test('2.3'))
      let reg3 = /^\\d$/ // => 匹配   \d  特殊转换为普通
      console.log(reg3.test('\\d'))
 
      // 直接使用 /^18|69$/  存在很乱的优先级问题
      // /^(18|69)$/  这样不存在优先级混乱问题
 
      // [] 中括号出现的字符一般都是代表本身的含义 且不包含多位数 只能是一位数
      // /^[@+]/$  出现@ 或者+ 中的一个
      //  /^[\d]$/  \d在中括号中还是0-9数字
      //  /[10-29]/  1 0 - 2 9

• 2).验证是否为有效数值

     // 验证是否为有效数值
      // 规则分析: 可能出现正负号 只出现一位  [+-]?
      //        一位0-9 多位不能0开头 (\d | [1-9]\d+)
      //        小数部分可能有可能没有 有小数点后面必须有数字 (\.\d+)?
      // 重点重点重点  正则中不能随意添加空格,空格会被识别当做判别中的一位
      let num = /^[+-]?(\d|([1-9]\d+))(\.\d+)$/
      console.log(num.test('+0.1'))

// 更简单
isNaA(parseFloat(num)) === true 

• 3)验证真实姓名

      /*
       *验证真实姓名
       * 汉字范围 /^[\u4E00-\u9FA5]$/
       * 名字长度2-10
       * 可能有译名  .汉字
       *
       * /^[\u4E00-\u9FA5]{2,10}(·[\u4E00-\u9FA5]{2,10}){0,2}$/
       *
       */
      let reg = /(.)?/
      reg.test('.')

• 4. 验证邮箱

      /*
       *验证邮箱
       *  \w+((-\w+)|(\.\w+))*
       * 开头是字母数字下划线(1-多位)
       * 还可以输 -数字字母下划线 或者.数字字母下划线 *
       * 邮箱的名字由数字字母下划线- . 几部分组成但是.-不能连续出现或者作为开头
       *
       * @[A-Za-z0-9]+
       * @后面数字字母1-多位
       *
       * ((\.|-)[A-Za-z0-9]+)*
       * 对@后面名字的补充
       * 多域名  .com.cn
       * 企业邮箱 zdz@jiazu-qiye.com
       *
       * \.[A-Za-z0-9]+
       * 匹配最后的常规    .com  域名
       */
 
      let email =
        /^\w+((-\w+)|(\.\w+))*@[A-Za-z0-9]+((\.|-)[A-za-z0-9]+)*\.[A-Za-z0-9]+$/

• 5. 身份证验证

  /*
      *身份证
      *规则:
            1.一共18位
            2.最后一位可能是X  代表10
            前六位:省市县
            最后四位:
              最后一位X或者数字
              倒数第二位: 偶数女 奇数 男
              其余两位经过算法算出
 
              小括号还具有:分组捕获功能,不仅可以把大正则匹配的信息捕获,还可以单独捕获到每个小组的内容
      *
    */
      let id = /^(\d{6})(\d{4})(\d{2})(\d{2})(\d{2})(\d)(\d|X)$/
      console.log(id.exec('37152219900101823X'))

5.以前学习的记录

  let time = '2020-11-6'  // => 2020年11月16日
    let reg = /^(\d{4})-(\d{1,2})-(\d{1,2})/g
    time2 = time.replace(reg,'$1年$2月$3日')
    console.log(time2)
 
    // 思路:拿reg和time匹配捕获,匹配几次就会把传递的函数执行几次
    //      不仅把方法执行而且replace还会把实参信息传递给函数
    time1 = time.replace(reg,(...arg) => {
      console.log(arg)
      // 参数中第一项为捕获到的完整字符串,其后为每次捕获到的小分组
      // 最后一项为匹配字符串 倒数第二项为第一次匹配的索引
      let [,$1,$2,$3] = arg
      function padZero(str) {
        return ('00' + str).slice(str.length)
      }
      $2 = padZero($3)
      $3 = padZero($2)
      return $1 + '年' + $2 + '月' + $3 
      + '日'
    })
    console.log(time1)
 
   // 首字母大写  replace不改变原字符串
 
    let reg1 = /\b([a-zA-Z])[a-zA-Z]+\b/g
    let str1 = 'good good study day day up!'
    // 函数执行6次
    str1 = str1.replace(reg1,(...arg) => {
      // 参数的第一项是匹配的完整分组 good 第二项是匹配到的小分组 g
      console.log(arg)
      let [content,$1] = arg
      $1 = $1.toUpperCase()
      content = content.slice(1)
      return $1 + content
    })
    console.log(str1)

• 字母出现最大次数

 /*
      * 如何验证一个字符串中那个字符串出现的次数
      *
      *
    */
 
    let str = 'aaabbbbbbbbccccbcccccd'
    // 去重
    function statastic(str) {
      let obj = {},
        max = 1,
        res = []
        ;[].forEach.call(str, char => {
          if (typeof obj[char] !== 'undefined') {
            obj[char]++
            return
          }
          obj[char] = 1
        })
      for (let key in obj) {
        let item = obj[key]
        item > max ? max = item : null
      }
      for (let key in obj) {
        if (obj[key] === max) {
          res.push(key)
        }
      }
      // 此时res被转换为字符串
      return `maxItem:${res}\nvalue:${max}`
    }
    console.log(statastic(str))
 
 
    // 排序
    function statastic1(str) {
      // 将字符串转化为数组排序再转化为字符串
      str = str.split('').sort((a, b) => a.localeCompare(b)).join('')
      // 匹配重复字母
      let reg = /([a-zA-Z])\1+/g
      // 捕获
      let arr = str.match(reg)
      // 把捕获的结果数组根据长度排序 得到一个降序排列的数组里面包含结果数组字符串
      // ["bbbbbbbb", "cccccccc", "aaa"]
      arr.sort((a, b) => b.length - a.length)
      console.log(arr)
      let max = arr[0].length,
        res = [arr[0].substr(0, 1)]
      // 对于可能出现相同次数的字母进行查询
      for (let i = 1; i < arr.length; i++) {
        let item = arr[i]
        if (item.length < max) {
          break
        }
        res.push(item.substr(0, 1))
      }
      return `maxItem:${res}\nvalue:${max}`
    }
    console.log(statastic1(str))
 
    function statastic3(str) {
      // 字母排序
      str = str.split('').sort((a, b) => a.localeCompare(b)).join('')
      let max = 0,
        res = [],
        flag = false;
        console.log(str)
      for (let i = str.length; i > 0; i--) {
        // 查找出现次数最多的  从最大次数(字符串长度)开始检测
        let reg = new RegExp('([a-zA-Z])\\1{' + (i - 1) + '}', 'g')
        str.replace(reg, (content, $1) => {
          res.push($1)
          max = i 
          flag = true
          // break //不能放在这里 只能放在循环中
        })
        if (flag) {
          break
        }
      }
      return `maxItem:${res}\nvalue:${max}`
    }
    console.log(statastic3(str))

• 时间字符串格式化

   /*
      * 服务器获取时间字符串格式
      * 2020-11-17 09:00:00
      * 2020/11/17 09:00:00
      * 想要转化为的格式
      * 2020年08月13日
      * 08月13日 09时00分
    */
 
    function formatTime1(template) {
      // 1.获取字符串中年月日时间
      let timeArr = this.match(/\d+/g)
      template = template || "{0}年{1}月{2}日{3}时{4}分{5}秒"
      template = template.replace(/\{(\d+)\}/g, (content, $1) => {
        let time = timeArr[$1] || '00'
        // 补0
        function padZero(str) {
          return ('00' + str).substr(str.length)
        }
        time = padZero(time)
        return time
      })
      return template
    }
    // 简化代码
    function formatTime(template = "{0}年{1}月{2}日{3}时{4}分{5}秒") {
      let timeArr = this.match(/\d+/g)
      // 直接解构赋值
      return template.replace(/\{(\d+)\}/g, (...[,$1]) => {
        let time = timeArr[$1] || '00'
        return time.length < 2 ? '0' + time : time 
      })
    }
 
    // 循环扩展原型方法
    ['formatTime'].forEach(item => {
      String.prototype[item] = eval(item)
    })
    let time = '2020-11-17 09:0:00'
    console.log(time.formatTime())
    console.log(time.formatTime('{3}时{4}分{5}秒'))

• 简单url拆分

    function queryParams(url) {
      let obj = {}
      let reg = /([^?=&#]+)=([^?=&#]+)/g
      url.replace(reg, (...[, $1, $2]) => obj[$1] = $2)
      url.replace(/#([^$=?]+)/, (...[, $1]) => obj.hash = $1)
      return obj
    }
    console.log(queryParams('www.baidu.com?123=456&id=888#box'))

• 千分符

function millionmeter(num) {
      num += ''
      num = num.split('').reverse().join('')
      for (let i = 3; i < num.length; i += 4) {
        let preV = num.substring(0, i),
          next = num.substring(i)
        num = preV + ',' + next
      }
      return num.split('').reverse().join('')
    }
    let num = 1151781932
    console.log(millionmeter(num))
 
 
    function millionmeter1(num) {
      num += ''
      num = num.split('').reverse()
      for (let i = 3; i < num.length; i += 4) {
        num.splice(i,0,',')
      }
      // reverse 不对原数组产生影响
      return num.reverse().join('')
    }
 
    console.log(millionmeter1(num))
 
   // 正向预查的使用 
    // 思想:从结尾开始进行前项预查 每三个数字一组,当数字不是三个就进行前一个匹配条件 捕获并且添加逗号 之后剩余所有分组都符合三个一组条件
    function millionmeter2(num) {
      num += ''
      let reg = /\d{1,3}(?=(\d{3})+$)/g
      return num = num.replace(reg,content => content + ',')
      
    }
    console.log(millionmeter2(num))