Javascript(十五) RegExp 一

JavaScript对正则表达式的支持是通过ECMAScript中的RegExp类来实现的。

re = new RegExp("pattern",["flags"])

re 必选项。
    将要赋值为正则表达式模式的变量名。
Pattern 必选项。
    要使用的正则表达式模式。如果使用语法 1，用 "/" 字符分隔模式。如果用语法 2，用引号将模式引起来。 
flags 可选项。
    如果使用语法 2 要用引号将 flag 引起来。标志可以组合使用，可用的有： g （全文查找出现的所有 pattern） i （忽略大小写） m （多行查找）

正则表达式的元字符： ( [ { \ ^ $ | ) ? * + . 
      任何时候要使用他们都需要使用转义符 \。 例如匹配 ? 需要使用 var reQMark =/\?/;
      字面量 如果要使用 RegExp 就得 var reQMark = new RegExp("\\?"); 这个叫双重转义，
      当所有的表达式使用 非字面量来表示的时候，所有的反斜杠都必须用两个反斜杠来表示。 可以直接似乎用字符来表示他们，也可以使用它们的ASCII码或unicode来表示 .
      用ASCII码表示必须指定一个两位的 16进制代码，在前面加上\x 字符b 的ascii码为98 等于16进制的62 var regB=/\x62/; 
      若使用Unicode来表示，必须制定一个4位的16进制来表示 \u0062 --字符b

其他转义字符 
    \t         制表符 
    \n         换行符 
    \r         回车符 
    \f         换页符 
    \a        alert字符 
    \e        escape字符 
    \cX      与Z相对应的控制字符 
    \b        回退字符 
    \v        垂直制表符 
    \0        空字符 
    如果通过RegExp来构造它们都必须使用双重转义。 

预定义类
                代码            等同于                 匹配
                -------------------------------------------------------------------------------
                .                 [^\n\r]                除了换行和回车之外的任意字符
                \d               [\d]                    数字
                \D               [^\d]                  非数字字符
                \s               [\t\n\x0B\f\r]        空白字符
                \S               [^\t\n\x0B\f\r]     非空白字符
                \w              [a-zA-Z_0-9]        单词字符(所有字符，所有数字和下划线)
                \W              [^a-zA-Z_0-9]     非单词字符
                \b                                        匹配单词的边界也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
                \B                                        匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
                -------------------------------------------------------------------------------        
        

量词
                代码            描述
                ----------------------------------------
                ?                出现0次或1次
                *                出现0次或多次(任意次)
                +                出现1次或多次
                {n}             出现n次
                {n,m}          至少出现n次，不大于m次
                {n,}            至少出现n次
                ----------------------------------------

如果想匹配bread read red

var reg=/b?rea?d/; 

如果匹配 bead baed,beed,baad,bad,bed

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

贪婪的、惰性的和支配性的量词 
      贪婪量词首先看整个字符串是否匹配，如果发现没有匹配，它去掉该字符串中的最后一个字符并再尝试。这个过程 一直重复知道发现一个匹配的字符或者字符串不剩字符，目前所有的量词都是贪婪的。 惰性量词首先看字符串的第一个字母是否匹配，如果单独这一个字符串还不够，就读入下一个字符，整个过程直到 找到匹配或者整个字符串都不匹配。惰性量词和贪婪量词的工作方式正好相反。 支配性量词只尝试匹配整个字符串，如果整个字符串不匹配，不做进一步尝试。

 

                    怎样表示贪婪，惰性和支配量词，是完全使用星号，加号和问号。
                    贪婪        惰性        支配        描述
                    -----------------------------------------------
                    ?            ??            ?+            匹配0个或1个
                    *            *?           *+            匹配0个或任意个
                    +            +?           ++            匹配1个或任意个
                    {n}         {n}?        {n}+         匹配n个
                    {n,m}      {n,m}?     {n,m}+     匹配至少n个，不超过m个
                    {n,}        {n,}?       {n,}+        匹配至少n个
                    ---------------------------------------------------

                    var sToMatch="abbbaabbbaaabbb1234"
                    var re1=/.*bbb/g;
                    var re2=/.?bbb/g;
                    var re3=/.+bbb/g;
                    
                    想要匹配跟着bbb的任意字符，最后，想要获得匹配的结果是"abbb","aabbb","aaabbb"
                    只有re2可以得到正确的结果。
                    第一个re1是贪婪的，首先他是匹配整个字符串，下面是整个匹配的过程
                    re1.test("abbbaabbbaaabbb1234");// no-match
                    re1.test("abbbaabbbaaabbb123");    // no-match
                    re1.test("abbbaabbbaaabbb12");    // no-match
                    re1.test("abbbaabbbaaabbb1");        // no-match
                    re1.test("abbbaabbbaaabbb");        // match
                    所以re1返回是唯一的结果是 abbbaabbbaaabbb
                    
                    对于re2 匹配过程如下
                    re2.test("a");            //no-match
                    re2.test("ab");            //no -match
                    re2.test("abb");        //no -match
                    re2.test("abbb");        //match
                    //store this result and start with next latter
                    
                    re2.test("a");            //no-match
                    re2.test("aa");            //no-match
                    re2.rest("aab");        //no-match
                    re2.test("aabb");        //no-match
                    re2.test("aabbb");        //match
                    //store this result and start with next latter
                    
                    re2.test("a");            //no-match
                    re2.test("aa");            //no-match
                    re2.test("aaa");        //no-match
                    re2.test("aaaab");        //no-match
                    re2.test("aaaabb");        //no-match
                    re2.test("aaaabbb");    //match
                    //store this result and start with next latter
                    
                    re2.test("1");            //no-match
                    re2.test("12");            //no-match
                    re2.test("123");        //no-match
                    re2.test("1234");        //no-match
                    //done
                    
                    re3其实没有返回结果，如果这次测试失败，就得不到结果 
                    re3.test("abbbaabbbaaabbb1234")    //no-match
                    
                    如果换成abbbaabbbaaabbb 那么 re1和re3返回同样的结果
                    
                    游览器对支配量词的支持还很不完善，IE 和 Opera不支持支配量词，如果要使用它，就会抛出一个错误。
                    Mozilla不会产生错误，但是它会将支配量词看成是贪婪的。