delphi正则表达式验证操作

更新时间：2024-04-11 00:50:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

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 的添加方式可以省略第二步.

三、使用方法

PerlRegEx提供了TPerlRegEx类。主要用法是： RegEx : TPerlRegEx; ....

RegEx := TPerlRegEx; try

RegEx.Subject := '要匹配的正文'; RegEx.RegEx := '正则表达式'; if RegEx.Match then .... finally

RegEx.free end;

如果要多次匹配并做一些处理，可以: Matched : boolean; ....

RegEx.Match;

while RegEx.FoundMatch do begin ....

RegEx.MatchAgain; end;

如果要替换匹配到的内容，可以

RegEx.Subject := '要匹配的正文'; RegEx.RegEx := '正则表达式'; RegEx.Replace := '替换的字符串'

if RegEx.Match then RegEx.ReplaceAll; //结果在RegEx.subject 或者 if RegEx.Match then Result := RegEx.Replacement;

匹配到的字符串放在RegEx.MatchedExpression中，长度在RegEx.MatchedExpressionLength中，上一次匹配的结束位置在RegEx.Stop中匹配到的子串放在RegEx.SubExpressions中，子串个数在RegEx.SubExpressionCount中。

如果正则式很复杂而且常用，可创建一个生存期相对长的TPerlRegEx实例．设置好RegEx属性后，使用.Study方法对正则表达式进行预处理．据帮助文档说，文档资料会大大提高效率．

详情可参考文档。有一点文档上没有提到（又或者我看漏了），在第一次匹配之后，如果没有重新赋值subject，下一次匹配无论用Match或者MatchAgain，都是从上次的结束位置开始。所以如果要重新开始匹配，应先把RegEx.Start := 0;

四、正则单元

程序代码

unit UnitRegEx;

interface uses

PerlRegEx;

function CheckEmail(EmailAddr: string): Boolean; function CheckStrOrNumber(Str: string): Boolean; var

PerlRegEx: TPerlRegEx;

implementation

//Email电子邮箱检测

function CheckEmail(EmailAddr: string): Boolean; begin

PerlRegEx := TPerlRegEx.Create(nil); PerlRegEx.Subject := EmailAddr;

PerlRegEx.RegEx := '\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*'; Result := PerlRegEx.Match; end;

//字符、数字检测

function CheckStrOrNumber(Str: string): Boolean; begin

PerlRegEx := TPerlRegEx.Create(nil); PerlRegEx.Subject := Str;

PerlRegEx.RegEx := '^[A-Za-z0-9]+$'; Result := PerlRegEx.Match; end; end.

五、使用实例

程序代码

procedure TFrmRegister.btnNextClick(Sender: TObject); begin try

if not CheckStrOrNumber(edtUser.Text) then begin

Application.MessageBox(PChar('请您正确输入用户名。'), '系统提示', 64);

edtUser.SetFocus; edtUser.SelText; Exit; end

else if not CheckEmail(edtEmail.Text) then begin

Application.MessageBox(PChar('请您正确输入常用的电子邮箱。'), '系统提示', 64);

edtEmail.SetFocus; edtEmail.SelText; Exit; end; except

on E: Exception do

Application.MessageBox(PChar(E.Message), '系统提示', 64) end; end;

六、常用正则表式

正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。

匹配中文字符的正则表达式： [\一-\龥]

评注：匹配中文还真是个头疼的事，有了这个表达式就好办了

匹配双字节字符(包括汉字在内)：[^\\x00-\\xff]

评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

匹配空白行的正则表达式：\\n\\s*\\r

评注：可以用来删除空白行

匹配HTML标记的正则表达式：<(\\S*?)[^>]*>.*?|<.*? />

评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力

匹配首尾空白字符的正则表达式：^\\s*|\\s*$

评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式

匹配Email地址的正则表达式：

\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*

评注：表单验证时很实用

匹配网址URL的正则表达式：[a-zA-z]+://[^\\s]*

评注：网上流传的版本功能很有限，上面这个基本可以满足需求

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$

评注：表单验证时很实用

匹配国内电话号码：\\d{3}-\\d{8}|\\d{4}-\\d{7}

评注：匹配形式如 0511-4405222 或 021-87888822

匹配腾讯QQ号：[1-9][0-9]{4,}

评注：腾讯QQ号从10000开始

匹配中国邮政编码：[1-9]\\d{5}(?!\\d)

评注：中国邮政编码为6位数字

匹配身份证：\\d{15}|\\d{18}

评注：中国的身份证为15位或18位

匹配ip地址：\\d+\\.\\d+\\.\\d+\\.\\d+

评注：提取ip地址时有用。

匹配特定数字：

^[1-9]\\d*$ //匹配正整数

^-[1-9]\\d*$ //匹配负整数

^-?[1-9]\\d*$ //匹配整数

^[1-9]\\d*|0$ //匹配非负整数（正整数 + 0）

^-[1-9]\\d*|0$ //匹配非正整数（负整数 + 0）

^[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*$ //匹配正浮点数

^-([1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*)$ //匹配负浮点数

^-?([1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*|0?\\.0+|0)$ //匹配浮点数

^[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*|0?\\.0+|0$ //匹配非负浮点数（正浮点数 + 0）

^(-([1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*))|0?\\.0+|0$ //匹配非正浮点数（负浮点数 + 0）

评注：处理大量数据时有用，具体应用时注意修正。

匹配特定字符串：

^[A-Za-z]+$ //匹配由26个英文字母组成的字符串

^[A-Z]+$ //匹配由26个英文字母的大写组成的字符串

^[a-z]+$ //匹配由26个英文字母的小写组成的字符串

^[A-Za-z0-9]+$ //匹配由数字和26个英文字母组成的字符串

^\\w+$ //匹配由数字、26个英文字母或者下划线组成的字符串

评注：最基本也是最常用的一些表达式。 -------------------------------------- 试验:删除http所有标签

var

reg: TPerlRegEx; str:string; begin

str:=memo1.Text; //有<>等内容 reg := TPerlRegEx.Create(nil); reg.Subject := memo1.Text; reg.RegEx := '\\<[^>]+()\\>';

while reg.MatchAgain do begin

str:=StringReplace(str,reg.SubExpressions[0],'',[rfReplaceAll]); //删除HTTP标签 end;

ShowMessage(str);

FreeAndNil(reg); end; 结果:正确!

日期时间判断正则表达式

这里是判断YYYY-MM-DD这种格式的

^((((1[6-9]|[2-9]\\d)\\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\\d|3[01]))|(((1[6-9]|[2-9]\\d)\\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\\d|30))|(((1[6-9]|[2-9]\\d)\\d{2})-0?2-(0?[1-9]|1\\d|2[0-8]))|(((1[6-9]|[2-9]\\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))$

下面的是加了时间验证的

‘((((1[6-9]|[2-9]\\d)\\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\\d|3[01]))|(((1[6-9]|[2-9]\\d)\\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\\d|30))|(((1[6-9]|[2-9]\\d)\\d{2})-0?2-(0?[1-9]|1\\d|2[0-8]))|(((1[6-9]|[2-9]\\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))

(20|21|22|23|[0-1]?\\d):[0-5]?\\d:[0-5]?\\d|((((1[6-9]|[2-9]\\d)\\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\\d|3[01]))|(((1[6-9]|[2-9]\\d)\\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\\d|30))|(((1[6-9]|[2-9]\\d)\\d{2})-0?2-(0?[1-9]|1\\d|2[0-8]))|(((1[6-9]|[2-9]\\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))’; 日期的正则表达式,YYYY-MM-DD YYYY/MM/DD YYYY.MM.DD

\:16|[2468][048]|[3579][26])00)))(\\/|-|\\.)(?:0?2\\1(?:29))$)|(?:(?:1[6-9]|[2-9]\\d)?\\d{2})(\\/|-|\\.)(?:(?:(?:0?[13578]|1[02])\\2(?:31))|(?:(?:0?[1,3-9]|1[0-2])\\2(29|30))|(?:(?:0?[1-9])|(?:1[0-2]))\\2(?:0?[1-9]|1\\d|2[0-8]))$\string regex

= @\)|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[4

69])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\ s]?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][1235679])|([1 3579][01345789]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?(( 0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?(( 0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|(1[0-9] )|(2[0-8]))))))\//日期部分 regex

+= @\)))))?$\//时间部分

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; //执行全部替换 ---www.bianceng.cn ShowMessage(reg.Subject); //返回替换结果: ◆S◆S FreeAndNil(reg); //或 reg.Free end;

Delphi中正则表达式语法(1) 关于大小写与中文时间:2012-12-20 万一

//替换一般字符串 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) 或者与重复时间:2012-12-20 万一

// | 号的使用, | 是或者的意思 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) 匹配范围时间:2012-12-20 万一

// [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) 常用转义字符与时间:2012-12-20 万一

// \\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); //返回: ◆◆◆◆Delphi◆2008◆for◆Win32◆◆

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] // www.bianceng.cn 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) 边界时间:2012-12-20 万一

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

// $ 行尾

// www.bianceng.cn 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) 贪婪匹配与非贪婪匹配

时间:2012-12-20 万一

//贪婪匹配 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;

//更多贪婪与非贪婪匹配对照: 贪婪匹配非贪婪匹配描述 ? ?? 0 个或 1 个 + +? 1 个或多个 * *? 0 个或多个 {n} {n}? n 个

{n,m} {n,m}? n - m 个 {n,} {n,}? n 个或多个

Delphi中正则表达式语法(7) 匹配转义字符时间:2012-12-20 万一

// ? 号的意义是匹配 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) 引用子表达式 - 也叫反向引用时间:2012-12-20 万一

//准备: 我们先写一个搜索所有英文单词的表达式 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;

//假如我们只需要每个单词的第一个字母呢? 这要用到子表达式 // www.bianceng.cn 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;

Delphi中正则表达式语法(9) 临界匹配 - 预搜索与反向预搜索时间:2012-12-20 万一

//匹配右边 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 := '(?

ShowMessage(reg.Subject); //返回: ◆, ◆, ￥333, ￥444 FreeAndNil(reg); end;

Delphi中正则表达式语法(10) 选项时间:2012-12-20 万一

// 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: 让特殊符号 . 能够匹配换行符 (. 的本意是匹配换行符以外的任意字符)

// www.bianceng.cn 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) 查找时间:2012-12-22 博客园万一

//查找是否存在 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;

//目标字符串的位置与长度这是我在D7中的测试结果

procedure TForm1.Button3Click(Sender: TObject); var

filenames,apath,arq,ayy,amm,add,atime: string; adate:Tdatetime; mylist:TStringlist; i,a,j:integer; reg: TPerlRegEx; begin

reg := TPerlRegEx.Create();

reg.Subject := '表达式的内容13568221705匹配12345的内容'; reg.RegEx := '\\d[0-9]+'; while reg.MatchAgain do

begin

Showmessage(reg.MatchedText);

ShowMessage(IntToStr(reg.MatchedOffset)); //它所在的位置: 10 ShowMessage(IntToStr(reg.MatchedLength)); //它的长度: 6 end;

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;

Delphi中正则表达式之TPerlRegEx类的属性与方法(2) 关于子表达式时间:2012-12-22 博客园万一

// 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 时间:2012-12-22 博客园万一

//设定搜索范围: 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 时间:2012-12-22 博客园万一

// 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 时间:2012-12-22 博客园万一

// 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函数

时间:2012-12-22 博客园万一

// 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函数时间:2012-12-22 博客园万一

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

TPerlRegEx delphi 下的正则表达式~~~nice~！

发布时间：2011-08-22 发布来源：

遗忘是一般刚强的，有发明力的人的宝贝，他们会像天然一样的遗忘，天然界就不知道有什么过失，弱者不是把疾苦作为惩前毖后的教训，反而在疾苦中讨生活生计，浸在里头，天天回顾以往的魔难，熬煎本身。DELPHi中的REGEXPR

其实这个Pascal单位我在几个论坛上方都推荐过，也是我独一会用的DELPHI下面的正则表达式实现。正则表达式是个极其繁琐和强大的器材，小生才疏学浅，也不筹办写正则表达式的教程，借着对这个单位的介绍，会有一些浅近且有效的例子。

起首介绍的是这个单位的主角：TRegExpr类，这个类包含很多成员，这里仅简单的介绍一下一般匹配的过程。下面是一段在文本中提取邮件地址的代码：

Procedure GetName（TextToCheck:String;aList:TStringList）; Var

myExpr: TRegExpr; begin

myExpr := TRegExpr.Create; Try

myExpr.Expression := \（.*？）\if myExpr.（TextToCheck） then repeat

aList.Add（myExpr.Match[1]）; until not MyExpr.Next; finally myExpr.Free; end; end;

下面对这段代码进行一点扼要的申明．

起首是myExpr.Expression := \（.*？）\这个语句用以匹配name=\情势的字符串。 ―.*？‖是很常见的一段，默示对随便率性字符串的―非贪婪匹配‖，代表合适匹配前提的最短字符串，关于贪婪非贪婪的题目，会在后面申明。

括号默示对这段文字的引用，匹配中呈现合适该模式的字符串将会存储在TRegExpr的Match数组中。接下来是if myExpr.（TextToChceck）这一句，这一语句就是开端哄骗上文提到的正则表达式对TextToCheck进行匹配。办法有三个重载：

function （const AInputString : AnsiString） : boolean; //对AInputString参数进行匹配 function : boolean; overload; //对InputString成员进行匹配

function （AOffset: integer） : boolean; overload; //对InputString成员，从AOffset地位开端进行匹配该办法返回一个布尔型的值，若是为真，则注解InputString中包含表达式所匹配的模式，例如\作为参数，就会返回True。

接下来的语句中呈现的myExpr.Match[1]，则用以取出本次匹配成果

最后的Next其实是应用了上方提到的第三个重载，用来对反复呈现的字符串进行连气儿匹配，返回成果的含义同雷同

接下来谈谈Match成员，此中Match[0]默示全部表达式的匹配成果，之后的数组元素则代表括号中的匹配成果，元素编号遵守括号从左到右的次序递增，嵌套括号则以从内向外的次序递增。例如一个简单的对E-Mail地址的匹配： Quotes From ？？？

输入字符串：\＠sina.com\，\＠d2g.com\正则表达式：\（（.*？）＠（.*？））\，\履行成果如下： 0 \＠sina.com\， 1 dirt＠sina.com 2 dirt 3 sina.com

从中即可看出Match数组中的成果分列次序。

而上文中呈现的.*？经常用于不很严谨的场合，例如前面用到的邮件地址提取，有人就写出几百字符的的验证表达式。此中―.‖默示随便率性单个字符，―*‖ 默示前面的字符（串）至少呈现一次，而\？\在这里就长短贪婪限制符，举一个简单的例子：\，如许一个字符串，若是用\（.*？）\进行匹配，则Match[1]的内容就是\，若是去掉了此中的\？\，则Match[1]就变成了\，这就可以看出贪婪和非贪婪的差别。

一个根蒂根基的匹配过程就到这里，有空会再持续写一些其他的相干内容，敬请丢砖

转自：http://www.delphibbs.com/keylife/iblog_show.asp？xid=13902 作者：coolbaby

TRegExpr是正则表达式在delphi中的一个很好的实现。

是一个零丁的单位，应用时直接引用即可。还自带了几个sample。

对此中的SelfTest例子加了几行注释如下： { basic tests }

r := TRegExpr.Create;

r.Expression := \

r. （\）; Check （0， 19， 1）;

//？在此处默示让*处于非贪婪模式 r.Expression := \？\

r. （\）; Check （0， 1， 0）;

r.Expression := \

r. （\）; Check （0， 19， 5）; //和上方的+体式格式，功能一样 r.Expression := \

r. （\）; Check （0， 19， 5）;

//？这里默示匹配[A-Z]0次或者一次 r.Expression := \？\

r. （\）; Check （0， 19， 2）;

// d代表数字，^代表非，总得来说就是一个或者多个非数字字符 r.Expression := \

r. （\）; Check （0， 19， 5）;

半小时精通正则表达式

作者:Web应用网起原:Web应用网

跟我学正则表达式!

想必很多人都对正则表达式都头疼.今天，我以我的熟悉，加上彀上一些文章，用常人都可以懂得的表达体式格式.来和大师分享进修经验.

开篇，还是得说说 ^ 和￥他们是分别用来匹配字符串的开端和停止，以下分别举例申明

\开首必然要有\字符串;

\￥\结尾必然要有\的字符串; 那么，

\￥\就是请求以abc开首和以abc结尾的字符串，实际上是只有abc匹配 \匹配包含notice的字符串

你可以看见若是你没有效我们提到的两个字符（最后一个例子），就是说模式（正则表达式）可以呈如今被查验字符串的任何处所，你没有把他锁定到两边接着，说说 \， \，和 \？\，

他们用来默示一个字符可以呈现的次数或者次序. 他们分别默示： \相当于{0，}， \相当于{1，}，

\相当于{0，1}，这里是一些例子:

\和ab{0，}同义，匹配以a开首，后面可以接0个或者N个b构成的字符串（\， \， \，等）;

\和ab{1，}同义，同上条一样，但起码要有一个b存在（\， \，等.）; \？\和ab{0，1}同义，可以没有或者只有一个b;

\？b+￥\匹配以一个或者0个a再加上一个以上的b结尾的字符串. 要点， \， \，和 \？\尽管它前面那个字符.

你也可以在大括号里面限制字符呈现的个数，比如

\请求a后面必然要跟两个b（一个也不克不及少）（\）;

\，}\请求a后面必然要有两个或者两个以上b（如\， \，等.）; \，5}\请求a后面可以有2－5个b（\， \， or \）.

如今我们把必然几个字符放到小括号里，比如： \（bc）*\匹配 a 后面跟0个或者一个\\（bc）{1，5}\一个到5个 \

还有一个字符 \，相当于OR 操纵:

\匹配含有\或者 \的字符串; \（b│cd）ef\匹配含有 \或者 \的字符串;

\（a│b）*c\匹配含有如许多个（包含0个）a或b，后面跟一个c 的字符串;

一个点（\）可以代表所有的单一字符，不包含\若是，要匹配包含\在内的所有单个字符，怎么办？对了，用\这种模式.

\一个a加一个字符再加一个0到9的数字 \￥\三个随便率性字符结尾 .

中括号括住的内容只匹配一个单一的字符

\匹配单个的 a 或者 b （和 \一样）;

\匹配\到\的单个字符（和\还有 \结果一样）; 一般我们都用[a-zA-Z]来指定字符为一个大小写英文

\匹配以大小写字母开首的字符串 \％\匹配含有形如 x％的字符串

\，[a-zA-Z0-9]￥\匹配以逗号再加一个数字或字母结尾的字符串

你也可以把你不想要得字符列在中括号里，你只须要在总括号里面应用\作为开首 \％[^a-zA-Z]％\匹配含有两个百分号里面有一个非字母的字符串.

要点:^用在中括号开首的时辰，就默示打消括号里的字符

为了PHP可以或许申明，你必须在这些字符面前后加\，并且将一些字符转义.

不要忘怀在中括号里面的字符是这条规路的例外—在中括号里面，所有的特别字符，包含（\），都将落空他们的特别性质 \？{}.]\匹配含有这些字符的字符串.

还有，正如regx的手册告诉我们: \若是列表里含有 \，最好把它作为列表里的第一个字符（可能跟在\后面）. 若是含有\，最好把它放在最前面或者最后面， or 或者一个局限的第二个停止点[a-d-0-9]

中心的?-‘将有效.

看了上方的例子，你对{n，m}应当懂得了吧.要重视的是，n和m都不克不及为负整数，并且n老是小于m. 如许，才干起码匹配n次且最多匹配m次. 如\，5}\将匹配 \中的前五个p 下面说说以开首的

?? 书上说他是用来匹配一个单词鸿沟，就是...比如\，可以匹配love里的ve而不匹配very里有ve B 正好和上方的??相反.例子我就不举了

.....忽然想起来....可以到http://www.phpv.net/article.php/251 看看其它用开首的语法

好，我们来做个应用:

如何构建一个模式来匹配货币数量的输入

构建一个匹配模式去搜检输入的信息是否为一个默示money的数字。我们认为一个默示money的数量有四种体式格式： \和 \，000.00\，或者没有小数项目组， \，000\如今让我们开端构建这个匹配模式: ^[1-9][0-9]*￥

这是所变量必须以非0的数字开首.但这也意味着单一的 \也不克不及经由过程测试. 以下是解决的办法:

^（0│[1-9][0-9]*）￥

\只有0和不以0开首的数字与之匹配\，我们也可以容许一个负号在数字之前: ^（0│-？[1-9][0-9]*）￥

这就是: \或者一个以0开首且可能有一个负号在前面的数字.\好了，如今让我们别那么严谨，容许以0开首.如今让我们放弃负号，因为我们在默示货币的时辰并不须要用到. 我们如今指定模式用来匹配小数项目组: ^[0-9]+（.[0-9]+）？￥

这暗示匹配的字符串必须起码以一个阿拉伯数字开首. 然则重视，在上方模式中 \是不匹配的，只有 \和 \才可以. （你知道为什么吗） ^[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-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（\， \，\， trim（￥str））;

最后，我把另一串搜检EMAIL的正则表达式让看文章的你来解析一下.

\＃￥％&\？A-Z^_`a-z{|}~]+\＠\＃￥％&\？A-Z^_`a-z{|}~]+.\＃￥％&\？A-Z^_`a-z{|}~]+￥\

若是能便利的读懂，那这篇文章的目标就达到了.

JScript 和 VBScript 正则表达式的语律例则

一个正则表达式就是由通俗字符（例如字符 a 到 z）以及特别字符（称为元字符）构成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜刮的字符串进行匹配。

这里有一些可能会碰到的正则表达式示例：

JScript VBScript 匹配

/^[ ]*￥/ \￥\匹配一个空白行。

/d-d/ \验证一个ID 号码是否由一个2位数字，一个连字符以及一个5位数字构成。 /<（.*）>.*/ \（.*）>.*\匹配一个 HTML 标识表记标帜。

下表是元字符及其在正则表达式高低文中的行动的一个完全列表：

字符描述

将下一个字符标识表记标帜为一个特别字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，\匹配字符 \。\匹配一个换行符。序列 \匹配 \而 \（\则匹配 \（\。

^ 匹配输入字符串的开端地位。若是设置了 RegExp 对象的 Multiline 属性，^ 也匹配 \或 \之后的地位。

￥匹配输入字符串的停止地位。若是设置了RegExp 对象的 Multiline 属性，￥也匹配 \或 \之前的地位。

* 匹配前面的子表达式零次或多次。例如，zo* 能匹配 \以及 \。* 等价于。

+ 匹配前面的子表达式一次或多次。例如，\能匹配 \以及 \，但不克不及匹配 \。+ 等价于。

？匹配前面的子表达式零次或一次。例如，\（es）？\可以匹配 \或 \中的\。？等价于。

n 是一个非负整数。匹配断定的 n 次。例如，\不克不及匹配 \中的 \，然则能匹配 \中的两个 o。

n 是一个非负整数。至少匹配n 次。例如，\不克不及匹配 \中的 \，但能匹配 \中的所有 o。\等价于 \。\则等价于 \。

m 和 n 均为非负整数，此中n <= m。起码匹配 n 次且最多匹配 m 次。例如，\将匹配 \中的前三个 o。\等价于 \？\。请重视在逗号和两个数之间不克不及有空格。

？当该字符紧跟在任何一个其他限制符（*， +，？，，，）后面时，匹配模式长短贪婪的。非贪婪模式尽可能少的匹配所搜刮的字符串，而默认的贪婪模式则尽可能多的匹配所搜刮的字符串。例如，对于字符串 \，\？\将匹配单个 \，而 \将匹配所有 \。

. 匹配除 \之外的任何单个字符。要匹配包含 \在内的任何字符，请应用象 \的模式。（pattern）匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 凑集获得，在VBScript 中应用 SubMatches 凑集，在JScript 中则应用 … 属性。要匹配圆括号字符，请应用 \（\或 \）\。（？:pattern）匹配 pattern 但不获取匹配成果，也就是说这是一个非获取匹配，不进行存储供今后应用。这在应用 \或\字符（|）来组合一个模式的各个项目组是很有效。例如， \（？:y|ies）就是一个比 \更简单的表达式。

（？=pattern）正向预查，在任何匹配 pattern 的字符串开端处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不须要获取供今后应用。例如，\（？=95|98|NT|2000）\能匹配 \2000\中的 \，但不克不及匹配 \中的 \。预查不消费字符，也就是说，在一个匹配产生后，在最后一次匹配之后立即开端下一次匹配的搜刮，而不是从包含预查的字符之后开端。（？!pattern）负向预查，在任何不匹配 pattern 的字符串开端处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不须要获取供今后应用。例如\（？!95|98|NT|2000）\能匹配 \中的 \，但不克不及匹配 \中的 \。预查不消费字符，也就是说，在一个匹配产生后，在最后一次匹配之后立即开端下一次匹配的搜刮，而不是从包含预查的字符之后开端 x|y 匹配 x 或 y。例如，\能匹配 \或 \。\（z|f）ood\则匹配 \或 \。 [xyz] 字符凑集。匹配所包含的随便率性一个字符。例如， \可以匹配 \中的 \。 [^xyz] 负值字符凑集。匹配未包含的随便率性字符。例如， \可以匹配 \中的\。 [a-z] 字符局限。匹配指定局限内的随便率性字符。例如，\可以匹配 \到 \局限内的随便率性小写字母字符。

[^a-z] 负值字符局限。匹配任何不在指定局限内的随便率性字符。例如，\可以匹配任何不在 \到 \局限内的随便率性字符。

匹配一个单词鸿沟，也就是指单词和空格间的地位。例如， \可以匹配\中的 \，但不克不及匹配 \中的 \。

B 匹配非单词鸿沟。\能匹配 \中的 \，但不克不及匹配 \中的 \。 cx 匹配由 x 指明的把握字符。例如， cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。不然，将 c 视为一个原义的 \字符。 d 匹配一个数字字符。等价于 [0-9]。 D 匹配一个非数字字符。等价于 [^0-9]。 f 匹配一个换页符。等价于 x0c 和 cL。匹配一个换行符。等价于 x0a 和 cJ。匹配一个回车符。等价于 x0d 和 cM。

s 匹配任何空白字符，包含空格、制表符、换页符等等。等价于 [ f v]。 S 匹配任何非空白字符。等价于 [^ f v]。匹配一个制表符。等价于 x09 和 cI。

\\f : 换页符 \\n : 换行符 \\r : 回车符

\\t : 制表符(Tab) \\v : 垂直制表符

\\S 匹配任何非空白, 相当于 [^\\f\\n\\r\\t\\v]

v 匹配一个垂直制表符。等价于 x0b 和 cK。

w 匹配包含下划线的任何单词字符。等价于\。 W 匹配任何非单词字符。等价于 \。

xn 匹配 n，此中 n 为十六进制转义值。十六进制转义值必须为断定的两个数字长。例如，\匹配 \。\则等价于 \。正则表达式中可以应用 ASCII 编码。.

um 匹配 num，此中 num 是一个正整数。对所获取的匹配的引用。例如，\（.）\匹配两个连气儿的雷同字符。

标识一个八进制转义值或一个向后引用。若是之前至少 n 个获取的子表达式，则 n 为向后引用。不然，若是 n 为八进制数字（0-7），则 n 为一个八进制转义值。

m 标识一个八进制转义值或一个向后引用。若是 m 之前至少有 nm 个获得子表达式，则 nm 为向后引用。若是 m 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。若是前面的前提都不满足，若 n 和 m 均为八进制数字（0-7），则 m 将匹配八进制转义值 nm。

ml 若是 n 为八进制数字（0-3），且 m 和 l 均为八进制数字（0-7），则匹配八进制转义值 nml。 un 匹配 n，此中 n 是一个用四个十六进制数字默示的 Unicode 字符。例如， u00A9 匹配版权符号（?）。

所有中文（不包含标点）：（[xB0-xF7][xA1-xFE]）+ 所有GB2312-80编码（[xA1-xFE][xA1-xFE]）+ 所有中文空格（xA1xA1）+

英文标点：[x20-x2Fx3A-x40x5B-x60x7B-x7E]

在delphi下应用TPerlRegEx也是不错的巴尔扎克

本文来源：https://www.bwwdw.com/article/n9yp.html

相关文章：

正在阅读：

delphi正则表达式验证操作04-11

论税务稽查自由裁量权的应用和控制01-13

综合管廊施工方案04-07

洛阳职称改革职改办职称论文发表-公路养护就地热再生温拌技术应04-18

我家的小童星作文400字07-07

麦德龙超市物流调研报告05-12

国开区基本情况机构设置05-10

卡拉ok点歌系统的设计与实现（正稿） 2 - 图文04-07

学校传染病防治预案02-13

电大外国文学 2007年7月 - -2012年7月试卷（共11份试卷含参考答案及评分标准）10-10

上一篇：金川安全预案(2) - 图文下一篇：寒假低段班第七次课—童话、寓言故事阅读技巧