Delphi 正则表达式起步

最新推荐文章于 2014-01-19 16:18:05 发布

踏雪无痕

最新推荐文章于 2014-01-19 16:18:05 发布

阅读量949

点赞数

分类专栏： Delphi正则表达式

Delphi正则表达式专栏收录该内容

8 篇文章 0 订阅

订阅专栏

在 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); //或 reg.Free
end;

//查找是否存在
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;
//替换一般字符串
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;
  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;
begin
  reg := TPerlRegEx.Create(nil);  reg.Subject := 'CodeGear Delphi 2007 for Win32';
  reg.RegEx   := 'Delphi';  while reg.MatchAgain do  //很明显: 本例只能找到一个结果
  begin
    ShowMessage(reg.MatchedExpression); //找到的字符串: Delphi
    ShowMessage(IntToStr(reg.MatchedExpressionOffset)); //它所在的位置: 10
    ShowMessage(IntToStr(reg.MatchedExpressionLength)); //它的长度: 6
  end;  FreeAndNil(reg);
end;
// Matchedexpression_r 与Subexpression_rs[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_r); //Delphi; 这是匹配到的内容
   ShowMessage(reg.Subexpression_rs[0]); //Delphi; 也可以这样显示匹配到的内容
end;
{
Subexpression_rs 是一个数组:
Subexpression_rs[1] 储存第 1 个表达式匹配的内容;
Subexpression_rs[2] 储存第 2 个表达式匹配的内容;
Subexpression_rs[n] 储存第 n 个表达式匹配的内容;

Subexpression_rs[0] 储存整个表达式匹配的内容;

Matchedexpression_r 表示的不过是 Subexpression_rs[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.Subexpression_rs[0]); //将分别显示: A1111 BB222 CCC33DDDD4
   ShowMessage(reg.Subexpression_rs[1]); //将分别显示: A BB CCC DDDD
   ShowMessage(reg.Subexpression_rs[2]); //将分别显示: 1111 222 33 4

   {另外:
     reg.Subexpression_rCount     是子表达式的个数;
     reg.Subexpression_rLengths[n] 是第 n 个表达式返回的字符串的长度;
     reg.Subexpression_rOffsets[n] 是第 n 个表达式返回的字符串在源字符串中的位置
    }
end;

FreeAndNil(reg);
end;

//子表达式不能超过 MAX_SUBexpression_rS = 99 个, MAX_SUBexpression_rS 是TPerlRegEx 的内置常数.

//设定搜索范围: 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;

// 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 的值, 当然是不能赋值的, 它仅仅是返回值.
}

// 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;

{
编译表达式, 会加快执行速度、降低启动速度;
如果表达式比较复杂而又多次执行, 应该先编译;
编译内容包括表达式选项.
}

// 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;

//字符串分割: 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;

 

 
 
  
  
   
   
    
    [delphi] 
    
    view plain
    
    copy
    
    
   
   
  
  
  
  procedure TForm1.FormCreate(Sender: TObject);  
var  
  reg: TPerlRegEx;                      //声明正则表达式变量  
begin  
  reg := TPerlRegEx.Create(nil);        //建立  
  
  reg.Subject := 'GoodBoy is You!';    //这是要替换的源字符串  
  reg.RegEx   := 'You';                //这是表达式, 在这里是准备替换掉的子串  
  reg.Replacement := 'Me';             //要替换成的新串  
  reg.ReplaceAll;                      //执行全部替换  
  
  ShowMessage(reg.Subject);           //返回替换结果: GoodBoy is Me  
  
  FreeAndNil(reg);                    //或 reg.Free  
end;  
 
 
 

 
 
  
  
   
   
    
    [delphi] 
    
    view plain
    
    copy
    
    
   
   
  
  
  
  //License Version 1.1  
//Delphi 7.0  
procedure TForm1.btn1Click(Sender: TObject);  
var  
  Reg : TPerlRegEx;  
begin  
  Reg := TPerlRegEx.Create(nil);  
  with Reg do  
  begin  
    Subject := '我爱DELPHI, 但Delphi不爱我--Delphi!';   //目标字符串  
    RegEx := 'Delphi';                                  //要替换的字符串  
    Replacement := '它';                                //替换后的字符串  
    Options := [preCaseLess];                           //不区分大小写  
    ReplaceAll;                                         //全部替换  
    ShowMessage(Subject);  
    FreeAndNil(Reg);  
  end;  
  //设置Options := [preCaseLess];中文也可以替换  
end; 
 
 
function zzth(s,z,t:string):string;//正则表达式替换匹配值并返回结果
var
reg: TPerlRegEx; //声明正则表达式变量
begin
reg := TPerlRegEx.Create(nil); //建立
reg.Subject := s; //这是要替换的源字符串
 reg.RegEx := z; //这是表达式, 在这里是准备替换掉的子串
 reg.Replacement := t; //要替换成的新串
 //reg.Options := [preCaseLess]; //不区分大小的设定, 默认是区分的
 reg.ReplaceAll; //执行全部替换
 result:=reg.Subject; //返回替换结果
FreeAndNil(reg); //因为建立时属主给了 nil, 这里没有使用 reg.Free
end;
//调用示例：
//第一个参数是原字符串，第二的参数是正则表达式，第三个参数是替换后的字符串
ShowMessage(zzth('Aa123aa','[A-Z]*','456')); //返回456123aa

function zzfh(s,z:string):string;//正则表达式返回匹配值
var
reg: TPerlRegEx;
begin
 reg := TPerlRegEx.Create(nil);
 reg.Subject := s;
 reg.RegEx := z;
 if reg.Match then
 begin
 result:=reg.MatchedExpression;
 end;
 FreeAndNil(reg);
end;
//调用示例：
//第一个参数是原字符串，第二的参数是正则表达式
ShowMessage(zzfh('Aa123aa','[A-Za-z]*'));//返回Aa

function zzfg(s,z:string):string;//字符串分割
var
 reg: TPerlRegEx;
 List: TStrings;
begin
 List := TStringList.Create;
 reg := TPerlRegEx.Create(nil);
 reg.Subject := s;
 reg.RegEx := z; {这里可是运行相当复杂的分割符啊}
 reg.Split(List,MaxInt);
 {第一个参数读入的是 Subject; 第二个参数是分成多少份}
 { 输入一个最大整数, 表示能分多少就分多少}
 result:=List.Text;
 FreeAndNil(reg);
 List.Free;
end;
//调用示例：
//第一个参数是原字符串，第二的参数是正则表达式
ShowMessage(zzfg('aaa,bbb.ccc|ddd','[|,.]'));
 {返回:
 aaa
 bbb
 ccc
 ddd
 }

踏雪无痕

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Delphi 正则表达式起步

在 Delphi 中使用正则表达式, 目前 PerlRegEx 应该是首选, 准备彻底而细致地研究它.官方网站: http://www.regular-expressions.info/delphi.html直接下载: http://www.regular-expressions.info/download/TPerlRegEx.zip安装方法:1、先把解压的
复制链接

扫一扫

专栏目录