正則表達式式應用非常廣泛，本文給大家收集整理些正則表達式知識點解讀及判斷有效數字、手機號郵箱正則表達式，對常用正則表達式相關知識感興趣的朋友一起學習吧

 

1、正則僅僅就是用來處理字符串的：匹配、捕獲

匹配：驗證當前的字符串是否符合我們的規則（每一個正則都是一個規則）
捕獲：在整個字符串當中，把符合規則的字符都依次的獲取到--->exec、match、replace

2、正則的組成：元字符、修飾符

元字符：

特殊意義的元字符：

/d匹配一個0-9的數字相當于[0-9]，和它相反的
/D匹配一個除了0-9的任意字符相當于【】  
/w匹配一個0-9、a-z、A-Z_ 的數字或字符，相當于[0-9a-zA-Z_]  、
/s匹配一個空白字符（空格、制表符。。。）
/b匹配一個單詞的邊界 “w100 w000”
/t匹配一個制表符
/n匹配一個換行
. 匹配一個除了/n以外的任意字符
^ 以某一個元字符開頭
$ 以某一個元字符結尾
/ 轉譯字符
x|y  x或者y的一個
[xyz] x、y、z、中的任意一個
[^xyz]除了x、y、z、中的任意一個
[a-z] -> 匹配a-z中的任意一個字符
[^a-z] -> 匹配除了a-z中的任意一個字符
() 正則中的分組

量詞：

*  0到多個
+  1到多個
?  0到1個    

？在正則中的意義比較多

    放在一個非量詞元字符后面代表出現0-1次  例如/^/d?$/出現0-9直接的數0到1次

    放在一個量詞元字符后面，取消捕獲時候的貪婪性  /^/d+?$/捕獲的時候只是把第一個捕獲的數字獲取 "2015"--->2
    (?:)分組值匹配不捕獲
    (?=)正向預查
    (?!)負向預查

()的作用
1)改變默認的優先級
2)可以進行分組捕獲
3)分組引用

{n}出現n次
{n,}出現n到多次
{n,m}出現n到m次

普通元字符

任何字符在正則中除了以上有特殊意義的，其他的都是代表本身意思的普通元字符

修飾符：

i：忽略字母的大小寫
m：multiline 多行匹配
g：global全局匹配

項目中經常使用的正則

1）判斷是有效數字的正則

   有效數字是指：正數、負數、零、小數

第一部分：可能出現加減或者沒有
第二部分：一位數可以是0，多位數不能以0開頭
第三部分：可以有小數也可以沒有小數，但是一旦出現小數點，后面至少跟一位數字
var reg =/^[+-]?(/d|[1-9]/d+)(/./d+)?$/;

有效的正整數（包含0）：/^[+]?(/d|[1-9]/d+)$/;

有效的負整數（包含0）：/^-(/d|[1-9]/d+)$/;

判斷手機號（簡單版）：
var  reg=/^1/d{10}$/;

判斷郵箱
第一部分：數字、字母、下劃線、- 一到多位
第二部分：@
第三部分：數字、字母、 一到多位
第四部分：(.兩到四位) .com   .cn   .net   ..      .com.cn
var reg =/^[0-9a-zA-Z_-]+@[0-9a-zA-Z-]+(/.[a-zA-Z]{2,4}){1,2}$/

判斷年齡在18到65之間的
18-19/20-59/60-65
var  reg =/^((18|19)|([2-5]/d)|(6[0-5]))$/

真實有效的中華人民共和國姓名 2-4 位漢字
var reg = /^[/u4e00-/u9fa5]{2,4}$/;

身份證號碼
前六位是省->市->縣（區）
四位年 兩位月 兩位日

簡單版

    var reg = /^/d{17}(/d|X)$/;
    130828199012040617

復雜版

    var reg = /^(/d{2})(/d{4})(/d{4})(/d{2})(/d{2})(?:/d{2})(/d)(?:/d|X)$/;

細節知識點

里面出現的任何字符都是代表本身意義的，例如：[.]中的”.“就是代表一個小數點而不是除了/n以外的任意字符
里面出現18不是數字18而是1或者8，例如[18-65]是1或者8-6或者5中任選一個

1、exec正則的捕獲方法--->先匹配，然后把匹配的內容捕獲

如果字符串沒有匹配這個正則，捕獲的返結果是null

如果和正則匹配，返回的結果是一個數組

例子
var str ="2015zhufeng2016peixun"
var reg = //d+/;

第一項是我們捕獲的內容

index：捕獲的內容在元字符串中開始的索引位置
input：捕獲的原始字符串

2、正則的捕獲是懶惰的

正則的每一次捕獲都從lastIndex值開始，第一次捕獲的時候，lastIndex=0，從原始字符串索引為0的位置開始查找捕獲，而默認的情況下，第一次捕獲完成，lastIndex的值并沒有發生改變，還是0，所以第二次捕獲還是從原始字符串索引為0處開始查找，這樣找到的還是第一次捕獲的內容
  解決辦法：添加全局修飾符g--->加上g后，第一次捕獲完成后，lastIndex的值發生了改變，變為第一次捕獲內容后的第一個字符的開始索引，第二次捕獲是繼續向后查找的...
  疑問：不用全局修飾符g每次捕獲完成后手動修改lastIndex的值不可以么？
不可以，雖然手動修改了lastIndex，確實把lastIndex的值進行改變了，但是正則查找的時候還是從索引0開始的
 

1. var str = "zhufeng2015peixun2016"; 
2.   var reg = //d+/g; 

例子

    為了防止沒有加全局修飾符g導致的死循環,我們在處理之前,對于沒有添加g的手動給添加一個g
 

1. RegExp.prototype.myExecAll = function myExecAll() { 
2.     var _this = this, str = arguments[0], ary = [], res = null; 
3.     !_this.global ? _this = eval(_this.toString() + "g") : null; 
4.     res = _this.exec(str); 
5.     while (res) { 
6.       ary[ary.length] = res[0]; 
7.       res = _this.exec(str); 
8.     } 
9.     return ary; 
10.   }; 
11.   var ary = reg.myExecAll(str); 
12.   console.log(ary); 
13.     console.log(reg.lastIndex);//->0 
14.     var res = reg.exec(str); 
15.     console.log(res); 
16.     console.log(reg.lastIndex);//->11 
17.     res = reg.exec(str); 
18.     console.log(res); 
19.     console.log(reg.lastIndex);//->21 
20.     res = reg.exec(str); 
21.     console.log(res);//->null 

 3、match:捕獲字符串中存在一個叫做match的方法也可以實現捕獲，而且只要我們取消了正則的懶惰性，執行一次match方法就可以捕獲到所有內容了
 

1. var str = "zhufeng2015peixun2016"; 
2. var reg = //d+/g; 
3. console.log(str.match(reg)); 

    疑問:那我們都用match來替換exec多好啊?

4、正則的分組捕獲

每一次捕獲的時候，不僅僅可以把大正則匹配的內容捕獲到，而且還可以把每一個小分組（子正則）匹配的內容單獨的捕獲到
 

1. var str = "zhufeng[2015]peixun[2016]"; 
2. var reg = //[(/d)(/d+)/]/g; 
3. var res = reg.exec(str); 
4. console.log(res); 
5. ["[2015]", "2", "015", index: 7, input: "zhufeng[2015]peixun[2016]"] 

第一項是大正則捕獲的內容 res[0]
第二項是第一個分組捕獲的內容 res[1]
第三項是第二個分組捕獲的內容 rex[2]
。。。。。

分組的只匹配不捕獲:我們如果執行把分組內容進行匹配但是不進行捕獲的話,只需要在分組的前面加上?:即可
 

1. var str = "zhufeng[2015]peixun[2016]"; 
2.  var reg = //[(?:/d)(/d+)/]/g; 
3.  var res = reg.exec(str); 
4.  console.log(res); 
5.  ["[2015]", "015"...] 

      數組中的第一項是大正則捕獲的內容 res[0]
      數組中的第二項是第二個分組捕獲的內容 res[1]
      第一個分組添加了?:,所以只匹配不捕獲

5、exec和match的區別

match只能捕獲大正則匹配的內容，對于分組捕獲中，是無法獲取分組匹配的內容的，所以如果捕獲的時候不需要捕獲分組的內容，我們直接用match更方便，如果需要捕獲分組的內容，我們只能使用exec來一個個捕獲
 

1. var str = "zhufeng[2015]peixun[2016]"; 
2.   var reg = //[(/d+)/]/g; 
3.   //console.log(str.match(reg));//->["[2015]", "[2016]"] 
4.   var ary = []; 
5.   var res = reg.exec(str); 
6.   while (res) { 
7.     //ary.push(res[1]); 
8.     ary.push(RegExp.$1);//RegExp.$1獲取當前正則第一個分組捕獲的內容，（可能在部分IE瀏覽器下捕獲不到值） 
9.     res = reg.exec(str); 
10.   } 
11.   console.log(ary); 

6、正則的貪婪性：在每一次的捕獲的時候，總是按照正則匹配的最長結果捕獲
 

1. var str = "zhufeng2015peixun2016"; 
2.     var reg = //d+/g; 
3.     console.log(reg.myExecAll(str));//-->["2015","2016"] 
4.   var str = "zhufeng2015peixun2016"; 
5.   var reg = //d+?/g; 
6.   console.log(reg.myExecAll(str));//-->["2", "0", "1", "5", "2", "0", "1", "6"] 

7、分組引用

/2代表出現和第二個分組一模一樣的內容

/1代表出現和第一個分組一模一樣的內容
 

1. var reg=/^(/w)(/w)/2/1$/; 
2.   "woow"、"1221"... 

8、字符串方法---->replace：把一個字符串中的某個字符替換成新的內容

1)在不使用正則的情況下

執行一次replace只能替換字符串中的一個，需要替換多個同樣需要執行多次
 

1. var str = "zhufeng2015 zhufeng2016"; 
2.   "zhufeng" -> "珠峰" 
3.   str = str.replace("zhufeng", "珠峰").replace("zhufeng", "珠峰"); 

有些時候即使執行多次,也實現不了替換
 

1. "zhufeng" -> "zhufengpeixun" 
2. str = str.replace("zhufeng", "zhufengpeixun").replace("zhufeng", "zhufengpeixun"); 

   [第一個參數可以是一個正則] 把所有和正則匹配的內容進行替換(但是和捕獲一樣默認是懶惰的,只有加上全局修飾符g才可以)
 

1. var str = "zhufeng2015 zhufeng2016"; 
2. str = str.replace(/zhufeng/g, "zhufengpeixun"); 
3. console.log(str);<br> 

  1)執行和執行次數問題

    其實和exec捕獲的原理是一模一樣的

    例如：我們第二個參數如果傳遞的是一個函數,每當正則在字符串中捕獲一次當前的這個函數就執行一次 ->本題中一共捕獲了兩次,所以函數執行了兩次
 

1. var str = "zhufeng2015 zhufeng2016"; 
2. str = str.replace(/zhufeng/g, function () { 

     2)參數問題

      console.dir(arguments);
      不僅僅是執行function,而且還給我們的函數傳遞了參數,并且傳遞的參數和每一次exec捕獲的內容是一模一樣的
      如果是第一次exec捕獲->["zhufeng",index:0,input:"原始字符串"]
      第一次執行函數里面的參數
      arguments[0] -> "zhufeng"/**/
      arguments[1] -> 0  相當于exec中的index 開始捕獲的索引位置
      arguments[2] -> "原始字符串" 相當于exec中的input

3)返回值問題

      return返回的是什么,就相當于把當前捕獲的內容替換成什么
 

1. return "zhufengpeixun"; 
2. }); 
3. console.log(str);