正则表达式笔记（一）

（1 ）量词讲解：

? 出现0次或1次

* 出现0次或n次

+ 出现1次或n次

1贪婪,惰性，支配性量词

a贪婪：先看整个字符串是否匹配，如果没有发现匹配，就去掉最后一个字符匹配，依次类推

b惰性：刚好和贪婪相反，先看第一个字符是否匹配，如不匹配，紧接着下个字母一起是否匹配，依次类推

c支配量词：只尝试匹配整个字符串。

如何区分：例如：单独一个？是贪婪的，问号后面再跟着一个问号（？？）是惰性的，支配量词为：在？后面加上一个加号（？+）

贪婪                  惰性                  支配                                描述方式

？                      ？？                   ？+                                 表示 出现0次或1次

*                         *？                      *+                                 表示  出现0次或n次

+                        +？                      ++                                表示 出现1次或n次

{n}                    {n} ？                  {n} +                              表示出现n次

/** * 贪婪方法： * 一下子打算匹配整个字符串，如果发现不匹配，就去掉最后一个字符，进行匹配，以此类推。 * 一旦匹配成功之后，并不是马上返回，而是跳跃到下一个字符的起点，再次开始贪婪的匹配 */public void greedy(){ String str="1abbbaabbbaaabbb1234abbbc";         Pattern p2 = Pattern.compile("[^1]*bbb");        Matcher m2 =p2.matcher(str);        while(m2.find()){            System.out.println(m2.group());        }       // 先找到满足条件的第一个字符，所以1会被过滤掉，然后进行全局匹配        //abbbaabbbaaabbb1234abbbc  不匹配        //abbbaabbbaaabbb1234abbb   不匹配        //abbbaabbbaaabbb1234abb    不匹配        //......        ///abbbaabbbaaabbb          匹配       // 之后表达式会继续寻找这个字符串后面的匹配的第一个字符，所以后面的1会被过滤掉，然后再进行全局匹配，即：       // 234abbbc   不匹配       //  234abbb    匹配        // 所以会得到两个匹配结果  abbbaabbbaaabbb和234abbb}

/** * 懒惰方法:从第一个字符开始进行匹配，如果不匹配，那么就在读入一个字符， * 进行整体匹配，以此类推 */public void reluctant(){ String str="1abbbaabbbaaabbb1234abbbc";         Pattern p2 = Pattern.compile("[^1]*?bbb");        Matcher m2 =p2.matcher(str);        while(m2.find()){            System.out.println(m2.group());        }        //先找到满足条件的第一个字符，所以1还是被过滤，从a开始，匹配过程如下//a    不匹配//ab   不匹配//abb  不匹配//abbb 匹配        //  继续从下一个位置开始读入第一个匹配字符       // a    不匹配        //aa   不匹配       // 不匹配       // aabbb匹配       // 一直进行到最后，所以得到的结果为abbb,aabbb,aaabbb,234abbb}

（2 ）分组：使用()

（3 ）反向引用：每个分组都被放在一个特殊的地方以备将来使用。这些存储在分组中的特殊值，称之为反向引用

表达式:   (A?(B?(c?)))可产生 1~3个反向引用  。跟()有关

(1)    (A?(B?(c?)))

(2)    (B?(c?)

(3)    (c?)
例如：所有的反向引用都保存在RegExp函数中。

<script type="text/javascript">        var str1="#123456789";       var reNumbers=/#(\d+)/;       alert(reNumbers.test(str1));       alert(RegExp.$1);//返回括号内 \d+匹配的字符串： 123456789</script>

还可以直接在定义分组表达式中使用包含反向引用。可以通过转义符号

<script type="text/javascript">  var str2="dogdog"; var redog=/(dog)\1/; alert(redog.test(str2));//\1的含义代表引用dog词组，相当于/dogdog/ alert(RegExp.$1);//dog</script>

反向引用在replace中的应用.

通过$1,$2来实现。

例如： trim()函数的实现

<script type="text/javascript"> String.prototype.trim=function(){ var reg=/^\s+(.*?)\s+$/; return this.replace(reg,"$1"); } var t=" sdsdsd sdsdsd "; alert("{"+t.trim()+"}");//去掉了前后空格，只保留了中间的内容,使用了$1.很强</script>

例2：使用反向引用逆转字符串

<script type="text/javascript"> var str3="1234 5678"; var reMatch=/(\d{4}) (\d{4})/; var sNews=str3.replace(reMatch,"$2 $1"); alert(sNews);// 5678 1234 将分组的值逆转</script>

（4 ）候选：使用管道符（|），表示或者

例如：

<script type="text/javascript">  var str4="this is a string using badword1 and badword2"; var reMatch4=/badword|anotherbadword/ig;  var result=str4.replace(reMatch4,"**");   alert(result); //返回 this is a string using **1 and **2</script>

（5）非捕获性分组

创建反向引用的分组称为捕获性分组，存储反向引用会降低匹配速度，通过非捕获性分组，可以拥有匹配字符串序列的能力，无须存储结果的开销

规则：在左括号后面加上一个问号和紧跟这个一个冒号

 <script type="text/javascript">  var str1="#123456789";  var reNumbers=/#(?:\d+)/; alert(reNumbers.test(str1));//true  alert(RegExp.$1);//返回括号内 \d+匹配的字符串： ""</script>

比捕获性分组多增加?:,但返回的结果仍然是true,只是未将分组的值存储在RegExp 中

例2

 <script type="text/javascript"> var str3="1234 5678"; var reMatch=/(?:\d{4}) (\d{4})/; var sNews=str3.replace(reMatch,"$2 $1"); alert(sNews);// $2 5678 </script>

加了？：的为非捕获性分组，没有存储分组的内容，所以会直接显示$2字符串， 而$1则直接匹配 5678.

例3

<script type="text/javascript"> //创建自己去的html标签中的内容 String.prototype.scriptHtml=function(){   var reg=/<(?:.|\s)*?>/ig;    return this.replace(reg,"");  } var sTest="<br>232323 233swew23 232</br>"; alert(sTest.scriptHtml());//232323 233swew23 232</script>

去掉首尾标签，得到标签间的内容

（6 ）前瞻

有时候，希望某个特殊字符分组出现在另一个字符串之前。才去捕获它。

分为正向前瞻和负向前瞻。正向前瞻检查的是接下了出现的是不是某个特定的字符集，而负向前瞻检查接下来不应该出现的字符集

正向前瞻要将模式放在（？=和）之间，这不是分组，分组不会考虑前瞻的存在（不管正向还是负向）。 表示XX后面紧跟着XX

<script type="text/javascript"> var sToMatch1="bedroom"; var sToMatch2="bedyard";var regstr=/(bed(?=room))/;// 表示bed后面紧跟这roomalert(regstr.test(sToMatch1));//true alert(RegExp.$1); //bed alert(RegExp.$2); //"" 说明第二个括号使用了？=不是分组，没有将值存储起来alert(regstr.test(sToMatch2));//false</script>

负向前瞻要将模式放在（？！和）之间，表示XX后面不能紧跟着XX

例如：

<script type="text/javascript"> var sToMatch1="bedroom"; var sToMatch2="bedyard"; var regstr=/(bed(?!room))/;// 表示bed后面不能紧跟这roomalert(regstr.test(sToMatch1));//false alert(regstr.test(sToMatch2));//true alert(RegExp.$1); //bed alert(RegExp.$2); //"" 说明第二个括号使用了？=不是分组，没有将值存储起来</script>

注意没有后瞻

（7）边界

^表示行开头，$表示行结尾 \b单词的结尾， \B表示非单词的边界

例如：

<script type="text/javascript"> var ss="the important is a improve";         //var regstr=/^(\w+)/;//以字母开头。匹配了the        var regstr=/^(.+?)\b/; //使用惰性模式从左边开始匹配，必须是单词       alert(regstr.test(ss));//true       alert(RegExp.$1);//the </script>

（8）多行模式

<script type="text/javascript"> var ss="the important is a improve\n asdsds abc\n wewe 2we"; var regstr=/(\w+)$/g;//匹配以非空白符结尾的  alert(ss.match(regstr));//返回的结果是2we</script>

由于字符串包含\n换行符，如果需要将improve 和abc 2we都返回出来呢？

多行模式在只需要加一个m选项

<script type="text/javascript"> var ss="the important is a improve\n asdsds abc\n wewe 2we"; var regstr=/(\w+)$/mg;//匹配以非空白符结尾的 alert(ss.match(regstr));//返回improve,abc,2we</script>