js正则表达式小节

字符类是用于测试的字符的组合，通过将一些字符放入方括号中，可以很有效的告诉正则表达式去匹配第一个字符、第二个字符、第三个字符等等。

1、简单类，比如，想匹配“bat"，"cat", "fat"

<script type="text/javascript">
var x;
var sToMatch = "a bat, a bcat, a Fat baT, a faT cat";
var reBatCatRat = /[bcf]at/gi;
var arrMatches = sToMatch.match(reBatCatRat);
document.write(sToMatch+"</br>");
for(x in arrMatches){
document.write(arrMatches[x] + "</br/>");
}
</script>

<script type="text/javascript">
var x;
var sToMatch = "a bat, a bcat, a Fat baT, a faT cat";
var reBatCatRat = /[bcf]at/gi;
var arrMatches = sToMatch.match(reBatCatRat);
document.write(sToMatch+"</br>");
for(x in arrMatches){
document.write(arrMatches[x] + "</br/>");
}
</script>

2、负向类，除了特定的字符，可能会想匹配所有的字符，负向类可以指定要排除的字符，脱字符号（^）告诉正则表达式字符不能匹配后面跟着的字符，例如，只想获取包含at但不能以b或c开头的单

<script type="text/javascript">
var x;
var sToMatch = "a bat, a cat, a Fat haT, a faT cat";
var reBatCatRat = /[^bc]at/gi;
var arrMatches = sToMatch.match(reBatCatRat);
document.write(sToMatch+"</br>");
for(x in arrMatches){
document.write(arrMatches[x] + "</br/>");
}
</script>

<script type="text/javascript">
var x;
var sToMatch = "a bat, a cat, a Fat haT, a faT cat";
var reBatCatRat = /[^bc]at/gi;
var arrMatches = sToMatch.match(reBatCatRat);
document.write(sToMatch+"</br>");
for(x in arrMatches){
document.write(arrMatches[x] + "</br/>");
}
</script>

3、范围类，假设要匹配所有的字母表中的字符，但又不想逐个输入，可以使用范围类。指定从a到z的范围[a-z]，”-"是从什么到什么的意思，这里仅仅匹配小写字母

<script type="text/javascript">
var x;
var sToMatch = "num1, num2, num3, num4, num5, num6, num7";
var reOneToFour = /num[1-4]/gi;
var arrMatches = sToMatch.match(reOneToFour);
document.write(sToMatch+"</br>");
for(x in arrMatches){
document.write(arrMatches[x] + "</br/>");
}
</script>

<script type="text/javascript">
var x;
var sToMatch = "num1, num2, num3, num4, num5, num6, num7";
var reOneToFour = /num[1-4]/gi;
var arrMatches = sToMatch.match(reOneToFour);
document.write(sToMatch+"</br>");
for(x in arrMatches){
document.write(arrMatches[x] + "</br/>");
}
</script>

4、组合类,是由几种其他的类组合而成的字符类。例如要匹配所有从a~m的字母，以及从1~4的数字，以及一个换行符，那么要用到的类应该是这样的[a-m1-4\m]，注意内部类之间不要有空格，

javascript不支持某些其他正则表达式实现中的联合类和交叉类。这意味着不能有类似[a-m[p-z]]或者[a-m[^b-e]]之类的模式出现

5、预定义类，

代码	等同于	匹配
.	[^\n\r]	除了换行和回车以外的任意字符
\d	[0-9]	数字
\D	[^0-9]	非数字字符
\s	[ \t\n\x0B\f\r]	空白字符
\S	[^ \t\r\n\x0B\f]	非空白字符
\w	[a-zA-Z_0-9]	单词字符（所有的字母、所有的数字、下划线）
\W	[^a-zA-Z_0-9]	非单词字符

例如，想匹配三格数字：

<script type="text/javascript">
var x;
var sToMatch = "567 9838 abc";
var reThreeNums = /[0-9][0-9][0-9]/;
var arrMatches = sToMatch.match(reThreeNums);
//alert(arrMatches.length);
for(x in arrMatches){
document.write(arrMatches[x] + "</br/>");
}
</script>

<script type="text/javascript">
var x;
var sToMatch = "567 9838 abc";
var reThreeNums = /[0-9][0-9][0-9]/;
var arrMatches = sToMatch.match(reThreeNums);
//alert(arrMatches.length);
for(x in arrMatches){
document.write(arrMatches[x] + "</br/>");
}
</script>

量词：可以指定某个特定模式出现的次数。

1、简单量词

代码	描述
?	零次或一次出现
*	零次或多次出现
+	一次或多次出现
{n}	恰好n次出现
{n, m}	至少n次出现，最后m次出现
{n, }	至少n次出现

2、贪婪的，惰性的和支配性的量词

贪婪量词：先看整个字符串是否匹配成功，如果没有发现匹配，它去掉该字符串中的最后一个字符，并再次尝试。如果还是没有发现匹配，那么再次去掉最后一个字符，这个过程会一直重复知道发现一个匹配或者字符串不剩任何字符。目前讨论的所有量词都是贪婪量词。

惰性量词：先看字符串中的第一个字符是否匹配，如果单独这一个字符不够，就读入下一个字符，组成两个字符的字符串。如果还是没有发现匹配，惰性量词就继续从字符串中添加字符直到发现匹配或者整个字符串都检查过也没有匹配。

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

贪婪	惰性	支配	描述
?	??	?+	零次或一次出现
*	*?	*+	零次或多次出现
+	+?	++	一次或多次出现
{n}	{n}?	{n}+	恰好n次出现
{n, m}	{n, m}?	{n, m}+	至少n次出现，最后m次出现
{n, }	{n, }?	{n, }+	至少n次出现

复杂模式：

复杂模式不仅仅由字符类和量词组成，也可以由分组、反向引用、前瞻和其他一些强大的正则表达式功能组成。

1、分组，是通过一系列括号包围一系列字符、字符类以及量词来使用的。例如：

var re1 = /(dog)?/ 匹配“dog”的零次或一次出现

var re2 = /(dog)*/ 匹配“dog”的零次或多次出现

var re3 = /(dog)+/ 匹配“dog”的一次或多次出现

var re = /([bd]ad?)*/ 匹配下列字符的零次或多次出现：ba, bad, da, dad

2、反向引用，在表达式计算完之后，每个分组都被存放在一个特殊的地方以备将来使用。这些存储在分组中的特殊值，称之为反向引用。

反向引用是按照从左到右遇到的左括号字符的顺序进行创建和编号的。其可以有以下几种不同的用于：

（1）使用正则表达式对象的test(), match()和search()方法后，反向引用的值可以从RegExp构造函数中获得

<script type="text/javascript">
var sToMatch = "#1242455";
var reNumbers = /#(\d+)/;
reNumbers.test(sToMatch);
alert(RegExp.$1);
</script>

<script type="text/javascript">
var sToMatch = "#1242455";
var reNumbers = /#(\d+)/;
reNumbers.test(sToMatch);
alert(RegExp.$1);
</script>

（2）直接在定义分组的表达式中包含反向引用。这可以通过使用特殊转义字符序列如\1，\2等实现。

<script type="text/javascript">
var sToMatch = "dogdog";
var reDog = /(dog)\1/;
alert(reDog.test(sToMatch));
</script>

<script type="text/javascript">
var sToMatch = "dogdog";
var reDog = /(dog)\1/;
alert(reDog.test(sToMatch));
</script>

正则表达式reDog首先创建单词dog的组，然后又被特殊转义字符\1引用，使得这个正则表达式等同于/dogdog/

（3）可以用在String对象的replace()方法中，通过使用特殊字符序列$1, $2等来实现。例如，想将字符串“1234 5678”变为“5678 1234”，可以通过下面的代码：

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

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

3、候选

候选操作符和ECMAScript的二进制异或一样，是一个管道符（|），它放在两个单独的模式之间。

<script type="text/javascript">
var sToMatch1 = "red";
var sToMatch2 = "blue";
var reRedOrBlue = /(red|blue)/;
alert(reRedOrBlue.test(sToMatch1));
alert(reRedOrBlue.test(sToMatch2));
</script>

<script type="text/javascript">
var sToMatch1 = "red";
var sToMatch2 = "blue";
var reRedOrBlue = /(red|blue)/;
alert(reRedOrBlue.test(sToMatch1));
alert(reRedOrBlue.test(sToMatch2));
</script>

4、非捕获性分组

创建反向引用的分组，称之为捕获性分组。同时还有非捕获性分组，它不会创建反向引用。在较长的正则表达式中，存储反向引用会降低匹配速度。通过使用非捕获性分组，仍然可以拥有与匹配字符串序列同样的能力，而无需存储结果的开销。

如果要创建一个非捕获性分组，只要在左括号的后面加上一个问号和一个紧跟的冒号：

<script type="text/javascript">
var sToMatch = "#123456";
var reNumbers = /#(?:\d+)/;
reNumbers.test(sToMatch);
alert("here");
alert(RegExp.$1);
alert(sToMatch.replace(reNumbers, "abcd$1"));
</script>

<script type="text/javascript">
var sToMatch = "#123456";
var reNumbers = /#(?:\d+)/;
reNumbers.test(sToMatch);
alert("here");
alert(RegExp.$1);
alert(sToMatch.replace(reNumbers, "abcd$1"));
</script>

5、前瞻

告诉正则表达式运算器向前看一些字符而不移动其位置。同样存在正向前瞻和负向前瞻。正向前瞻检查的是接下来出现的是不是某个特定的字符集。而负向前瞻则是检查接下来的不应该出现的特定字符集。

创建正向前瞻要将模式放在(?=和）之间。注意这不是分组，虽然也用到括号。

<script type="text/javascript">
var sToMatch1 = "bedroom";
var sToMatch2 = "bedding";
var reBed = /(bed(?=room))/;
alert(reBed.test(sToMatch1));
alert(RegExp.$1);
alert(reBed.test(sToMatch2));
</script>

<script type="text/javascript">
var sToMatch1 = "bedroom";
var sToMatch2 = "bedding";
var reBed = /(bed(?=room))/;
alert(reBed.test(sToMatch1));
alert(RegExp.$1);
alert(reBed.test(sToMatch2));
</script>

创建负向前瞻要将模式放在(?!和）之间。

<script type="text/javascript">
var sToMatch1 = "bedroom";
var sToMatch2 = "bedding";
var reBed = /(bed(?!room))/;
alert(reBed.test(sToMatch1));
alert(RegExp.$1);
alert(reBed.test(sToMatch2));
</script>

<script type="text/javascript">
var sToMatch1 = "bedroom";
var sToMatch2 = "bedding";
var reBed = /(bed(?!room))/;
alert(reBed.test(sToMatch1));
alert(RegExp.$1);
alert(reBed.test(sToMatch2));
</script>

javascript支持前瞻，但是不支持后瞻

6、边界

用于正则表达式中表示模式的位置。

边界	描述
^	行开头
$	行结尾
\b	单词的边界
\B	非单词的边界

<!--边界
查找一个单词，但要出现在行尾-->
<script type="text/javascript">
 var sToMatch = "Important word is the last one.";
 var reLastWord = /(\w+).$/;
 reLastWord.test(sToMatch);
 alert(RegExp.$1);
</script>

<!--边界
查找一个单词，但要出现在行尾-->
<script type="text/javascript">
	var sToMatch = "Important word is the last one.";
	var reLastWord = /(\w+).$/;
	reLastWord.test(sToMatch);
	alert(RegExp.$1);
</script>

7、多行模式，在正则表达式后面添加一个m选项。比较下面的输出：

<script type="text/javascript">
 var x;
 var sToMatch = 
"First second\n third fourth\n fifth sixth";
 var reLastWord = /(\w+)$/g;
 var arrWords = sToMatch.match(reLastWord);
 for(x in arrWords){
 document.write(arrWords[x] + "</br>");
 }
 var reLastWord = /(\w+)$/gm;
 var arrWords = sToMatch.match(reLastWord);
 for(x in arrWords){
 document.write(arrWords[x] + "</br>");
 }
</script>

<script type="text/javascript">
	var x;
	var sToMatch = "First second\n third fourth\n fifth sixth";
	var reLastWord = /(\w+)$/g;
	var arrWords = sToMatch.match(reLastWord);
	for(x in arrWords){
		document.write(arrWords[x] + "</br>");
	}
	var reLastWord = /(\w+)$/gm;
	var arrWords = sToMatch.match(reLastWord);
	for(x in arrWords){
		document.write(arrWords[x] + "</br>");
	}
</script>