javaScript正则表达式精华

本文介绍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 全局匹配
   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_
   \b 简单点理解，是用来表示\w单词的边界 "1 11 111 22".match(/\b\d\d\b/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"]