首字母大小写无关模式

有一段时间，我在写正则表达式来匹配Drug关键字时，经常写出 /viagra|cialis|anti-ed/ 这样的表达式。为了让它更美观，我会给关键词排序；为了提升速度，我会使用 /[Vv]iagra/ 而非/viagra/i ，只让必要的部分进行大小写通配模式。确切地说，我是需要对每个单词的首字母进行大小写无关的匹配。

我写了这样的一个函数，专门用来批量转换。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#convert regex to sorted list, then provide both lower/upper case for the first letter of each word #luf means lower upper first sub luf{     #   split the regex with the delimiter |     my @arr=sort(split(/\|/,shift));     #   provide both the upper and lower case for the       #   first leffer of each word     foreach (@arr){s/\b([a-zA-Z])/[\l$1\u$1]/g;}     #   join the keyword to a regex again     join('|',@arr); } print luf "sex pill|viagra|cialis|anti-ed"; #   the output is:[aA]nti-[eE]d|[cC]ialis|[sS]ex [pP]ill|[vV]iagra

控制全局匹配下次开始的位置

记得jyf曾经问过我，如何控制匹配开始的位置。嗯，现在我可以回答这个问题了。Perl 提供了 pos 函数，可以在 /g 全局匹配中调整下次匹配开始的位置。举例如下：

1 2 3 4 5

$_="abcdefg"; while(/../g) {     print $&; }

其输出结果是每两个字母，即ab, cd, ef

可以使用 pos($_)来重新定位下一次匹配开始的位置，如：

1 2 3 4 5 6

$_="abcdefg"; while(/../g) {     pos($_)--;  #pos($_)++;     print $&; }

输出结果：

1 2	pos($_)--:  ab, bc, cd, de, ef, fg. pos($_)++:  ab, de.

可以阅读 Perl 文档中关于 pos的章节获取详细信息。

散列与正则表达式替换

《effective-perl-2e》第三章有这样一个例子（见下面的代码），将特殊符号转义。

1 2	my %ent = { '&' => 'amp', '<' => 'lt', '>' => 'gt' }; $html =~ s/([&<>])/&$ent{$1};/g;

这个例子非常非常巧妙。它灵活地运用了散列这种数据结构，将待替换的部分作为 key ，将与其对应的替换内容作为 value 。这样只要有匹配就会捕获，然后将捕获的部分作为 key ，反查到 value 并运用到替换中，体现了高级语言的效率。

不过，这样的 Perl 代码，能否移植到 Python 中呢？ Python 同样支持正则，支持散列（Python 中叫做 Dictionary），但是似乎不支持在替换过程中插入太多花哨的东西（替换行内变量内插）。

查阅 Python 的文档，（在 shell 下 执行 python ，然后 import re，然后 help(re)），：

1 2 3 4 5 6 7

sub(pattern, repl, string, count=0)     Return the string obtained by replacing the leftmost     non-overlapping occurrences of the pattern in string by the     replacement repl.  repl can be either a string or a callable;     if a string, backslash escapes in it are processed.  If it is     a callable, it's passed the match object and must return     a replacement string to be used.

原来 python 和 php 一样，是支持在替换的过程中使用 callable 回调函数的。该函数的默认参数是一个匹配对象变量。这样一来，问题就简单了：

1 2 3 4 5 6 7 8 9

ent={'<':"lt",     '>':"gt",     '&':"amp",     } def rep(mo):     return ent[mo.group(1)] html=re.sub(r"([&<>])",rep, html)

python 替换函数 callback 的关键点在于其参数是一个匹配对象变量。只要明白了这一点，查一下手册，看看该种对象都有哪些属性，一一拿来使用，就能写出灵活高效的 python 正则替换代码。

问题

问题描述

有如下文本，如何使用正则式，将其中不含color选项的item匹配出来？

1 2 3 4 5 6 7 8

<item>     color:red; </item> <item>     size:12;     number:45;     type:good; </item>

典型的错误答案

新手容易提供这样的错误答案：<item>.*?(?!color).*?</item>。其出发点是正确的：只有当color不出现在目标字串时，该匹配才是所需要的。事实上，这样的正则表达式不能如君所愿，它匹配所有的<item>...</item>。这是为什么呢？

Perl之排除型匹配

最简单的排除型匹配

匹配是=~, 不匹配当然是 !~ 了。写到这里想到，在正则式中，凡是由=组成的正则式符号，全可以使用!来替代，以表现相反的意思。例如(?=)与(?!)，(?<=)与(?<!)，=~与!~。

返回正题，看个例子。如果要检测某字串是否含有good，当然要用if ($string =~ /good/)，如果$string里有good则条件为真，否则为假；

如果要检测某字串是否不含有good，可以用if ($string !~ /good/)，如果$string里没有good则条件为真，否则为假。

这种匹配测试，较适合于在大段的字串中搜索某个简单的模式，然后对于匹配的结果作出两种不同的判断，非此即彼。虽然迅速干练，但是对于复杂情况的判断，还是有些累赘。

对于文章开始提出的问题而言，当然可以这样解决：先搜索所有的 <item>...</item>，然后分别判断是否存在color项即可：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#!/usr/bin/perl -w my $text=<<END; <item>     color:red; </item> <item>     size:12;     number:45;     type:good; </item> END my @result = $text=~ m!<item>.*?</item>!sg; foreach $item (@result) {     if ($item !~ /color/)     {         print "$item";     } }

输出结果是:

1 2 3 4 5

<item>     size:12;     number:45;     type:good; </item>

虽然也不错，但是它总是“宁可错杀不可错放”地找完所有可能项，再一一重新进行排除。能否一开始就先界定，我们要找的是不含color的item呢？排除型匹配正是为此而生。

排除型匹配

不好意思，“排除型匹配”这个词是我生造的。其它的说法或许是“否定断言”，“否定环视”等等。后两者的命名，都是从匹配过程的角度出发；而此处命名，是从结果出发。具体说来，就是使用 (?!...)和(?<!...)作为辅助条件判断，来简化正则表达式，方便快捷地找到符合要求的匹配。

这两个东东的使用方法类似，都是指，当前位置不出现某种模式。不同的是，(?!...)是指当前位置的右边，而(?<!)自然就是指左边了。

这里隆重推出Anrs同学翻译的教程: 环视一以及环视二。仔细阅读这两文章，彻底明白环视这两个概念，将会提升您的正则表达式功力。后文将建立在您已经理解环视这个概念的基础上。

闲话一句。既然使用“左边”和“右边”既形象又好懂，为什么没见过“左瞻”，“右瞻”，“左向”，“右向”，反而全是些“前瞻后瞻”，“正向逆向”这样的不好理解的说法呢？撕烤者也同有此问。我的理解是，或许是为了照顾阿语等从右向左书写的用户的习惯吧。无论如何，将从 ^到 $的方向称之为“向前”总不会错。

描述当前位置（左侧或右侧）的模式，从而辅助判断正则式是否匹配，是环视的作用。它只描述，不消耗字符；只辅助判断，从不单独出现。这与^和$简直如出一辙。

一则例子

例子. 现在有许多与fanfou.com类似的网址。如何写一条正则表达式，来匹配域名含fanfou，但是TLS不是.com的模式？

答案：/\bfanfou\.(?!com)[a-z]{2,4}\b/i。分析这条正则表达式：

• 以\b开始，明确字符边界；
• fanfou主域名不可少；
• \.匹配一个普通的点号；此处不要使用点号元字符；
• (?!com)表示此处（即从fanfou.的右边）不得出现com三个连续字符；
• [a-z]{2,4}表示是2至4位的拉丁字母；因为域名的TLS最短是2位（如.au, .us），最长可为4位（如.info, .asia）；
• 右侧边界同样重要，否则我们之前的{2,4}就白费了；
• 使用i表示不分大小写；这是域名的特征之一。

回到本题

按照要求，一步步建立这条正则式。

• 该正则式匹配的是<item>...</item>结构。因此，正则式以<item>开始。
• 在<item>和</item>之间不得出现color，是这条正则式的难点。因为，color可能位于这个结构之内的任意一点，因此要规定，此内任意一点都不得出现color一词。这样的点为：(?!color).。这样的点重复1+次，正则式写为((?!color).)+。注意这里有个小陷阱：不要写为(?!color).+，否则它只描述了最左侧的一点不得出现color，其余部分则都无所谓。而写为((?!color).)+则保证每一点都不出现color。
• 正则式此时为<item>((?!color).)+?</item>。为了节省资源，括号通常写成非捕获模式(?:...)；为了保证点号匹配换行符，可以指定s模式或使用[\s\S]代替点号元字符。此处仍使用点号。正则式修改为<item>(?:(?!color).)+?</item>。

总体来说，环视相对于基本的元字符还是要抽象一些。不过一旦理解并掌握了它，就会发现它在精确匹配和替换时十分有用。上面的分析，希望有所帮助。如果您有类似的问题，欢迎提出。

缘由

为什么不用RegexBuddy了

• 它是收费软件，价格不算便宜。$39.95。Google一下，或有惊喜。
• 它只能用于Windows平台。虽然在ubuntu下，我会额外安装wine，仅仅是为了驱动RegexBuddy。
• Mac下无法使用RegexBuddy。近来我开始使用Mac环境了，不想再为windows软件单独运行环境了。regexbuddy似乎要失之交臂了。搜索了一下，这里，这里，找到的软件聊聊无几，性能也乏善可陈：大多仅支持JavaScript这样比较朴素的正则，缺乏多语言、多选项的支持。–RegexBuddy出色的表现，已经将我对正则辅助软件的期望值训练得极为挑剔，一般软件难以落入老夫的法眼了，呵呵。

没有现成的解决方案，我就考虑，如何自己DIY一个了。

我理想中的正则辅助软件

1. 像RegexBuddy一样，支持以下属性：

1. 支持多语言正则。至少要支持Perl, Python, PHP, JavaScript吧。.Net的用得不多（只在回答别人问题时用过，不算），可以无视；
2. 支持匹配、替换、分割(split)；
3. 支持生成代码片段；这一点很重要。我平常不会死背硬记一些电脑可以代劳的冬冬，除非经常用–经常用的，慢慢也就变成肌肉记忆了。

2. 除此之外，它最好还能：

1. 兼容于各种常见平台。我指的是，Win/Lin/Mac。
2. 对于语言的支持要原生。说实话，我怀疑RegexBuddy还在用Perl5.8风格的正则。5.10中的许多新奇好用的特性，还没有在RegexBuddy中得到支持。究其原因，RegexBuddy的作者大概是自行从头构建的Perl等正则引擎，在细节、版本上，与最新版有所差异。说到语言，想起余晟老师的一点意见，就是思考正则问题时，先不要考虑是什么语言、版本的正则，心中要有统一的语法。我同意余老师的观点，但是也觉得，在了解了貌似通用的正则语法基础之后，应该比较清晰地了解自己最常用的正则语言的语法细节，以及与其它语言的差异，以避免似是而非。跑题，打住。
3. 开源，正版，免费。我们向其他人介绍正则，总得有一款可以拿得出手的工具吧？免费这条倒是不苛求，话说好软件还是应该有所回报的。

问题是，这么好的软件，到那里去找呢？找不到的话，自己想从头实现，该如何动手呢？

我的思路历程

• 使用Objective-C来实现。不过，这想法没多久就像萝莉一样被推倒了。Obj-C固然是要学的，但我等不及了。RegexBuddy这类的软件我是天天都在用。这个目标似乎比上一条还要临渴掘井。为mac平台开发了，代码至少还要为win/lin单独编译吧？再者，如果用了Obj-C，正则引擎怎么办？从头实现？xiaofei说，要实现一个好用的正则引擎，要一个优秀的团队半年的时间。当然，Obj-C也可以调用现成的模块，这也引出了我现在的思路。
• 做成网页程序，前端接收用户输入，后端使用CGI调用服务器上的原生正则引擎（perl、python），匹配、替换后展现在前端。它最大的好处是，语言百分百原生，Native；只要网络在，打开浏览器就能用；即使没有网络，本机localhost也可用，而且更快。JavaScript/PHP就不必劳驾CGI了，原汤化原食就可以。

话说我已经选择了第二套方案，于是就着手实现。

目前的进度

• 已经使用HTML+jQuery画出了简单的界面，实现了perl 5.10版的CGI程序，能够进行匹配、替换、分割（Split)。
• 未实现的功能：代码Snippets自动生成；其它语言版本的实现。
• 对于我自己来说，基本上已经可以使用了。我现在就正在 eat my own dog food，一边用它，一边完善它。不过要想发布出来供大家使用，还需要旷日持久的功能完善、界面美化。
• 截图见文章末尾。
  

Perl CGI 代码以及简要说明

代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

#!/usr/bin/perl -w use CGI; my $counter=1; sub cl {     $counter*=-1;     "#ff0" if $counter==1;     "#0ff" if $counter==-1; } sub h_color {     my ($a)=shift;     $counter*=-1;     $color=($counter<0) ? "#ff0" : "#0ff";     "<span style='background-color:$color'>".$a."</span>"; } my $q=CGI->new; die "$!" unless $q; print $q->header(-type=>"text/html; charset=UTF-8"); my $regex=$q->param("regex"); #quit immediatly if no $regex input die unless $regex; my $text=$q->param("text"); my $mode=$q->param("mode"); my $x=$q->param("space"); my $action=$q->param("action"); $regex =~ s/\s+//g if $x; if ($action eq "match") {     my $code="";     $code.='$text =~ s@$regex';     $code.='@&h_color($&)';     $code.='@eg'.$mode.';';     eval $code;     $text =~ s#\n#<br />#g;     print $text unless $@; } elsif ($action eq "replace") {     my $code="";     my $replace=$q->param("replace");         $code = "\$text =~ s:\$regex:$replace:g;";     eval "$code";     $text =~ s#\n#<br/>#g;     print "<pre>$text</pre>" unless $@; } elsif ($action eq "split") {     #@result=split(m@$regex@mode, $text);     my $code="";     $code .= '@result=split(m@$regex@'. $mode . ', $text);';     $code .= '@result=grep /\S/, @result;';     $code .= 'my $count=@result;';     $code .= 'print "<font color=\"#ff008c\">$count</font> record(s) returned:";';     $code .= 'print "<ol>";';     $code .= 'print "<li>".&h_color($_)."</li>" foreach (@result);';     $code .= 'print "</ol";';     eval $code; }

代码…还算简洁。主要就是接收并简单处理一下各个参数，然后按照不同的动作要求（match/replace/splie）进行相应的动态代码生成，然后eval执行结果，返回输出。在match/split中，还插入了代码高亮的小功能。基于perl代码的高效紧凑，实现起来倒也不至于冗长。感谢cnhacktnt的协助。

截图

以下摘自某网友来信:

难点

1. javascript不支持点号匹配换行符, 因此无法直接进行多行匹配;
2. 处理前面没有http:的//, 当然要用否定前瞻( negative lookbehine)了:(?<!http:)\/\/. 可惜javascript不支持.
   

思路

关于多行匹配

这个问题, 之前我已经说过, 要点是使用[\S\s]来模拟匹配换行符的点号. 原文在这里:《DIY万能通配符》. 可以以此写出这样的javascript代码来消除多行注释:

1 2 3 4 5

//to uncomment C-style multiple line comment function uncomment_multi(str) {      return str.replace(/\/\*[\S\s]*?\*\//g, ""); }

单行注释之javascript实现(不完善)

单行注释并没有想像中的那样简单. 如果你认为只要 str.replace("//.*$")即可, 那么必须保证所要处理的文本都是最简单的, 如下:

1	var pig="ase"; //this is a comment.

事实上这是行不通的. 现实程序中下面的例子比比皆是:

1 2	var url="http://iregex.org"; //this is my site. var url="//not real comment here http://iregex.org"; //this is my site.

我尝试使用javascript写了个模拟否定前瞻的函数, 可以处理http://这种情况, 但是该函数看起来并不令人赏心悦目, 而且也不能处理引号中有双斜杠的情况. 我对javascript的正则式支持的特性之简陋实在很失望. 于是, 我求助于perl完成这一任务. 先看一下我写的javascript的删除单行注释的函数:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

function uncomment_single(str) {     var result;     var single=new RegExp("\/\/.","ig");     var start=0;     while((result=single.exec(str))!=null)     {         var part=str.slice(start,result.index);         var negLeft=new RegExp("http:$","i");         if (! negLeft.test(part))         {             return str.slice(0,result.index);         }         start=result.index+result[0].length-1;     }     return str; }

perl版删除注释思路及源码(相对完善)

待测试文本

好吧, 既然祭出了强大的perl, 之前的小打小闹似的例子就一边去吧. 我将使用如下相对复杂的文本来验证我的程序:

1	<!DOCTYPE h/tml PUBLIC "-//W3C//DTD XHTML\" 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> sdfasdf//real comment here//"

认真分析单行注释的特点

正确地分析其特点, 是写出合理高效的程序的前提. 观察可知, 单行注释的特点如下:

1. 引号内(包括单引号和双引号)的双斜线不算注释.
2. 引号是配对出现的, 两个引号之间的以反斜线转义掉的引号不算结束符. 例如"hello \" //world", 这里的//world部分不能算做注释.
3. 由连续的非引号非斜线部分组成的字符串也不是注释. 特别指出, 单个斜线不能算做注释. 为什么前半部分不但要非引号而且要非斜线呢? 因为[^'"]+是有可能误匹配abcde//real comment "quoted string in comment"这样的情况, 因此我们归纳出一个条件[^'"/]+; 又因为还要避免abcde/real comment "quoted string in comment"这样的情况, 还需要特别补充规定单个的斜线不是注释. 正则式是[^'"/]|(?<!/)/(?!/).
4. 除去上述内容以外, 以双斜线开始直至行尾的部分就是注释. 因为我们用到了行尾这个概念, 需要在正则式中特别指出是^$匹配行首行尾的多行模式. 使用//m来表示.

正则实现

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#!/usr/bin/perl -w $str = <<"EOF"; <!DOCTYPE h/tml PUBLIC "-//W3C//DTD XHTML\" 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> sdfasdf//real comment here//" EOF #print $str; if ($str=~     m%         ^             (?:                 [^'"/]|                 (?<!/)/(?!/)|                 (?<quote>['"])                     (?:\\ \g{quote}|                     (?!\g{quote}).)*                 \g{quote}             )*             (?<comment>//.*)         $     %xm)     {         print $+{comment}; }

几点补充

• 该程序在perl5.10版才能运行成功. 因为用到了命名捕获(?<quote>['"])这样比较高阶的特性. 当然, 不使用5.10也并非没有办法, 我们大可以使用numbered capture, 只不过看起来更不直观罢了.
• 匹配结束后, 命名捕获都保存在hash表%+中了. 使用print $+{comment}这样的方式可以方便地调用.
• 指定了x模式, 以便加入空白字符和换行, 让正则表达式看起来有层次感. 事实上, 对于复杂的正则表达式, 不使用x模式是极其不明智的做法.
• 为了在字串中方便地表示单双引号, 使用了heredoc的方式. 个人觉得不如python的三重引号方便.

小结

从正则表达式的角度来说, javascript实在太弱. 当然, 也与本人的javascript功底较浅有关系. perl对于正则表达式的支持实在是强撼且不遗余力. 上面的实现, 应该可以涵盖绝大多数的注释情况了. 如果您测试出现bug, 或者遇到更BT的字串, 欢迎留言讨论.

rex按：

写完上一篇文章之后，一直在考虑如何真正实现从普通文本中归纳正则表达式的实现。走了许多弯路，也学了不少知识。例如，perl黑豹书上复杂的数据结构、匿名散列和数组、refenrence；紫龙书上的状态机的构造，数据结构上图论的知识，都是很有用的。另外还新学了graphviz的用法。以前觉得很神秘，不过一用才发现很直观。本文的插图是使用online版本的graphviz画的。

除了本文的这种实现方法（基于图），我还使用另一种方式实现了，很简单：基于关键词。具体作法是，逐一读取每一行文本，使用\s+等将其split开，形成array；然后再对所有的array进行求交集的操作（使用hash），得到每一行都有的关键词；然后按从左到右的顺序建立这覆的正则式^(.*?)keyword1(.*?)keyword2….keywordN(.*?)$，再分别匹配每一行文本，得到hash的hash表，或者array的array，转置，并列输出，得到^(option1|option2…)keyword1(option..)…$这样的正则式。最后作为验证，再将所最终生成的正则与每一行匹配测试一下。

这样以词为单位做完之后，再逐个字母地分隔开来，递归地处理(option1|option2…)的部分。先是单词级，再是字母级，有利于先在最大程度上找出重复的内容；而且粗化和细化的处理过程，思路是一致的，粒度不同罢了。

新手请自重，高手请赐教，我的思路未必是正确或最优的。

问题

有文本文件text.txt，内容如下：

this is a red fox

this is a blue firefox

this is a pig

a red fox

请写一则程序，根据文本内容，自动构造（比较合理的）正则表达式，使之能够匹配文件中每一行文本。

标准正则

有两种极端的解法是不可取的：

1. ^.*$
2. ^(this is a red fox|this is a blue firefox|this is a pig|a red fox)$

第一种失之于太宽泛，第二种失之于太狭隘。太宽泛则泥沙俱下，无论什么文本都能匹配；太狭隘则僵化死板，缺乏灵活性。好的正则表达式源于例文本（从例文本中提取规律），又高于例文本（能匹配同规律的其它文本）。匹配什么，排除什么，都有定则，所谓“君子有所为而有所不为”，指的就是这种情况（貌似跑题了:)）。

那么，如何是比较靠谱的正则表达式呢？以上文的例子而言，可以是：

^(this is )?a (red fox|blue firefox|pig)$

现在我们向着标准答案出发。

思路

任何复杂的电路图，都可以拆分为三种简单的关系：串联，并联，短路。正则表达式也同理。

既然是一条正则匹配所有的文本，那么这条正则（记为$re）也应该匹配第一行文本。

第一行文本为this is a red fox。那么，从^this is a red fox$应该是$re的一个（真）子集。它的路径为：“^”->this->is->a->red->fox->”$”。全部节点之间，是串联关系，从左到右依次排列即可。

示意图如下(可以点击看全尺寸图，下同)：

同理，第二行文本也应该是$re的子集。不过，由于已经存在了由^->this->is->a的路径，到a时出现支路，a->blue->firefox->$；

将此路径添加到示意图上，得到：

显而易见，这两条并列的支路，始于a，终于$，可以使用|来并列之。

好了，我们总结一下规律：

并列：如果存在A->B->C，且同时存在A->D->C，则B与D之间是并联关系。即出发点相同，结束点相同，且出发点与结束点之间各有一个以上的节点。并列使用括号来表示，之间以|分隔。例如，对于A->B->C，A->D->C，则可以使用A(B|D)C来表示其正则关系。

为什么要强调是一个以上节点呢？这里先卖个关子。请继续阅读。

再往下，this is a pig，同理，只需要在原图基础上添加a->pig->$的支路即可。此时图示如下：

最后一条，a red fox。这条貌似复杂，但是只需在^->a之间新添加了一条路径而已；a->red->fox->$之间原有路径，可以继续使用。此时，得到完整的示意图如下：

此时，观察可知，一种新的情况出现了。同时存在^->a，和“^”->this->is->a两条路径。想一下初中物理电路图，我们可以将这种情况称为“短路”，即，“^”->this->is->a这个线路的^、a两个节点之间，添加了一条无障碍通道，它能无视this、is的存在，因此，让this->is这条路径成为可选项。再总结一下规律：

如果有A->B->…C->D的路径，且有A->D的路径，则称A->D之间存在短路，此时,B->…->C可以用(B->…->C)?来表示(就是用括号来表示被短路的部分，问号表示短路之)。

顶点A,D之间，最多存在一个短路关系。但是可以有1或更多条并列的关系存在。

好了，分析结束，得到这样的正则式：

^(this is )?a (red fox|blue firefox|pig)$

这也就是为什么上文要强调是一个节点的缘故。

如果我们再精益求精的话，可以对red fox|blue firefox|pig这部分递归地进行上述分析过程，进而得到 (red |blue fire)fox|pig这样的结果。

实现

思路有了，编程就简单了。perl中，固然可以使用比较简洁的hash表来表示链表之间的关系：

例如：

my $hash;

$$hash{“^”}{“this”}{“is”}{“a”}{“red”}{“fox”}{“\$”}=”";

$$hash{“^”}{“this”}{“is”}{“a”}{“blue”}{“firefox”}{“\$”}=”";

…

但是，节点的增删修改都是麻烦事。（我在hash迷宫中lost了很久才爬出来）

抽空补了一下有向图的知识，觉得可以简化问题如下。

上图其实是一个有向图，只需记录所有的顶点集合，路径集合，再来求各路径之间的关系；最后打印输出，即是所求。

顶点集合为：

(^, this, is, a, red, fox, blue, firefox, pig, $);

通路关系集合为：

(^->this, this->is,…)

这两个集合在读取文本文件行的时候可以一次性建立。不复杂。关键是关系的确立。

再次总结，如下：

• 从一个顶点A出发的N条支路必定汇合（只是有时是同一个点，有时不在同一点而已。本文给出的例子是最简单的情况，这里可以假设为汇合到同一点）于M点。
• 这N条路中，每一条路径的长短以经过的节点个数来计算。例如上图中，^到a有一条路，上面的路径为2，下面的路径为0。
• 短的支路决定了这N条支路的关系。
• 长度为任意两点之间，最多只可能有一条长度为0的边。
• 如果存在长度为0的边，则其余的同级的支路被短路。
• 长度不为0的N-1条支路之间是并列关系。
• 整个图始于^，终于$。

这些条件、判断，均可以细化为函数。具体的程序从略。

值得一提的是，代码中用了$&, (?{}) 这样的perl only的东东，明晰了思路，简化了代码。如果不使用这种特性的话，代码要长5倍。另外，据说从效率上来说，use English之后，使用$MATCH比直接使用$&快5倍。但是对于即输入即执行的命令行程序来说，$&已经足够好。

实际应用一例：

源码：

简单观察可知，hello world!共重复4行；I love regex.重复2行。如何使用正则表达式来写一个程序，统计这些数据呢？因为现实中需要统计的文件，绝非是只凭肉眼就能观察出来。我想到了两种方法，第一种方法，是依赖于正则表达式（否则这篇文章也不会贴在这里）；第二种，hash表做主角，正则表达式作绿叶。

正则表达式的解法

思路是：对于任何一行文本，如果后面若干行[0～EOF）之后，如果存在相同的文本行，则记下该行内容，统计出现次数；然后删除这样的文本行，再进行下一行的统计。输出统计结果。

下面是相应的perl程序，附注释。

Hash表解法

这种方法，受益于perl语言本身的强大的hash表功能。思路如下：

• 建立空的hash表；
• 逐行读取文件；
• 以文本内容为key，插入到表中来。如果是首次出现，value为0，否则value++。
• 输出hash表中value>=2的记录。

Perl程序：

结果

上面的程序分别保存为dup_re.pl，dup_hash.pl。由于程序对于外部文件的读取的方法不同，运行方式也有差别，详见下图：

Update

忽然想到，如果要让这脚本更有效，可以指定忽略大小写，忽略单词间多个空格的情况，使得Hello world!与 　　hello　　 WORLd! 被视为重复行。测试了一下，正则式没让我失望。

原文在此。rex译于2009年12月15～17日，翻译过程中使用的是google docs@prism@firefox@ubuntu 9.10，很爽的体验。感谢余晟老师在正则和翻译方面的悉心指导。

平时我们用到的正则表达式，其实没那么“规则”。多数编程语言所支持的扩展的正则表达式，其运算能力比起形式语言理论所定义的“规则”正则表达式要强得多。

rex注：在这里其实可以看到，如果将正则表达式译为正规表达式，一切就都通顺了：
平时我们用到的正规表达式，其实没那么“正规”。多数编程语言所支持的扩展的正规表达式，其运算能力比起正式语言理论所定义的“正规”正规表达式要强得多。

regular expression的日文是“正规表现”，在鸟哥书中，好像也将其称为正规表达式。via

例如，经常用到的捕获缓存，就是用来帮助我们临时存储任意正则表达式模式，以便重复使用。 又如，“环视断言”能让正则表达式引擎在做决定之前先偷偷看看环视一下。这些扩展让正则表达式非常强大，足以描述一些“上下文无关语法”。

Perl语言的正则表达式引擎特性异常丰富，其特征之一是懒惰正则子表达式（Lazy regular subexpressions），格式为(??{code})，其中的“code”可以是任意一段perl程序，该子表达式可能匹配时，这段程序就会执行。

我们可以利用这一特征来编写出非常有趣的东西，即将正则表达式自身嵌在它的“code”部分，由此生成递归的正则表达式(a recursive regular expression)！

一直以来，正则表达式无法匹配0ⁿ1ⁿ这种表达式，也就是由若干个0以及同等数量的1所组成的字符串。如果使用懒惰正则子表达式，这一经典问题就迎刃而解。

下面是匹配0ⁿ1ⁿ字串的perl正则表达式代码。

rex注：紫龙书第四章有云：“文法是比正则表达式表达能力更强的表示方法。每个可以使用正则表达式描述的构造，都可以使用文法来描述，但是反之不成立。换句话说，每个正则语言都是一个上下文无关语言，但是反之不成立。”书中交待的正则，也应该是指的常规正则表达式，而非现代语言中的扩展的正则表达式。一般使用正则表达式来构造小部件，而使用文法来组建语言框架。

此正则表达式匹配一个字符0，之后是正则表达式自身0或1次，之后是字符1。如果正则表达式自身部分不能匹配，那么它只能匹配01；如果自身部分可以匹配，则正则表达式匹配的是00($regex)?11，此时若不能匹配自身则结果是0011，若可以匹配就是000($regex)?111，……依次顺延。

下面是匹配0⁵⁰⁰⁰⁰1⁵⁰⁰⁰⁰的Perl程序：

现在来看题图所示的Yo Dawg正则表达式。你先猜猜它的作用？正确答案是，它匹配(foo(bar())baz)这样完全嵌套的括号表达式（fully parenthesized expression）或((()()())())这样的平衡括号表达式（balanced parentheses）。

rex注：关于Yo Dawg图片的含义，可以参考这里。基本上是全是“Yo dawg, I herd you like X, so we put a Y in your Y so you can Z while you Z”的结构的配图文字。

构造此正则表达式的思路是这样的。对于完全嵌套的括号表达式，它的开始字符是一个开括号。这是最简单的一步，我们直接写出（上面程序中的(1)）。同理，它的结束字符是闭括号，于是得到(7)。现在该动脑筋了，括号中间是什么呢？对，它可以是既不是开括号又不是闭括号的任意字符（第(3)点），也可以是另一个完全嵌套的表达式（即第(5)点）。所有的这些，既可以只匹配0次（第(3)点），以便构造最小的完全嵌套括号表达式()，也可以匹配多次来匹配较复杂的表达式。

去掉 /x 选项（即，不再使用多行风格的注释模式），可以简记为：

但是切勿在正式产品中使用这一特性，它太诡异，不好把握。建议使用较稳定成熟的Text::Balanced 或 Regexp::Common 模块。

rex注：对于(??{code})，perl官方的提示是：此正则表达式仅作测试使用，可能有更新而不作提示。代码执行时产生的副作用，因版本而异，运行结果或有不同，取决于正则引擎的后期优化。

最后提醒大家，在Perl 5.10中已经可以使用递归捕获缓存来替代懒惰代码子表达式了，运行结果相同。

下面是匹配0ⁿ1ⁿ的递归捕获缓存语法(?N)的实现：

(?1)*的含义是“匹配第一组0或多次”，这里的第一组是指整个正则表达式。

请自行动手，重写平衡括号的正则表达式，当作练习。

祝玩得开心！

则输出：

注意事项：

1. 整数部分可以使用半角的逗号、空格、单引号、下划线、中划线分隔。
2. 分隔符的位置可以任意（每3位可，每4位也可），可以任意组合（可以混合使用上述的分隔符）。
3. 如果使用单引号，请注意在最外边加上双引号以免转义。

完整程序：

• 能否只用官方的API来获取全部饭否消息？
• 饭否消息结构
• 使用regex解析饭否消息
• 使用xml解析饭否消息
• 两相比较
• 相关阅读

批量导出饭否程序的方法很多，但是基本思路都是先将该网页保存到本地，然后将有用的饭否消息析取出来。本文不讨论如何下载饭否网页了（使用迅雷、wget、curl等），重点讨论对于下载到本地的网页，如何将有用的饭否消息析取出来。

小插曲：能否只用官方的API来获取全部饭否消息？

您或许会提议为什么不使用饭否自身的API。是的，饭否的API更快捷方便，兼容性很强。只是，饭否官方只提供下载前20条饭否消息的API。如果纯粹使用饭否官方API来下载全部饭否消息的方法也不是没有，只是很邪恶：

1 2 3 4 5 6

while (true) {     download 20 messages via API;     store them;     delete this 20 messages via API; }

一边下载一边删除，确实总能得到全部消息。删除了前面的20条，能保证后面的20条以新消息的面目出现。这在理论上是行得通的。但是我们需要的是英雄Heroes里Peter那样无损的复制方式，而不是Sylar那样的残忍的剪切方式，呵呵。既然官方的API有限制，我们就自己动手了。请继续阅读本文。

饭否消息结构

打开一个饭否消息网页的源代码，例如本人的
http://fanfou.com/regex/p.1（其实http://fanfou.com/regex是http://fanfou.com/regex/p.1的快捷方式。这里使用完整的路径，以便体现其一般性。），观察可见，有用的饭否消息在这个框架里面：（代码较长，阅读请点击展开）

Tips：在分析饭否源代码时，饭否消息全在一行，不便于阅读。您可以拷贝所需要的代码（注意前后结构的匹配呼应）到vim中，执行:%s/>/>\r/g(将每个>后面加上一个换行符)，再按ggvG全选，按=格式代码，所有的代码就成了漂亮的缩进格式，便于阅读了。

使用regex解析饭否消息

下面是使用regex来解析饭否消息的代码（直接拷贝自本人原来的perl抓饭程序。）

可以看出，使用正则表达式，能够比较真实地再现原网页代码的风貌。有几处小地方需要说明一下：

• 在第一组小括号里，我使用了([^<]+?)来捕获消息正文（一条完整的消息可以分为：消息正文；发送时间；消息uuid例如QD6qHiqUbeE，发送方法，类型（彩信还是文本））。最初是使用.*?的。但是这样不精确，有时候两条消息竟然混合在一起。而([^<]+?)捕获的是从当前位置开始至下一个<之前的所有内容。或许您会问，这不怕受到消息正文中可能出现的<的影响吗？答案是：不会受到影响。因为饭否会把所有的<以及其实有可能影响解析的字符，都转换成<的形式了，因此它不影响解析。同时，使用精确的正则表达式有助于提高效率，让不匹配的正则式尽早失败。
• (?:statuses|share)。这条正则表达式是用来捕获饭否的uuid。它不但能捕获以普通方法发布的消息（网页、短信、手机、API、IM工具等），还能捕获由“饭否分享”工具发布的消息。我不是很喜欢饭否分享这个工具。（或许改天有时间写篇文章，揭露它的缺点？）之所以把“饭否分享”消息和普通消息分开来说，是因为两者的结构是不一样的。
• 通过(网页|(?:\s*<[^>]+>)[^<]+(?:))这条正则式，既用了捕获型括号，又用了非捕获型括号。使用后者，能有效地避免程序太复杂，便于按序号引用（$1,$2等，如果越多则越混乱，修改正则式后，更是乱成一团遭），还能节省内存（如果程序中捕获了太多的内容，而不及时释放，或许会占尽资源。毕竟不是只捕获几十字节。要考虑到饭否用户或许有近十万条的饭否消息。指的是苹果流冰这样的“万玻南痨话”）
• xi选项：x是为了使用忽略空白字符和允许注释；i选项是忽略大小写。

使用正则表达式来析取饭否消息文本，需要考虑的细节很多。一处不细致，程序运行起来就会给你难看。饭否彩信的格式就略过不分析了。道理相同，点到为止。

使用xml解析饭否消息

再来看一下在python下，使用xml来解析饭否消息。注：该程序参考了ppip的pyfan程序。