Delphi 正则表达式语法

作者:webfly 日期:2008-02-12

字体大小: 小中大

Delphi 正则表达式起步

在 Delphi 中使用正则表达式, 目前 PerlRegEx 应该是首选, 准备彻底而细致地研究它.

官方网站: http://www.regular-expressions.info/delphi.html
直接下载: http://www.regular-expressions.info/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 正则表达式之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;

[本日志由 webfly 于 2008-02-12 07:25 PM 编辑]

文章来自: 本站转贴

引用通告: 查看所有引用 | 我要引用此文章

Tags: delphi 正则表达式

相关日志:

评论: 0 | 引用: 0 | 查看次数: -

发表评论

昵　称:
密　码:	游客发言不需要密码.
内　容:	正在加载编辑器...
验证码:
选　项:	禁止表情转换禁止自动转换链接禁止自动转换关键字记住我的信息,以便下次评论时不用输入用户名.

虽然发表评论不用注册，但是为了保护您的发言权，建议您注册帐号.