Delphi 正则表达式起步
在 Delphi 中使用正则表达式, 目前 PerlRegEx 应该是首选, 准备彻底而细致地研究它.
官方网站: http://www.regular-expressions.info/delphi.html
直接下载: http://www.regular-expressions.info/download/TPerlRegEx.zip
3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414
安装方法:
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;
2008-2-24 13:25:14 Delphi 正则表达式语法(1): 关于大小写与中文
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
2008-2-24 13:26:03 Delphi 正则表达式语法(2): 或者与重复
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,} 和 * 是等效的
2008-2-24 13:26:37 Delphi 正则表达式语法(3): 匹配范围
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;
2008-2-24 13:27:07 Delphi 正则表达式语法(4): 常用转义字符与 .
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;
2008-2-24 13:27:39 Delphi 正则表达式语法(5): 边界
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 区分
2008-2-24 13:29:21 Delphi 正则表达式语法(6): 贪婪匹配与非贪婪匹配
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 个或多个
2008-2-24 13:32:17 Delphi 正则表达式语法(7): 匹配转义字符
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 次或任意次 /*
| 或 /|
/ 转义符号本身 //
2008-2-24 13:32:50 Delphi 正则表达式语法(8): 引用子表达式 - 也叫反向引用
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 类的方法时, 关于对 (子表达式) 的引用还有更多话题.
2008-2-24 13:33:28 Delphi 正则表达式语法(9): 临界匹配 - 也叫"预搜索"与"反向预搜索"
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;
2008-2-24 13:34:11 Delphi 正则表达式语法(10): 选项
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];
2008-2-24 13:35:02 Delphi 正则表达式之TPerlRegEx 类的属性与方法(1): 查找
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;
2008-2-24 13:35:38 Delphi 正则表达式之TPerlRegEx 类的属性与方法(2): 关于子表达式
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 的内置常数.
2008-2-24 13:36:07 Delphi 正则表达式之TPerlRegEx 类的属性与方法(3): Start、Stop
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;
2008-2-24 13:36:30 Delphi 正则表达式之TPerlRegEx 类的属性与方法(4): Replace
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 的值, 当然是不能赋值的, 它仅仅是返回值.
}
2008-2-24 13:37:08 Delphi 正则表达式之TPerlRegEx 类的属性与方法(5): Compile、Study
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;
{
编译表达式, 会加快执行速度、降低启动速度;
如果表达式比较复杂而又多次执行, 应该先编译;
编译内容包括表达式选项.
}
2008-2-24 13:37:28 Delphi 正则表达式之TPerlRegEx 类的属性与方法(6): EscapeRegExChars 函数
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;
2008-2-24 13:37:50 Delphi 正则表达式之TPerlRegEx 类的属性与方法(7): Split 函数
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;