Perl学习总结

来源：互联网发布：做详情页的软件编辑：程序博客网时间：2024/06/06 10:49

Perl(Practical Extraction and Report Language)

目的： 90%用于文字处理，10%用于其它。这是它的优势。
学习关键：熟悉Larry(创始人)的思维方式 + 下面所提及的框架要点

第一部分 Perl的总体框架

对于一门语言，我习惯从以下三个方面对其分类（他们都遵循从小-->大，从局部--->整体的顺序）

注：我觉得，这三个部分是统一的整体。比如语句= 操作数 + 操作符/程序结构（关键字）;

1. 组织方式

语句。组成代码的基本语句
块。由语句组成的块
函数。由块组成的特定功能的函数
整个文件。由不同函数组成的一个单一文件
可用函数库。提供了常见处理的解决方案。
整个工程。由多个文件组成。（到目前为止，我还没有用到多个文件的情况。当然，我只学了perl 几天时间。我相信它还是有这种机制的。不过其实我们用perl的原因，是因为它简单，快速。所以这有悖于初衷）

2. 关键字

2.1 声明，调用相关

&：调用函数
$：标量变量
@: 数组变量
%: 哈希

2.2 变量类型

和C/C++不同，不需要声明，笼统来讲，有两种

数值
字符

细节方面，比如没有整数，全部都以浮点数存储;字符与数值之间的转换等等

2.3 操作符（按照优先级顺序如下所示，详细用法见第二部分）

优先级自高而低(Perl&C is the same)

结合性操作符左括号和列表操作符的参数左->　=++ --(自增和自减)右**右/ ! ~ + - (一元操作符)左=~ !~左* / % x左+ - . (二元操作符)左<< >>　Named unary operators (-X filetests, rand)　< <= > >= lt le gt ge(“不等的”)　= = != <=> eq ne cmp(“相等的”)左&左| ^左&&左||　.. …右?:(三元操作符)右= += -= .=左, =>　List operators(rightward)右not左And左or xor

3. 程序控制结构

3.1 顺序

3.2 循环

http://net.pku.edu.cn/~yhf/tutorial/perlstep/perlstep4.html

while
until
do while/until
foreach
for
last
next
redo

3.3 选择

http://net.pku.edu.cn/~yhf/tutorial/perlstep/perlstep4.html

if
if else
if elsif else
unless

第二部分运算符详解

http://linux.chinaunix.net/doc/program/2005-01-28/966.shtml

描述

词语和列表操作符(靠左)
词语在 Perl 里有着最高的优先级别. 词语包括变量, 引号或类似引号的操作符, 任何括号里的表达式, 用括号括起参数的函数. 实际上, 这不是函数, 而是一些列表操作符和一元操作符, 当用括号括起它们的参数时, 它们就象是函数一样. 这些都在记录在文档 perlfunc 中.

如果任何列表操作符 (比如 print() ) 或任何一元操作符 (比如 chdir() ) 后面跟了一个左括号, 该操作符和它所有在括号中参数就有最高的优先级, 就象普通的函数调用一样.

如果没有括号对, 象 print , sort , 或 chmod 这些列表操作符的优先级别要么很高, 要么很低, 取决于看向操作符的左边还是右边. 例如:

@ary = (1, 3, sort 4, 2); print @ary; # prints 1324

sort 右边的逗号在 sort 被计算前被计算, 而左边的逗号则在之后计算. 换句话说, 列表操作符总是要把其后的所有参数组合起来, 相对它前面的表达式整体作为一个词语. 要注意括号的使用:

# 在这些计算被执行之前程序就会退出: print($foo, exit); # 这明显不是想要的结果 print $foo, exit; # 这样也不行 # 这样可以在退出前打印: (print $foo), exit; # 这是对的 print($foo), exit; # 这也对 print ($foo), exit; # 甚至这也对

也请注意

print ($foo &amp; 255) + 1, &quot;/n&quot;;

可能不会产生和一眼看上去应该有的运行结果. 参看 Named Unary Operators 查找更多有关的信息.

结构 do {} 和 eval {} , 也被当作词语处理, 情况和调用子过程及方法一样, 匿名结构 [] 和 {} 也一样.

参看 Quote and Quotelike Operators 和 I/O Operators .

箭头操作符
和在 C/C++ 里一样, ``->'' 操作符取消引用. 如果它的右边是 [...] 或 {...} 下标, 它的左边必须是对数组或哈希表的直接或符号化引用(如果不是一个左值(可被赋值), 要是一个存放直接引用的单元). 参看 perlref .

否则, 右边就是一个方法的名字或是一个存放方法名字的简单数值变量, 而左边必须是一个个对象(一个 blessed reference)或是一个类名(一个包名). 参看 perlobj .

自动增量减量
``++'' 和 ``--'' 和 C 里面的作用是一样的, 如果出现在变量之前, 在返回变量的值前进行增量或减量操作, 如果出现在变量之后, 操作在返回变量的值后进行.

自动增量操作符还有一个小小的特别功能. 如果对一个数字变量进行增量操作, 或者只要在数字上下文里使用, 增量的结果没有什么特别. 但如果对一个字符串变量增量, 或者是在字符串上下文里使用增量操作, 对象是满足模式 /^[a-zA-Z]*[0-9]*$/, 那么增量操作是针对整个字符串, 结果保持在模式范围内, 操作是带进位的:

print ++($foo = '99'); # prints '100' print ++($foo = 'a0'); # prints 'a1' print ++($foo = 'Az'); # prints 'Ba' print ++($foo = 'zz'); # prints 'aaa'

自动减量操作没有这个特性.

幂
二元 ``**'' 是幂操作符. 优先级比一元减操作符高, 所以 -2**4 等于 -(2**4), 不是 (-2)**4. (该操作符号是用 C 的 pow(3) 函数实现的, 该函数是对 double 类型操作)

符号一元操作符
一元 ``!'' 代表逻辑非, 即 ``not''. 参看 not , 这是个优先级稍低的版本.

一元 ``-'' 对数字操作数是算术的负号. 作用于字符串时, 如果字符串是标识符, 返回负号后跟标识符组成的字符串. 否则返回以负号开头的字符串. 这些规则的意思是 -bareword 就等于 ``-bareword'' .

一元 ``~'' 代表按位取反, 即 1 的补码.

一元 ``+'' 不起任何作用, 不管是对数字或字符串. 它的用处是在语法上把函数名和后面带括号的表达式隔开, 避免后者被当做参数处理. (参看 List Operators 中的例子)

一元 ``/'' 代表引用它后面的东西. 参看 perlref . 这个含义和字符串里的反斜杠的含义不同, 虽然两者都有避免后随被解释的作用.

捆绑操作符
二元 ``=~'' 把表达式捆绑到模式匹配上. 有些操作默认是搜索或修改变量 $_ . 这个操作符能对其他字符串进行同样的操作. 右边的参数是一个搜索模式, 替换, 或转换. 左边的参数代替 $_ 进行搜索, 替换, 转换. 返回值表示了操作是否成功. (如果右边的参数是表达式而非搜索模式, 替换或者转换, 在运行时刻会被解释作搜索模式. 这样做在效率上要比显式的使用搜索模式低, 因为每次进行表达式求值时模式会被重新编译, 除非使用了 /o.)

二元 ``!~'' 和 ``=~'' 的用法一样, 但返回值是逻辑上相反的.

乘法操作符
二元 ``*'' 把两个数字相乘.

二元 ``/'' 把两个数字相除.

二元 ``%'' 把两个数字求模.

二元 ``x'' 是重复操作符. 在数值上下文里, 返回一个字符串, 由左边的操作数重复右边操作数指定的次数组成. 在列表上下文里, 如果左边的操作数是括号括住的列表, 就重复这个列表.

print '-' x 80; # 打印一行虚线 print &quot;/t&quot; x ($tab/8), ' ' x ($tab%8); # tab over @ones = (1) x 80; # 包含80个 1 的列表 @ones = (5) x @ones; # 把所有元素设为 5

加法操作符
二元 ``+'' 把两个数字相加.

二元 ``-'' 把两个数字相减.

二元 ``.'' 连接两个字符串.

移位操作符
二元 ``<<'' 把左边的参数向左移位右边参数指定的次数. 参数必须是整数.

二元 ``>>'' 把左边的参数向右移位右边参数指定的次数. 参数必须是整数.

命名一元操作符
命名的一元操作符带上可选的括号被当作单参数的函数. 如文件测试操作符 -f, -M, 等等. 参看 perlfunc .

如果任何列表操作符 ( print() , 等等.) 或者任何一元操作符 ( chdir() , 等等.) 后跟有左括号, 该操作符和括号里的参数一起具有最高的优先级, 就象普通的函数调用一样. 例如:

chdir $foo || die; # (chdir $foo) || die chdir($foo) || die; # (chdir $foo) || die chdir ($foo) || die; # (chdir $foo) || die chdir +($foo) || die; # (chdir $foo) || die

但是, * 的优先级比 || 高:

chdir $foo * 20; # chdir ($foo * 20) chdir($foo) * 20; # (chdir $foo) * 20 chdir ($foo) * 20; # (chdir $foo) * 20 chdir +($foo) * 20; # chdir ($foo * 20) rand 10 * 20; # rand (10 * 20) rand(10) * 20; # (rand 10) * 20 rand (10) * 20; # (rand 10) * 20 rand +(10) * 20; # rand (10 * 20)

参看``List Operators''.

关系操作符
二元 ``<'' 返回真, 如果左边的参数在数字上小于右边的参数.

二元 ``>'' 返回真, 如果左边的参数在数字上大于右边的参数.

二元 ``<='' 返回真, 如果左边的参数在数字上小于或等于右边的参数.

二元 ``>='' 返回真, 如果左边的参数在数字上大于或等于右边的参数.

二元 ``lt'' 返回真, 如果左边的参数在字符顺序上小于右边的参数.

二元 ``gt'' 返回真, 如果左边的参数在字符顺序上大于右边的参数.

二元 ``le'' 返回真, 如果左边的参数在字符顺序上小于或等于右边的参数.

二元 ``ge'' 返回真, 如果左边的参数在字符顺序上大于或等于右边的参数.

相等操作符
二元 ``=='' 返回真, 如果左边的参数在数字上等于右边的参数.

二元 ``!='' 返回真, 如果左边的参数在数字上不等于右边的参数.

二元 ``<=>'' 分别返回 -1, 0, 或 1, 取决于左边的参数在数字上是小于, 等于, 或大于右边的参数.

二元 ``eq'' 返回真, 如果左边的参数在字符顺序上等于右边的参数.

二元 ``ne'' 返回真, 如果左边的参数在字符顺序上不等于右边的参数.

二元 ``cmp'' 分别返回 -1, 0, 或 1, 取决于左边的参数在字符顺序上是小于, 等于, 或大于右边的参数.

按位与
二元 ``&'' 返回两个操作数按位进行与操作的结果

按位或和异或
二元 ``|'' 返回两个操作数按位进行或操作的结果

二元 ``^'' 返回两个操作数按位进行异或操作的结果

C 风格的逻辑与
二元 ``&&'' 进行快速的逻辑与操作. 即如果左边操作数是假, 右边的操作数不会被求值. 当右边的操作数被求值, 数值或列表上下文会被传递过去.

C 风格的逻辑或
二元 ``&&'' 进行快速的逻辑或操作. 即如果左边操作数是真, 右边的操作数不会被求值. 当右边的操作数被求值, 数值或列表上下文会被传递过去.

|| 和 && 与 C 的不同之处是返回值不一定是 0 或 1, 而是最后的计算结果. 因此, 能正确找出 home 目录(不会是 ``0'')的方法应该是:

$home = $ENV{'HOME'} || $ENV{'LOGDIR'} || (getpwuid($<))[7] || die "You're homeless!/n";

为了增加程序的可读性, Perl 提供了 ``and'' 和 ``or'' 操作符(见下). 快速操作的特点是一样的. 但 ``and'' 和 ``or'' 的优先级要低很多, 所以在不用括号也可以安全地用在列表操作符后:

unlink &quot;alpha&quot;, &quot;beta&quot;, &quot;gamma&quot; or gripe(), next LINE;

用 C 风格操作符就要写成这样:

unlink(&quot;alpha&quot;, &quot;beta&quot;, &quot;gamma&quot;) || (gripe(), next LINE);

范围操作符
二元 ``..'' 是范围操作符, 在不同的上下文中有不同的含义. 在列表上下文中, 返回一个数组, 值的大小是从左边的操作数的右边的操作数(按一递增). 这可以用于编写 for (1..10) 循环, 或者是对数组做分片操作. 由于当前的实现方式中使用了临时数组, 所以下面的代码会浪费很多内存:

for (1 .. 1_000_000) { # code }

在数值上下文里, ``..'' 返回一个布尔值. 操作符是对位的, 象开关一样, 功能类似 sed, awk 等其它编辑器里的行范围(逗号) 操作符. 每个 ``..'' 操作符会维护自己的布尔值状态. 如果左边的操作数是假, 状态为假. 如果左操作数为真, 状态就是真, 直到右边的操作数也为真, 状态变回假. (在范围操作符被再次计算时, 状态才变回假. 它可以测试右操作数并在变成真值的计算过程中变成假值(象在 awk 里一样), 但还是会变到真值一次. 如果不想等到下一次计算才测试右操作数(象在 sed 里一样), 可以用三点 (``...'') 代替两点.) 当操作符处于 ``假'' 状态时, 右操作数不会被计算, 而当状态为 ``真'' 时, 左操作数不会被计算. 操作符的优先级稍低于 || 和 &&. 返回值是空字符串代表假值, 或是一串数字(从 1 开始)代表真值. 当范围到达时这串数字被复位。范围里最后一个数字有追加的字符串 ``E0''，但不影响它的数字值, 用来提供到达尾部的信息. 如果要忽略开始点, 可以等待大于 1 的数字. 如果 ``..'' 的左右操作数都不是数字, 操作数隐含地和当前行号变量 $. 进行比较. 例子:

作为数值操作符:

if (101 .. 200) { print; } # 打印第二个一百行 next line if (1 .. /^$/); # 跳过开头的行 s/^/&gt; / if (/^$/ .. eof()); # 引起全体文字

作为列表操作符:

for (101 .. 200) { print; } # 打印 $_ 一百次 @foo = @foo[$[ .. $#foo]; # 耗费资源的空循环 @foo = @foo[$#foo-4 .. $#foo]; # 切出最后 5 个元素

如果操作数是字符串, 范围操作符(在列表上下文里)使用特别的增量算法. 例如用

@alphabet = ('A' .. 'Z');

表示所有英文字母, 或者

$hexdigit = (0 .. 9, 'a' .. 'f')[$num &amp; 15];

表示所有16进制数字, 或者

@z2 = ('01' .. '31'); print $z2[$mday];

打印两位格式的日期. 如果最后指定的值不在算法能产生的范围内, 那么一直计算到下一个值的长度比最后的值大为止.

条件操作符
三元 ``?:'' 是条件操作符, 和 C 里的一样. 它的意思很象一个 if-then-else. 如果 ? 前面的参数为真, 返回 : 前面的参数, 否则返回 : 后面的参数. 例如:

printf &quot;I have %d dog%s./n&quot;, $n, ($n == 1) ? '' : &quot;s&quot;;

数值上下文或列表上下文会被传送给选中的参数.

$a = $ok ? $b : $c; # 得到数值 @a = $ok ? @b : @c; # 得到数组 $a = $ok ? @b : @c; # 这不对了

如果第2,3参数都是合法的左值, 操作符可以被赋值:

($a_or_b ? $a : $b) = $c;

但这样写的程序读起来不太容易.

赋值操作符
``='' 是普通的赋值操作符.

赋值符和 C 里的作用一样. 即

$a += 2;

等同于

$a = $a + 2;

但不象 tie() 那样会带来反引用左值的副作用. 其他赋值操作符的使用是类似的:

**= += *= &= <<= &&=
-= /= |= >>= ||=
.= %= ^=
x=

要注意这些操作符的优先级比等号高.

和 C 不同, 赋值操作符产生一个有效的左值. 对赋值进行修改等于先赋值, 再修改用于赋值的变量. 如: ($tmp = $global) =~ tr [A-Z] [a-z];

还有

($a += 2) *= 3;

等同于

$a += 2; $a *= 3;

第三部分正则表达式

http://www.chinaunix.net/jh/25/159388.html

正则表达式的三种形式

正则表达式中的常用模式

正则表达式的 8 大原则



    　　正则表达式是 Perl 语言的一大特色，也是 Perl 程序中的一点难点，不过如果大家能够很好的掌握他，就可以轻易地用正则表达式来完成字符串处理的任务，当然在 CGI 程序设计中就更能得心应手了。下面我们列出一些正则表达式书写时的一些基本语法规则。

--------------------------------------------------------------------------------

1. 正则表达式的三种形式

首先我们应该知道 Perl 程序中，正则表达式有三种存在形式，他们分别是：

匹配：m/<regexp>;/ （还可以简写为 /<regexp>;/ ，略去 m）

替换：s/<pattern>;/<replacement>;/

转化：tr/<pattern>;/<replacemnt>;/

这三种形式一般都和 =~ 或 !~ 搭配使用（其中 "=~" 表示相匹配，在整条语句中读作 does，"!~" 表示不匹配，在整条语句中读作 doesn't），并在左侧有待处理的标量变量。如果没有该变量和 =~ !~ 操作符，则默认为处理 $_ 变量中的内容。举例如下：

$str = "I love Perl";

$str =~ m/Perl/; # 表示如果在 $str 中发现 "Perl" 字符串，则返回 "1" 否则返回 "0"。

$str =~ s/Perl/BASH/; # 表示将变量 $str 中的 "Perl" 字符串替换为 "BASH"，如果发生此替换则返回 "1"，否则返回 "0"。

$str !~ tr/A-Z/a-z/; # 表示将变量 $str 中的所有大写字母转化为小写字母，如果转化发生了则返回 "0"，否则返回 "1"。

另外还有：

foreach (@array) { s/a/b/; } # 此处每次循环将从 @array 数组中取出一个元素存放在 $_ 变量中，并对 $_ 进行替换处理。

while (<FILE>;) { print if (m/error/); } # 这一句稍微复杂一些，他将打印 FILE 文件中所有包含 error 字符串的行。

Perl 的正则表达式中如果出现 () ，则发生匹配或替换后 () 内的模式被 Perl 解释器自动依次赋给系统 $1, $2 ...... 请看下面的例子：

$string = "I love perl";

$string =~ s/(love)/<$1>;/; # 此时 $1 = "love"，并且该替换的结果是将 $string 变为 "I <love>; perl"

$string = "i love perl";

$string =~ s/(i)(.*)(perl)/<$3>;$2<$1>;/; # 这里 $1 = "i"，$2 = " love "，$3 = "perl"，并且替换后 $string 变为 "<perl>; love <i>;"

替换操作 s/<pattern>;/<replacement>;/ 还可以在末尾加上 e 或 g 参数，他们的含义分别为：

s/<pattern>;/<replacement>;/g 表示把待处理字符串中所有符合 <pattern>; 的模式全部替换为 <replacement>; 字符串，而不是只替换第一个出现的模式。

s/<pattern>;/<replacement>;/e 表示将把 <replacemnet>; 部分当作一个运算符，这个参数用的不多。

比如下面的例子：

$string = "i:love:perl";

$string =~ s/:/*/; #此时 $string="i*love:perl";

$string = "i:love:perl";

$string =~ s/:/*/g; #此时 $string="i*love*perl";

$string =~ tr/*/ /; #此时 $string="i love perl";

$string = "www22cgi44";

$string =~ s/(/d+)/$1*2/e; # (/d+)代表 $string 中的一个或多个数字字符，将这些数字字符执行 *2 的操作，因此最后 $string 变成了 "www44cgi88"。

下面给出一个完整的例子：

#!/usr/bin/perl

print"请输入一个字符串!/n";

$string = <STDIN>;; # <STIDN>;代表标准输入，会让使用者输入一字符串

chop($string); # 将$string最后一个换行的字符/n删除掉

if($string =~ /perl/){

　　print("输入的字符串中有 perl 这个字符串!/n";

}

如果输入的字符串含有 perl 这个字符串的话，就会显示后面的提示信息。

2. 正则表达式中的常用模式

下面是正则表达式中的一些常用模式。

/pattern/  结果

. 匹配除换行符以外的所有字符

x? 匹配 0 次或一次 x 字符串

x* 匹配 0 次或多次 x 字符串，但匹配可能的最少次数

x+ 匹配 1 次或多次 x 字符串，但匹配可能的最少次数

.* 匹配 0 次或一次的任何字符

.+ 匹配 1 次或多次的任何字符

{m} 匹配刚好是 m 个的指定字符串

{m,n} 匹配在 m个以上 n个以下的指定字符串

{m,} 匹配 m个以上的指定字符串

[] 匹配符合 [] 内的字符

[^] 匹配不符合 [] 内的字符

[0-9] 匹配所有数字字符

[a-z] 匹配所有小写字母字符

[^0-9] 匹配所有非数字字符

[^a-z] 匹配所有非小写字母字符

^ 匹配字符开头的字符

$ 匹配字符结尾的字符

/d 匹配一个数字的字符，和 [0-9] 语法一样

/d+ 匹配多个数字字符串，和 [0-9]+ 语法一样

/D 非数字，其他同 /d

/D+ 非数字，其他同 /d+

/w 英文字母或数字的字符串或下划线，和 [a-zA-Z0-9_] 语法一样

/w+ 和 [a-zA-Z0-9]+ 语法一样

/W 非英文字母或数字的字符串，和 [^a-zA-Z0-9] 语法一样

/W+ 和 [^a-zA-Z0-9]+ 语法一样

/s 空格，和 [/n/t/r/f] 语法一样

/s+ 和 [/n/t/r/f]+ 一样

/S 非空格，和 [^/n/t/r/f] 语法一样

/S+ 和 [^/n/t/r/f]+ 语法一样

/b 匹配以英文字母,数字为边界的字符串

/B 匹配不以英文字母,数值为边界的字符串

a|b|c 匹配符合a字符或是b字符或是c字符的字符串

abc 匹配含有 abc 的字符串

(pattern) () 这个符号会记住所找寻到的字符串，是一个很实用的语法。第一个 () 内所找到的字符串变成 $1 这个变量或是 /1 变量，第二个 () 内所找到的字符串变成 $2 这个变量或是 /2 变量，以此类推下去。

/pattern/i i 这个参数表示忽略英文大小写，也就是在匹配字符串的时候，不考虑英文的大小写问题。

/ 如果要在 pattern 模式中找寻一个特殊字符，如 "*"，则要在这个字符前加上 / 符号，这样才会让特殊字符失效

下面给出一些例子：

范例说明

/perl/ 找到含有 perl 的字符串

/^perl/ 找到开头是 perl 的字符串

/perl$/ 找到结尾是 perl 的字符串

/c|g|i/ 找到含有 c 或 g 或 i 的字符串

/cg{2,4}i/ 找到 c 后面跟着 2个到 4个 g ，再跟着 i 的字符串

/cg{2,}i/ 找到 c 后面跟着 2个以上 g ，再跟着 i 的字符串

/cg{2}i/ 找到 c 后面跟着 2个 g，再跟着 i 的字符串

/cg*i/ 找到 c 后面跟着 0个或多个 g ，再跟着 i 的字符串，如同/cg{0,}i/

/cg+i/ 找到 c 后面跟着一个以上 g，再跟着 i 的字符串，如同/cg{1,}i/

/cg?i/ 找到 c 后面跟着 0个或是 1个 g ，再跟着 i 的字符串，如同/cg{0,1}i/

/c.i/ 找到 c 后面跟着一个任意字符，再跟着 i 的字符串

/c..i/ 找到 c 后面跟着二个任意字符，再跟着 i 的字符串

/[cgi]/ 找到符合有这三个字符任意一个的字符串

/[^cgi]/ 找到没有这三个字符中任意一个的字符串

//d/ 找寻符合数字的字符，可以使用//d+/来表示一个或是多个数字组成的字符串

//D/ 找寻符合不是数字的字符，可以使用//D+/来表示一个或是更多个非数字组成的字符串

//*/ 找寻符合 * 这个字符，因为 * 在常规表达式中有它的特殊意思，所以要在这个特殊符号前加上 / 符号，这样才会让这个特殊字符失效

/abc/i 找寻符合 abc 的字符串而且不考虑这些字符串的大小写

3. 正则表达式的八大原则

　　如果在 Unix 中曾经使用过 sed、awk、grep 这些命令的话，相信对于 Perl 语言中的正则表达式(Regular Expression)不会感到陌生。Perl 语言由于有这个功能，所以对字符串的处理能力非常强。在Perl语言的程序中，经常可以看到正则表达式的运用，在 CGI 程序设计中也不例外。

　　正则表达式是初学 Perl 的难点所在，不过只要一旦掌握其语法，你就可以拥有几乎无限的模式匹配能力，而且 Perl 编程的大部分工作都是掌握常规表达式。下面给大家介绍几条正则表达式使用过程中的 8 大原则。

　　正则表达式在对付数据的战斗中可形成庞大的联盟——这常常是一场战争。我们要记住下面八条原则：

· 原则1：正则表达式有三种不同形式(匹配(m/ /)，替换(s/ / /eg)和转换(tr/ / /))。

· 原则2：正则表达式仅对标量进行匹配( $scalar =~ m/a/; 可以工作; @array =~ m/a/ 将把@array作为标量对待，因此可能不会成功)。

· 原则3：正则表达式匹配一个给定模式的最早的可能匹配。缺省时，仅匹配或替换正则表达式一次( $a = 'string string2'; $a =~ s/string/ /; 导致 $a = 'string 2')。

· 原则4：正则表达式能够处理双引号所能处理的任意和全部字符( $a =~ m/$varb/ 在匹配前把varb扩展为变量；如果 $varb = 'a' $a = 'as'，$a =~ s/$varb/ /; 等价于 $a =~ s/a/ /; ，执行结果使 $a = " s" )。

· 原则5：正则表达式在求值过程中产生两种情况：结果状态和反向引用： $a=~ m/pattern/ 表示 $a 中是否有子串 pattern 出现，$a =~ s/(word1)(word2)/$2$1/ 则“调换”这两个单词。

· 原则6：正则表达式的核心能力在于通配符和多重匹配运算符以及它们如何操作。$a =~ m//w+/ 匹配一个或多个单词字符；$a =~ m//d/" 匹配零个或多个数字。

· 原则7：如果欲匹配不止一个字符集合，Perl使用 "|" 来增加灵活性。如果输入 m/(cat|dog)/ 则相当于“匹配字符串 cat 或者 dog。

· 原则8：Perl用 (?..) 语法给正则表达式提供扩展功能。（这一点请同学们课后看相关资料）

想要学习所有这些原则？我建议大家先从简单的开始，并且不断的尝试和实验。实际上如果学会了 $a =~ m/ERROR/ 是在 $a 中查找子串ERROR，那么你就已经比在 C 这样的低层语言中得到了更大的处理能力。