js中的正则表达式

本文介绍javaScript正则表达式

目录

创建正则表达式
正则表达式flag
在字符串中使用正则表达式
正则表达式的方法
元字符
特殊字符
贪婪模式
分组

---

1. 创建正则表达式

   var str = "I love English";
   var reg = new RegExp("love", "g"); 使用构造函数创建
   var reg = /love/g; 使用字面量形式
   

2. 正则表达式flag

   i 表示不区分大小写 var reg = /Love/i;
   g 全局匹配
   m 多行模式
   u uicode模式
   y 粘连模式
       使用粘连模式，只有指定了正确lastIndex，才会匹配元素
       var str = "aa-aa-aa";
       var reg = /-/y;
       reg.lastIndex = 2;
       console.log(reg.exec(str))
   

3. 在字符串中使用正则表达式

   • search

   返回给定要查找的字符第一个出现的索引位置
       var str = "I love English";
       var reg = /Love/i;
       console.log(str.search(reg)); -> 2
   

   • match

   返回字符串匹配的相关信息
       不使用正则 g 
           只匹配第一个满足的元素
           var str = "I love English";
           var reg = /Love/i;
           console.log(str.match(reg)); -> ["love", index: 2, input: "I love English"]
           使用小括号可以提取一部分
           var reg = /(Love)/i;
           console.log(str.match(reg)); -> ["love", "love", index: 2, input: "I love English"]
       使用正则 g
           开启g后，全局查找符合的元素
           var str = "aa aa aa";
           var reg = /aa/g;
           console.log(str.match(reg)); -> ["aa", "aa", "aa"]
           使用小括号无用
       没有匹配的元素则返回null
   

   • split

   分割字符串
       var str = "aaCDaaCDaa";
       console.log(str.split(/CD/));
   

   • replace

   替换字符串一部分
       var str = "aa-aa-aa";
       console.log(str.replace(/-/, "A")); 替换第一个 "aaAaa-aa"
       console.log(str.replace(/-/g, "A")); 替换所有的 "aaAaaAaa"
       第二个参数中可以使用反向引用字符
           $$ 表示一个$字符 console.log(str.replace(/-/g, "$$")); -> aa$aa$aa
           $& 表示匹配到的字符 console.log(str.replace(/-/g, "$&$&")); -> aa--aa--aa
           $` 表示匹配到的字符之前的所有字符 console.log(str.replace(/-/g, "C$`")); -> aaCaaaaCaa-aaaa
           $' 表示匹配到的字符之后的所有字符 console.log(str.replace(/-/g, "C$'")); -> aaCaa-aaaaCaaaa
           $n 表示匹配的字符中第几个括号中匹配的字符 console.log(str.replace(/(-)/g, "C$1")); -> aaC-aaC-aa
       第二个参数还可以使用函数
           只要匹配到了都会调用此函数
           console.log(str.replace(/(-)/g, function(...obj){
               console.log(obj); -> ["-", "-", 2, "aa-aa-aa"] 
               obj的参数
                   第一个参数，匹配的字符
                   第二个参数，小括号的字符
                   第三个参数，匹配的字符的索引位
                   第四个参数，原始字符
               return 1
           })); -> aa1aa1aa
   

4. 正则表达式的方法

   • test

   判断是否有符合正则匹配的元素
       console.log(/a/.test(str)); -> true
       等价于 console.log(str.search(/a/) != -1);
   

   • exec

   exec用来提取匹配的元素
       不使用g，作用和不用g的match方法是一样的
           var str = "aa-aa-aa";
           console.log(/-/.exec(str)); -> ["-", index: 2, input: "aa-aa-aa"]
       使用g，重复调用exec逐步向后查找
           var str = "aa-aa-aa";
           var reg = /-/g;
           console.log(reg.exec(str)); -> ["-", index: 2, input: "aa-aa-aa"]
           console.log(reg.exec(str)); -> ["-", index: 5, input: "aa-aa-aa"]
           全部找出匹配的元素
           let result = null;
           while(result = reg.exec(str)){
               console.log(result);
           }
   

5. 元字符

   d 数字0~9
   s 空字符spaces,tabs,newlines
   w 字母 a-ZA-Z_
    简单点理解，是用来表示w单词的边界 "1 11 111 22".match(/dd/g) -> ["11", "22"]
   D 非数字字符
   S 非空格字符
   W 非字母字符
   B 非边界
   . 匹配任意字符，除了newlines
   

6. 特殊字符

   需要转义的字符
       . ( )  / [ ]
   []用法
       [abc] 表示多个字符中的一个
       [a-z]
       [^abc] 表示除了abc以外的字符
   量词
       d{5} 表示5个数字
       d{3,5} 表示 >=3 <=5 个字符
       d{3,} 表示 >=3 个字符
       + 一个或一个以上
       ? 0个或者一个
       * 0个或者多个
   或
       a|b|c
   精确匹配
       /^abc$/
   

7. 贪婪模式

   在使用量词的时候，默认是开启贪婪模式的
       let str = "today is a 'good day', isn't it?"
       console.log(str.match(/'.+'/)); -> ["'good day', isn'", index: 11, input: "today is a 'good day', isn't it?"]
   取消贪婪模式
       console.log(str.match(/'.+?'/)); -> ["'good day'", index: 11, input: "today is a 'good day', isn't it?"]
       console.log(str.match(/'[^']+'/)) -> ["'good day'", index: 11, input: "today is a 'good day', isn't it?"]
   

8. 分组

   使用圆括号可以提取组
       let str = "aa-bb-aa";
       console.log(str.match(/(a)+/)); -> ["aa", "a", index: 0, input: "aa-bb-aa"]
   取消捕获组
       console.log(str.match(/(?:a)+/)); -> ["aa", index: 0, input: "aa-bb-aa"]
   分的组可以直接在正则表达式中引用
       console.log(str.match(/(a)1/)); -> ["aa", "a", index: 0, input: "aa-bb-aa"]