正则表达式笔记（一）

（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后面紧跟这room
alert(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后面不能紧跟这room
alert(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>