一、符号解释
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