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

标签：元字符   允许   lin   white   com   mpi   die   基本   背景   

正则表达式

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)基本的语法字符

案例:

            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某个字符与自附件的那个微小间隙.

案例:

            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#正则表达式”很好很强大”的地方之一

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

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

标签：元字符   允许   lin   white   com   mpi   die   基本   背景   

原文地址：http://www.cnblogs.com/jia125go/p/7602643.html