好好學一遍JavaScript 筆記(六)

繼續正則表達式——量詞:

/** 
  * 量詞可以指定某個特定模式出現的次數。當指定某個模式應當出現 
  * 的次數時、可以指定硬性數量(例如、某個字符應該出現三次)、也 
  * 可以指定軟性數量(例如、這個字符至少應該出現一次、不過可以 
  * 重復任意次)。 
         代碼        描述 
         ?     出現零次或一次 
         *     出現零次或多次(任意次) 
         +     出現一次或多次(至少出現一次) 
         {n}   一定出現n次 
         {n,m}    至少出現n次但不超過m次 
         {n,}     至少出現n次 
          
     例如:想匹配bread,read,red這幾個單詞  
  */  
 var sIf = /b?rea?d/;         
 sIf = /b{0,1}rea{0,1}d/;     //另外一種方法   
   
 /** 
  *  
  * 例如匹配 bd,bad,baad,baaad 
  *  
  *             正則表達式           匹配 
                 ba?d            "bd","bad" 
                 ba*d            "bd","bad","baad","baaad" 
                 ba+d            "bad","baad","baaad" 
                 ba{0,1}d        "bd","bad" 
                 ba{0,}d         "bd","bad","baad","baaad" 
                 ba{1,}d         "bad","baad","baaad" 
  */  
    
 /** 
  * 匹配:bead、baed、beed、baad、bad  
  */  
 //var eaTest = /b[ea]{1,2}d/ ;   
 var sToMatch = "abbbaabbbaaabbb1234";  
 var re1 = /.*bbb/g;   //貪婪  
 var re2 = /.*?bbb/g;   //惰性  
 var re3=/.*+bbb/g;   //支配         
 alert("re1:"+re1.exec(sToMatch)+"    \n–re2:"+re2.exec(sToMatch));  
貪婪的、惰性的和支配性的量詞
貪婪量詞先看整個字符串是否匹配、如果沒有發現匹配、它就去掉
該字符串中的最後一個字符、並再次嘗試。如果還是沒有發現匹配
、那麼再次去掉最後一個字符、這個過程會一直重復直到發現一個
匹配或者字符串不剩任何字符。
惰性量詞首先看字符串中的第一個字符是否匹配、如果單獨這一個
字符還不夠、就讀入下一個字符、組成兩個字符的字符串。如果還
是沒有發現匹配、惰性量詞繼續從字符串中添加字符知道發現匹配
或者整個字符串都檢查過也沒有匹配。惰性量詞和貪婪量詞的工作
方式恰好相反。
支配量詞隻嘗試匹配整個字符串。如果整個字符串不能產生匹配、
不做進一步嘗試。支配詞其實簡單的說、就是一刀切。
怎樣表示貪婪、惰性和支配量詞呢?正是完全使用星號、加號和問號。
例如、單獨一個問號(?)是貪婪的、但是問號後面在跟一個問號(??)就
是惰性的。要使問號成為支配量詞、在後面加上一個加號(?+)。

貪婪               惰性            支配                 描述
 ?                    ??                ?+               零次或一次出現
 *                     *?                 *+               零次或多次出現
 +                    +?                ++              一次或多次出現
{n}                 {n}?              {n}+            恰好n次出現
{n,m}            {n,m}?          {n,m}+       至少n次至多m次出現
{n,}                {n,}?             {n,}+           至少n次出現
—————原文出自《javaScript高級程序設計》———————–
復雜模式——分組:

/** 
  * 分組、 
  * 假設想匹配字符串"dogdog"。使用目前獲得的知識 
  * 可能估計表達式應該類似: 
  */  
 var res = /dogdog/g;  
 alert(res.test("dogdog"));    
 
 //分組重寫:  
 var res = /(dog){2}/g;  
 alert(res.test("dogdog"));      
   
 //分組量詞使用  
 var re1 = /(dog)?/;  //出現零次或一次     
 var re2 = /(dog)*/;  //出現零次或多次(任意次)  
 var re3 = /(dog)+/;  //出現一次或多次(至少出現一次)  
   
 //同時也可以將分組放在中間  
 var res = /(mmm( and nnn)?)/;    
trim() 方法:

/** 
  * trim() 方法  
  * "\s" 匹配所有空格 . 
  * "." 小數點可以匹配除瞭換行符(\n)以外的任意一個字符. 
  * "^" 與字符串開始的地方匹配,不匹配任何字符. 
  * "{1}quot; 與字符串結束的地方匹配,不匹配任何字符. 
  * var reExt = /^\s*(.*?)\s+$/ ;    
  * 這個正則表達式將查找字符串開頭的零個或多個空白、 
  * 跟著是任意數目的字符(在分組中捕獲的字符)、 
  * 最後字符串結尾處又是零個或多個空白。 
  * 通過配合使用String對象的replace()方法以及反向引用、 
  * 就可以自定義自己的trim()方法: 
  */  
 String.prototype.trim = function(){    
      var reExt = /^\s*(.*?)\s+$/ ;   
      /* 
       * $1表示的就是左邊表達式中括號內的字符,即第一個子匹配,   
       * 同理可得$2表示第二個子匹配。什麼是子匹配呢?通俗點講, 
       * 就是左邊每一個括號是第一個字匹配,第二個括號是第二個子匹配。 
       */   
      return this.replace(reExt,"$1");                 
 };  
 alert("'"+"  fdsa  ".trim()+"'");   
反向引用:

/** 
  * 反向引用 
  * 每個分組都被存放在一個特殊的地方以備將來使用。 
  * 這些存儲在分組中的特殊值、我們稱之為反向引用。 
  * 首先、使用正則表達式對象的test()、match()、或search()方法後、 
  * 反向引用的值可以從RegExp構造函數中獲得    
  */   
 var reg = /#(\d+)/;     
 alert(reg.test("#123456789"));   
 /* 
  * 輸出的是(\d+)匹配的內容:123456789 
  * 如果有第二個分組()則$2依此類推  
  */  
 alert("'"+RegExp.$1+"'");      
 
 /** 
  * 反向引用示例:  
  */  
 var reg = /(\d{3})(\d{3})/;  
 /* 
  * $1等同於:456 
  * $2等同於:123 
  */  
 alert("456123".replace(reg,"$2$1"));   
候選:

/** 
  * 候選 
  * 一個表達式、即匹配"古道西風"又匹配"旦旦而學" 
  * "|"管道符:左右兩邊表達式之間 "或" 關系  
  */  
 var reg = /(古道西風|旦旦而學)/;    
 alert(reg.test("旦旦而s"));  
非捕獲性分組:

/** 
  * 非捕獲性分組 
  * 在較長的正則表達式中、存儲反向引用會降低匹配速度。 
  * 通過使用非捕獲性分組、仍然可以擁有與匹配字符串列同樣的能力、 
  * 而無需要存儲結果的開銷。 
  * 創建一個非捕獲性分組、隻要在左括號的後面加上一個問號和一個緊跟的冒號: 
  */  
 var reg = /#(?:\d+)/;        
 reg.test("#456123");    
 alert(RegExp.$1);  
去掉文本中所有HTML標簽:

String.prototype.stripHTML = function (){    
    var reTag = /<(?:.|\s)*?>/g;     
    return this.replace(reTag,"");    
};  
/* 
 * 如果非要在雙引號字符串使用雙引號則加上\轉義  
 */  
alert("<option value=\"1\">1</option>".stripHTML());   
前瞻:

/** 
  * 前瞻 
  * 它告訴正則表達式運算器向前看一些字符而不移動其位置。 
  * 同樣存在正向前瞻和負向前瞻。 
  * 正向前瞻檢查的是接下來出現的是不是某個特定字符集。 
  * 而負向前瞻則是檢查接下來的不應該出現的特定字符集。 
  * 創建正向前瞻要將模式放在(?=和)之間。 
  */  
 var testStr = "begRooms";  
 var testAry = "begTest";  
 var reg = /beg(?=Room)/;    //匹配後面跟著Room的beg        
 alert(reg.test(testStr));//true  
 alert(reg.test(testAry));//false  
   
 /* 
  * 負向前瞻 
  * 要創建它要將模式放在(?!和)之間。   
  */  
 var reg = /beg(?!Room)/;  //匹配後面不跟著Room的beg         
 alert(reg.test(testStr));  //false  
 alert(reg.test(testAry));  //true  
邊界:

/** 
  * 邊界 
  * \w: 匹配包括下劃線的任何單詞字符,等價於 [A-Z a-z 0-9_] 
  * \W: 匹配任何非單詞字符,等價於 [^A-Z a-z 0-9_] 
  * \b:單詞邊界 
  * \B:非單詞邊界  
  */  
 var sT = "my English is very shit.";   
 var reg = /(\w+)\.$/;   
 alert(reg.test(sT));  //true  
 alert(RegExp.$1);  //shit  
   
 var reg = /^(\w+)/;     
 alert(reg.test(sT));  //true    
 alert(RegExp.$1);  //my    
   
 var reg = /^(.+?)\b/;  
 reg.test(sT);  
 alert(RegExp.$1);  //my 

摘自 旦旦而學的專欄

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。