正则表达式

一、符号解释

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