perl入门教程.docx
《perl入门教程.docx》由会员分享，可在线阅读，更多相关《perl入门教程.docx（60页珍藏版）》请在冰豆网上搜索。
perl入门教程
第二节
（1）数字
双精度浮点型
整数浮点数
数字操作符+-*/%**
（2）字符串
Unicode和utf-8
单引号和双引号内的字符串
（3）字符串操作符
连接操作符
重复操作符
（4）数字与字符串之间的转换
Print“123”*3;Print“123s”*3;Print“123s”.3;
（5）Perl的警告信息
Use这个函数用来加载和引用Perl的模块,或者是子程序,
Usewarnings；Print“123s”*3;Print“123s”.3;
Print–wtest.pl
（6）标量变量
容器变量名称不变，存储内容改变美元符号：
$
（7）变量的命名
字母、数字和下划线全部小写
（8）变量的赋值
双目赋值操作符
（9）字符串中的标量变量内插
Print“$c“;print$c:
（10）操作符的优先级与结合性
直接括号搞定
（11）比较操作符和if控制结构While（）{}
== !
=><>=<=
Eqnegtltgele
If（）{}
（12）布尔值0为假其他都为真
（13）获取用户的输入
（14）Chomp（）操作符如果字符串后面有两个换行符？
chomp（）（perl5）会删除\n以及后面的所有内容。
chop（）（perl4）会删除最后一个字符。
（15）Undef值
while（$n<10）{$sum=$sum+1;$n=$n+1;}print$sum;
（16）defined（）函数
defined（）
第三节
（1）标量：
数字字符串
单引号和双引号内的字符串
（6）标量变量
容器变量名称不变，存储内容改变美元符号：
$
（11）if控制结构While（）{}
比较操作符
获取用户的输入
（14）Chomp（）操作符如果字符串后面有两个换行符？
（15）Undef值
（16）defined（）函数
标量——列表（数据）
标量变量——数组（变量）
数组内可以同时包含数字、字符、undef值
数组或列表的索引：
整数，从0开始
数组的索引不是整数？
舍去小数
超过数组尾端的元素进行赋值？
数组的长度无上限，增补的默认为undef
数组里最后一个元素的索引值：
$#aaa
这个数字比数组内元素的个数少1
负数数组索引值：
-1
数组：
@
数组的赋值
@aaa=qw,（）,1..100,@bbb,（@ccc,“abc”,123）
数组的初始值：
（）
变量的初始值：
undef
将一个数组复制到另外一个数组：
列表赋值，
访问数组中的元素：
$aaa[0]=”aaa”;
$aaa和@aaa、$aaa[0]一样吗？
列表直接量：
圆括号内逗号隔开
范围操作符：
..
数组内的元素，可以是表达式和变量
（$aaa,17）（$a+$b,$c+$d）
qw简写：
qw（），简洁，当成单引号qw任何标点符号作为定界符！
/#
qw内的转义字符
列表的赋值
（$a,$b,$c）=（“aaa”,”bbb”,”ccc”）
互换变量（$a,$b）=（$b,$a）
赋值时左右两边变量的个数不相等？
下标超出数组的尾端？
undef值
字符串中的数组内插
数组变量可以放在双引号内，数组各元素自动添加空格分隔，首尾不会添加空格
电子邮件放进双引号内：
转义字符或单引号
数组操作函数：
Perl尽量少用索引，影响速度。
pop和push操作符
新增元素到数组尾端，更高的索引赋值。
pop：
取出数组最后一个元素返回
@aaa=1:
3;
$bbb=pop（@aaa）;@aaa是多少？
$ccc=pop@aaa;@aaa是多少？
pop@aaa;@aaa是多少？
与Chop（） ;区别
Push（@aaa，9）；
Push@aaa，9；不用括号
Push@aaa，1..9；
Push@aaa，@bbb；
Pop和push的操作对象是数组，不是列表。
Shift和unshift操作符
处理最左边，最前边
$a=shift（@aaa）;
$a=shift@aaa;
Unshift（@aaa,5）;
Unshift@aaa,@bbb;
Splice操作符
Push-pop和shift-unshift操作首尾
Splice操作中间的元素
四个参数，后两个可选，必须有两个
第一个是目标数组，第二是开始位置
@aaa=1..5；
@bbb=splice@aaa，2；
删掉了2以后的，并返回
第三个参数：
长度，个数，不是位置
删掉一个片段
第四个参数是要替换的列表，不一定和删除的一样长
可以不删除，制定位置插入
列表和数组
列表是指数据，而数组是其变量名。
可以有一些值（列表）但不属于数组；但
每一个数组标量都有一个列表。
第一个元素的索引为0.
print$fred[0];
$fred[1]="test";
数组中最后一个元素的索引为$#
例如
$rocks[0]="a";
$rocks[1]="b";
$end=$#rocks;
$number_of_rocks=$end+1;
$rocks[$#rocks]="lastone";
或者用-1索引最后一个元素
$rocks[-1]="lastone";
列表
（1,2,3）
（1..100）
（5..1）空列表
qw简写：
qw（fredbarneybettywilmadino）相当于
（"fred","barney","betty","wilma","dino"）
除了用括号作为分界符，还可以用任何标点符号，如：
qw!
fredbarney!
qw[fredbarney]
列表赋值：
（$fred,$barney,$dino）=（"flintstone","rubble",undef）;
可以用来交换两个变量的值
（$fred,$barney）=（$barney,$fred）;
给列表赋值：
（$rocks[0],$rocks[1]）=qw/talcmica/;
或者
@rocks=qw/talcmica/;
@tiny=（）;#空表
@giant=1..1e5; #包含100，000个元素
@stuff=（@giant,undef,@giant）;#包含200，001个元素的表
pop将数组的最后一个元素取出并返回。
@array=5..9;
$fred=pop（@array）;#fred=9，@array现在为（5,6,7,8）
pop@array;#@array现在为（5，6，7）,8被丢弃
push将一个元素加到数组末尾
push（@array,0）;
push@array,8;
push@array,1..10;
@others=qw/90210/;
push@array,@others;
unshift和shift对一个数组的开头进行操作。
@array=qw#dinofredbarney#;
$m=shift（@array）;#$m为"dino",@array为（"fred","barney"）
shift@array;
unshift（@array,5）;
unshift@array,4; #@array为（4，5）；
@others=1..3;
unshift@array,@others;#@array为（1,2,3,4,5）
数组放入双引号的字符串中，其中的数组元素会自动由空格分开。
对email应该这样定义
$email="fred\@bedrock.edu";
$fred="right";
print"thisis$fred[3]\n";
print"thisis${fred}[3]\n";
print"thisis$fred"."[3]\n";
print"thisis$fred\[3]\n";
输出
thisiswrong
thisisright[3]
thisisright[3]
thisisright[3]
foreach控制结构：
foreach$rock（qw/bedrockslatelava/）{
print"onerockis$rock.\n";
}
其中$rock是控制变量，如果修改了控制变量，那么原始列表也被修改。
在循环结束后，控制变量将恢复原来的值。
@rocks=qw/abc/;
$rock="test";
print"$rock\n";
print"@rocks\n";
foreach$rock（@rocks）{
$rock=$rock."o";
}
print"$rock\n";
print"@rocks\n";
结果为：
test
abc
test
aoboco
最常用的默认变量$_
如果在foreach中省略了控制变量，则使用默认变量$_
foreach（1..10）{
print"$_\n";
}
或者
$_="test";
print;
reverse将列表和数组反转
@fred=6..10;
@barney=rever（@fred）;
@wilma=reverse6..10;
@fred=reverse@fred;
sort排序：
大写排在小写前，数字在字符前
标量和列表上下文：
@people=qw/fredbarneybetty/;
@sorted=sort@people; 列表上下文:
barneybettyfred
$number=42+@people; 标量上下文42+3=45
又比如对于reverse，在列表上下文，反转列表；在标量上下文，反转字符串
@backwards=reverseqw/yabbadabbadoo/; 返回doo,dabba,yabba
$backwards=reverseqw/yabbadabbadoo/;返回oodabbadabbay
@wilma=undef;一个元素（undef）
@betty=（）;空数组，无元素
scalar将列表转成标量
print@people,scalar@people;
比如对STDIN，是标量还是列表，也不同。
对于标量，输入一行，回车，就可以
。
对列表，要以ctrl+z来表明结尾，回车。
@lines=;
foreach（@lines）{
print$_."\n";
}
$line=;
print$line;
读入所有行，不包含换行符
chomp（@lines=）;
第四节
赋值：
@aaa=qw,（）,1..100,@bbb,（@ccc,“abc”,123）
qw简写：
qw（），简洁，当成单引号
数组的初始值：
（）
变量的初始值：
undef
访问：
$aaa[0]=”aaa”;
下标超出数组的尾端？
undef值
数组或列表的索引：
整数，从0开始、小数、负数、$#aaa
$aaa和@aaa、$aaa[0]一样吗？
输出：
字符串中的数组内插
数组变量可以放在双引号内，数组各元素自动添加空格分隔，首尾不会添加空格
电子邮件放进双引号内：
转义字符或单引号
数组操作函数：
Perl尽量少用索引，影响速度。
Pop和push
Shift和unshift操作符
Splice操作符
索引表达式
@aaa=qw（abcdefgh）;
Print$aaa[0];
$b=5;$b=”2*5”;
Print$aaa[$b-1];
Foreach控制结构
Foreach$aaa（qw/aaabbbccc/）{
Print$aaa.”\n”;
}
控制变量：
每次迭代，控制变量$aaa从列表中取出一个值。
循环时，控制变量就是列表中本身的值，改变它会改变列表元素的值
$a="123";
@aaa=qw（abcdefgh）;
foreach$a（@aaa）{
print"$a"."\n";
$a=$a.$a;
}
print"@aaa"."\n";
print"$a";
循环结束时，控制变量变回其初始值，如undef
Foreach省略控制变量：
默认$_变量
@aaa=qw（abcdefgh）;
foreach（@aaa）{
print"$_"."\n";
}
Reverse操作符
@aaa=1..4 ;
@bbb=reverse（@aaa） ;
赋值的时候，先算右边，再给左边
Reverse不会修改原来的数组。
@aaa=qw（abcdefgh）;
@bbb=reverse（@aaa）;
print"@aaa"."\n";
print"@bbb"."\n";
Sort操作符：
对字符进行排序
@aaa=（1,5,3,2,4,8）;
@bbb=sort（@aaa）;
print"@aaa"."\n";
print"@bbb"."\n";
each操作符,每次调用，返回数组的两个值，索引和该元素的值
（$aaa,$bbb）=each@aaa
@aaa=qw（abcdefgh）;
（$a,$b）=each@aaa;
print"$a".""."$b"."\n";
（$a,$b）=each@aaa;
print"$a".""."$b"."\n";
打印数组的索引和值
@aaa=qw（abcdefgh）;
while（（$a,$b）=each@aaa）{
print"$a".""."$b"."\n";
}
@aaa=qw（abcdefgh）;
$index=0;
foreach（@aaa）
{
print"$index"."".$_."\n";
$index=$index+1;
}
标量上下文与列表上下文：
同一表达式出现在不同的地方，会有不同的意义。
是数字还是字符，取决于操作符
是标量还是数组，取决于操作符
“12abc”*2，“12abc”.2
数组：
在列表上下文中，会返回列表。
在标量上下文中，会返回个数。
@bbb=Reverse@aaa；
$n=@aaa;
$bbb=Reverse@aaa；
@aaa=qw（123abc）;
$a=reverse@aaa;
print"$a";
强制指定标量上下文
@aaa=qw（abcde）;
printscalar@aaa;
列表上下文中的
$aaa=;
print$aaa;
@aaa=;
print"@aaa";
数组里去掉换行符
@aaa=;
chomp（@aaa）;
print"@aaa";
第五节
为什么要子程序：
继承、代码重复利用、定义自己的函数。
定义子程序：
sub子程序名{}
subprint_value{
$a=$a+1;
print$a;
}
子程序可定义在程序的任意位置，不需要对子程序进行声明，子程序的定义是全局的。
子程序重名时，后面的会覆盖掉前面的。
警告会提醒。
目前为止，所有的变量都是全局的。
调用子程序：
&+子程序名
$a=10;
&print_value;
subprint_value{
$a=$a+1;
print$a;
}
返回值：
所有的perl都有一个返回值，最后的一个运算结果就是返回值，小心最后一行代码
$a=10;
print3*&print_value;
subprint_value{
$a=$a+1;
}
$a=10;
print3*&print_value;
subprint_value{
$a=$a+1;
print"5"."\n";
}
最后一个print，输出是1，表示成功输出。
最大值：
$value_1=10;
$value_2=5;
print&max_value;
submax_value{
if（$value_1>$value_2）{
$value_1
}else{
$value_2;
}
}
参数：
&max_value（10,25）
特殊的数组变量：
@_，
第一个参数$_[0]，第二个参数$_[1]，（与$_无关，$aaa与$aaa[0]区别？
）
print&max_value（10,25）;
submax_value{
if（$_[0]>$_[1]）{
$_[0]
}else{
$_[1];
}
}
print&max_value（10,25,100）;
print&max_value（10）;
私有变量：
@_
子程序的私有变量：
防止和其他变量冲突
print&max_value（10,25）;
submax_value{
my（$a,$b）;
（$a,$b）=@_;
if（$a>$b）{$a;}else{$b;}
}
my（$a,$b）=@_;子程序第一行，命名和赋值
变长参数列表：
print&max_value（10,25,100）;
submax_value{
if（@_!
=2）{print"warning";}else{
my（$a,$b）=@_;
if（$a>$b）{
$a;
}else{
$b;
}
}
}
print&max_value（10,25,100,1,1000）;
submax_value{
my（$a）=shift@_;
foreach（@_）{
if（$_>$a）{$a=$_;}
}
$a;}
空参数列表
my变量的其他用法：
用在程序里，封装变量，防止出错。
my（$a）=@_;
my$a=@_;
@a=（1,2,3,4,5）;
my（$a）=@a;
print"$a"."\n";
my$a=@a;
print"$a"."\n";
my$a,$b;
my（$a,$b）;
my@a;
foreachmy$a（@aaa）{}
usestrict编译命令
usestrict;
@a=（1,2,3,4,5）;
my（$a）=@a;
print"$a"."\n";
my$a=@a;
print"$a"."\n";
新变量必须用my
usestrict;
my$ab=1;
$a_b=$ab+1;
print$ab;
return操作符：
程序停止并返回值
usestrict;
my@name=qw（chydttzxlyzjwy）;
my$output=&find_name（"wyy",@name）;
print$output;
subfind_name{
my（$input,@name_list）=@_;
foreach（@name_list）{
if（$inputeq$_）{return$input;}
}
return"no";
}
省略与号：
不要把定义子程序放在调用语句的后面
防止与内置的函数重名
非标量返回值，子程序可以返回数组
usestrict;
print&return_array（1,5）;
subreturn_array{
my（$a,$b）=@_;
if（$a<$b）{return$a..$b;}
}
持久性私有变量：
state
usestrict;
use5.010;
subreturn_array{
state$n=0;
$n=$n+1;
print$n;
}
&return_array;
&return_array;
第六节
为什么要子程序：
继承、代码重复利用、定义自己的函数。
定义子程序：
sub子程序名{}
subprint_value{
$a=$a+1;
print$a;
}
调用子程序：
&+子程序名
返回值：
所有的perl都有一个返回值，最后的一个运算结果就是返回值，小心最后一行代码
最后一个print，输出是1，表示成功输出。
参数：
&max_value（10,25）
特殊的数组变量：
@_，
第一个参数$_[0]，第二个参数$_[1]
变长参数列表：
空参数列表
子程序的私有变量：
防止和其他变量冲突
my（$a,$b）=@_;子程序第一行，命名和赋值
my变量的其他用法：
用在程序里，封装变量，防止出错。
my（$a）=@_;my$a=@_;
@a=（1,2,3,4,5）;
my（$a）=@a;
print"$a"."\n";
my$a=@a;
print"$a"."\n";
usestrict编译命令
usestrict;
@a=（1,2,3,4,5）;
my（$a）=@a;
print"$a"."\n";
my$a=@a;
print"$a"."\n";
新变量必须用my
usestrict;
my$ab=1;
$a_b=$ab+1;
print$ab;
return操作符：
程序停止并返回值
usestrict;
my@name=qw（chydttzxlyzjwy）;
my$output=&find_name（"wyy",@name）;
print$output;
subfind_name{
my（$input,@name_list）=@_;
foreach（@name_list）{
if（$inputeq$_）{return$input;}
}
return"no";
}
省略与号：
不要把定义子程序放在调用语句的后面
防止与内置的函数重名
非标量返回值，子程序可以返回数组
usestrict;
print&return_array（1,5）;
subreturn_array{
my（$a,$b）=@_;
if（$a<$b）{return$a..$b;}
}
持久性私有变量：
state
usestrict;
use5.010;
subreturn_array{
state$n=0;
$n=$n+1;
print$n;
升级会员 