谈谈C# replace在正则表达式中的意义

多少年来，许多的编程语言和工具都包含对正则表达式的支持，.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");

以上所述是小编给大家分享的c# replace在正则表达式中的意义，希望对大家有所帮助！