C# 正则表达式及常用正则表达式

匹配模式+环视(顺序环视、逆序环视)+贪婪与非贪婪
 
RegexOptions.Multiline
“^”匹配结果分析
在不开启多行模式时，“^”只匹配字符串的开始位置，也就是位置0。
在开启了多行模式后，“^”匹配字符串开始位置和每个“\n”之后的行起始位置。
 
“$”匹配结果分析
在不开启多行模式时，如果字符结尾是“\n”，那么“$”会匹配结尾“\n”之前和结束两个位置。
在开启多行模式后，“$”匹配每行“\n”之前的位置和字符串结束位置。
 
需要注意的是，在.NET中，无论是否开启多行模式，“^”和“$”匹配的都只是一个位置，是零宽度的。其它语言中“^”和“$”的意义可能会有所不同。
只有在正则表达式中涉及到多行的“^”和“$”的匹配时，才使用Multiline模式。
 
RegexOptions.Compiled
Compiled改变的是.NET中正则表达式的编译方式。启用了Compiled模式，会延长启动时间，占用更多的内存，会提高匹配速度。当然，对最终性能的影响，需要根据具体问题综合考虑的。这一模式也是被“滥”用最多的模式之一。
 
程序运行过程中，第一次遇到正则表达式，需要加载正则引擎，对正则表达式进行必要的语法检查，并做适当的优化，最后把它转换为适合正则引擎应用的形式。这种“解析”过程，对于复杂的正则表达式，频繁调用或是匹配较大的数据源时，对效率的影响较大。
 
这时可以在构建正则表达式时开启Compiled模式。这样做会将正则表达式直接编译为MSIL代码，在正则匹配过程中，可以由JIT优化为更快的本地机器代码，获得更高的匹配速度。但这种方式会降低正则的解析速度，占用更多的内存，而且它占用的内存在程序运行过程中会一直占用，无法释放。
 
什么场景下使用Compiled模式，需要根据实际情况具体问题具体分析，一般来说，以下场景不适合使用Compiled模式：
1.对匹配效率没有要求的场景；
2.非常简单的正则表达式；
3.极少调用的方法中声明的正则表达式；
4.循环体中声明的正则表达式（除了动态生成的正则表达式，否则不要在循环体内声明正则表达式）；
5.静态方法中声明的正则表达式（静态方法每次调用都需要重新编辑正则表达式，使用Compiled模式只会降低效率）。
 
RegexOptions.RightToLeft
RightToLeft改变的是正则表达式匹配的顺序，从右到左进行匹配
一个由字母组成的字符串，最长14位，要求每隔2位加一个逗号，最左边不加，求一个好的算法
例：“abcdefg”    返回“a,bc,de,fg”
代码实现：
string test = "abcdefg";
string result = Regex.Replace(test, @"(?<!^)[a-zA-Z]{2}", ",$0", RegexOptions.RightToLeft);
 
RegexOptions.ExplicitCapture
这一模式改变的是普通捕获组的匹配行为。将普通捕获组解释为非捕获组，只有显式命名的命名捕获组才当作捕获组使用。
捕获组的作用是将括号()内子表达式匹配到的内容保存到内存中一个组里，供以后引用，在.NET中捕获组有两种形式
(Expression) 普通捕获组
(?<name>Expression) 命名捕获组
其它形式的(?...)都不是捕获组。
但是(Expression)这种捕获组语法规则也带来一个副作用，在一些不得不使用()的场合，会默认为使用了捕获组，将匹配到的内容保存到内存中，而有些情况下这些内容并不需要关心的，浪费了系统资源，降低了匹配效率，所以才有了非捕获组(?:Expression)的出现，来抵消这一副作用。而非捕获组带来的另一个副作用的就是可读性的降低。
string test = "<li title=\"截至2009-07-28 20:45:49，用户的总技术分为：5988；截至2009-07-26日，用户的总技术分排名为：4133\">(...)</li>";
Regex reg = new Regex(@"([01][0-9]|2[0-3])(:[0-5][0-9]){2}", RegexOptions.ExplicitCapture);
MatchCollection mc = reg.Matches(test);
string s = "";
foreach (Match m in mc)
{
s += m.Value + "\n";
s += m.Groups[1].Value + "\n";
s += m.Groups[2].Value + "\n";
}
Console.Write(s);
未开启RegexOptions.ExplicitCapture
/*
20:45:49
20
:49
*/
开启的结果是
/*
20:45:49
 
 
*/
 
 
(?imnsx-imnsx:)形式
string[] test = new string[] { "Abc", "AbcdefGHIjklmn", "abcdefghijklmn" };
Regex reg = new Regex(@"^[A-Z](?i:[A-Z]{9,19})$");
string str = "";
foreach (string s in test)
{
str += "源字符串：" + s.PadRight(15, ‘ ‘) + "  匹配结果： " + reg.IsMatch(s) + "\n";
}
Console.WriteLine(str);
/*--------输出--------
源字符串： Abc              匹配结果： False
源字符串： AbcdefGHIjklmn   匹配结果： True
源字符串： abcdefghijklmn   匹配结果： False
*/
语法：(?-i:Expression)
这种语法规则表达为括号内的子表达式关闭忽略大小写模式。通常与全局匹配模式配合使用，表示全局为忽略大小写的，局部为严格区分大小写。
string test = "<DIV id=\"Test\" class=\"create\">first</div> and <DIV id=\"TEST\" class=\"delete\">second</div>";
Regex reg = new Regex(@"<div id=""(?-i:TEST)""[^>]*>[\w\s]+</div>", RegexOptions.IgnoreCase);
string str = "";
MatchCollection mc = reg.Matches(test);
foreach (Match m in mc)
{
str += m.Value + "\n";
}
Console.WriteLine(str);
/*--------输出--------
<DIV id="TEST" class="delete">second</div>
*/
环视基础
表达式
说明
(?<=Expression)
逆序肯定环视，表示所在位置左侧能够匹配Expression
(?<!Expression)
逆序否定环视，表示所在位置左侧不能匹配Expression
(?=Expression)
顺序肯定环视，表示所在位置右侧能够匹配Expression
(?!Expression)
顺序否定环视，表示所在位置右侧不能匹配Expression
 
string str = "aa<p>one</p>bb<div>two</div>cc";
foreach (Match item in Regex.Matches(str, @"<(?!/?p\b)[^>]+>"))
{
Console.WriteLine(item.Value);
}
/*
<div>
</div>
*/
string str = "<div>a test</div><div>1</div>";
foreach (Match item in Regex.Matches(str, @"(?<=<div>)[^<]+(?=</div>)"))
{
Console.WriteLine(item.Value);
}
/*
a test
1
*/
 
double[] data = new double[] { 0, 12, 123, 1234, 12345, 123456, 1234567, 123456789, 1234567890, 12.345, 123.456, 1234.56, 12345.6789, 123456.789, 1234567.89, 12345678.9 };
string s = "";
foreach (double d in data)
{
s += "源字符串：" + d.ToString().PadRight(15) + "格式化：" + Regex.Replace(d.ToString(), @"(?<=\d)(?<!\.\d*)(?=(?:\d{3})+(?:\.\d+|$))", ",") + "\n";
}
Console.Write(s);
 
结果：
源字符串：0              格式化：0
源字符串：12             格式化：12
源字符串：123            格式化：123
源字符串：1234           格式化：1,234
源字符串：12345          格式化：12,345
源字符串：123456         格式化：123,456
源字符串：1234567        格式化：1,234,567
源字符串：123456789      格式化：123,456,789
源字符串：1234567890     格式化：1,234,567,890
源字符串：12.345         格式化：12.345
源字符串：123.456        格式化：123.456
源字符串：1234.56        格式化：1,234.56
源字符串：12345.6789     格式化：12,345.6789
源字符串：123456.789     格式化：123,456.789
源字符串：1234567.89     格式化：1,234,567.89
源字符串：12345678.9     格式化：12,345,678.9
 
实现分析：
首先根据需求可以确定是把一些特定的位置替换为“,”，接下来就是分析并找到这些位置的规律，并抽象出来以正则表达式来表示。
1、这个位置的左侧必须为数字
2、这个位置右侧到出现“.”或结尾为止，必须是数字，且数字的个数必须为3的倍数
3、这个位置左侧相隔任意个数字不能出现“.”
由以上三条，就可以完全确定这些位置，只要实现以上三条，组合一下正则表达式就可以了。
根据分析，最终匹配的结果是一个位置，所以所有子表达式都要求是零宽度。
1、是对当前所在位置左侧附加的条件，所以要用到逆序环视，因为要求必须出现，所以是肯定的，符合这一条件的子表达式即为“(?<=\d)”
2、是对当前所在位置右侧附加的条件，所以要用到顺序环视，也是要求出现，所以是肯定的，是数字，且个数为3的倍数，即“(?=(?:\d{3})*)”，到出现“.”或结尾为止，即“(?=(?:\d{3})*(?:\.|$))”
3、是对当前所在位置左侧附加的条件，所以要用到逆序环视，因为要求不能出现，所以是否定的，即“(?<!\.\d*)”
因为零宽度的子表达式是非互斥的，最后匹配的都是同一个位置，所以先后顺序是不影响最后的匹配结果的，可以任意组合，只是习惯上把逆序环视写在左侧，顺序环视写在右侧。
 
 
 
贪婪与非贪婪模式匹配
string str = "aa<div>test1</div>bb<div>test2</div>cc";
foreach (Match item in Regex.Matches(str, @"<div>.*</div>"))
{
Console.WriteLine(item.Value);
}
/*贪婪模式，很好理解，尽量多匹配
<div>test1</div>bb<div>test2</div>
*/
如果正则表达式是<div>.*?</div>
/*非贪婪模式，也叫懒惰模式，就是懒的意思，匹配到了就不会再向后匹配
<div>test1</div>
<div>test2</div>
*/
 
贪婪非贪婪的比较以及优化
string str =@"The phrase ""regular expression"" is called ""Regex"" for short.";
foreach (Match item in Regex.Matches(str, @""".*"""))
{
Console.WriteLine(item.Value);
}
一、使用”.*”这种匹配的结果不符合："regular expression" is called "Regex"
二、使用”.*?”的结果：
"regular expression"
"Regex"
OK，不过进行了四次回溯
三、使用这种[^"]*匹配OK，没有回溯
四、对三的改进，固化分组 (?>[^"]*)，匹配效率最好
 
再看一例，获取img标签的src内容：
string str =@"<img class=""test"" src=""/img/logo.gif"" title=""测试"" />";
foreach (Match item in Regex.Matches(str, @"<img\b.*?src=""(.*?)"".*?"))
{
Console.WriteLine(item.Groups[1].Value);
}
使用的是非贪婪模式，我们通过排除型字符组转换为贪婪模式，提高匹配效率
@"<img\b.*?src=""([^""]*)""[^>]*"
img与src之间的非贪婪通过顺序环视来转化
@"<img\b(?:(?!src=).)*src=""([^""]*)""[^>]*"
“(?!src=).”表示这样一个字符，从它开始，右侧不能是字符序列“src=”，而“(?:(?!src=).)*”就表示符合上面规则的字符，有0个或无限多个。这样就达到排除字符序列的目的，实现的效果同排除型字符组一样，只不过排除型字符组排除的是一个或多个字符，而这种环视结构排除的是一个或多个有序的字符序列。
 
但是以顺序环视的方式排除字符序列，由于在匹配每一个字符时，都要进行较多的判断，所以相对于非贪婪模式，是提升效率还是降低效率，要根据实际情况进行分析。对于简单的正则表达式，或是简单的源字符串，一般来说是非贪婪模式效率高些，而对于数量较大源字符串，或是复杂的正则表达式，一般来说是贪婪模式效率高些。
 
PS：一般都是贪婪模式+固化分组，当然也需要看具体情况。
 
一些正则的实践篇
清除掉iframe+javascript+css的恶意脚本
http://rczjp.cn/HTML/101210/20105010115029.html
正则截取URL网址
http://rczjp.cn/HTML/101218/20102718032702.html
常见的正则
http://rczjp.cn/HTML/081119/20082119022155.html
 
此文章来自原作者：http://blog.csdn.net/lxcnn/ 具体详情去过客的blog参看。
下面是作者写的NFA引擎匹配原理，讲解的很详细，值得参看：
http://blog.csdn.net/lxcnn/archive/2009/06/28/4304651.aspx