Js-正则表达式和常用表达式

- 日理万妓 2023-06-28 06:29 103阅读 0赞

# Ⅰ- 壹 - 正则 #

*  微型语言 正则表达式
 *  判断字符串是否符合规则

**创建正则**

var reg=/正则内容/修饰符
    var reg=/a/g;//字面量创建 /正则内容/修饰符
    
    var reg=new RegExp(正则内容,修饰符)
    var reg=new RegExp("s","g")//构造函数创建

## 一 正则方法两种 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>简介</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>reg.exec()</td> 
   <td>没有查找到返回null，用来查找满足正则匹配内容的结果并且返回一个数组这个数组只有一个元素，多个属性分别是群组，还有索引，字符串本身，并不可以全局匹配</td> 
  </tr> 
  <tr> 
   <td>reg.test()</td> 
   <td>判断字符串正则是否满足,检索字符串中指定的值。返回 true 或 false。</td> 
  </tr> 
 </tbody> 
</table>

console.log((/^[-+]?\d*$/).test("24"));

## 二 正则表达式的符号 ##

#### 1 修饰符 ####

<table> 
 <thead> 
  <tr> 
   <th>修饰符</th> 
   <th>简介</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>i</td> 
   <td>正则匹配内容忽略大小写</td> 
  </tr> 
  <tr> 
   <td>g</td> 
   <td>全局匹配 从头查找到尾部</td> 
  </tr> 
  <tr> 
   <td>m</td> 
   <td>匹配多行</td> 
  </tr> 
 </tbody> 
</table>

#### 2 范围符（方括号） ####

方括号用于查找某个范围内的字符：括号内都需要加上转义斜杠 \\ 字符串本身具有转义

<table> 
 <thead> 
  <tr> 
   <th>表达式</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>[abc]</td> 
   <td>查找方括号之间的任何字符。</td> 
  </tr> 
  <tr> 
   <td>[^abc]</td> 
   <td>查找任何不在方括号之间的字符。^ 表示不选取 如果^ 不是第一个则无效</td> 
  </tr> 
  <tr> 
   <td>[0-9]</td> 
   <td>查找任何从 0 至 9 的数字。[0-20]= [0-2 0] === [0-2]</td> 
  </tr> 
  <tr> 
   <td>[a-z]</td> 
   <td>查找任何从小写 a 到小写 z 的字符。</td> 
  </tr> 
  <tr> 
   <td>[A-Z]</td> 
   <td>查找任何从大写 A 到大写 Z 的字符。</td> 
  </tr> 
 </tbody> 
</table>

#### 3 元字符 ####

元字符（Metacharacter）是拥有特殊含义的字符：

<table> 
 <thead> 
  <tr> 
   <th>元字符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>.(点)</td> 
   <td>查找单个字符，除了换行和行结束符。统配的字符 ，一个点代表一个字符（匹配任意一个），写在[ ] 中就是转义之后的点 而不是通配符</td> 
  </tr> 
  <tr> 
   <td>\w</td> 
   <td>查找单词字符。[ a-zA-Z0-9_」</td> 
  </tr> 
  <tr> 
   <td>\W</td> 
   <td>查找非单词字符。[ ^a-zA-Z0-9_」</td> 
  </tr> 
  <tr> 
   <td>\d</td> 
   <td>查找数字。等价于[0-9]</td> 
  </tr> 
  <tr> 
   <td>\D</td> 
   <td>查找非数字字符。等价于[ ^0-9]</td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td>查找空白字符。等价于[ \f\n\r\t\v]</td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td>查找非空白字符。</td> 
  </tr> 
 </tbody> 
</table>

#### 4 重复 ####

<table> 
 <thead> 
  <tr> 
   <th>量词</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>n+</td> 
   <td>表达式至少出现1次，相当于 {1,}，比如：["a+b"可以匹配 “ab”,“aab”,“aaab”…]</td> 
  </tr> 
  <tr> 
   <td>n*</td> 
   <td>表达式不出现或出现任意次，相当于 {0,}，比如：["/^*b"可以匹配 “b”,"^^^b"…]</td> 
  </tr> 
  <tr> 
   <td>n?</td> 
   <td>匹配表达式0次或者1次，相当于 {0,1}，比如：["a[cd]?"可以匹配 “a”,“ac”,“ad”]</td> 
  </tr> 
  <tr> 
   <td>n{X}</td> 
   <td>表达式重复n次，比如：["/w{2}" 相当于 “/w/w”]；[“a{5}” 相当于 “aaaaa”]</td> 
  </tr> 
  <tr> 
   <td>n{X,Y}</td> 
   <td>表达式至少重复m次，最多重复n次，比如：["ba{1,3}"可以匹配 “ba"或"baa"或"baaa”]</td> 
  </tr> 
  <tr> 
   <td>n{X,}</td> 
   <td>表达式至少重复m次，比如：["/w/d{2,}“可以匹配 “a12”,”_456",“M12344”…]</td> 
  </tr> 
  <tr> 
   <td>n$</td> 
   <td>匹配任何结尾为 n 的字符串。与字符串结束的地方匹配，不匹配任何字符</td> 
  </tr> 
  <tr> 
   <td>^n</td> 
   <td>匹配任何开头为 n 的字符串。与字符串开始的地方匹配，不匹配任何字符</td> 
  </tr> 
  <tr> 
   <td>?=n</td> 
   <td>匹配任何其后紧接指定字符串 n 的字符串。</td> 
  </tr> 
  <tr> 
   <td>?!n</td> 
   <td>匹配任何其后没有紧接指定字符串 n 的字符串。</td> 
  </tr> 
 </tbody> 
</table>

#### 5 转义 ####

两个\\在字符或者正则表达式的\[\]都是-一个\\

console.1og("aa\\a\a" .match(/[\\]/g)); //打印 /
    
    
    console.log("aZsw" . match(/[a-zA-Z]/g));
    console.log("aZsw" .match(/[a-zA-Z0-9]/g));

## 三 字符串匹配正则方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>简介</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>str.search()</td> 
   <td>按照正则表达式查找字符串中的内容,返回优先查找到第一个元素下标， 不能全局匹配。</td> 
  </tr> 
  <tr> 
   <td>str.split()</td> 
   <td>按照正则表达式匹配内容切割字符串</td> 
  </tr> 
  <tr> 
   <td>str.replace()</td> 
   <td>按照正则表达式匹配内容进行替换,可以替换成相同的也可以替换成不同的，可以获取下标和元素</td> 
  </tr> 
  <tr> 
   <td>str.match()</td> 
   <td>如果不加全局,可以达到exec的目的，如果加有全局匹配,就会只返回找到的所有元素数组，如果加有群组,但是不加全局,则除返回找到的元素外,还返回群组的元素。</td> 
  </tr> 
 </tbody> 
</table>

#### 1 str.search() ####

按照正则表达式查找字符串中的内容,返回优先查找到第一个元素下标  
**用法：**

var str="abcdeafgh";
    console.log(str.search(/a/));// 0

#### 2 str.split() ####

按照正则表达式匹配内容切割字符串，不能使用全局匹配  
**用法：**

str.split("b")
    console.log(str.split(/[cf]/));//Array(3) [ "ab", "dea", "gh" ]
    
    var str=" abc (nihao)dejs";
    str=str .split(/[]/)[1];
    console.log(str);//nihao

#### 3 str.replace() ####

按照正则表达式匹配内容进行替换,可以替换成相同的也可以替换成不同的。可以获取元素和下标  
**用法：**

str=str.replace(/a/g,"z");
    	str.replace(正则表达式,回调函数(item,index){ 
        return //返回要替换的内容
      })

var str="abcdeafgh";
     str=str.replace(/a/g,function(item,index){ 
        return index===0 ? "x" : "y";
    })
    console.log(str); //xbcdeyfgh

**查找所有匹配正则元素的下标**

var str="abcdeafgh";
    var arr=[];
            str.replace(/a/g,function(item,index){ 
                arr.push(index);
            })
            console.log(arr); //Array [ 0, 5 ]

**把任何满足正则内容的进行替换**

var str="abcdeafgh";
    str=str.replace(/[bdfh]/g,"0");
    console.log(str);//a0c0ea0g0

var str="abcabcadf";
    str=str.replace(/[abc]/g,function(item){ 
        switch(item){ 
            case "a":return "1";
            case "b":return "2";
            case "c":return "3";
        }
    });
    console.log(str);//1231231df

var str = "中国四大古典名著有'西游记', '红楼梦', '水浒','三国演义'";
    
        var n = 0;
        str = str.replace(/'/g, function (item) { 
          return n++ % 2 === 0 ? "《" : "》";
        });
    console.log(str)//中国四大古典名著有,《西游记》, 《红楼梦》, 《水浒》,《三国演义》

#### 4 str.match() ####

如果不加全局,可以达到exec的目的。如果加有全局匹配,就会只返回找到的所有元素数组。 如果加有群组,但是不加全局,则除返回找到的元素外,还返回群组的元素

**用法：**

var str="abcadef";
    
    console.log(str.match(/a/g));//Array [ "a", "a" ]

![在这里插入图片描述][20200108192521712.png]

## 四 正则用法以及特性 ##

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>/a{0}/</td> 
   <td>没有字符a,意味着匹配一个空字符</td> 
  </tr> 
  <tr> 
   <td>/b{0}/</td> 
   <td>匹配一个空字符</td> 
  </tr> 
 </tbody> 
</table>

console.log("aaaaaa".match(/a{3,4}/g));//最大允许4，最小允许3次

#### 1 贪婪匹配 先匹配最大的 ####

所谓的贪婪性就是正则在捕获时，每一次会尽可能多的去捕获符合条件的内容。  
如果我们想尽可能的少的去捕获符合条件的字符串的话，可以在量词元字符后加“?“”

console.log("aaaaaaaa".match(/a{2,4}/g));//Array [ "aaaa", "aaaa" ]
    
    console.log("aaaaaabbb".match(/a{0,4}/g));//Array(6) [ "aaaa", "aa", "", "", "", "" ]

.\*:在一起就表示任意字符出现零次或多次,没有`?`表示贪婪模式

#### 2 非贪婪匹配 ####

用于\* + 或者\{ \} 来匹配最少的部分，用于重复的数据

console.log("aaaaaaaa".match(/a{2,5}?/g));//Array(4) [ "aa", "aa", "aa", "aa" ]
     console.log("aaaaaaaa".match(/a{2}/g));//Array(4) [ "aa", "aa", "aa", "aa" ]
     console.log("caaaaatcbbbbt".match(/c.*?t/g));//Array [ "caaaaat", "cbbbbt" ]

.\*?:就是匹配尽可能少的字符。就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复(非贪婪模式)

#### 3 断言 ####

断言只是条件，本身并不会匹配，能帮助你找到符合条件的字符串

*  ?= 后置条件 向后断言，例：(?=a) 仅当表达式 a 在 此位置的右侧（后面）匹配时才继续匹配。
 *  ?! 向后断言，不等于，例：(?!a) 仅当表达式 a 不在 此位置的右侧（后面）匹配时才继续匹配
 *  ?<= 前置条件 向前断言，例：(?<=a) 仅当表达式 a 在 此位置的左侧（前面）匹配时才继续匹配。
 *  ?<! 前置条件不等于，例：(?<!a) 仅当表达式 a 在 此位置的左侧（前面）匹配时才继续匹配。

###### （1）前瞻断言 ######

1.  **(?=exp) 顺序肯定环视，表示所在位置右侧能够匹配exp**

console.log("abad adef adcd".replace(/a(?=d)/g,"0"));//ab0d 0def 0dcd

console.log("a0bcd adef a&cd".replace(/a(?=[a-z])|a(?=[0-9])/g,"1"));//10bcd 1def a&cd

1.  **(?!exp) 顺序否定环视，表示所在位置右侧不能匹配exp**

console.log("a0bc adef a&bc".replace(/a(?![a-z])/g,"1"));//相当于不等于 //10bc adef 1&bc

console.log("a0bcd adef a&cd".replace(/a(?![a-z])|a(?![0-9])/g, "1"));//10bcd 1def 1&cd

###### （2）后瞻断言 ######

1.  **(?<=exp) 逆序肯定环视，表示所在位置左侧能够匹配exp**

console.log("a0bc adef a&bc".match(/(?<=[0-9])b/g))  //["b"]
     console.log("a0bc adef a&bc".replace(/(?<=[0-9])b/g,"1"));//前置条件 //a01c adef a&bc

1.  **(?<!exp) 逆序否定环视，表示所在位置左侧不能匹配exp**

console.log("a0bc adef a&bc".replace(/(?<![0-9])b/g,"1"));//前置条件不等于 //a0bc adef a&1c

#### 5 或者 | ####

| | 或者 空字符串

console.log("abcdef".match(/|a|b/g));//如果|得一端没有内容,则认为匹配空字符
     
    console.log("abcdef".match(/a||b/g));//如果|得一端没有内容,则认为匹配空字符
    
    console.log("abcdef".match(/a|d|/g));//如果|得一端没有内容,则认为匹配空字符

#### 6 群组 ( ) ####

当使用match时，如果使用群组，加上g和不加g是有差距

不加g可以将每个群组列表在数组的下标1开始的元素

加g就不能找到群组内容

console.log("18617891076".match(/(\d{3})(\d{4})(\d{4})/)) //Array(4) [ "18617891076", "186", "1789", "1076" ]
    
     console.log("10[a]3[bc]".match(/(\d+)\[([a-zA-Z]+)\]/g)) "10[a]"，"3[bc]"

在replace中如果不使用群组，后面的函数中参数第一位时符合正则内容，第二位是这个字符的下标

在replace中如果使用群组，后面的函数中参数分别是符合正则的内容，和每个群组的内容

默认  $1,$2,$3....   为群组的第几个
    
    //3[a]3[bc]==>aaabcbcbc
    
    var str="10[a]3[bc]".replace(/(\d+)\[([a-zA-Z]+)\]/g,function($1,$2,$3){ 
    
         return $3.repeat($2);
    
      });
    
    
    var str="10[a]3[bc]".replace(/(\d+)\[([a-zA-Z]+)\]/g,function(item1,item2,item3){ 
    
         return item3.repeat(item2);
    
      });
    
      console.log(str);

# Ⅱ - 贰 - 正则表达式（示例） #

#### 一 隐藏手机号 ####

方法1：

var str="18617891076".match(/(\d{3})(\d{4})(\d{4})/).slice(1).reduce(function(value,item,index){ 
            return index===1 ? value+"****" : value+item;
        })
        console.log(str);  //186****1076

方法2：

var str="18617891076".replace(/(\d{3})(\d{4})(\d{4})/,"$1****$3");
       console.log(str);   //186****1076

#### 二 检测中文 ####

console.log("你好".match(/[\u4e00-\u9fd5]+/g)); //数组

#### 三 检测邮箱 ####

console.log("xietian@163.com".match(/^\w+@\w{2,}\.(com|net)$/)); //Array [ "xietian@163.com", "com" ]

#### 四 内容必须包含数字 ####

并且的关系

console.log("sadfsad213423".match(/^(?=.*\d)(?=.*[a-z])\w+$/));

# Ⅲ - 叁 - 常用表达式 #

1.匹配手机号码
        /^(0|86|17951)?(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{ 8}$/
        举例：
            if(!tel.match(/^(0|86|17951)?(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$/)){ 
                  alert("请输入正确的手机号码！");
    
             }
       2.匹配邮箱
         /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{ 2,4})+$/
         ^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
         举例：
             if(!eamil.match( /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/)){ 
                  alert("请输入正确的手机号码！");
    
             }  
        3.匹配中国大陆身份证
          /^[1-9]\d{ 5}[1-9]\d{ 3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{ 3}(\d|x|X)$/
    	  18位身份证号码	^((\d{ 18})|([0-9x]{ 18})|([0-9X]{ 18}))$
        4.匹配数字,字母,下划线,中文
          /^[\u4e00-\u9fa5A-Za-z0-9_]+$/ 
    
        5.匹配IP地址  
          /^[1-9]\d{ 5}$/
    
        6.匹配网址URL
          /^(f|ht){ 1}(tp|tps):\/\/([\w-]+\.)+[\w-]+(\/[\w- ./?%&=]*)?/
    
        7.匹配字母开头，5-16字符，字母数字下划线：
          /^[a-zA-Z][a-zA-Z0-9_]{ 4,15}$/   
    
        8. 域名	[a-zA-Z0-9][-a-zA-Z0-9]{ 0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
      
        9. InternetURL	[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
      
        10. 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)	^[a-zA-Z][a-zA-Z0-9_]{ 4,15}$
    	11.码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)	^[a-zA-Z]\w{ 5,17}$
    	12.日期格式	^\d{ 4}-\d{ 1,2}-\d{ 1,2}
    	13.空白行(可以用来删除空白行)	\n\s*\r
    	14.首尾空白字符(可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)	^\s*|\s*$或(^\s*)|(\s*$)

正则验证代码如下：

验证字母：/^[a-zA-Z]+$/
    验证长度为3的字符：/^.{ 3}$/
    验证由26个英文字母组成的字符串：/^[A-Za-z]+$/
    验证日期YYYY-MM-DD：/^(\d{ 1,4})(-|\/)(\d{1,2})\2(\d{1,2})$/
    验证邮编：/^\d{ 6}$/
    验证日期格式YYYY-MM-DD hh:mm:ss：/^(\d{ 1,4})(-|\/)(\d{1,2})\2(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/
    验证整数：/^[-+]?\d*$/
    验证小数：/^[-\+]?\d+(\.\d+)?$/
    验证中文：/^[\u4e00-\u9fa5]+$/
    验证邮箱：/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/
    验证手机号：/^1[3456789]\d{ 9}$/
    验证身份证：/^\d{ 6}(18|19|20)?\d{ 2}(0[1-9]|1[12])(0[1-9]|[12]\d|3[01])\d{ 3}(\d|X)$/

3\[a\]3\[bc\]==>aaabcbcbc

默认  $1,$2,$3....   为群组的第几个
    
    var str="10[a]3[bc]".replace(/(\d+)\[([a-zA-Z]+)\]/g,function($1,$2,$3){ 
    
         return $3.repeat($2);
    
      });
    
    
    var str="10[a]3[bc]".replace(/(\d+)\[([a-zA-Z]+)\]/g,function(item1,item2,item3){ 
    
         return item3.repeat(item2);
    
      });
    
      console.log(str);

# 0 - 0 - 知识点： #

### repeat() ###

使用repeat之后会将原来的字符串复制n次

let str="qwe"
      
     let str2=srt.repeat(2)
      
     console.log(str2) *//qweqwe*

[20200108192521712.png]: https://img-blog.csdnimg.cn/20200108192521712.png