|
“正则表达式”的应用范围越来越广，有了这个强大的工具，我们可以做很多事情，如搜索一句话中某个特定的数据，屏蔽掉一些非法贴子的发言，网页中匹配特定数据，代码编辑框中字符的高亮等等，这都可以用正则表达式来完成。 本书分为四个部分。 第一部分介绍了易语言的正则表达式支持库，在这里，大家可以了解第一个正则表达式的易语言程序写法，以及一个通用的小工具的制作。 第二部分介绍了正则表达式的基本语法，大家可以用上述的小工具进行试验。 第三部分介绍了用易语言写的正则表达式工具的使用方法。这些工具是由易语言用户提供的，有的工具还带有易语言源码。他们是：monkeycz、零点飞越、寻梦。 第四部分介绍了正则表达式的高级技巧。 目录第一章易语言正则表达式入门一．与DOS下的通配符类似其实，所谓的“正则表达式”，是大家一直在使用的，记得吗？在搜索文件时，会使用一种威力巨大的武器——DOS通配符——“?”和“*”。这就是最常用的正则表达式。例如： 123.*表示所有文件名为123的文件，如123.txt, 123.doc, 123.wps, 123.swf, 123.xls等。 “中国?.doc”表示所有文件名类似于 中国1.doc、中国2.doc、中国x.doc 这样的文件。 上述DOS下的通配符用“?”号代表一个字符，“*”号代表任意个字符，但在正则表达式中，可能这些都有些改变。如“*”号匹配的就不一样。下面看看正则表达式是如何规定的吧。 二．初步了解正则表达式的规定正则表达式正是在“DOS通配符”基础上复杂化而得到的。其最常用的表达式可能是： *匹配0或多个正好在它之前的那个字符。例如a*意味着能够匹配任意数量的a字符 .匹配任何单个字符。例如r.t匹配这些字符串：rat、rut、r t，但是不匹配root （等同于DOS通配符下的？号。） ^匹配一行的开始。例如^When 能够匹配字符串When in the course of human events的开始，但是不能匹配What and When in the。 $匹配行结束符。例如正则表达式weasel$ 能够匹配字符串Hes a weasel的末尾，但是不能匹配字符串They are a bunch of weasels.。 在这些字符中，可以使用 \. 来表示 . ，\* 表示 * ，不过，这种情况出现得很少，如果不能理解，可以暂时不理它，到用的时候就明白了。 正则表达式还有一个强大的符号：[ ]，这个 [ ]所括的内容，可以不按顺序进行匹配。如 [abc]匹配abc, acb, bac, bca, cab, cba这6个文本 [0-9]匹配任意0到9的数字 [a-z]匹配所有小写字母 [A-Z]匹配所有大写字母 当然，你可以把它们混在一起写成[a-z0-9]这种样子。 很多时候，我们需要检查文本中的非数字，我们就可以使用^这个符号，表示“除了……” [^0-9]匹配所有非数字文本 [^a-zA-Z]匹配所有非字母的文本 [^FONT]匹配所有不含FONT的文本 三．一个速查列表下面用一个表来表示：
四．正则表达式支持库的命令基本的规则这些也就够了。下面将讲一讲易语言中正则表达式的数据类型和几个相关命令，相关的数据类型有两个：正则表达式和搜索结果。如下图所示： 4.1第1个正则表达式程序新建一个易语言程序,界面设计如下图所示: 按钮被单击事件代码如下： .局部变量 正则表达式1, 正则表达式 正则表达式1.创建 (“A.C”, 假) 编辑框2.内容 ＝ 到文本 (正则表达式1.匹配 (编辑框1.内容)) 如下图所示： 在这里，“正则表达式1”是一个正则对象，使用“创建”方法建议了一个“A.C”正则表达式，然后与编辑框1中的内容进行正则比较，最后得出结论。 运行后，大家只要输入三个字符，前为A后为C都会返回真。如下图所示： 但如果是小写或多于三个字符，那么返回就会是假。如下图所示： 大家也许会问，这样匹配有意义吗？我只能说，有没有意义只在于你怎么用了，如：可用于程序加密时，不采用判断语句，也不采用循环语句，而是用正则去匹配是否注册成功，以及可以进行程序名称的检查，程序中一些文字的检查等，这可能让一些不会正则的破解者很难下手。 4.2第2个正则表达式例程通过第一个正则程序，大家会了解正则匹配的重要性，也了解了易语言正则支持库的基本使用方法，下面这个例程可以让大家了解正则会返回一些更多的内容，大家如何去取回这些信息呢。下面改动上述程序中的一些代码为以下： .局部变量 正则表达式1, 正则表达式 .局部变量 搜索结果1, 搜索结果, , 0 正则表达式1.创建 (“A.C”, 假) 搜索结果1 ＝ 正则表达式1.搜索全部 (编辑框1.内容) 编辑框2.内容＝ 搜索结果1 [1].取匹配文本 (编辑框1.内容, ) 改动后如下所示： 在这里，增加了一个搜索结果的对象，用这个对象接收正则表达式匹配的结果，然后从中提取出大家想要的数据。 上述易语言代码的运行结果如下图所示： 改动上面编辑框的内容后，结果如下： 这次是较为重要的一环，即我们知道了取回的内容。即由A和C包含的内容。以及下面会论述到的位置信息。取回的包含的内容意义重大，如：可以取回一对括号内的内容，这也是为了查找的方便。 4.3第3个例程这次的工作任务是取一批文字中的所有字母与数字内容。 按钮被单击事件代码如下： .局部变量 正则表达式1, 正则表达式 .局部变量 搜索结果1, 搜索结果, , 0 .局部变量 数组索引, 整数型 正则表达式1.创建 (“[a-z0-9” ＋ #换行符 ＋ “]”, 假) [ ]中间的内容，就是要搜索的内容，可以是任意字符，包括换行、空格、特殊符号.但注意如果有字符^，就表示除了，如[^abc]表示除了abc,现在，我们给出的表达式意思是匹配含字母、数字、换行符的文本，后面那个假意思是不区分大小写，你写成真也没有问题。 搜索结果1 ＝ 正则表达式1.搜索全部 (编辑框1.内容) 搜索结果是个数组，实际上存放的是字符串搜索后的各种参数，例如位置等, 可以用取匹配文本（，）方法将其取出，注意它的第一个参数必须和搜索全部（）的参数一致 编辑框2.内容 ＝ “” .计次循环首 (取数组成员数 (搜索结果1), 数组索引) 编辑框2.加入文本 (搜索结果1 [数组索引].取匹配文本 (编辑框1.内容, )) .计次循环尾 () 图片如下所示： 运行后，大家可以在上面的编辑框中输入中文与字母数字的混合，点击按钮后，就可以从中提取出字母与数字了。运行效果如下图所示： 4.4一个小型的正则工具在这里，大家将学会制作一个小型的正则表达式工具，使用这个工具进行下面章节更加细致的学习。这个例程也可以在本书的随书光盘中找到。 程序界面如下所示安排： 按钮被单击事件的代码如下： .局部变量 正则表达式1, 正则表达式 .局部变量 搜索结果1, 搜索结果, , 0 .局部变量 位置1, 整数型 正则表达式1.创建 (组合框1.内容, 假) .如果真 (正则表达式1.是否为空 () ＝ 真) 连续赋值 (“”, 编辑框A.内容, 编辑框B.内容, 编辑框C.内容, 编辑框D.内容, 编辑框2.内容) 返回 () .如果真结束 编辑框2.内容 ＝ 到文本 (正则表达式1.匹配 (编辑框1.内容)) 搜索结果1 ＝ 正则表达式1.搜索全部 (编辑框1.内容) .如果真 (取数组下标 (搜索结果1, ) ＝ 0) 连续赋值 (“”, 编辑框A.内容, 编辑框B.内容, 编辑框C.内容, 编辑框D.内容, 编辑框2.内容) 返回 () .如果真结束 编辑框A.内容 ＝ 搜索结果1 [1].取匹配文本 (编辑框1.内容, 位置1) 编辑框B.内容 ＝ 到文本 (位置1) 编辑框C.内容 ＝ 到文本 (位置1 ＋ 取文本长度 (编辑框A.内容)) 编辑框D.内容 ＝ 到文本 (取文本长度 (编辑框A.内容)) 抓图如下： 通过上述代码后，运行效果如下： 上述是测试“匹配”方法中注释的内容： 正则表达式.创建 (“易语言4\.0(模块|支持库)?”) 信息框 (正则表达式.匹配 (“易语言4.0支持库”), 0, ) 在第二章中，大家会发现本书大量用到了这个小程序。 请置这个程序的启动窗口总在最前。 注意：下标从0开始还是从1开始，因当前编程语言的不同而可能不同。 第二章揭开正则表达式的神秘面纱[原创文章，转载请保留或注明出处：http://www./zh/regref.htm] 引言正则表达式（regular expression）描述了一种字符串匹配的模式，可以用来：（1）检查一个串中是否含有符合某个规则的子串，并且可以得到这个子串；（2）根据匹配规则对字符串进行灵活的替换操作。 正则表达式学习起来其实是很简单的，不多的几个较为抽象的概念也很容易理解。之所以很多人感觉正则表达式比较复杂，一方面是因为大多数的文档没有做到由浅入深地讲解，概念上没有注意先后顺序，给读者的理解带来困难；另一方面，各种引擎自带的文档一般都要介绍它特有的功能，然而这部分特有的功能并不是大家首先要理解的。 一.正则表达式规则1.1普通字符字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号，都是“普通字符”。表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符。 举例1：表达式“c”，在匹配字符串“abcde”时，匹配结果是：成功；匹配到的内容是：“c”；匹配到的位置是：开始于2，结束于3。（注：下标从0开始还是从1开始，因当前编程语言的不同而可能不同） 举例2：表达式“bcd”，在匹配字符串“abcde”时，匹配结果是：成功；匹配到的内容是：“bcd”；匹配到的位置是：开始于1，结束于4。 1.2简单的转义字符一些不便书写的字符，采用在前面加\的方法。这些字符其实我们都已经熟知了。
还有其他一些在后边章节中有特殊用处的标点符号，在前面加“\”后，就代表该符号本身。比如：^, $都有特殊意义，如果要想匹配字符串中“^”和“$”字符，则表达式就需要写成“\^”和“\$”。
这些转义字符的匹配方法与“普通字符”是类似的。也是匹配与之相同的一个字符。 举例1：表达式“\$d”，在匹配字符串“abc$de”时，匹配结果是：成功；匹配到的内容是：“$d”；匹配到的位置是：开始于3，结束于5。 1.3能够与“多种字符”匹配的表达式正则表达式中的一些表示方法，可以匹配“多种字符”其中的任意一个字符。比如，表达式“\d”可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个。这就好比玩扑克牌时候，大小王可以代替任意一张牌，但是只能代替一张牌。
举例1：表达式“\d\d”，在匹配“abc123”时，匹配的结果是：成功；匹配到的内容是：“12”；匹配到的位置是：开始于3，结束于5。 举例2：表达式“a.\d”，在匹配“aaa100”时，匹配的结果是：成功；匹配到的内容是：“aa1”；匹配到的位置是：开始于1，结束于4。 1.4自定义能够匹配“多种字符”的表达式使用方括号[ ]包含一系列字符，能够匹配其中任意一个字符。用[^ ]包含一系列字符，则能够匹配其中字符之外的任意一个字符。同样的道理，虽然可以匹配其中任意一个，但是只能是一个，不是多个。
举例1：表达式“[bcd][bcd]”匹配“abc123”时，匹配的结果是：成功；匹配到的内容是：“bc”；匹配到的位置是：开始于1，结束于3。 举例2：表达式“[^abc]”匹配“abc123”时，匹配的结果是：成功；匹配到的内容是：“1”；匹配到的位置是：开始于3，结束于4。 1.5修饰匹配次数的特殊符号前面章节中讲到的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号，那么不用重复书写表达式就可以重复匹配。 使用方法是：“次数修饰”放在“被修饰的表达式”后边。 比如：“[bcd][bcd]”可以写成“[bcd]{2}”。
举例1：表达式“\d+\.?\d*”在匹配“It costs $12.5”时，匹配的结果是：成功；匹配到的内容是：“12.5”；匹配到的位置是：开始于10，结束于14。 举例2：表达式“go{2,8}gle”在匹配“Ads by goooooogle”时，匹配的结果是：成功；匹配到的内容是：“goooooogle”；匹配到的位置是：开始于7，结束于17。 想取得某个网址的匹配可以如下： 哈哈，越来越有意思了吧，如果在一句话中找到某个网址也是非常简单的了，如下图所示： 1.6其他一些代表抽象意义的特殊符号一些符号在表达式中代表抽象的特殊意义：
进一步的文字说明仍然比较抽象，因此，举例帮助大家理解。 举例1：表达式^aaa在匹配xxx aaa xxx时，匹配结果是：失败。因为^要求与字符串开始的地方匹配，因此，只有当aaa位于字符串的开头的时候，^aaa才能匹配，比如：aaa xxx xxx。 举例2：表达式aaa$在匹配xxx aaa xxx时，匹配结果是：失败。因为$要求与字符串结束的地方匹配，因此，只有当aaa位于字符串的结尾的时候，aaa$才能匹配，比如：xxx xxx aaa。 举例3：表达式.\b.在匹配@@@abc时，匹配结果是：成功；匹配到的内容是：@a；匹配到的位置是：开始于2，结束于4。 进一步说明：\b与^和$类似，本身不匹配任何字符，但是它要求它在匹配结果中所处位置的左右两边，其中一边是\w范围，另一边是非\w的范围。 举例4：表达式“\bend\b”在匹配“weekend,endfor,end”时，匹配结果是：成功；匹配到的内容是：“end”；匹配到的位置是：开始于15，结束于18。 一些符号可以影响表达式内部的子表达式之间的关系：
举例5：表达式Tom|Jack在匹配字符串Im Tom, he is Jack时，匹配结果是：成功；匹配到的内容是：Tom；匹配到的位置是：开始于4，结束于7。匹配下一个时，匹配结果是：成功；匹配到的内容是：Jack；匹配到的位置时：开始于15，结束于19。 举例6：表达式(go\s*)+在匹配Lets go go go!时，匹配结果是：成功；匹配到内容是：go go go；匹配到的位置是：开始于6，结束于14。 举例7：表达式￥(\d+\.?\d*)在匹配＄10.9,￥20.5时，匹配的结果是：成功；匹配到的内容是：￥20.5；匹配到的位置是：开始于6，结束于10。单独获取括号范围匹配到的内容是：20.5。 二.正则表达式中的一些高级规则2.1匹配次数中的贪婪与非贪婪在使用修饰匹配次数的特殊符号时，有几种表示方法可以使同一个表达式能够匹配不同的次数，比如：{m,n}, {m,}, ?, *, +，具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中，总是尽可能多的匹配。比如，针对文本dxxxdxxxd，举例如下：
由此可见，“\w+”在匹配的时候，总是尽可能多的匹配符合它规则的字符。虽然第二个举例中，它没有匹配最后一个“d”，但那也是为了让整个表达式能够匹配成功。同理，带“*”和“{m,n}”的表达式都是尽可能地多匹配，带“?”的表达式在可匹配可不匹配的时候，也是尽可能的“要匹配”。这种匹配原则就叫作“贪婪”模式。 非贪婪模式： 在修饰匹配次数的特殊符号后再加上一个“?”号，则可以使匹配次数不定的表达式尽可能少的匹配，使可匹配可不匹配的表达式，尽可能的“不匹配”。这种匹配原则叫作“非贪婪”模式，也叫作“勉强”模式。如果少匹配就会导致整个表达式匹配失败的时候，与贪婪模式类似，非贪婪模式会最小限度的再匹配一些，以使整个表达式匹配成功。举例如下，针对文本“dxxxdxxxd”举例：
更多的情况，举例如下： 举例1：表达式“(.*)”与字符串“ aa bb ”匹配时，匹配的结果是：成功；匹配到的内容是“aa bb ”整个字符串，表达式中的“”将与字符串中最后一个“”匹配。举例2：相比之下，表达式“(.*?)”匹配举例1中同样的字符串时，将只得到“ aa ”，再次匹配下一个时，可以得到第二个“bb ”。2.2反向引用\1, \2...表达式在匹配时，表达式引擎会将小括号“( )”包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候，小括号包含的表达式所匹配到的字符串可以单独获取。这一点，在前面的举例中，已经多次展示了。在实际应用场合中，当用某种边界来查找，而所要获取的内容又不包含边界时，必须使用小括号来指定所要的范围。比如前面的“(.*?)”。 其实，“小括号包含的表达式所匹配到的字符串”不仅是在匹配结束后才可以使用，在匹配过程中也可以使用。表达式后边的部分，可以引用前面“括号内的子匹配已经匹配到的字符串”。引用方法是“\”加上一个数字。“\1”引用第1对括号内匹配到的字符串，“\2”引用第2对括号内匹配到的字符串……以此类推，如果一对括号内包含另一对括号，则外层的括号先排序号。换句话说，哪一对的左括号“(”在前，那这一对就先排序号。 举例如下： 举例1：表达式“(|)(.*?)(\1)”在匹配“Hello, World”时，匹配结果是：成功；匹配到的内容是：“Hello”。再次匹配下一个时，可以匹配到“World”。 举例2：表达式“(\w)\1{4,}”在匹配“aa bbbb abcdefg ccccc 111121111 999999999”时，匹配结果是：成功；匹配到的内容是“ccccc”。再次匹配下一个时，将得到999999999。这个表达式要求“\w”范围的字符至少重复5次，注意与“\w{5,}”之间的区别。 举例3：表达式“<(\w+)\s*(\w+(=(|).*?\4)?\s*)*>.*?”在匹配“”时，匹配结果是成功。如果“”与“”不配对，则会匹配失败；如果改成其他配对，也可以匹配成功。 2.3预搜索，不匹配；反向预搜索，不匹配前面的章节中，本书讲到了几个代表抽象意义的特殊符号：“^”，“$”，“\b”。它们都有一个共同点，那就是：它们本身不匹配任何字符，只是对“字符串的两头”或者“字符之间的缝隙”附加了一个条件。理解到这个概念以后，本节将继续介绍另外一种对“两头”或者“缝隙”附加条件的，更加灵活的表示方法。 正向预搜索：“(?=xxxxx)”，“(?!xxxxx)” 格式：“(?=xxxxx)”，在被匹配的字符串中，它对所处的“缝隙”或者“两头”附加的条件是：所在缝隙的右侧，必须能够匹配上xxxxx这部分的表达式。因为它只是在此作为这个缝隙上附加的条件，所以它并不影响后边的表达式去真正匹配这个缝隙之后的字符。这就类似“\b”，本身不匹配任何字符。“\b”只是将所在缝隙之前、之后的字符取来进行了一下判断，不会影响后边的表达式来真正的匹配。 举例1：表达式“Windows(?=NT|XP)”在匹配“Windows 98, Windows NT, Windows 2000”时，将只匹配“Windows NT”中的“Windows”，其他的“Windows”字样则不被匹配。 举例2：表达式“(\w)((?=\1\1\1)(\1))+”在匹配字符串“aaa ffffff 999999999”时，将可以匹配6个“f”的前4个，可以匹配9个“9”的前7个。这个表达式可以读解成：重复4次以上的字母数字，则匹配其剩下最后2位之前的部分。当然，这个表达式可以不这样写，在此的目的是作为演示之用。 格式：“(?!xxxxx)”，所在缝隙的右侧，必须不能匹配xxxxx这部分表达式。 举例3：表达式“((?!\bstop\b).)+”在匹配“fdjka ljfdl stop fjdsla fdj”时，将从头一直匹配到“stop”之前的位置，如果字符串中没有“stop”，则匹配整个字符串。 举例4：表达式“do(?!\w)”在匹配字符串“done, do, dog”时，只能匹配“do”。在本条举例中，“do”后边使用“(?!\w)”和使用“\b”效果是一样的。 反向预搜索：“(?<=xxxxx)”，“(? 这两种格式的概念和正向预搜索是类似的，反向预搜索要求的条件是：所在缝隙的“左侧”，两种格式分别要求必须能够匹配和必须不能够匹配指定表达式，而不是去判断右侧。与“正向预搜索”一样的是：它们都是对所在缝隙的一种附加条件，本身都不匹配任何字符。 举例5：表达式“(?<=\d{4})\d+(?=\d{4})”在匹配“1234567890123456”时，将匹配除了前4个数字和后4个数字之外的中间8个数字。由于JScript.RegExp不支持反向预搜索，因此，本条举例不能够进行演示。很多其他的引擎可以支持反向预搜索，比如：Java 1.4以上的java.util.regex包，.NET中System.Text.RegularExpressions命名空间，以及本站推荐的最简单易用的DEELX正则引擎。 三.其他通用规则还有一些在各个正则表达式引擎之间比较通用的规则，在前面的讲解过程中没有提到。 3.1表达式中，可以使用“\xXX”和“\uXXXX”表示一个字符（“X”表示一个十六进制数）
3.2在表达式\s，\d，\w，\b表示特殊意义的同时，对应的大写字母表示相反的意义
3.3在表达式中有特殊意义，需要添加“\”才能匹配该字符本身的字符汇总
3.4括号“( )”内的子表达式，如果希望匹配结果不进行记录供以后使用，可以使用“(?:xxxxx)”格式 举例１：表达式 “(?:(\w)\1)+”匹配“a bbccdd efg”时，结果是“bbccdd”。括号“(?:)”范围的匹配结果不进行记录，因此“(\w)”使用“\1”来引用。 3.5常用的表达式属性设置简介：Ignorecase，Singleline，Multiline，Global
四.其他提示4.1如果想要了解高级的正则引擎还支持那些复杂的正则语法，可参见网上关于DEELX正则引擎的说明文档。 4.2如果要要求表达式所匹配的内容是整个字符串，而不是从字符串中找一部分，那么可以在表达式的首尾使用^和$，比如：^\d+$要求整个字符串只有数字。 4.3如果要求匹配的内容是一个完整的单词，而不会是单词的一部分，那么在表达式首尾使用\b，比如：使用\b(if|while|else|void|int……)\b来匹配程序中的关键字。 4.4表达式不要匹配空字符串。否则会一直得到匹配成功，而结果什么都没有匹配到。比如：准备写一个匹配123、123.、123.5、.5这几种形式的表达式时，整数、小数点、小数数字都可以省略，但是不要将表达式写成：\d*\.?\d*，因为如果什么都没有，这个表达式也可以匹配成功。更好的写法是：\d+\.?\d*|\.\d+。 4.5能匹配空字符串的子匹配不要循环无限次。如果括号内的子表达式中的每一部分都可以匹配0次，而这个括号整体又可以匹配无限次，那么情况可能比上一条所说的更严重，匹配过程中可能死循环。虽然现在有些正则表达式引擎已经通过办法避免了这种情况出现死循环了，比如.NET的正则表达式，但是我们仍然应该尽量避免出现这种情况。如果我们在写表达式时遇到了死循环，也可以从这一点入手，查找一下是否是本条所说的原因。 4.6合理选择贪婪模式与非贪婪模式，参见话题讨论。 4.7或|的左右两边，对某个字符最好只有一边可以匹配，这样，不会因为|两边的表达式因为交换位置而有所不同。 第三章正则表达式工具与实例第一章将易语言的正则表达式工具简单地向大家作了介绍，并且在最后给出了一个实用的小工具进行测试。在第二章中，重点介绍了正则表达式的概念，同时用这个小工具进行了验算。本章会重新回到易语言环境中，将正则表达式支持库中的所有命令都介绍给大家。在本章的后面，就会有针对性地教大家自己写工具，以及介绍几个有用的实例。 一．正则表达式支持库在第一章中只是简单地使用了易语言正则表达式的几个命令。在此将会向大家介绍所有的命令。同时希望大家能安装ESDN，很多例程大家都可以通过这个进一步了解。 1.1“正则表达式”数据类型“创建”方法：表示创建一个正则表达式，其在第一章中已有使用。根据指定的正则表达式文本创建一个正则表达式对象。本对象中的原有内容将被释放。成功返回真；否则返回假。 “是否为空”方法：测试是否已使用创建方法载入一个正则表达式了，如果已有正则表达式，返回为“真”，否则返回为“假”。 “取文本”方法。测试是否已使用创建方法载入一个正则表达式了，如果已有正则表达式，返回正则表达式的文本，否则返回“空”。 “匹配”方法。表示用正则表达式与被测试文本之间的完全对应关系是否成立，如果完全对应返回“真”，否则返回“假”。比如：正则表达式.创建(“易语言4\.0(模块|支持库)?”) |信息框(正则表达式.匹配(“易语言4.0支持库”), 0, )将显示“真”。 “搜索”方法。使用指定的正则表达式搜索指定文本中与该表达式匹配的子文本。 “替换”方法。使用指定的正则表达式搜索指定文本中与该表达式匹配的子文本，并按照指定的格式进行替换。 “搜索全部”方法。使用指定的正则表达式搜索指定文本中与该表达式匹配的所有子文本。返回值包含所有的搜索结果的一维数组，数组原有内容将被销毁，维数也将根据需要做相应调整。本命令的内部是通过循环多次调用“搜索”，每次指定适当的参数，来实现搜索整个文本的。返回值数组的各个成员分别对应每次调用“搜索”的返回值。本命令可高效地一次性取得目标文本中所有的匹配子文本信息。 “取子表达式个数”方法。返回该表达式中子表达式（用圆括号标记）的个数。比如“易语言4\.0(模块|支持库)?”中包含1个子表达式：“(模块|支持库)”。 1.2“搜索结果”数据类型“是否为空”方法。表示搜索结果数据类型中是否有数据，如果对象的内容为空，没有数据，那么返回“真”，否则返回“假”。 “取匹配文本”方法。取得与整个正则表达式匹配的子文本。 “取子匹配文本”方法。取得与正则表达式中某个子表达式匹配的子文本。 二．正则表达式实用工具2.1一个成品工具在天空或华军，可以下载到一些制作好的正则表达式工具，其各有自己的优点。大家可以自己去下载一下。本书的随书光盘中也有这样一个工具。 一般一个正则表达式工具可能包括下面的重要部分：
生成代码的工个是单独一个窗口，如下图所示： 此外，有的工具还提供了可以辅助生成正则表达式的工具。 有时，大家下载一个正则表达式工具，运行不了，这是需要“.NET”的支持才行。 2.2易语言写的工具用易语言写一个正则表达式工具实际上也不是什么难事。在此向大家介绍一下界面，操作方法应该也是比较简单的。 三．应用实例3.1实例１打开随书例程：匹配中文.e，界面如下： 代码如下： 运行后的效果如下： 3.2实例２大家还是自己看代码吧。 3.3实例3http://www./vbs/dispbbs.asp?boardID=148&ID=100588&page=1 大家可以下载这个贴子中的编译程序源代码，其中有一部分的接收到错误信息时，可以通过正则表达式匹配到出错行，并且定位到出错的行上。 3.4实例4在ESDN中有一个替换网页的例程，大家自己看吧。 第四章正则表达式话题[原创文章，转载请保留或注明出处： 引言本文将逐步讨论一些正则表达式的使用话题。本文为第二章之后的扩展，在阅读本文之前，建议先阅读本书第二章节内容。 一.表达式的递归匹配有时候，我们需要用正则表达式来分析一个计算式中的括号配对情况。比如，使用表达式“\( [^)]* \)”或者“\( .*? \)”可以匹配一对小括号。但是如果括号内还嵌有一层括号的话，如“( ( ) )”，则这种写法将不能够匹配正确，得到的结果是“( ( )”。类似情况的还有HTML中支持嵌套的标签如“ ”等。本节将要讨论的是，想办法把有嵌套的的成对括号或者成对标签匹配出来。 1.１匹配未知层次的嵌套有的正则表达式引擎，专门针对这种嵌套提供了支持。并且在栈空间允许的情况下，能够支持任意未知层次的嵌套：比如Perl，PHP，GRETA等。在PHP和GRETA中，表达式中使用(?R)来表示嵌套部分。 匹配嵌套了未知层次的“小括号对”的表达式写法如下：“\( ([^()] | (?R))* \)”。 [Perl和PHP的示例代码] 1.2匹配有限层次的嵌套对于不支持嵌套的正则表达式引擎，只能通过一定的办法来匹配有限层次的嵌套。思路如下： 第一步，写一个不能支持嵌套的表达式：“\( [^()]* \)”，“((?!).)*”。这两个表达式在匹配有嵌套的文本时，只匹配最内层。 第二步，写一个可匹配嵌套一层的表达式：“\( ([^()] | \( [^()]* \))* \)”。这个表达式在匹配嵌套层数大于一时，只能匹配最里面的两层，同时，这个表达式也能匹配没有嵌套的文本或者嵌套的最里层。 匹配嵌套一层的“”标签，表达式为：“((?!).|(((?!).)*))*”。这个表达式在匹配“”嵌套层数大于一的文本时，只匹配最里面的两层。 第三步，找到匹配嵌套(n)层的表达式与嵌套(n-1)层的表达式之间的关系。比如，能够匹配嵌套(n)层的表达式为： [标记头]([匹配[标记头]和[标记尾]之外的表达式]|[匹配n-1层的表达式])*[标记尾] 回头来看前面编写的“可匹配嵌套一层”的表达式：
第四步，依此类推，可以编写出匹配有限(n)层的表达式。这种方式写出来的表达式，虽然看上去很长，但是这种表达式经过编译后，匹配效率仍然是很高的。 二.非贪婪匹配的效率可能有不少的人和本人一样，有过这样的经历：当我们要匹配类似“内容”或者“[b]加粗[/b]”这样的文本时，我们根据正向预搜索功能写出这样的表达式：“([^<]|<(?!/td>))*”或者“((?!).)*”。 当发现非贪婪匹配之时，恍然大悟，同样功能的表达式可以写得如此简单：“.*?”。顿时间如获至宝，凡是按边界匹配的地方，尽量使用简捷的非贪婪匹配“.*?”。特别是对于复杂的表达式来说，采用非贪婪匹配“.*?”写出来的表达式的确是简练了许多。 然而，当一个表达式中，有多个非贪婪匹配时，或者多个未知匹配次数的表达式时，这个表达式将可能存在效率上的陷阱。有时候，匹配速度慢得莫名奇妙，甚至开始怀疑正则表达式是否实用。 ２.１效率陷阱的产生在本书第二章里，对非贪婪匹配的描述中说到：“如果少匹配就会导致整个表达式匹配失败的时候，与贪婪模式类似，非贪婪模式会最小限度的再匹配一些，以使整个表达式匹配成功。” 具体的匹配过程是这样的： 1．“非贪婪部分”先匹配最少次数，然后尝试匹配“右侧的表达式”。 2．如果右侧的表达式匹配成功，则整个表达式匹配结束。如果右侧表达式匹配失败，则“非贪婪部分”将增加匹配一次，然后再尝试匹配“右侧的表达式”。 3．如果右侧的表达式又匹配失败，则“非贪婪部分”将再增加匹配一次。再尝试匹配“右侧的表达式”。 4．依此类推，最后得到的结果是“非贪婪部分”以尽可能少的匹配次数，使整个表达式匹配成功。或者最终仍然匹配失败。 当一个表达式中有多个非贪婪匹配，以表达式“d(\w+?)d(\w+?)z”为例，对于第一个括号中的“\w+?”来说，右边的“d(\w+?)z”属于它的“右侧的表达式”，对于第二个括号中的“\w+?”来说，右边的“z”属于它的“右侧的表达式”。 当“z”匹配失败时，第二个“\w+?”会“增加匹配一次”，再尝试匹配“z”。如果第二个“\w+?”无论怎样“增加匹配次数”，直至整篇文本结束，“z”都不能匹配，那么表示“d(\w+?)z”匹配失败，也就是说第一个“\w+?”的“右侧”匹配失败。此时，第一个“\w+?”会增加匹配一次，然后再进行“d(\w+?)z”的匹配。循环前面所讲的过程，直至第一个“\w+?”无论怎么“增加匹配次数”，后边的“d(\w+?)z”都不能匹配时，整个表达式才宣告匹配失败。 其实，为了使整个表达式匹配成功，贪婪匹配也会适当的“让出”已经匹配的字符。因此贪婪匹配也有类似的情况。当一个表达式中有较多的未知匹配次数的表达式时，为了让整个表达式匹配成功，各个贪婪或非贪婪的表达式都要进行尝试减少或增加匹配次数，由此容易形成一个大循环的尝试，造成了很长的匹配时间。本文之所以称之为“陷阱”，因为这种效率问题往往不易察觉。 举例：“d(\w+?)d(\w+?)d(\w+?)z”匹配“ddddddddddd...”时，将花费较长一段时间才能判断出匹配失败。 ２.２效率陷阱的避免避免效率陷阱的原则是：避免“多重循环”的“尝试匹配”。并不是说非贪婪匹配就是不好的，只是在运用非贪婪匹配的时候，需要注意避免过多“循环尝试”的问题。 情况一：对于只有一个非贪婪或者贪婪匹配的表达式来说，不存在效率陷阱。也就是说，要匹配类似“内容”这样的文本，表达式“([^<]|<(?!/td>))*”和“((?!).)*”和“.*?”的效率是完全相同的。 情况二：如果一个表达式中有多个未知匹配次数的表达式，应防止进行不必要的尝试匹配。 比如，对表达式“”更好。 附录:一．17种常用正则表达式
附录2-简明教程 正则表达式(regular expression) 前言 正则表达式是烦琐的，但是强大的，学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。只要认真去阅读这些资料，加上应用的时候进行一定的参考，掌握正则表达式不是问题。 索引 1._引子 2._正则表达式的历史 3._正则表达式定义 3.1_普通字符 3.2_非打印字符 3.3_特殊字符 3.4_限定符 3.5_定位符 3.6_选择 3.7_后向引用 4._各种操作符的运算优先级 5._全部符号解释 6._部分例子 7._正则表达式匹配规则 7.1_基本模式匹配 7.2_字符簇 7.3_确定重复出现 -------------------------------------------------------------------------------- 1. 引子 目前，正则表达式已经在很多软件中得到广泛的应用，包括*nix（Linux, Unix等），HP等操作系统，PHP，C#，Java等开发环境，以及很多的应用软件中，都可以看到正则表达式的影子。 正则表达式的使用，可以通过简单的办法来实现强大的功能。为了简单有效而又不失强大，造成了正则表达式代码的难度较大，学习起来也不是很容易，所以需要付出一些努力才行，入门之后参照一定的参考，使用起来还是比较简单有效的。 例子： ^.+@.+\\..+$ 这样的代码曾经多次把我自己给吓退过。可能很多人也是被这样的代码给吓跑的吧。继续阅读本文将让你也可以自由应用这样的代码。 注意：这里的第7部分跟前面的内容看起来似乎有些重复，目的是把前面表格里的部分重新描述了一次，目的是让这些内容更容易理解。 2. 正则表达式的历史 正则表达式的“祖先”可以一直上溯至对人类神经系统如何工作的早期研究。Warren McCulloch 和 Walter Pitts 这两位神经生理学家研究出一种数学方式来描述这些神经网络。 1956 年, 一位叫 Stephen Kleene 的数学家在 McCulloch 和 Pitts 早期工作的基础上，发表了一篇标题为“神经网事件的表示法”的论文，引入了正则表达式的概念。正则表达式就是用来描述他称为“正则集的代数”的表达式，因此采用“正则表达式”这个术语。 随后，发现可以将这一工作应用于使用 Ken Thompson 的计算搜索算法的一些早期研究，Ken Thompson 是 Unix 的主要发明人。正则表达式的第一个实用应用程序就是 Unix 中的 qed 编辑器。 如他们所说，剩下的就是众所周知的历史了。从那时起直至现在正则表达式都是基于文本的编辑器和搜索工具中的一个重要部分。 3. 正则表达式定义 正则表达式(regular expression)描述了一种字符串匹配的模式，可以用来检查一个串是否含有某种子串、将匹配的子串做替换或者从某个串中取出符合某个条件的子串等。 列目录时， dir *.txt或ls *.txt中的*.txt就不是一个正则表达式,因为这里*与正则式的*的含义是不同的。 正则表达式是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。 3.1 普通字符 由所有那些未显式指定为元字符的打印和非打印字符组成。这包括所有的大写和小写字母字符，所有数字，所有标点符号以及一些符号。 3.2 非打印字符 字符 含义 \cx 匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 c 字符。 \f 匹配一个换页符。等价于 \x0c 和 \cL。 \n 匹配一个换行符。等价于 \x0a 和 \cJ。 \r 匹配一个回车符。等价于 \x0d 和 \cM。 \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 \t 匹配一个制表符。等价于 \x09 和 \cI。 \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。 3.3 特殊字符 所谓特殊字符，就是一些有特殊含义的字符，如上面说的*.txt中的*，简单的说就是表示任何字符串的意思。如果要查找文件名中有＊的文件，则需要对＊进行转义，即在其前加一个\。ls \*.txt。正则表达式有以下特殊字符。 特别字符 说明 $ 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 \n 或 \r。要匹配 $ 字符本身，请使用 \$。 ( ) 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。 * 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。 + 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。 . 匹配除换行符 \n之外的任何单字符。要匹配 .，请使用 \。 [ 标记一个中括号表达式的开始。要匹配 [，请使用 \[。 ? 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。 \ 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， n 匹配字符 n。\n 匹配换行符。序列 \\ 匹配 \，而 \( 则匹配 (。 ^ 匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。 { 标记限定符表达式的开始。要匹配 {，请使用 \{。 | 指明两项之间的一个选择。要匹配 |，请使用 \|。 构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与操作符将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。 3.4 限定符 限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有*或+或?或{n}或{n,}或{n,m}共6种。 *、+和?限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。 正则表达式的限定符有： 字符 描述 * 匹配前面的子表达式零次或多次。例如，zo* 能匹配 z 以及 zoo。* 等价于{0,}。 + 匹配前面的子表达式一次或多次。例如，zo+ 能匹配 zo 以及 zoo，但不能匹配 z。+ 等价于 {1,}。 ? 匹配前面的子表达式零次或一次。例如，do(es)? 可以匹配 do 或 does 中的do 。? 等价于 {0,1}。 {n} n 是一个非负整数。匹配确定的 n 次。例如，o{2} 不能匹配 Bob 中的 o，但是能匹配 food 中的两个 o。 {n,} n 是一个非负整数。至少匹配n 次。例如，o{2,} 不能匹配 Bob 中的 o，但能匹配 foooood 中的所有 o。o{1,} 等价于 o+。o{0,} 则等价于 o*。 {n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，o{1,3} 将匹配 fooooood 中的前三个 o。o{0,1} 等价于 o?。请注意在逗号和两个数之间不能有空格。 3.5 定位符 用来描述字符串或单词的边界，^和$分别指字符串的开始与结束，\b描述单词的前或后边界，\B表示非单词边界。不能对定位符使用限定符。 3.6 选择 用圆括号将所有选择项括起来，相邻的选择项之间用|分隔。但用圆括号会有一个副作用，是相关的匹配会被缓存，此时可用?:放在第一个选项前来消除这种副作用。 其中?:是非捕获元之一，还有两个非捕获元是?=和?!，这两个还有更多的含义，前者为正向预查，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串，后者为负向预查，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。 3.7 后向引用 对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左至右所遇到的内容存储。存储子匹配的缓冲区编号从 1 开始，连续编号直至最大 99 个子表达式。每个缓冲区都可以使用 \n 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。 可以使用非捕获元字符 ?:, ?=, or ?! 来忽略对相关匹配的保存。 4. 各种操作符的运算优先级 相同优先级的从左到右进行运算，不同优先级的运算先高后低。各种操作符的优先级从高到低如下： 操作符 描述 \ 转义符 (), (?:), (?=), [] 圆括号和方括号 *, +, ?, {n}, {n,}, {n,m} 限定符 ^, $, \anymetacharacter 位置和顺序 | “或”操作 5. 全部符号解释 字符 描述 \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，n 匹配字符 n。\n 匹配一个换行符。序列 \\ 匹配 \ 而 \( 则匹配 (。 ^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 \n 或 \r 之后的位置。 $ 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 \n 或 \r 之前的位置。 * 匹配前面的子表达式零次或多次。例如，zo* 能匹配 z 以及 zoo。* 等价于{0,}。 + 匹配前面的子表达式一次或多次。例如，zo+ 能匹配 zo 以及 zoo，但不能匹配 z。+ 等价于 {1,}。 ? 匹配前面的子表达式零次或一次。例如，do(es)? 可以匹配 do 或 does 中的do 。? 等价于 {0,1}。 {n} n 是一个非负整数。匹配确定的 n 次。例如，o{2} 不能匹配 Bob 中的 o，但是能匹配 food 中的两个 o。 {n,} n 是一个非负整数。至少匹配n 次。例如，o{2,} 不能匹配 Bob 中的 o，但能匹配 foooood 中的所有 o。o{1,} 等价于 o+。o{0,} 则等价于 o*。 {n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，o{1,3} 将匹配 fooooood 中的前三个 o。o{0,1} 等价于 o?。请注意在逗号和两个数之间不能有空格。 ? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 oooo，o+? 将匹配单个 o，而 o+ 将匹配所有 o。 . 匹配除 \n 之外的任何单个字符。要匹配包括 \n 在内的任何字符，请使用象 [.\n] 的模式。 (pattern) 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 \( 或 \)。 (?:pattern) 匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 或 字符 (|) 来组合一个模式的各个部分是很有用。例如， industr(?:y|ies) 就是一个比 industry|industries 更简略的表达式。 (?=pattern) 正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，Windows (?=95|98|NT|2000) 能匹配 Windows 2000 中的 Windows ，但不能匹配 Windows 3.1 中的 Windows。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。 (?!pattern) 负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如Windows (?!95|98|NT|2000) 能匹配 Windows 3.1 中的 Windows，但不能匹配 Windows 2000 中的 Windows。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始 x|y 匹配 x 或 y。例如，z|food 能匹配 z 或 food。(z|f)ood 则匹配 zood 或 food。 [xyz] 字符集合。匹配所包含的任意一个字符。例如， [abc] 可以匹配 plain 中的 a。 [^xyz] 负值字符集合。匹配未包含的任意字符。例如， [^abc] 可以匹配 plain 中的p。 [a-z] 字符范围。匹配指定范围内的任意字符。例如，[a-z] 可以匹配 a 到 z 范围内的任意小写字母字符。 [^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。例如，[^a-z] 可以匹配任何不在 a 到 z 范围内的任意字符。 \b 匹配一个单词边界，也就是指单词和空格间的位置。例如， er\b 可以匹配never 中的 er，但不能匹配 verb 中的 er。 \B 匹配非单词边界。er\B 能匹配 verb 中的 er，但不能匹配 never 中的 er。 \cx 匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 c 字符。 \d 匹配一个数字字符。等价于 [0-9]。 \D 匹配一个非数字字符。等价于 [^0-9]。 \f 匹配一个换页符。等价于 \x0c 和 \cL。 \n 匹配一个换行符。等价于 \x0a 和 \cJ。 \r 匹配一个回车符。等价于 \x0d 和 \cM。 \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 \t 匹配一个制表符。等价于 \x09 和 \cI。 \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。 \w 匹配包括下划线的任何单词字符。等价于[A-Za-z0-9_]。 \W 匹配任何非单词字符。等价于 [^A-Za-z0-9_]。 \xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，\x41 匹配 A。\x041 则等价于 \x04 & 1。正则表达式中可以使用 ASCII 编码。. \num 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，(.)\1 匹配两个连续的相同字符。 \n 标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。 \nm 标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。 \nml 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。 \un 匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。 6. 部分例子 正则表达式 说明 /\b([a-z]+) \1\b/gi 一个单词连续出现的位置 /(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/ 将一个URL解析为协议、域、端口及相对路径 /^(?:Chapter|Section) [1-9][0-9]{0,1}$/ 定位章节的位置 /[-a-z]/ A至z共26个字母再加一个-号。 /ter\b/ 可匹配chapter，而不能terminal /\Bapt/ 可匹配chapter，而不能aptitude /Windows(?=95 |98 |NT )/ 可匹配Windows95或Windows98或WindowsNT,当找到一个匹配后，从Windows后面开始进行下一次的检索匹配。 7. 正则表达式匹配规则 7.1 基本模式匹配 一切从最基本的开始。模式，是正规表达式最基本的元素，它们是一组描述字符串特征的字符。模式可以很简单，由普通的字符串组成，也可以非常复杂，往往用特殊的字符表示一个范围内的字符、重复出现，或表示上下文。例如： ^once 这个模式包含一个特殊的字符^，表示该模式只匹配那些以once开头的字符串。例如该模式与字符串once upon a time匹配，与There once was a man from NewYork不匹配。正如如^符号表示开头一样，$符号用来匹配那些以给定模式结尾的字符串。 bucket$ 这个模式与Who kept all of this cash in a bucket匹配，与buckets不匹配。字符^和$同时使用时，表示精确匹配（字符串与模式一样）。例如： ^bucket$ 只匹配字符串bucket。如果一个模式不包括^和$，那么它与任何包含该模式的字符串匹配。例如：模式 once 与字符串 There once was a man from NewYork Who kept all of his cash in a bucket. 是匹配的。 在该模式中的字母(o-n-c-e)是字面的字符，也就是说，他们表示该字母本身，数字也是一样的。其他一些稍微复杂的字符，如标点符号和白字符（空格、制表符等），要用到转义序列。所有的转义序列都用反斜杠(\)打头。制表符的转义序列是：\t。所以如果我们要检测一个字符串是否以制表符开头，可以用这个模式： ^\t 类似的，用\n表示“新行”，\r表示回车。其他的特殊符号，可以用在前面加上反斜杠，如反斜杠本身用\\表示，句号.用\.表示，以此类推。 7.2 字符簇 在INTERNET的程序中，正规表达式通常用来验证用户的输入。当用户提交一个FORM以后，要判断输入的电话号码、地址、EMAIL地址、信用卡号码等是否有效，用普通的基于字面的字符是不够的。 所以要用一种更自由的描述我们要的模式的办法，它就是字符簇。要建立一个表示所有元音字符的字符簇，就把所有的元音字符放在一个方括号里： [AaEeIiOoUu] 这个模式与任何元音字符匹配，但只能表示一个字符。用连字号可以表示一个字符的范围，如： [a-z] //匹配所有的小写字母 [A-Z] //匹配所有的大写字母 [a-zA-Z] //匹配所有的字母 [0-9] //匹配所有的数字 [0-9\.\-] //匹配所有的数字，句号和减号 [ \f\r\t\n] //匹配所有的白字符 同样的，这些也只表示一个字符，这是一个非常重要的。如果要匹配一个由一个小写字母和一位数字组成的字符串，比如z2、t6或g7，但不是ab2、r2d3 或b52的话，用这个模式： ^[a-z][0-9]$ 尽管[a-z]代表26个字母的范围，但在这里它只能与第一个字符是小写字母的字符串匹配。 前面曾经提到^表示字符串的开头，但它还有另外一个含义。当在一组方括号里使用^是，它表示“非”或“排除”的意思，常常用来剔除某个字符。还用前面的例子，我们要求第一个字符不能是数字： ^[^0-9][0-9]$ 这个模式与&5、g7及-2是匹配的，但与12、66是不匹配的。下面是几个排除特定字符的例子： [^a-z] //除了小写字母以外的所有字符 [^\\\/\^] //除了(\)(/)(^)之外的所有字符 [^\\] //除了双引号()和单引号()之外的所有字符 特殊字符. (点，句号)在正规表达式中用来表示除了“新行”之外的所有字符。所以模式^.5$与任何两个字符的、以数字5结尾和以其他非“新行”字符开头的字符串匹配。模式.可以匹配任何字符串，除了空串和只包括一个“新行”的字符串。 PHP的正规表达式有一些内置的通用字符簇，列表如下： 字符簇 含义 [[:alpha:]] 任何字母 [[:digit:]] 任何数字 [[:alnum:]] 任何字母和数字 [[:space:]] 任何白字符 [[:upper:]] 任何大写字母 [[:lower:]] 任何小写字母 [[:punct:]] 任何标点符号 [[:xdigit:]] 任何16进制的数字，相当于[0-9a-fA-F] 7.3 确定重复出现 到现在为止，你已经知道如何去匹配一个字母或数字，但更多的情况下，可能要匹配一个单词或一组数字。一个单词有若干个字母组成，一组数字有若干个单数组成。跟在字符或字符簇后面的花括号({})用来确定前面的内容的重复出现的次数。 字符簇 含义 ^[a-zA-Z_]$ 所有的字母和下划线 ^[[:alpha:]]{3}$ 所有的3个字母的单词 ^a$ 字母a ^a{4}$ aaaa ^a{2,4}$ aa,aaa或aaaa ^a{1,3}$ a,aa或aaa ^a{2,}$ 包含多于两个a的字符串 ^a{2,} 如：aardvark和aaab，但apple不行 a{2,} 如：baad和aaa，但Nantucket不行 \t{2} 两个制表符 .{2} 所有的两个字符 这些例子描述了花括号的三种不同的用法。一个数字，{x}的意思是“前面的字符或字符簇只出现x次”；一个数字加逗号，{x,}的意思是“前面的内容出现x或更多的次数”；两个用逗号分隔的数字，{x,y}表示“前面的内容至少出现x次，但不超过y次”。我们可以把模式扩展到更多的单词或数字： ^[a-zA-Z0-9_]{1,}$ //所有包含一个以上的字母、数字或下划线的字符串 ^[0-9]{1,}$ //所有的正数 ^\-{0,1}[0-9]{1,}$ //所有的整数 ^\-{0,1}[0-9]{0,}\.{0,1}[0-9]{0,}$ //所有的小数 最后一个例子不太好理解，是吗？这么看吧：与所有以一个可选的负号(\-{0,1})开头(^)、跟着0个或更多的数字([0-9]{0,})、和一个可选的小数点(\.{0,1})再跟上0个或多个数字([0-9]{0,})，并且没有其他任何东西($)。下面你将知道能够使用的更为简单的方法。 特殊字符?与{0,1}是相等的，它们都代表着：“0个或1个前面的内容”或“前面的内容是可选的”。所以刚才的例子可以简化为： ^\-?[0-9]{0,}\.?[0-9]{0,}$ 特殊字符*与{0,}是相等的，它们都代表着“0个或多个前面的内容”。最后，字符+与 {1,}是相等的，表示“1个或多个前面的内容”，所以上面的4个例子可以写成： ^[a-zA-Z0-9_]+$ //所有包含一个以上的字母、数字或下划线的字符串 ^[0-9]+$ //所有的正数 ^\-?[0-9]+$ //所有的整数 ^\-?[0-9]*\.?[0-9]*$ //所有的小数 当然这并不能从技术上降低正规表达式的复杂性，但可以使它们更容易阅读。 教程精选：正则表达式快速入门作者：开心石头 出处：天极网 责任编辑：wenwu [ 2005-12-02 11:06 ] 【导读】正则表达式是从左向右去匹配目标字符串的一组模式。大多数字符在模式中表示它们自身并匹配目标中相应的字符 正则表达式广泛出现在UNIX/Linux相关的各种领域和多种编程语言里。从常见的shell命令到大名鼎鼎的Perl语言再到当前非常流行的PHP，它都扮演着一个重要的角色。甚至windows的命令行控制台也支持正则表达式。如果你是一个Linux服务器管理员，你经常会在一些服务器的设置脚本里看到它。 可以说，它是学好Linux/UNIX必需掌握的一个知识点，否则你连Linux的启动脚本都读不懂。偏偏它又的确有点晦涩难懂，而且相关的资料又大部分是英文，更为它的学习增加了几多困难。即使有些中文的翻译资料，不同的译者对一些术语的译法也五花八门，读着让人平添困惑。为此，我决定为它写一个简明教程，尽量可以覆盖正则表达式涉及到的各主要概念。 我并不想把本文写成一本详细的正则表达式语法手册，事实上，这些手册已经存在了，不过读起来比较难懂。我希望的是在完成本教程后，你可以比较轻松的读懂各种工具的正则表达式语法手册并可以迅速上手，不过要用好正则表达式，可不是一篇短短的教程可以解决的，那是无数实践练习的结果。但是，本文的最后一部分对于正则表达式的编写提出了一些原则性的建议，学习一下这些正则表达式应用先驱者的经验会让我们在今后的实践中少走一些弯路。 正则表达式是英文“regular expressions”的译文，它的产生据说可以追溯到“神经网络”等比较高深的理论。那么什么是正则表达式呢? 正则表达式是从左向右去匹配目标字符串的一组模式。大多数字符在模式中表示它们自身并匹配目标中相应的字符。举个最简单的例子，模式“The quick brown fox”匹配了目标字符串中与其完全相同的一部分。 前面已经提过，正则表达式被许多植根于UNIX/Linux的工具采用，可是这些工具的正则表达式语法并不完全相同，它们中的一些对正则表达式语法的扩展并不被其它工具识别，这也为正则表达式的使用增加了难度。因此，当你在一个具体的环境中使用正则表达式时，你还要先看一下目标环境支持的语法范围，以确保你的正则表达式被正确的解析。 在本文中列举的例子里，我们用正斜线“/”做为模式的定界符(delimiter)，一个模式用下面这种格式表示: /[A-Z]+(abc|xyz)*/I 本文将较详细的阐明下面这些正则表达式概念：模式修正符（modifier），元字符（Meta-characters），子模式（subpatterns）与逆向引用（Back references），重复（Repetition）和量词（quantifiers），断言（Assertions），注释，正则表达式中的递归，最后我介绍一款方便学习正则表达式的工具并介绍一些正则表达式编写的思路。 正则表达式的模式修正符(modifier)正则表达式的模式修正符主要用来限定模式与目标字符串的匹配方式，例如是否需要大小写敏感的匹配，是单行模式还是多行模式。修正符中的空格和换行被忽略，其它字符会导致错误。下面列举一些常见的模式修正符。注意，模式修正符是区分大小写的。 i:非大小写敏感模式，:如果设定此修正符，模式中的字符将同时匹配大小写字母。 m:多行模式，当设定了此修正符，“行起始”和“行结束”除了匹配整个字符串开头和结束外，还分别匹配其中的换行符的之后和之前。 s:单行模式，如果设定了此修正符，模式中的圆点元字符(.)匹配所有的字符，包括换行符。没有此设定的话，则不包括换行符。 对于多行模式和单行模式，一个容易让初学者迷惑的地方是这两者并不向字面上那样是互斥的。事实上，它们只是分别定义了英文句点(.)、音调符(^)和美元符($)这三个元字符的匹配方式，因此，单行模式与多行模式的修正符可以同时使用。 x:如果设定了此修正符，模式中的空白字符除了被转义的或在字符类中的以外完全被忽略，在未转义的字符类之外的#以及下一个换行符之间的所有字符，包括两头，也都被忽略。它使得可以在复杂的模式中加入注释。我们会在后面的部分更详细的讲解正则表达中的注释。 模式修正符还有很多，这里不再一一列举。我们会结合后面的内容介绍一些其它的模式修正符。不同的工具也可以添加自己的模式修正符，不过上面几最为常见。 模式修正符通常跟在模式定义结束符的后面，例如下面例子中模式最后的“i”字符。/[A-Z]+(abc|xyz)*/i，这时此修正符会对整个匹配模式起作用。模式修正符也可以在模式内部通过包含在(?和)之间的修正符字母序列来实现。例如，(?im)设定了不区分大小写，多行模式。也可以通过在字母前加上减号来取消这些选项。例如组合的选项(?im-s)，设定了不区分大小写和多行模式，并取消了单行模式。如果一个字母在减号之前与之后都出现了，则该选项被取消设定。 注意，如果(?im-s)出现在一个子模式内(被另一对小括号包含)会把模式修正符的作用局限在该子模式中。 正则表达式的元字符（Meta-characters） 正则表达式的威力在于其能够在模式中包含选择和循环。它们通过使用元字符来编码在模式中，元字符不代表其自身，它们用一些特殊的方式来解析。 有两组不同的元字符:一种是模式中除了方括号内都能被识别的，还有一种是在方括号内被识别的。如果想在模式里包含一个元字符本身，就需要用到转义符号，正则表达式常用反斜线“\”作为转义字符使用，为了匹配“\”本身，你需要输入两个“\”，向这样“\\”。当然，这个符号本身也是一个元字符。 方括号之外的元字符有这些: 有数种用途的通用转义符 ^ 断言目标的开头(或在多行模式下行的开头，即紧随一换行符之后) $ 断言目标的结尾(或在多行模式下行的结尾，即紧随一换行符之前) . 匹配除了换行符外的任意一个字符(默认情况下) [ 字符类定义开始 ] 字符类定义结束 | 开始一个多选一的分支 ( 子模式开始 ) 子模式结束 ? 扩展(的含义，我们已经在介绍模式修正符里看到过它的使用。它也可以是0或1数量限定符，以及数量限定符最小值 * 匹配0个或多个的数量限定符 + 匹配1个或多个的数量限定符 { 最少/最多数量限定开始 } 最少/最多数量限定结束 模式中方括号内的部分称为“字符类”。字符类中可用的元字符为: 通用转义字符 ^ 排除字符类，但仅当其为第一个字符时有效 - 指出字符范围 在这里，最值得一提是“\”这个元字符。之所以重点对它进行讲解是因为这一个元字符有多种不同的用法，在不同情况下代表不同的含义，而且使用频率非常高，是个很容易让人迷惑的地方。 第一种用法前面我们已经提过，是作为通用转义字符使用，如果其后跟着一个非字母数字字符，则取消该字符可能具有的任何特殊含义。此种将反斜线用作转义字符的用法适用于无论是字符类之中还是之外。例如“\\”代表一个单独的反斜线“\”。 第二种用途提供了一种在模式中以可见方式去编码不可打印字符的方法。模式中完全可以包括不可打印字符，除了代表模式结束的二进制零，例如，可以用“\a”代表alarm，即BEL字符(0x07)，或用“\cx”代表control-x，其中x是任意字符。当然，这种方法表示的不一定非得是不可打印字符，实际上，可以用“\xhh(十六进制代码为hh的字符)”和“\ddd(八进制代码为ddd的字符)”来以编码的形式表达任何单字节字符，例如“\040”可以用来表示空格。 反斜线的第三个用法是指定通用字符类型，这些字符类型序列可以出现在字符类之中和之外。每一个匹配相应类型中的一个字符。如果当前匹配点在目标字符串的结尾，以上所有匹配都失败，因为没有字符可供匹配。有以下这些常见的通用字符类: \d任一十进制数字 \D任一非十进制数的字符 \s任一空白字符 \S任一非空白字符 \w任一“字”的字符 \W任一“非字”的字符 反斜线的第四个用法是某些简单的断言，关于断言的讨论我们放在后面，这里先不加讨论。 反斜线的最后一个用法是逆向引用。关于逆向引用，我们会在后面讨论逆向引用的部分来做进一步的讨论。 我们已经看到，反斜线的众多用法，其中一些涉及到了以后才讲的内容。我们在模式中遇到反斜线时一定要注意它具体是哪一种用途以免疑惑。 另外两个方括号也是非常重要的元字符，左方括号开始了一个字符类，右方括号结束之。单独一个右方括号不是特殊字符。字符类匹配目标中的一个字符，该字符必须是字符类定义的字符集中的一个;除非字符类中的第一个字符是音调符(^)，此情况下目标字符必须不在字符类定义的字符集中。如果在字符类中需要音调符本身，则其必须不是第一个字符，或用反斜线转义。例如，[^A-Z]表式非大写字符。 其它元字符我们会在以后的文章中结合相关内容介绍。 在上篇文章里，我们介绍了正则表达式的模式修正符与元字符，细心的读者也许会发现，这部分介绍的非常简略，而且很少有实际的例子的讲解。这主要是因为网上现有的正则表达式资料都对这部分都有详细的介绍和众多的例子，如果觉得对前一部分缺乏了解可以参看这些资料。本文希望可以尽可能多涉及一些较高级的正则表达式特性。 在本文里，我们主要介绍子模式(subpatterns)，逆向引用(Back references)和量词(quantifiers)，其中重点介绍对这些概念的一些扩展应用，例如子模式中的非捕获子模式，量词匹配时的greedy与ungreedy。 子模式(subpatterns)与逆向引用(Back references) 正则表达式可以包含多个字模式，子模式由圆括号定界，可以嵌套。这也是两个元字符“(”和“)”的作用。子模式可以有以下作用: 1.将多选一的分支局部化。 例如，模式: cat(aract|erpillar|)匹配了cat，cataract或caterpillar之一，没有圆括号的话将匹配cataract，erpillar或空字符串。 2.将子模式设定为捕获子模式(例如上面这个例子)。当整个模式匹配时，目标字符串中匹配了子模式的部分可以通过逆向引用进行调用。左圆括号从左到右计数(从1开始)以取得捕获子模式的数。 注意，子模式是可以嵌套的，例如，如果将字符串the red king来和模式/the ((red|white) (king|queen))/进行匹配，捕获的子串为red king，red以及king，并被计为1，2和3，可以通过“\1”，“\2”，“\3”来分别引用它们，“\1”包含了“\2”和“\3”，它们的序号是由左括号的顺序决定的。 在一些老的linux/unux工具里，子模式使用的圆括号需要用反斜线转义，向这种\(subpattern\)，但现代的工具已经不需要了，本文中使用的例子都不进行转义。 在上文里，我们介绍了正则表达式的子模式，逆向引用和量词，在这篇文章里，我们将重点介绍正则表达式中的断言(Assertions)。 断言(Assertions) 断言(Assertions)是在目标字符串的当前匹配位置进行的一种测试但这种测试并不占用目标字符串，也即不会移动模式在目标字符串中的当前匹配位置。 读起来似乎有点拗口，我们还是举几个简单的例子。 两个最常见的断言是元字符“^”和“$”，它们检查匹配模式是否出现在行首或行尾。 我们来看这个模式/^\d\d\d$/，试着用它来匹配目标字符串“123”。“\d\d\d”表示三个数字字符，匹配了目标字符串的三个字符，而模式中的^和$分别表示这三个字符同时出现在行首和行尾，而它们本身并不与目标字符串中的任何字符相对应。 其它还有一些简单的断言\b, \B, \A, \Z, \z，它们都以反斜线开头，前面我们已经介绍过反斜线的这个用法。这几个断言的含义如下表。
注意这些断言不能出现在字符类中，如果出现了也是其它的含义，例如\b在字符类中表示反斜线字符0x08。 前面介绍的这些断言的测试都是一些基于当前位置的测试，断言还支持更多复杂的测试条件。更复杂的断言以子模式方式来表示，它包括前向断言(Lookahead assertions)和后向断言(Lookbehind assertions)。 前向断言(Lookahead assertions) 前向断言从目标字符串的当前位置向前测试断言条件是否成立。前向断言又可分为前向肯定断言和前向否定断言，分别用(?=和{?!表示。例如模式/ \w+(?=;)/用来表示一串文本字符后面会有一个分号，但是这个分号并不包括在匹配结果中。一件有趣的事看起来差不多的模式/ (?=;)\w+/并不是表示一串前面不是分号的alpha字符串，事实上，不论这串alpha字符的前面是否是一个分号它总是匹配的，要完成这个功能需要我们下面提到的后向断言(Lookbehind assertions)。 后向断言(Lookbehind assertions) 后向断言分别用(?<=和(? 使用后向断言与一次性子模式搭配使用可以有效的文本的结束部分进行匹配，这里来看一下例子。 考虑一下如果用/abcd$/这样一个简单的模式来匹配一长段以abcd结尾的文本，因为模式的匹配过程是从左向右进行的，正则表达式引擎将在文本中寻找每一个a字符并尝试匹配剩余的模式，如果在这长段文本里仅好有不少的a字符，这样做明显是非常低效的，而如果把以上模式换成为样/^.*abcd$/，这时前面的“^.*”部分将匹配整个文本，然后它发现下一个模式a无法匹配，这时会发生前面提到过的回溯过程，解析器会逐次缩短“^.*”匹配的字符长度从右向左逐次查找剩余的子模式，也要产生多次的尝试过程。现在，我们用一次性子模式与后向断言重写所用的模式，改为/^(?>.*)(?<=abcd)/，这时，一次性子模式一次匹配了整段文本，然后用后向断言检查前面四个字符是否为abcd，只需要一次检测就可以立刻确定整个模式是否匹配。在遇到需要匹配一个很长的文本时，这种方法可以非常显著的提高处理效率。 一个模式中可以包含多个相继的断言，断言也可以嵌套。另外，断言使用的子模式也是非捕获的，不能被逆向引用。 断言的一个重要应用领域就是做为条件子模式的条件。那什么是条件子模式呢？ 在上一篇文章里，我们介绍了正则表达式中断言相关的一些概念，在本文里，我们会介绍正则表达式中递归的运用与利用正则表达式修改目标字符串。 正则表达式中的递归 接触过程序的朋友可能都遇到过成对的各种括号吧，这些括号常常相互嵌套，而且嵌套的层次数目无法确定。试想一下如果想提取一段程序里用括号括起的一段代码，这里面很可能包含了层次数目不定的其它括号对，用正则表达式该如何完成? 在Perl 5.6之前这的确有点困难，不过从Perl 5.6之后，引入了递归正则表达式，这个问题得到了解决。通常在正则表达式里用“(?R)”表示一个对自己的引用，下面让我们看看用什么正则表达式来解决刚才提出的问题。
现在让我们来分析这个模式的含义，这里使用了“x”模式修正符，以便可以在模式中加入空格以方便阅读。 模式的开头是匹配第一个左圆括号，然后我们需要捕获的子模式，注意，字模式后面跟了量词“*”，表示此模式可以重复0到多次。最后是一个结束圆括号。现在我们分析子模式( (?>[^()]+) | (?R) )的内容。这是一个分支子模式，表示模式可以有两种情况，第一种是(?>[^()]+)，这是一个一次性子模式，代表一个以上的非括号字符，另一种情况是| (?R)，也即对正则表达式自己的递归调用——\( ( (?>[^()]+) | (?R) )* \)，又寻找一个左圆括号，开始查找一对嵌套的圆括号包含的内容。 分析到这里，这个正则表达式的含义已经基本清楚，但你注意到没有，这里为什么要使用一次性子模式(?>[^()]+)来查找非括号字符串? 事实上，由于递归的层次是无限的，这种处理非常必要，特别是遇到不匹配的字符串时，它不会让你陷入长时间的等待。考虑一下下面这个目标字符串， (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() 在得出不匹配的最终结果前，如果不使用一次性子模式，解析器将尝试每一种可能的方法来分割目标字符串，这将浪费大量的时间。 在上一篇文章里，我们介绍了正则表达式中的递归与替换，现在让我们接触一个学习正则表达式时方便测试使用的工具，并介绍一些正则表达式的编写思路。 一个学习正则表达式的便捷工具 学习正则表达式最好的方法当然是实践，不过支持正则表达式的工具虽多，但如果仅仅用来做练习却不是很方便。 这里我向一家推荐一款专门的正则表达式编写测试工具，PHPEdit公司的Regular Expression Editor工具。这是一个免费软件，主要用来调试PHP使用的Perl兼容正则表达式函数。使用它可以方便的输入目标字符串和正则表达式，并实时看到匹配的结果。可以到它的下载网页去下载这个工具。 程序的界面非常简明，不过使用中发现，它的一些功能使用起来好像有问题，只有preg_match_all和preg_replace功能正常，另外在匹配模式输入框中，不要加模式定界符，程序好像把该输入框中的全部内容都作为模式来解析。 好在做为一个正则表达式的练习工具，它的功能是足够了，下面是它的运行界面。 程序运行界面 文中提到的各个例子都可以在里面进行测试，在最上面的框里输入模式，把目标字符串写进中间的输入框，点击“run the regxwp”按钮可以在下面得到匹配结果。 正则表达式之道http://net.pku.edu.cn/~yhf/tao_regexps_zh.html 原著：Steve Mansour sman@scruznet.com Revised: June 5, 1999 (copied by jm /at/ jmason.org from http://www./%7esman/regexp.htm, after the original disappeared! ) 翻译：Neo Lee neo.lee@gmail.com 2004年10月16日 英文版原文 译者按：原文因为年代久远，文中很多链接早已过期（主要是关于vi、sed等工具的介绍和手册），本译文中已将此类链接删除，如需检查这些链接可以查看上面链接的原文。除此之外基本照原文直译，括号中有“译者按”的部分是译者补充的说明。如有内容方面的问题请直接和Steve Mansor联系，当然，如果你只写中文，也可以和我联系。 目录 一．什么是正则表达式一个正则表达式，就是用某种模式去匹配一类字符串的一个公式。很多人因为它们看上去比较古怪而且复杂所以不敢去使用——很不幸，这篇文章也不能够改变这一点，不过，经过一点点练习之后我就开始觉得这些复杂的表达式其实写起来还是相当简单的，而且，一旦你弄懂它们，你就能把数小时辛苦而且易错的文本处理工作压缩在几分钟（甚至几秒钟）内完成。正则表达式被各种文本编辑软件、类库（例如Rogue Wave的tools.h++）、脚本工具（像awk/grep/sed）广泛的支持，而且像Microsoft的Visual C++这种交互式IDE也开始支持它了。 我们将在如下的章节中利用一些例子来解释正则表达式的用法，绝大部分的例子是基于vi中的文本替换命令和grep文件搜索命令来书写的，不过它们都是比较典型的例子，其中的概念可以在sed、awk、perl和其他支持正则表达式的编程语言中使用。你可以看看不同工具中的正则表达式这一节，其中有一些在别的工具中使用正则表达式的例子。还有一个关于vi中文本替换命令（s）的简单说明附在文后供参考。 1．正则表达式基础正则表达式由一些普通字符和一些元字符（metacharacters）组成。普通字符包括大小写的字母和数字，而元字符则具有特殊的含义，我们下面会给予解释。 在最简单的情况下，一个正则表达式看上去就是一个普通的查找串。例如，正则表达式testing中没有包含任何元字符，，它可以匹配testing和123testing等字符串，但是不能匹配Testing。 要想真正的用好正则表达式，正确的理解元字符是最重要的事情。下表列出了所有的元字符和对它们的一个简短的描述。 元字符描述 .匹配任何单个字符。例如正则表达式r.t匹配这些字符串：rat、rut、r t，但是不匹配root。 $匹配行结束符。例如正则表达式weasel$能够匹配字符串Hes a weasel的末尾，但是不能匹配字符串They are a bunch of weasels.。 ^匹配一行的开始。例如正则表达式^When in能够匹配字符串When in the course of human events的开始，但是不能匹配What and When in the。 *匹配0或多个正好在它之前的那个字符。例如正则表达式.*意味着能够匹配任意数量的任何字符。 \这是引用府，用来将这里列出的这些元字符当作普通的字符来进行匹配。例如正则表达式\$被用来匹配美元符号，而不是行尾，类似的，正则表达式\.用来匹配点字符，而不是任何字符的通配符。 [ ] [c1-c2] [^c1-c2]匹配括号中的任何一个字符。例如正则表达式r[aou]t匹配rat、rot和rut，但是不匹配ret。可以在括号中使用连字符-来指定字符的区间，例如正则表达式[0-9]可以匹配任何数字字符；还可以制定多个区间，例如正则表达式[A-Za-z]可以匹配任何大小写字母。另一个重要的用法是“排除”，要想匹配除了指定区间之外的字符——也就是所谓的补集——在左边的括号和第一个字符之间使用^字符，例如正则表达式[^269A-Z]将匹配除了2、6、9和所有大写字母之外的任何字符。 \< \>匹配词（word）的开始（\<）和结束（\>）。例如正则表达式\ \( \)将\(和\)之间的表达式定义为“组”（group），并且将匹配这个表达式的字符保存到一个临时区域（一个正则表达式中最多可以保存9个），它们可以用\1到\9的符号来引用。 |将两个匹配条件进行逻辑“或”（Or）运算。例如正则表达式(him|her)匹配it belongs to him和it belongs to her，但是不能匹配it belongs to them.。注意：这个元字符不是所有的软件都支持的。 +匹配1或多个正好在它之前的那个字符。例如正则表达式9+匹配9、99、999等。注意：这个元字符不是所有的软件都支持的。 ?匹配0或1个正好在它之前的那个字符。注意：这个元字符不是所有的软件都支持的。 \{i\} \{i,j\}匹配指定数目的字符，这些字符是在它之前的表达式定义的。例如正则表达式A[0-9]\{3\}能够匹配字符A后面跟着正好3个数字字符的串，例如A123、A348等，但是不匹配A1234。而正则表达式[0-9]\{4,6\}匹配连续的任意4个、5个或者6个数字字符。注意：这个元字符不是所有的软件都支持的。 -------------------------------------------------------------------------------- 最简单的元字符是点，它能够匹配任何单个字符（注意不包括新行符）。假定有个文件test.txt包含以下几行内容：
我们可以使用grep命令来测试我们的正则表达式，grep命令使用正则表达式去尝试匹配指定文件的每一行，并将至少有一处匹配表达式的所有行显示出来。命令 grep r.t test.txt 在test.txt文件中的每一行中搜索正则表达式r.t，并打印输出匹配的行。正则表达式r.t匹配一个r接着任何一个字符再接着一个t。所以它将匹配文件中的rat和rut，而不能匹配Rotten中的Rot，因为正则表达式是大小写敏感的。要想同时匹配大写和小写字母，应该使用字符区间元字符（方括号）。正则表达式[Rr]能够同时匹配R和r。所以，要想匹配一个大写或者小写的r接着任何一个字符再接着一个t就要使用这个表达式：[Rr].t。 要想匹配行首的字符要使用抑扬字符（^）——又是也被叫做插入符。例如，想找到text.txt中行首he打头的行，你可能会先用简单表达式he，但是这会匹配第三行的the，所以要使用正则表达式^he，它只匹配在行首出现的h。 有时候指定“除了×××都匹配”会比较容易达到目的，当抑扬字符（^）出现在方括号中是，它表示“排除”，例如要匹配he，但是排除前面是t or s的情性（也就是the和she），可以使用：[^st]he。 可以使用方括号来指定多个字符区间。例如正则表达式[A-Za-z]匹配任何字母，包括大写和小写的；正则表达式[A-Za-z][A-Za-z]*匹配一个字母后面接着0或者多个字母（大写或者小写）。当然我们也可以用元字符+做到同样的事情，也就是：[A-Za-z]+，和[A-Za-z][A-Za-z]*完全等价。但是要注意元字符+并不是所有支持正则表达式的程序都支持的。关于这一点可以参考后面的正则表达式语法支持情况。 要指定特定数量的匹配，要使用大括号（注意必须使用反斜杠来转义）。想匹配所有100和1000的实例而排除10和10000，可以使用：10\{2,3\}，这个正则表达式匹配数字1后面跟着2或者3个0的模式。在这个元字符的使用中一个有用的变化是忽略第二个数字，例如正则表达式0\{3,\}将匹配至少3个连续的0。 二．范例1．简单的例子这里有一些有代表性的、比较简单的例子。 vi命令作用 :%s/ */ /g把一个或者多个空格替换为一个空格。 :%s/ *$//去掉行尾的所有空格。 :%s/^/ /在每一行头上加入一个空格。 :%s/^[0-9][0-9]* //去掉行首的所有数字字符。 :%s/b[aeio]g/bug/g将所有的bag、beg、big和bog改为bug。 :%s/t\([aou]\)g/h\1t/g将所有tag、tog和tug分别改为hat、hot和hug（注意用group的用法和使用\1引用前面被匹配的字符）。 2．中级的例子（神奇的咒语）例1 将所有方法foo(a,b,c)的实例改为foo(b,a,c)。这里a、b和c可以是任何提供给方法foo()的参数。也就是说我们要实现这样的转换： 之前之后 foo(10,7,2) foo(7,10,2) foo(x+13,y-2,10) foo(y-2,x+13,10) foo( bar(8), x+y+z, 5) foo( x+y+z, bar(8), 5) 下面这条替换命令能够实现这一魔法： :%s/foo(\([^,]*\),\([^,]*\),\([^)]*\))/foo(\2,\1,\3)/g 现在让我们把它打散来加以分析。写出这个表达式的基本思路是找出foo()和它的括号中的三个参数的位置。第一个参数是用这个表达式来识别的：：\([^,]*\)，我们可以从里向外来分析它： [^,]除了逗号之外的任何字符 [^,]* 0或者多个非逗号字符 \([^,]*\)将这些非逗号字符标记为\1，这样可以在之后的替换模式表达式中引用它 \([^,]*\),我们必须找到0或者多个非逗号字符后面跟着一个逗号，并且非逗号字符那部分要标记出来以备后用。 现在正是指出一个使用正则表达式常见错误的最佳时机。为什么我们要使用[^,]*这样的一个表达式，而不是更加简单直接的写法，例如：.*，来匹配第一个参数呢？设想我们使用模式.*来匹配字符串10,7,2，它应该匹配10,还是10,7,？为了解决这个两义性（ambiguity），正则表达式规定一律按照最长的串来，在上面的例子中就是10,7,，显然这样就找出了两个参数而不是我们期望的一个。所以，我们要使用[^,]*来强制取出第一个逗号之前的部分。 这个表达式我们已经分析到了：foo(\([^,]*\)，这一段可以简单的翻译为“当你找到foo(就把其后直到第一个逗号之前的部分标记为\1”。然后我们使用同样的办法标记第二个参数为\2。对第三个参数的标记方法也是一样，只是我们要搜索所有的字符直到右括号。我们并没有必要去搜索第三个参数，因为我们不需要调整它的位置，但是这样的模式能够保证我们只去替换那些有三个参数的foo()方法调用，在foo()是一个重载（overoading）方法时这种明确的模式往往是比较保险的。然后，在替换部分，我们找到foo()的对应实例，然后利用标记好的部分进行替换，是的第一和第二个参数交换位置。 例2 假设有一个CSV（comma separated value）文件，里面有一些我们需要的信息，但是格式却有问题，目前数据的列顺序是：姓名，公司名，州名缩写，邮政编码，现在我们希望讲这些数据重新组织，以便在我们的某个软件中使用，需要的格式为：姓名，州名缩写-邮政编码，公司名。也就是说，我们要调整列顺序，还要合并两个列来构成一个新列。另外，我们的软件不能接受逗号前后面有任何空格（包括空格和制表符）所以我们还必须要去掉逗号前后的所有空格。 这里有几行我们现在的数据： Bill Jones, HI-TEK Corporation , CA, 95011 Sharon Lee Smith, Design Works Incorporated, CA, 95012 B. Amos , Hill Street Cafe, CA, 95013 Alexander Weatherworth, The Crafts Store, CA, 95014 ... 我们希望把它变成这个样子： Bill Jones,CA 95011,HI-TEK Corporation Sharon Lee Smith,CA 95012,Design Works Incorporated B. Amos,CA 95013,Hill Street Cafe Alexander Weatherworth,CA 95014,The Crafts Store ... 我们将用两个正则表达式来解决这个问题。第一个移动列和合并列，第二个用来去掉空格。 下面就是第一个替换命令： :%s/\([^,]*\),\([^,]*\),\([^,]*\),\(.*\)/\1,\3 \4,\2/ 这里的方法跟例1基本一样，第一个列（姓名）用这个表达式来匹配：\([^,]*\)，即第一个逗号之前的所有字符，而姓名内容被用\1标记下来。公司名和州名缩写字段用同样的方法标记为\2和\3，而最后一个字段用\(.*\)来匹配（匹配所有字符直到行末）。替换部分则引用上面标记的那些内容来进行构造。 下面这个替换命令则用来去除空格： :%s/[ \t]*,[ \t]*/,/g 我们还是分解来看：[ \t]匹配空格/制表符，[ \t]*匹配0或多个空格/制表符，[ \t]*,匹配0或多个空格/制表符后面再加一个逗号，最后，[ \t]*,[ \t]*匹配0或多个空格/制表符接着一个逗号再接着0或多个空格/制表符。在替换部分，我们简单的我们找到的所有东西替换成一个逗号。这里我们使用了结尾的可选的g参数，这表示在每行中对所有匹配的串执行替换（而不是缺省的只替换第一个匹配串）。 例3 假设有一个多字符的片断重复出现，例如： Billy tried really hard Sally tried really really hard Timmy tried really really really hard Johnny tried really really really really hard 而你想把really、really really，以及任意数量连续出现的really字符串换成一个简单的very（simple is good!），那么以下命令： :%s/\(really \)\(really \)*/very / 就会把上述的文本变成： Billy tried very hard Sally tried very hard Timmy tried very hard Johnny tried very hard 表达式\(really \)*匹配0或多个连续的really （注意结尾有个空格），而\(really \)\(really \)*匹配1个或多个连续的really 实例。 3．困难的例子（不可思议的象形文字）Coming soon. 三．不同工具中的正则表达式OK，你已经准备使用RE（regular expressions，正则表达式），但是你并准备使用vi。所以，在这里我们给出一些在其他工具中使用RE的例子。另外，我还会总结一下你在不同程序之间使用RE可能发现的区别。 当然，你也可以在Visual C++编辑器中使用RE。选择Edit->Replace，然后选择Regular expression选择框，Find What输入框对应上面介绍的vi命令:%s/pat1/pat2/g中的pat1部分，而Replace输入框对应pat2部分。但是，为了得到vi的执行范围和g选项，你要使用Replace All或者适当的手工Find Next and Replace（译者按：知道为啥有人骂微软弱智了吧，虽然VC中可以选中一个范围的文本，然后在其中执行替换，但是总之不够vi那么灵活和典雅）。 sed Sed是Stream EDitor的缩写，是Unix下常用的基于文件和管道的编辑工具，可以在手册中得到关于sed的详细信息。 这里是一些有趣的sed脚本，假定我们正在处理一个叫做price.txt的文件。注意这些编辑并不会改变源文件，sed只是处理源文件的每一行并把结果显示在标准输出中（当然很容易使用重定向来定制）： sed脚本描述 sed s/^$/d price.txt删除所有空行 sed s/^[ \t]*$/d price.txt删除所有只包含空格或者制表符的行 sed s///g price.txt删除所有引号 awk awk是一种编程语言，可以用来对文本数据进行复杂的分析和处理。可以在手册中得到关于awk的详细信息。这个古怪的名字是它作者们的姓的缩写（Aho，Weinberger和Kernighan）。 在Aho，Weinberger和Kernighan的书The AWK Programming Language中有很多很好的awk的例子，请不要让下面这些微不足道的脚本例子限制你对awk强大能力的理解。我们同样假定我们针对price.txt文件进行处理，跟sed一样，awk也只是把结果显示在终端上。 awk脚本描述 awk $0 !~ /^$/ price.txt删除所有空行 awk NF > 0 price.txt awk中一个更好的删除所有行的办法 awk $2 ~ /^[JT]/ {print $3} price.txt打印所有第二个字段是J或者T打头的行中的第三个字段 awk $2 !~ /[Mm]isc/ {print $3 + $4} price.txt针对所有第二个字段不包含Misc或者misc的行，打印第3和第4列的和（假定为数字） awk $3 !~ /^[0-9]+\.[0-9]*$/ {print $0} price.txt打印所有第三个字段不是数字的行，这里数字是指d.d或者d这样的形式，其中d是0到9的任何数字 awk $2 ~ /John|Fred/ {print $0} price.txt如果第二个字段包含John或者Fred则打印整行 grep grep是一个用来在一个或者多个文件或者输入流中使用RE进行查找的程序。它的name编程语言可以用来针对文件和管道进行处理。可以在手册中得到关于grep的完整信息。这个同样古怪的名字来源于vi的一个命令，g/re/p，意思是global regular expression print。 下面的例子中我们假定在文件phone.txt中包含以下的文本，——其格式是姓加一个逗号，然后是名，然后是一个制表符，然后是电话号码： Francis, John 5-3871 Wong, Fred 4-4123 Jones, Thomas 1-4122 Salazar, Richard 5-2522 grep命令描述 grep \t5-...1 phone.txt把所有电话号码以5开头以1结束的行打印出来，注意制表符是用\t表示的 grep ^S[^ ]* R phone.txt打印所有姓以S打头和名以R打头的行 grep ^[JW] phone.txt打印所有姓开头是J或者W的行 grep , ....\t phone.txt打印所有姓是4个字符的行，注意制表符是用\t表示的 grep -v ^[JW] phone.txt打印所有不以J或者W开头的行 grep ^[M-Z] phone.txt打印所有姓的开头是M到Z之间任一字符的行 grep ^[M-Z].*[12] phone.txt打印所有姓的开头是M到Z之间任一字符，并且点号号码结尾是1或者2的行 egrep egrep是grep的一个扩展版本，它在它的正则表达式中支持更多的元字符。下面的例子中我们假定在文件phone.txt中包含以下的文本，——其格式是姓加一个逗号，然后是名，然后是一个制表符，然后是电话号码： Francis, John 5-3871 Wong, Fred 4-4123 Jones, Thomas 1-4122 Salazar, Richard 5-2522 egrep command Description egrep (John|Fred) phone.txt打印所有包含名字John或者Fred的行 egrep John|22$|^W phone.txt打印所有包含John或者以22结束或者以W的行 egrep net(work)?s report.txt从report.txt中找到所有包含networks或者nets的行 正则表达式语法支持情况 命令或环境. [ ] ^ $ \( \) \{ \} ? + | ( ) vi X X X X X Visual C++ X X X X X awk X X X X X X X X sed X X X X X X Tcl X X X X X X X X X ex X X X X X X grep X X X X X X egrep X X X X X X X X X fgrep X X X X X perl X X X X X X X X X vi替换命令简介 Vi的替换命令： :ranges/pat1/pat2/g 其中 :这是Vi的命令执行界面。 range是命令执行范围的指定，可以使用百分号（%）表示所有行，使用点（.）表示当前行，使用美元符号（$）表示最后一行。你还可以使用行号，例如10,20表示第10到20行，.,$表示当前行到最后一行，.+2,$-5表示当前行后两行直到全文的倒数第五行，等等。 s表示其后是一个替换命令。 pat1这是要查找的一个正则表达式，这篇文章中有一大堆例子。 pat2这是希望把匹配串变成的模式的正则表达式，这篇文章中有一大堆例子。 g可选标志，带这个标志表示替换将针对行中每个匹配的串进行，否则则只替换行中第一个匹配串。 网上有很多vi的在线手册，你可以访问他们以获得更加完整的信息。 |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
