正则表达式回顾
正则表达式的知识可能是不少编程人员最烦恼的事儿了。如果你还没有规则表达式方面的知识的话,建议从正则表达式的基础知识入手。前参见 正则表达式语法。
下面就来研究C#中的正则表达式,C#中的正则表达式包含在.NET基础雷库的一个名称空间下,这个名称空间就是System.Text.RegularExpressions。该名称空间包括8个类,1个枚举,1个委托。他们分别是:
Capture: 包含一次匹配的结果;
CaptureCollection: Capture的序列;
Group: 一次组记录的结果,由Capture继承而来;
GroupCollection:表示捕获组的集合
Match: 一次表达式的匹配结果,由Group继承而来;
MatchCollection: Match的一个序列;
MatchEvaluator: 执行替换操作时使用的委托;
Regex:编译后的表达式的实例。
RegexCompilationInfo:提供编译器用于将正则表达式编译为独立程序集的信息
RegexOptions 提供用于设置正则表达式的枚举值
Regex类中还包含一些静态的方法:
Escape: 对字符串中的regex中的转义符进行转义;
IsMatch: 如果表达式在字符串中匹配,该方法返回一个布尔值;
Match: 返回Match的实例;
Matches: 返回一系列的Match的方法;
Replace: 用替换字符串替换匹配的表达式;
Split: 返回一系列由表达式决定的字符串;
Unescape:不对字符串中的转义字符转义。
下面介绍他们的用途:
先看一个简单的匹配例子,我们首先从使用Regex、Match类的简单表达式开始学习。 Match m = Regex.Match("abracadabra", "(a|b|r)+"); 我们现在有了一个可以用于测试的Match类的实例,例如:if (m.Success){},如果想使用匹配的字符串,可以把它转换成一个字符串: MesaageBox.Show("Match="+m.ToString()); 这个例子可以得到如下的输出: Match=abra。这就是匹配的字符串了。
Regex 类表示只读正则表达式类。它还包含各种静态方法(在下面的实例中将逐一介绍),允许在不显式创建其他类的实例的情况下使用其他正则表达式类。
以下代码示例创建了 Regex 类的实例并在初始化对象时定义一个简单的正则表达式。声明一个Regex对象变量:Regex objAlphaPatt;,接着创建Regex对象的一个实例,并定义其规则:objAlphaPatt=new Regex("[^a-zA-Z]");
IsMatch方法指示 Regex 构造函数中指定的正则表达式在输入字符串中是否找到匹配项。这是我们使用C#正则表达式时最常用的方法之一。下面的例子说明了IsMatch方法的使用:
if( !objAlphaPatt.IsMatch("testisMatchMethod"))
lblMsg.Text = "匹配成功";
else
lblMsg.Text = "匹配不成功";
这段代码执行的结果是“匹配成功”
if( ! objAlphaPatt.IsMatch("testisMatchMethod7654298"))
lblMsg.Text = "匹配成功";
else
lblMsg.Text = "匹配不成功";
这段代码执行的结果是“匹配不成功”
Escape方法表示把转义字符作为字符本身使用,而不再具有转义作用,最小的元字符集(\、*、+、?、|、{、[、(、)、^、$、.、# 和空白)。Replace方法则是用指定的替换字符串替换由正则表达式定义的字符模式的所有匹配项。看下面的例子,还是使用上面定义的Regex对象:objAlphaPatt.Replace("this [test] ** replace and escape" ,Regex.Escape("()"));他的返回结果是:this\(\)\(\)test\(\)\(\)\(\)\(\)\(\)replace\(\)and\(\)escape,如果不是Escape的话,则返回结果是:this()()test()()()()()replace()and()escape,Unescape 反转由 Escape 执行的转换,但是,Escape 无法完全反转 Unescape。
Split方法是把由正则表达式匹配项定义的位置将输入字符串拆分为一个子字符串数组。例如:
Regex r = new Regex("-"); // Split on hyphens.
string[] s = r.Split("first-second-third");
for(int i=0;i<s.Length;i++)
{
Response.Write(s[i]+"<br>");
}
执行的结果是:
First
Second
Third
看上去和String的Split方法一样,但string的Split方法在由正则表达式而不是一组字符确定的分隔符处拆分字符串。
Match方法是在输入字符串中搜索正则表达式的匹配项,并Regex 类的 Match 方法返回 Match 对象,Match 类表示正则表达式匹配操作的结果。下面的例子演示Match方法的使用,并利用Match对象的Group属性返回Group对象:
string text = @"public string testMatchObj string s string match ";
string pat = @"(\w+)\s+(string)";
// Compile the regular expression.
Regex r = new Regex(pat, RegexOptions.IgnoreCase);
// Match the regular expression pattern against a text string.
Match m = r.Match(text);
int matchCount = 0;
while (m.Success)
{
Response.Write("Match"+ (++matchCount) + "<br>");
for (int i = 1; i <= 2; i++)
{
Group g = m.Groups[i];
Response.Write("Group"+i+"='" + g + "'" + "<br>");
CaptureCollection cc = g.Captures;
for (int j = 0; j < cc.Count; j++)
{
Capture c = cc[j];
Response.Write("Capture"+j+"='" + c + "', Position="+c.Index + "<br>");
}
}
m = m.NextMatch();
}
该事例运行结果是:
Match1
Group1='public'
Capture0='public', Position=0
Group2='string'
Capture0='string', Position=7
Match2
Group1='testMatchObj'
Capture0='testMatchObj', Position=14
Group2='string'
Capture0='string', Position=27
Match3
Group1='s'
Capture0='s', Position=34
Group2='string'
Capture0='string', Position=36
MatchCollection 类表示成功的非重叠匹配的只读的集合,MatchCollection 的实例是由 Regex.Matches 属性返回的,下面的实例说明了通过在输入字符串中找到所有与Regex中指定的匹配并填充 MatchCollection。
MatchCollection mc;
Regex r = new Regex("match");
mc = r.Matches("matchcollectionregexmatchs");
for (int i = 0; i < mc.Count; i++)
{
Response.Write( mc[i].Value + " POS:" + mc[i].Index.ToString() + "<br>");
}
该实例运行的结果是:
match POS:0
match POS:20
正则表达式对初学者来说,往往是一种神秘的东西,实际上,仔细研究一下也就是那么回事儿,没有多么的难。希望这篇文章对你有所帮助。
又重新学了一遍C#的正则表达式,温故而知新,C#的正则就用一句话概括吧:很好很强大! 这里做个笔记,笔记的相关内容多数摘自MSDN。
Regex 类表示不可变(只读)的正则表达式。它还包含各种静态方法,允许在不显式创建其他类的实例的情况下使用其他正则表达式类。
Match 类表示正则表达式匹配操作的结果。Match 类的 Match.Success 匹配是否成功。Match.Index 返回第一个匹配的位置。
MatchCollection 类表示成功的【非重叠】匹配项的序列。MatchCollection 的实例是由 Regex.Matches 方法返回的。
GroupCollection 类表示被捕获的组的集合,并在单个匹配项中返回该捕获组的集合。GroupCollection 的实例在 Match.Groups 属性返回的集合中返回。
CaptureCollection 类表示捕获的子字符串的序列,并返回由单个捕获组所执行的捕获集。由于限定符,捕获组可以在单个匹配中捕获多个字符串。Captures 属性(CaptureCollection 类的对象)作为 Match 和 Group 类的成员提供,目的是便于对捕获的子字符串的集合进行访问。
Group 类表示来自单个捕获组的结果。因为 Group 可以在单个匹配中捕获零个、一个或更多的字符串(使用限定符),所以它包含 Capture 对象的集合。因为 Group 继承自 Capture,所以可以直接访问最后捕获的子字符串(Group 实例本身等价于 Captures 属性返回的集合的最后一项)。
Capture 类包含来自单个子表达式捕获的结果。
为了更好地理解上面类的相互关系,我把msdn的示例扩展了一下:
using System;
using System.Text.RegularExpressions;
/// <summary>
/// 2008-10-07 copyright 可爱的猴子
/// http://www.dreamdu.com/blog/
/// </summary>
public class RegexTest
{
public static void Main()
{
Regex r = new Regex("(Abc)+");
string str = "XYZAbcAbcAbcXYZAbcAb";
MatchCollection mc = r.Matches(str);
Console.WriteLine("---------------------Group-------MatchCollection={0}", mc.Count);
foreach (Match mt in mc)
{
Console.WriteLine("match = {0}", mt.Value);
Console.WriteLine("--------------Group={0}", mt.Groups.Count);
foreach (Group gc in mt.Groups)
{
Console.WriteLine("Group value is:{0}. Index is:{1}",gc.Value, gc.Index);
Console.WriteLine("-------Gapture={0}",gc.Captures.Count);
foreach (Capture gg in gc.Captures)
{
Console.WriteLine("Capture value is:{0}. Index is:{1}",gg.Value, gg.Index);
}
}
}
Console.WriteLine("---------------------Capture-------MatchCollection={0}",mc.Count);
foreach (Match mt in mc)
{
Console.WriteLine("match = {0}",mt.Value);
Console.WriteLine("--------------Capture={0}",mt.Captures.Count);
foreach (Capture gc in mt.Captures)
{
Console.WriteLine("Group value is:{0}. Index is:{1}",gc.Value, gc.Index);
}
}
Match m = r.Match(str);
GroupCollection gcc = m.Groups;
Console.WriteLine("--------------------------------GroupCollection={0}",gcc.Count);
foreach (Group gt in gcc)
{
CaptureCollection cc = gt.Captures;
Console.WriteLine("--------------Captures={0}",cc.Count);
foreach (Capture ccnp in gt.Captures)
{
Console.WriteLine("Capture value is:{0}. Index is:{1}",ccnp.Value, ccnp.Index);
}
}
CaptureCollection ccn = m.Captures;
Console.WriteLine("--------------------------------CaptureCollection={0}",ccn.Count);
foreach (Capture gt in ccn)
{
Console.WriteLine("Capture value is:{0}. Index is:{1}",gt.Value, gt.Index);
}
}
}
C#正则表达式 — 语言元素
正则表达式中的语言元素,有些模糊的内容我加入了简单的示例。
1,@
禁止转义CS字符串(这个是我加的。与正则无关)
2,字符转义
大多数重要的正则表达式语言运算符都是非转义的单个字符。转义符 \(单个反斜杠)通知正则表达式分析器反斜杠后面的字符不是运算符。例如,分析器将星号 (*) 视为重复限定符,而将后跟星号的反斜杠 (\*) 视为 Unicode 字符 002A。
下表中列出的字符转义在正则表达式和替换模式中都会被识别。
一般字符 除 . $ ^ { [ ( | ) * + ? \ 外,其他字符与自身匹配。
\a 与响铃(警报)\u0007 匹配。
\b 如果在 [] 字符类中,则与退格符 \u0008 转义字符 \b 是一个特例。在正则表达式中,\b 表示单词边界(在 \w 和 \W 之间),不过,在 [] 字符类中,\b 表示退格符。在替换模式中,\b 始终表示退格符。
\t 与 Tab 符 \u0009 匹配。
\r 与回车符 \u000D 匹配。
\v 与垂直 Tab 符 \u000B 匹配。
\f 与换页符 \u000C 匹配。
\n 与换行符 \u000A 匹配。
\e 与 Esc 符 \u001B 匹配。
\040 将 ASCII 字符匹配为八进制数(最多三位);如果没有前导零的数字只有一位数或者与捕获组号相对应,则该数字为后向引用。(有关更多信息,请参见反向引用。) 例如,字符 \040 表示空格。
\x20 使用十六进制表示形式(恰好两位)与 ASCII 字符匹配。
\cC 与 ASCII 控制字符匹配;例如,\cC 为 Ctrl-C。
\u0020 使用十六进制表示形式(恰好四位)与 Unicode 字符匹配。
\ 在后面带有不识别为转义符的字符时,与该字符匹配。例如,\* 与 \x2A 相同。
3,替换
只在替换模式中允许替换。对于正则表达式中的类似功能,使用后向引用(如 \1)。有关后向引用的详细信息,请参见 反向引用 和后向引用构造。
字符转义和替换是在替换模式中识别的唯一的特殊构造。下面几部分描述的所有语法构造只允许出现在正则表达式中;替换模式中不识别它们。例如,替换模式 a*${txt}b 会插入字符串“a*”,该字符串后跟按 txt 捕获组匹配的子字符串,该子字符串后跟字符串“b”(如果有)。在替换模式中,* 字符不会识别为元字符。与此类似,在正则表达式匹配模式中不识别 $ 模式。在正则表达式中,$ 指定字符串的结尾。
下表显示如何定义命名并编号的替换模式。
字符 说明
$ 数字 替换按组号 number(十进制)匹配的最后一个子字符串。
${name} 替换由 (?
$$ 替换单个“$”字符。
$& 替换完全匹配本身的一个副本。
$` 替换匹配前的输入字符串的所有文本。
$’ 替换匹配后的输入字符串的所有文本。
$+ 替换最后捕获的组。
$_ 替换整个输入字符串。
using System; using System.Text.RegularExpressions; /// <summary> /// 2008-10-07 copyright 可爱的猴子 /// http://www.dreamdu.com/blog/ /// </summary> public class RegexTest { public static void Main() { string str = "ab cb db bb"; string pattern = @"(?<txt>b{1})"; foreach (Match m in Regex.Matches(str,pattern)) { Console.WriteLine("{0}--{1}",m.Value, m.Index); } //str = Regex.Replace(str, pattern, "a*${txt}"); str = Regex.Replace(str, pattern, "a*$1"); Console.WriteLine(str); } }
4,字符类
字符类表示一组可以匹配输入字符串的字符。组合原义字符、转义符和字符类以构成正则表达式模式。
[字符分组] (正字符分组。) 匹配指定字符分组内的任何字符。字符分组由串连的一个或多个原义字符、转义符、字符范围或字符类组成。例如,若要指定所有元音字母,使用 [aeiou]. 若要指定所有标点符号和十进制数字符,使用代码 [\p{P}\d]。
[^字符分组] (负字符分组。) 匹配不在指定字符分组内的任何字符。字符分组由串连的一个或多个原义字符、转义符、字符范围或字符类组成。前导符 (^) 是强制的,指示字符分组为负字符分组,而不是正字符分组。例如,若要指定除元音字母以外的所有字符,使用 [^aeiou]. 若要指定除标点符号和十进制数字符以外的所有字符,使用 [^\p{P}\d]。
[第一个字符-最后一个字符] (字符范围。) 匹配字符范围中的任何字符。字符范围是一系列连续的字符,定义的方法是:指定系列中的第一个字符,连字符 (-),然后指定系列中的最后一个字符。如果两个字符具有相邻的 Unicode 位,则这两个字符是连续的。可以串连两个或更多字符范围。例如,若要指定从“0”至“9”的十进制数范围、从“a”至“f”的小写字母范围,以及从“A”至“F”的大写字母范围,使用 [0-9a-fA-F]。
. (句点字符。) 匹配除 \n 以外的任何字符。如果已用 Singleline 选项做过修改,则句点字符可与任何字符匹配。有关更多信息,请参见正则表达式选项。请注意,正字符分组或负字符分组中的句点字符(方括号内的句点)将被视为原义句点字符,而非字符类。
\p{ 名称 } 匹配通过名称(例如 Ll、Nd、Z、IsGreek 和 IsBoxDrawing)指定的 Unicode 通用类别或命名块中的任何字符。
\P{ 名称 } 匹配不在名称中指定的 Unicode 通用类别或命名块中的任何字符。
\w 与任何单词字符匹配。等效于 Unicode 通用类别 [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]。如果通过 ECMAScript 选项指定了符合 ECMAScript 的行为,则 \w 等效于 [a-zA-Z_0-9]。
\W 与任何非单词字符匹配。等效于 Unicode 通用类别 [^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]。如果通过 ECMAScript 选项指定了符合 ECMAScript 的行为,则 \W 等效于 [^a-zA-Z_0-9]。
\s 与任何空白字符匹配。等效于转义符和 Unicode 通用类别 [\f\n\r\t\v\x85\p{Z}]。如果通过 ECMAScript 选项指定了符合 ECMAScript 的行为,则 \s 等效于 [ \f\n\r\t\v]。
\S 与任何非空白字符匹配。等效于转义符和 Unicode 通用类别 [^\f\n\r\t\v\x85\p{Z}]。如果通过 ECMAScript 选项指定了符合 ECMAScript 的行为,则 \S 等效于 [^ \f\n\r\t\v]。
\d 与任何十进制数字匹配。对于 Unicode 类别的 ECMAScript 行为,等效于 \p{Nd},对于非 Unicode 类别的 ECMAScript 行为,等效于 [0-9]。
\D 与任何非数字字符匹配。对于 Unicode 类别的 ECMAScript 行为,等效于 \P{Nd},对于非 Unicode 类别的 ECMAScript 行为,等效于 [^0-9] 。
4.1,字符类减法 — 就只听听名字就知道很爽了!
语法: [基本分组-[排除分组]]
[a-z-[m-p]] 从a-z排除m-p
[a-z-[d-w-[m-o]]] 从d-w排除m-o,为组合一,再在a-z中排除组合一。
5,正则表达式选项
就是RegexOptions啦,这个有ECMAScript选项,不错!搞javascript正则的应该比较熟悉!我感觉IgnoreCase,Multiline,Compiled(提高效率),ECMAScript比较常用。
RegexOption 成员 内联字符 说明
None N/A 指定不设置任何选项。
IgnoreCase i 指定不区分大小写的匹配。
Multiline m 指定多行模式。更改 ^ 和 $ 的含义,以使它们分别与任何行的开头和结尾匹配,而不只是与整个字符串的开头和结尾匹配。
ExplicitCapture n 指定唯一有效的捕获是显式命名或编号的 (?<name>…) 形式的组。这允许圆括号充当非捕获组,从而避免了由 (?:…) 导致的语法上的笨拙。
Compiled N/A 指定正则表达式将被编译为程序集。生成该正则表达式的 Microsoft 中间语言 (MSIL) 代码;以较长的启动时间为代价,得到更快的执行速度。
Singleline s 指定单行模式。更改句点字符 (.) 的含义,以使它与每个字符(而不是除 \n 之外的所有字符)匹配。
IgnorePatternWhitespace x 指定从模式中排除非转义空白并启用数字符号 (#) 后面的注释。(有关转义空白字符的列表,请参见字符转义。) 请注意,空白永远不会从字符类中消除。
RightToLeft N/A 指定搜索是从右向左而不是从左向右进行的。具有此选项的正则表达式将移动到起始位置的左边而不是右边。(因此,起始位置应指定为字符串的结尾而不是开头。) 为了避免构造具有无限循环的正则表达式的可能性,此选项不能在中流指定。但是,(?<) 回顾后发构造提供了可用作子表达式的类似替代物。RightToLeft 只更改搜索方向。它不会反转所搜索的子字符串。预测先行和回顾后发断言不改变:预测先行向右搜索;回顾后发向左搜索。
ECMAScript N/A 指定已为表达式启用了符合 ECMAScript 的行为。此选项仅可与 IgnoreCase 和 Multiline 标志一起使用。将 ECMAScript 同任何其他标志一起使用将导致异常。
CultureInvariant N/A 指定忽略语言中的区域性差异。有关更多信息,请参见在 RegularExpressions 命名空间中执行不区分区域性的操作。
6,原子零宽度断言
下表中描述的元字符不会使引擎在字符串中前进或使用字符。它们只是根据字符串中的当前位置使匹配成功或失败。例如,^ 指定当前位置在行或字符串的开头。因此,正则表达式 ^FTP 只会返回那些在行的开头出现的字符串“FTP”的匹配项。
^ 指定匹配必须出现在字符串的开头或行的开头。有关更多信息,请参见正则表达式选项中的Multiline 选项。
$ 指定匹配必须出现在以下位置:字符串结尾、字符串结尾处的\n之前或行的结尾。有关更多信息,请参见正则表达式选项中的 Multiline 选项。
\A 指定匹配必须出现在字符串的开头(忽略 Multiline 选项)。
\Z 指定匹配必须出现在字符串的结尾或字符串结尾处的 \n 之前(忽略 Multiline 选项)。
\z 指定匹配必须出现在字符串的结尾(忽略 Multiline 选项)。
\G 指定匹配必须出现在上一个匹配结束的地方。与Match.NextMatch()一起使用时,此断言确保所有匹配都是连续的。
\b 指定匹配必须出现在\w(字母数字)和\W(非字母数字)字符之间的边界上。匹配必须出现在单词边界上(即出现在由任何非字母数字字符分隔的单词中第一个或最后一个字符上)。匹配也可以出现在字符串结尾处的单词边界上。
\B 指定匹配不得出现在 \b 边界上。
7,限定符
限定符将可选数量的数据添加到正则表达式。限定符表达式应用于紧挨着它前面的字符、组或字符类。.NET Framework 正则表达式支持最小匹配 (lazy) 限定符。
下表描述了影响匹配的元字符。数量 n 和 m 是整数常数。
* 匹配前导元素零次或零次以上。该限定符等效于 {0,}。* 是贪婪限定符,对应的非贪婪限定符是 *?。
+ 匹配前导元素一次或多次。它等效于 {1,}。+ 是贪婪限定符,对应的非贪婪限定符是 +?。
? 匹配前导元素零次或一次。它等效于 {0,1}。? 是贪婪限定符,对应的非贪婪限定符是 ??。
{n} 匹配前导元素恰好 n 次。{n} 是贪婪限定符,对应的非贪婪限定符为 {n}?。
{n,} 匹配前导元素至少 n 次。{n,} 是贪婪限定符,对应的非贪婪限定符为 {n}?。
{n,m} 匹配前导元素至少 n 次,但不超过 m 次。{n,m} 是贪婪限定符,对应的非贪婪限定符为 {n,m}?。
*? 匹配前导元素零次或零次以上,但次数尽可能少。它是与贪婪限定符 * 相对的惰性限定符。
+? 匹配前导元素一次或多次,但次数尽可能少。它是与贪婪限定符 + 相对的惰性限定符。
?? 匹配前导元素零次或一次,但次数尽可能少。它是与贪婪限定符 ? 相对的惰性限定符。
{n}? 匹配前导元素恰好 n 次。它是与贪婪限定符 {n}+ 相对的惰性限定符。
{n,}? 匹配前导元素至少 n 次,但次数尽可能少。它是与贪婪限定符 {n,} 相对的惰性限定符。
{n,m}? 匹配前导元素 n 到 m 次,但次数尽可能少。它是与贪婪限定符 {n,m} 相对的惰性限定符。
贪婪限定符与惰性限定符的区别
一些限定符有两种版本:
贪婪版本:贪婪限定符尝试尽可能多地匹配它所应用到的元素。
非贪婪(惰性)版本:非贪婪限定符尝试尽可能少地匹配它所应用到的元素。
例如:\b.*([0-9]{4})\b 与 \b.*?([0-9]{4})\b”
在大多数情况下,带有贪婪限定符和惰性限定符的正则表达式将返回相同的匹配项。在与句点 (. ) 元字符(该元字符匹配任何字符)一起使用时,它们多数情况下会返回不同的结果。
8,分组构造
分组构造描述了正则表达式的子表达式,通常用于捕获输入字符串的子字符串。
(子表达式) 捕获匹配的子表达式(或非捕获组;有关更多信息,请参见正则表达式选项中的 ExplicitCapture 选项)。使用 () 的捕获基于左括号按顺序从 1 开始自动编号。捕获元素编号为零的第一个捕获是由整个正则表达式模式匹配的文本。
(?<name>子表达式) 将匹配的子表达式捕获到一个组名称或编号名称中。用于 name 的字符串不得包含任何标点符号,并且不能以数字开头。可以使用单引号替代尖括号,例如 (?’name’)。
(?<name1-name2>子表达式) (平衡组定义。) 删除先前定义的 name2 组的定义,并在 name1 组中存储先前定义的 name2 组和当前组之间的间隔。如果未定义 name2 组,则匹配将回溯。由于删除 name2 的最后一个定义会显示 name2 的先前定义,因此该构造允许将 name2 组的捕获堆栈用作计数器,用于跟踪嵌套构造(如括号)。在此构造中,name1 是可选的。可以使用单引号替代尖括号,例如 (?’name1-name2′)。
(?:子表达式) (非捕获组。) 不捕获由子表达式匹配的子字符串。
(?imnsx-imnsx:子表达式) 应用或禁用子表达式中指定的选项。例如,(?i-s: ) 将打开不区分大小写并禁用单行模式。有关更多信息,请参见正则表达式选项。
(?=子表达式) (零宽度正预测先行断言。) 仅当子表达式在此位置的右侧匹配时才继续匹配。例如,\w+(?=\d) 与后跟数字的单词匹配,而不与该数字匹配。此构造不会回溯。
(?!子表达式) (零宽度负预测先行断言。) 仅当子表达式不在此位置的右侧匹配时才继续匹配。例如,\b(?!un)\w+\b 与不以 un 开头的单词匹配。
(?<=子表达式) (零宽度正回顾后发断言。) 仅当子表达式在此位置的左侧匹配时才继续匹配。例如,(?<=19)99 与跟在 19 后面的 99 的实例匹配。此构造不会回溯。
(?<!子表达式) (零宽度负回顾后发断言。) 仅当子表达式不在此位置的左侧匹配时才继续匹配。
(?> 子表达式) (非回溯子表达式(也称为“贪婪”子表达式)。) 该子表达式仅完全匹配一次,然后就不会逐段参与回溯了。(也就是说,该子表达式仅与可由该子表达式单独匹配的字符串匹配。)
默认情况下,如果匹配未成功,回溯会搜索其他可能的匹配。如果已知无法成功回溯,可以使用非回溯子表达式避免不必要的搜索,从而提高性能。
命名捕获基于左括号按从左到右的顺序依次编号(与非命名捕获类似),但在对所有非命名捕获进行计数之后才开始对命名捕获编号。例如,模式 ((?<One>abc)\d+)?(?<Two>xyz)(.*)按编号和名称产生下列捕获组。(编号为 0 的第一个捕获总是指整个模式)。
编号 名称 模式
0 0(默认名称) ((?<One>abc)\d+)?(?<Two>xyz)(.*)
1 1(默认名称) ((?<One>abc)\d+)
2 2(默认名称) (.*)
3 1 (?<One>abc)
4 2 (?<Two>xyz)
平衡组匹配简直太强大啦!!下面是匹配尖括号<与>的的数量是否相等,详见msdn的示例
string pattern = "^[^<>]*(((?’Open’<)[^<>]*)+((?’Close-Open’>)[^<>]*)+)*(?(Open)(?!))$”;
9,后向引用构造
\数字 后向引用。例如,(\w)\1 查找双写的单词字符。
\k<name> 命名后向引用。例如,(?<char>\w)\k<char> 查找双写的单词字符。表达式 (?<43>\w)\43 执行同样的操作。可以使用单引号替代尖括号,例如 \k’char’。
using System; using System.Text.RegularExpressions; /// <summary> /// 2008-10-07 copyright 可爱的猴子 /// http://www.dreamdu.com/blog/ /// </summary> public class RegexTest { public static void Main() { string str = "ab cb dbbb abab"; string pattern = @"(?<ab>ab)\k<ab>"; foreach (Match m in Regex.Matches(str,pattern)) { Console.WriteLine("{0}--{1}",m.Value, m.Index); } } }
10,替换构造
下表列出了用于修改正则表达式以允许进行二者之一/或匹配的特殊字符。
| 与以 |(竖线)字符分隔的术语中的任何一项匹配;例如, cat|dog|tiger。使用最左侧的成功匹配。
(?( 表达式 )yes|no) 如果表达式在此位置匹配,则与“yes”部分匹配;否则,与“no”部分匹配。“no”部分可省略。表达式可以是任何有效的子表达式,但它将变为零宽度断言,因此该语法等效于 (?(?=expression)yes|no)。请注意,如果表达式是命名组的名称或捕获组编号,则替换构造将解释为捕获测试(在本表的下一行对此进行了描述)。若要避免在这些情况下产生混淆,则可以显式拼出内部 (?=expression)。
(?( name )yes|no) 如果命名捕获字符串有匹配,则与“yes”部分匹配;否则,与“no”部分匹配。“no”部分可省略。如果给定的名称不与此表达式中使用的捕获组的名称或编号对应,则替换构造将解释为表达式测试(在本表的上一行进行了描述)。
您可能感兴趣的内容
<a\s*href=\"/search_m/(?<city>\d+)/(?<type>\d+)_d(?<area>\d+)\">(?<areaname>.*?)</a>
<li><a\s*href=\"/search_m/(?<city>\d+)/(?<type>\d+)_b(?<subarea>\d+)\"[^>]+>(?<subareaname>.*?)</a></li>
实例:
<a href="/shop/510320" class="BL TMuchBigger_2 Bold" title="白家大院" onclick = "pageTracker._trackPageview('dp_search_beijing_shopname');">白家大院</a>
</p>
<div class="ShopScore">
<div class="Score1">20</div>
<div class="Score2">31</div>
<div class="Score3">26</div>
<div class="AvgPrice">¥242</div>
</div>
<p class="Blank"></p>
</div>
<div class="ShopItem">
<div class="ShopContent">
地址: 海淀区苏州街15号乐家花园内
62658851
<br />标签: 商务宴请 官府菜 有花园<br />
正则表达式:
<a\s*href=\"(/shop/\d+)\"[^>]+>\s*([^\00-\ff]+)\s*</a>\s*</p>\s*<[^>]+>\s*<[^>]+>\s*(\d+)\s*</div>\s*<[^>]+>\s*(\d+)\s*</div>\s*<[^>]+>\s*(\d+)\s*</div>
\s*<[^>]+>\s*¥(\d+)\s*</div>\s*</div>\s*<[^>]+>\s*</p>\s*</div>\s*<[^>]+>\s*<[^>]+>\s*([^\00-\ff]+)\s* \s*(\d+)\s*<[^>]+>\s*([^\00-\ff]+)
提取内容分组构造:
GROUP[1]: '/shop/510320'
GROUP[2]: '白家大院'
GROUP[3]: '20'
GROUP[4]: '31'
GROUP[5]: '26'
GROUP[6]: '242'
GROUP[7]: '地址: 海淀区苏州街15号乐家花园内'
GROUP[8]: '62658851'
GROUP[9]: '标签: 商务宴请 官府菜 有花园<br />'
----------------------------------------------------------------------------------------
实例:
<tr>
<td class="odd"><a href="https://files.cnblogs.com/article/info/96/96231.htm">地皇传说</a></td>
<td class="even"><a href="https://files.cnblogs.com/article/html/96/96231/index.shtml" target="_blank">孤心情劫 第一百零四章 孤心之心</a></td>
<td class="odd">孤独漂流</td>
<td class="even">449K</td>
<td class="odd" align="center">07-09-16</td>
<td class="even" align="center">连载</td>
</tr>
正则表达式:
<tr>\s*<[^>]+>\s*<a href=\"(.*)\">([^<].*)</a>\s*</td>\s*<[^>]+><a href=\"(.*)\"\s*target="_blank">([^<].*)</a></td>\s*<[^>]+>([^<].*)</td>\s*<[^>]+>([^<].*)</td>\s*<[^>]+>([^<].*)</td>\s*<[^>]+>([^<].*)</td>\s*</tr>
提取内容分组构造:
GROUP[1]: '/files/article/info/96/96231.htm'
GROUP[2]: '地皇传说'
GROUP[3]: '/files/article/html/96/96231/index.shtml'
GROUP[4]: '孤心情劫 第一百零四章 孤心之心'
GROUP[5]: '孤独漂流'
GROUP[6]: '449K'
GROUP[7]: '07-09-16'
GROUP[8]: '连载'
正则表达式30分钟入门教程
版本:v2.3 (2008-4-13) 作者:deerchao 转载请注明来源
目录
- 本文目标
- 如何使用本教程
- 正则表达式到底是什么东西?
- 入门
- 测试正则表达式
- 元字符
- 字符转义
- 重复
- 字符类
- 分枝条件
- 反义
- 分组
- 后向引用
- 零宽断言
- 负向零宽断言
- 注释
- 贪婪与懒惰
- 处理选项
- 平衡组/递归匹配
- 还有些什么东西没提到
- 联系作者
- 最后,来点广告...
- 网上的资源及本文参考文献
- 更新说明
本文目标
30分钟内让你明白正则表达式是什么,并对它有一些基本的了解,让你可以在自己的程序或网页里使用它。
如何使用本教程
最重要的是——请给我30分钟,如果你没有使用正则表达式的经验,请不要试图在30秒内入门——除非你是超人 :)
别被下面那些复杂的表达式吓倒,只要跟着我一步一步来,你会发现正则表达式其实并没有你想像中的那么困难。当然,如果你看完了这篇教程之后,发现自己明白了很多,却又几乎什么都记不得,那也是很正常的——我认为,没接触过正则表达式的人在看完这篇教程后,能把提到过的语法记住80%以上的可能性为零。这里只是让你明白基本的原理,以后你还需要多练习,多使用,才能熟练掌握正则表达式。
除了作为入门教程之外,本文还试图成为可以在日常工作中使用的正则表达式语法参考手册。就作者本人的经历来说,这个目标还是完成得不错的——你看,我自己也没能把所有的东西记下来,不是吗?
清除格式 文本格式约定:专业术语 元字符/语法格式 正则表达式 正则表达式中的一部分(用于分析) 对其进行匹配的源字符串 对正则表达式或其中一部分的说明
隐藏边注 本文右边有一些注释,主要是用来提供一些相关信息,或者给没有程序员背景的读者解释一些基本概念,通常可以忽略。
正则表达式到底是什么东西?
字符是计算机软件处理文字时最基本的单位,可能是字母,数字,标点符号,空格,换行符,汉字等等。字符串是0个或更多个字符的序列。文本也就是文字,字符串。说某个字符串匹配某个正则表达式,通常是指这个字符串里有一部分(或几部分分别)能满足表达式给出的条件。
在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说,正则表达式就是记录文本规则的代码。
很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard),也就是*和?。如果你想查找某个目录下的所有的Word文档的话,你会搜索*.doc。在这里,*会被解释成任意的字符串。和通配符类似,正则表达式也是用来进行文本匹配的工具,只不过比起通配符,它能更精确地描述你的需求——当然,代价就是更复杂——比如你可以编写一个正则表达式,用来查找所有以0开头,后面跟着2-3个数字,然后是一个连字号“-”,最后是7或8位数字的字符串(像010-12345678或0376-7654321)。
入门
学习正则表达式的最好方法是从例子开始,理解例子之后再自己对例子进行修改,实验。下面给出了不少简单的例子,并对它们作了详细的说明。
假设你在一篇英文小说里查找hi,你可以使用正则表达式hi。
这几乎是最简单的正则表达式了,它可以精确匹配这样的字符串:由两个字符组成,前一个字符是h,后一个是i。通常,处理正则表达式的工具会提供一个忽略大小写的选项,如果选中了这个选项,它可以匹配hi,HI,Hi,hI这四种情况中的任意一种。
不幸的是,很多单词里包含hi这两个连续的字符,比如him,history,high等等。用hi来查找的话,这里边的hi也会被找出来。如果要精确地查找hi这个单词的话,我们应该使用\bhi\b。
\b是正则表达式规定的一个特殊代码(好吧,某些人叫它元字符,metacharacter),代表着单词的开头或结尾,也就是单词的分界处。虽然通常英文的单词是由空格,标点符号或者换行来分隔的,但是\b并不匹配这些单词分隔字符中的任何一个,它只匹配一个位置。
如果需要更精确的说法,\b匹配这样的位置:它的前一个字符和后一个字符不全是(一个是,一个不是或不存在)\w。
假如你要找的是hi后面不远处跟着一个Lucy,你应该用\bhi\b.*\bLucy\b。
这里,.是另一个元字符,匹配除了换行符以外的任意字符。*同样是元字符,不过它代表的不是字符,也不是位置,而是数量——它指定*前边的内容可以连续重复出现任意次以使整个表达式得到匹配。因此,.*连在一起就意味着任意数量的不包含换行的字符。现在\bhi\b.*\bLucy\b的意思就很明显了:先是一个单词hi,然后是任意个任意字符(但不能是换行),最后是Lucy这个单词。
换行符就是'\n',ASCII编码为10(十六进制0x0A)的字符。
如果同时使用其它元字符,我们就能构造出功能更强大的正则表达式。比如下面这个例子:
0\d\d-\d\d\d\d\d\d\d\d匹配这样的字符串:以0开头,然后是两个数字,然后是一个连字号“-”,最后是8个数字(也就是中国的电话号码。当然,这个例子只能匹配区号为3位的情形)。
这里的\d是个新的元字符,匹配一位数字(0,或1,或2,或……)。-不是元字符,只匹配它本身——连字符或者减号。
为了避免那么多烦人的重复,我们也可以这样写这个表达式:0\d{2}-\d{8}。 这里\d后面的{2}({8})的意思是前面\d必须连续重复匹配2次(8次)。
测试正则表达式
其它可用的测试工具:
如果你不觉得正则表达式很难读写的话,要么你是一个天才,要么,你不是地球人。正则表达式的语法很令人头疼,即使对经常使用它的人来说也是如此。由于难于读写,容易出错,所以找一种工具对正则表达式进行测试是很有必要的。
由于在不同的环境下正则表达式的一些细节是不相同的,本教程介绍的是微软 .Net Framework 2.0下正则表达式的行为,所以,我向你介绍一个.Net下的工具Regex Tester。首先你确保已经安装了.Net Framework 2.0,然后下载Regex Tester。这是个绿色软件,下载完后打开压缩包,直接运行RegexTester.exe就可以了。
下面是Regex Tester运行时的截图:
元字符
现在你已经知道几个很有用的元字符了,如\b,.,*,还有\d.正则表达式里还有更多的元字符,比如\s匹配任意的空白符,包括空格,制表符(Tab),换行符,中文全角空格等。\w匹配字母或数字或下划线或汉字等。
对中文/汉字的特殊处理是由.Net提供的正则表达式引擎支持的,其它环境下的具体情况请查看相关文档。
下面来看看更多的例子:
\ba\w*\b匹配以字母a开头的单词——先是某个单词开始处(\b),然后是字母a,然后是任意数量的字母或数字(\w*),最后是单词结束处(\b)。
好吧,现在我们说说正则表达式里的单词是什么意思吧:就是多于一个的连续的\w。不错,这与学习英文时要背的成千上万个同名的东西的确关系不大 :)
\d+匹配1个或更多连续的数字。这里的+是和*类似的元字符,不同的是*匹配重复任意次(可能是0次),而+则匹配重复1次或更多次。
\b\w{6}\b 匹配刚好6个字母/数字的单词。
代码 | 说明 |
---|---|
. | 匹配除换行符以外的任意字符 |
\w | 匹配字母或数字或下划线或汉字 |
\s | 匹配任意的空白符 |
\d | 匹配数字 |
\b | 匹配单词的开始或结束 |
^ | 匹配字符串的开始 |
$ | 匹配字符串的结束 |
元字符^(和数字6在同一个键位上的符号)和$都匹配一个位置,这和\b有点类似。^匹配你要用来查找的字符串的开头,$匹配结尾。这两个代码在验证输入的内容时非常有用,比如一个网站如果要求你填写的QQ号必须为5位到12位数字时,可以使用:^\d{5,12}$。
这里的{5,12}和前面介绍过的{2}是类似的,只不过{2}匹配只能不多不少重复2次,{5,12}则是重复的次数不能少于5次,不能多于12次,否则都不匹配。
因为使用了^和$,所以输入的整个字符串都要用来和\d{5,12}来匹配,也就是说整个输入必须是5到12个数字,因此如果输入的QQ号能匹配这个正则表达式的话,那就符合要求了。
和忽略大小写的选项类似,有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项,^和$的意义就变成了匹配行的开始处和结束处。
字符转义
如果你想查找元字符本身的话,比如你查找.,或者*,就出现了问题:你没办法指定它们,因为它们会被解释成别的意思。这时你就得使用\来取消这些字符的特殊意义。因此,你应该使用\.和\*。当然,要查找\本身,你也得用\\.
例如:unibetter\.com匹配unibetter.com,C:\\Windows匹配C:\Windows。
重复
你已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有的限定符(指定数量的代码,例如*,{5,12}等):
代码/语法 | 说明 |
---|---|
* | 重复零次或更多次 |
+ | 重复一次或更多次 |
? | 重复零次或一次 |
{n} | 重复n次 |
{n,} | 重复n次或更多次 |
{n,m} | 重复n到m次 |
下面是一些使用重复的例子:
Windows\d+匹配Windows后面跟1个或更多数字
^\w+匹配一行的第一个单词(或整个字符串的第一个单词,具体匹配哪个意思得看选项设置)
字符类
要想查找数字,字母或数字,空白是很简单的,因为已经有了对应这些字符集合的元字符,但是如果你想匹配没有预定义元字符的字符集合(比如元音字母a,e,i,o,u),应该怎么办?
很简单,你只需要在方括号里列出它们就行了,像[aeiou]就匹配任何一个英文元音字母,[.?!]匹配标点符号(.或?或!)。
我们也可以轻松地指定一个字符范围,像[0-9]代表的含意与\d就是完全一致的:一位数字;同理[a-z0-9A-Z_]也完全等同于\w(如果只考虑英文的话)。
下面是一个更复杂的表达式:\(?0\d{2}[) -]?\d{8}。
“(”和“)”也是元字符,后面的分组节里会提到,所以在这里需要使用转义。
这个表达式可以匹配几种格式的电话号码,像(010)88886666,或022-22334455,或02912345678等。我们对它进行一些分析吧:首先是一个转义字符\(,它能出现0次或1次(?),然后是一个0,后面跟着2个数字(\d{2}),然后是)或-或空格中的一个,它出现1次或不出现(?),最后是8个数字(\d{8})。
分枝条件
不幸的是,刚才那个表达式也能匹配010)12345678或(022-87654321这样的“不正确”的格式。要解决这个问题,我们需要用到分枝条件。正则表达式里的分枝条件指的是有几种规则,如果满足其中任意一种规则都应该当成匹配,具体方法是用|把不同的规则分隔开。听不明白?没关系,看例子:
0\d{2}-\d{8}|0\d{3}-\d{7}这个表达式能匹配两种以连字号分隔的电话号码:一种是三位区号,8位本地号(如010-12345678),一种是4位区号,7位本地号(0376-2233445)。
\(0\d{2}\)[- ]?\d{8}|0\d{2}[- ]?\d{8}这个表达式匹配3位区号的电话号码,其中区号可以用小括号括起来,也可以不用,区号与本地号间可以用连字号或空格间隔,也可以没有间隔。你可以试试用分枝条件把这个表达式扩展成也支持4位区号的。
\d{5}-\d{4}|\d{5}这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字,或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题:使用分枝条件时,要注意各个条件的顺序。如果你把它改成\d{5}|\d{5}-\d{4}的话,那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配分枝条件时,将会从左到右地测试每个条件,如果满足了某个分枝的话,就不会去再管其它的条件了。
分组
我们已经提到了怎么重复单个字符(直接在字符后面加上限定符就行了);但如果想要重复多个字符又该怎么办?你可以用小括号来指定子表达式(也叫做分组),然后你就可以指定这个子表达式的重复次数了,你也可以对子表达式进行其它一些操作(后面会有介绍)。
(\d{1,3}\.){3}\d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式,请按下列顺序分析它:\d{1,3}匹配1到3位的数字,(\d{1,3}\.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次,最后再加上一个一到三位的数字(\d{1,3})。
IP地址中每个数字都不能大于255,大家千万不要被《24》第三季的编剧给忽悠了...
不幸的是,它也将匹配256.300.888.999这种不可能存在的IP地址。如果能使用算术比较的话,或许能简单地解决这个问题,但是正则表达式中并不提供关于数学的任何功能,所以只能使用冗长的分组,选择,字符类来描述一个正确的IP地址:((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)。
理解这个表达式的关键是理解2[0-4]\d|25[0-5]|[01]?\d\d?,这里我就不细说了,你自己应该能分析得出来它的意义。
反义
有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外,其它任意字符都行的情况,这时需要用到反义:
代码/语法 | 说明 |
---|---|
\W | 匹配任意不是字母,数字,下划线,汉字的字符 |
\S | 匹配任意不是空白符的字符 |
\D | 匹配任意非数字的字符 |
\B | 匹配不是单词开头或结束的位置 |
[^x] | 匹配除了x以外的任意字符 |
[^aeiou] | 匹配除了aeiou这几个字母以外的任意字符 |
例子:\S+匹配不包含空白符的字符串。
<a[^>]+>匹配用尖括号括起来的以a开头的字符串。
后向引用
使用小括号指定一个子表达式后,匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下,每个分组会自动拥有一个组号,规则是:从左向右,以分组的左括号为标志,第一个出现的分组的组号为1,第二个为2,以此类推。
后向引用用于重复搜索前面某个分组匹配的文本。例如,\1代表分组1匹配的文本。难以理解?请看示例:
\b(\w+)\b\s+\1\b可以用来匹配重复的单词,像go go, 或者kitty kitty。这个表达式首先是一个单词,也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b),这个单词会被捕获到编号为1的分组中,然后是1个或几个空白符(\s+),最后是分组1中捕获的内容(也就是前面匹配的那个单词)(\1)。
你也可以自己指定子表达式的组名。要指定一个子表达式的组名,请使用这样的语法:(?<Word>\w+)(或者把尖括号换成'也行:(?'Word'\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容,你可以使用\k<Word>,所以上一个例子也可以写成这样:\b(?<Word>\w+)\b\s+\k<Word>\b。
使用小括号的时候,还有很多特定用途的语法。下面列出了最常用的一些:
分类 | 代码/语法 | 说明 |
---|---|---|
捕获 | (exp) | 匹配exp,并捕获文本到自动命名的组里 |
(?<name>exp) | 匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name'exp) | |
(?:exp) | 匹配exp,不捕获匹配的文本,也不给此分组分配组号 | |
零宽断言 | (?=exp) | 匹配exp前面的位置 |
(?<=exp) | 匹配exp后面的位置 | |
(?!exp) | 匹配后面跟的不是exp的位置 | |
(?<!exp) | 匹配前面不是exp的位置 | |
注释 | (?#comment) | 这种类型的分组不对正则表达式的处理产生任何影响,用于提供注释让人阅读 |
我们已经讨论了前两种语法。第三个(?:exp)不会改变正则表达式的处理方式,只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面,也不会拥有组号。
零宽断言
地球人,是不是觉得这些术语名称太复杂,太难记了?我也和你一样。知道有这么一种东西就行了,它叫什么,随它去吧!“无名,万物之始...”
接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西,也就是说它们像\b,^,$那样用于指定一个位置,这个位置应该满足一定的条件(即断言),因此它们也被称为零宽断言。最好还是拿例子来说明吧:
断言用来声明一个应该为真的事实。正则表达式中只有当断言为真时才会继续进行匹配。
(?=exp)也叫零宽度正预测先行断言,它断言自身出现的位置的后面能匹配表达式exp。比如\b\w+(?=ing\b),匹配以ing结尾的单词的前面部分(除了ing以外的部分),如查找I'm singing while you're dancing.时,它会匹配sing和danc。
(?<=exp)也叫零宽度正回顾后发断言,它断言自身出现的位置的前面能匹配表达式exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分),例如在查找reading a book时,它匹配ading。
假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了),你可以这样查找需要在前面和里面添加逗号的部分:((?<=\d)\d{3})*\b,用它对1234567890进行查找时结果是234567890。
下面这个例子同时使用了这两种断言:(?<=\s)\d+(?=\s)匹配以空白符间隔的数字(再次强调,不包括这些空白符)。
负向零宽断言
前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现,但并不想去匹配它时怎么办?例如,如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样:
\b\w*q[^u]\w*\b匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐,直接就观察出来了),你会发现,如果q出现在单词的结尾的话,像Iraq,Benq,这个表达式就会出错。这是因为[^u]总要匹配一个字符,所以如果q是单词的最后一个字符的话,后面的[^u]将会匹配q后面的单词分隔符(可能是空格,或者是句号或其它的什么),后面的\w*\b将会匹配下一个单词,于是\b\w*q[^u]\w*\b就能匹配整个Iraq fighting。负向零宽断言能解决这样的问题,因为它只匹配一个位置,并不消费任何字符。现在,我们可以这样来解决这个问题:\b\w*q(?!u)\w*\b。
零宽度负预测先行断言(?!exp),断言此位置的后面不能匹配表达式exp。例如:\d{3}(?!\d)匹配三位数字,而且这三位数字的后面不能是数字;\b((?!abc)\w)+\b匹配不包含连续字符串abc的单词。
同理,我们可以用(?<!exp),零宽度正回顾后发断言来断言此位置的前面不能匹配表达式exp:(?<![a-z])\d{7}匹配前面不是小写字母的七位数字。
请详细分析表达式(?<=<(\w+)>).*(?=<\/\1>),这个表达式最能表现零宽断言的真正用途。
一个更复杂的例子:(?<=<(\w+)>).*(?=<\/\1>)匹配不包含属性的简单HTML标签内里的内容。(<?(\w+)>)指定了这样的前缀:被尖括号括起来的单词(比如可能是<b>),然后是.*(任意的字符串),最后是一个后缀(?=<\/\1>)。注意后缀里的\/,它用到了前面提过的字符转义;\1则是一个反向引用,引用的正是捕获的第一组,前面的(\w+)匹配的内容,这样如果前缀实际上是<b>的话,后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒,不包括前缀和后缀本身)。
注释
小括号的另一种用途是通过语法(?#comment)来包含注释。例如:2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)。
要包含注释的话,最好是启用“忽略模式里的空白符”选项,这样在编写表达式时能任意的添加空格,Tab,换行,而实际使用时这些都将被忽略。启用这个选项后,在#后面到这一行结束的所有文本都将被当成注释忽略掉。例如,我们可以前面的一个表达式写成这样:
(?<= # 断言要匹配的文本的前缀
<(\w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)
) # 前缀结束
.* # 匹配任意文本
(?= # 断言要匹配的文本的后缀
<\/\1> # 查找尖括号括起来的内容:前面是一个"/",后面是先前捕获的标签
) # 后缀结束
贪婪与懒惰
当正则表达式中包含能接受重复的限定符时,通常的行为是(在使整个表达式能得到匹配的前提下)匹配尽可能多的字符。考虑这个表达式:a.*b,它将会匹配最长的以a开始,以b结束的字符串。如果用它来搜索aabab的话,它会匹配整个字符串aabab。这被称为贪婪匹配。
有时,我们更需要懒惰匹配,也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式,只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧:
a.*?b匹配最短的,以a开始,以b结束的字符串。如果把它应用于aabab的话,它会匹配aab(第一到第三个字符)和ab(第四到第五个字符)。
为什么第一个匹配是aab(第一到第三个字符)而不是ab(第二到第三个字符)?简单地说,因为正则表达式有另一条规则,比懒惰/贪婪规则的优先级更高:最先开始的匹配拥有最高的优先权——The match that begins earliest wins。
代码/语法 | 说明 |
---|---|
*? | 重复任意次,但尽可能少重复 |
+? | 重复1次或更多次,但尽可能少重复 |
?? | 重复0次或1次,但尽可能少重复 |
{n,m}? | 重复n到m次,但尽可能少重复 |
{n,}? | 重复n次以上,但尽可能少重复 |
处理选项
在C#中,你可以使用Regex(String, RegexOptions)构造函数来设置正则表达式的处理选项。如:Regex regex = new Regex("\ba\w{6}\b", RegexOptions.IgnoreCase);
上面介绍了几个选项如忽略大小写,处理多行等,这些选项能用来改变处理正则表达式的方式。下面是.Net中常用的正则表达式选项:
名称 | 说明 |
---|---|
IgnoreCase(忽略大小写) | 匹配时不区分大小写。 |
Multiline(多行模式) | 更改^和$的含义,使它们分别在任意一行的行首和行尾匹配,而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$的精确含意是:匹配\n之前的位置以及字符串结束前的位置.) |
Singleline(单行模式) | 更改.的含义,使它与每一个字符匹配(包括换行符\n)。 |
IgnorePatternWhitespace(忽略空白) | 忽略表达式中的非转义空白并启用由#标记的注释。 |
RightToLeft(从右向左查找) | 匹配从右向左而不是从左向右进行。 |
ExplicitCapture(显式捕获) | 仅捕获已被显式命名的组。 |
ECMAScript(JavaScript兼容模式) | 使表达式的行为与它在JavaScript里的行为一致。 |
一个经常被问到的问题是:是不是只能同时使用多行模式和单行模式中的一种?答案是:不是。这两个选项之间没有任何关系,除了它们的名字比较相似(以至于让人感到疑惑)以外。
平衡组/递归匹配
这里介绍的平衡组语法是由.Net Framework支持的;其它语言/库不一定支持这种功能,或者支持此功能但需要使用不同的语法。
有时我们需要匹配像( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构,这时简单地使用\(.+\)则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式,懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等,比如( 5 / ( 3 + 2 ) ) ),那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的,配对的括号之间的内容呢?
为了避免(和\(把你的大脑彻底搞糊涂,我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把xx <aa <bbb> <bbb> aa> yy这样的字符串里,最长的配对的尖括号内的内容捕获出来?
这里需要用到以下的语法构造:
- (?'group') 把捕获的内容命名为group,并压入堆栈(Stack)
- (?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容,如果堆栈本来为空,则本分组的匹配失败
- (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话,继续匹配yes部分的表达式,否则继续匹配no部分
- (?!) 零宽负向先行断言,由于没有后缀表达式,试图匹配总是失败
如果你不是一个程序员(或者你自称程序员但是不知道堆栈是什么东西),你就这样理解上面的三种语法吧:第一个就是在黑板上写一个"group",第二个就是从黑板上擦掉一个"group",第三个就是看黑板上写的还有没有"group",如果有就继续匹配yes部分,否则就匹配no部分。
我们需要做的是每碰到了左括号,就在压入一个"Open",每碰到一个右括号,就弹出一个,到了最后就看看堆栈是否为空--如果不为空那就证明左括号比右括号多,那匹配就应该失败。正则表达式引擎会进行回溯(放弃最前面或最后面的一些字符),尽量使整个表达式得到匹配。
< #最外层的左括号
[^<>]* #最外层的左括号后面的不是括号的内容
(
(
(?'Open'<) #碰到了左括号,在黑板上写一个"Open"
[^<>]* #匹配左括号后面的不是括号的内容
)+
(
(?'-Open'>) #碰到了右括号,擦掉一个"Open"
[^<>]* #匹配右括号后面不是括号的内容
)+
)*
(?(Open)(?!)) #在遇到最外层的右括号前面,判断黑板上还有没有没擦掉的"Open";如果还有,则匹配失败
> #最外层的右括号
平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配嵌套的<div>标签:<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div>.
还有些什么东西没提到
我已经描述了构造正则表达式的大量元素,还有一些我没有提到的东西。下面是未提到的元素的列表,包含语法和简单的说明。你可以在网上找到更详细的参考资料来学习它们--当你需要用到它们的时候。如果你安装了MSDN Library,你也可以在里面找到关于.net下正则表达式详细的文档。
代码/语法 | 说明 |
---|---|
\a | 报警字符(打印它的效果是电脑嘀一声) |
\b | 通常是单词分界位置,但如果在字符类里使用代表退格 |
\t | 制表符,Tab |
\r | 回车 |
\v | 竖向制表符 |
\f | 换页符 |
\n | 换行符 |
\e | Escape |
\0nn | ASCII代码中八进制代码为nn的字符 |
\xnn | ASCII代码中十六进制代码为nn的字符 |
\unnnn | Unicode代码中十六进制代码为nnnn的字符 |
\cN | ASCII控制字符。比如\cC代表Ctrl+C |
\A | 字符串开头(类似^,但不受处理多行选项的影响) |
\Z | 字符串结尾或行尾(不受处理多行选项的影响) |
\z | 字符串结尾(类似$,但不受处理多行选项的影响) |
\G | 当前搜索的开头 |
\p{name} | Unicode中命名为name的字符类,例如\p{IsGreek} |
(?>exp) | 贪婪子表达式 |
(?<x>-<y>exp) | 平衡组 |
(?im-nsx:exp) | 在子表达式exp中改变处理选项 |
(?im-nsx) | 为表达式后面的部分改变处理选项 |
(?(exp)yes|no) | 把exp当作零宽正向先行断言,如果在这个位置能匹配,使用yes作为此组的表达式;否则使用no |
(?(exp)yes) | 同上,只是使用空表达式作为no |
(?(name)yes|no) | 如果命名为name的组捕获到了内容,使用yes作为表达式;否则使用no |
(?(name)yes) | 同上,只是使用空表达式作为no |
联系作者
好吧,我承认,我骗了你,读到这里你肯定花了不止30分钟.相信我,这是我的错,而不是因为你太笨.我之所以说"30分钟",是为了让你有信心,有耐心继续下去.既然你看到了这里,那证明我的阴谋成功了.被忽悠的感觉很爽吧?
要投诉我,或者觉得我其实可以做得更好,或者有任何其它问题,欢迎来我的博客让我知道.
邮箱:steven9801@163.com
QQ: 48039387