正则表达式

 

 

 

正则表达式用于对字符串进行操作, 是用来检验和操作字符串的强大工具。简单的理解正则表达式可以认为是一种特殊的验证字符串。正则表达式常见运用是验证用户输入信息格式，表达式 “\w{1,}@\w{1,}\.\w{1”，实际上就是验证邮件地址是否合法的；当然正则表达式不仅仅是用于验证，可以说只要运用字符串的地方都可以使用正则表达式,正则表达式在英文中写作（Regular Expression），根据正则表达式的使用范围和单词意思.NET将其命名空间设置为System.Text.RegularExpressions

Capture 用于单个表达式捕获结果
CaptureCollection 用于一个序列进行字符串捕获
Group 表示单个捕获的结果
GroupCollection 表示捕获组的集会
Match 表示匹配单个正则表达式结果
MatchCollection 表示通过迭代方式应用正则表达式到字符串中
Regex 表示不可变的正则表达式
RegexCompilationInfo 将编译正则表达式需要提供信息

 一、符号解释
1、@符号
表示跟在它后面的字符串按原义输出，不进行任何转义等操作
其实@并非正则表达式的"成员"，但是它经常与C#正则表达式出双入对

string str1 = @"C:\Inetpub\wwwroot";
string str2 = "C:\\Inetpub\\wwwroot";
string str3 = "C:\Inetpub\wwwroot";
if ( str1 == str2 ) {
    Console.WriteLine( "str1 == str2" );
} else {
    Console.WriteLine( "str1 != str2" );
}
// 输出：str1 == str2
if ( str1 == str3 ) {
    Console.WriteLine( "str1 == str3" );
} else {
    Console.WriteLine( "str1 != str3" );
}
// 输出：str1 != str3，这是因为 \ 在C#中用于实现转义，如"\n"换行

2、基本的语法字符

字符	解释
[xyz]	字符集合，匹配[]内所列出的所有字符
[^xyz]	负值字符集合匹配所有非[]内所列出的字符
\d	0-9的数字，等价于 [0-9]
\D	\d的补集，即所有非数字的字符，等价于 [^0-9]
\w	匹配包括下划线的任何单词字符，等价于[A-Za-z0-9_]
\W	\w的补集，匹配任何非单词字符，等价于[^A-Za-z0-9_]
\t	匹配一个制表符等价于 \x09 和 \cI
\v	匹配一个垂直制表符，等价于 \x0b 和 \cK
\f	匹配一个换页符等价于 \x0c 和 \cL
\n	匹配一个换行符等价于 \x0a 和 \cJ
\r	匹配一个回车符等价于 \x0d 和 \cM
\s	匹配任何空白字符，包括空格、制表符、换页符等，等价于[\f\n\r\t\v]
\S	\s的补集，匹配任何非空白字符等价于 [^ \f\n\r\t\v]
.	匹配除 "\n" 之外的任何单个字符

 

string m = "1"; 
string n = "a"; 
Regex reg = new Regex( @"\D" ); // 匹配非数字的字符
reg.IsMatch( m ); // 结果：false
reg.IsMatch(); // 结果：true
string m = "1"; 
string n = "%"; 
Regex reg = new Regex( "[a-z0-9]" ); // 匹配小写字母或数字字符 
reg.IsMatch( m ); // 结果：true
reg.IsMatch( n ); // 结果：false

 3、标记符（转义）
\将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符

4、定位符
"定位符"所代表的是一个虚的字符，它代表一个位置 

字符	解释
^	匹配输入字符串的开始位置
$	匹配输入字符串的结束位置
\b	匹配一个单词边界，也就是指单词和空格间的位置
\B	\b的补集，匹配非单词边界

 

string str1 = "hi, nice to meet you!";
string str2 = "hello, nice to meet you!";
Regex reg = new Regex( "^hi.*you!$" ); // 匹配以hi开头，you!结尾的字符
reg.IsMatch( str1 ); // 结果：true
reg.IsMatch( str2 ); // 结果：false
string str1 = "her";
string str2 = "here";
Regex reg = new Regex( "er\b" );
reg.IsMatch( str1 ); // 结果：true
reg.IsMatch( str2 ); // 结果：false
Regex reg = new Regex( "er\B" );
reg.IsMatch( str1 ); // 结果：false
reg.IsMatch( str2 ); // 结果：true

5、重复匹配符 

字符	解释
{n}	匹配前面的子表达式次n必须为正整数
{n,}	匹配前面的子表达式n次以上n必须为正整数
{n,m}	前面的子表达式最少匹配次且最多匹配m次，m和n均必须为正整数，并且n<=m，另外逗号和两个数之间不能有空格
*	匹配前面的子表达式零次或多次，等价于{0,}
+	匹配前面的子表达式一次或多次，等价于 {1,}
?	匹配前面的子表达式零次或一次，等价于 {0,1}

 

string x = "1";
string y = "10";
string z = "100";
Regex reg = new Regex( "\d+" );
reg.IsMatch( x ); // 结果：true
reg.IsMatch( y ); // 结果：true
reg.IsMatch( z ); // 结果：true
Regex reg = new Regex( "\d{2,3}" );
reg.IsMatch( x ); // 结果：false
reg.IsMatch( y ); // 结果：true
reg.IsMatch( z ); // 结果：true

 6、选择匹配符

字符	解释
(x|y)	匹配 x 或 y，[a-z]其实也是一种选择匹配，只不过它只能匹配单个字符，而(x|y)则提供了更大的范围

 

string str1 = "think";
string str2 = "thank";
Regex reg = new Regex( "th(i|a)nk" );
reg.IsMatch( str1 ); // 结果：true
reg.IsMatch( str2 ); // 结果：true

7、十六进制字符
正则表达式中，可以使用 "\xXX" 和 "\uXXXX" 表示一个字符（"X" 表示一个十六进制数）形式字符范围：
\xXX 编号在 0到255 范围的字符，比如：空格可以使用 "\x20" 表示
\uXXXX 任何字符可以使用 "\u" 再加上其编号的4位十六进制数表示，比如：汉字可以使用"[\u4e00-\u9fa5]"表示

二、匹配模式
1、组与非捕获组
正则表达式引擎会记忆"()"中匹配到的内容，作为一个"组"，并且可以通过索引的方式进行引用
表达式中的"\1"用于反向引用表达式中出现的第一个组，"\2"引用表达式中出现的第二个组，则依此类推

string str1 = "Live for nothing,die for something"; 
string str2 = "Live for nothing,die for somebody"; 
Regex reg = new Regex( @"^Live ([a-z]{3}) no([a-z]{5}),die \1 some\2$" ); 
reg.IsMatch( str1 ); // 结果：true
reg.IsMatch( str2 ); // 结果：false
// 输出组中的内容
string str = "Live for nothing,die for something"; 
Regex reg = new Regex( @"^Live for no([a-z]{5}),die for some\1$" ); 
if ( reg.IsMatch( str ) ) { 
    Console.WriteLine( reg.Match( str ).Groups[1].Value ); // 输出：thing（Groups[0]表示整个匹配的字符串）
}
// 也可以根据组名进行索引使用以下格式为标识一个组的名称(?<groupname>…)
string str = "Live for nothing,die for something"; 
Regex reg = new Regex( @"^Live for no(?<g1>[a-z]{5}),die for some\1$" ); 
if ( reg.IsMatch( str ) ) { 
    Console.WriteLine( reg.Match( str ).Groups["g1"].Value ); // 输出：thing
}
// 替换组中的内容
string str = "Live for nothing nothing";
Regex reg = new Regex( @"([a-z]+) \1$" );
if ( reg.IsMatch( str ) ) {
    str = reg.Replace( str, "$1" );
    Console.WriteLine( str ); //输出：Live for nothing
}

在组前加上"?:"表示这是个"非捕获组"，即引擎只匹配但不保存该组的内容

string str = "Live for nothing"; 
Regex reg = new Regex( @"(?:[a-z]+) \1$" );
if ( reg.IsMatch( str ) ) {
    Console.WriteLine( reg.Match( str ).Groups[1].Value ); // 输出：(空) 
}

2、贪婪与非贪婪匹配
正则表达式的引擎是贪婪，只要模式允许，它将匹配尽可能多的字符
可以通过在"重复匹配符"（*,+,{}）后面添加?将匹配模式改成非贪婪 

string str = "Live for nothing nothing,die for something";
Regex reg1 = new Regex( @".*thing" );
if ( reg1.IsMatch( str ) ) {
    Console.WriteLine( reg1.Match( str ).Value ); // 输出：Live for nothing,die for something
}
Regex reg2 = new Regex( @".*?thing" );
if ( reg2.IsMatch( str ) ) {
    Console.WriteLine( reg2.Match( str ).Value ); // 输出：Live for nothing
}

3、回溯与非回溯
使用"(?>…)"方式进行非回溯声明由于正则表达式引擎的贪婪特性，导致它在某些情况下，将进行回溯以获得匹配

string str = "Live for nothing nothing,die for something";
Regex reg1 = new Regex( @".*thing," );
if ( reg1.IsMatch( str ) ) {
    Console.WriteLine( reg1.Match( str ).Value ); // 输出：Live for nothing
}
Regex reg2 = new Regex(@"(?>.*)thing,");
if ( reg2.IsMatch( str ) ) { // 不匹配 
    Console.WriteLine( reg2.Match( str ).Value );
}
//在reg1中，".*"由于其贪婪特性，将一直匹配到字符串的最后，随后匹配"thing"，但在匹配","时失败，此时引擎将回溯，并在"thing,"处匹配成功 
//在reg2中，由于强制非回溯，所以整个表达式匹配失败

4、正反向预查
(?=pattern) 正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串这是一个非获取匹配，也就是说，只匹配但不保存该组的内容供以后使用
(?!pattern) 反向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串这也是一个非获取匹配

string str1 = "Windows 98";
string str2 = "Windows 2000";
string str3 = "Windows XP";
Regex reg1 = new Regex( @"Windows (?=98|2000)" );
Regex reg2 = new Regex( @"Windows (?!98|2000)" );
reg1.IsMatch( str1 ); // 结果：true
reg1.IsMatch( str2 ); // 结果：true
reg1.IsMatch( str3 ); // 结果：false
reg2.IsMatch( str1 ); // 结果：false
reg2.IsMatch( str2 ); // 结果：false
reg2.IsMatch( str3 ); // 结果：true