正则表达式

C#(常用的正则表达式) 


1.匹配HTML标记的正则表达式：<(.*)>.*<\/\1>|<(.*) \/>  例如：<title></title>


2. 正整数: ^[0-9]*[1-9][0-9]*$


3.负整数: ^-[0-9]*[1-9][0-9]*$


4.整数: -?\d+$


5.正浮点数: ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$


6.负浮点数: ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$


7.浮点数:^(-?\d+)(\.\d+)?$


8.26个英文字(不区分大小写): ^[A-Za-z]+$


9.26个大写英文字母: ^[A-Z]+$


10.26个小写英文字母:^[a-z]+$


11.数字和26个英文字母混合: ^[A-Za-z0-9]+$


12.数字和26个英文字母和下划线混合: ^\w+$


13.电子邮件地址: \w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*h


14.网址URL: ^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$


15.中国电话: ((d{3,4})|d{3,4}-)?d{7,8}(-d{3})*  例如：021-8888888 或者0515-88888888 或者 021-88888888-888


16.字母开头，允许5-16字节，允许字母数字下划线: ^[a-zA-Z][a-zA-Z0-9_]{6,20}$


17.QQ号: ^[1-9]*[1-9][0-9]*$


 18.IP地址: ^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$


19.首尾空格:(^\s*)|(\s*$)


20.空行：\n[\s| ]*\r


21.中国邮政编码：[1-9]\d{5}(?!\d)


22. 中国手机：(86)*0*13\d{9}


23.中国电话(包括手机)：(\(\d{3,4}\)|\d{3,4}-|\s)?\d{7,14}


24.数字：(-?\d*)(\.\d+)? 


25.双字节字符：[^\x00-\xff]*


26.过滤不安全的字符：^(([A-Z]*|[a-z]*|\d*|[-_\~!@#\$%\^&\*\.\(\)\[\]\{\}<>\?\\\/\'\"]*)|.{0,5})$|\s


27.日期：((((19){1}|(20){1})d{2})|d{2})[01]{1}d{1}[0-3]{1}d{1}   如:20060518


********************************************************************
常用的正则表达式[转] 




匹配中文字符的正则表达式： [u4e00-u9fa5]
匹配双字节字符(包括汉字在内)：[^x00-xff]
匹配空行的正则表达式：n[s| ]*r
匹配HTML标记的正则表达式：/<(.*)>.*|<(.*) />/
匹配首尾空格的正则表达式：(^s*)|(s*$)
匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
匹配网址URL的正则表达式：^[a-zA-z]+://(w+(-w+)*)(.(w+(-w+)*))*(?S*)?$
匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
匹配国内电话号码：(d{3}-|d{4}-)?(d{8}|d{7})?
匹配腾讯QQ号：^[1-9]*[1-9][0-9]*$


一个密码只能由字母，数字，_，-和组成，正则表达式怎么写？
^([a-z]|[A-Z]|[0-9]|(-)|(_))+$


如何用正则表达式只能让输入框只可以输入有汉字、数字、字母
======================================
@"\d|[a-zA-z]|[\u4e00-\u9fff]"
^(?:[\u4e00-\u9fa5]*\w*\s*)+$
@"\w|[\u4e00-\u9fff]"
只有中文^([\u4e00-\u9fa5]*)


只可以输入有双字节字符、数字、字母、空格、下划线
"^(?:([^x00-xff]*\w*\s?))+$"




"^\w+$"　　//由数字、26个英文字母或者下划线组成的字符串?
"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"　　　　//email地址?
"^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$"　　//url
/^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/???//??年-月-日
/^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/???//?月/日/年
"^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$"???//Emil
"(d+-)?(d{4}-?d{7}|d{3}-?d{8}|^d{7,8})(-d+)?"?????//电话号码
"^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$"???//IP地址




非法字符验证
匹配非法字符如:< > & / ' |?
正则表达式 [^<>&/|'\]+


日期验证
匹配形式如:20030718,030718
范围:1900--2099
正则表达式((((19){1}|(20){1})d{2})|d{2})[01]{1}d{1}[0-3]{1}d{1}




由26个英文字母组成的字符串
[^[A-Za-z]+$]　　


由26个英文字母的大写组成的字符串
[^[A-Z]+$]　　


由26个英文字母的小写组成的字符串
[^[a-z]+$]　　


由数字和26个英文字母组成的字符串
[^[A-Za-z0-9]+$]　　


由数字、26个英文字母或者下划线组成的字符串
[^\\w+$]　　


email地址
[^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+$]　　　　


url
[^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$]　　




匹配中文字符的正则表达式： [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内)：[^\x00-\xff]




中国电话号码验证
匹配形式如:0511-4405222 或者021-87888822 或者 021-44055520-555 或者 (0511)4405222
正则表达式 "((d{3,4})|d{3,4}-)?d{7,8}(-d{3})*"


中国邮政编码验证
匹配形式如:215421
正则表达式 "d{6}"


电子邮件验证
匹配形式如:justali@justdn.com
正则表达式 "w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*"


身份证验证
匹配形式如:15位或者18位身份证
正则表达式 "d{18}|d{15}"
 


***************************************************************
常用正则表达式 


"^\d+$" //非负整数（正整数 + 0） 
"^[0-9]*[1-9][0-9]*$" //正整数 
"^((-\d+)|(0+))$" //非正整数（负整数 + 0） 
"^-[0-9]*[1-9][0-9]*$" //负整数 
"^-?\d+$" //整数 
"^\d+(\.\d+)?$" //非负浮点数（正浮点数 + 0） 
"^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$" //正浮点数 
"^((-\d+(\.\d+)?)|(0+(\.0+)?))$" //非正浮点数（负浮点数 + 0） 
"^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$" //负浮点数 
"^(-?\d+)(\.\d+)?$" //浮点数 
"^[A-Za-z]+$" //由26个英文字母组成的字符串 
"^[A-Z]+$" //由26个英文字母的大写组成的字符串 
"^[a-z]+$" //由26个英文字母的小写组成的字符串 
"^[A-Za-z0-9]+$" //由数字和26个英文字母组成的字符串 
"^\w+$" //由数字、26个英文字母或者下划线组成的字符串 
"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$" //email地址 
"^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$" //url 
/^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/ // 年-月-日 
/^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/ // 月/日/年 
"^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$" //Emil 
"(d+-)?(d{4}-?d{7}|d{3}-?d{8}|^d{7,8})(-d+)?" //电话号码 
"^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$" //IP地址 


YYYY-MM-DD基本上把闰年和2月等的情况都考虑进去了 
^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))$


****************************************************************
正则表达式在输入框的应用：
只能输入数字
onKeypress="return (/\d/.test(String.fromCharCode(event.keyCode)))"


tempRowQtyPlan.Attributes.Add("onkeypress", @"return (/\d/.test(String.fromCharCode(event.keyCode)));");


--------------------------
只能输入数字或‘.’
tempRowQtyPlan.Attributes.Add("onkeypress", @"return (/\d|\./.test(String.fromCharCode(event.keyCode)));");


******************************************************************
C#正则表达式 
图片 src[^>]*[^/].(?:jpg|bmp|gif)(?:\"|\') 
中文 ^([\u4e00-\u9fa5]+|[a-zA-Z0-9]+)$ 
网址 "\<a.+?href=['""](?!http\:\/\/)(?!mailto\:)(?>foundAnchor>[^'"">]+?)[^>]*?\>" 


匹配中文字符的正则表达式： [\u4e00-\u9fa5] 


匹配双字节字符(包括汉字在内)：[^\x00-\xff] 


匹配空行的正则表达式：\n[\s| ]*\r 


匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/ 


匹配首尾空格的正则表达式：(^\s*)|(\s*$)（像vbscript那样的trim函数） 


匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)* 


匹配网址URL的正则表达式：http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)? 
--------------------------------------------------------------------------- 
以下是例子： 


利用正则表达式限制网页表单里的文本框输入内容： 


用正则表达式限制只能输入中文：οnkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))" 


1.用正则表达式限制只能输入全角字符： οnkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))" 


2.用正则表达式限制只能输入数字：οnkeyup="value=value.replace(/[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))" 


3.用正则表达式限制只能输入数字和英文：οnkeyup="value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))" 


4.计算字符串的长度（一个双字节字符长度计2，ASCII字符计1） 


String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;} 


5.javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下： 


String.prototype.trim = function() 
{ 
return this.replace(/(^\s*)|(\s*$)/g, ""); 
} 


利用正则表达式分解和转换IP地址： 


6.下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序： 


function IP2V(ip) 
{ 
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式 
if(re.test(ip)) 
{ 
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1 
} 
else 
{ 
throw new Error("不是一个正确的IP地址!") 
} 
} 


不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下： 


var ip="10.100.20.168" 
ip=ip.split(".") 
alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1)) 


(?<=>)[^>]*(?=<) 


*****************************************************************************
正则表达式基础知识




基本语法




★字符匹配语法：


 字符语法 语法解释 语法例子 


 \d 匹配数字（0~9） ‘\d’匹配8,不匹配12； 


 \D 匹配非数字 ‘\D’匹配c,不匹配3； 


 \w 匹配任意单字符 ‘\w\w’ 匹配A3,不匹配@3； 


 \W 匹配非单字符 ‘\W’匹配@,不匹配c； 


 \s 匹配空白字符 ‘\d\s\d’匹配3 d,不匹配abc； 


 \S 匹配非空字符 ‘\S\S\S’匹配A#4,不匹配3 d； 


 . 匹配任意字符 ‘....’匹配A$ 5,不匹配换行； 


 […] 匹配括号中任意字符 [b-d]匹配b、c、d, 不匹配e； 


 [^…] 匹配非括号字符 [^b-z]匹配a,不匹配b-z的字符； 




★重复匹配语法：


 重复语法 语法解释 语法例子 


 {n} 匹配n次字符 \d{3}匹配\d\d\d,不匹配\d\d或\d\d\d\d 


 {n,} 匹配n次和n次以上 \w{2}匹配\w\w和\w\w\w以上,不匹配\w 


 {n,m} 匹配n次上m次下 \s{1,3}匹配\s,\s\s,\s\s\s,不匹配\s\s\s\s 


 ? 匹配0或1次 5?匹配5或0，不匹配非5和0 


 + 匹配一次或多次 \S+匹配一个以上\S，不匹配非一个以上\S 


 * 匹配0次以上 \W*匹配0以上\W，不匹配非N*\W 




★字符定位语法：


 重复语法 语法解释 语法例子 


 ^ 定位后面模式开始位置   


 $ 前面模式位于字符串末端   


 \A 前面模式开始位置   


 \z 前面模式结束位置   


 \Z 前面模式结束位置(换行前)   


 \b 匹配一个单词边界   


 \B 匹配一个非单词边界   


 
★转义匹配语法：


 转义语法 涉及字符(语法解释) 语法例子 


 “\”+实际字符 \ . * + ? | ( ) { }^ $  例如：\\匹配字符“\” 


 \n 匹配换行   


 \r 匹配回车   


 \t 匹配水平制表符   


 \v 匹配垂直制表符   


 \f 匹配换页   


 \nnn 匹配一个8进制ASCII   


 \xnn 匹配一个16进制ASCII   


 \unnnn 匹配4个16进制的Uniode     


 \c+大写字母 匹配Ctrl-大写字母 例如：\cS-匹配Ctrl+S 




**********************************************************************************
解读C＃中的正则表达式
多少年来，许多的编程语言和工具都包含对正则表达式的支持，.NET基础类库中包含有一个名字空间和一系列可以充分发挥规则表达式威力的类，而且它们也都与未来的Perl 5中的规则表达式兼容。
  
  　　此外，regexp类还能够完成一些其他的功能，例如从右至左的结合模式和表达式的编辑等。
  
  　　在这篇文章中，我将简要地介绍System.Text.RegularExpression中的类和方法、一些字符串匹配和替换的例子以及组结构的详细情况，最后，还会介绍一些你可能会用到的常见的表达式。
  
  应该掌握的基础知识
  　　规则表达式的知识可能是不少编程人员“常学常忘”的知识之一。在这篇文章中，我们将假定你已经掌握了规则表达式的用法，尤其是Perl 5中表达式的用法。.NET的regexp类是Perl 5中表达式的一个超集，因此，从理论上说它将作为一个很好的起点。我们还假设你具有了C#的语法和.NET架构的基本知识。
  
  　　如果你没有规则表达式方面的知识，我建议你从Perl 5的语法着手开始学习。在规则表达式方面的权威书籍是由杰弗里·弗雷德尔编写的《掌握表达式》一书，对于希望深刻理解表达式的读者，我们强烈建议阅
读这本书。
  
  RegularExpression组合体
  　　regexp规则类包含在
System.Text.RegularExpressions.dll文件中，在对应用软件进行编译时你必须引用这个文件，例如，csc r:System.Text.RegularExpressions.dll foo.cs命令将创建foo.exe文件，它就引用了System.Text.RegularExpressions文件。
  
  名字空间简介
  　　在名字空间中仅仅包含着6个类和一个定义，它们是：
  
  　　Capture: 包含一次匹配的结果；
  
  　　CaptureCollection: Capture的序列；
  
  　　Group: 一次组记录的结果，由Capture继承而来；
  
  　　Match: 一次表达式的匹配结果，由Group继承而来；
  
  　　MatchCollection: Match的一个序列；
  
  　　MatchEvaluator: 执行替换操作时使用的代理；
  
  　　Regex：编译后的表达式的实例。
  
  　　Regex类中还包含一些静态的方法：
  
  　　Escape: 对字符串中的regex中的转义符进行转义；
  
  　　IsMatch: 如果表达式在字符串中匹配，该方法返回一个布尔值；
  
  　　Match: 返回Match的实例；
  
  　　Matches: 返回一系列的Match的方法；
  
  　　Replace: 用替换字符串替换匹配的表达式；
  
  　　Split: 返回一系列由表达式决定的字符串；
  
  　　Unescape:不对字符串中的转义字符转义。
  
  简单匹配
  　　我们首先从使用Regex、Match类的简单表达式开始学习。
  
  　　Match m = Regex.Match("abracadabra", "(a|b|r)+");
  
  　　我们现在有了一个可以用于测试的Match类的实例，例如：if (m.Success)...
  
  　　如果想使用匹配的字符串，可以把它转换成一个字符串：
  
  　　Console.WriteLine("Match="+m.ToString());
  
  　　这个例子可以得到如下的输出: Match=abra。这就是匹配的字符串了。
  
  字符串的替换
  　　简单字符串的替换非常直观。例如下面的语句：
  
  　　string s = Regex.Replace
("abracadabra", "abra", "zzzz");
  
  　　它返回字符串zzzzcadzzzz，所有匹配的字符串都被替换成了zzzzz。
  
  　　现在我们来看一个比较复杂的字符串替换的例子：
  
  　　string s = Regex.Replace(" abra ", @"^\s*(.*?)
\s*$", "$1");
  
  　　这个语句返回字符串abra，其前导和后缀的空格都去掉了。
  
  　　上面的模式对于删除任意字符串中的前导和后续空格都非常有用。在C#中，我们还经常使用字母字符串，在一个字母字符串中，编译程序不把字符“ \” 作为转义字符处理。在使用字符“\”指定转义字符时，
@"..."是非常有用的。另外值得一提的是$1在字符串替换方面的使用，它表明替换字符串只能包含被替换的字符串。
  
  匹配引擎的细节
  　　现在，我们通过一个组结构来理解一个稍微复杂的例子。看下面的
例子：
  
  　　string text 
= "abracadabra1abracadabra2abracadabra3";
  
  　　string pat = @"
  
  　　　　( # 第一个组的开始
  
  　　　　 abra # 匹配字符串abra
  
  　　　　 ( # 第二个组的开始
  
  　　　　 cad # 匹配字符串cad
  
  　　　　 )? # 第二个组结束（可选）
  
  　　　　) # 第一个组结束
  
  　　　　+ # 匹配一次或多次
  
  　　　　";
  
  　　//利用x修饰符忽略注释
  
  　　Regex r = new Regex(pat, "x");
  
  　　//获得组号码的清单
  
  　　int[] gnums = r.GetGroupNumbers();
  
  　　//首次匹配
  
  　　Match m = r.Match(text);
  
  　　while (m.Success)
  
  　　 {
  
  　　//从组1开始
  
  　　 for (int i = 1; i < gnums.Length; i++)
  
  　　　　{
  
  　　　　Group g = m.Group(gnums[i]);
  
  　　//获得这次匹配的组
  
  　　　　Console.WriteLine("Group"+gnums[i]+"=["+g.ToString()+"]");
  
  　　//计算这个组的起始位置和长度
  
  　　　　CaptureCollection cc = g.Captures;
  
  　　　　for (int j = 0; j < cc.Count; j++)
  
  　　　　 {
  
  　　　　 Capture c = cc[j];
  
  　　　　 Console.WriteLine(" Capture" + j + "=["+c.ToString()
  
  　　　　　　 + "] Index=" + c.Index + " Length=" + c.Length);
  
  　　　　 }
  
  　　　　}
  
  　　//下一个匹配
  
  　　 m = m.NextMatch();
  
  　　 }
  
  　　这个例子的输出如下所示：
  
  　　Group1=[abra]
  
  　　　　　　Capture0=[abracad] Index=0 Length=7
  
  　　　　　　Capture1=[abra] Index=7 Length=4
  
  　　Group2=[cad]
  
  　　　　　　Capture0=[cad] Index=4 Length=3
  
  　　Group1=[abra]
  
  　　　　　　Capture0=[abracad] Index=12 Length=7
  
  　　　　　　Capture1=[abra] Index=19 Length=4
  
  　　Group2=[cad]
  
  　　　　　　Capture0=[cad] Index=16 Length=3
  
  　　Group1=[abra]
  
  　　　　　　Capture0=[abracad] Index=24 Length=7
  
  　　　　　　Capture1=[abra] Index=31 Length=4
  
  　　Group2=[cad]
  
  　　　　　　Capture0=[cad] Index=28 Length=3
  
  　　我们首先从考查字符串pat开始，pat中包含有表达式。第一个capture是从第一个圆括号开始的，然后表达式将匹配到一个abra。第二个capture组从第二个圆括号开始，但第一个capture组还没有结束，这意味着第一个组匹配的结果是abracad ，而第二个组的匹配结果仅仅是cad。因此如果通过使用？符号而使cad成为一项可选的匹配，匹配的
结果就可能是abra或abracad。然后，第一个组就会结束，通过指定+符号要求表达式进行多次匹配。
  
  　　现在我们来看看匹配过程中发生的情况。首先，通过调用Regex的constructor方法建立表达式的一个实例，并在其中指定各种选项。在这个例子中，由于在表达式中有注释，因此选用了x选项，另外还使用了一些空格。打开x选项，表达式将会忽略注释和其中没有转义的空格。
  
  　　然后，取得表达式中定义的组的编号的清单。你当然可以显性地使用这些编号，在这里使用的是编程的方法。如果使用了命名的组，作为一种建立快速索引的途径这种方法也十分有效。
  
  　　接下来是完成第一次匹配。通过一个循环测试当前的匹配是否成功，接下来是从group 1开始重复对组清单执行这一操作。在这个例子中没有使用group 0的原因是group 0是一个完全匹配的字符串，如果要通过收集全部匹配的字符串作为一个单一的字符串，就会用到group 0了。
  
  　　我们跟踪每个group中的CaptureCollection。通常情况下每次匹配、每个group中只能有一个capture，但本例中的Group1则有两个capture：Capture0和Capture1。如果你仅需要Group1的
ToString，就会只得到abra，当然它也会与abracad匹配。组中ToString的值就是其CaptureCollection中最后一个Capture的值，这正是我们所需要的。如果你希望整个过程在匹配abra后结束，就应该从表达式中删除+符号，让regex引擎知道我们只需要对表达式进行匹配。
  
  基于过程和基于表达式方法的比较
  　　一般情况下，使用规则表达式的用户可以分为以下二大类：第一类用户尽量不使用规则表达式，而是使用过程来执行一些需要重复的操作；第二类用户则充分利用规则表达式处理引擎的功能和威力，而尽可能少地使用过程。
  
  　　对于我们大多数用户而言，最好的方案莫过于二者兼而用之了。我希望这篇文章能够说明.NET语言中regexp类的作用以及它在性能和复杂性之间的优、劣点。
  
  基于过程的模式
  　　我们在编程中经常需要用到的一个功能是对字符串中的一部分进行匹配或其他一些对字符串处理，下面是一个对字符串中的单词进行匹配的例子：
  
  　　string text = "the quick red fox jumped over the lazy brown dog.";
  
  　　System.Console.WriteLine("text=[" + text + "]");
  
  　　string result = "";
  
  　　string pattern = @"\w+|\W+";
  
  　　foreach (Match m in Regex.Matches(text, pattern))
  
  　　 {
  
  　　// 取得匹配的字符串
  
  　　 string x = m.ToString();
  
  　　// 如果第一个字符是小写
  
  　　 if (char.IsLower(x[0]))
  
  　　// 变成大写
  
  　　　　x = char.ToUpper(x[0]) + x.Substring(1, x.Length-1);
  
  　　// 收集所有的字符
  
  　　 result += x;
  
  　　 }
  
  　　System.Console.WriteLine("result=[" + result + "]");
  
  　　正象上面的例子所示，我们使用了C#语言中的foreach语句处理每个匹配的字符，并完成相应的处理，在这个例子中，新创建了一个result字符串。这个例子的输出所下所示：
  
  　　text=[the quick red fox jumped over the lazy brown dog.]
  
  　　result=[The Quick Red Fox Jumped Over The Lazy Brown Dog.]
  
  基于表达式的模式
  　　完成上例中的功能的另一条途径是通过一个MatchEvaluator，新的代码如下所示：
  
  　　static string CapText(Match m)
  
  　　　　{
  
  　　//取得匹配的字符串
  
  　　　　string x = m.ToString();
  
  　　// 如果第一个字符是小写
  
  　　　　if (char.IsLower(x[0]))
  
  　　// 转换为大写
  
  　　　　 return char.ToUpper(x[0]) + x.Substring(1, x.Length-1);
  
  　　　　return x;
  
  　　　　}
  
  　　　　
  
  　　 static void Main()
  
  　　　　{
  
  　　　　string text = "the quick red fox jumped over the
  
  　　　　 lazy brown dog.";
  
  　　　　System.Console.WriteLine("text=[" + text + "]");
  
  　　　　string pattern = @"\w+";
  
  　　　　string result = Regex.Replace(text, pattern,
  
  　　 new MatchEvaluator(Test.CapText));
  
  　　　　System.Console.WriteLine("result=[" + result + "]");
  
  　　　　}
  
  　　同时需要注意的是，由于仅仅需要对单词进行修改而无需对非单词进行修改，这个模式显得非常简单。
  
  常用表达式
  　　为了能够更好地理解如何在C#环境中使用规则表达式，我写出一些对你来说可能有用的规则表达式，这些表达式在其他的环境中都被使用过，希望能够对你有所帮助。
  
  罗马数字
  　　string p1 = "^m*(d?c{0,3}|c[dm])" + "(l?x{0,3}|x[lc])(v?i{0,3}|i[vx])$";
  
  　　string t1 = "vii";
  
  　　Match m1 = Regex.Match(t1, p1);
  
  交换前二个单词
  　　string t2 = "the quick brown fox";
  
  　　string p2 = @"(\S+)(\s+)(\S+)";
  
  　　Regex x2 = new Regex(p2);
  
  　　string r2 = x2.Replace(t2, "$3$2$1", 1);
  
  关健字=值
  　　string t3 = "myval = 3";
  
  　　string p3 = @"(\w+)\s*=\s*(.*)\s*$";
  
  　　Match m3 = Regex.Match(t3, p3);
  
  实现每行80个字符
  　　string t4 = "********************"
  
  　　 + "******************************"
  
  　　 + "******************************";
  
  　　string p4 = ".{80,}";
  
  　　Match m4 = Regex.Match(t4, p4);
  
  月/日/年 小时:分:秒的时间格式
  　　string t5 = "01/01/01 16:10:01";
  
  　　string p5 = @"(\d+)/(\d+)/(\d+) (\d+):(\d+):(\d+)";
  
  　　Match m5 = Regex.Match(t5, p5);
  
  改变目录（仅适用于Windows平台）
  string t6 = @"C:\Documents and Settings\user1\Desktop\";
  
  string r6 = Regex.Replace(t6,@"\\user1\\", @"\\user2\\");
  
  扩展16位转义符
  　　string t7 = "%41"; // capital A
  
  　　string p7 = "%([0-9A-Fa-f][0-9A-Fa-f])";
  
  　　string r7 = Regex.Replace(t7, p7, HexConvert);
  
  删除C语言中的注释（有待完善）
  　　string t8 = @"
  
  　　/*
  
  　　 * 传统风格的注释
  
  　　 */
  
  　　";
  
  　　string p8 = @"
  
  　　 /\* # 匹配注释开始的定界符
  
  　　 .*? # 匹配注释
  
  　　 \*/ # 匹配注释结束定界符
  
  　　";
  
  　　string r8 = Regex.Replace(t8, p8, "", "xs");
  
  删除字符串中开始和结束处的空格
  　　string t9a = " leading";
  
  　　string p9a = @"^\s+";
  
  　　string r9a = Regex.Replace(t9a, p9a, "");
  
  　　string t9b = "trailing ";
  
  　　string p9b = @"\s+$";
  
  　　string r9b = Regex.Replace(t9b, p9b, "");
  
  　　在字符\后添加字符n，使之成为真正的新行
  
  　　string t10 = @"\ntest\n";
  
  　　string r10 = Regex.Replace(t10, @"\\n", "\n");
  
  转换IP地址
  　　string t11 = "55.54.53.52";
  
  　　string p11 = "^" +
  
  　　 @"([01]?\d\d|2[0-4]\d|25[0-5])\." +
  
  　　 @"([01]?\d\d|2[0-4]\d|25[0-5])\." +
  
  　　 @"([01]?\d\d|2[0-4]\d|25[0-5])\." +
  
  　　 @"([01]?\d\d|2[0-4]\d|25[0-5])" +
  
  　　 "$";
  
  　　Match m11 = Regex.Match(t11, p11);
  
  删除文件名包含的路径
  　　string t12 = @"c:\file.txt";
  
  　　string p12 = @"^.*\\";
  
  　　string r12 = Regex.Replace(t12, p12, "");
  
  联接多行字符串中的行
  　　string t13 = @"this is
  
  　　a split line";
  
  　　string p13 = @"\s*\r?\n\s*";
  
  　　string r13 = Regex.Replace(t13, p13, " ");
  
  提取字符串中的所有数字
  　　string t14 = @"
  
  　　test 1
  
  　　test 2.3
  
  　　test 47
  
  　　";
  
  　　string p14 = @"(\d+\.?\d*|\.\d+)";
  
  　　MatchCollection mc14 = Regex.Matches(t14, p14);
  
  找出所有的大写字母
  　　string t15 = "This IS a Test OF ALL Caps";
  
  　　string p15 = @"(\b[^\Wa-z0-9_]+\b)";
  
  　　MatchCollection mc15 = Regex.Matches(t15, p15);
  
  找出小写的单词
  　　string t16 = "This is A Test of lowercase";
  
  　　string p16 = @"(\b[^\WA-Z0-9_]+\b)";
  
  　　MatchCollection mc16 = Regex.Matches(t16, p16);
  
  找出第一个字母为大写的单词
  　　string t17 = "This is A Test of Initial Caps";
  
  　　string p17 = @"(\b[^\Wa-z0-9_][^\WA-Z0-9_]*\b)";
  
  　　MatchCollection mc17 = Regex.Matches(t17, p17);
  
  找出简单的HTML语言中的链接
  　　string t18 = @"
  
  　　<html>
  
  　　<a href=""first.htm"">first tag text</a>
  
  　　<a href=""next.htm"">next tag text</a>
  
  　　</html>
  
  　　";
  
  　　string p18 = @"<A[^>]*?HREF\s*=\s*[""']?" + @"([^'"" >]+?)[ '""]?>";
  
  　　MatchCollection mc18 = Regex.Matches(t18, p18, "si");