我爱正则表达式 » rex http://iregex.org 原创、翻译、转载关于正则表达式的文章 Sun, 27 Jun 2010 04:20:24 +0000 en hourly 1 http://wordpress.org/?v=3.0 Python 中文正则笔记 http://iregex.org/blog/python-chinese-unicode-regular-expressions.html http://iregex.org/blog/python-chinese-unicode-regular-expressions.html#comments Sun, 27 Jun 2010 03:50:41 +0000 rex http://iregex.org/?p=129 总结在 python 语言里使用正则表达式匹配中文的经验。关键词：中文，cjk，utf8，unicode，python。

从字符串的角度来说，中文不如英文整齐、规范，这是不可避免的现实。本文结合网上资料以及个人经验，以 python 语言为例，稍作总结。欢迎补充或挑错。

一点经验

  • 可以使用 repr()函数查看字串的原始格式。这对于写正则表达式有所帮助。
  • Python 的 re模块有两个相似的函数：re.match(), re.search 。两个函数的匹配过程完全一致，只是起点不同。match只从字串的开始位置进行匹配，如果失败，它就此放弃；而search则会锲而不舍地完全遍历整个字串中所有可能的位置，直到成功地找到一个匹配，或者搜索完字串，以失败告终。如果你了解match的特性（在某些情况下比较快），大可以自由用它；如果不太清楚，search通常是你需要的那个函数。
  • 从一堆文本中，找出所有可能的匹配，以列表的形式返回，这种情况用findall()这个函数。例子见后面的代码。
  • utf8下，每个汉字占据3个字符位置，正则式为[\x80-\xff]{3}，这个都知道了吧。
  • unicode下，汉字的格式如\uXXXX，只要找到对应的字符集的范围，就能匹配相应的字串，方便从多语言文本中挑出所需要的某种语言的文本。不过，对于像日文这样的粘着语，既有中文字符，又有平假名片假名，或许结果会有所偏差。
  • 两种字符类可以并列在一起使用，例如，平假名、片假名、中文的放在一起，u"[\u4e00-\u9fa5\u3040-\u309f\u30a0-\u30ff]+"，来自定义所需要匹配的文本。
  • 匹配中文时，正则表达式和目标字串的格式必须相同。这一点至关重要。或者都用默认的utf8，此时你不用额外做什么；如果是unicode，就需要在正则式之前加上u""格式。
  • 可以这样定义unicode字符串：string=u"我爱正则表达式"。如果字串不是unicode的，可以使用unicode()函数转换之。如果你知道源字串的编码，可以使用newstr=unicode(oldstring, original_coding_name)的方式转换，例如 linux 下常用unicode(string, "utf8")，windows 下或许会用cp936吧，没测试。

例程序

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
#author:         rex
#blog:           http://iregex.org
#filename        py_utf8_unicode.py
#created:        2010-06-27 09:11

import re
def findPart(regex, text, name):
    res=re.findall(regex, text)
    if res:
        print "There are %d %s parts:\n"% (len(res), name)
        for r in res:
            print "\t",r
        print

#sample is utf8 by default.
sample='''en: Regular expression is a powerful tool for manipulating text.
zh: 正则表达式是一种很有用的处理文本的工具。
jp: 正規表現は非常に役に立つツールテキストを操作することです。
jp-char: あアいイうウえエおオ
kr:정규 표현식은 매우 유용한 도구 텍스트를 조작하는 것입니다.
puc: 。？！、，；：“ ”‘ ’——……·－·《》〈〉！￥％＆＊＃
'''
#let's look its raw representation under the hood:
print "the raw utf8 string is:\n", repr(sample)
print

#find the non-ascii chars:
findPart(r"[\x80-\xff]+",sample,"non-ascii")

#convert the utf8 to unicode
usample=unicode(sample,'utf8')

#let's look its raw representation under the hood:
print "the raw unicode string is:\n", repr(usample)
print

#get each language parts:
findPart(u"[\u4e00-\u9fa5]+", usample, "unicode chinese")
findPart(u"[\uac00-\ud7ff]+", usample, "unicode korean")
findPart(u"[\u30a0-\u30ff]+", usample, "unicode japanese katakana")
findPart(u"[\u3040-\u309f]+", usample, "unicode japanese hiragana")
findPart(u"[\u3000-\u303f\ufb00-\ufffd]+", usample, "unicode cjk Punctuation")

其输出结果为：

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
68
69
70
71
72
73
the raw utf8 string is:
'en: Regular expression is a powerful tool for manipulating text.\nzh: \xe6\xad\xa3\xe5\x88\x99\xe8\xa1\xa8\xe8\xbe\xbe\xe5\xbc\x8f\xe6\x98\xaf\xe4\xb8\x80\xe7\xa7\x8d\xe5\xbe\x88\xe6\x9c\x89\xe7\x94\xa8\xe7\x9a\x84\xe5\xa4\x84\xe7\x90\x86\xe6\x96\x87\xe6\x9c\xac\xe7\x9a\x84\xe5\xb7\xa5\xe5\x85\xb7\xe3\x80\x82\njp: \xe6\xad\xa3\xe8\xa6\x8f\xe8\xa1\xa8\xe7\x8f\xbe\xe3\x81\xaf\xe9\x9d\x9e\xe5\xb8\xb8\xe3\x81\xab\xe5\xbd\xb9\xe3\x81\xab\xe7\xab\x8b\xe3\x81\xa4\xe3\x83\x84\xe3\x83\xbc\xe3\x83\xab\xe3\x83\x86\xe3\x82\xad\xe3\x82\xb9\xe3\x83\x88\xe3\x82\x92\xe6\x93\x8d\xe4\xbd\x9c\xe3\x81\x99\xe3\x82\x8b\xe3\x81\x93\xe3\x81\xa8\xe3\x81\xa7\xe3\x81\x99\xe3\x80\x82\njp-char: \xe3\x81\x82\xe3\x82\xa2\xe3\x81\x84\xe3\x82\xa4\xe3\x81\x86\xe3\x82\xa6\xe3\x81\x88\xe3\x82\xa8\xe3\x81\x8a\xe3\x82\xaa\nkr:\xec\xa0\x95\xea\xb7\x9c \xed\x91\x9c\xed\x98\x84\xec\x8b\x9d\xec\x9d\x80 \xeb\xa7\xa4\xec\x9a\xb0 \xec\x9c\xa0\xec\x9a\xa9\xed\x95\x9c \xeb\x8f\x84\xea\xb5\xac \xed\x85\x8d\xec\x8a\xa4\xed\x8a\xb8\xeb\xa5\xbc \xec\xa1\xb0\xec\x9e\x91\xed\x95\x98\xeb\x8a\x94 \xea\xb2\x83\xec\x9e\x85\xeb\x8b\x88\xeb\x8b\xa4.\npuc: \xe3\x80\x82\xef\xbc\x9f\xef\xbc\x81\xe3\x80\x81\xef\xbc\x8c\xef\xbc\x9b\xef\xbc\x9a\xe2\x80\x9c \xe2\x80\x9d\xe2\x80\x98 \xe2\x80\x99\xe2\x80\x94\xe2\x80\x94\xe2\x80\xa6\xe2\x80\xa6\xc2\xb7\xef\xbc\x8d\xc2\xb7\xe3\x80\x8a\xe3\x80\x8b\xe3\x80\x88\xe3\x80\x89\xef\xbc\x81\xef\xbf\xa5\xef\xbc\x85\xef\xbc\x86\xef\xbc\x8a\xef\xbc\x83\n'

There are 14 non-ascii parts:

    正则表达式是一种很有用的处理文本的工具。
    正規表現は非常に役に立つツールテキストを操作することです。
    あアいイうウえエおオ
    정규
    표현식은
    매우
    유용한
    도구
    텍스트를
    조작하는
    것입니다
    。？！、，；：“
    ”‘
    ’——……·－·《》〈〉！￥％＆＊＃

the raw unicode string is:
u'en: Regular expression is a powerful tool for manipulating text.\nzh: \u6b63\u5219\u8868\u8fbe\u5f0f\u662f\u4e00\u79cd\u5f88\u6709\u7528\u7684\u5904\u7406\u6587\u672c\u7684\u5de5\u5177\u3002\njp: \u6b63\u898f\u8868\u73fe\u306f\u975e\u5e38\u306b\u5f79\u306b\u7acb\u3064\u30c4\u30fc\u30eb\u30c6\u30ad\u30b9\u30c8\u3092\u64cd\u4f5c\u3059\u308b\u3053\u3068\u3067\u3059\u3002\njp-char: \u3042\u30a2\u3044\u30a4\u3046\u30a6\u3048\u30a8\u304a\u30aa\nkr:\uc815\uaddc \ud45c\ud604\uc2dd\uc740 \ub9e4\uc6b0 \uc720\uc6a9\ud55c \ub3c4\uad6c \ud14d\uc2a4\ud2b8\ub97c \uc870\uc791\ud558\ub294 \uac83\uc785\ub2c8\ub2e4.\npuc: \u3002\uff1f\uff01\u3001\uff0c\uff1b\uff1a\u201c \u201d\u2018 \u2019\u2014\u2014\u2026\u2026\xb7\uff0d\xb7\u300a\u300b\u3008\u3009\uff01\uffe5\uff05\uff06\uff0a\uff03\n'

There are 6 unicode chinese parts:

    正则表达式是一种很有用的处理文本的工具
    正規表現
    非常
    役
    立
    操作

There are 8 unicode korean parts:

    정규
    표현식은
    매우
    유용한
    도구
    텍스트를
    조작하는
    것입니다

There are 6 unicode japanese katakana parts:

    ツールテキスト
    ア
    イ
    ウ
    エ
    オ

There are 11 unicode japanese hiragana parts:

    は
    に
    に
    つ
    を
    することです
    あ
    い
    う
    え
    お

There are 5 unicode cjk Punctuation parts:

    。
    。
    。？！、，；：
    －
    《》〈〉！￥％＆＊＃
]]> http://iregex.org/blog/python-chinese-unicode-regular-expressions.html/feed 11 正则笔记 http://iregex.org/blog/regex-note-20100621.html http://iregex.org/blog/regex-note-20100621.html#comments Mon, 21 Jun 2010 15:04:15 +0000 rex http://iregex.org/?p=128 笔记三则，贴在这里。

首字母大小写无关模式

有一段时间，我在写正则表达式来匹配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 正则替换代码。

]]> http://iregex.org/blog/regex-note-20100621.html/feed 4 Superor老师的正则表达式视频教程 http://iregex.org/blog/regex-tutorial-by-superor.html http://iregex.org/blog/regex-tutorial-by-superor.html#comments Sun, 20 Jun 2010 01:35:06 +0000 rex http://iregex.org/?p=127 浏览CU时发现Superor老师的《探索Perl的世界(更新到40集)-Perl 教学视频》（国人，中文），其中有5集是讲正则表达式的。观看之后觉得不错，贴在这里。

之前贴过余晟老师的正则表达式视频，由于各种不可抗力，所上传到各大空间的，也都渐渐不再能访问。我最早是从老友牛腩粉那里得到的，地址在此，可以留言，碰碰运气。

Superor老师的视频，其实不限于正则表达式，而是系统地讲解 Perl 的教程。我是断章取义，将正则表达式部分摘过来了。Superor老师也说过了，他在学习Perl时，准备了不少书，但是不是系统地看完，而是用到哪一部分，就细读这一部分的全部内容。学正则表达式也可如此。

视频是在线的，效果不错，虽然会插播广告。

第20集：第八章 正则表达式

http://www.boobooke.com/v/bbk3748

第21集：第八章 正则表达式

http://www.boobooke.com/v/bbk3749

第22集：第八章 正则表达式

http://www.boobooke.com/v/bbk3750

第23集：第八章 正则表达式

http://www.boobooke.com/v/bbk3751

第24集：第八章 正则表达式

http://www.boobooke.com/v/bbk3752

]]> http://iregex.org/blog/regex-tutorial-by-superor.html/feed 0 小议“排除型匹配” http://iregex.org/blog/negate-match.html http://iregex.org/blog/negate-match.html#comments Mon, 24 May 2010 08:46:29 +0000 rex http://iregex.org/?p=122 网友cfc4n问及关于(?!)的正则表达式问题。回答之后，顺便总结了一下Perl语言中如何匹配“不出现”某元素，贴在这里。

问题

问题描述

有如下文本，如何使用正则式，将其中不含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>。

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

]]> http://iregex.org/blog/negate-match.html/feed 2 打造自己的正则表达式助手程序 http://iregex.org/blog/diy-regexbuddy.html http://iregex.org/blog/diy-regexbuddy.html#comments Wed, 12 May 2010 05:32:37 +0000 rex http://iregex.org/?p=115 其实RegexBuddy挺好用的，我一直用它。它的用法、好处，可以写好多文字，本站也做过介绍；不过，也有理由不用它，同时这也是撰写本文的一个原因。我动了动脑筋，花了一点时间，已经做出雏形。现在将思路公布在这里，与各位交流一下。

缘由

为什么不用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的协助。

截图

  • Photobucket
  • Photobucket
  • Photobucket
  • Photobucket
]]> http://iregex.org/blog/diy-regexbuddy.html/feed 11 PHP中的递归正则 http://iregex.org/blog/recursive-regex-in-php.html http://iregex.org/blog/recursive-regex-in-php.html#comments Mon, 10 May 2010 04:57:28 +0000 rex http://iregex.org/?p=84 之前一篇文章翻译了Perl语言中的递归正则表达式. 其实不少语言中的正则都是支持递归的, 例如本文要介绍的PHP正则递归. 虽然, 工作中最常用的正则表达式都很”正则”, 只用最基本的语法就能解决85%以上的问题, 而且合理有效地使用普通正则来解决复杂问题也是一门技巧与学问; 但是高级一点的语法的确有它存的价值, 有时不用它还真办不了事儿; 况且学习正则的乐趣也在于尝试各种各样的可能性, 满足自己无穷无尽的好奇心.

本文内容, 整理自网文Finer points of PHP regular expressions. 其分析过程剥茧抽丝, 丝丝入扣, 值得一读. 该文系统地列出了PHP中正则表达式常见特性, 我只摘取其中递归部分翻译整理出来.

正文

例子

什么时候会用到递归正则表达式呢? 当然是待匹配的字串中递归地出现某种模式时(貌似废话). 最经典的例子, 就是递归正则处理嵌套括号的问题了. 例子如下.

假设你的文本中包含了正确配对的嵌套括号. 括号的深度可以是无限层. 你想捕获这样的括号组.

恕我剧透, 标准答案是这样的:

1
2
3
4
5
6
7
<?php
$string = "some text (a(b(c)d)e) more text";
if(preg_match("/\(([^()]+|(?R))*\)/",$string,$matches))
{
    echo "<pre>"; print_r($matches); echo "</pre>";
}
?>

其输出结果是:

1
2
3
4
5
Array
(
    [0] => (a(b(c)d)e)
    [1] => e    
)

可见, 我们所需要的文本, 已经捕获到$matches[0]中了.

原理

现在思考原理.

上面的正则表达式中的关键点是(?R). (?R)的作用就是递归地替换它所在的整条正则表达式. 在每次迭代时, PHP 语法分析器都会将(?R)替换为”\(([^()]+|(?R))*\)“.

因此, 具体到上述的例子, 其正则表达式等价于:

"/\(([^()]+|\(([^()]+|\(([^()]+)*\))*\))*\)/"

但是上面的代码只适合深度为3层的括号. 对于未知深度的括号嵌套, 就只好使用这种正则了:

"/\(([^()]+|(?R))*\)/"

它不但能够匹配无限深度, 还简化了正则表达式的语法. 功能强大, 语法简洁.

现在来细看一下"/\(([^()]+|(?R))*\)/"是怎样匹配"(a(b(c)d)e)"的:

  1. "(c)"这部分被正则式 "\(([^()]+)*\)" 匹配. 请注意, (c) 其实就相当于整个递归的一个缩影, 麻雀虽小五脏俱全, 因此它用到了整个正则表达式.
    换言之, 下一步中的(c), 可以使用(?R) 来匹配.
  2. (b(c)d)的匹配过程为:
    1. "\("匹配"(";
    2. "[^()]+"匹配"b";
    3.  (?R)匹配"(c)";
    4. "[^()]+"匹配"d";
    5. "\)"匹配")".

根据上面的匹配原理, 不难理解为什么数组的第2个元素$matches[1]与'e'等价. 子串'e'是在最后一次匹配迭代中被捕获. 匹配过程中, 只有最后一次的捕获结果才会保存到数组中.

rex注: 关于这个特性, 可以自行尝试一下, 看看使用正则式([a-z]+[0-9]+)+来匹配字串abc123xyz890, 其捕获结果$1是什么. 注意, 其结果与 Left Longest 原理并不冲突.

如果我们只需要捕获 $matches[0], 可以这样做:

1
2
3
4
5
6
7
<?php
    $string = "some text (a(b(c)d)e) more text";
    if(preg_match("/\((?:[^()]+|(?R))*\)/",$string,$matches))
    {
        echo "<pre>"; print_r($matches); echo "</pre>";
    }
?>

产生的结果相同:

1
2
3
4
Array
    (
     [0] => (a(b(c)d)e)
    )

所做的改动是捕获括号()改为非捕获捕获括号(?:)了.

还可以进一步完善为:

1
2
3
4
5
6
7
<?php
    $string = "some text (a(b(c)d)e) more text";
    if(preg_match("/\((?>[^()]+|(?R))*\)/",$string,$matches))
    {
        echo "<pre>"; print_r($matches); echo "</pre>";
    }
?>

这里我们用到了所谓的一次性模式(rex注: 余晟先生译的《精通正则表达式v3.0》中, 谓之”固化分组”. 可参考该书.) PHP手册也推荐只要条件允许, 就尽可能使用这种模式, 以便提升正则表达式的速度.

一次性模式很简单, 这里不再详述. 如果感兴趣, 可以参考PHP 官方手册. 如果您想深入学习PERL兼容式正则表达式, 请参考文末链接.

提到的链接

]]> http://iregex.org/blog/recursive-regex-in-php.html/feed 5 搬家完毕 http://iregex.org/blog/moved.html http://iregex.org/blog/moved.html#comments Tue, 04 May 2010 01:57:32 +0000 rex http://iregex.org/?p=86 原空间(homezz.com)到期, 顺便换为法国alwaysdata.com的了. 搬家很顺利, 使用scp将数据从原空间隔空传物过去; 配置好域名dns, 数据文件, 新空间就激活了. 很顺利.

另, 新站的访问速度如何? 可以接受吗?

目前在蕴酿一篇关于”如何DIY一款像RegexBuddy那样的正则表达式工具”的博客, 敬请期待.

]]> http://iregex.org/blog/moved.html/feed 6 五一搬家 http://iregex.org/blog/moving.html http://iregex.org/blog/moving.html#comments Thu, 29 Apr 2010 10:53:30 +0000 rex http://iregex.org/?p=85 本站在五一期间将更换空间。

]]> http://iregex.org/blog/moving.html/feed 7 使用正则表达式删除注释 http://iregex.org/blog/uncomment-program-with-regex.html http://iregex.org/blog/uncomment-program-with-regex.html#comments Sat, 03 Apr 2010 09:51:56 +0000 rex http://iregex.org/?p=83 问题

以下摘自某网友来信:

javascript正则中的否定前瞻

难点

  1. javascript不支持点号匹配换行符, 因此无法直接进行多行匹配;
  2. 处理前面没有http:的//, 当然要用否定前瞻( negative lookbehine)了:(?<!http:)\/\/. 可惜javascript不支持.
    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的字串, 欢迎留言讨论.

]]> http://iregex.org/blog/uncomment-program-with-regex.html/feed 14 [链接]使用正则表达式搜索文本文件 http://iregex.org/blog/search-text-file-with-regex.html http://iregex.org/blog/search-text-file-with-regex.html#comments Sat, 27 Mar 2010 09:15:46 +0000 rex http://iregex.org/blog/%e9%93%be%e6%8e%a5%e4%bd%bf%e7%94%a8%e6%ad%a3%e5%88%99%e8%a1%a8%e8%be%be%e5%bc%8f%e6%90%9c%e7%b4%a2%e6%96%87%e6%9c%ac%e6%96%87%e4%bb%b6.html IBM文库发布一篇新文章：

正则表达式新手和老手都可以一读。副标题“在大海里捞针”很有意思。

]]> http://iregex.org/blog/search-text-file-with-regex.html/feed 0