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的匹配，可以只考虑最常见的形式。
