此处将为大家介绍关于Delphi比较第三方正则组件PerlRegEx和官方的RegularExpressions速度测试的详细内容，此外，我们还将为您介绍关于3.2re--正则表达式操作（Regula

此处将为大家介绍关于Delphi 比较第三方正则组件 PerlRegEx 和 官方的 RegularExpressions 速度测试的详细内容，此外，我们还将为您介绍关于3.2 re--正则表达式操作（Regular expression operations）、7.2. re — Regular expression operations正则表达式 p...、Delphi 正则表达式之TPerlRegEx 类的属性与方法(6): EscapeRegExChars 函数、JavaScript——正则表达式RegExp(Regular Expression)的有用信息。

本文目录一览：

• Delphi 比较第三方正则组件 PerlRegEx 和 官方的 RegularExpressions 速度测试
• 3.2 re--正则表达式操作（Regular expression operations）
• 7.2. re — Regular expression operations正则表达式 p...
• Delphi 正则表达式之TPerlRegEx 类的属性与方法(6): EscapeRegExChars 函数
• JavaScript——正则表达式RegExp(Regular Expression)

Delphi 比较第三方正则组件 PerlRegEx 和 官方的 RegularExpressions 速度测试

3.2 re--正则表达式操作（Regular expression operations）

本模块提供了正则表达式的匹配操作，它的功能跟Perl语言里的功能一样。

无论是Unicode字符串还是单字节8位组成的字符串，都可以使用模式匹配和字符串查找的功能。不过要注意的是Unicode字符串与8位的字符串不能混合使用，也就是说你不能在Unicode里去匹配单字节的模式，或者其它查找的功能。同样也不能在不同类型的字符串里相互替换字符串。

正则表达式使用反斜线（‘\’）来指定特定的格式的意义，或者是允许使用特定的字符。为了解决使用反斜线（‘\’），它的解决方法跟在字符串格式化里使用一样的方案。比如想匹配双反斜线（‘\\’），就需要使用’\\\\’的格式，因为每两个双反斜线（‘\\’）表示一个斜线。

不过，也可以使用另外一种方法来表示正则表达式的字符串，不用这么麻烦的方法，那就是使用‘r’字符开头来表示原始字符串处理。比如写成r’\n’就是表示两个字符：\和n的字符串，如果没有r开头的字符串’\n’则是表示一个字符的字符串，它表示换行字符。

有一点是要注意的，所有正则表达式的相关函数和方法都在编译正则表达式的对象那节里，但并不是说这些函数和方法需要编译正则表达式才可以使用，而是直接可以使用，不过会有一些性能上损失，或者要多输入一些参数。

蔡军生 QQ:9073204 深圳

7.2. re — Regular expression operations正则表达式 p...

文中翻译有些不到位的地方请看原文http://docs.python.org/library/re.html

另推荐有关python re的文档http://docs.python.org/howto/regex

中文翻译可参加http://www.cnblogs.com/ltang/archive/2011/07/31/2122914.html  

本模块提供了那些在Perl中可找到的相似的匹配操作。被搜索的patterns和strings可以是Unicode性字符串或8位字符串。

    正则表达式使用了反斜线''\''字符来指示特别的形式或允许在不使用它们特别含义的情况下使用这写特殊字符。这样会有问题，比如，为了匹配字面上的反斜线''\''，pattern可能会是''\\\\''，因为正则表达式必须是\\, 并且每一个反斜线在正常的python字面字符串必须被表示为\\。

    为此的解决方案是使用python的raw string观念；在前缀''r''的反斜线不在具有特别含义所以r"\n"是包含''\''和''n''的2个字符，而"\n"本身是一个换行符是一个字符。通常，在Python代码中的patterns被表示为raw string。    明白大部分正则表示操作可在模块级函数和RegexObject方法下完成是很重要的。这些函数不需要你首先编译一个regex对象，但也失去了一些fine-tuning参数，所以是捷径。--参见  Mastering Regular Expressions 一书

7.2.1. Regular Expression Syntax

    正则表达式（RE）明确了a set of strings that matches it;本模块中的函数让你检查一个特别的string是否匹配一个给出的re正则表达式(或给出的re是否匹配特别的string）

    多个正则表达式可联合成新的正则表达式；如果A和B都是RE，则AB也是RE，一般来说，如果字符串P匹配A并且另一个字符串Q匹配B，则PQ将匹配AB。This holds unless A or B contain low precedence operations; boundary conditions between A and B; or have numbered group references.因此复杂的表达式可有小的简单表达式构成。

    正则表达式可包含特殊和普通字符。大部分普通字符比如''A'',''B'',''C''是最简单的正则表达式；他们只是匹配他们自己 。可联合起来，所以last匹配''last''（剩下将介绍特别类型）

    一些像''|'' , ''(''的特殊字符。特殊字符或者代表了普通字符类，或者影响着他们周围的正则表达式是如何别解释的。pattern不要包含null字节，但可使用\number中的null 字节比如''\x00''。

    特殊字符：

''.''  :默认时匹配除换行符外的任意字符，如果明确了DOTALL标记，这匹配包含换行符在内的所有字符。

''^'' :匹配string的开始，在multiline模式下在每一行就匹配

''*'' :使前面的RE匹配0次或多次。所以 ab*将匹配''a'' , ''ab'' , ''a''并后跟任意多个''b''

''?'' : 使前面的RE匹配0次或1次。所以ab?将匹配''a'' 或''ab''

*?   +?   ?? : ''*'' ,''+'' ,''?''都是贪心的；他们能匹配多少就匹配多少。有时这种行为是不希望的；如果RE <.*>匹配''<H1>title</H1>''时将匹配整个字符串而不是我们想要的''<H1>''.所以，后加''?''将使非贪心或minimal模式；能够少匹配多少就匹配多少，所以,   .*?将匹配''<H1>'' .

{m} :前面的RE匹配m次；比如a{6}将明确匹配6个''a''字符，而不是5次。

{m,n} :前面的RE匹配m到n次，在m到n的范围内能匹配多少就匹配多少。比如 a{3,5}将匹配从3到5次的''a''。省略m时说明从0次开始匹配，省略n时说明了上界为无穷多次的匹配。比如，a{4,}b匹配aaab好100个''a''再后接''b'',但不是''aaab''.

{m,n}? :前面的RE匹配m到n次，在m到n的范围内能少匹配多少就匹配多少。所以是非贪心的，如果string为''aaaaaa''则a{3,5}将匹配5个''a'' 而 a{3,5}?将匹配只3个''a''

''\'' :或者转义（escapes）特殊字符（即允许你匹配像''*'',''?''的特殊字符），或signals 一个特殊的字符串：

如果你不使用raw string来表示pattern，记得python也在string literals中将反斜线''\''用作转义字符；如果python语法分析器不认识转义字符，则反斜线和接下来的字符会被包含在最终结果的string中，但是，如果python识别了最终序列，则反斜线应重复2次。复杂斌难以理解，所以强烈推荐使用raw strings

[] :明确字符集

1.单独列出来的字符 [amk]将匹配''a''或 ''m''或 ''k''

2. 字符范围 [a-z]小写字母  [0-5][0-9]两位数字00-59   [0-9A-Fa-f]匹配16进制位，如果''-''被转义（[a\-z]）或被放在开头或结尾（[a-]）见匹配''-''

3. 在[]中特殊字符失去了其特殊的含义，比如[(+*)]将匹配字面上的''('' 或''+''或  ''*'' 或 '')''

4. 像\w 或\S的字符类也可放在[]中，即使匹配的字符依赖于LOCALE或UNICODE模式是否有效

5. 匹配不在[]中的字符，如果字符集中的第一个字符是''^''，则匹配字符集外的任意字符。比如[^5]将匹配除了5以外的任意字符，[^^]将匹配除了''^''外的任意字符。''^''如果不出现在字符集的第一个字符则没有特殊的含义。

6. 为了在集合中匹配'']'',前加反斜线或放在集合开头。比如 [()[\]{}]和[]()[{}]都匹配圆括号

 

''|'' :A|B （其中A和B可是任意的RE）创造了一个将匹配A或者B的正则表达式。任意数量的RE可由''|''方式分隔。此中方式也可在group中出现(下面)。当目标字符串被scanned时，由''|''分隔的RE从左到右一个一个被试。但有一个完全匹配时，此分支被接受。意味着一旦A匹配了，则B不会被test一遍，即使B可能会有一个更长的匹配。换句话说，''|''是非贪心的。为了匹配字母上的literal ''|'' 使用\|或放入[]中为[|]

(...) :只是将RE放入此中，以便后面引用：\number。为了匹配字面上的''''( 或'')''使用\(或\)或在字符类中:[(] 和[)]

(?...) :

(?iLnsux): 

(?:...): 非捕获版的RE。匹配的字串无法在后面需要时被引用

(?P<name>...): 同(...)只是匹配后可由group名来引用。比如如果pattern是(?P<id>[a-zA-Z_]\w*),则以后可用m.group(''id'')或m.end(''id'')方式引用，

(?P=name): group名为name的RE

(?#...): 注释；圆括号中的注释被忽略

(?=...): 如果...匹配下面的时此才匹配，但不消耗任意的string。被叫做lookahead assertion。比如，Isaac(?=Asimov)只在后接''Asimov时才''将匹配''Isaac''

(?!...): 如果...不匹配下面的时此才匹配，比如 Isaac(?!Asimov)将匹配''Isaac''只在不后接''Asimov''时

(?<=...):前接...时才匹配。(?<=abc)def将在abcdef中发现一个匹配，...只能是固定长度的pattern，比如 abc或a|b可以，但a*和a{3,4}不行。

此例找前跟连字号的一个word:

(?<!...): 如果不前接...时此才匹配。同上，...比是固定长度。

(?(id/name)yes-pattern|no-pattern): 如果为id或名为name的group存在时才去匹配yes-pattern，反之，匹配no-pattern。no-pattern是可选的也就可省略。比如，(<)?(\w+@\w+(?:\. \w+)+)(?(1)>)是可poor的邮件匹配pattern,将匹配''<user@host.com>''或''user@host.com''但不会匹配''<user@host.com'' .

 

New in version 2.4.

\number：匹配编号为number的RE

    group从1开始编号。比如(.+) \1匹配''the the ''或 ''55 55'',但不是''the end'' (注意空格).编号只能从0到99.

\A :只匹配string的开头。

\b : 匹配空字符串，但仅仅在word的开头或结尾。一个word被定义为有字母，数字，或下划线组成的序列，所以word的端（end）是空格或非字母，非数字，非下划线。\b被定义为\w 和\W字符之间的boundary（反之，也成立），或\w和string的开始端或结束端之间，比如，r''\bfoo\b''匹配''foo'',''foo.'' ''(foo)'', ''bar foo baz''但不会匹配''foobar''或 ''foo3''.为了兼容python的string，在字符范围内\b代表backspace字符。

\B :  匹配空字符，但仅仅但它不在word的开头或结尾时。这意味着r''py\B''将匹配''python'',''py3'',''py2'',而不会匹配''py'',''py.'',''py!''. \B是\b的反面，所以is also subject to the settings of LOCALE and UNICDOE.

\d :  当没有明确UNICODE标志位时，将匹配任意的decimal数字；这等同于[0-9].有了UNICODE时，将匹配whatever is classified as a decimal digit in the Unicode character properties database.

\D: 当没有明确UNICODE标志位时，将匹配任意的非decimal数字；这等同于[^0-9].有了UNICODE时，将匹配anything other than character marked as digits in the Unicode character properties database.

\s:　当没有明确UNICODE标志位时，将匹配任意的非空格字符；这等同于［^\t\n\r\f\v］....

\S:

\w:这等同于[a-zA-Z0-9]

\W: 

\Z:

本模块定义了一些函数，常量，和异常。一些函数是。。。的简化版本。大部分应用都使用complied形式。

 

re.compile(pattern,flags=0)

    编译一个正则表达式pattern为正则表达式对象，可利用此对象的match()和search()方法。

    RE的行为可由flags改变。其值可为下面变量的任何一个，或使用|的OR操作混合起来。

等价于：

但使用re.compile()为了重用而保存最终的正则表达式对象是更有效的。

re.DEBUG:显示有关compiled expression的调试信息。

re.I  re.IGNORECASE: 完成大小写无关匹配；所以，像[A-Z]的表达式也将匹配小写字母。这不受current locale影响。

re.L  re.LOCALE: 使得\w \W \b \B \s \S依赖与current locale

re.M re.MULTILINE: 明确此时，pattern字符''^''匹配string的开头并且在每一行的开头；''$''匹配string的结尾并且在每一行的结尾。默认情况下，''^''只匹配string的开头，''$''只匹配string的结尾。

re.S re.DOTALL: 使得''.''将匹配包含换行符在内的任意字符，没有此flag时匹配除换行符外的任意字符。

re.U re.UNICODE:使得\w \W \b \B \s \S依赖与Unicode character properties database.

re.X re.VERBOSE: 此flag可使你写出好看的RE。除了字符类的空格和preceded by unescaped backslash的空格外其他的在pattern中的空格会被忽略，

意味着下面等价：

re.search(pattern,string,flags=0)

    扫描string从中找到pattern匹配的位置，并返回相应的MatchObject实例对象。如果没有匹配返回None；注意这不同于在string中找到0长度的匹配。

re.match(pattern,string,flags=0)

    如果在string的开始有0或多个字符匹配pattern，并返回相应的MatchObject实例对象。如果没有匹配返回None；注意这不同于在string中找到0长度的匹配。

    注意甚至在multiline模式下，re.match()将仅仅匹配string的开头而不是每一行的开头。

    如果你想要在string的任何地方locate a match，使用search()。

re.split(pattern,string ,maxsplit=0,flags=0)

    split string by the occurrence of pattern。如果pattern加了圆括号，则所有pattern里所有groups的内容作为最终结果的list被返回。如果maxsplit非0，则最多maxsplit个分片发生，并且string中剩下的内容作为list中最后的元素。

如果有捕获groups(pattern或某个子pattern被圆括号括起来) in the seaparator并且它匹配字符串的开头，结果将以空字符串开头，空字符串结尾：

注意split绝不会在不匹配时split字符串：

re.findall(pattern,string,flags = 0)

    以list的形式返回string中所有的非重叠的匹配，每一个匹配时list的一个元素。string被从左到右扫描，匹配。如果一个或多个groups被发现，则返回返回元素为tuple的list。

re.finditer(pattern,string,flags = 0)

    对每一个非重叠匹配返回MatchObject实例的inerator。

re.sub(pattern,repl,string,count = 0,flags = 0)

    返回由repl替代string中每一个非重叠匹配的字串后的string。如果没有匹配被发现，则原string被返回。repl可以是string或函数，如果是string，则转义字符被使用，比如\n是一个换行符，\r是carriage return,等等。不被识别的转义字符\j are left alone.后向引用是\6表示group号为6的被匹配的字串：

如果repl是函数，则对每一个非重叠的引用此函数被调用一次。此函数把每个MatchObject对象作为函数参数，sub返回替换之后的字符串：

 

pattern可以是string或RE对象

可选的参数count是被替换的最大数；是非负值。如果此参数别省略或为0，则所有匹配被替换。仅当not adjacent to a previous match 是empty matchs被替换：sub(''x*'',''-'',''abc'')返回''-a-b-c-''.

除了字符转义和后向引用外，\g<name>将使用被匹配的group名为name的字串，此group定义为(?P<name>...).\g<number>也使用了相应的group数；\g<2>等价于\2,但不与替换中的比如\g<2>0混淆。\20被解释为对group 20的引用，不是group 2的引用并后跟字面字符''0''。后向引用\g<0>替换了整个匹配的字串。

 

re.subn(pattern,repl,string ,count = 0,flags = 0)

    完成与sub同样的操作，但返回一个tuple (new_string,number_of_subs_made).

re.escape(string)

    返回所有non-alphanumerics backslashed字串；

re.purge()

    清除RE缓存

exception re.error

    但一个无效的RE被传递给函数时Exception被raised(比如，可能包含了unmatched parentheses)或在编译或匹配时发生的错误。但如果string不匹配RE是不会发生error的

class re.RegexObject

    RegexObject类支持下面的方法和属性：

search(string[, pos[, endpos]])

    扫描此string并找RE匹配此string的位置，并返回相应的MatchObject对象。如果不匹配返回None；注意这不同于找到0长度的match。

    第二个可选的参数pos给在出string中匹配开始的索引位置；默认是0即从头开始匹配。这不完全同于对string的分片操作；''^''匹配string的开头或newline的后面位置，但...

       可选的参数endpos限制了string被搜索多远；就好像string只有endpos长，所以对匹配来讲仅仅有pos 到endpos-1的字符被搜索。如果endpos小于pos，不会有匹配，否则，如果rx被编译成了RE对象，re.search(string,0,50)等价于rx.search(string[:50],0)。

match(string[,pos[,endpos]])

    如果在string的开头有0个或多个字符匹配此RE，则返回相应的MatchObject实例对象。如果没有匹配则返回None；注意，这不同于0长度匹配。

可选的pos和endpos同search()。

    如果你想要在string中定位一个match，使用search()而不是match()

split(string,maxsplit = 0)

    等同于split()函数，使用compiled pattern

findall(string[, pos[, endpos]])

    相似与findall()函数，使用compiled pattern，但也接受可选的参数，此些参数同match()中。

finditer(string[, pos[, endpos]])

    相似与finditer()函数，使用compiled pattern，但也接受可选的参数，此些参数同match()中。

sub(repl,string,count = 0)

    等价于sub()函数，使用compiled pattern。

subn(repl,string,count = 0)

    等价于subn()函数，使用compiled pattern

flags

    regex匹配flags。 

groups

    patten中被捕获的groups数

groupindex

    一个字典，此字典将由(?P<id>)定义的group名与group数一一对应。如果在patter中没有使用

    groups(pattern或某个    子pattern没有被圆括号括起来)则此字典为empty

pattern

    the pattern string from which the RE object was compiled

class re.MatchObject

    MatchObject总是有值为True的布尔值，所以你可以测试比如matct()

    expand(template)

        返回对template字符串进行backlash替换之后而获得的字符串，正如sub()方法那样。转义比如\n被转换为恰当的字符，数字后引用(\1 ,\2)和有名后引用(\g<1>,\g<name>)被相应group的内容所替换。

    group([group1, ...])

         返回匹配的一个或多个的子group。如果有一个参数，则结果是一个单string，如果有多个参数，结果是每个参数为一个item的tuple。没有参数时，group1默认为0(整个匹配被返回)。如果groupN为0，相应的返回值是整个匹配的string；如果参数在[1..99]范围内，结果是匹配相应的group的string。如果group number为负或大于patter中定义的group number，则raise一个IndexError异常。如果一个group包含在pattern中且没有匹配，则相应的结果为None。如果一个group包含在pattern中且多次被匹配，则最后那次匹配被返回。

如果RE使用了(?P<name>...)语法，则groupN参数也可以是个string，此string由group name给出。如果string参数不被用作pattern中的group名，raise一个IndexError。

一个适度复杂的例子：

有名的groups也可由index来引用：

如果一个group匹配了多次，只是最后那次匹配 is accessible：

    groups([default])

        返回所有由subgroup匹配形成的tuple，从1到开始。default参数不会参与匹配；默认为None

        比如：

不是所有的group会参与到匹配中。如果默认值未给出则groups将默认为None，否则值为默认值：

    groupdict([default])

        返回一个字典，此字典包含了key为subgroup名 value为相应的匹配字串。如果默认值未给出则groups将默认为None，否则值为默认值：

    start([group])

    end([group])

           返回每个匹配的group的开始和结束位置；group默认为0(即整个匹配的字串)。如果group存在但没有匹配时返回-1.对一个match对象m，一个group g满足一个匹配，则g匹配的字串(m.group(g))为:

 注意：m.start(group)在group匹配一个null字符串时将等同于m.end(group)。比如，m = re.search(''b(c?)'',''cba'')执行后，m.start(0)是1，m.end(0)是2，m.start(1)和m.end(1)都是2，m.start(2)将raise一个IndexError异常。

一个将从email地址中删除remove_this的例子：

    span([group])

        对MatchObject m来说，返回一个(m.start(group), m,end(group))的tuple。注意，如果group不匹配，结果是(-1, -1)

group默认为0，整个匹配。

    pos

        此值传给RegexObject对象的search()或match()方法。这是RE引擎开始匹配的index的开始位置

    endpos

        此值传给RegexObject对象的search()或match()方法。这是RE引擎开始匹配的index的结束位置

    lastindex   

    lastgroup

    re

    string

在整个例子中，我们将使用下面的helpler函数显示math objects，使之结果更美观：

假设你正在写一个扑克程序，此程序中每个玩家的手由5个字符的字符串代表，其中每一个字符代表一个卡片，''a''代表ace，''k''代表king， ''q''代表queen， ''j''代表jack， ''t''代表10以及2到9代表了卡的值。

为了查看一个给出的string是否是个有效地hand，可以如下怎么做：

最后一个hand， "727ak",包含了一对或2个相同值的卡。可使用后向引用：

Python中当前没有相等价的scanf()函数，RE一般比scanf()格式更强大，也更啰嗦，下表或多或少提供了一些等价于scanf()函数的RE格式

scanf() Token	Regular Expression
%c	.
%5c	.{5}
%d	[-+]?\d+
%e, %E, %f, %g	[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?
%i	[-+]?(0[xX][\dA-Fa-f]+|0[0-7]*|\d+)
%o	0[0-7]*
%s	\S+
%u	\d+
%x, %X	0[xX][\dA-Fa-f]+

为了从像下面的string中提取文件名和数字：

你会像下面这样使用scanf()格式：

而等价的RE会是：

Python提供了2个不同的基于RE的基本操作：re.match()用来仅仅检查string的开头，而re.search()检查string中任何一个位置开始的匹配(perl默认就是这样)比如：

以''^''开始的RE可被用在search()中以便来约束在string开头处的匹配：

但，在MULTILINE模式下，match()函数仅仅匹配string的开头，但以''^''开头的RE的search()函数可匹配每行的开头。

split()函数以pattern将string分隔形成一个list。此方法在将文本数据转化为易读易修改的数据结构时显得很与价值。

首先，输入正常意义下来自于文件，这里我们使用triple-quoted字符串语法：

字符串给一个或多个空行分隔开。现在我们将string转化为每一个非空行是list中一个元素而形成的list：

最后，将每一行在split成一个first-name last-name telephone-number 和 address构成的list。使用maxsplit参数，因为address占有空间：

'':?''匹配last-name的冒号。如果maxsplit为4我们可以从street-name中分隔出housr-number：

sub()用string或函数的结果替换每一次pattern的匹配。这个例子显示了使用sub()函数repl为一个函数，在此函数中"munge" text，或者随机化除了第一个和最后一个字符外的字符：

findall()匹配所有的pattern，不仅仅是search()那样子匹配第一个。比如，如果某个作家想要在文本中找到所有的动词，他或她可像如下这样使用：

如果某人想要得到有关匹配更多的信息，finditer()是很有用的，因为它提供了MathcObject实例对象。接着前面的例子，如果某个作家想要在某个文本中找到动词以及出现的位置，可使用finditer():

raw stirng概念(r"text")使得RE健全。没有此，每个在RE中的反斜线''\''可能必须要前缀另一个反斜线来转义它，下面代码功能上等价：

当某人想要匹配一个字面上的反斜线是，必须在RE中转义。有了raw string后即r"\\"。没有raw string时必须使用"\\\\",下面代码等价：

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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;

 
 
 
 
 

 

 

  
  

JavaScript——正则表达式RegExp(Regular Expression)

正则表达式用于定义一些字符串规则 ,计算机可以根据正则表达式，来检查一个字符串是否符合规则,符合规则则返回True,否则将返回false,其次可以通过正则表达式将字符串中符合规则的内容提取出来，从而进行更好的验证。 首先，在JavaScript中使用正则表达式需要新建一个RegExp对象。就像这样,我们可以用一种对象的方式创建出一个新的正则表达式对象。

在RegExp对象中的第一个参数是“正则表达式的规则和内容”，第二个参数是正则表达式的匹配模式，在这里有1.忽略大小写模式，2.全局匹配模式 当然很多时候为了方便开发，我们会使用JavaScript字面量的方式使用正则表达式，就像这样。

 

虽然这种方式比较简答，但是这种方式缺乏了灵活性，这个我们后面会继续说，现在不着急/

一、正则表达式基本语法：

1. 创建一个正则表达式，检查一个字符串中是否含有ab

运行结果:

2. 创建一个正则表达式，检查一个字符串中是否含有a或b

运行结果:

3.  创建一个正则表达式中检查一个字符串中是否有字母 首先这个问题，如果我们用之前的方案来解决的话，我们可能需要把26个英文字母全部写入正则表达式的规则中，就像/a|b|c|d|e|f|g|h|i|g|k|l|m|n|.../ 但是换句话说，正则表达式的本意就是通过计算机的自动匹配来减少无用的人工操作，所以我们需要引入新的符号，区间"[]"符号。

借助"[ ]"这个符号，我们可以将26个字符a-zA-Z进行依次检查。下面我们就可以完成这个检测喽～

4. 检查一个字符串中是否有abc / adc / aec

通常这种方式我们不常用，因为这三个字符中有一种规律，abc adc aec三个字符串中都有相同的首字母a和末尾字母c，三个字符串中只有中间的字符不一样，分别是b,d,e三个字符，同样我们可以用[]中括号来将可能会变化的字符加入此操作符中, 就像这样——>

运行结果和到上面那个一样：

5. 除此以外，正则表达式也可以像JavaScript中的数组方法resever反转一样，如果我们想查询字符串中不含有数字的字符串，我们可以使用^尖括号操作符进行分辨

例如就像这样：查询除了ab剩余的字符

运行结果:

除此以外，数字也可以这样来操作

本次笔记全部代码:

关于Delphi 比较第三方正则组件 PerlRegEx 和 官方的 RegularExpressions 速度测试的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于3.2 re--正则表达式操作（Regular expression operations）、7.2. re — Regular expression operations正则表达式 p...、Delphi 正则表达式之TPerlRegEx 类的属性与方法(6): EscapeRegExChars 函数、JavaScript——正则表达式RegExp(Regular Expression)的相关知识，请在本站寻找。

本文标签：

• Delphi
• PerlRegEx
• RegularExpressions
• 速度测试