收藏.net正則表達式 用法
来源：互联网 发布：python的helloworld 编辑：程序博客网 时间：2024/06/03 16:35
.NET 框架正则表达式并入了其他正则表达式实现的最常见功能，被设计为与 Perl 5 正则表达式兼容，.NET 框架正则表达式还包括一些在其他实现中尚未提供的功能，.NET 框架正则表达式类是基类库的一部分，并且可以和面向公共语言运行库的任何语言或工具一起使用。
2、字符串搜索
正则表达式语言由两种基本字符类型组成：原义（正常）文本字符和元字符。正是元字符组为正则表达式提供了处理能力。当前，所有的文本编辑器都有一些搜索功能，通常可以打开一个对话框，在其中的一个文本框中键入要定位的字符串，如果还要同时进行替换操作，可以键入一个替换字符串，比如在Windows操作系统中的记事本、Office系列中的文档编辑器都有这种功能。这种搜索最简单的方式，这类问题很容易用String类的String.Replace()方法来解决，但如果需要在文档中识别某个重复的，该怎么办？编写一个例程，从一个String类中选择重复的字是比较复杂的，此时使用语言就很适合。
一般表达式语言是一种可以编写搜索表达式的语言。在该语言中，可以把文档中要搜索的文本、转义序列和特定含义的其他字符组合在一起，例如序列/b表示一个字的开头和结尾（子的边界），如果要表示正在查找的以字符th开头的字，就可以编写一般表达式/bth（即序列字符界是-t-h）。如果要搜索所有以th结尾的字，就可以编写th/b（序列t-h-字边界）。但是，一般表达式要比这复杂得多，例如，可以在搜索操作中找到存储部分文本的工具性程序（facility）。
3、.NET 框架的正则表达式类
下面通过介绍 .NET 框架的正则表达式类，熟悉一下.NET框架下的正则表达式的使用方法。
3.1 Regex 类表示只读正则表达式
Regex 类包含各种静态方法，允许在不显式实例化其他类的对象的情况下使用其他正则表达式类。以下代码示例创建了 Regex 类的实例并在初始化对象时定义一个简单的正则表达式。请注意，使用了附加的反斜杠作为转义字符，它将 /s 匹配字符类中的反斜杠指定为原义字符。
Regex r; // 声明一个 Regex类的变量
r = new Regex("//s2000"); // 定义表达式
3.2 Match 类表示正则表达式匹配操作的结果
以下示例使用 Regex 类的 Match 方法返回 Match 类型的对象，以便找到输入字符串中第一个匹配。此示例使用 Match 类的 Match.Success 属性来指示是否已找到匹配。
Regex r = new Regex("abc"); // 定义一个Regex对象实例
Match m = r.Match("123abc456"); // 在字符串中匹配
if (m.Success)
{
Console.WriteLine("Found match at position " + m.Index); //输入匹配字符的位置
}
3.3 MatchCollection 类表示非重叠匹配的序列
该集合为只读的，并且没有公共构造函数。MatchCollection 的实例是由 Regex.Matches 属性返回的。使用 Regex 类的 Matches 方法，通过在输入字符串中找到的所有匹配填充 MatchCollection。下面代码示例演示了如何将集合复制到一个字符串数组（保留每一匹配）和一个整数数组（指示每一匹配的位置）中。
MatchCollection mc;
String[] results = new String[20];
int[] matchposition = new int[20];
Regex r = new Regex("abc"); //定义一个Regex对象实例
mc = r.Matches("123abc4abcd");
for (int i = 0; i < mc.Count; i++) //在输入字符串中找到所有匹配
{
results[i] = mc[i].Value; //将匹配的字符串添在字符串数组中
matchposition[i] = mc[i].Index; //记录匹配字符的位置
}
3.4 GroupCollection 类表示捕获的组的集合
该集合为只读的，并且没有公共构造函数。GroupCollection 的实例在 Match.Groups 属性返回的集合中返回。下面的控制台应用程序查找并输出由正则表达式捕获的组的数目。
using System;
using System.Text.RegularExpressions;
public class RegexTest
{
public static void RunTest()
{
Regex r = new Regex("(a(b))c"); //定义组
Match m = r.Match("abdabc");
Console.WriteLine("Number of groups found = " + m.Groups.Count);
}
public static void Main()
{
RunTest();
}
}
该示例产生下面的输出：
Number of groups found = 3
3.5 CaptureCollection 类表示捕获的子字符串的序列
由于限定符，捕获组可以在单个匹配中捕获多个字符串。Captures属性（CaptureCollection 类的对象）是作为 Match 和 group 类的成员提供的，以便于对捕获的子字符串的集合的访问。例如，如果使用正则表达式 ((a(b))c)+（其中 + 限定符指定一个或多个匹配）从字符串"abcabcabc"中捕获匹配，则子字符串的每一匹配的 Group 的 CaptureCollection 将包含三个成员。
下面的程序使用正则表达式 (Abc)+来查找字符串"XYZAbcAbcAbcXYZAbcAb"中的一个或多个匹配，阐释了使用 Captures 属性来返回多组捕获的子字符串。
using System;
using System.Text.RegularExpressions;
public class RegexTest
{
public static void RunTest()
{
int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;
Regex r = new Regex("(Abc)+"); //查找"Abc"
m = r.Match("XYZAbcAbcAbcXYZAbcAb"); //设定要查找的字符串
gc = m.Groups;
//输出查找组的数目
Console.WriteLine("Captured groups = " + gc.Count.ToString());
// Loop through each group.
for (int i=0; i < gc.Count; i++) //查找每一个组
{
cc = gc[i].Captures;
counter = cc.Count;
Console.WriteLine("Captures count = " + counter.ToString());
for (int ii = 0; ii < counter; ii++)
{
// Print capture and position.
Console.WriteLine(cc[ii] + " Starts at character " +
cc[ii].Index); //输入捕获位置
}
}
}
public static void Main() {
RunTest();
}
}
此例返回下面的输出结果：
Captured groups = 2
Captures count = 1
AbcAbcAbc Starts at character 3
Captures count = 3
Abc Starts at character 3
Abc Starts at character 6
Abc Starts at character 9
3.6 Capture 类包含来自单个子表达式捕获的结果
在 Group 集合中循环，从 Group 的每一成员中提取 Capture 集合，并且将变量 posn 和 length 分别分配给找到每一字符串的初始字符串中的字符位置，以及每一字符串的长度。
Regex r;
Match m;
CaptureCollection cc;
int posn, length;
r = new Regex("(abc)*");
m = r.Match("bcabcabc");
for (int i=0; m.Groups[i].Value != ""; i++)
{
cc = m.Groups[i].Captures;
for (int j = 0; j < cc.Count; j++)
{
posn = cc[j].Index; //捕获对象位置
length = cc[j].Length; //捕获对象长度
}
}
把组合字符组合起来后，每次都会返回一个组对象，就可能并不是我们希望的结果。如果希望把组合字符作为搜索模式的一部分，就会有相当大的系统开销。对于单个的组，可以用以字符序列"?:"开头的组禁止这么做，就像URI样例那样。而对于所有的组，可以在RegEx.Matches()方法上指定RegExOptions.ExplicitCapture标志。
4、利用正则表达式实现字符串搜索
4.1 在C#中使用.net一般表达式引擎
下面将通过一个样例的开发，执行并显示一些搜索的结果，说明一般表达式的一些特性，以及如何在C#中使用.NET一般表达式引擎。说明使用字符串时应在前面加上符号@。
String Text=@"I can not find my position in Beijing";
把这个文本称为输入字符串，为了说明一般表达式.NET类，本文先进行一次纯文本的搜索，这次搜索不带任何转义序列或一般表达式命令。假定要查找所有字符串ion，把这个搜索字符串称为模式。使用一般表达式和上面声明的变量Text，编写出下面的代码：
String Pattern = "ion";
MatchCollection Matches = Regex.Matches(Text,Pattern,RegexOptions);
foreach(Match NextMatch in Matches)
{ Console.WriteLine(NextMatch.Index); }
在这段代码中，使用了System.Text.RegularExpressions名称空间中Regex类的静态方法Match()。这个方法的参数是一些输入文本、一个模式和RegexOptions每句中的一组可选标志。Matches()返回MatchCollection，每个匹配都用一个Match对象来表示。在上面的代码中，只是在集合中迭代，使用Match类的Index属性，返回输入文本中匹配所在的索引。运行这段代码，将得到1个匹配项。
一般集合的功能主要取决于模式字符串。原因是模式字符串不仅仅包含纯文本。如前所述。还包含元字符和转义序列，元字符是给出命令的特殊字符，而转义序列的工作方式与C#的转义序列相同，它们都是以反斜杠/开头的字符，具有特殊的含义。例如，假定要查找以n开头的字，就可以使用转义序列/b，它表示一个字的边界（字的边界是以某个字母数字标的字符开头，或者后面是一个空白字符或标点符号），下面编写如下代码：
String Pattern = @"/bn";
MatchCollection Matches = Regex.Matches(Text,Pattern,RegexOptions.IgnoreCase|
RegexOptions.ExplicitCapture);
要在运行时把/b传递给.NET一般表达式引擎，反斜杠/不应被C#编译器解释为转义序列。如果要查找以序列ion结尾的字，可以使用下面的代码：
String Pattern = @"ion/b";
如果要查找以字母n开头，以序列ion结尾的所有字，需要一个以/bn开头，以ion/b结尾的模式，中间内容怎么办？需要告诉计算机n和ion中间的内容可以是任意长度的字符，只要字符不是空白即可，正确的模式如下所示：
String Pattern = @"/bn/S*ion/b";
4.2 特定字符或转义序列
大多数重要的正则表达式语言运算符都是非转义的单个字符。转义符 /（单个反斜杠）通知正则表达式分析器反斜杠后面的字符不是运算符。例如，分析器将星号 (*) 视为重复限定符，而将后跟星号的反斜杠 (/*) 视为 Unicode 字符 002A。
使用一般表达式要习惯的一点是，查看像这样怪异的字符序列，但这个序列的工作是非常逻辑化的。转义序列/S表示任何不适空白的字符。*称为数量词，其含义是前面的字符可以重复任意次，包括0次。序列/S*表示任何不适空白的字符。因此，上面的模式匹配于以n开头，以ion结尾的任何单个字。下表中列出的字符转义在正则表达式和替换模式中都会被识别。
表1：特定字符或转义序列
特定字符或转义序列 含义 样例 匹配的样例 ^ 输入文本的开头 ^B B，但只能是文本中的第一个字符 $ 输入文本的结尾 X$ X，但只能是文本中的最后一个字符 . 除了换行字符（/n）以外的所有单个字符 i.ation isation、ization * 可以重复0次或多次的前导字符 ra*t rat、raat等 + 可以重复1次或多次的前导字符 ra+t rt、rat、raat等 ？ 可以重复0次或1次的前导字符 ra?t 只有rt和rat匹配 /s 任何空白字符 /sa [space]a,/ta,/na（/t和/n与C#的/t和/n含义相同） /S 任何不是空白的字符 /SF aF,rF,cF，但不能是/tf /b 字边界 ion/b 以ion结尾的任何字 /B 不是字边界的位置 /BX/B 字中间的任何X
如果要搜索一个元字符，也可以通过带有反斜杠的转义字符来表示。例如，.表示除了换行字符以外的任何字符，而/.表示一个点。
可以把可替换的字符放在方括号中，请求匹配包含这些字符。例如，[1|c]表示字符可以是1或者是c。如果要搜索map或者man，可以使用序列"ma[n|p]"（仅指引号内字符，下面雷同）。在方括号中，也可以制定一个范围，例如"[a-z]"表示所有的小写字母（使用连字号 (-) 允许指定连续字符范围），"[B-F]"表示B到F之间的所有大写字母，"[0-9]"表示一个数字，如果要搜索一个整数（该序列只包含0到9的字符），就可以编写"[0-9]+"（注意，使用+字符表示至少要有这样一个数字，但可以有多个数字，所以9、83和3443等都是匹配的。）
下面看看一般表达式的结果，编写一个实例RegularExpressionsZzy。建立几个一般表达式，显示其结果，让用户了解一下表达式是如何工作的。
该实例的核心是一个方法WriteMatches()，它把MatchCollection中的所有匹配以比较详细的方式显示出来。对于每个匹配，它都会显示该匹配在输入字符串中所在的索引，匹配的字符串和一个略长的字符串，其中包含输入文本中至多8个外围字符，其中至少有5个字符放在匹配的前面，至多5个字符放在匹配的后面（如果匹配的位置在输入文本的开头或结尾5个字符内，则结果中匹配前后的字符就会少于4个）。换言之，靠近输入文本末尾的匹配应是"and messaging ofd"，匹配的前后各有5个字符，但位于输入文本的最后一个字上的匹配就应是"g of data"，匹配的字后只有一个字符。因为在该字符的后面是字符串的结尾。这个长字符串可以更清楚地表明一般表达式是在什么地方查找到匹配的：
static void WriteMatches(string text, MatchCollection matches)
{
Console.WriteLine("Original text was: /n/n" + text + "/n");
Console.WriteLine("No. of matches: " + matches.Count);
foreach (Match nextMatch in matches)
{
int Index = nextMatch.Index;
string result = nextMatch.ToString();
int charsBefore = (Index < 5) ? Index : 5;
int fromEnd = text.Length - Index - result.Length;
int charsAfter = (fromEnd < 5) ? fromEnd : 5;
int charsToDisplay = charsBefore + charsAfter + result.Length;
Console.WriteLine("Index: {0}, /tString: {1}, /t{2}",Index, result,
text.Substring(Index - charsBefore, charsToDisplay));
}
}
在这个方法中，处理过程是确定在较长的字符串中有多少个字符可以显示，而无需超限输入文本的开头或结尾。注意在Match对象上使用了另一个属性Value，它包含标识该匹配的字符串，而且，RegularExpressionsZzy只包含名为Find_po，Find_n等的方法，这些方法根据本文执行某些搜索操作。
4.3 正则表达式选项
可以使用影响匹配行为的选项修改正则表达式模式。可以通过两种基本方法设置正则表达式选项：其一是可以在 Regex(pattern, options) 构造函数中的 options 参数中指定，其中 options 是 RegexOptions 枚举值的按位"或"组合；其二是使用内联 (?imnsx-imnsx:) 分组构造或 (?imnsx-imnsx) 其他构造在正则表达式模式内设置它们。
在内联选项构造中，一个选项或一组选项前面的减号 (-) 用于关闭这些选项。例如，内联构造 (?ix-ms) 将打开 IgnoreCase 和 IgnorePatternWhiteSpace 选项而关闭 Multiline 和 Singleline 选项。
表2：RegexOptions 枚举的成员以及等效的内联选项字符
RegexOption 成员 内联字符 说明 None 无 指定不设置任何选项。 IgnoreCase i 指定不区分大小写的匹配。 Multiline m 指定多行模式。更改 ^ 和 $ 的含义，以使它们分别与任何行的开头和结尾匹配，而不只是与整个字符串的开头和结尾匹配。 ExplicitCapture n 指定唯一有效的捕获是显式命名或编号的 (?<name>...) 形式的组。这允许圆括号充当非捕获组，从而避免了由 (?:...) 导致的语法上的笨拙。 Compiled 无 指定正则表达式将被编译为程序集。生成该正则表达式的 Microsoft 中间语言 (MSIL) 代码；以较长的启动时间为代价，得到更快的执行速度。 Singleline s 指定单行模式。更改句点字符 (.) 的含义，以使它与每个字符（而不是除 /n 外的所有字符）匹配。 IgnorePatternWhitespace x 指定从模式中排除非转义空白并启用数字符号 (#) 后面的注释。请注意，空白永远不会从字符类中消除。 RightToLeft 无 指定搜索是从右向左而不是从左向右进行的。具有此选项的正则表达式将移动到起始位置的左边而不是右边。（因此，起始位置应指定为字符串的结尾而不是开头。）为了避免构造具有无限循环的正则表达式的可能性，此选项不能在中流指定。但是，(?<) 回顾后发构造提供了可用作子表达式的类似替代物。 ECMAScript 无 指定已为表达式启用了符合 ECMAScript 的行为。此选项仅可与 IgnoreCase 和 Multiline 标志一起使用。将 ECMAScript 同任何其他标志一起使用将导致异常。
例如，Find_po在字开头处查找以"po"开头的字符串：
static void Find_po()
{
string text = @" I can not find my position in Beijing ";
string pattern = @"/bpo/S*ion/b";
MatchCollection matches = Regex.Matches(text, pattern, RegexOptions.IgnoreCase
| RegexOptions.IgnorePatternWhitespace | RegexOptions.ExplicitCapture);
WriteMatches(text, matches);
}
这段代码还使用了名称空间RegularExpressions：
using System;
using System.Text.RegularExpressions;
4.4 匹配、组和捕获
一般表达式的一个很好的特性是可以把字符组合起来，方式与C#中的复合语句一样。在C#中，可以通过把任意数量的语句放在花括号中的方式把它们组合在一起。其结果就像一个复合语句那样。在一般表达式模式中，也可以把任何字符组合起来（包括元字符和转义序列），像处理一个字符那样处理它们。唯一的区别是要使用圆括号，而不是花括号，得到的序列成为一个组。
例如，模式"(an)+"定位序列an的任以重复。量词+只应用于它前面的一个字符，但因为我们把字符组合起来了，所以它现在把重复的an作为一个单元来对待。"(an)."应用到输入文本"bananas came to Europe late in the annals of history"上，会从bananas中选择出anan。另一方面，如果使用an+，则将从annals中选择ann，从bananas中选择出两个an。为什么(an)+选择的是anan，而没有把单个的an作为一个匹配。匹配规则是不能重复的，如果有可能重复，在默认情况下就选择较长的匹配。
但是，组的功能要比这强大得多。在默认情况下，把模式的一部分组合为一个组时，就要求一般表达式引擎记住可以按照这个组来匹配，也可以按照整个模式来匹配。换言之，可以把组当作一个要匹配的模式，如果要把字符串分解为各个部分，这种模式就是非常有效的。
例如，URI的格式是"<protocol>://<address>:<port>"，其中端口是可选的。它的一个样例是http://www.comprg.com.cn:8080。假定要从一个URI中提取协议、地址和端口，而且紧邻URI的后面可能有空白（但没有标点符号），就可以使用下面的表达式："/b(/S+)://(/S+)(?::(/S+))?/b"
该表达式的工作方式如下：首先，前导和尾部的/b序列确保只需要考虑完全是字的文本部分，在这个文本部分中，第一组"(/S+)://"会选择一个或多个不适空白的字符，其后是"://"。在HTTPURI的开头会选择出http://。花括号表示把http存储为一个组。后面的"(/S+)"则在上述URI中选择www. comprg.com.cn，这个组在遇到词的结尾时或标记另一个组的冒号"(:)"时结束。
下一个组选择端口（本例是:8080）。后面的？表示这个组在匹配中是可选的，如果没有:xxxx，也不会妨碍匹配的标记。
这是非常重要的，因为端口在URI中一般不指定，实际上，在大多数情况下，URI是没有端口号的。但是，事情会比较复杂。如果要求冒号可以出现，也可以不出现，但不希望把这个冒号也存储在组中。为此，可以嵌套两个组：内部的"(/S+)"组选择冒号后面的内容（本例中是8080），外面的组包含内部的组，后面是一个冒号，该冒号又在序列"?:"的后面。这个序列表示该组不应保存（只需要保存"8080"，不需要保存":8080"）。不要把这两个冒号混淆了，第一个冒号是序列"?:"的一部分，表示不保存这个组，第二个冒号是要搜索的文本。
在这个字符串上运行该模式：I always visit http://www. comprg.com.cn 得到的匹配是http://www. comprg.com.cn。在这个匹配中，仅提到了三个组，还有第四个组表示匹配本身。理论上，每个组都可以选择0次、1次或者多次匹配。单个的匹配就称为捕获。在第一个组"(/S+)"，有一个捕获http。第二个组也有一个捕获www. comprg.com.cn，但第三个组没有捕获，因为在这个URI中没有端口号。注意该字符串在其本身上包含第二个http://。虽然它匹配于第一个组，但不会被搜索出来，因为整个搜索表达式不匹配于这部分文本。
再比如下面这个例子，以下代码示例使用 Match.Result 来从 URL提取协议和端口号。例如，"http://www.yahoo.com.cn:8080/index.html"将返回"http:8080"。
String Extension(String url)
{
Regex r = new Regex(@"^(?<proto>/w+)://[^/]+?(?<port>:/d+)?/",
RegexOptions.Compiled);
return r.Match(url).Result("${proto}${port}");
}
5、小结
.NET 框架正则表达式类是基类库的一部分，并且可以和面向公共语言运行库的任何语言或工具（包括 ASP.NET 和 Visual Studio .NET）一起使用。本文给出了在C#下利用正则表达式实现字符串搜索功能的方法，通过对.NET框架下的正则表达式的研究及实例分析，总结了正则表达式的规则、选项等，方便以后朋友们的应用。
规则表达式的知识可能是不少编程人员“常学常忘”的知识之一。在这篇文章中，我们将假定你已经掌握了规则表达式的用法，尤其是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的序列；
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中的CaptureCollection。通常情况下每次匹配、每个group中只能有一个capture，但本例中的Group1则有两个capture：Capture0和Capture1。如果你仅需要Group1的ToString，就会只得到abra，当然它也会与abracad匹配。组中ToString的值就是其CaptureCollection中最后一个Capture的值，这正是我们所需要的。如果你希望整个过程在匹配abra后结束，就应该从表达式中删除+符号，让regex引擎知道我们只需要对表达式进行匹配。
基于过程和基于表达式方法的比较
一般情况下，使用规则表达式的用户可以分为以下二大类：第一类用户尽量不使用规则表达式，而是使用过程来执行一些需要重复的操作；第二类用户则充分利用规则表达式处理引擎的功能和威力，而尽可能少地使用过程。
对于我们大多数用户而言，最好的方案莫过于二者兼而用之了。我希望这篇文章能够说明.net
我们在编程中经常需要用到的一个功能是对字符串中的一部分进行匹配或其他一些对字符串处理，下面是一个对字符串中的单词进行匹配的例子：
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语言中的链接
"^/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
- 收藏.net正則表達式 用法
- CListCtrl用法(收藏)
- DataGrid用法集锦[收藏]
- DataGrid用法集锦[收藏]
- DataGrid用法集锦[收藏]
- CListCtrl用法(收藏)
- DataGrid用法集锦[收藏]
- DataGrid用法集锦[收藏]
- DataGrid用法集锦[收藏]
- DataGrid用法集锦[收藏]
- eval的用法收藏
- CListCtrl 用法总结收藏
- priority_queue用法小结 收藏
- CComPtr用法(收藏)
- String.Format用法 收藏
- jspSmartUpload的用法收藏
- setsockopt函数用法收藏
- define用法归类收藏
- 使用 GUID 值来作为数据库行标识(转载)
- PIM 几个点
- VSS使用指南
- Java的class文件转为EXE文件的八种方法
- New Vectored Exception Handling in Windows XP
- 收藏.net正則表達式 用法
- hibernate产生自动增长的主键
- 通过JDBC连接Oracle的十大灵活技术
- 谈局域网用户的限制技术以及反限制技巧
- 突破局域网中对用户上网的限制
- API Hook的实现
- 新一代Java核心技术即将出现
- 将CMD.exe输入 输出 通过管道发送出去
- MySQL 一种比较经济的数据库
