📄 正则表达式30分钟入门教程 - deerchao的blog - 博客园.htm
字号:
<TR>
<TH rowSpan=4>零宽断言</TH>
<TD><SPAN class=code>(?=exp)</SPAN></TD>
<TD><SPAN class=desc>匹配exp前面的位置</SPAN></TD></TR>
<TR>
<TD><SPAN class=code>(?<=exp)</SPAN></TD>
<TD><SPAN class=desc>匹配exp后面的位置</SPAN></TD></TR>
<TR>
<TD><SPAN class=code>(?!exp)</SPAN></TD>
<TD><SPAN class=desc>匹配后面跟的不是exp的位置</SPAN></TD></TR>
<TR>
<TD><SPAN class=code>(?<!exp)</SPAN></TD>
<TD><SPAN class=desc>匹配前面不是exp的位置</SPAN></TD></TR>
<TR>
<TH>注释</TH>
<TD><SPAN class=code>(?#comment)</SPAN></TD>
<TD><SPAN
class=desc>这种类型的分组不对正则表达式的处理产生任何影响，用于提供注释让人阅读</SPAN></TD></TR></TBODY></TABLE>
<P>我们已经讨论了前两种语法。第三个<SPAN
class=code>(?:exp)</SPAN>不会改变正则表达式的处理方式，只是这样的组匹配的内容<SPAN
class=desc>不会像前两种那样被捕获到某个组里面，也不会拥有组号</SPAN>。</P>
<H2 id=lookaround>零宽断言</H2>
<P
class=note>地球人，是不是觉得这些术语名称太复杂，太难记了？我也和你一样。知道有这么一种东西就行了，它叫什么，随它去吧！“无名，万物之始...”</P>
<P>接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像<SPAN class=code>\b</SPAN>,<SPAN
class=code>^</SPAN>,<SPAN
class=code>$</SPAN>那样用于指定一个位置，这个位置应该满足一定的条件(即断言)，因此它们也被称为<SPAN
class=name>零宽断言</SPAN>。最好还是拿例子来说明吧：</P>
<P class=note>断言用来声明一个应该为真的事实。正则表达式中只有当断言为真时才会继续进行匹配。</P>
<P><SPAN class=code>(?=exp)</SPAN>也叫<SPAN class=name>零宽度正预测先行断言</SPAN>，它<SPAN
class=desc>断言自身出现的位置的后面能匹配表达式exp</SPAN>。比如<SPAN
class=regex>\b\w+(?=ing\b)</SPAN>，匹配<SPAN
class=desc>以ing结尾的单词的前面部分(除了ing以外的部分)</SPAN>，如查找<SPAN class=string>I'm singing
while you're dancing.</SPAN>时，它会匹配<SPAN class=desc>sing</SPAN>和<SPAN
class=desc>danc</SPAN>。</P>
<P><SPAN class=code>(?<=exp)</SPAN>也叫<SPAN
class=name>零宽度正回顾后发断言</SPAN>，它<SPAN
class=desc>断言自身出现的位置的前面能匹配表达式exp</SPAN>。比如<SPAN
class=regex>(?<=\bre)\w+\b</SPAN>会匹配<SPAN
class=desc>以re开头的单词的后半部分(除了re以外的部分)</SPAN>，例如在查找<SPAN class=string>reading a
book</SPAN>时，它匹配<SPAN class=desc>ading</SPAN>。</P>
<P>假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：<SPAN
class=regex>((?<=\d)\d{3})*\b</SPAN>，用它对<SPAN
class=string>1234567890</SPAN>进行查找时结果是<SPAN class=desc>234567890</SPAN>。</P>
<P>下面这个例子同时使用了这两种断言：<SPAN class=regex>(?<=\s)\d+(?=\s)</SPAN>匹配<SPAN
class=desc>以空白符间隔的数字(再次强调，不包括这些空白符)</SPAN>。</P>
<H2 id=negativelookaround>负向零宽断言</H2>
<P>前面我们提到过怎么查找<STRONG>不是某个字符或不在某个字符类里</STRONG>的字符的方法(反义)。但是如果我们只是想要<STRONG>确保某个字符没有出现，但并不想去匹配它</STRONG>时怎么办？例如，如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样：</P>
<P><SPAN class=regex>\b\w*q[^u]\w*\b</SPAN>匹配<SPAN
class=desc>包含<STRONG>后面不是字母u的字母q</STRONG>的单词</SPAN>。但是如果多做测试(或者你思维足够敏锐，直接就观察出来了)，你会发现，如果q出现在单词的结尾的话，像<STRONG>Iraq</STRONG>,<STRONG>Benq</STRONG>，这个表达式就会出错。这是因为<SPAN
class=part>[^u]</SPAN>总要匹配一个字符，所以如果q是单词的最后一个字符的话，后面的<SPAN
class=part>[^u]</SPAN>将会匹配q后面的单词分隔符(可能是空格，或者是句号或其它的什么)，后面的<SPAN
class=part>\w*\b</SPAN>将会匹配下一个单词，于是<SPAN
class=regex>\b\w*q[^u]\w*\b</SPAN>就能匹配整个<SPAN class=string>Iraq
fighting</SPAN>。<SPAN
class=name>负向零宽断言</SPAN>能解决这样的问题，因为它只匹配一个位置，并不<STRONG>消费</STRONG>任何字符。现在，我们可以这样来解决这个问题：<SPAN
class=regex>\b\w*q(?!u)\w*\b</SPAN>。</P>
<P><SPAN class=name>零宽度负预测先行断言</SPAN><SPAN class=code>(?!exp)</SPAN>，<SPAN
class=desc>断言此位置的后面不能匹配表达式exp</SPAN>。例如：<SPAN
class=regex>\d{3}(?!\d)</SPAN>匹配<SPAN
class=desc>三位数字，而且这三位数字的后面不能是数字</SPAN>；<SPAN
class=regex>\b((?!abc)\w)+\b</SPAN>匹配<SPAN class=desc>不包含连续字符串abc的单词</SPAN>。</P>
<P>同理，我们可以用<SPAN class=code>(?<!exp)</SPAN>,<SPAN
class=name>零宽度正回顾后发断言</SPAN>来<SPAN class=desc>断言此位置的前面不能匹配表达式exp</SPAN>：<SPAN
class=regex>(?<![a-z])\d{7}</SPAN>匹配<SPAN
class=desc>前面不是小写字母的七位数字</SPAN>。</P>
<P class=note>请详细分析表达式<SPAN
class=regex>(?<=<(\w+)>).*(?=<\/\1>)</SPAN>，这个表达式最能表现零宽断言的真正用途。</P>
<P>一个更复杂的例子：<SPAN
class=regex>(?<=<(\w+)>).*(?=<\/\1>)</SPAN>匹配<SPAN
class=desc>不包含属性的简单HTML标签内里的内容</SPAN>。<SPAN
class=code>(<?(\w+)>)</SPAN>指定了这样的<SPAN class=name>前缀</SPAN>：<SPAN
class=desc>被尖括号括起来的单词</SPAN>(比如可能是<b>)，然后是<SPAN
class=part>.*</SPAN>(任意的字符串),最后是一个<SPAN class=name>后缀</SPAN><SPAN
class=part>(?=<\/\1>)</SPAN>。注意后缀里的<SPAN
class=part>\/</SPAN>，它用到了前面提过的字符转义；<SPAN class=part>\1</SPAN>则是一个反向引用，引用的正是<SPAN
class=desc>捕获的第一组</SPAN>，前面的<SPAN
class=part>(\w+)</SPAN>匹配的内容，这样如果前缀实际上是<b>的话，后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒，不包括前缀和后缀本身)。</P>
<H2 id=commenting>注释</H2>
<P>小括号的另一种用途是通过语法<SPAN class=code>(?#comment)</SPAN>来包含注释。例如：<SPAN
class=regex>2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)</SPAN>。</P>
<P>要包含注释的话，最好是启用“忽略模式里的空白符”选项，这样在编写表达式时能任意的添加空格，Tab，换行，而实际使用时这些都将被忽略。启用这个选项后，在#后面到这一行结束的所有文本都将被当成注释忽略掉。例如，我们可以前面的一个表达式写成这样：</P><PRE class=regex> (?<= # 断言要匹配的文本的前缀
<(\w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)
) # 前缀结束
.* # 匹配任意文本
(?= # 断言要匹配的文本的后缀
<\/\1> # 查找尖括号括起来的内容：前面是一个"/"，后面是先前捕获的标签
) # 后缀结束</PRE>
<H2 id=greedyandlazy>贪婪与懒惰</H2>
<P>当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配<STRONG>尽可能多</STRONG>的字符。考虑这个表达式：<SPAN
class=regex>a.*b</SPAN>，它将会匹配<SPAN
class=desc>最长的以a开始，以b结束的字符串</SPAN>。如果用它来搜索<SPAN
class=string>aabab</SPAN>的话，它会匹配整个字符串<SPAN class=desc>aabab</SPAN>。这被称为<SPAN
class=name>贪婪</SPAN>匹配。</P>
<P>有时，我们更需要<SPAN
class=name>懒惰</SPAN>匹配，也就是匹配<STRONG>尽可能少</STRONG>的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号<SPAN
class=code>?</SPAN>。这样<SPAN class=regex>.*?</SPAN>就意味着<SPAN
class=desc>匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复</SPAN>。现在看看懒惰版的例子吧：</P>
<P><SPAN class=regex>a.*?b</SPAN>匹配<SPAN
class=desc>最短的，以a开始，以b结束的字符串</SPAN>。如果把它应用于<SPAN
class=string>aabab</SPAN>的话，它会匹配<SPAN class=desc>aab（第一到第三个字符）</SPAN>和<SPAN
class=desc>ab（第四到第五个字符）</SPAN>。</P>
<P
class=note>为什么第一个匹配是aab（第一到第三个字符）而不是ab（第二到第三个字符）？简单地说，因为正则表达式有另一条规则，比懒惰／贪婪规则的优先级更高：最先开始的匹配拥有最高的优先权——The
match that begins earliest wins。</P>
<TABLE cellSpacing=0>
<CAPTION>表5.懒惰限定符</CAPTION>
<THEAD>
<TR>
<TH scope=col>代码/语法</TH>
<TH scope=col>说明</TH></TR></THEAD>
<TBODY>
<TR>
<TD><SPAN class=code>*?</SPAN></TD>
<TD><SPAN class=desc>重复任意次，但尽可能少重复</SPAN></TD></TR>
<TR>
<TD><SPAN class=code>+?</SPAN></TD>
<TD><SPAN class=desc>重复1次或更多次，但尽可能少重复</SPAN></TD></TR>
<TR>
<TD><SPAN class=code>??</SPAN></TD>
<TD><SPAN class=desc>重复0次或1次，但尽可能少重复</SPAN></TD></TR>
<TR>
<TD><SPAN class=code>{n,m}?</SPAN></TD>
<TD><SPAN class=desc>重复n到m次，但尽可能少重复</SPAN></TD></TR>
<TR>
<TD><SPAN class=code>{n,}?</SPAN></TD>
<TD><SPAN class=desc>重复n次以上，但尽可能少重复</SPAN></TD></TR></TBODY></TABLE>
<H2 id=regexoptions>处理选项</H2>
<P class=note>在C#中，你可以使用<A title="MSDN 相关文档"
href="http://msdn2.microsoft.com/zh-cn/library/h5845fdz.aspx">Regex(String,
RegexOptions)构造函数</A>来设置正则表达式的处理选项。如：Regex regex = new Regex("\ba\w{6}\b",
RegexOptions.IgnoreCase);</P>
<P>上面介绍了几个选项如忽略大小写，处理多行等，这些选项能用来改变处理正则表达式的方式。下面是.Net中常用的正则表达式选项：</P>
<TABLE cellSpacing=0>
<CAPTION>表6.常用的处理选项</CAPTION>
<THEAD>
<TR>
<TH scope=col>名称</TH>
<TH scope=col>说明</TH></TR></THEAD>
<TBODY>
<TR>
<TD>IgnoreCase(忽略大小写)</TD>
<TD>匹配时不区分大小写。</TD></TR>
<TR>
<TD>Multiline(多行模式)</TD>
<TD>更改<SPAN class=code>^</SPAN>和<SPAN
class=code>$</SPAN>的含义，使它们分别在任意一行的行首和行尾匹配，而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,<SPAN
class=code>$</SPAN>的精确含意是:匹配\n之前的位置以及字符串结束前的位置.) </TD></TR>
<TR>
<TD>Singleline(单行模式)</TD>
<TD>更改<SPAN class=code>.</SPAN>的含义，使它与每一个字符匹配（包括换行符\n）。 </TD></TR>
<TR>
<TD>IgnorePatternWhitespace(忽略空白)</TD>
<TD>忽略表达式中的非转义空白并启用由<SPAN class=code>#</SPAN>标记的注释。</TD></TR>
<TR>
<TD>RightToLeft(从右向左查找)</TD>
<TD>匹配从右向左而不是从左向右进行。</TD></TR>
<TR>
<TD>ExplicitCapture(显式捕获)</TD>
<TD>仅捕获已被显式命名的组。</TD></TR>
<TR>
<TD>ECMAScript(JavaScript兼容模式)</TD>
<TD>使表达式的行为与它在JavaScript里的行为一致。</TD></TR></TBODY></TABLE>
<P>一个经常被问到的问题是：是不是只能同时使用多行模式和单行模式中的一种？答案是：不是。这两个选项之间没有任何关系，除了它们的名字比较相似（以至于让人感到疑惑）以外。</P>
<H2 id=balancedgroup>平衡组/递归匹配</H2>
<P class="important note">这里介绍的平衡组语法是由.Net
Framework支持的；其它语言／库不一定支持这种功能，或者支持此功能但需要使用不同的语法。</P>
<P>有时我们需要匹配像<SPAN class=desc>( 100 * ( 50 + 15 )
)这样的可嵌套的层次性结构</SPAN>，这时简单地使用<SPAN
class=code>\(.+\)</SPAN>则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式，懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等，比如<SPAN
class=string>( 5 / ( 3 + 2 ) )
)</SPAN>，那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的，配对的括号之间的内容呢？</P>
<P>为了避免<SPAN class=code>(</SPAN>和<SPAN
class=code>\(</SPAN>把你的大脑彻底搞糊涂，我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把<SPAN class=string>xx
<aa <bbb> <bbb> aa> yy</SPAN>这样的字符串里，最长的配对的尖括号内的内容捕获出来？</P>
<P>这里需要用到以下的语法构造：</P>
<UL>
<LI><SPAN class=code>(?'group')</SPAN> 把捕获的内容命名为group,并压入<SPAN
class=name>堆栈(Stack)</SPAN>
<LI><SPAN class=code>(?'-group')</SPAN>
从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
<LI><SPAN class=code>(?(group)yes|no)</SPAN>
如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
<LI><SPAN class=code>(?!)</SPAN> 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败 </LI></UL>
<P
class=note>如果你不是一个程序员（或者你自称程序员但是不知道堆栈是什么东西），你就这样理解上面的三种语法吧：第一个就是在黑板上写一个"group"，第二个就是从黑板上擦掉一个"group"，第三个就是看黑板上写的还有没有"group"，如果有就继续匹配yes部分，否则就匹配no部分。</P>
<P>我们需要做的是每碰到了左括号，就在压入一个"Open",每碰到一个右括号，就弹出一个，到了最后就看看堆栈是否为空－－如果不为空那就证明左括号比右括号多，那匹配就应该失败。正则表达式引擎会进行回溯(放弃最前面或最后面的一些字符)，尽量使整个表达式得到匹配。</P><PRE class=regex>< #最外层的左括号
[^<>]* #最外层的左括号后面的不是括号的内容
(
(
(?'Open'<) #碰到了左括号，在黑板上写一个"Open"
[^<>]* #匹配左括号后面的不是括号的内容
)+
(
(?'-Open'>) #碰到了右括号，擦掉一个"Open"
[^<>]* #匹配右括号后面不是括号的内容
)+
)*
(?(Open)(?!)) #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败
> #最外层的右括号</PRE>
<P>平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配<SPAN class=desc>嵌套的<div>标签</SPAN>：<SPAN
class=regex><div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div></SPAN>.</P>
<H2 id=more>还有些什么东西没提到</H2>
<P>我已经描述了构造正则表达式的大量元素，还有一些我没有提到的东西。下面是未提到的元素的列表，包含语法和简单的说明。你可以在网上找到更详细的参考资料来学习它们--当你需要用到它们的时候。如果你安装了MSDN
Library,你也可以在里面找到关于.net下正则表达式详细的文档。</P>
<TABLE cellSpacing=0>
<CAPTION>表7.尚未详细讨论的语法</CAPTION>
<THEAD>
<TR>
<TH scope=col>代码/语法</TH>
<TH scope=col>说明</TH></TR></THEAD>
<TBODY>
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -