正则表达式笔记之二

1， 元字符：元字符是正则表达式语法的一部分，它们有：

       (   [  {   /   ^   $   |   )   ?   *   +   .

       任何时候要在正则表达式中使用这些元字符，都必须对它们进行转义

 

2， 特殊字符： 对于特殊字符，你可以通过使用字符来表示它们，也可以使用它们的ASCII代码或者Unicode代码来指定。要使用ASCII表示一个字符，则必须指定一个两位的十六进制代码，并在前面加上/x。例如，字符b的ASCII码为98，等于十六进制的62，因此，字符b可以使用/x62:

       var sColor = "blue";

       var regB = //x62/;

       alert(regB.test(sColor));            // output "true"

       如果要使用Unicode来表示字符，必须指定字符串的四位的十六进制表示形式。因此b应该是/u0062

       另外，还有其他一些预定义的特殊字符，如果通过RegExp构造函数来使用它们，都必须进行转义。字符如下：

        /t                            制表符

        /n                           换行符

        /r                            回车符

        /f                            换页符

        /a                           alert字符

        /e                           escape字符

        /cX                          与X相对应的控制字符

        /b                           回退字符

        /v                           垂直制表符

        /0                           空字符

 

3， 字符类： 字符类是用于测试的字符的组合。

      a, 简单类： 通过将一些字符放入方括中，可以很有效地告诉正则表达式去匹配第一个字符，第二个字符等等。

          例如，假设要匹配"bat","cat","fat"，使用简单类可以很方便的解决这个问题：

          var sToMatch = "a bat, a Cat, a fAt baT, a faT cat";

          var regBatCatFat = /[bcf]at/gi;

          var arrMatches = sToMatch.match(regBatCatFat);

          其中arrMatches中现在存放乐这些值："bat", "Cat", "fAt", "baT", "faT", "cat"。

          也可以在简单类（或者其他的字符类）中包含特殊字符，例如把b替换成它的Unicode形式：

          var regBatCatFat = /[/u0062cf]at/gi;

 

      b, 负向类： 有时可，除了特定的一些，你可能会想要匹配所有的字符。这种情况下，可以使用负向类，它可以指定要排除的字符。

          例如，要匹配除了a和b的所有字符，那么这个字符类就是[^ab]。脱字符号(^)告诉正则表达式字符不能匹配后面跟着的字符。

          回到前面的例子，如果只想获取包含at但不能以b或c开头的单词呢？

          var sToMatch = "a bat, a Cat, a fAt baT, a faT cat";

          var regBatCatFat = /[^bc]at/gi;

          var arrMatches = sToMatch.match(regBatCatFat);

          其中arrMatches中现在存放乐这些值："bat", "Cat", "fAt", "baT", "faT", "cat"。

          在这个例子中，arrMatches包含"fAt"和"faT"，因为这些字符串匹配了一个以at结尾但不以b或c开头的字符序列。

 

      c, 范围类：假设要匹配所有的字符表中的字符，但是又不想逐个输入，这是可以使用范围类指定从a到z之间的范围[a-z].

          这里关键的地方是那条横线(-)，它在这里应该看作是“从什么到什么”而不是减号。

          注意： [a-z]仅仅匹配了小写字符，除非正则表达式用i来指明是不区分大小写的。如果仅仅要匹配大写字母，使用[A-Z]

          var sToMatch = "num1, num2,num3,num4,num5,num6, num7, num8, num9"

          var regOneToFour = /num[1-4]/gi;

          var arrMatches = sToMatch.match(regOneToFour);

          在执行完后，arrMatches中包含"num1", "num2", "num3", "num4"，因为他们都匹配num后面跟着字符1~4.

          也可以使用负向范围类，这样可以排除给定范围内的所有字符。例如，要排除字符1~4，使用的类是[^1-4]

 

      d, 组合类： 组合类是由几种其他的类组合而成的字符类。

          例如要匹配所有从a~m的字母以及从1~4的数字，以及一个换行符，那么用到的类应该这样：[a-m1-4/n]

          注意在内部的类之间不要有空格

         

      e, 预定义类： 由于某些模式会反复用到，所以可以使用一组预定义类以让我们更方便地指定复杂类，如下：

           代码                         等同于                               匹配

           .                              [^/n/r]                             除了换行和回车之外的任意字符

           /d                            [0-9]                                数字

           /D                            [^0-9]                             非数字字符

           /s                            [/t/n/x0B/f/r]                    空白字符

           /S                            [^/t/n/x0B/f/r]                 非空白字符

           /w                           [a-zA-Z_0-9]                    单词字符（所有的字母、数字和下划线）

           /W                          [^a-zA-Z_0-9]                  非单词字符

           使用预定义字符可以明显地使模式匹配变得简单。例如，假设要匹配3个数字，如果不用/d的话，代码会类似这样：

           var sToMatch = "567 9838 abc";

           var regThreeNums = /[0-9][0-9][0-9]/;

           alert(regThreeNums.test(sToMatch));       // output "true"

           使用/d，正则表达式变得更加明了：

           var sToMatch = "567 9838 abc";

           var regThreeNums = //d/d/d/;

           alert(regThreeNums.test(sToMatch));       // output "true"

 

4，  量词： 量词可以制定某个特定模式出现的次数。当指定莫个模式应当出现的次数时，可以指定硬性数量（如莫个字符应该出现三次），也可以指定软性数量（如莫个字符至少出现一次，但可以出现任意多次）。

       a, 简单量词：下表列出乐指定特定模式数量的几种不同方法：

            代码                                   描述

            ?                                       出现零次或一次

            *                                       出现零次或多次（任意次）

            +                                       出现一次或多次（至少出现一次）

            {n}                                   一定出现n次

            {n,m}                               至少出现n次但不超过m次

            {n,}                                  至少出现n次

            例如，假设想匹配单词bread, read或red，使用问好量词，则可以只要使用一个表达式就可以匹配这三个：

            var regPattern = /b?rea?d/;

            次正则表达式等同于下面这个表达式：

            var regPattern = /b{0,1}rea{1,0}d/;

            它表示：b出现零次或一次，跟着r，跟着e，跟着出现零次或一次的a，跟着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和bed，可以使用下面的表达式:

            var regPattern = /b[ae]{1,2}d/;

            这个表达式表示：字符类[ae]可以出现最少一次，最多两次。

 

       b, 贪婪的，惰性的和支配性的量词。

           贪婪量词先看整个的字符串是否匹配。如果没有发现匹配，它就去掉该字符串中的最后一个字符，并再次尝试。如果还是没有发现匹配，

           那么再次去掉最后一个字符，这个过程会一直重复直到发现一个匹配或者字符串不剩任何字符。到目前为止讨论的所有量词都是贪婪的。

           惰性量词先看字符串中的第一个字母是否匹配。如果单独这一个字符还不够，就读入下一个字符，组成两个字符的字符串。如果还是没有

           发现匹配，惰性量词继续从字符串中添加字符直到发现匹配或者整个字符串都检查过也没有匹配。它与贪婪量词的工作方式恰好相反

           支配量词只尝试整个字符串。如果这个字符串不能产生匹配，不做进一步尝试。

           怎样表示贪婪、惰性和支配量词呢？正是完全使用星号、加号和问号。如，单独一个问号(?)是贪婪的，但一个问号后再跟一个问号(??)

           就是惰性的。要使问号成为支配量词，在后面加上一个加号(?+)。

           贪婪                     惰性                   支配                  描述

           ?                         ??                      ?+                    零次或一次出现

           *                         *?                      *+                   零次或多次出现

           +                         +?                      ++                  一次或多次出现

           {n}                     {n}?                  {n}+               恰好n次出现

           {n,m}                 {n,m}?              {n,m}+            至少n次至多m次出现

           {n,}                    {n,}?                 {n,}+              至少n次出现

           用下面这个例子说明：

           var sToMatch = "abbbaabbbaabbb1234";

           var reg1 = /.*bbb/g;           // 贪婪的， 返回"abbbaabbbaaabbb"

           var reg2 = /.*?bbb/g;         // 惰性的， 返回"abbb", "aabbb", "aaabbb"

           var reg3 = /.*+bbb/g;        // 支配的， 无返回

           注意： 浏览器对支配量词的支持还不完善。IE和Opera不支持支配量词，如果要用它就会抛出一个错误。Mozilla不会产生错误，但它会

                     将支配量词看作是贪婪的。