好好學一遍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）之外的任意一個字符.
         * "^" 與字符串開始的地方匹配，不匹配任何字符.
         * "$" 與字符串結束的地方匹配，不匹配任何字符.
         * 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