C#编程（四十六）----------正则表达式

正则表达式

1.定义一个Regex类的实例

Regex regex=new Regex(“”);

这里初始化参数就是一个正则表达式,”\d”表示配置数字

2.判断是否匹配

判断一个字符串,是否匹配一个正则表达式,在Regex对象中,可以使用Regex.IsMatch(string )方法.

Regex regex = new Regex(@"\d");

bool b1=regex.IsMatch("abc"); //返回值为false，字符串中未包含数字

bool b2 = regex.IsMatch("abc3abc"); //返回值为true，因为字符串中包含了数字

3.获取匹配次数

使用Regex.Matches(string)方法得到一个Matched集合,再使用这个集合的Count属性.

int count=regex.Matches(“abc123abc”).Count;

count的值为3,因为匹配了三次数字

4.获取匹配内容

使用regex.Match(string)方法进行匹配

Regex regex = new Regex(@"\d");

string str=regex.Match("abc123abc").Value;

Console.WriteLine(str);

返回值为1,表示第一个匹配到的值

5.捕获

正则表达式中可以使用括号对部分值进行捕获,想要获取捕获的值,可以使用Regex.Match(string).Groups[int].Value来获取.

Regex regex = new Regex(@"\w2(\d*)"); //匹配两个字母间的数字串

string str=regex.Match("abc123abc").Groups[0].Value; //返回值为“123”

Console.WriteLine(str);

一.C#正则表达式符号模式

说明:由于在正则表达式中“ \ ”、“ ? ”、“ * ”、“ ^ ”、“ $ ”、“ + ”、“（”、“）”、“ | ”、“ { ”、“ [ ”等字符已经具有一定特殊意义,如果需要用他们的原始意义,则应该对它进行转义,例如希望在字符串中至少有一个”\”,那么正则表达式应该这么说:\\+.

一.在C#中,要使用正则表达式,请在源文件开头处添加以下语句:

using System.Text.RegularExpressions

二.Regex类常用的方法

1.静态的Match方法

使用静态Match方,可以得到源中第一个匹配模式的连续子串.

静态的Match方法有两个重载,分别是:

Regex.Match(string input,string pattren);

Regex.Match(string input,string pattren ,RegexOptions options);

第一种重载的参数表示:输入,模式

第二种重载的参数表示:输入,模式,RegexOptions枚举的”按位或”组合.

RegexOptions枚举的有效值是：

Complied表示编译此模式

CultureInvariant表示不考虑文化背景

ECMAScript表示符合ECMAScript，这个值只能和IgnoreCase、Multiline、Complied连用

ExplicitCapture表示只保存显式命名的组

IgnoreCase表示不区分输入的大小写

IgnorePatternWhitespace表示去掉模式中的非转义空白，并启用由#标记的注释

Multiline表示多行模式，改变元字符^和$的含义，它们可以匹配行的开头和结尾

None表示无设置，此枚举项没有意义

RightToLeft表示从右向左扫描、匹配，这时，静态的Match方法返回从右向左的第一个匹配

Singleline表示单行模式，改变元字符.的意义，它可以匹配换行符

注意：Multiline在没有ECMAScript的情况下，可以和Singleline连用。Singleline和Multiline不互斥，但是和ECMAScript互斥

2.静态的Matches方法

这个方法的重载形式同静态的Match方法,返回一个MatchCollection,表示输入中,匹配模式的匹配的集合.

3.静态的IsMatch()方法

此方法返回一个bool,重载形式同静态的Matches,若输入中匹配模式,返回true,否则返回false.可以理解为:IsMatch方法,返回Matches方法返回的集合是否为空.

四.Regex类的实例

1.字符串替换

例如我想把如下格式记录中的NAME值修改为WANG

string line="ADDR=1234;NAME=ZHANG;PHONE=123456";

Regex reg=new Regex("NAME=(.+);");

string modified=reg.Replace(line,"NAME=WANG;");

Console.WriteLine(modified);

分析:修改后的字符串为ADDR=1234;NAME=WANG;PHONE=123456

2.字符串匹配

例如我想提取刚才那条记录中的NAME值.

string line="ADDR=1234;NAME=ZHANG;PHONE=123456";

Regex reg=new Regex("NAME=(.+);");

Match match = reg.Match(line);

string value = match.Groups[1].Value;

Console.WriteLine(value);

3.Match实例:文本中含有"speed=30.2mph",需要提取该速度值，但是速度的单位可能是公制也可能是英制，mph,km/h,m/s都有可能；另外前后可能有空格。

string line = "lane=1;speed=30.3mph;acceleration=2.5mph/s";

Regex reg = new Regex(@"speed\s*=\s*([\d\.]+)\s*(mph|km/h|m/s)*");

Match match = reg.Match(line);

string value = match.Groups[1].Value;//数值

Console.WriteLine(value);

Console.WriteLine(match.Groups[2].Value);//单位

4.案例:解码gps的GPRMC字符串

Regex reg = new Regex(@"^\$GPRMC,[\d\.]*,[A|V],(-?[0-9]*\.?[0-9]+),([NS]*),(-?[0-9]*\.?[0-9]+),([EW]*),.*");

分析:以前需要几十行代码的工作,现在一行就完成了.

五.System.Text.RegularExpressions命名空间的说明

该命名空间包括8个类,1个枚举,1以委托.他们分别是:

Capture: 包含一次匹配的结果；
CaptureCollection: Capture的序列；
Group: 一次组记录的结果，由Capture继承而来；
GroupCollection：表示捕获组的集合
Match: 一次表达式的匹配结果，由Group继承而来；
MatchCollection: Match的一个序列；
MatchEvaluator: 执行替换操作时使用的委托；
Regex：编译后的表达式的实例。
RegexCompilationInfo：提供编译器用于将正则表达式编译为独立程序集的信息
RegexOptions 提供用于设置正则表达式的枚举值
Regex类中还包含一些静态的方法：
Escape: 对字符串中的regex中的转义符进行转义；
IsMatch: 如果表达式在字符串中匹配，该方法返回一个布尔值；
Match: 返回Match的实例；
Matches: 返回一系列的Match的方法；
Replace: 用替换字符串替换匹配的表达式；
Split: 返回一系列由表达式决定的字符串；
Unescape:不对字符串中的转义字符转义。

(1)”@”符号

“@”符号表示,跟在它后面的字符串是个”逐字字符串”,举例,一下两个声明是等效的:

string x=”c:\\syx\\haha”

string y=@”c:\syx\haha”

事实上如果按照如下声明:

string y=”c:\syx\haha”,C#会报错,因为”\”在C#中用于实现转移,如”\n”表示换行.

(2)基本的语法字符

字符	含义
\d	0-9的数字
\D	\d的补集(以所有字符为全集,下同),即所有的非数字的字符
\w	单词字符,指大小写字母,0-9的数字,下划线
\W	\w的补集
\s	空白字符,包括换行符\n,回车符\r,制表符\t,垂直制表符\v,换页符\f
\S	\s的补集
[...]	匹配[]内所列出的所有字符
[^...]	匹配非[]内所列出的所有字符
.	除换行符\n以外的任意字符

案例:

string i = "\n";

string m = "3";

Regex r = new Regex(@"\D");//同Regex r = new Regex("\\D");

Console.WriteLine(r.IsMatch(i));//输出true

Console.WriteLine(r.IsMatch(m));//输出false

案例:

string i = "%";

string m = "3";

//匹配小写字母或数字字符

Regex r = new Regex("[a-z0-9]");

Console.WriteLine(r.IsMatch(i));//输出false

Console.WriteLine(r.IsMatch(m));//输出true

(3)定位字符:

“定位字符”所代表的是一个虚的字符,它代表一个位置,你可以直观的认为”定位字符”所代表的hi某个字符与自附件的那个微小间隙.

定位字符	含义
^	表示其后的字符必须位于字符串的开始处
$	表示其前面的字符必须位于字符串的结尾处
\b	匹配一个单词的边界
\B	匹配一个非单词的边界
\A	前面的字符必须位于字符处的开始出
\z	前面的字符必须位于字符串的结尾处
\Z	前面的字符必须位于字符串的结尾处,或者位于换行符前

案例:

string i = "Live for nothing,die for something";

Regex r1 = new Regex("^Live for nothing,die for something$");

//r1.IsMatch(i) true

Regex r2 = new Regex("^Live for nothing,die for some$");

//r2.IsMatch(i) false

Regex r3 = new Regex("^Live for nothing,die for some");

//r3.IsMatch(i) true

案例:

string i = @"Live for nothing,

die for something";//多行

Regex r1 = new Regex("^Live for nothing,die for something$");

Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0

Regex r2 = new Regex("^Live for nothing,die for something$", RegexOptions.Multiline);

Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//0

Regex r3 = new Regex("^Live for nothing,\r\ndie for something$");

Console.WriteLine("r3 match count:" + r3.Matches(i).Count);//1

Regex r4 = new Regex("^Live for nothing,$");

Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//0

Regex r5 = new Regex("^Live for nothing,$", RegexOptions.Multiline);

Console.WriteLine("r5 match count:" + r5.Matches(i).Count);//0

Regex r6 = new Regex("^Live for nothing,\r\n$");

Console.WriteLine("r6 match count:" + r6.Matches(i).Count);//0

Regex r7 = new Regex("^Live for nothing,\r\n$", RegexOptions.Multiline);

Console.WriteLine("r7 match count:" + r7.Matches(i).Count);//0

Regex r8 = new Regex("^Live for nothing,\r$");

Console.WriteLine("r8 match count:" + r8.Matches(i).Count);//0

Regex r9 = new Regex("^Live for nothing,\r$", RegexOptions.Multiline);

Console.WriteLine("r9 match count:" + r9.Matches(i).Count);//1

Regex r10 = new Regex("^die for something$");

Console.WriteLine("r10 match count:" + r10.Matches(i).Count);//0

Regex r11 = new Regex("^die for something$", RegexOptions.Multiline);

Console.WriteLine("r11 match count:" + r11.Matches(i).Count);//1

Regex r12 = new Regex("^");

Console.WriteLine("r12 match count:" + r12.Matches(i).Count);//1

Regex r13 = new Regex("$");

Console.WriteLine("r13 match count:" + r13.Matches(i).Count);//1

Regex r14 = new Regex("^", RegexOptions.Multiline);

Console.WriteLine("r14 match count:" + r14.Matches(i).Count);//2

Regex r15 = new Regex("$", RegexOptions.Multiline);

Console.WriteLine("r15 match count:" + r15.Matches(i).Count);//2

Regex r16 = new Regex("^Live for nothing,\r$\n^die for something$", RegexOptions.Multiline);

Console.WriteLine("r16 match count:" + r16.Matches(i).Count);//1

对于一个多行字符串,在设置了Multiline选项之后,^和$将出现多次匹配.

案例:

string i = "Live for nothing,die for something";

string m = "Live for nothing,die for some thing";

Regex r1 = new Regex(@"\bthing\b");

Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0

Regex r2 = new Regex(@"thing\b");

Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//2

Regex r3 = new Regex(@"\bthing\b");

Console.WriteLine("r3 match count:" + r3.Matches(m).Count);//1

Regex r4 = new Regex(@"\bfor something\b");

Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//1

\b通常用于约束一个完整的单词

(4)重复描述符

“重复描述符”是体现C#正则表达式”很好很强大”的地方之一

重复描述符	含义
{n}	匹配前面的字符n次
{n,}	匹配前面的字符n次或多余n次
{n,m}	匹配前面的字符n到m次
?	匹配前面的字符0或者1次
+	匹配前面的字符1次或多于1次
*	匹配前面的字符0次或多于0次

案例:匹配1000到9999的整数

string x = "1024";

string y = "+1024";

string z = "1,024";

string a = "1";

string b = "-1024";

string c = "10000";

Regex r = new Regex(@"^\+?[1-9],?\d{3}$");

Console.WriteLine("x match count:" + r.Matches(x).Count);//1

Console.WriteLine("y match count:" + r.Matches(y).Count);//1

Console.WriteLine("z match count:" + r.Matches(z).Count);//1

Console.WriteLine("a match count:" + r.Matches(a).Count);//0

Console.WriteLine("b match count:" + r.Matches(b).Count);//0

Console.WriteLine("c match count:" + r.Matches(c).Count);//0

(5)择一匹配

C#正则表达式中的(|)符号似乎没有一个专门的称为,姑且称之为”择一匹配”吧.事实上,像[a-z]也是一种择一匹配,只不过它只能匹配单个字符,而(|)则提供了更大的范围,(ab|xy)表示匹配ab或匹配xy.注意”|”与”()”在此是一个整体.

案例:匹配0到100的整数.最外层的括号包含两部分”(100(.0+)*)” , “([1-9]?[0-9])(\.\d+)*”,这两部分是”OR”的关系,即正则表达式引擎会现场时匹配100,如果失败,则尝试匹配后一个表达式(表示[0,100)范围中的数字)

string x = "0";

string y = "0.23";

string z = "100";

string a = "100.01";

string b = "9.9";

string c = "99.9";

string d = "99.";

string e = "00.1";

Regex r = new Regex(@"^\+?((100(.0+)*)|([1-9]?[0-9])(\.\d+)*)$");

Console.WriteLine("x match count:" + r.Matches(x).Count);//1

Console.WriteLine("y match count:" + r.Matches(y).Count);//1

Console.WriteLine("z match count:" + r.Matches(z).Count);//1

Console.WriteLine("a match count:" + r.Matches(a).Count);//0

Console.WriteLine("b match count:" + r.Matches(b).Count);//1

Console.WriteLine("c match count:" + r.Matches(c).Count);//1

Console.WriteLine("d match count:" + r.Matches(d).Count);//0

Console.WriteLine("e match count:" + r.Matches(e).Count);//0

(6)特殊字符的匹配

案例:匹配“\”

string x = "\\";

Regex r1 = new Regex("^\\\\$");

Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1

Regex r2 = new Regex(@"^\\$");

Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1

Regex r3 = new Regex("^\\$");

Console.WriteLine("r3 match count:" + r3.Matches(x).Count);//0

案例:匹配双引号

string x = "\"";

Regex r1 = new Regex("^\"$");

Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1

Regex r2 = new Regex(@"^""$");

Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1

(7)组与非捕获组

案例:

//正则表达式引擎会记忆“()”中匹配到的内容，作为一个“组”，并且可以通过索引的方式进行引用。表达式中的“\1”，用于反向引用表达式中出现的第一个组，即粗体标识的第一个括号内容，“\2”则依此类推。

string x = "Live for nothing,die for something";

string y = "Live for nothing,die for somebody";

Regex r = new Regex(@"^Live ([a-z]{3}) no([a-z]{5}),die \1 some\2$");

Console.WriteLine("x match count:" + r.Matches(x).Count);//1

Console.WriteLine("y match count:" + r.Matches(y).Count);//0

案例:            //获取组中的内容。注意，此处是Groups[1]，因为Groups[0]是整个匹配的字符串，即整个变量x的内容。

string x = "Live for nothing,die for something";

Regex r = new Regex(@"^Live for no([a-z]{5}),die for some\1$");

if (r.IsMatch(x))

{

Console.WriteLine("group1 value:" + r.Match(x).Groups[1].Value);//输出：thing

}

案例:            //可根据组名进行索引。使用以下格式为标识一个组的名称(?<groupname>…)。

string x = "Live for nothing,die for something";

Regex r = new Regex(@"^Live for no(?<g1>[a-z]{5}),die for some\1$");

if (r.IsMatch(x))

{

Console.WriteLine("group1 value:" + r.Match(x).Groups["g1"].Value);//输出：thing

}

案例:            //删除原字符串中重复出现的“nothing”。在表达式之外，使用“$1”来引用第一个组，下面则是通过组名来引用：

string x = "Live for nothing nothing";

Regex r = new Regex(@"([a-z]+) \1");

if (r.IsMatch(x))

{

x = r.Replace(x, "$1");

Console.WriteLine("var x:" + x);//输出：Live for nothing

}

案例://在组前加上“?:”表示这是个“非捕获组”，即引擎将不保存该组的内容。

string x = "Live for nothing nothing";

Regex r = new Regex(@"(?<g1>[a-z]+) \1");

if (r.IsMatch(x))

{

x = r.Replace(x, "${g1}");

Console.WriteLine("var x:" + x);//输出：Live for nothing

}

string x = "Live for nothing";

Regex r = new Regex(@"^Live for no(?:[a-z]{5})$");

if (r.IsMatch(x))

{

Console.WriteLine("group1 value:" + r.Match(x).Groups[1].Value);//输出：(空)

}

(8)贪婪与非贪婪

正则的引擎是贪婪,只要模式允许,它将匹配尽可能多的字符.通过在”重复描述符”(+,*)后面添加”?”,可以将匹配模式改成非贪婪.实例:

string x = "Live for nothing,die for something";

Regex r1 = new Regex(@".*thing");

if (r1.IsMatch(x))

{

Console.WriteLine("match:" + r1.Match(x).Value);//输出：Live for nothing,die for something

}

Regex r2 = new Regex(@".*?thing");

if (r2.IsMatch(x))

{

Console.WriteLine("match:" + r2.Match(x).Value);//输出：Live for nothing

}

(9)回溯与非回溯

使用”(?>...)”方式进行非回溯声明.由于正则表达式引擎的贪婪特性,导致他在某些情况下,将进行回溯以获得匹配,实例:

//在r1中，“.*”由于其贪婪特性，将一直匹配到字符串的最后，随后匹配“thing”，但在匹配“,”时失败，此时引擎将回溯，并在“thing,”处匹配成功。

string x = "Live for nothing,die for something";

Regex r1 = new Regex(@".*thing,");

if (r1.IsMatch(x))

{

Console.WriteLine("match:" + r1.Match(x).Value);//输出：Live for nothing,

}

Regex r2 = new Regex(@"(?>.*)thing,");

if (r2.IsMatch(x))//不匹配

{

Console.WriteLine("match:" + r2.Match(x).Value);

}

分析:由于强制非回溯,所以整个表达式匹配失败.

(10)正向预搜索,反向预搜索

正向预搜索声明格式:正声明”(?=...)”,负声明”(?!...)”,声明本身不作为最终匹配结果的一部分,示例如下:

//r1中的正声明表示必须保证在四位数字的后面必须紧跟着“ used”，r2中的负声明表示四位数字之后不能跟有“ used”。

string x = "1024 used 2048 free";

Regex r1 = new Regex(@"\d{4}(?= used)");

if (r1.Matches(x).Count == 1)

{

Console.WriteLine("r1 match:" + r1.Match(x).Value);//输出：1024

}

Regex r2 = new Regex(@"\d{4}(?! used)");

if (r2.Matches(x).Count == 1)

{

Console.WriteLine("r2 match:" + r2.Match(x).Value); //输出：2048

}

反向预搜索声明格式：正声明“(?<=)”，负声明“(?<!)”，声明本身不作为最终匹配结果的一部分，请看下面的示例：

//r1中的反向正声明表示在4位数字之前必须紧跟着“used:”，r2中的反向负声明表示在4位数字之前必须紧跟着除“used:”之外的字符串。

string x = "used:1024 free:2048";

Regex r1 = new Regex(@"(?<=used:)\d{4}");

if (r1.Matches(x).Count == 1)

{

Console.WriteLine("r1 match:" + r1.Match(x).Value);//输出：1024

}

Regex r2 = new Regex(@"(?<!used:)\d{4}");

if (r2.Matches(x).Count == 1)

{

Console.WriteLine("r2 match:" + r2.Match(x).Value);//输出：2048

}

(11)十六进制字符范围

正则表达式中，可以使用 "\xXX" 和 "\uXXXX" 表示一个字符（"X" 表示一个十六进制数）形式字符范围：

\xXX       编号在 0到255 范围的字符，比如：空格可以使用 "\x20" 表示。

\uXXXX   任何字符可以使用 "\u" 再加上其编号的4位十六进制数表示，比如：汉字可以使用“[\u4e00-\u9fa5]”表示。

(12)对[0,100]的比较完备的匹配

案例:

下面是一个比较综合的示例，对于匹配[0,100]，需要特殊考虑的地方包括

*00合法，00.合法，00.00合法，001.100合法

*空字符串不合法，仅小数点不合法，大于100不合法

*数值是可带后缀的，如“1.07f”表示该值为一个float类型（未考虑）

Regex r = new Regex(@"^\+?0*(?:100(\.0*)?|(\d{0,2}(?=\.\d)|\d{1,2}(?=($|\.$)))(\.\d*)?)$");

string x = "";

while (true)

{

x = Console.ReadLine();

if (x != "exit")

{

if (r.IsMatch(x))

{

Console.WriteLine(x + " succeed!");

}

else

{

Console.WriteLine(x + " failed!");

}

}

else

{

break;

}

}

（13）精确匹配有时候是困难的

有些需求要做到精确匹配比较困难，例如：日期、Url、Email地址等，其中一些你甚至需要研究一些专门的文档写出精确完备的表达式，对于这种情况，只能退而求其次，保证比较精确的匹配。例如对于日期，可以基于应用系统的实际情况考虑一段较短的时间，或者对于像Email的匹配，可以只考虑最常见的形式。