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


元字符


描述


.点


匹配任何单个字符。例如正则表达式r.t匹配这些字符串:rat、rut、r t,但是不匹配root。


$


匹配行结束符。例如正则表达式weasel$ 能够匹配字符串"He's a weasel"的末尾 ,但是不能匹配字符串"They are a bunch of weasels."


^


匹配一行的开始。例如正则表达式^When in能够匹配字符串"When in the course of human events"的开始,但是不能匹配"What and When in the"


*


匹配0或多个正好在它之前的那个字符。例如正则表达式.*意味着能够匹配任意数量的任何字符。


\


这是引用符,用来将这里列出的这些元字符当作普通的字符来进行匹配。例如正则表达式\$被用来匹配美元符号,而不是行尾,类似的,正则表达式\.用来匹配点字符,而不是任何字符的通配符。


[ ]


[c1-c2]


[^c1-c2]


匹配括号中的任何一个字符。例如正则表达式r[aou]t匹配rat、rot和rut,但是不匹配ret。可以在括号中使用连字符-来指定字符的区间,例如正则表达式[0-9]可以匹配任何数字字符;还可以制定多个区间,例如正则表达式[A-Za-z]可以匹配任何大小写字母。另一个重要的用法是“排除”,要想匹配除了指定区间之外的字符——也就是所谓的补集——在左边的括号和第一个字符之间使用^字符,例如正则表达式[^269A-Z] 将匹配除了2、6、9和所有大写字母之外的任何字符。


\< \>


匹配词(word)的开始(\<)和结束(\>)。例如正则表达式\<the\>能够匹配字符串"for the wise"中的"the",但是不能匹配字符串"otherwise"中的"the"。注意:这个元字符不是所有的软件都支持的。


\( \)


将 \( 和 \) 之间的表达式定义为“组”(group),并且将匹配这个表达式的字符保存到一个临时区域(一个正则表达式中最多可以保存9个),它们可以用 \1 到\9 的符号来引用。


|


将两个匹配条件进行逻辑“或”(Or)运算。例如正则表达式(him|her) 匹配"it belongs to him"和"it belongs to her",但是不能匹配"it belongs to them."。注意:这个元字符不是所有的软件都支持的。


+


匹配1或多个正好在它之前的那个字符。例如正则表达式9+匹配9、99、999等。注意:这个元字符不是所有的软件都支持的。


?


匹配0或1个正好在它之前的那个字符。注意:这个元字符不是所有的软件都支持的。


\{i\}


\{i,j\}


匹配指定数目的字符,这些字符是在它之前的表达式定义的。例如正则表达式A[0-9]\{3\} 能够匹配字符"A"后面跟着正好3个数字字符的串,例如A123、A348等,但是不匹配A1234。而正则表达式[0-9]\{4,6\} 匹配连续的任意4个、5个或者6个数字字符。注意:这个元字符不是所有的软件都支持的。


/*******************匹配常见的格式*********************/
//var pattern=/^\w{5,10}$/; //最少5位的下划线、字母、数字,\w+相当于\w{1,} \w*相当于\w{0,} \w?相当于\w{0,1} \w{5,10}5到10位
//var pattern1=/^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$/;//15位的身份证
//var pattern2=/^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$/;//18位的身份证
//var pattern=/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/;//匹配E-MALI地址
//var pattern=/^http:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?/;//匹配网址
//var pattern=/http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?/;//匹配网址
//var pattern=/^[\u4e00-\u9fa5]$/;//匹配中文字符(单个汉字)
//var pattern=/^[1-9]\d{5}(?!\d)$/;//匹配邮政编码
//var pattern=/^[1-2][0-9][0-9][0-9]-[0-1]{0,1}[0-9]-[0-3]{0,1}[0-9]$/;//匹配日期 如:1900-01-01
//var pattern=/^[^\x00-\xff]$/;//匹配双字节字符(包括汉字在内的单个字符)
//var pattern=/^<(.*)>.*<\/\1>|<(.*) \/>$/;//匹配HTML标记
//var pattern=/<(\S*?)[^>]*>.*?<\/\1>|<.*? \/>/;//匹配HTML标记
//var pattern=/^\n[\s| ]*\r$/;//可以用来删除空白行
//var pattern=/^(\s*)|(\s*)$///可以用来删除行首尾的空白字符(包括空格、制表符、换页符等等)
//var pattern=/^[a-zA-Z][a-zA-Z0-9_]{4,15}$/;//字母开头,限制5-16字节,允许字母数字下划线
//var pattern=/^\d{3}-\d{8}|\d{4}-\d{7,8}$/;//匹配国内电话 如:0739-8888888(8) 或 020-88888888
//var pattern=/^[1-9][0-9]{4,}$/;//匹配QQ号码 腾讯QQ号从10000开始
//var pattern=/^\d+\.\d+\.\d+\.\d+$/;//匹配IP地址
/*******************匹配特定数字*********************/
//var pattern=/^(\w)\1{4,}*$/;//匹配整数
//var pattern=/-?[1-9]\d*$/;//匹配整数
//var pattern=/^[1-9]\d*$/;//匹配正整数
//var pattern=/^-[1-9]\d*$/;//匹配负整数
//var pattern=/^[1-9]\d*|0$/;//匹配非负整数
//var pattern=/^-[1-9]\d*|0$/;//匹配非正整数
//var pattern=/^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$/;//匹配正浮点数
//var pattern=/^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$/;//匹配负浮点数
//var pattern=/^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$/;//匹配浮点数
//var pattern=/^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$/;//匹配非负浮点数
//var pattern=/^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$/;//匹配非正浮点数
/********************匹配特定字符串*****************/
//var pattern=/^[A-Za-z]+$/;//匹配由26个英文字母组成的字符串
//var pattern=/^[A-Z]+$/;//匹配由26个英文字母的大写组成的字符串
//var pattern=/^[a-z]+$/;//匹配由26个英文字母的小写组成的字符串
//var pattern=/^[A-Za-z0-9]+$/;//匹配由数字和26个英文字母组成的字符串
//var pattern=/^\w+$/;//匹配由数字、26个英文字母或者下划线组成的字符串
<script>
if(!pattern.test(document.getElementById("content").value)){
alert("请输入正确的格式!");
return false;
}
}
</script>
<%
‘限制只能输入中文:onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,‘‘)" onbeforepaste="clipboardData.setData(‘text‘,clipboardData.getData(‘text‘).replace(/[^\u4E00-\u9FA5]/g,‘‘))"
‘限制只能输入全角字符:onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,‘‘)" onbeforepaste="clipboardData.setData(‘text‘,clipboardData.getData(‘text‘).replace(/[^\uFF00-\uFFFF]/g,‘‘))"
‘限制只能输入数字:onkeyup="value=value.replace(/[^\d]/g,‘‘) "onbeforepaste="clipboardData.setData(‘text‘,clipboardData.getData(‘text‘).replace(/[^\d]/g,‘‘))"
‘限制只能输入数字和英文:onkeyup="value=value.replace(/[\W]/g,‘‘) "onbeforepaste="clipboardData.setData(‘text‘,clipboardData.getData(‘text‘).replace(/[^\d]/g,‘‘))"
%>
匹配模式+环视(顺序环视、逆序环视)+贪婪与非贪婪

RegexOptions.Multiline
“^”匹配结果分析
在不开启多行模式时,“^”只匹配字符串的开始位置,也就是位置0。
在开启了多行模式后,“^”匹配字符串开始位置和每个“\n”之后的行起始位置。 “$”匹配结果分析
在不开启多行模式时,如果字符结尾是“\n”,那么“$”会匹配结尾“\n”之前和结束两个位置。
在开启多行模式后,“$”匹配每行“\n”之前的位置和字符串结束位置。 需要注意的是,在.NET中,无论是否开启多行模式,“^”和“$”匹配的都只是一个位置,是零宽度的。其它语言中“^”和“$”的意义可能会有所不同。
只有在正则表达式中涉及到多行的“^”和“$”的匹配时,才使用Multiline模式。 RegexOptions.Compiled
Compiled改变的是.NET中正则表达式的编译方式。启用了Compiled模式,会延长启动时间,占用更多的内存,会提高匹配速度。当然,对最终性能的影响,需要根据具体问题综合考虑的。这一模式也是被“滥”用最多的模式之一。 程序运行过程中,第一次遇到正则表达式,需要加载正则引擎,对正则表达式进行必要的语法检查,并做适当的优化,最后把它转换为适合正则引擎应用的形式。这种“解析”过程,对于复杂的正则表达式,频繁调用或是匹配较大的数据源时,对效率的影响较大。 这时可以在构建正则表达式时开启Compiled模式。这样做会将正则表达式直接编译为MSIL代码,在正则匹配过程中,可以由JIT优化为更快的本地机器代码,获得更高的匹配速度。但这种方式会降低正则的解析速度,占用更多的内存,而且它占用的内存在程序运行过程中会一直占用,无法释放。 什么场景下使用Compiled模式,需要根据实际情况具体问题具体分析,一般来说,以下场景不适合使用Compiled模式:
.对匹配效率没有要求的场景;
.非常简单的正则表达式;
.极少调用的方法中声明的正则表达式;
.循环体中声明的正则表达式(除了动态生成的正则表达式,否则不要在循环体内声明正则表达式);
.静态方法中声明的正则表达式(静态方法每次调用都需要重新编辑正则表达式,使用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[].Value + "\n";
s += m.Groups[].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(, ' ') + " 匹配结果: " + 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[] { , , , , , , , , , 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() + "格式化:" + Regex.Replace(d.ToString(), @"(?<=\d)(?<!\.\d*)(?=(?:\d{3})+(?:\.\d+|$))", ",") + "\n";
}
Console.Write(s); 结果:
源字符串: 格式化:
源字符串: 格式化:
源字符串: 格式化:
源字符串: 格式化:,
源字符串: 格式化:,
源字符串: 格式化:,
源字符串: 格式化:,,
源字符串: 格式化:,,
源字符串: 格式化:,,,
源字符串:12.345 格式化:12.345
源字符串:123.456 格式化:123.456
源字符串:1234.56 格式化:,234.56
源字符串:12345.6789 格式化:,345.6789
源字符串:123456.789 格式化:,456.789
源字符串:1234567.89 格式化:,,567.89
源字符串:12345678.9 格式化:,,678.9 实现分析:
首先根据需求可以确定是把一些特定的位置替换为“,”,接下来就是分析并找到这些位置的规律,并抽象出来以正则表达式来表示。
、这个位置的左侧必须为数字
、这个位置右侧到出现“.”或结尾为止,必须是数字,且数字的个数必须为3的倍数
、这个位置左侧相隔任意个数字不能出现“.”
由以上三条,就可以完全确定这些位置,只要实现以上三条,组合一下正则表达式就可以了。
根据分析,最终匹配的结果是一个位置,所以所有子表达式都要求是零宽度。
、是对当前所在位置左侧附加的条件,所以要用到逆序环视,因为要求必须出现,所以是肯定的,符合这一条件的子表达式即为“(?<=\d)”
、是对当前所在位置右侧附加的条件,所以要用到顺序环视,也是要求出现,所以是肯定的,是数字,且个数为3的倍数,即“(?=(?:\d{})*)”,到出现“.”或结尾为止,即“(?=(?:\d{})*(?:\.|$))”
、是对当前所在位置左侧附加的条件,所以要用到逆序环视,因为要求不能出现,所以是否定的,即“(?<!\.\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[].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
上一篇:EasyUI组合树插件


下一篇:UML 类图介绍