分类： Delphi 2008-10-06 23:45 547人阅读 收藏 举报
首先介绍的是这个单元的主角：TRegExpr类，这个类包括很多成员，这里仅简单的介绍一下一般匹配的过程。下面是一段在文本中提取邮件地址的代码：
Procedure GetName(TextToCheck:String;aList:TStringList);
Var
myExpr: TRegExpr;
begin
myExpr := TRegExpr.Create;
Try
myExpr.Expression := 'name="(.*?)"';
if myExpr.Exec(TextToCheck) then
repeat
aList.Add(myExpr.Match[1]);
until not MyExpr.ExecNext;
finally
myExpr.Free;
end;
end;
下面对这段代码进行一点简要的说明．
首先是myExpr.Expression := 'name="(.*?)"';这个语句用以匹配name="XXXXX"形式的字符串。
“.*?”是很常见的一段，表示对任意字符串的“非贪婪匹配”，代表符合匹配条件的最短字符串，关于贪婪非贪婪的问题，会在后面说明。
括号表示对这段文字的引用，匹配中出现符合该模式的字符串将会存储在TRegExpr的Match数组中。
接下来是if myExpr.Exec(TextToChceck)这一句，这一语句就是开始利用上文提到的正则表达式对TextToCheck进行匹配。Exec方法有三个重载：
function Exec (const AInputString : AnsiString) : boolean; //对AInputString参数进行匹配
function Exec : boolean; overload; //对InputString成员进行匹配
function Exec (AOffset: integer) : boolean; overload; //对InputString成员，从AOffset位置开始进行匹配
该方法返回一个布尔型的值，如果为真，则表明InputString中包含表达式所匹配的模式，例如'Name="Hello.Gif"'作为参数，就会返回True。
接下来的语句中出现的myExpr.Match[1]，则用以取出本次匹配结果
最后的ExecNext其实是使用了上面提到的第三个重载，用来对重复出现的字符串进行连续匹配，返回结果的含义同Exec相同
接下来谈谈Match成员，其中Match[0]表示整个表达式的匹配结果，之后的数组元素则代表括号中的匹配结果，元素编号按照括号从左到右的顺序递增，嵌套括号则以从内向外的顺序递增。例如一个简单的对E-Mail地址的匹配：
Quotes From ???
输入字符串：'"dirt@sina.com","v@d2g.com"'
正则表达式：'"((.*?)@(.*?))",'
执行结果如下：
0 "dirt@sina.com",
1 dirt@sina.com
2 dirt
3 sina.com
从中即可看出Match数组中的结果排列顺序。
而上文中出现的.*?经常用于不很严谨的场合，例如前面用到的邮件地址提取，有人就写出几百字符的的验证表达式。其中“.”表示任意单个字符，“*”表示前面的字符（串）至少出现一次，而'?'在这里就是非贪婪限定符，举一个简单的例子："aaa""bbb"，这样一个字符串，如果用'"(.*?)"'进行匹配，则Match[1]的内容就是'aaa'，如果去掉了其中的'?'，则Match[1]就变成了'aaa""bbb'，这就可以看出贪婪和非贪婪的区别。
=================================================================================
TRegExpr是正则表达式在delphi中的一个很好的实现。
是一个单独的单元，使用时直接引用即可。还自带了几个sample。
对其中的SelfTest例子加了几行注释如下：
{ basic tests }
r := TRegExpr.Create;
r.Expression := '[A-Z]';
r.Exec ('234578923457823659GHJK38');
Check (0, 19, 1);
//?在此处表示让*处于非贪婪模式
r.Expression := '[A-Z]*?';
r.Exec ('234578923457823659ARTZU38');
Check (0, 1, 0);
r.Expression := '[A-Z]+';
r.Exec ('234578923457823659ARTZU38');
Check (0, 19, 5);
//和上面的+方式,功能一样
r.Expression := '[A-Z][A-Z]*';
r.Exec ('234578923457823659ARTZU38');
Check (0, 19, 5);
//?这里表示匹配[A-Z]0次或者一次
r.Expression := '[A-Z][A-Z]?';
r.Exec ('234578923457823659ARTZU38');
Check (0, 19, 2);
// /d代表数字,^代表非,总得来说就是一个或者多个非数字字符
r.Expression := '[^/d]+';
r.Exec ('234578923457823659ARTZU38');
Check (0, 19, 5);
半小时精通正则表达式
作者:Web应用网 来源:Web应用网
跟我学正则表达式!
想必很多人都对正则表达式都头疼.今天,我以我的认识,加上网上一些文章,希望用常人都可以理解的表达方式.来和大家分享学习经验.
开篇,还是得说说 ^ 和 $ 他们是分别用来匹配字符串的开始和结束，以下分别举例说明
"^The": 开头一定要有"The"字符串;
"of despair$": 结尾一定要有"of despair" 的字符串;
那么,
"^abc$": 就是要求以abc开头和以abc结尾的字符串，实际上是只有abc匹配
"notice": 匹配包含notice的字符串
你可以看见如果你没有用我们提到的两个字符（最后一个例子），就是说 模式（正则表达式） 可以出现在被检验字符串的任何地方，你没有把他锁定到两边
接着,说说 '*', '+',和 '?',
他们用来表示一个字符可以出现的次数或者顺序. 他们分别表示：
"zero or more"相当于{0,},
"one or more"相当于{1,},
"zero or one."相当于{0,1}, 这里是一些例子:
"ab*": 和ab{0,}同义,匹配以a开头,后面可以接0个或者N个b组成的字符串("a", "ab", "abbb", 等);
"ab+": 和ab{1,}同义,同上条一样，但最少要有一个b存在 ("ab", "abbb", 等.);
"ab?":和ab{0,1}同义,可以没有或者只有一个b;
"a?b+$": 匹配以一个或者0个a再加上一个以上的b结尾的字符串.
要点, '*', '+',和 '?'只管它前面那个字符.
你也可以在大括号里面限制字符出现的个数，比如
"ab{2}": 要求a后面一定要跟两个b（一个也不能少）("abb");
"ab{2,}": 要求a后面一定要有两个或者两个以上b(如"abb", "abbbb", 等.);
"ab{3,5}": 要求a后面可以有2－5个b("abbb", "abbbb", or "abbbbb").
现在我们把一定几个字符放到小括号里，比如：
"a(bc)*": 匹配 a 后面跟0个或者一个"bc";
"a(bc){1,5}": 一个到5个 "bc."
还有一个字符 '│', 相当于OR 操作:
"hi│hello": 匹配含有"hi" 或者 "hello" 的 字符串;
"(b│cd)ef": 匹配含有 "bef" 或者 "cdef"的字符串;
"(a│b)*c": 匹配含有这样多个（包括0个）a或b，后面跟一个c
的字符串;
一个点('.')可以代表所有的单一字符,不包括"/n"
如果,要匹配包括"/n"在内的所有单个字符,怎么办?
对了,用'[/n.]'这种模式.
"a.[0-9]": 一个a加一个字符再加一个0到9的数字
"^.{3}$": 三个任意字符结尾 .
中括号括住的内容只匹配一个单一的字符
"[ab]": 匹配单个的 a 或者 b ( 和 "a│b" 一样);
"[a-d]": 匹配'a' 到'd'的单个字符 (和"a│b│c│d" 还有 "[abcd]"效果一样); 一般我们都用[a-zA-Z]来指定字符为一个大小写英文
"^[a-zA-Z]": 匹配以大小写字母开头的字符串
"[0-9]%": 匹配含有 形如 x％ 的字符串
",[a-zA-Z0-9]$": 匹配以逗号再加一个数字或字母结尾的字符串
你也可以把你不想要得字符列在中括号里，你只需要在总括号里面使用'^' 作为开头 "%[^a-zA-Z]%" 匹配含有两个百分号里面有一个非字母的字符串.
要点:^用在中括号开头的时候,就表示排除括号里的字符
为了PHP能够解释，你必须在这些字符面前后加'',并且将一些字符转义.
不要忘记在中括号里面的字符是这条规路的例外—在中括号里面, 所有的特殊字符，包括(''), 都将失去他们的特殊性质 "[*/+?{}.]"匹配含有这些字符的字符串.
还有,正如regx的手册告诉我们: "如果列表里含有 ']', 最好把它作为列表里的第一个字符(可能跟在'^'后面). 如果含有'-', 最好把它放在最前面或者最后面, or 或者一个范围的第二个结束点[a-d-0-9]中间的‘-’将有效.
看了上面的例子,你对{n,m}应该理解了吧.要注意的是,n和m都不能为负整数,而且n总是小于m. 这样,才能 最少匹配n次且最多匹配m次. 如"p{1,5}"将匹配 "pvpppppp"中的前五个p
下面说说以/开头的
/b 书上说他是用来匹配一个单词边界,就是...比如've/b',可以匹配love里的ve而不匹配very里有ve
/B 正好和上面的/b相反.例子我就不举了
.....突然想起来....可以到http://www./article.php/251 看看其它用/ 开头的语法
好,我们来做个应用:
如何构建一个模式来匹配 货币数量 的输入
构建一个匹配模式去检查输入的信息是否为一个表示money的数字。我们认为一个表示money的数量有四种方式： "10000.00" 和 "10,000.00",或者没有小数部分, "10000" and "10,000". 现在让我们开始构建这个匹配模式:
^[1-9][0-9]*$
这是所变量必须以非0的数字开头.但这也意味着 单一的 "0" 也不能通过测试. 以下是解决的方法:
^(0│[1-9][0-9]*)$
"只有0和不以0开头的数字与之匹配"，我们也可以允许一个负号在数字之前:
^(0│-?[1-9][0-9]*)$
这就是: "0 或者 一个以0开头 且可能 有一个负号在前面的数字." 好了,现在让我们别那么严谨，允许以0开头.现在让我们放弃 负号 , 因为我们在表示钱币的时候并不需要用到. 我们现在指定 模式 用来匹配小数部分:
^[0-9]+(/.[0-9]+)?$
这暗示匹配的字符串必须最少以一个阿拉伯数字开头. 但是注意，在上面模式中 "10." 是不匹配的, 只有 "10" 和 "10.2" 才可以. （你知道为什么吗）
^[0-9]+(/.[0-9]{2})?$
我们上面指定小数点后面必须有两位小数.如果你认为这样太苛刻,你可以改成:
^[0-9]+(/.[0-9]{1,2})?$
这将允许小数点后面有一到两个字符. 现在我们加上用来增加可读性的逗号（每隔三位）, 我们可以这样表示:
^[0-9]{1,3}(,[0-9]{3})*(/.[0-9]{1,2})?$
不要忘记 '+' 可以被 '*' 替代 如果你想允许空白字符串被输入话 (为什么?). 也不要忘记反斜杆 ’/’ 在php字符串中可能会出现错误 (很普遍的错误).
现在，我们已经可以确认字符串了, 我们现在把所有逗号都去掉 str_replace(",", "", $money) 然后在把类型看成 double然后我们就可以通过他做数学计算了.
再来一个:
构造检查email的正则表达式
在一个完整的email地址中有三个部分:
1. 用户名 (在 '@' 左边的一切),
2.'@',
3. 服务器名(就是剩下那部分).
用户名可以含有大小写字母阿拉伯数字,句号 ('.'), 减号('-'), and 下划线 ('_'). 服务器名字也是符合这个规则,当然下划线除外.
现在, 用户名的开始和结束都不能是句点. 服务器也是这样. 还有你不能有两个连续的句点他们之间至少存在一个字符，好现在我们来看一下怎么为用户名写一个匹配模式:
^[_a-zA-Z0-9-]+$
现在还不能允许句号的存在. 我们把它加上:
^[_a-zA-Z0-9-]+(/.[_a-zA-Z0-9-]+)*$
上面的意思就是说: "以至少一个规范字符（除了.）开头,后面跟着0个或者多个以点开始的字符串."
简单化一点, 我们可以用 eregi()取代 ereg().eregi()对大小写不敏感, 我们就不需要指定两个范围 "a-z" 和 "A-Z" – 只需要指定一个就可以了:
^[_a-z0-9-]+(/.[_a-z0-9-]+)*$
后面的服务器名字也是一样,但要去掉下划线:
^[a-z0-9-]+(/.[a-z0-9-]+)*$
好. 现在只需要用”@”把两部分连接:
^[_a-z0-9-]+(/.[_a-z0-9-]+)*@[a-z0-9-]+(/.[a-z0-9-]+)*$
这就是完整的email认证匹配模式了,只需要调用
eregi(‘^[_a-z0-9-]+(/.[_a-z0-9-]+)*@[a-z0-9-]+(/.[a-z0-9-]+)*$ ’,$eamil)
就可以得到是否为email了
正则表达式的其他用法
提取字符串
ereg() and eregi() 有一个特性是允许用户通过正则表达式去提取字符串的一部分(具体用法你可以阅读手册). 比如说,我们想从 path/URL 提取文件名 – 下面的代码就是你需要:
ereg("([^///]*)$", $pathOrUrl, $regs);
echo $regs[1];
高级的代换
ereg_replace() 和 eregi_replace()也是非常有用的: 假如我们想把所有的间隔负号都替换成逗号:
ereg_replace("[ /n/r/t]+", ",", trim($str));
最后,我把另一串检查EMAIL的正则表达式让看文章的你来分析一下.
"^[-!#$%&/'*+//./0-9=?A-Z^_`a-z{|}~]+'.'@'.'[-!#$%&/'*+///0-9=?A-Z^_`a-z{|}~]+/.'.'[-!#$%&/'*+//./0-9=?A-Z^_`a-z{|}~]+$"
如果能方便的读懂,那这篇文章的目的就达到了.
JScript 和 VBScript 正则表达式 的语法规则
一个正则表达式就是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
这里有一些可能会遇到的正则表达式示例：
JScript VBScript 匹配
/^/[ /t]*$/ "^/[ /t]*$" 匹配一个空白行。
//d-/d/ "/d-/d" 验证一个ID 号码是否由一个2位数字，一个连字符以及一个5位数字组成。
/<(.*)>.*<//>/ "<(.*)>.*<//>" 匹配一个 HTML 标记。
下表是元字符及其在正则表达式上下文中的行为的一个完整列表：
字符 描述
/ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'/n' 匹配一个换行符。序列 '/' 匹配 "" 而 "/(" 则匹配 "("。
^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '/n' 或 '/r' 之后的位置。
$ 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '/n' 或 '/r' 之前的位置。
* 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于。
+ 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 。
匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 。
n 是一个非负整数。匹配确定的 n 次。例如，'o' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
n 是一个非负整数。至少匹配n 次。例如，'o' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o' 等价于 'o+'。'o' 则等价于 'o*'。
m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o" 将匹配 "fooooood" 中的前三个 o。'o' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
当该字符紧跟在任何一个其他限制符 (*, +, ?, , , ) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
. 匹配除 "/n" 之外的任何单个字符。要匹配包括 '/n' 在内的任何字符，请使用象 '[./n]' 的模式。
(pattern) 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 … 属性。要匹配圆括号字符，请使用 '/(' 或 '/)'。
(?: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 是一个正整数。对所获取的匹配的引用。例如，'(.)' 匹配两个连续的相同字符。
/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 匹配版权符号 (©)。
在 Delphi 中使用正则表达式, 目前 PerlRegEx 应该是首选, 准备彻底而细致地研究它.
官方网站: http://www./delphi.html
直接下载: http://www./download/TPerlRegEx.zip
安装方法:
1、先把解压的 TPerlRegEx 文件夹放一个合适的地方, 我放在了 Delphi 的 Imports 目录中.
2、目前最新 For Win32 的版本是对 Delphi 2006 的, 2007 也能用.
打开 PerlRegExD2006.dpk, 提示缺少资源文件, 没关系;
在 Project Manager 窗口中的 PerlRegExD2006.bpl 上点击右键, 执行 Install;
这时在 Tool Palette 的列表中已经有了 TPerlRegEx, 在 JGsoft 组.
3、Tools -> Options -> Environment Options -> Delphi Options -> Library-Win32 -> Library path ->
添加路径: .../Imports/TPerlRegEx
4、可以使用了! 直接 uses PerlRegEx 或从 Tool Palette 添加都可以.
如果不喜欢 Tool Palette 的添加方式可以省略第二步.
计划的学习步骤: 1、正则语法; 2、TPerlRegEx 功能.
--------------------------------------------------------------------------------
//准备用这段简单的代码测试语法:
uses
PerlRegEx; //uses 正则表达式单元
procedure TForm1.FormCreate(Sender: TObject);
var
reg: TPerlRegEx; //声明正则表达式变量
begin
reg := TPerlRegEx.Create(nil); //建立
reg.Subject := 'sSsS'; //这是要替换的源字符串
reg.RegEx := 's'; //这是表达式, 在这里是准备替换掉的子串
reg.Replacement := '◆'; //要替换成的新串
reg.ReplaceAll; //执行全部替换
ShowMessage(reg.Subject); //返回替换结果: ◆S◆S
FreeAndNil(reg); //因为建立时属主给了 nil, 这里没有使用 reg.Free
end;
Delphi 正则表达式语法(1): 关于大小写与中文
//替换一般字符串
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '我爱DELPHI, 但Delphi不爱我!';
reg.RegEx := 'Delphi';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: 我爱DELPHI, 但◆不爱我!
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//不区分大小写
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '我爱DELPHI, 但Delphi不爱我!';
reg.RegEx := 'Delphi';
reg.Replacement := '◆';
reg.Options := [preCaseLess]; //不区分大小的设定, 默认是区分的
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: 我爱◆, 但◆不爱我!
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//试试中文替换
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '我爱DELPHI, 但Delphi不爱我!';
reg.RegEx := '我';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆爱DELPHI, 但Delphi不爱◆!
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//如果不区分大小写, 竟然也不区分中文字了
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '我爱DELPHI, 但Delphi不爱我!';
reg.RegEx := '我';
reg.Replacement := '◆';
reg.Options := [preCaseLess]; //也设定不区分大小
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆◆DELPHI, ◆Delphi◆◆◆!
FreeAndNil(reg);
end;
//我测试了不同的汉字, 除了乱以外,没有规律; 所有如果操作汉字暂时不要指定 preCaseLess
Delphi 正则表达式语法(2): 或者与重复
// | 号的使用, | 是或者的意思
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007';
reg.RegEx := 'e|Delphi|0'; //使用了 | 记号
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: Cod◆G◆ar ◆ 2◆◆7
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// + 的使用, + 是重复 1 个或多个
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'a aa aaa aaaa ab abb abbba a呀a';
reg.RegEx := 'ab+'; //使用了 + 记号, 这里是允许 a 后面有 1 个或多个 b
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: a aa aaa aaaa ◆ ◆ ◆a a呀a
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// * 的使用, * 是重复 0 个或多个
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'a aa aaa aaaa ab abb abbba a呀a';
reg.RegEx := 'ab*'; //使用了 * 记号, 这里是允许 a 后面有多个或者没有 b
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ ◆◆ ◆◆◆ ◆◆◆◆ ◆ ◆ ◆◆ ◆呀◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// ? 的使用, ? 是重复 0 个或 1 个
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'a aa aaa aaaa ab abb abbba a呀a';
reg.RegEx := 'a?'; //使用了 ? 记号
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ ◆◆ ◆◆◆ ◆◆◆◆ ◆b ◆bb ◆bbb◆ ◆呀◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//大括号的使用<1>, 指定重复数
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'a aa aaa aaaa ab abb abbba a呀a';
reg.RegEx := 'a{3}'; //这里指定重复 3 次
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: a aa ◆ ◆a ab abb abbba a呀a
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//大括号的使用<2>
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'a aa aaa aaaa ab abb abbba a呀a';
reg.RegEx := 'a{2,4}'; //这里指定重复 2-4 次
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: a ◆ ◆ ◆ ab abb abbba a呀a
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//大括号的使用<3>
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'a aa aaa aaaa ab abb abbba a呀a';
reg.RegEx := 'a{1,}'; //n 个或多个, 这里是 1 个或多个
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ ◆ ◆ ◆ ◆b ◆bb ◆bbb◆ ◆呀◆
FreeAndNil(reg);
end;
//上面这个 {1,} 和 + 是等效的;
//还有 {0,1} 与 ? 是等效的;
//{0,} 和 * 是等效的
Delphi 正则表达式语法(3): 匹配范围
// [A-Z]: 匹配所有大写字母
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '[A-Z]';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ode◆ear ◆elphi 2007 for ◆in32
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// [a-z]: 匹配所有小写字母
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '[a-z]';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: C◆◆◆G◆◆◆ D◆◆◆◆◆ 2007 ◆◆◆ W◆◆32
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// [0-9]: 匹配所有数字
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '[0-9]';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: CodeGear Delphi ◆◆◆◆ for Win◆◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//匹配几个范围
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '[C-Do-p0-2]'; //大写字母: C-D; 小写字母: o-p; 数字: 0-2
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆◆deGear ◆el◆hi ◆◆◆7 f◆r Win3◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//匹配 [] 中的所有
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '[Ci2]'; //大写字母: C; 小写字母: i; 数字: 2
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆odeGear Delph◆ ◆007 for W◆n3◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// ^ 排除 [] 中的所有
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '[^Ci0-2]'; //这里排除了大写字母: C; 小写字母: i; 数字: 0-2
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: C◆◆◆◆◆◆◆◆◆◆◆◆◆i◆200◆◆◆◆◆◆◆i◆◆2
FreeAndNil(reg);
end;
Delphi 正则表达式语法(4): 常用转义字符与 .
// /d 匹配所有数字, 相当于 [0-9]
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '期待Delphi 2008 for Win32！';
reg.RegEx := '/d';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: 期待Delphi ◆◆◆◆ for Win◆◆！
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /D 匹配所有非数字, 相当于 [^0-9]
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '期待Delphi 2008 for Win32！';
reg.RegEx := '/D';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆◆◆◆◆◆◆◆◆◆◆2008◆◆◆◆◆◆◆◆32◆◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /w 匹配字母、数字与下划线_, 相当于 [A-Za-z0-9_]
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '期待Delphi 2008 for Win32！';
reg.RegEx := '/w';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: 期待◆◆◆◆◆◆ ◆◆◆◆ ◆◆◆ ◆◆◆◆◆！
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /W 匹配非字母、数字与下划线_, 相当于 [^A-Za-z0-9_]
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '期待Delphi 2008 for Win32！';
reg.RegEx := '/W';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: 期待◆◆◆◆◆◆ ◆◆◆◆ ◆◆◆ ◆◆◆◆◆！
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /s 匹配任何空白, 包括空格、制表、换页等, 相当于 [/f/n/r/t/v]
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '期待Delphi 2008 for Win32！';
reg.RegEx := '/s';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: 期待Delphi◆2008◆for◆Win32！
FreeAndNil(reg);
end;
{
/f : 换页符
/n : 换行符
/r : 回车符
/t : 制表符(Tab)
/v : 垂直制表符
}
--------------------------------------------------------------------------------
// /S 匹配任何非空白, 相当于 [^/f/n/r/t/v]
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '期待Delphi 2008 for Win32！';
reg.RegEx := '/S';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆◆◆◆◆◆◆◆◆◆ ◆◆◆◆ ◆◆◆ ◆◆◆◆◆◆◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /x 匹配十六进制的 ASCII
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi';
reg.RegEx := '/x61'; // a 的 ASCII 值是 97, 也就是十六进制的 61
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: CodeGe◆r Delphi
FreeAndNil(reg);
end;
//非常遗憾 TPerlRegEx 不能使用 /u 或 /U 匹配 Unicode 字符!
--------------------------------------------------------------------------------
// . 匹配除换行符以外的任何字符
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '期待' + #10 + 'Delphi 2008 for Win32！'; //#10是换行符
reg.RegEx := '.';
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject);
{返回:
◆◆◆◆
◆◆◆◆◆◆◆◆◆◆◆◆◆◆◆◆◆◆◆◆◆◆◆
}
FreeAndNil(reg);
end;
Delphi 正则表达式语法(5): 边界
// /b 单词边界
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi Delphi2007 MyDelphi';
reg.RegEx := '/bDelphi/b'; //前后边界
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ Delphi2007 MyDelphi
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /b 单词边界: 左边界
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi Delphi2007 MyDelphi';
reg.RegEx := '/bDelphi'; //左边界
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ ◆2007 MyDelphi
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /b 单词边界: 右边界
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi Delphi2007 MyDelphi';
reg.RegEx := 'Delphi/b'; //右边界
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ Delphi2007 My◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /B 非单词边界
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi MyDelphi2007 MyDelphi';
reg.RegEx := '/BDelphi/B'; //现在只有 MyDelphi2007 中的 Delphi 属于非单词边界
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: Delphi My◆2007 MyDelphi
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// ^ 行首
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi Delphi2007 MyDelphi';
reg.RegEx := '^Del'; //匹配在行首的 Del
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆phi Delphi2007 MyDelphi
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /A 也标记行首
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi Delphi2007 MyDelphi';
reg.RegEx := '/ADel'; //匹配在行首的 Del
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆phi Delphi2007 MyDelphi
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// $ 行尾
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi Delphi2007 MyDelphi';
reg.RegEx := 'phi$'; //匹配在行尾的 phi
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: Delphi Delphi2007 MyDel◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// /Z 也标记行尾
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi Delphi2007 MyDelphi';
reg.RegEx := 'phi/Z'; //匹配在行尾的 phi
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: Delphi Delphi2007 MyDel◆
FreeAndNil(reg);
end;
// 测试时, /Z 不区分大小写; /A 区分
Delphi 正则表达式语法(6): 贪婪匹配与非贪婪匹配
//贪婪匹配
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '<html><head><title>标题</title></head><body>内容</body></html>';
reg.RegEx := '<.*>'; //将会全部匹配, 因为两头分别是: < 和 >
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//非贪婪匹配
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '<html><head><title>标题</title></head><body>内容</body></html>';
reg.RegEx := '<.*?>'; // *? 是非贪婪匹配方法之一, 将匹配每组 <>
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆◆◆标题◆◆◆内容◆◆
FreeAndNil(reg);
end;
//更多贪婪与非贪婪匹配对照:
贪婪匹配 非贪婪匹配 描述
0 个或 1 个
+ +? 1 个或多个
* *? 0 个或多个
{n} {n}? n 个
{n,m} {n,m}? n - m 个
{n,} {n,}? n 个或多个
Delphi 正则表达式语法(7): 匹配转义字符
// ? 号的意义是匹配 0-1 次, 如果需要匹配 ? 怎么办
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '你好吗? 还行!';
reg.RegEx := '/?|!'; // 加转义用的 /
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: 你好吗◆ 还行◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//乱用转义符号 / 有时是可以的, 但有时会出问题, 最好不要乱用
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '你好吗? 还行!';
reg.RegEx := '/?|/!|/好'; // 给没必要的 "!" 与 "好" 加了 / 在本例中也正常了
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: 你◆吗◆ 还行◆
FreeAndNil(reg);
end;
{ 本来是有一个选项 [preExtra] 禁止乱用的, 但效果不好}
正则表达式中的特殊字符表:
特殊字符 在正则表达式中的意义 匹配字符本身
^ 匹配字符串的开始,或不匹配 [] 中的内容 /^
$ 匹配字符串的结尾 /$
( 和 ) 标记子表达式 /( 和 /)
[ 和 ] 匹配"多种字符" 的表达式 /[ 和 /]
{ 和 } 匹配次数的符号 /{ 和 /}
. 匹配除换行符以外的所有字符 /.
匹配 0 次或 1 次 /?
+ 匹配至少 1 次 /+
* 匹配 0 次或任意次 /*
| 或 /|
/ 转义符号本身 //
Delphi 正则表达式语法(8): 引用子表达式 - 也叫反向引用
//准备: 我们先写一个搜索所有英文单词的表达式
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'one two three four five six seven eight nine ten';
reg.RegEx := '/b[A-Za-z]+/b'; //这个表达式就可以找到所有的英文单词
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ ◆ ◆ ◆ ◆ ◆ ◆ ◆ ◆ ◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//假如我们只需要每个单词的第一个字母呢? 这要用到子表达式
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'one two three four five six seven eight nine ten';
reg.RegEx := '/b([A-Za-z])[A-Za-z]*/b'; //注意表达式中有子表达式, 在 () 中
reg.Replacement := '/1'; // /1 引用了第一个子表达式
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: o t t f f s s e n t
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//表达式中可以有多个子表达式
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'one two three ten';
reg.RegEx := '(t)(/w+)'; //这个表达式分别找出三个或四个字母的单词
reg.Replacement := '[/1-/2:/0]'; // /1/2 分别引用对应的子表达式; /0 引用整个表达式
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: one [t-wo:two] [t-hree:three] [t-en:ten]
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//在后面介绍 TPerlRegEx 类的方法时, 关于对 (子表达式) 的引用还有更多话题.
Delphi 正则表达式语法(9): 临界匹配 - 也叫"预搜索"与"反向预搜索"
//匹配右边
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi 6; Delphi 7; Delphi 2007; Delphi Net';
reg.RegEx := 'Delphi (?=2007)'; // ?=
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: Delphi 6; Delphi 7; ◆2007; Delphi Net
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//不匹配右边
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi 6; Delphi 7; Delphi 2007; Delphi Net';
reg.RegEx := 'Delphi (?!2007)'; // ?!
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆6; ◆7; Delphi 2007; ◆Net
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//匹配左边
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '111, 222, ￥333, ￥444';
reg.RegEx := '(?<=￥)/d{3}'; // ?<=
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: 111, 222, ￥◆, ￥◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//不匹配左边
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '111, 222, ￥333, ￥444';
reg.RegEx := '(?<!￥)/d{3}'; // ?<!
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆, ◆, ￥333, ￥444
FreeAndNil(reg);
end;
Delphi 正则表达式语法(10): 选项
// preCaseLess: 不区分大小写, 相当于其他语言中的 i
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'abc ABC aBc';
reg.RegEx := 'abc';
reg.Replacement := '◆';
reg.Options := [preCaseLess]; //选项是集合类型的
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ ◆ ◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// preAnchored: 只匹配字符串开始, 相当于 ^, 不过还是有区别的
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'abc abc abc';
reg.RegEx := 'abc';
reg.Replacement := '◆';
reg.Options := [preAnchored]; //指定: preAnchored
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆ abc abc
FreeAndNil(reg);
end;
{preAnchored 选项和 ^ 的区别:
1、任何情况下, preAnchored 只匹配字符串开头;
2、在 preMultiLine 选项模式下, ^ 还能匹配每行的开头;
3、^ 还有其他用途.
}
--------------------------------------------------------------------------------
// preDollarEndOnly: 让 $ 只匹配字符串结尾
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'abc abc abc'#13#10 +
'abc abc abc'#13#10 +
'abc abc abc';
reg.RegEx := 'abc$'; //当然需要有 $
reg.Replacement := '◆';
reg.Options := [preDollarEndOnly]; //指定: preDollarEndOnly
reg.ReplaceAll;
ShowMessage(reg.Subject);
{返回:
abc abc abc
abc abc abc
abc abc ◆
}
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// preMultiLine: 多行匹配, 相当于其他语言中的 m
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'abc abc abc'#13#10 +
'abc abc abc'#13#10 +
'abc abc abc';
reg.RegEx := '^abc';
reg.Replacement := '◆';
reg.Options := [preMultiLine]; //指定: preMultiLine
reg.ReplaceAll;
ShowMessage(reg.Subject);
{返回:
◆ abc abc
◆ abc abc
◆ abc abc
}
{如果不指定 preMultiLine 将返回:
◆ abc abc
abc abc abc
abc abc abc
}
FreeAndNil(reg);
end;
{
1、preMultiLine 是对 ^ 和 $ 的扩展使用;
2、在指定了 [preAnchored] 或 [preDollarEndOnly] 的情况下无效.
}
--------------------------------------------------------------------------------
// preSingleLine: 让特殊符号 . 能够匹配换行符 (. 的本意是匹配换行符以外的任意字符)
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'aaa;bbb;'#13#10 +
'111;222;'#13#10 +
'AAA;BBB;';
reg.RegEx := ';.';
reg.Replacement := '◆';
reg.Options := [preSingleLine]; //指定: preSingleLine
reg.ReplaceAll;
ShowMessage(reg.Subject);
{返回:
aaa◆bb◆
111◆22◆
AAA◆BB;
}
{如果不指定 preMultiLine 将返回:
aaa◆bb;
111◆22;
AAA◆BB;
}
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// preUnGreedy: 指定为非贪婪模式
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := '《Delphi》and《C++Builder》';
reg.RegEx := '《.*》';
reg.Replacement := '◆';
reg.Options := [preUnGreedy]; //指定: preUnGreedy
{ 在本例中, reg.RegEx := '《.*?》'; 可以达到同样的效果}
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆and◆ ; 如果不指定 preUnGreedy, 将返回: ◆
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
// preExtended: 指定为扩展模式
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'Delphi C++Builder';
reg.RegEx := 'i/x20C'; // /x20 是用十六进制的方式表示的空格
reg.Replacement := '◆';
reg.Options := [preExtended]; //指定: preExtended
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: Delph◆++Builder
FreeAndNil(reg);
end;
{preExtended 是最复杂的一个选项:
1、它会忽略表达式中的空白, 譬如: 本例中的表达式如果是 'i C' 将不会匹配成功;
2、空白要用相应的十六进制表示, 譬如用 /x20 表示空格;
3、把表达式中从 # 到行尾的部分当作注释而被忽略;
4、如果要使用 # ,需要用 /# 代替;
5、表达式的标准注释是: (?#...) 及其中 # 后面的内容均为注释, 不管指定 preExtended 与否
}
--------------------------------------------------------------------------------
关于选项 preExtra:
如果表达式中需要特殊字符 ^ $ ( ) [ ] { } . ? + * | / 时, 需要加转义符号 / ;
默认状态下, 其他字符前面添加了 / 会识别为字符本身;
preExtra 选项应该就是禁止这种情况的, 也就是不要在非特殊字符前加 / ;
但测试效果 ... 也许是我没弄明白!
还有三个状态选项: preNotBOL, preNotEOL, preNotEmpty
reg.State := [preNotBOL] 是让标记开始的 ^ 无效;
reg.State := [preNotEOL] 是让标记结尾的 $ 无效;
reg.State := [preNotEmpty] 没弄明白!
另外这些选择是可以组合使用的, 譬如:
reg.Options := [preCaseLess, preMultiLine, preSingleLine];
reg.State := [preNotBOL, preNotEOL];
Delphi 正则表达式之TPerlRegEx 类的属性与方法(1): 查找
//查找是否存在
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '/d';
if reg.Match then
ShowMessage('找到了')
else
ShowMessage('没找到');
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//查找是否存在(方法2)
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '/d';
reg.Match; //执行查找
if reg.FoundMatch then //布尔变量 FoundMatch 会告诉我们查找有没有结果
ShowMessage('找到了')
else
ShowMessage('没找到');
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//显示找到的第一个
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '/d';
if reg.Match then
ShowMessage(reg.MatchedExpression) //2
else
ShowMessage('没找到');
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//分别显示找到的每一个和总数
var
reg: TPerlRegEx;
num: Integer; //用 num 来计数
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '/d';
num := 0;
while reg.MatchAgain do //MatchAgain 是下一个
begin
ShowMessage(reg.MatchedExpression); //将分别显示: 2 0 0 7 3 2
Inc(num);
end;
ShowMessage(IntToStr(num)); //6
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//分别显示找到的每一个和总数(另一种写法)
var
reg: TPerlRegEx;
num: Integer; //用 num 来计数
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := '/d';
num := 0;
if reg.Match then
begin
repeat
ShowMessage(reg.MatchedExpression); //将分别显示: 2 0 0 7 3 2
Inc(num);
until (not reg.MatchAgain);
end;
ShowMessage(IntToStr(num)); //6
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//目标字符串的位置与长度
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007 for Win32';
reg.RegEx := 'Delphi';
while reg.MatchAgain do //很明显: 本例只能找到一个结果
begin
ShowMessage(reg.MatchedExpression); //找到的字符串: 2007
ShowMessage(IntToStr(reg.MatchedExpressionOffset)); //它所在的位置: 10
ShowMessage(IntToStr(reg.MatchedExpressionLength)); //它的长度: 6
end;
FreeAndNil(reg);
end;
Delphi 正则表达式之TPerlRegEx 类的属性与方法(2): 关于子表达式
// MatchedExpression 与 SubExpressions[0]
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'CodeGear Delphi 2007';
reg.RegEx := 'Delphi';
while reg.MatchAgain do
begin
ShowMessage(reg.MatchedExpression); //Delphi; 这是匹配到的内容
ShowMessage(reg.SubExpressions[0]); //Delphi; 也可以这样显示匹配到的内容
end;
{
SubExpressions 是一个数组:
SubExpressions[1] 储存第 1 个表达式匹配的内容;
SubExpressions[2] 储存第 2 个表达式匹配的内容;
SubExpressions[n] 储存第 n 个表达式匹配的内容;
SubExpressions[0] 储存整个表达式匹配的内容;
MatchedExpression 表示的不过是 SubExpressions[0].
}
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//提取子表达式匹配到的内容
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'abc A1111 BB222 CCC33 DDDD4';
reg.RegEx := '/b([A-D]+)([1-4]+)/b'; //这个表达式有两个子表达式构成
while reg.MatchAgain do
begin
ShowMessage(reg.SubExpressions[0]); //将分别显示: A1111 BB222 CCC33 DDDD4
ShowMessage(reg.SubExpressions[1]); //将分别显示: A BB CCC DDDD
ShowMessage(reg.SubExpressions[2]); //将分别显示: 1111 222 33 4
{另外:
reg.SubExpressionCount 是子表达式的个数;
reg.SubExpressionLengths[n] 是第 n 个表达式返回的字符串的长度;
reg.SubExpressionOffsets[n] 是第 n 个表达式返回的字符串在源字符串中的位置
}
end;
FreeAndNil(reg);
end;
--------------------------------------------------------------------------------
//子表达式不能超过 MAX_SUBEXPRESSIONS = 99 个, MAX_SUBEXPRESSIONS 是 TPerlRegEx 的内置常数.
Delphi 正则表达式之TPerlRegEx 类的属性与方法(3): Start、Stop
//设定搜索范围: Start、Stop
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'ababab';
reg.RegEx := 'ab';
reg.Replacement := '◆';
reg.Start := 1;
reg.Stop := 2;
while reg.MatchAgain do
begin
reg.Replace;
end;
ShowMessage(reg.Subject); //返回: ◆abab
reg.Subject := 'ababab';
reg.Start := 3;
reg.Stop := 4;
while reg.MatchAgain do
begin
reg.Replace;
end;
ShowMessage(reg.Subject); //返回: ab◆ab
reg.Subject := 'ababab';
reg.Start := 5;
reg.Stop := 6;
while reg.MatchAgain do
begin
reg.Replace;
end;
ShowMessage(reg.Subject); //返回: abab◆
FreeAndNil(reg);
end;
Delphi 正则表达式之TPerlRegEx 类的属性与方法(4): Replace
// Replace
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.RegEx := 'ab';
reg.Replacement := '◆';
reg.Subject := 'ababab';
reg.ReplaceAll;
ShowMessage(reg.Subject); //返回: ◆◆◆
reg.Subject := 'ababab';
//下面四行程序, 相当于 reg.ReplaceAll;
while reg.MatchAgain do
begin
reg.Replace;
end;
ShowMessage(reg.Subject); //返回: ◆◆◆
FreeAndNil(reg);
end;
{
ReplaceAll 函数返回的是 Boolean;
Replace 函数返回的是 Replacement 的值, 当然是不能赋值的, 它仅仅是返回值.
}
Delphi 正则表达式之TPerlRegEx 类的属性与方法(5): Compile、Study
// Compile、Study
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.RegEx := 'ab';
reg.Options := [preCaseLess];
reg.Compile; {编译表达式}
reg.Study; {Study 方法会检查是否编译, 如果没有编译则执行 Compile}
reg.Replacement := '◆';
reg.Subject := 'abAbaB';
reg.ReplaceAll;
ShowMessage(reg.Subject); {返回: ◆◆◆}
FreeAndNil(reg);
end;
{
编译表达式, 会加快执行速度、降低启动速度;
如果表达式比较复杂而又多次执行, 应该先编译;
编译内容包括表达式选项.
}
Delphi 正则表达式之TPerlRegEx 类的属性与方法(6): EscapeRegExChars 函数
// EscapeRegExChars 函数可以自动为特殊字符加转义符号 /
var
reg: TPerlRegEx;
begin
reg := TPerlRegEx.Create(nil);
reg.Subject := 'C++Builer';
reg.RegEx := reg.EscapeRegExChars('C+') + '{2}'; {相当于 'C/+{2}'}
reg.Replacement := '◆';
reg.ReplaceAll;
ShowMessage(reg.Subject); {返回: ◆Builer}
FreeAndNil(reg);
end;
Delphi 正则表达式之TPerlRegEx 类的属性与方法(7): Split 函数
//字符串分割: Split
var
reg: TPerlRegEx;
List: TStrings;
begin
List := TStringList.Create;
reg := TPerlRegEx.Create(nil);
reg.Subject := 'aaa,bbb,ccc,ddd';
reg.RegEx := ','; {这里可是运行相当复杂的分割符啊}
reg.Split(List,MaxInt); {第一个参数读入的是 Subject; 第二个参数是分成多少份}
{ 输入一个最大整数, 表示能分多少就分多少}
ShowMessage(List.Text);
{返回:
aaa
bbb
ccc
ddd
}
FreeAndNil(reg);
List.Free;
end;
