我爱正则表达式 » 应用 http://iregex.org 原创、翻译、转载关于正则表达式的文章 Tue, 29 Mar 2011 05:04:10 +0000 en hourly 1 http://wordpress.org/?v=3.3 较安全的rm脚本 http://iregex.org/blog/safer-rm-command.html http://iregex.org/blog/safer-rm-command.html#comments Tue, 29 Mar 2011 05:00:18 +0000 rex http://iregex.org/?p=155 想必不少人体会过在Linux下误删文件的欲哭无泪的感觉。我整理出一份比较安全的rm脚本，贴在这里。

特性

  • 接管原生的/bin/rm命令，将待删除的文件mv至回收站，便于统一管理，或者更重要的，拯救误删文件。
  • 需要调用原生的rm时，指定路径即可，例如：/bin/rm -rf somefolder
  • 记录删除日志到/var/log/trash.log。如果不需要记录日志，只需要将log变量置空即可。
  • 将文件移动至回收站时自动重命名，以便可以重复删除重名文件。
  • 贴图：我爱正则表达式

贴代码

用法

  • 将下面的代码贴至~/.bashrc 或 ~/.bash_profile中，然后刷新该文件source ~/.bashrc即可。
  • 临时取消自定义的rm：可以使用前文所说的/bin/rm或在当前环境下取消该function的定义：unset -f rm。
  • 需要根据自己的系统，修改一下各个变量的定义。
    • 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
    #safe remove, mv the files to .Trash with unique name
    #and log the acction
    function rm()
    {
        trash="$HOME/.Trash"
        log="/var/log/trash.log"
        stamp=`date "+%Y-%m-%d %H:%M:%S"` #current time

        while [ -f "$1" ]; do

            #remove the possible ending /
            file=`echo $1 |sed 's#\/$##' `

            pure_filename=`echo $file  |awk -F / '{print $NF}' |sed -e "s#^\.##" `

            if [ `echo $pure_filename | grep "\." ` ]; then
                new_file=` echo $pure_filename |sed -e "s/\([^.]*$\)/$RANDOM.\1/" `
            else
                new_file="$pure_filename.$RANDOM"
            fi

            trash_file="$trash/$new_file"
            mv "$file" "$trash_file"

            if [ -w $log ]; then
                echo -e "[$stamp]\t$file\t=>\t[$trash_file]" |tee -a $log
            else
                echo -e "[$stamp]\t$file\t=>\t[$trash_file]"
            fi

            shift   #increment the loop
        done
    }
    ]]>     http://iregex.org/blog/safer-rm-command.html/feed 30     搞定Mac下的郑码输入法 http://iregex.org/blog/zhengma-on-openvanilla-for-mac.html http://iregex.org/blog/zhengma-on-openvanilla-for-mac.html#comments Sun, 07 Nov 2010 14:43:05 +0000 rex http://iregex.org/?p=152 最近用上了Mac, 苦于没有一份好用的郑码输入法. 于是发挥不怕折腾的精神, 自己制作一份码表, 记在这里.

    郑码

    估计没多少人使用郑码吧, 这是一个非常小众的输入法方案, 与五笔类似, 据说更”规则”. 没有用过五笔, 不好评价. 个人比较喜欢, 一直在用. 无论如何, 拼音输入法是无福消受的.

    在Ubuntu下可以使用 ibus, 但是在Mac下就没有这么幸运了. Fit是不错的输入法, 但是只有内置的拼音和五笔, 暂不支持自定义码表; QIM是收费软件, 貌似可以自定义码表, 但它缺少文档, 找了半天没发现多少有用信息.

    搜索一番, 找到一个OpenVanilla, 香草输入法. 免费, 开放, 支持自定义码表. 地址在这里 . 另外从郑码爱好者家园上看到一个类似的解决方案, 只不过不太完美(例如, 无法忍受的词频混乱问题). 地址在这里 .

    做一份郑码码表

    词汇列表: 使用的是搜狗实验室的语料文本. 地址在这里 , 格式为 “词A 词频 词性1 词性2 … 词性N”, 取自己有用的词汇以及对应词频信息即可. 该文件只有两字词至多字词, 没有单个汉字的字频信息.

    字频列表: 在 lingua.mtsu.edu 上找到了字频列表, 令人喜出望外的是, 它还带有单字的(多音字)拼音/声调. 这为我打造一份带有拼音辅助的码表方案提供了极大的便利. 其实拼音只作为形码的辅助而使用, 只有打不出的字才反查拼音, 无需单字或词汇的简拼信息. 又因为它是辅助, 因此将所有的拼音信息放在做好的列表的末尾即可.

    有了上述的两个文件, 就可以准备做码表了. 不过, 还需要单字的构词码码表, 以及约定俗成的快速码表(例如, 对于”北京”一词, 郑码有两种打法, 一是简单的ts, 一是正规的trsj). 单字构词码表之前我已经准备出来了, 后者我从网上搜索到的郑码光盘中找到了大字集的码表.

    制作的过程不难, 不过细节不少. 不赘述. 过程中当然少不了正则表达式的帮忙.

    最终做出来的是五码郑码. 非常好用. 每次启动香草时要花一秒钟左右的时间, 但是一旦运行起来, 就感觉不到了. 毕竟, 最终的词汇列表为19万条之巨.

    香草的最大的优势在于开放和免费. 比起qim或fit来, 它作为一个输入法, 支持的特性/自定义功能实在有限. 连自定义切换中英文也不可以, 更不用说动态调整词频和增删词条了. 我写了一个bash function, 用来搜索现有的词条; 写了一个bash脚本, 用来删除词条; 写了一个python程序, 用来动态添加新词.

    最后这个添加新词的python程序还是比较好玩的. 支持从命令行中或文件中读取词汇列表, 批量添加到词库中. 添加过程中它自己生成格式正确的郑码编码; 添加完毕之后还会杀死香草, 以便重新加载新词库.

    程序push到github了. 在这里.

    Photobucket

    Update

  • 2010-11-08查看了一下香草的其它输入法码表，搞定了标点符号。
    • ]]>     http://iregex.org/blog/zhengma-on-openvanilla-for-mac.html/feed 7     一个简单的中文分词程序 http://iregex.org/blog/simple-nlp-for-chinese.html http://iregex.org/blog/simple-nlp-for-chinese.html#comments Sun, 26 Sep 2010 14:41:12 +0000 rex http://iregex.org/?p=151

    kds:“前驻法大使吴建民指出，应该理**国”,想了一下，原来两个星号是“性爱”两字，生活在一个机械屏蔽时代的中国还真有喜感。——via

    想必您也看到了推特上关于“理＊＊国”的笑话了。我正好想学一下中文分词方面的知识，这是第一篇。

    分词原理与实现

    英语等以空白字符作为分隔符的语言，分词不是问题。中文分词，需要处理的细节太多。单就“真歧义”这一问题（简言之，如果没有上下文，连活生生的人也无法确定如何断句的歧义句）的处理方法而言，前辈们就已写出洋洋洒洒许多文字。不过这属于进阶题目。我想先实现一个最简单的分词程序。

    以我的理解，最简单的分词程序，应该是先将中文文本切成最小的单位－－汉字－－再从词典里找词，将这些字按照最左最长原则（与正则精神暗合），合并为以词为单位的集合。这样的应该是最快的，只按照给定的数据划分合并即可，不必考虑语法元素的权重（词性：名动形数量代等等，语法：主谓宾定状补），以及上下文的出现次数。

    关于源文本的切分，就参照《统计汉字／英文单词数》一文的思路，使用正则表达式r"(?x) (?: [\w-]+  | [\x80-\xff]{3} )")来匹配即可。

    关于词典，我使用的是CC-CEDICT的词典，原因有三：没有版权问题；速度较快；Chrome也在用它（发现了吧：在Chrome上双击中文句子，会自动选择中文词汇而不是单字或整行进行反选高亮）。

    接下来是如何分词。经过思考，我发现搜索树的原理可以拿来就用。原理请见此文：Trie in Python。具体方法是，将词库逐字读入内存，建立搜索树；然后对目标文本进行逐字分析，如果该字之后还可搜索，则继续搜索；否则停止，作为一个词汇单位处理。

    这样的算法理论上比较快（未进行benchmark），原因有三：使用Trie结构，本质上是哈希表，空间换时间，是O(0)级的搜索；词库只有800K，可以轻易载入，内存空间没占多少；算法最慢的部分是载入Trie的阶段，之后速度就不再受影响。

    不过，谈到它的扩充性，目前只能在words.txt中手动添加新词，而不能实现机器学习。

    源码

    完整的程序（包括我处理过的词库列表）放在github上了。有兴趣的可以把玩一下。这里列出主程序：

    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
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    #
    #author:         rex
    #blog:           http://iregex.org
    #filename        nlp.py
    #created:        2010-09-26 19:15

    import re
    import sys

    regex=re.compile(r"(?x) (?: [\w-]+  | [\x80-\xff]{3} )")

    def init_wordslist(fn="./words.txt"):
        f=open(fn)
        lines=sorted(f.readlines())
        f.close()
        return lines

    def words_2_trie(wordslist):
        d={}
        for word in wordslist:
            ref=d
            chars=regex.findall(word)
            for char in chars:
                ref[char]=ref.has_key(char) and ref[char] or {}
                ref=ref[char]
            ref['']=1
        return d

    def search_in_trie(chars, trie):
        ref=trie
        index=0
        for char in chars:
            if ref.has_key(char):
                print char,
                ref=ref[char]
                index+=1
            else:
                if index==0:
                    index=1
                    print char,
                print '*',
                try:
                    chars=chars[index:]
                    search_in_trie(chars, trie)
                except:
                    pass
                break
    def main():
        #init
        words=init_wordslist()
        trie=words_2_trie(words)
        #read content
        fn=sys.argv[1]
        string=open(fn).read()
        chars=regex.findall(string)
       
        #do the job
        search_in_trie(chars, trie)

    if __name__=='__main__':
        main()

    本机测试

    测试的文本如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    只听得一个女子低低应了一声。绿竹翁道：“姑姑请看，这部琴谱可有些古怪。”那
    女子又嗯了一声，琴音响起，调了调弦，停了一会，似是在将断了的琴弦换去，又调了调
    弦，便奏了起来。初时所奏和绿竹翁相同，到后来越转越高，那琴韵竟然履险如夷，举重
    若轻，毫不费力的便转了上去。令狐冲又惊又喜，依稀记得便是那天晚上所听到曲洋所奏
    的琴韵。这一曲时而慷慨激昂，时而温柔雅致，令狐冲虽不明乐理，但觉这位婆婆所奏，
    和曲洋所奏的曲调虽同，意趣却大有差别。这婆婆所奏的曲调平和中正，令人听着只觉音
    乐之美，却无曲洋所奏热血如沸的激奋。奏了良久，琴韵渐缓，似乎乐音在不住远去，倒
    像奏琴之人走出了数十丈之遥，又走到数里之外，细微几不可再闻。

    理性爱国
    性爱体验
    我爱正则表达式

    请留意末尾三行。

    再看一下程序处理的结果：（＊表示词汇间的分隔）

    1
    只 * 听 得 * 一 个 * 女 子 * 低 低 * 应 * 了 * 一 声 * 。 * 绿 * 竹 * 翁 * 道 * ： * “ * 姑 姑 * 请 看 * ， * 这 * 部 * 琴 * 谱 * 可 有 * 些 * 古 怪 * 。 * ” * 那 * 女 子 * 又 * 嗯 * 了 * 一 声 * ， * 琴 * 音 响 * 起 * ， * 调 * 了 * 调 * 弦 * ， * 停 * 了 * 一 会 * ， * 似 是 * 在 * 将 * 断 * 了 * 的 * 琴 弦 * 换 * 去 * ， * 又 * 调 * 了 * 调 * 弦 * ， * 便 * 奏 * 了 * 起 来 * 。 * 初 * 时 * 所 * 奏 * 和 * 绿 * 竹 * 翁 * 相 同 * ， * 到 * 后 来 * 越 * 转 * 越 * 高 * ， * 那 * 琴 * 韵 * 竟 然 * 履 险 如 夷 * ， * 举 重 * 若 * 轻 * ， * 毫 不 费 力 * 的 * 便 * 转 * 了 * 上 去 * 。 * 令 狐 * 冲 * 又 * 惊 * 又 * 喜 * ， * 依 稀 * 记 得 * 便 是 * 那 天 * 晚 上 * 所 * 听 到 * 曲 * 洋 * 所 * 奏 * 的 * 琴 * 韵 * 。 * 这 一 * 曲 * 时 而 * 慷 慨 * 激 昂 * ， * 时 而 * 温 柔 * 雅 致 * ， * 令 狐 * 冲 * 虽 * 不 明 * 乐 理 * ， * 但 * 觉 * 这 位 * 婆 婆 * 所 * 奏 * ， * 和 * 曲 * 洋 * 所 * 奏 * 的 * 曲 调 * 虽 * 同 * ， * 意 趣 * 却 * 大 有 * 差 别 * 。 * 这 * 婆 婆 * 所 * 奏 * 的 * 曲 调 * 平 和 * 中 正 * ， * 令 人 * 听 * 着 * 只 * 觉 * 音 乐 之 * 美 * ， * 却 * 无 * 曲 * 洋 * 所 * 奏 * 热 血 * 如 * 沸 * 的 * 激 * 奋 * 。 * 奏 * 了 * 良 久 * ， * 琴 * 韵 * 渐 * 缓 * ， * 似 乎 * 乐 音 * 在 * 不 住 * 远 * 去 * ， * 倒 像 * 奏 * 琴 * 之 * 人 * 走 出 * 了 * 数 十 * 丈 * 之 * 遥 * ， * 又 * 走 * 到 * 数 * 里 * 之 外 * ， * 细 微 * 几 * 不 可 再 * 闻 * 。 * 理 性 * 爱 国 * 性 爱 * 体 验 * 我 * 爱 * 正 则 * 表 达 式

    更新

    2010-10-03更新:发现本程序的一个bug。已改进算法，更精确，更快速。程序详见GitHub，链接如前。

    请看新程序的分词结果：

    只 * 听 * 得 * 一 * 个 * 女子 * 低 * 低 * 应 * 了 * 一声 * 。 * 绿 * 竹 * 翁 * 道 * ： * “ * 姑姑 * 请看 * ， * 这 * 部 * 琴谱 * 可 * 有些 * 古怪 * 。 * ” * 那 * 女子 * 又 * 嗯 * 了 * 一声 * ， * 琴 * 音响 * 起 * ， * 调 * 了 * 调 * 弦 * ， * 停 * 了 * 一会 * ， * 似 * 是 * 在 * 将 * 断 * 了 * 的 * 琴弦 * 换 * 去 * ， * 又 * 调 * 了 * 调 * 弦 * ， * 便 * 奏 * 了 * 起来 * 。 * 初 * 时 * 所 * 奏 * 和 * 绿 * 竹 * 翁 * 相同 * ， * 到 * 后来 * 越 * 转 * 越 * 高 * ， * 那 * 琴 * 韵 * 竟然 * 履 * 险 * 如 * 夷 * ， * 举重 * 若 * 轻 * ， * 毫不 * 费力 * 的 * 便 * 转 * 了 * 上去 * 。 * 令狐 * 冲 * 又 * 惊 * 又 * 喜 * ， * 依稀 * 记得 * 便是 * 那天 * 晚上 * 所 * 听到 * 曲 * 洋 * 所 * 奏 * 的 * 琴 * 韵 * 。 * 这 * 一 * 曲 * 时而 * 慷慨 * 激昂 * ， * 时而 * 温柔 * 雅致 * ， * 令狐 * 冲 * 虽 * 不明 * 乐理 * ， * 但 * 觉 * 这位 * 婆婆 * 所 * 奏 * ， * 和 * 曲 * 洋 * 所 * 奏 * 的 * 曲调 * 虽 * 同 * ， * 意趣 * 却 * 大有 * 差别 * 。 * 这 * 婆婆 * 所 * 奏 * 的 * 曲调 * 平和 * 中正 * ， * 令人 * 听 * 着 * 只 * 觉 * 音乐 * 之 * 美 * ， * 却 * 无 * 曲 * 洋 * 所 * 奏 * 热血 * 如 * 沸 * 的 * 激 * 奋 * 。 * 奏 * 了 * 良久 * ， * 琴 * 韵 * 渐 * 缓 * ， * 似乎 * 乐音 * 在 * 不住 * 远 * 去 * ， * 倒像 * 奏 * 琴 * 之 * 人 * 走出 * 了 * 数 * 十 * 丈 * 之 * 遥 * ， * 又 * 走 * 到 * 数 * 里 * 之外 * ， * 细微 * 几 * 不可 * 再 * 闻 * 。 *

    理性 * 爱国 *

    性爱 * 体验 *

    我 * 爱 * 正则 * 表达式 *

    轻 * 音乐 *

    ]]>     http://iregex.org/blog/simple-nlp-for-chinese.html/feed 17     统计汉字／英文单词数 http://iregex.org/blog/words-counter-in-python.html http://iregex.org/blog/words-counter-in-python.html#comments Sat, 25 Sep 2010 11:25:38 +0000 rex http://iregex.org/?p=148 一个简单的程序，统计文本文档中的单词和汉字数，逆序排列（出现频率高的排在最前面）。python实现。

    思路

    • 使用正则式 "(?x) (?: [\w-]+  | [\x80-\xff]{3} )"获得utf-8文档中的英文单词和汉字的列表。
    • 使用dictionary来记录每个单词／汉字出现的频率，如果出现过则＋1，如果没出现则置1。
    • 将dictionary按照value排序，输出。

    源码

    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
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    #
    #author:         rex
    #blog:           http://iregex.org
    #filename        counter.py
    #created:        Mon Sep 20 21:00:52 2010
    #desc:           convert .py file to html with VIM.

    import sys
    import re
    from operator import itemgetter

    def readfile(f):
        with file(f,"r") as pFile:
            return pFile.read()
           
    def divide(c, regex):
        #the regex below is only valid for utf8 coding
        return regex.findall(c)
       

    def update_dict(di,li):
        for i in li:
            if di.has_key(i):
                di[i]+=1
            else:
                di[i]=1
        return di
       
    def main():

        #receive files from bash
        files=sys.argv[1:]
       
        #regex compile only once
        regex=re.compile("(?x) (?: [\w-]+  | [\x80-\xff]{3} )")

        dict={}

        #get all words from files
        for f in files:
            words=divide(readfile(f), regex)
            dict=update_dict(dict, words)

        #sort dictionary by value
        #dict is now a list.
        dict=sorted(dict.items(), key=itemgetter(1), reverse=True)

        #output to standard-output
        for i in dict:
            print i[0], i[1]


    if __name__=='__main__':
        main()

    Tips

    由于使用了files=sys.argv[1:] 来接收参数，因此./counter.py file1 file2 ...可以将参数指定的文件的词频累加计算输出。

    可以自定义该程序。例如，

    • 使用
      1
      2
      regex=re.compile("(?x) ( [\w-]+  | [\x80-\xff]{3} )")
      words=[w for w in regex.split(line) if w]

      这样得到的列表是包含分隔符在内的单词列表，方便于以后对全文分词再做操作。

    • 以行为单位处理文件，而不是将整个文件读入内存，在处理大文件时可以节约内存。
    • 可以使用这样的正则表达式先对整个文件预处理一下，去掉可能的html tags: content=re.sub(r"<[^>]+","",content)，这样的结果对于某些文档更精确。
    ]]>     http://iregex.org/blog/words-counter-in-python.html/feed 4     打造自己的正则表达式助手程序 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 15     better downloader in perl http://iregex.org/blog/better-downloader-in-perl.html http://iregex.org/blog/better-downloader-in-perl.html#comments Sun, 14 Mar 2010 16:08:12 +0000 rex http://iregex.org/?p=80 这两天写了一段perl程序，输入url地址，下载其中的文件，计算MD5值，查该文件是否是病毒；如果无记录，则调用另外一个perl脚本将其上传到某一网站作详细测试。我想说的是，这些功能可能使用bash来编程，会更直接；用perl来做bash的事情总有些越俎代庖。不过，目前我对perl极感兴趣；有机会就用它；另外，将不成熟的代码贴出来，留给未来的自己一个鄙视现在的自己的机会也好:)

    一个小小的发现是，qx可以将所包含的语句当作bash命令来执行，并把结果返回。另外书中交待，eval也是极有用的，不过这次没用上，下次找机会牛刀小试一把。

    之所以没有使用curl, md5等等模块，而是使用shell命令，是因为我所用的虚拟机里没有安装，但是它们是bash下标准的可执行文件。这样写来，效率会有点折扣，但是绿色便携。

    无废话，贴代码。

    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
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    #!/usr/bin/perl -w

    #this script offers a better download service
    #integreting virustotal infor, send-sample.pl
    #by rex.zhang
    #on 03-11-2010 in Shanghai
    #updated @003122010;

    my ($url)=$ARGV[0];

    #it is assumed that the filename is the last part of the url,
    #just after the last / and before the $
    main($url);

    sub main
    {
        my ($url)=@_;

        #print help message and quit if no url input;
        help() if (not $url);
       
        my ($md5,$size,$name);
        $url =~ /\/([^\/]+)$/;

        #get the filename from the url;
        $name=$1;

        #get filesize from the url; if no size got, quit.
        $size=get_filesize($url);
        exit if $size;

        #try 5 times at most to get the file.
        my ($try)=5;
        my $ok;
        while($try--)
        {
          $ok=download_file($url);
          last if $ok;
        }
        if (not $ok)
        {
            print "can not download the file, quit!\n";
            exit();
        }

        #get the md5 locally
        $md5=get_md5($name);

        #and the url link from $virustotal;
        my ($link)=get_vt_link($md5);
        if ($link)
        {
            #and even the virus infor;
            my ($info)=get_vt_info($link);
            if (not $info)
            {
                v_test($name,$md5);
                print "\nSample has been sent to vtest. \nthanks for using.\n\n";
            }
        }
    }

    #return the md5 value of the file.
    #the filename is in the current directory
    sub get_md5
    {
        my ($filename)=@_;
        my $md5=`md5sum $filename`;
        $md5 =~ /^(\w{32})/;
        print "\nthe md5 of the $filename is:\t $1.\n";
        return $1;
    }

    #get the virustotal link with the given md5 value;
    sub get_vt_link
    {
        my($md5)=@_;
        my ($link)=`curl -s -e "https://www.virustotal.com" -d "x=80&y=23&hash=$md5" "http://www.virustotal.com/vt/en/consultamd5" | grep href`;
        my ($bool)= $link =~ /href="([^"]+)"/i;
            if ($bool)
            {
                return "http://www.virustotal.com".$1;
            }
            else
            {
                return 0;
            }
    }

    #get the virus infor according to a virus total infor link
    sub get_vt_info
    {
        my($url)=@_;
        my $line;
        my $sophos =0;     #if sophos has no detection, do the vtest.
            foreach (qx{curl -s $url})
            {
                $line.=$_;
            }
        my (@result) = $line=~ m!<tr[^>]*>\s*<td>(?:Sophos|Symantec|TrendMicro|McAfee)</td>.*?</tr>!sig;
        if (not @result)
        {
            print "\nNo record in VirusTotal. Sending v-test...\n";
            return $sophos;
        }

        print "\nvirustotal record found as following:\n";
        foreach (@result)
        {
            my $tmp=$_;
            $tmp =~ s/(<[^>]+>\s*)+/\t/sig;
            print $tmp."\n";
            if ($tmp =~ m/(?:Sophos[.\s0-9]+)(?!-)(\S+)\s*$/i)
            {
                $sophos=$1;
            }
        }
        print "\nSophos has detection as $sophos, no v-test needed.\n" if $sophos;
        print "you can read the virus details here:\n";
        print "\t$url\n\n";

        exit() if $sophos;
    }

    #get the filesize by using the curl -I option.
    #print the filesize if it is greater than a given value, 2MB by default.
    sub get_filesize{

        my ($url)=@_;
        my ($size,$unit);
        foreach (qx{curl -s -I $url})
        {
            if (/Content-Length:\s(\d+)/)
            {
                $size=$1;
            }
            if (/Accept-Ranges:\s(\w+)/)
            {
                $unit=$1;
            }
        }
        if (not $size)
        {
            print "can not get the length of the file, exit!\n";
            exit;
        }
        $size=int($size / 1024);

        my $flag=0;     #if flag=1 it is too large ;
        if ($size>1024 * 2)
        {
            $flag=1;
            print "the file is ${size}KB and greater than 2MB!\n";
            print "it is too large to be a virus. exit.\n";
        }
        else
        {
            print "\nThe file size is $size kb, downloading...\n\n";
        }
        $flag;
    }

    #simply download the file
    sub download_file
    {
        my ($url)=@_;
        $url =~ /([^\/]+)$/;
        my $filename=$1;
        `curl -O $url`;
        if (not -e $filename)
        {
            print "no filename, retrying...\n";
            return 0;
        }
        print "\nfile is downloaded and saved as $filename.\n";
        1;
    }

    #print the help message and exit if no url input
    sub help
    {
        print "Usage: ./dl http://.../file.exe\n";
        print "\tthe last part of the url is regarded as filename.\n";
        exit();
    }

    #send the v-test email, with md5 value in the subject.
    sub v_test
    {
        my ($file,$md5)=@_;
        `zip $file.zip $file`;
        `send-sample.pl -a $file.zip -s "$file.zip URL MD5 $md5"`;
    }
    ]]>     http://iregex.org/blog/better-downloader-in-perl.html/feed 0     关于从普通文本提取正则表达式的再思考 http://iregex.org/blog/text-2-regular-expressions-again.html http://iregex.org/blog/text-2-regular-expressions-again.html#comments Mon, 08 Mar 2010 18:32:19 +0000 rex http://iregex.org/?p=79

    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->”$”。全部节点之间，是串联关系，从左到右依次排列即可。

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

    Photobucket

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

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

    Photobucket

    显而易见，这两条并列的支路，始于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->$的支路即可。此时图示如下：

    Photobucket

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

    Photobucket

    此时，观察可知，一种新的情况出现了。同时存在^->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了很久才爬出来）
    抽空补了一下有向图的知识，觉得可以简化问题如下。

    Photobucket

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

    顶点集合为：
    (^, this, is, a, red, fox, blue, firefox, pig, $);
    通路关系集合为：
    (^->this, this->is,…)

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

    再次总结，如下：
    • 从一个顶点A出发的N条支路必定汇合（只是有时是同一个点，有时不在同一点而已。本文给出的例子是最简单的情况，这里可以假设为汇合到同一点）于M点。
    • 这N条路中，每一条路径的长短以经过的节点个数来计算。例如上图中，^到a有一条路，上面的路径为2，下面的路径为0。
    • 短的支路决定了这N条支路的关系。
    • 长度为任意两点之间，最多只可能有一条长度为0的边。
    • 如果存在长度为0的边，则其余的同级的支路被短路。
    • 长度不为0的N-1条支路之间是并列关系。
    • 整个图始于^，终于$。
    这些条件、判断，均可以细化为函数。具体的程序从略。
    ]]>     http://iregex.org/blog/text-2-regular-expressions-again.html/feed 4     个人应用之明文字串到正则 http://iregex.org/blog/literal-text-to-regex.html http://iregex.org/blog/literal-text-to-regex.html#comments Wed, 10 Feb 2010 08:50:15 +0000 rex http://iregex.org/?p=78 近来工作中需要将某种明文字串转为简单的正则式。手动做当然可以，但是大量重复性的劳动，自然是交给机器处理为好。昨晚写了一款这样的脚本，放在这里。因为是处理我自己的工作的脚本，贴在这里仅作记录和存档之用，可能对别人没什么实际作用。当然，从现有的明文字串到正则式的转换，应该是个不错的题目，有兴趣朋友的可以深究。

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

    实际应用一例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    perl hash2re.pl H:aaa-Aaaa-AaaaAaaaaaaAaaaaaaa-AAA0.zip/H:aaa-Aaaa-AaaaAaaaaaaAaaaaaaa-AAA-0/aaa-Aaaa-AaaaAaaaaaaAaaaaaaa-AAA-0/aaa/Aaaaa/aaa-Aaaa-AaaaAaaaaaaAaaaaaaa-AAA-0.exe
    RE 1:   ^[a-z]{3}-[A-Z][a-z]{3}-[A-Z][a-z]{3}[A-Z][a-z]{6}[A-Z][a-z]{7}-[A-Z]{3}[0-9]\.zip$
            Matches: "aaa-Aaaa-AaaaAaaaaaaAaaaaaaa-AAA0.zip"

    RE 2:   ^[a-z]{3}-[A-Z][a-z]{3}-[A-Z][a-z]{3}[A-Z][a-z]{6}[A-Z][a-z]{7}-[A-Z]{3}-[0-9]$
            Matches: "aaa-Aaaa-AaaaAaaaaaaAaaaaaaa-AAA-0"

    RE 3:   ^[a-z]{3}-[A-Z][a-z]{3}-[A-Z][a-z]{3}[A-Z][a-z]{6}[A-Z][a-z]{7}-[A-Z]{3}-[0-9]$
            Matches: "aaa-Aaaa-AaaaAaaaaaaAaaaaaaa-AAA-0"

    RE 4:   ^[a-z]{3}$
            Matches: "aaa"

    RE 5:   ^[A-Z][a-z]{4}$
            Matches: "Aaaaa"

    RE 6:   ^[a-z]{3}-[A-Z][a-z]{3}-[A-Z][a-z]{3}[A-Z][a-z]{6}[A-Z][a-z]{7}-[A-Z]{3}-[0-9]\.exe$
            Matches: "aaa-Aaaa-AaaaAaaaaaaAaaaaaaa-AAA-0.exe"

    源码：

    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
    #!/usr/bin/perl

    #   by rex zhang
    #   Feb 09 2010 in Shanghai

    #   usage: split and regexize hashed filename
    #

    my $lines=$ARGV[0];
    while($lines =~ m#(C:[^/]+)#)
    {
        $c=$1;
        $lines =~ s/$c//;
        print "ClearText Filename Ignored:\t\"$c\"\n\n";

    }
    my @array=split(m!\s*(?:\/|H:)+\s*!, $lines);

    my $counter=0;
    foreach $line (@array){
        next if not $line;
        my $re=$line;
        local $len;    

        $re =~ s/(?=[.\[\]()])/\\/g;
        $re =~ s/\?/./g;
        $re =~ s/0+(?{ $len=length($&)})/[0-9]\{$len\}/g;
        $re =~ s/A+(?{ $len=length($&)})/[A-Z]\{$len\}/g;
        $re =~ s/a+(?{ $len=length($&)})/[a-z]\{$len\}/g;
        $re =~ s/(.)\1+(?{ $len=length($&)})/$1\{$len\}/g;
        $re =~ s/\{1\}//g;
        $re =  "\^$re\$";

        $counter++;
        if ($line =~ /$re/)
        {
            print "RE $counter:\t$re\n";
            print "\tMatches: \"$line\"\n";    
        }
        else
        {
            print "RE $counter:\t$re\n";
            print "\tFailed: \"$line\"\n";
        }
        print "\n";
    }
    ]]>     http://iregex.org/blog/literal-text-to-regex.html/feed 2     统计重复文本行的两种方法 http://iregex.org/blog/get-duplicated-lines.html http://iregex.org/blog/get-duplicated-lines.html#comments Sat, 06 Feb 2010 07:09:43 +0000 rex http://iregex.org/?p=77 假设样本文件a.txt内容如下：

    1
    2
    3
    4
    5
    6
    hello world!
    hello world!
    I love regex.
    hello world!
    I love regex.
    hello world!

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

    正则表达式的解法

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #!/usr/bin/perl
    #usage:  ./dup_re.pl <a.txt

    undef $/;           # enable "slurp" mode
    my $file = <STDIN>;          # whole file now here

    while($file =~ m
        /                   #for each line;
            ^\s*            #ignore the whitespaces at both ends;
            (\S.*?)         #get the line content, save to $1;
            \s*$            #ignore empty lines by using \S
            .*?             #check if there is the same pattern of $1
            ^\s*\1\s*$              #after 0 or more lines;
        /smx)
    {
        my $line=$1;                        
        my $count= $file =~ s/$line//g;     #delete the duplicated lines
                           #save the number to $count;
                                           #ignore empty lines
            print $count,"times:\t",$line,"\n";
    }

    Hash表解法

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

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

    Perl程序：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #!/usr/bin/perl
    #usage:  ./dup_hash.pl a.txt

    my %hash=();
    while(<>)
    {
       if (/^\s*(\S.*?)\s*$/)           #ignore whitespaces at both ends;
       {                                #ignore empty lines by using \S
            $hash{$1}++;                #save the line to $1, and count the time it appears
       }
    }

    #sort the hash by values;
    foreach $key (sort { $hash{$b} <=> $hash{$a} } keys %hash) {
        if ($hash{$key}>=2)             #only print the lines that duplicates;
        {                               #for all results, just remove the 'if' line
           printf "%d times:\t%s\n", $hash{$key}, $key;
        }
    }

    结果

    上面的程序分别保存为dup_re.pl，dup_hash.pl。由于程序对于外部文件的读取的方法不同，运行方式也有差别，详见下图：
    我爱正则表达式|统计重复文本行的两种方法

    Update

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

    ]]>     http://iregex.org/blog/get-duplicated-lines.html/feed 8     由正则式反推文本:REExtractor http://iregex.org/blog/reextractor.html http://iregex.org/blog/reextractor.html#comments Tue, 02 Feb 2010 09:12:35 +0000 rex http://iregex.org/?p=76 发现一款简单有趣的正则表达式应用：REExtractor，作用是输入正则表达式，输出符合正则式描述的文本。作者给的介绍是
    Generate all possibilities of Regular Expression，即生成正则表达式的所有可能性。不过，理论上可以做到，执行时却有限制。

    一些限制

    1. 平台是GAE，语言是python，因此用的是python正则。或需代理才能访问使用。
    2. 支持的元字符或缩写：(), [],{m,n},{n},|,\w,\d。如果需要用到这些字符的字面值，请使用反斜线转义之。其中这里的\w等同于[a-zA-Z0-9]，为62个字符之一，而不是通常意义上的包括下划线在内的[_a-zA_Z0-9]，63字符之一。但是可以用[_\w]来代替，没问题的。
    3. 不支持的元字符：.(点号),^,$,\b,\D,\W,\1…（后向引用）, (?=…), (?!…), (?<=…), (?<!…)等。
      • 如果出现.点号，则直接输出。
      • 如果使用^, $, \b, \1, (?=…), (?!…), (?<=…), (?<!…)， 程序无视之。
      • 如果使用\D或\b或[^]，则程序会报错。原因是范围太宽。
    4. 不支持可能性在1000条以上结果的正则表达式。例如，\w{2}，因为它的可能性是62×62。但是你可以使用\w\d，因为它的可能性是62×10。

    它能做什么

    我爱正则表达式|由正则式反推文本
    好吧，虽然限制多多，但是你仍然可以拿它来做一些有趣的应用。下面略举两例。

    • 生成一些简单的邮箱地址。试一下这条正则式：[abc]{3}\d@1(26|63).com ，它生成540条邮箱地址。
    • 生成一些人名。试一下这条正则式：张[小大勇赞强战海][虎猫龙彪平]。它生成35条人名。是的，它支持中文，并且每个中文字都可以当成一个字符来应用。如果你家要添一个宝宝，可以将一些可能的字排列一下，看看哪些组合比较赏心、顺口，再从中选择一个。

    平心而论，上面的这些小应用，当然可以直接编程实现，限制更少，更灵活，更强大。但是有必要每次都开编译器么？尝试一下这款小程序，也挺有趣的。而且，上一节中提及的一些限制，其实也是蛮有道理的。毕竟从正则式反推文本，用不到大多数的零宽断言（不过\1这种反向引用应该挺常用的，却不支持）。当作一个小玩具就好。

    ]]>     http://iregex.org/blog/reextractor.html/feed 2