组的概念
当你获得这样的一个字符串”最后比分是：19/24”，你肯定希望有一个正则表达式，他不单能够找到形如 data1/data2的字符串，还应该能够直接把data1,data2作为单独的结果传送出来。否则你需要再对形如”19/24”的字符串进行分析，才能够顺利得到双方的比分。显然，正则表达式不会忽略这个问题，所以他增加了组的概念。你可以把一次搜索的结果分别放入不同的组中，并通过组名或者组的所以分别取得这些组的结果。比如上例，我们就可以用@”(/d+)/(/d+)”作为表达式。来看看结果吧：
Regex regex = new Regex(@"(/d+)/(/d+)");
MatchCollection matches = regex.Matches(@"最后比分是：19/24");
//show matches
Console.WriteLine("----------------------------------");
foreach(Match m in matches)
{
//Console.WriteLine("match string is: /"{0}/", length: {1}", // m.Value.ToString(), m.Value.Length);
foreach(string name in regex.GetGroupNames())
{
Console.WriteLine("/r capture group /"{0}/" value is:/"{1}/""
, name, m.Groups[name].Value);
}
}
Console.WriteLine("matched count: {0}", matches.Count);
输出：
----------------------------------
capture group "0" value is:"19/24"
capture group "1" value is:"19"
capture group "2" value is:"24"
matched count: 1
现在清楚了吧，Regex对象把匹配的结果放入组0中。同时，匹配的组信息也放入了对应的组中。组的名称在默认的情况下，是从1开始依次增加的整数。0作为保留名称，专门用于指示匹配的整个字符串。既然有”默认情况”这样的概念，自然也就意味着用户可以自定义组的名称。方法很简单，在组的前面加上：?<name>就可以了。好了，现在把前面的正则表达式修改一下，换成@”(?<score1>/d+)/(?<score1>/d+)”，现在再看看结果：
----------------------------------
capture group "0" value is:"19/24"
capture group "score1" value is:"19"
capture group "score2" value is:"24"
matched count: 1
换成自己定义的名字了吧，哈哈！为了在今后的测试中，能够更加方便的看到所有结果，我们对前面介绍过的showMatches()做一点小小的调整。这样，如果在表达式中包含了组的定义，我们也可以在不需要修改任何代码的情况下，直接看到所有的组信息了，调整后的方法showMatchesPro()如下：
public static void showMatchesPro(string expression, RegexOptions option, string ms)
{
Regex regex = new Regex(expression, option);
MatchCollection matches = regex.Matches(ms);
//show matches
Console.WriteLine("----------------------------------");
Console.WriteLine(" string: /"{0}/"/r/n expression: /"{1}/"/r/n match result is:",
ms, expression);
foreach(Match m in matches)
{ foreach(string name in regex.GetGroupNames())
{
Console.WriteLine("/r capture group /"{0}/" value is:/"{1}/"",
name, m.Groups[name].Value);
}
}
Console.WriteLine("matched count: {0}", matches.Count);
// show group name
Console.WriteLine("group name count {0}", regex.GetGroupNames().Length);
foreach(string name in regex.GetGroupNames())
{
Console.WriteLine("group name :/"{0}/"", name);
}
}
正则表达式中的组是很重要的一个概念，它是我们通向高级正则应用的的桥梁。 组的概念 一个正则表达式匹配结果可以分成多个部分，这就是组(Group)的目的。能够灵活的使用组后，你会发现Regex真是很方便，也很强大。 先举个例子
| public static void Main() { string s = "2005-2-21"; Regex reg = new Regex(@"(?<y>/d{4})-(?<m>/d{1,2})-(?<d>/d{1,2})",RegexOptions.Compiled); Match match = reg.Match(s); int year = int.Parse(match.Groups["y"].Value); int month = int.Parse(match.Groups["m"].Value); int day = int .Parse(match.Groups["d"].Value); DateTime time = new DateTime(year,month,day); Console.WriteLine(time); Console.ReadLine(); } |
| public static void Main() { string s = "2005-2-21"; Regex reg = new Regex(@"(/d{4})-(/d{1,2})-(/d{1,2})",RegexOptions.Compiled); Match match = reg.Match(s); int year = int.Parse(match.Groups[1].Value); int month = int.Parse(match.Groups[2].Value); int day = int .Parse(match.Groups[3].Value); DateTime time = new DateTime(year,month,day); Console.WriteLine(time); Console.ReadLine(); } |
| public static void Main() { string s = "2005-2-21"; Regex reg = new Regex(@"(?<2>/d{4})-(?<1>/d{1,2})-(?<3>/d{1,2})",RegexOptions.Compiled); Match match = reg.Match(s); int year = int.Parse(match.Groups[2].Value); int month = int.Parse(match.Groups[1].Value); int day = int .Parse(match.Groups[3].Value); DateTime time = new DateTime(year,month,day); Console.WriteLine(time); Console.ReadLine(); } |
<
table
>
<
tr
>
<
td
id
="td1"
>
</
td
>
<
td
id
="td2"
>
<
table
>
<
tr
>
<
td
>
snhame
</
td
>
<
td
>
f
</
td
>
</
tr
>
</
td
>
<
td
></
td
>
</
tr
>
</
table
>
<td id="td2"> <table> <tr> <td>snhame</td>
<td id="td2"> <table> <tr> <td>snhame</td> <td>f</td> </tr> </td> <td></td>
- (?<group>)或者(?’group’) - 把捕获的结果内容命名为group,并压入堆栈;
- (?<-group>)或者(?’-group’)- 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败;
- (?(group)yes|no)或者(?(group)yes|no)- 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分;
- (?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败 ;
上面的表达可以用更简单的表达式让大家理解一下堆栈,堆栈就像往箱子里面装东西,最先装的放在最下面,而最后装的放在最上面,在对堆栈有一定认识以后,这就非常好理解了,(?<group>)就为往箱子里面装一个东东,(?<-group>)就是在箱子里面取一个东东(当然第一次只能取到最上面的),(?(group)yes|no)就是最后再来检查箱子里是否还有东西,如果有则继续匹配yes部分,否则就匹配no的部分. 很简单的道理: 我们需要做的是每碰到了左括号，就在黑板上写一个"group"，每碰到一个右括号，就擦掉一个，到了最后就看看黑板上还有没有－－如果有那就证明左括号比右括号多，那匹配就应该失败.
下在这个是Jeffrey Friedl在精通正则表达式第二版当中所提供的例子 Jeffrey Friedl provides the following example in his excellent book Mastering Regular Expressions, 2nd Edition.
Balanced Parentheses. (匹配括号)
Dim R As Regex = New Regex(" /( " & _ " (?> " & _ " [^()]+ " & _ " | " & _ " /( (?<DEPTH>) " & _ " | " & _ " /) (?<-DEPTH>) " & _ " )* " & _ " (?(DEPTH)(?!)) " & _ " /) ", _ RegexOptions.IgnorePatternWhitespace);
现在这个正则表达式可以匹配正确的嵌套组但是这种结构不能匹配到像XML标签其嵌套字符多于一个简单字符的嵌套组
Regex re = new Regex(@"^ (?> /( (?<LEVEL>) # On opening paren push level | /) (?<-LEVEL>) # On closing paren pop level | (?! /( | /) ) . # Match any char except ( or ) )+ (?(LEVEL)(?!)) # If level exists then fail ___FCKpd___2quot;, RegexOptions.IgnorePatternWhitespace);
这个表达式也能匹配正确的嵌套组,但这里最大的不同就是这里用否定查找来确定这个字符不是一个匹配来代替[^()]+ 这一类的的匹配.它也只能匹配到一个字符的限制符. Balanced XML tags.Regex re = new Regex(@"^ (?> <tag> (?<LEVEL>) # On opening <tag> push level | </tag> (?<-LEVEL>) # On closing </tag> pop level | (?! <tag> | </tag> ) . # Match any char unless the strings )+ # <tag> or </tag> in the lookahead string (?(LEVEL)(?!)) # If level exists then fail ___FCKpd___3quot;, RegexOptions.IgnorePatternWhitespace | RegexOptions.IgnoreCase);这个正则表达式可以匹配到正确的xml嵌套的标签<tag>和</tag>.它只是把匹配括号的表达式中的"("修改为"<tag>"和")"修改为了"</tag>".General version of Balanced constructs (HTML Anchor tags used in example).
现在这个正则表达式用一个简单的字符串格式符替换掉表达式中弹出和加入的限定符.这种方式就更加的常用,它可以很简单的就把开始和结束限制符表示在其表达式当中. 这一切在.NET正则表达式当中都显得非常的简单.
Regex re = new Regex(string.Format(@"^ (?> {0} (?<LEVEL>) # On opening delimiter push level | {1} (?<-LEVEL>) # On closing delimiter pop level | (?! {0} | {1} ) . # Match any char unless the opening )+ # or closing delimiters are in the lookahead string (?(LEVEL)(?!)) # If level exists then fail ___FCKpd___8quot;, "<a[^>]*>", "</a>"), RegexOptions.IgnorePatternWhitespace | RegexOptions.IgnoreCase);Retrieving data between delimiters where there are possible nested delimiters
有一个比较通常的应用就是在两限制符之间的字符中包含里限制符标签(这也就是我们上面所提到的问题) If there were no nested tags then this regular expression would be rather simple but since there are one essentially needs to wrap the expression from above with the set of outer tags and then capture the inner text.
Regex re = new Regex(string.Format(@"^ {0} # Match first opeing delimiter (?<inner> (?> {0} (?<LEVEL>) # On opening delimiter push level | {1} (?<-LEVEL>) # On closing delimiter pop level | (?! {0} | {1} ) . # Match any char unless the opening )+ # or closing delimiters are in the lookahead string (?(LEVEL)(?!)) # If level exists then fail ) {1} # Match last closing delimiter ___FCKpd___10quot;, "<quote>", "</quote>"), RegexOptions.IgnorePatternWhitespace | RegexOptions.IgnoreCase); re.Match("<quote>inner text</quote>").Groups["inner"].Value == "inner text" re.Match("<quote>a<quote>b</quote>c</quote>").Groups["inner"].Value == "a<quote>b</quote>c"
Matching multiple balanced constructs(匹配多平衡组结构)
这个例子主要是为了显示如何匹配多种适当的平衡标签与一个单一平衡标签的表达式. 不过，经过表达式的创造和测试,它出现了一个有趣的问题,举例来说,以确保（ ）和[ ]得到正确嵌套单独实现容易如上所示, 而是要确保他们获得适当嵌套连同是不可能的. net的正则表达式为了更好地了解该问题考虑下列不正当嵌套实例（ [ ） ]或[(()]). 他们是单独嵌套表达式，但不当的嵌套时，考虑到它们放在一起.下面一个表达式认识到这一点：
Regex re = new Regex(@"^ (?> (?<LEVEL> /() # On opening paren capture ( on stack | (?(/k<LEVEL>=/() # Make sure the top of stack is ( (?<-LEVEL> /) )) # On closing paren pop ( off stack | (?<LEVEL> /[ ) # On opening bracket capture [ on stack | (?(/k<LEVEL>=/]) # Make sure the top of stack is [ (?<-LEVEL> /] )) # On closing bracket pop [ off stack | (?! /( | /) | /[ | /] ) . # Match any char except (, ), [ or ] )+ (?(LEVEL)(?!)) # If level exists then fail ___FCKpd___11quot;, RegexOptions.IgnorePatternWhitespace);这个正则表达式不能正常运行它只是作为一个示例来说明.
上面说了这么多,想必大家出都看出这个匹配多平衡组的原理了,其实质上也只是一个堆栈的原理.首先把左操作符压入栈. 在遇上右操作符的时候并不是马上把左操作符弹出,而是多了一个判定,判断其栈的最顶元素是否就是当前匹配到的右操作符 相对应的左操作符,如果是,则弹出,相反失败. 说了这么多,现在来解决问题了,很明显我们应该采用最后一种结构,匹配多平衡组.(由于时间的原因,这组答案没能完成) 采用前面匹配括号的方法来实现
< td. *? id = " td2 " [ ^> ] *> (( ?>< td[ ^> ] *> ( ?< o > ) |</ td > ( ?<- o > ) | [/s/S]) * )( ? (o)( ?! )) </ td >做的不怎么满意,还需继续学习. 分组构造 (
捕获匹配的子字符串（或非捕获组；有关详细信息，请参见正则表达式选项中的 ExplicitCapture 选项）。使用 () 的捕获根据左括号的顺 序从 1 开始自动编号。捕获元素编号为零的第一个捕获是由整个正则表达式模式匹配的文本。 (?<name>
扫一扫
610
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
