perl基本语法--转载

http://www.cnblogs.com/zhtxwd/archive/2012/03/06/2381585.html

本文介绍从变量类型、操作运算符、控制叙述、子程序、I/O和档案处理、 Regular Expressions、Spectial Variables、Help、函数、总结几个部分介绍perl，只是叙述了一些Perl的基本语法。

一．数据型态(Data type)：
Perl
的数据型态大致分为四种：Scalar（变量）、Scalar Array（数组）、Hash
Array（散列）、References（指针），看起来虽少但用起来却绰绰有余。尤其在写Perl程序时可以不必事先宣告变量，这一点对刚学程序语言
的人甚为方便，不过为了以后程序除错和维护方便，我建议你还是养成事先声明变量的习惯比较好。

1 Scalar（纯量变量）：
纯量变量是Perl里最基本的一种数据型态，它可以代表一个字符、字符串、整数、甚至浮点数，而Perl把它们都看成是一样的东东! 你甚至可以混着用，不可思议吧。例如：
# 井字号开头的后面都是批注。
# 纯量变数以$开头。
# my 是一种宣告变量的方式，它可以使变量区域化。
# 宣告变量时若不加 my 或 local 则Perl会把它当作全域变量使用。
# 习惯上，我们会将字符串用双引号括起来，而数值就不用加引号。
my $x="abc";
my $x=123;
my $x=4.56;

1-1 常用的操作运算符

1)、算术运算符
+(加)、-(减)、*(乘)、/(除)、**(幂)、%(余)、-(负)
（1）求幂（**） 结果不能超出数的范围。当指数为小数时，底数不能为负数，例如：25**1.5=125，(-25)**1.5=?（不成立）
（2）取余（%） 操作数为整数，否则要截取。第二个数不能为0（因为除数不能为0）
（3）负（-） -$a=$a*(-1)
此外，注意当一个字符串参加运算，需要转化为整数时，如果不能转化为整数则值为0。例如：’2’+1=3，’a’+1=1

2)、数字比较运算符
<（小于）、=（等于）、>（大于）、==（等于）、<=（小于等于）、>=（大于等于）、!=（不等于）、<=>（比较）
（1）==：比较运算，比较的结果为真或非零，假或零
（2）<=>：比较运算 例如：$a<=>$b，当$a>$b时，值为1；当$a<$b时，值为-1；当$a==$b时，值为0
（3）自动把操作数转化为整数,不能转化为整数则为0
（4）浮点数不精确，不要把值相近的数比较，否则得到的结果是出乎意料的

3)、字符串比较运算符
lt（小于）、gt（大于）、eq（等于）、le（小于等于）、ge（大于等于）、ne（等于）、cmp（比较）
（1）字符串的比较原则：按照字母表的顺序比较，数字<大写字母<小写字母（a小—z大）
（2）字符串比较的次序：字符串从左到右比较。’azz’<‘bc’（即：首先a与b进行比较，然后z与c进行比较）
（3）当一个串是另一个的前缀时，长度长的为大。例如：dog<doghouse
（4）字符串可以从右向左进位，且是字母数字分别进行
（5）自动把操作数转化为字符串。123 lt 45 => ’123’ lt ’45’
（6）cmp等同于<=>，结果为-1,0, 1
例如：$str1=”a”，$str2=”a“，则print ($str1 cmp $str2) ==> 0
例如：$str1=”a”，$str2=”b”，则print($str1 cmp $str2)===> -1
例如：$str1=”b”，$str2=”a”，则print($str1 cmp $str2)===> 1
（7）空串，0，Undef，这三种情况都为假
例如：如下比较的结果
35 != 30+5     #假
35 == 35.0     #真
'35' eq '35.0'   #假（当成字符串来比较）
'fred'  lt  'barney'  #假
'fred'  lt  'free'      #假
'fred'  eq "fred"    #真
'fred'  eq  "Fred"  #假
'   '  gt  ' '  #真

4)、字符串连接（.）、字符/字符串重复（x）
（1）连接（ “.“），例如：$a=‘a’.’b’;  =>‘ab’
在print时可以直接写print $a$b=>print $a.$b; 但是这两者的原理是不一样的
（2）重复（ “x” ），注意：前后有空格（目的：为了和变量名分开），例如：‘a’  x  5=‘aaaaa’，若重复次数<1，则返回空串
例如："5" x 4，即为："5555"
例如："love" x (4+1)，即为："lovelovelovelovelove"
例如："4.8" x 4，即为："4.84.84.84.8"
例如：6.1 x 3，即为："6.16.16.1"
即：左边是一个字符串，右边是该字符串出现的次数

5)、逻辑运算符（&&(and)（与）、||(or)（或）、!(not)（非）、xor（异或）
（1）先算左边的值，后算右边的值
（2）&&和and的优先级不同，但除非特殊情况，很难有区别

6)、位操作运算符
&（按位与）、 |（按位或）、 ~（按位非）、 ^（按位异或）、 <<（左移）、>>（右移）
（1）操作数为二进制整数，如果是小数则截取为整数
（2）<<左移，移开后空位补0，值为原数值的2*N倍（例如：z<<4，则z=z*（2的4次方））
（3）>>右移，首位补0，值为原值一半（并取整）（例如：z>>4，则z=z/（2的的次方））

7)、赋值运算符
=、+=、-=、*=、/=、%=、**=、&=、|=、^=、.=
（1）$a+=1=>$a=$a+1
（2）可以连等$a=$b=3;=>$a=3;$b=3;
（3）混用 ($a=$b)+=3;=>$a=$b;$a=$a+3;（不建议使用）

8)、自增（++）、自减（--）
（1）不要在变量两边都使用此种操作符：++$var--
（2）不要在变量自增/减后在同一表达式中再次使用：$var2 = $var1 + ++$var1;
（3）可用于字符串的自增，当z、Z、9时进位。$a=‘caz’; $a++; ==> $a=‘cba’;
（4）不能用于字符串的自减，当$a--时，按数字运算，字符先转化为0再自减
（5）如果字符串含有非字母数字符号，或数字位于字母中时，自增也先化为0再自增
例如：$a=‘ab*c’; $a++;  ==> $a=1;
例如：$a=‘ab5c’; $a++;  ==> $a=1；
（6）预增$b=++$a，$a先自增再赋值，后增$b=$a++；$a先赋值再自增；反之，同理
例如：$a=1; $b=++$a; =>$a=2,$b=2;
例如：$a=1; $b=$a++; =>$a=2,$b=1;
（7）只能用于单一变量，不能对运算后的变量进行。例如：($a+$b)++

9)、逗号（相当于：将两条语句写在一行）
适用范围： 只有当两个语句关联紧密时才使用
例如：$a+=1，$b=$a;  => $a+=1; $b=$a;
例如：$a="ab5c", print $a."\n";

10、条件运算符
条件？ 真：假
（1）三个操作数：先对条件表达式运算，为真时执行：的左边的运算，为假时执行：的右边的运算
例如：$result = $var == 0 ? 14 : 7；
（2）用于简单的条件
（3）条件表达式用在＝的左边
例如：$condvar == 43 ? $var1 : $var2 = 14;
例如：$condvar == 43 ? $var1 = 14 : $var2 = 14;

三、操作符优先级别（ precedence--优先级）
当一个表达式中出现几种不同的运算符，哪个先计算，哪个后计算
例如：$condvar == 43 ? $var1 : $var2 = 14;（先算条件，后算赋值）
例如：$x = $a == $b;（先算关系，后算赋值）
例如：$x == 0 || $y / $x > 5;（先算除，接着算大于、接着算等于，最后算关系或）
例如：$result = 11 * 2 + 6 ** 2 << 2;（先算幂，再算乘，接着算加，再接着算左移，最后算赋值）
（1）一般的优先级如下：自增自减最高，单操作数高于多操作数，数字运算 > 比较运算（数字比较与字符串比较） > 位运算 > 赋值运算 > 逻辑运算
（2）数字运算：幂 > */>+-
（3）比较运算： <（小于）、>（大于）高于（== 与!=）

2 Scalar Array：
Perl数组变量和列表的概念，列表是包含在括号里的一序列的值，可以为任何数值，也可为空，并且列表存贮于Perl数组变量中，与简单变量不同，Perl数组变量以字符"@"打头。

Perl数组变量和列表

一、列表

列表是包含在括号里的一序列的值，可以为任何数值，也可为空，如：

(1,5.3,"hello",2)，空列表：()。

注：只含有一个数值的列表(如：(43.2))与该数值本身(即：43.2)是不同的，但它们可

以互相转化或赋值。

列表例：

(17,$var,"astring")

(17,26<<2)

(17,$var1+$var2)

($value,"Theansweris$value")

二、Perl数组--列表的存贮

列表存贮于Perl数组变量中，与简单变量不同，Perl数组变量以字符"@"打头，如：

@array=(1,2,3);

注：

(1)Perl数组变量创建时初始值为空列表：()。

(2)因为PERL用@和$来区分Perl数组变量和简单变量，所以同一个名字可以同时用于Perl

数组变量和简单变量，如：

$var=1;

@var=(11,27.1,"astring");

但这样很容易混淆，故不推荐。

1、Perl数组的存取

◆对Perl数组中的值通过下标存取，第一个元素下标为0。试图访问不存在的Perl数组元

素，则结果为NULL，但如果给超出Perl数组大小的元素赋值，则Perl数组自动增长，原

来没有的元素值为NULL。如：

@array=(1,2,3,4);

$scalar=$array[0];

$array[3]=5;#now@arrayis(1,2,3,5)

$scalar=$array[4];#now$scalar=null;

$array[6]=17;#now@arrayis(1,2,3,5,"","",17)

◆Perl数组间拷贝

@result=@original;

◆用Perl数组给列表赋值

@list1=(2,3,4);

@list2=(1,@list1,5);#@list2=(1,2,3,4,5)

◆Perl数组对简单变量的赋值

(1)@array=(5,7,11);

($var1,$var2)=@array;#$var1=5,$var2=7,11被忽略

(2)@array=(5,7);

($var1,$var2,$var3)=@array;#$var1=5,$var2=7,$var3=""(null)

◆从标准输入(STDIN)给变量赋值

$var=<STDIN>;

@array=<STDIN>;#^D为结束输入的符号

2、字符串中的方括号和变量替换

"$var[0]"为Perl数组@var的第一个元素。

"$var\[0]"将字符"["转义，等价于"$var"."[0]"，$var被变量替换，[0]保持不变。

"${var}[0]"亦等价于"$var"."[0]"。

"$\{var}"则取消了大括号的变量替换功能，包含文字：${var}.

3、列表范围：

(1..10)=(1,2,3,4,5,6,7,8,9,10)

(2,5..7,11)=(2,5,6,7,11)

(3..3)=(3)

◆用于实数

(2.1..5.3)=(2.1,3.1,4.1,5.1)

(4.5..1.6)=()

◆用于字符串

("aaa".."aad")=("aaa","aab","aac","aad")

@day_of_month=("01".."31")

◆可包含变量或表达式

($var1..$var2+5)

◆小技巧：

$fred="Fred";

print(("Hello,".$fred."!\n")x2);

其结果为：

Hello,Fred!

Hello,Fred!

4、Perl数组的输出：

(1)@array=(1,2,3);

print(@array,"\n");

结果为：

123

(2)@array=(1,2,3);

print("@array\n");

结果为：

123

5、列表/Perl数组的长度

当Perl数组变量出现在预期简单变量出现的地方，则PERL解释器取其长度。

@array=(1,2,3);

$scalar=@array;#$scalar=3,即@array的长度

($scalar)=@array;#$scalar=1,即@array第一个元素的值

注：以Perl数组的长度为循环次数可如下编程：

$count=1;

while($count<=@array){

print("element$count:$array[$count-1]\n");

$count++;

}

6、子Perl数组

@array=(1,2,3,4,5);

@subarray=@array[0,1];#@subarray=(1,2)

@subarray2=@array[1..3];#@subarray2=(2,3,4)

@array[0,1]=("string",46);#@array=("string",46,3,4,5)now

@array[0..3]=(11,22,33,44);#@array=(11,22,33,44,5)now

@array[1,2,3]=@array[3,2,4];#@array=(11,44,33,5,5)now

@array[0..2]=@array[3,4];#@array=(5,5,"",5,5)now

可以用子Perl数组形式来交换元素：

@array[1,2]=@array[2,1];

7、有关Perl数组的库函数

(1)sort--按字符顺序排序

@array=("this","is","a","test");

@array2=sort(@array);#@array2=("a","is","test","this")

@array=(70,100,8);

@array=sort(@array);#@array=(100,70,8)now

(2)reverse--反转Perl数组

@array2=reverse(@array);

@array2=reversesort(@array);

(3)chop--Perl数组去尾

chop的意义是去掉STDIN（键盘）输入字符串时最后一个字符--换行符。而如果它作用到Perl数组上，则将Perl数组中每一个元素都做如此处理。

@list=("rabbit","12345","quartz");

chop(@list);#@list=("rabbi","1234","quart")now

(4)join/split--连接/拆分

join的第一个参数是连接所用的中间字符，其余则为待连接的字符Perl数组。

$string=join("","this","is","a","string");#结果为"thisisastring"

@list=("words","and");

$string=join("::",@list,"colons");#结果为"words::and::colons"

@array=split(/::/,$string);#@array=("words","and","colons")now

3 Hash Array(Associative Array)：
perl hash 常见用法
基本用法
#
初始化 %h为空数组%h = {};# 用数组初始化%h为 a=>1, b=>2%h = ('a', 1, 'b', 2);#
意义同上，只是另一种更形象化的写法。%h = ('a'=>1,
'b'=>2);#如果key是字符串，可以省略引号。下面这行和上面那行是一样的%h = (a=>1, b=>2);#
用{}来访问print &quot;$h{a}\n&quot;; # 打印1$h{b} = '2b';print
&quot;$h{b}\n&quot;; # 打印2b# 删除key用deletedelete $h{b}; #
从$h删除'b'
清空hash
undef %h

得到hash的所有键值
# 得到所有keys，顺序取决于hash函数，或者说是乱序
@all_keys = keys %h;
# 所有键值，是按hash的值从大往小排列的。值的比较是数字比较(比如说，10>9)
@all_keys = sort{$h{$b}&lt;=>$h{$a}} (keys %h);
# 所有键值，是按hash的值从小往大排列的。值的比较是数字比较
@all_keys = sort{$h{$a}&lt;=>$h{$b}} (keys %h);
# 所有键值，是按hash的值从小往大排列的。值的比较是字符串比较（比如说，'10' &lt; '9'）
@all_keys = sort{$h{$a} cmp $h{$b}} (keys %h);

判断hash是否包含key
exists($h{$key});

Hash的长度
想要知道一个hash存放多少数据
$hash_size = keys %h
# 把%h的长度放到$hash_size中
print scalar kes %h, &quot;\n&quot;
# 打印%h的长度。这里用了scalar来返回数组长度。

遍历一个hash
while (my ($k, $v) = each %h) {print &quot;$k ---> $v\n&quot;;}

Reference引用
Reference类似于C/C++的指针
$h_ref = \%h;
# 获得一个hash的reference%aHash = %{$h_ref};
# 把hash reference当成hash用$value = $h_ref->{akey}
# 这个和%h{akey}是一样的

传递hash到函数
一般都是传递一个reference到函数

%h = ();$h{a}=1;foo(\%h)print $h{b}, &quot;\n&quot;;
# 打印出2。
这个值来自于函数foo() sub foo {my ($h) = @_;print $h->{a}, &quot;\n&quot;;
# 打印出1$h->{b} = 2;}

函数返回hash，或者hash引用(hash reference)
函数可以返回hash
sub foo {my %fh;$fh{a} = 1;return %h;} my %h = foo();print

二控制结构(Control Statements)
1 选择 if结构
Perl的条件控制叙述和C语言很像，让使用者很快就能掌握它。不过Perl比C语言又另外多了些实用的语法，我用底线标出来，大家一看便知。

# Expression 就是条件叙述式，Perl和C一样没有定义布尔数据型态(Boolean datatype)，
# 因此 0 是false、非0 是ture。另外要注意字符串运算子和数值运算子要分清楚哦。
# Code Segment 就是用大括号括起来的一堆指令，也就是一个Block。
if (Expression) {Code Segment}
if (Expression) {Code Segment} else {Code Segment}
if (Expression) {Code Segment} elsif (Expression) {Code Segment} else {CodeSegment}
# elsif 就是 else if
# 如果指令(statement)只有一项，我们可以使用倒装句法，看起来比较简洁。
statement if (Expression);
# unless 就是if not
statement unless (Expression);例：
print "HELLO!\n" if ($name eq "friend");
$x-=10 if ($x == 100);
看吧! C 语言有的Perl大部分都有，学过 C 的人可以毫不费力的学会Perl。

2循环结构
Perl的循环控制叙述也和C语言很像，当然，照例Perl也另外多了些实用的语法：
# 注意：纯量变数前面要加个 $ 字号，这一点和C语言不一样哦。
for($i=0; $i<=10; $i++) {Code Segment}

# foreach 是承袭UNIX的shell script来的，
# 第一个自变量是纯量变数，第二个自变量要用括号括起来，里面是一个纯量数组，
# 顾名思义它就是把数组中的每个元素依序传给第一个自变量，直到全部传完。
# 它和 for($i=0; $i<=$#array; $i++) 用法虽然不同，但目的都是要取出数组的每个元素。
foreach $i (@array) {Code Segment}
# 其实在Perl中，for和foreach是可以混着用的，就看个的人习惯了。
# 下面这行就等于上面第一个叙述，不过简洁多了，大家可以试着用用看。
for $i (0..10) {Code Segment}

# while控制循环和后置循环。
while($i<=10) {Code Segment}
do {Code Segment} while(Expression);
# Perl也有和C语言的break和continue一样的指令，Perl叫它做 last 和 next (较口语化)。
# last是跳出现在所在的循环，next则是跳过下面的指令直接执行下一次的循环。
while(chomp($i=)) {
next if ($i == 5);
last unless ($i > 10);
}

Perl 还有提供label(标记)的语法，也就是goto
指令，不过有经验的programer并不喜欢用它，我也不建议大家使用，所以就此按下不讲。有兴趣的人请自行查阅。还有一点值得注意的是Perl没有提
供像C语言一样的 switch 叙述，不过Perl的pattern match的功能非常强，所以我建议你直接用 if else 叙述来做就好了。

3子程序(Subroutines)
(a) Syntax: sub NAME {Code}
(b) 呼叫子程序： &NAME(para1, para2,...)
(c) 参数传递：@_
Perl
和C一样是采用Call by
value的方式，不过因为Perl不用事先宣告变量，所以建立子程序的时候也不用宣告要传递什么参数。当主程序在传递参数给子程序时，Perl会把括号
括起来的参数按顺序放在一个特殊的全域变量 @_ 数组中，然后子程序就可以随意使用数组 @_ 里的参数，例如 $_[0] 是第一个参数，
$_[1] 是第二个，或是用 my($a1,$a2,$a3,...) = @_;来取出各个参数，当然 my @arg=@_; 或 my
%arg=@_;
也是可以的。由于Perl的语法非常活泼，使得程序在维护时特别棘手，因此写批注成为一项很重要的工作。我建议你最好在每个子程序前面加上对这段子程序的
描述，特别是需要传递的参数要注明清楚。
(d) Variable Localization：my or local
通常我们在程序中定义的变量都是全域变量，所以在子程序中若要把变量区域化则要加上 my 或 local 关键词，例如：my $x=3;，若子程序所用的变量名不小心和主程相同，Perl会以目前正在执行的子程序里的变量为优先。

4 I/O和档案处理
(a) Syntax:
open(FILEHANDLE,"Expression");
close(FILEHANDLE);
这里的Expression是一个叙述加上文件名称，若Expression只有文件名称没有加上叙述，则预设是只读。Expressions叙述如下：

Expression    Effect
open(FH, " filename")
open(FH, "+filename")
open(FH, ">filename")      Opens filename for writing.
open(FH, "+>filename")    Opens filename for both reading and writing.
open(FH, ">>filename")    Appends to filename.
open(FH, "command|")     Runs the command and pipes its output to thefilehandle.
open(FH, "command|")     Pipes the output along the filehandle to thecommand.
open(FH, "-")     Opens STDIN.
open(FH, ">-")     Opens STDOUT.
open(FH, "<&=N") Where N is a number, this performs the equivalent of C'sfdopen for reading.
open(FH, ">&=N")  Where N is a number, this performs the equivalent of C'sfdopen for writing.
例：
# 开启$filename这个档案，若开启失败则印出die后面的讯息，并结束程序。
open(FILE, $filename) || die "Can't open file $filename : $!\n";

# 下面是一个十分精简的写法，和 while($_=){print "$_";} 是等效的。
print while();

# 档案开启后要记得随手关闭，这才是写程序的好习惯。
close(FILE);

# $!和$_都是Perl的特殊变数，下面会介绍的。

(b) Input：
Perl没有特别用来输入的函数，因为Perl在执行程序时，会自动开启标准输入装置，其filehandle定为STDIN，所以在Perl中要输入数据的方法就是使用：

# Perl不会自动去掉结尾的CR/LF，跟C语言不同，所以要用chomp函数帮你去掉它。
# 大家常常会忘记这个动作，导致结果跟你想的不一样，要特别注意一下。
$input=<STDIN>; chomp $input;
# 下面是较简洁的写法。
chomp($input=<STDIN>);

(c) Output：print "variables or 字符串";
Perl也有printf()函数，语法和C语言一模一样，我就不多做介绍了。Perl另外有个print函数，比printf()更方便、更好用，包你爱不释手。Output不外乎是输出到屏幕或档案，用例子来说明比较容易了解。

# 不用再指定变量的data type，这样不是比printf()方便多了吗?
print "Scalar value is $x\n";

# . 是字符串加法的运算子，上下这两行是等效的。
print "Scalar value is " . $x . "\n";

# 输出到档案的方法。
print FILE "print $x to a file.";

# 下面是print的特殊用法，学自shell script的用法：
print<XXX

这招叫做 here document，XXX可以是你取的任何标识符，在标识符之间的字都会按照你所写的样子输出，就像\标签一样。而当一行的开头是XXX你取的这个标识符时，才会停止输出。
XXX

Perl 也有和 C 一样以 "\" 开头的特殊字符：
\t    tab
\n    newline
\r    return
\f    form feed
\b    backspace
\a    alarm(bell)
\e    escape
\033  octalchar
\x1b  hex char
\c[   control char
\l    lowercase next char
\u    uppercase next char
\L    lowercase till \E
\U    uppercase till \E
\E    end case modification
\Q    quoteregexp metacharacters till \E

另外需要说明的是 Perl 融合了unix shell
script的使用惯例，以双引号("")括起来的字符串会先经过展开，但反斜线(\)后面的字符则不展开，当作一般字符看待。而以单引号('')括起来
的字符串完全不会展开，以反单引号(``)括起来的字符串会把它当作命令列指令一样执行，等于system()一样。初学者常常会搞混，但习惯之后就会觉
得不这样分清楚反而不行哩，举个例吧：
$x="ls -l";
print "$x";             # Output ls -l
print "\$x";            # Output $x
print '$x';             # Output $x
print `$x`;             # Output files in this directory

函数
1. Perl函数
通过 & 调用.

2. Perl参数
Perl天然支持可变数目个参数。
在函数内部，所有参数按顺序放在数组 @_ 中，在函数内部，$_[0] 表示函数的第一个

参数，其余类推。

3. shift
shift 后跟一个数组，表示将数组的第一个值返回。数组也被改变，其第一个元素被弹

出。

演示代码一(求最大值):
#!/usr/bin/perl -w
use strict;
# 调用函数max，取得一组数值的最大值,并输出。
my $maxCnt = &max(11,22,33);
print "maxCnt=$maxCnt\n";

sub max {
# 采用遍历算法。先将参数中的第一个值赋给$currentMaxCnt。
# @_ 是默认的包含本函数所有参数 [如(11,22,33)]的数组。
# shift @_ 有两个结果: 1. 将数组 @_ 中的第一个值做为返回值(赋给了

$currentMaxCnt). 2. 将@_数组第一个值弹出[此后@_的值变为(22,33)].
my $currentMaxCnt = shift @_;
# 函数中使用shift时，@_可以省略。上面代码也可以写成这样。
#  my $currentMaxCnt = shift;

# 遍历整个@_数组。
foreach ( @_ ) {
# $_ 表示数组@_中当前被遍历到的元素.
if ( $_ > $currentMaxCnt ) {
# 如果发现当前数组元素比$currentMaxCnt大，那就将$currentMaxCnt重新赋值为当前

元素。
$currentMaxCnt = $_;
}
}
# 函数返回值为标量$currentMaxCnt.
return $currentMaxCnt;
}

演示代码二(求和):
#!/usr/bin/perl -w
use strict;

# 求一组数的和并打印。
my $s1 = &sumvar(11,22,33);
my $s2 = &sumarg(22,33,44);
my $s3 = &sumgod(11,22,33,44,55);
print "s1=$s1, s2=$s2, s3=$s3\n";

# 办法1
sub sumvar {
# 将参数数组的前三个元素值相应地赋给($first, $second, $third)
(my $first, my $second, my $third) = @_;
# 返回其和值。缺点: 如果是求四个参数的和，依然只能给出前三个的和。
return $first + $second + $third;
}

# 办法2
sub sumarg {
# $_[0] 表示参数数组@_的第一个元素。其余类推。
my $first = $_[0];
my $second = $_[1];
my $third = $_[2];
# 返回其和值。缺点: 同sumvar. 只是通过这里学习 $_[0] 这种用法。
return $first + $second + $third;
}

# 办法3, 参数可以任意多。都能求其和。
sub sumgod{
my $s = shift @_;
foreach ( @_ ) {
$s = $s + $_;
}
# 同前面函数max。
return $s;
}

8总结
整理了一下自己觉得用的比较多的一些符号、用法、函数、库之类的，这些都是很基本

的，但是“背熟”了，对提高效率会很有帮助。

数据操作
* $ - 声明与引用用一个scalar的变量
* @ - 声明与引用一个list，但是当访问一个list的成员时，需使用$ListName[index]
* % - 声明与引用一个hash表，但是当访问一个hash的成员时，需要使用$HashName

{key}

特殊变量
* $0 - 当前运行脚本的文件名
* @ARGV - 当前运行脚本的命令行参数列表
* $_ - 默认变量，如循环中的当前变量
* @_ - 函数的输入参数列表
* %ENV - 系统的环境变量
* @INC - Perl的Include路径列表，我们可以往该列表中添加我们自己的目录来方便引

用自定义的库
* $! - 当前系统提示，错误信息
* $^O - 操作系统的名字
* STDIN,STDOUT,STDERR - 输入输出的默认句柄，可以作一定的自定义
* => - 声明一个hash时可以用来明确的表示出key=>value的对应关系
* $^I- 指定备份的文件的后缀名，如此，被修改的文件将会自动以该后缀名保存一个副

本

特殊用法
* &Sub - 调用一个函数，虽然Perl有些规则让你在某些时候可以省略这里的&符号，但

是处于一致性考虑，所以自定义的函数的调用，我一律采用此种方式。
* $# - 用来取得模个数组的最大index, 一般情况下，也可以用-1来表示最后一个元素

的index的
* qw() - 快速声明一个字符串数组，可以省略那些烦人的引号

正则表达式
* $ - 获取被括号捕获的匹配
* $`, $&, $' - 获取匹配的字符串，以及其前后两个部分
* ^,$ - 字符串的始末位置，用作定位

常用函数
* pop, push, shift, unshift, reverse - list的操作函数
* keys，values, exists, each, delete - hash的操作函数
* chomp, split, join, index, substr, sort - 字符串操作函数
* sprintf,printf, print - 格式化输出函数
* system, exec, `` - 系统命令调用函数
* glob, unlink, mkdir, rmdir, rename,chmod,chown, open, close, opendir,

closedir - 文件系统操作函数
* stat, lstat,localtime,gmtime,utime - 文档属性，时间相关函数
* hex, oct - 二进制，八进制，十六进制数转化成十进制的函数
* grep, map - list高级操作函数

这些函数的详细介绍，都可以通过命令：
#perldoc -f functionname
查到

常用库
* File::Basename - 根据path获取文件名或者文件路径
* File::Spec - 根据文件名与路径组合成全路经
* File::Find - 递归遍历某个目录下所有文件
* XML::Simple - 以一个复杂的结构来表示xml文件，使用起来相当方便
* Time::HiRes - 经常用来计算一个操作所耗费的时间
* Getopt::Long - 当脚本需要复杂的输入参数与选项时用到
* Cwd - 拿到当前工作目录
* IO::File - 文件操作
* Win32 - 当需要调用一些Windows API时我会用它