(1)数字
双精度浮点型
整数 浮点数
数字操作符 + – * / % **
(2)字符串
Unicode和utf-8
单引号和双引号内的字符串
(3)字符串操作符
连接操作符
重复操作符
(4)数字与字符串之间的转换
Print “123”*3; Print “123s”*3; Print “123s”.3;
(5)Perl 的警告信息
Use这个函数用来加载和引用Perl的模块,或者是子程序,
Use warnings； Print “123s”*3; Print “123s”.3;
Print –w test.pl
(6)标量变量
容器 变量名称不变，存储内容改变 美元符号：$
(7)变量的命名
字母、数字和下划线 全部小写
(8)变量的赋值
双目赋值操作符
(9)字符串中的标量变量内插
Print “$c”; print $c:
(10)操作符的优先级与结合性
直接括号搞定
(11)比较操作符和if 控制结构 While (){}
== != > < >= <=
Eq ne gt lt ge le
If （）{}
(12)布尔值 0 为假 其他都为真
(13)获取用户的输入<STDIN>
(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 (){}
比较操作符
获取用户的输入<STDIN>
(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]=”last one”;
或者用-1索引最后一个元素
$rocks[-1]=”last one”;
列表
(1, 2, 3)
(1 .. 100)
(5 .. 1)空列表
qw简写：
qw(fred barney betty wilma dino)相当于
(“fred”, “barney”, “betty”, “wilma”, “dino”)
除了用括号作为分界符，还可以用任何标点符号，如：
qw! fred barney !
qw[ fred barney ]
列表赋值：
($fred,$barney,$dino)=(“flintstone”,”rubble”,undef);
可以用来交换两个变量的值
($fred,$barney)=($barney,$fred);
给列表赋值：
($rocks[0],$rocks[1])=qw/talc mica/;
或者
@rocks=qw/talc mica/;
@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/9 0 2 1 0/;
push @array, @others;
unshift和shift对一个数组的开头进行操作。
@array=qw# dino fred barney#;
$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 “this is $fred[3]\n”;
print “this is ${fred}[3]\n”;
print “this is $fred”.”[3]\n”;
print “this is $fred\[3]\n”;
输出
this is wrong
this is right[3]
this is right[3]
this is right[3]
foreach控制结构：
foreach $rock(qw/bedrock slate lava/) {
print “one rock is $rock.\n”;
}
其中$rock是控制变量，如果修改了控制变量，那么原始列表也被修改。
在循环结束后，控制变量将恢复原来的值。
@rocks=qw/a b c/;
$rock=”test”;
print “$rock\n”;
print “@rocks\n”;
foreach $rock(@rocks) {
$rock=$rock.”o”;
}
print “$rock\n”;
print “@rocks\n”;
结果为：
test
a b c
test
ao bo co
最常用的默认变量 $_
如果在foreach中省略了控制变量，则使用默认变量$_
foreach (1..10) {
print “$_\n”;
}
或者
$_=”test”;
print;
reverse将列表和数组反转
@fred=6..10;
@barney=rever(@fred);
@wilma=reverse 6 .. 10;
@fred=reverse @fred;
sort排序：大写排在小写前，数字在字符前
标量和列表上下文：
@people=qw/fred barney betty/;
@sorted=sort @people; 列表上下文:barney betty fred
$number=42+@people; 标量上下文 42+3= 45
又比如对于reverse，在列表上下文，反转列表；在标量上下文，反转字符串
@backwards=reverse qw/yabba dabba doo/; 返回doo, dabba, yabba
$backwards=reverse qw/yabba dabba doo/; 返回oodabbadabbay
@wilma=undef;一个元素(undef)
@betty=();空数组，无元素
scalar将列表转成标量
print @people, scalar @people;
比如对STDIN，是标量还是列表，也不同。对于标量，输入一行，回车，就可以
。对列表，要以ctrl+z来表明结尾，回车。
@lines=<STDIN>;
foreach (@lines) {
print $_.”\n”;
}
$line=<STDIN>;
print $line;
读入所有行，不包含换行符
chomp(@lines=<STDIN>);
第四节
赋值：
@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(a b c d e f g h);
Print $aaa[0];
$b=5; $b=”2*5″;
Print $aaa[$b-1];
Foreach控制结构
Foreach $aaa (qw /aaa bbb ccc/) {
Print $aaa.”\n”;
}
控制变量：每次迭代，控制变量$aaa从列表中取出一个值。
循环时，控制变量就是列表中本身的值，改变它会改变列表元素的值
$a=”123″;
@aaa=qw(a b c d e f g h);
foreach $a (@aaa){
print “$a”.”\n”;
$a=$a.$a;
}
print “@aaa”.”\n”;
print “$a”;
循环结束时，控制变量变回其初始值，如undef
Foreach省略控制变量：默认$_变量
@aaa=qw(a b c d e f g h);
foreach (@aaa){
print “$_”.”\n”;
}
Reverse操作符
@aaa=1..4 ;
@bbb=reverse(@aaa) ;
赋值的时候，先算右边，再给左边
Reverse不会修改原来的数组。
@aaa=qw(a b c d e f g h);
@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(a b c d e f g h);
($a,$b)=each @aaa;
print “$a”.” “.”$b”.”\n”;
($a,$b)=each @aaa;
print “$a”.” “.”$b”.”\n”;
打印数组的索引和值
@aaa=qw(a b c d e f g h);
while (($a,$b)=each @aaa){
print “$a”.” “.”$b”.”\n”;
}
@aaa=qw(a b c d e f g h);
$index=0;
foreach (@aaa)
{
print “$index”.” “.$_.”\n”;
$index= $index+1;
}
标量上下文与列表上下文：同一表达式出现在不同的地方，会有不同的意义。
是数字还是字符，取决于操作符
是标量还是数组，取决于操作符
“12abc”*2，”12abc”.2
数组：
在列表上下文中，会返回列表。
在标量上下文中，会返回个数。
@bbb=Reverse @aaa；
$n=@aaa;
$bbb=Reverse @aaa；
@aaa=qw(123 abc);
$a=reverse @aaa;
print “$a”;
强制指定标量上下文
@aaa=qw( a b c d e);
print scalar @aaa;
列表上下文中的<STDIN>
$aaa=<STDIN>;
print $aaa;
@aaa=<STDIN>;
print “@aaa”;
数组里去掉换行符
@aaa=<STDIN>;
chomp(@aaa);
print “@aaa”;
第五节
为什么要子程序：继承、代码重复利用、定义自己的函数。
定义子程序：sub 子程序名 {}
sub print_value {
$a=$a+1;
print $a;
}
子程序可定义在程序的任意位置，不需要对子程序进行声明，子程序的定义是全局的。
子程序重名时，后面的会覆盖掉前面的。警告会提醒。
目前为止，所有的变量都是全局的。
调用子程序：&+子程序名
$a=10;
&print_value;
sub print_value {
$a=$a+1;
print $a;
}
返回值：所有的perl都有一个返回值，最后的一个运算结果就是返回值，小心最后一行代码
$a=10;
print 3*&print_value;
sub print_value {
$a=$a+1;
}
$a=10;
print 3*&print_value;
sub print_value {
$a=$a+1;
print “5”.”\n”;
}
最后一个print，输出是1，表示成功输出。
最大值：
$value_1=10;
$value_2=5;
print &max_value;
sub max_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);
sub max_value {
if ($_[0]>$_[1]){
$_[0]
} else {
$_[1];
}
}
print &max_value(10,25,100);
print &max_value(10);
私有变量：@_
子程序的私有变量：防止和其他变量冲突
print &max_value(10,25);
sub max_value {
my ($a,$b);
($a,$b)=@_;
if ($a>$b){ $a;} else {$b;}
}
my ($a,$b)=@_;子程序第一行，命名和赋值
变长参数列表：
print &max_value(10,25,100);
sub max_value {
if (@_!=2){print “warning”;}else {
my ($a,$b)=@_;
if ($a>$b){
$a;
} else {
$b;
}
}
}
print &max_value(10,25,100,1,1000);
sub max_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;
foreach my $a (@aaa) {}
use strict编译命令
use strict;
@a=(1,2,3,4,5);
my ($a)=@a;
print “$a”.”\n”;
my $a=@a;
print “$a”.”\n”;
新变量必须用my
use strict;
my $ab=1;
$a_b=$ab+1;
print $ab;
return 操作符：程序停止并返回值
use strict;
my @name=qw(chy dtt zxl yzj wy);
my $output=&find_name(“wyy”,@name);
print $output;
sub find_name {
my ($input,@name_list)=@_;
foreach (@name_list){
if ($input eq $_){ return $input;}
}
return “no”;
}
省略与号：
不要把定义子程序放在调用语句的后面
防止与内置的函数重名
非标量返回值，子程序可以返回数组
use strict;
print &return_array(1,5);
sub return_array {
my ($a,$b)=@_;
if ($a<$b){return $a..$b;}
}
持久性私有变量：state
use strict;
use 5.010;
sub return_array {
state $n=0;
$n=$n+1;
print $n;
}
&return_array;
&return_array;
第六节
为什么要子程序：继承、代码重复利用、定义自己的函数。
定义子程序：sub 子程序名 {}
sub print_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”;
use strict编译命令
use strict;
@a=(1,2,3,4,5);
my ($a)=@a;
print “$a”.”\n”;
my $a=@a;
print “$a”.”\n”;
新变量必须用my
use strict;
my $ab=1;
$a_b=$ab+1;
print $ab;
return 操作符：程序停止并返回值
use strict;
my @name=qw(chy dtt zxl yzj wy);
my $output=&find_name(“wyy”,@name);
print $output;
sub find_name {
my ($input,@name_list)=@_;
foreach (@name_list){
if ($input eq $_){ return $input;}
}
return “no”;
}
省略与号：
不要把定义子程序放在调用语句的后面
防止与内置的函数重名
非标量返回值，子程序可以返回数组
use strict;
print &return_array(1,5);
sub return_array {
my ($a,$b)=@_;
if ($a<$b){return $a..$b;}
}
持久性私有变量：state
use strict;
use 5.010;
sub return_array {
state $n=0;
$n=$n+1;
print $n;
}
&return_array;
&return_array;
打开文件:打开句柄
open函数：两个参数
open （文件句柄，”路径”）
open(MYTEXT, “e:/perl/text.txt”)
关闭文件：关闭句柄
close（MYTEXT）；
die用法：
open(MYTEXT, “e:/perl/text.txt”) || die ;
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open”;
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
读取文件：<>
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
$line=<MYTEXT>;
print $line;
标量变量：一行的输入 $line=<MYTEXT>;
读取和输出整个文件：
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
while (defined($line=<MYTEXT>)){
chomp $line;
print $line;
}
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
while (<MYTEXT>){
print $_;
}
读取并存入数组：
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
@line=<MYTEXT> ;
print “@line”;
print $line[0];
写入文件：
open(MYTEXT,”>路径”) || die “$! \n”;
open(MYTEXT,”>>路径”) || die “$! \n”;
>:原有数据删除，写入新的数据
>>:不删除原有数据，添加到原数据结尾
open(MYTEXT, “>>e:/perl/output.txt”) || die “cannot output:$! \n”;
print MYTEXT “abc”;
close(MYTEXT);
完成了句柄的写入操作后，必须关闭句柄。close（）；写入句柄后并不保存到硬盘，而是在缓存里，关闭表示写入磁盘。
句柄与输出之间没有逗号
print MYTEXT, “abc”;
文件复制程序：
open(INPUT, “e:/perl/text.txt”) || die “cannot output:$! \n”;
open(OUTPUT, “>>e:/perl/output.txt”) || die “cannot output:$! \n”;
while (<INPUT>){
$a=$_;
print OUTPUT $a.$a;
}
文件复制程序2：数组写入文件
open(INPUT, “e:/perl/text.txt”) || die “cannot output:$! \n”;
open(OUTPUT, “>>e:/perl/output.txt”) || die “cannot output:$! \n”;
@a=<INPUT>;
print OUTPUT @a;
open(INPUT, “e:/perl/text.txt”) || die “cannot output:$! \n”;
open(OUTPUT, “>>e:/perl/output.txt”) || die “cannot output:$! \n”;
print OUTPUT <INPUT>;
重要的文件操作函数：split
数组=split(/分隔符/,标量);
@data=split(/\t/,$data);
open(INPUT, “e:/perl/text.txt”) || die “cannot output:$! \n”;
$a=<INPUT>;
@data=split(/ /,$a);
print $data[0];
open(INPUT, “e:/perl/text.txt”) || die “cannot output:$! \n”;
$a=<INPUT>;
@data=split(/!/,$a);
print $data[1];
open(INPUT, “e:/perl/text.txt”) || die “cannot output:$! \n”;
open(OUTPUT,”>e:/perl/output.txt”)|| die “$!”;
$a=<INPUT>;
@data=split(/!/,$a);
foreach (@data) {
$_=$_.$_.”\n”;
print OUTPUT $_;
}
open(INPUT, “e:/perl/aaa.txt”) || die “cannot output:$! \n”;
open(OUTPUT,”>e:/perl/output.txt”)|| die “$!”;
while (<INPUT>) {
$a=$_;
@data=split(/\t/,$a);
if ($data[3]==1){
print OUTPUT $a;
}
}
第七节
打开文件:打开句柄
open函数：两个参数
open （文件句柄，”路径”）
open(MYTEXT, “e:/perl/text.txt”)
open(MYTEXT,”<e:/perl/aaa.txt”);
open(MYTEXT,”<“,”e:/perl/aaa.txt”);
open MYTEXT,”<“,”e:/perl/aaa.txt”;
关闭文件：关闭句柄
close（MYTEXT）；
读取文件：<>
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
$line=<MYTEXT>;
print $line;
标量变量：一行的输入 $line=<MYTEXT>;
读取和输出整个文件：
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
while (defined($line=<MYTEXT>)){
chomp $line;
print $line;
}
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
while (<MYTEXT>){
print $_;
}
读取并存入数组：
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
@line=<MYTEXT> ;
print “@line”;
print $line[0];
写入文件：
open(MYTEXT,”>路径”) || die “$! \n”;
open(MYTEXT,”>>路径”) || die “$! \n”;
>:原有数据删除，写入新的数据
>>:不删除原有数据，添加到原数据结尾
open(MYTEXT, “>>e:/perl/output.txt”) || die “cannot output:$! \n”;
print MYTEXT “abc”;
close(MYTEXT);
$aaa=”OUT.txt”;
open MYTEXT,”<“,”e:/perl/aaa.txt”;
open OUTPUT,”>”,”e:/perl/$aaa”;
while (defined($a=<MYTEXT>)){
chomp $a;
print OUTPUT $a;
}
完成了句柄的写入操作后，必须关闭句柄。close（）；写入句柄后并不保存到硬盘，而是在缓存里，关闭表示写入磁盘。
句柄与输出之间没有逗号
print MYTEXT, “abc”;
来自钻石操作符的输入 <>
e:/perl aaa.txt bbb.txt ccc.txt
open(MYTEXT,”e:/perl”);
while (defined($a=<>)){
chomp $a;
print $a;
}
while(<>){
chomp;
print $_;
}
E:\perl>perl test.pl aaa.txt bbb.txt ccc.txt
调用参数：<>会首先查看@ARGV数组，决定用哪些文件名
open(MYTEXT,”e:/perl”);
@ARGV=qw(aaa.txt bbb.txt ccc.txt);
while (defined($a=<>)){
chomp $a;
print $a;
}
日常应用：同时处理合并多个文件
标准输出print需要注意的地方：
print（） 通常省略括号；
print (2+3)*4;
$result=print (2+3)*4;
print $result;
printf 的格式化输出：百分比符号开头%，
d: decimal
$a=4;
printf “%6d”,$a/3;
printf “%6d”,1000000;
printf “%6s”,”aaa”;
printf “%-6s”,”aaa”;
printf “%.2f”,$a/3;
转换的数目和列表的数目一致
printf “%.2f%%,%d”,$a/3,$a/3;
数组和printf
通常不用数组做print的参数。
用say来输出：默认输出的行尾加换行符
use
5.010;
print “aaa”;
print “aaa”;
say “aaa”;
say “aaa”;
say OUTPUI “aaa”；写入句柄
用die处理致命错误
die用法：
open(MYTEXT, “e:/perl/text.txt”) || die ;
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open”;
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
open (MYTEXT,”<“,”e:/perl/aaaaa.txt”)|| die “$!”;
$!:可读的系统错误信息，解释性的系统错误信息保存在特殊变量$!中。
warnings 不会终止程序，die停止程序。
自动检测致命错误：use autodie；
use autodie;
open (MYTEXT,”<“,”e:/perl/aaaaa.txt”);
标量变量中的文件句柄：
open ($bbb,”<“,”e:/perl/aaa.txt”);
while (defined($a=<$bbb>)){
chomp $a;
print $a;
}
重要的文件操作函数：split
数组=split(/分隔符/,标量);
@data=split(/\t/,$data);
open(INPUT, “e:/perl/text.txt”) || die “cannot output:$! \n”;
$a=<INPUT>;
@data=split(/ /,$a);
print $data[0];
open(INPUT, “e:/perl/text.txt”) || die “cannot output:$! \n”;
$a=<INPUT>;
@data=split(/!/,$a);
print $data[1];
open(INPUT, “e:/perl/text.txt”) || die “cannot output:$! \n”;
open(OUTPUT,”>e:/perl/output.txt”)|| die “$!”;
$a=<INPUT>;
@data=split(/!/,$a);
foreach (@data) {
$_=$_.$_.”\n”;
print OUTPUT $_;
}
open(INPUT, “e:/perl/aaa.txt”) || die “cannot output:$! \n”;
open(OUTPUT,”>e:/perl/output.txt”)|| die “$!”;
while (<INPUT>) {
$a=$_;
@data=split(/\t/,$a);
if ($data[3]==1){
print OUTPUT $a;
}
}
第八节
用die处理致命错误
die用法：
open(MYTEXT, “e:/perl/text.txt”) || die ;
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open”;
open(MYTEXT, “e:/perl/text.txt”) || die “cannot open:$! \n”;
open (MYTEXT,”<“,”e:/perl/aaaaa.txt”)|| die “$!”;
$!:可读的系统错误信息，解释性的系统错误信息保存在特殊变量$!中。
warnings 不会终止程序，die停止程序。
自动检测致命错误：use autodie；
use autodie;
open (MYTEXT,”<“,”e:/perl/aaaaa.txt”);
哈希
数组以数字作为索引，哈希以字符串作为索引。
哈希的索引称为键（key），唯一的字符串。
哈希里没有顺序，存储着键-值对应的集合。
哈希赋值
%home=(‘aaa’,1,’bbb’,5,’ddd’,3,’ccc’,2);
print $home{‘ccc’};
$home{‘ccc’}=100;
print $home{‘ccc’};
%home=(aaa => 1,bbb => 5,ddd => 3,ccc => 2);
print $home{aaa};
哈希的常用函数和用法：
展开哈希：
@aaa=%home;
print “@aaa”;
Reverse 哈希:
%aaa=reverse %home;
@bbb=%aaa;
print “@bbb”;
Keys和values函数
my %home=(aaa => 1,bbb => 5,ddd => 3,ccc => 2);
my @k=keys %home;
my @v=values %home;
print “@k”;
print “\n”;
print “@v”;
my %home=(aaa => 1,bbb => 5,ddd => 3,ccc => 2);
my $k=keys %home;
print “$k”;
each函数
my %home=(aaa => 1,bbb => 5,ddd => 3,ccc => 2);
@aaa=sort keys %home;
print “@aaa\n”;
foreach (@aaa){
$value=$home{$_};
print $_.” “.$value.”\n”;
}
my %home=(aaa => 1,bbb => 5,ddd => 3,ccc => 2);
while (($key,$value) = each %home){
print $key.”\t”.$value.”\n”;
};
my %home=(aaa => 1,bbb => 5,ddd => 3,ccc => 2);
while (($key,$value) = each %home){
if ($key eq “aaa”){
print $key.”\t”.$value.”\n”;
}
};
exists函数
my %home=(aaa => 1,bbb => 5,ddd => 3,ccc => 2);
if (exists $home{‘aaa’}){
print $home{‘aaa’};
}
delete函数和哈希元素内插
第九节
第七章 漫游正则表达式王国
正则表达式（regular expression）在Perl里也叫模式（pattern），表示匹配某个字符串的特征模版。
查看一个字符串，判断他匹配还是不匹配。
使用简单的模式
使用一对斜线//匹配$_中的内容。
$_=”aa bb cc”;
if (/aa/){
print “yes aa!”;
}
模式匹配的返回值通常为真或假，因此广泛用在if while 的条件表达式中。
\p{Space}
\p{Digit}
元字符：正则表达式中特殊含义的字符
点号：.能匹配任意一个字符的通配符，换行符除外。
$_=”abcd defg”;
if (/b.d/){
print “yes”;
}
\. \\：反斜线转义
简单的量词
星号*：匹配它前面的内容零次或多次。
$_=”abcd\t\t\t\tdefg”;
if (/d\t*d/){
print “yes”;
}
.*：匹配任意字符零次到无限次。
$_=”abcdokokokdefg”;
if (/d.*d/){
print “yes”;
}
加号+：匹配它前面的内容一次以上：
$_=”abcd defg”;
if (/d +d/){
print “yes”;
}
问号？：它前面的内容出现一次或没有。
$_=”abcd defg”;
if (/d ?d/){
print “yes”;
}
模式分组
圆括号（）：对字符串分组，也是元字符
/heilongjiang+/
/(Heilongjiang)+/：>=1 or >0
/(Heilongjiang)*/：>=0
/(Heilongjiang)?/：1 or 0
捕获组：利用反向引用来引用括号中模式所匹配的文字，写法为反斜线后面接数字，\1、\2等，相应的数字表示对应顺序的捕获组。
$_=”bcdd”;
if (/(.)\1/){
print “yes”;
}
$_=”okok”;
if (/(ok)\1/){
print “yes”;
}
$_=”youokok meokok”;
if (/you(….) me\1/){
print “yes”;
}
反向引用的分组：
$_=”youokok meokok”;
if (/(.)(.)\1\2/){
print “yes”;
}
反向引用的新写法：
$_=”youoo meokok”;
if (/(.)\111/){
print “yes”;
}
use 5.010;
$_=”youoo meokok”;
if (/(.)\g{1}/){
print “yes”;
}
use 5.010;
$_=”youoo meokok”;
if (/(.)\g{-1}/){
print “yes”;
}
择一匹配：
|”或”：匹配左边或右边的模式
$_=”abc bcd edf”;
if (/bcc|cdc|df/){
print “yes”;
}
$_=”abc bcd edf”;
if (/c( |\t)+b/){
print “yes”;
}
$_=”abc \tbcd edf”;
if (/c( +|\t+)b/){
print “yes”;
}
字符集
方括号[]:一组可能出现的字符，只匹配单个字符，方括号内的任意一个。
[abcdef]中的任意一个
$_=”abc bcd edf”;
if (/[fgg]/){
print “yes”;
}
可以用连字符（-）简写
$_=”abc bcd edf”;
if (/[a-z A-Z]/){
print “yes”;
}
第十节
点号：.能匹配任意一个字符的通配符，换行符除外。
星号*：匹配它前面的内容零次或多次。
.*：匹配任意字符零次到无限次。
加号+：匹配它前面的内容一次以上：
问号？：它前面的内容出现一次或没有。
模式分组
圆括号（）：对字符串分组，也是元字符
/heilongjiang+/
/(Heilongjiang)+/：>=1 or >0
/(Heilongjiang)*/：>=0
/(Heilongjiang)?/：1 or 0
捕获组：利用反向引用来引用括号中模式所匹配的文字，写法为反斜线后面接数字，\1、\2等，相应的数字表示对应顺序的捕获组。
反向引用的新写法：\g{1}
|”或”：匹配左边或右边的模式
字符集
方括号[]:一组可能出现的字符，只匹配单个字符，方括号内的任意一个。
[abcdef]中的任意一个
$_=”abc bcd edf”;
if (/[fgg]/){
print “yes”;
}
可以用连字符（-）简写
$_=”abc bcd edf”;
if (/[a-z A-Z]/){
print “yes”;
}
字符集的简写
\d 匹配一个数字[0-9]
\w 匹配一个字母、数字或下划线字符，相当于[a-zA-Z_0-9]
\s 匹配一个空字符 [\n \t]
\D 非数字
\W 非[a-zA-Z_0-9]
\S 表示匹配非空白字符
$_=”abc bcd edf”;
if (/[\s]/){
print “yes”;
}
用m//进行匹配
m// /() m {} m<>
$_=”abc bcd edf”;
if (m![\s]!){
print “yes”;
}
绑定操作符=~：默认情况下模式匹配的操作对象是$_，=~可以拿右边的模式匹配左边的字符串，而不是$_。
$aaa=”aaa -5.28 aaa”;
if ($aaa=~/aaa/){
print “yes”;
}
模式中的内插：正则表达式内部可进行双引号形式的内插。
$b=”aaa”;
$aaa=”aaa -5.28 aaa”;
if ($aaa=~/$b/){
print “yes”;
}
模式匹配修饰符：追加在模式表达式末尾定界符后面的字母。
/a 按照ASCⅡ码范围匹配字符
/i：大小写无关
$_=”abc bcd edf”;
if (/[A-Z]/i){
print “yes”;
}
/s：匹配任意字符，(.)无法匹配换行符，/s可以匹配包括换行符的任意字符。
$_=”abc\nbcd edf”;
if (/c(.)b/s){
print “yes”;
}
/x 加入空白符 空白符：/s和/t
$_=”aaa -5.28 bbb”;
if (/-? [0-9]+ \.? [0-9]*/x){
print “yes”;
}
$_=”aaa -5.28 bbb”;
if (/-? \d+ \.? \d*/x){
print “yes”;
}
组合选项修饰符：多项修饰符可连在一起，写在模式末尾，不区分顺序。如//six
锚位：在字符串指定位置进行匹配
\A：匹配字符串的绝对开头
$_=”aaa -5.28 bbb”;
if (/\Aa/){
print “yes”;
}
\z：匹配字符串的绝对末尾
$_=”aaa -5.28 bbb”;
if (/b\z/){
print “yes”;
}
\Z：匹配末尾，允许后边出现换行符
$_=”aaa -5.28 bbb\n”;
if (/b\Z/){
print “yes”;
}
/\A\s*\Z/：匹配一个空行，可以包含空白符。
^ $ /m
单词锚位：\b，匹配任何单词的首尾
/\baaa\b/：只能匹配aaa，无法匹配baaa和aaab，类似于整词匹配
\b匹配的是字母、数字、下划线组成的字符串。
$_=”aaa -5.28 aaa”;
if (/\baaa\b/){
print “yes”;
}
/\baaa\B/
捕获变量：圆括号内匹配到的字符串，保存在$1、$2等变量中。
$_=”abc def,ghi”;
if (/\s([a-zA-z]+),/){
print $1;
}
$_=”hello there, neighbor”;
if (/(\S+) (\S+), (\S+)/){
print “$1 $2 $3”;
}
捕获变量的存续期：捕获变量存储到下次成功的匹配为止，为防止覆盖，可存储到其他变量里。
$_=”123″;
if (/([0-9]+)/){
}
if (/([2-3]+)/){
}
print “$1”;
不捕获模式 （？：）
$_=”hello there, neighbor”;
if (/(?:\S+) (\S+), (\S+)/){
print “$1 $2 $3”;
}
命名捕获：
?<key>存储到$+{key}中
use 5.010;
$_=”aaa or bbb”;
if (/(?<str1>\w+) or (?<str2>\w+)/){
print “$+{str1} $+{str2}”;
}
自动捕获变量：$& $` $’
$`：匹配之前的部分
$’：剩下的未匹配的部分
$&：匹配到的部分
$_=”aaa bbb, ccc”;
if (/\s(\w+),/){
print “$&”;
}
通用量词
/a{5,15}/ 匹配出现5到15次a
/a{5, }/ 匹配出现超过5次a
/\w{5}/ 正好5个单词字符的字符串
$_=”aaa bbb, ccc”;
if (/(a{1,4})/){
print “$1”;
}
优先级
第一位 （）
第二位 量词
第三位 锚位和序列
第四位 择一竖线 |
第五位 原子 单独的字符 字符集和数字等
第十一节
点号：.能匹配任意一个字符的通配符，换行符除外。
星号*：匹配它前面的内容零次或多次。
.*：匹配任意字符零次到无限次。
加号+：匹配它前面的内容一次以上：
问号？：它前面的内容出现一次或没有。
\d 匹配一个数字[0-9]
\w 匹配一个字母、数字或下划线字符，相当于[a-zA-Z_0-9]
\s 匹配一个空字符 [\n \t]
\D 非数字
\W 非[a-zA-Z_0-9]
\S 表示匹配非空白字符
用m//进行匹配
m// /() m {} m<>
$_=”abc bcd edf”;
if (m![\s]!){
print “yes”;
}
绑定操作符=~：默认情况下模式匹配的操作对象是$_，=~可以拿右边的模式匹配左边的字符串，而不是$_。
模式中的内插：正则表达式内部可进行双引号形式的内插。
模式匹配修饰符：追加在模式表达式末尾定界符后面的字母。
/a 按照ASCⅡ码范围匹配字符
/i：大小写无关
$_=”abc bcd edf”;
if (/[A-Z]/i){
print “yes”;
}
/s：匹配任意字符，(.)无法匹配换行符，/s可以匹配包括换行符的任意字符。
$_=”abc\nbcd edf”;
if (/c(.)b/s){
print “yes”;
}
/x 加入空白符 空白符：/s和/t
$_=”aaa -5.28 bbb”;
if (/-? [0-9]+ \.? [0-9]*/x){
print “yes”;
}
$_=”aaa -5.28 bbb”;
if (/-? \d+ \.? \d*/x){
print “yes”;
}
组合选项修饰符：多项修饰符可连在一起，写在模式末尾，不区分顺序。如//six
锚位：在字符串指定位置进行匹配
\A：匹配字符串的绝对开头
$_=”aaa -5.28 bbb”;
if (/\Aa/){
print “yes”;
}
\z：匹配字符串的绝对末尾
$_=”aaa -5.28 bbb”;
if (/b\z/){
print “yes”;
}
\Z：匹配末尾，允许后边出现换行符
$_=”aaa -5.28 bbb\n”;
if (/b\Z/){
print “yes”;
}
/\A\s*\Z/：匹配一个空行，可以包含空白符。
^：行首 $：行尾 /m：多行匹配
单词锚位：\b，匹配任何单词的首尾
/\baaa\b/：只能匹配aaa，无法匹配baaa和aaab，类似于整词匹配
\b匹配的是字母、数字、下划线组成的字符串。
$_=”aaa -5.28 aaa”;
if (/\baaa\b/){
print “yes”;
}
/\baaa\B/
捕获变量：圆括号内匹配到的字符串，保存在$1、$2等变量中。
$_=”abc def,ghi”;
if (/\s([a-zA-z]+),/){
print $1;
}
$_=”hello there, neighbor”;
if (/(\S+) (\S+), (\S+)/){
print “$1 $2 $3”;
}
捕获变量的存续期：捕获变量存储到下次成功的匹配为止，为防止覆盖，可存储到其他变量里。
$_=”123″;
if (/([0-9]+)/){
}
if (/([2-3]+)/){
}
print “$1”;
不捕获模式 （？：）
$_=”hello there, neighbor”;
if (/(?:\S+) (\S+), (\S+)/){
print “$1 $2 $3”;
}
命名捕获：
?<key>存储到$+{key}中
use 5.010;
$_=”aaa or bbb”;
if (/(?<str1>\w+) or (?<str2>\w+)/){
print “$+{str1} $+{str2}”;
}
自动捕获变量：$& $` $’
$`：匹配之前的部分
$&：匹配到的部分
$’：剩下的未匹配的部分
$_=”aaa bbb, ccc”;
if (/\s(\w+),/){
print “$&”;
}
通用量词
/a{5,15}/ 匹配出现5到15次a
/a{5, }/ 匹配出现超过5次a
/\w{5}/ 正好5个单词字符的字符串
$_=”aaa bbb, ccc”;
if (/(a{1,4})/){
print “$1”;
}
优先级
第一位 （）
第二位 量词
第三位 锚位和序列
第四位 择一竖线 |
第五位 原子 单独的字符 字符集和数字等
第九章
用正则表达式处理文本
用s///进行替换
s# # # s{}{} s{}()
$aaa =~ s///;
$_=”aaa bbb ccc”;
if (s/aaa/ddd/){
print $_;
}
$_=”aaa bbb ccc”;
if (s/\s(\w+)\s/ $1 $1 /){
print $_;
}
用/g进行全局替换 /g /gsix
$_=”aaa bbb ccc”;
if (s/(\w+) (\w+)/$2 $1/){
print $_;
}
$_=”aaa bbb aaa”;
if (s/aaa/ddd/g){
print $_;
}
替换缩减空白
$_=”aaa bbb \taaa”;
if (s/\s+/ /g){
print $_;
}
去除行首尾空白
$_=” aaa bbb aaa”;
if (s/\A\s+//g){
print $_;
}
$_=” aaa bbb aaa”;
if (s/^\s+//g){
print $_;
}
$_=”aaa bbb aaa “;
if (s/\s+\z//g){
print $_;
}
$_=”aaa bbb aaa “;
if (s/\s+$//g){
print $_;
}
$_=” aaa bbb aaa “;
if (s/^\s+|\s+$//g){
print $_;
}
无损替换
$word=”aaa bbb aaa”;
$word_copy=$word;
$word =~ s/aaa/ddd/g;
print $word.”\n”;
print $word_copy.”\n”;
$word=”aaa bbb aaa”;
($word_copy=$word) =~ s/aaa/ddd/g;
print $word.”\n”;
print $word_copy.”\n”;
$word=”aaa bbb aaa”;
$word_copy=$word=~ s/aaa/ddd/g;
print $word.”\n”;
print $word_copy.”\n”;
$word=”aaa bbb aaa”;
$word_copy=$word=~ s/aaa/ddd/gr;
print $word.”\n”;
print $word_copy.”\n”;
大小写转换
$word=”aaa abcd aaa”;
$word=~ s/aaa (\w+) aaa/\U$1/;
print $word;
$word=”aaa ABCD aaa”;
$word=~ s/aaa (\w+) aaa/\L$1/;
print $word;
$word=”aaa ABCD aaa”;
$word=~ s/aaa (\w+) aaa/\l$1/;
print $word;
$word=”aaa abcd aaa”;
$word=~ s/aaa (\w+) aaa/\u$1/;
print $word;
$word=”aaa abcd aaa”;
$word=~ s/aaa (\w+) (\w+)/\U$1 \E$2/;
print $word;
split函数
$word=”aaa,bbb,ccc”;
@word_1=split(/,/,$word);
print “@word_1”;
$word=”aaa,bbb,,ccc”;
@word_1=split(/,/,$word);
print “@word_1”;
$word=”,,,aaa,bbb,ccc”;
@word_1=split(/,/,$word);
print “@word_1”;
默认的分隔是/\s+/
@word =split；
join函数
$word=”aaa,bbb,ccc,,,”;
@word_1=split(/,/,$word);
print “@word_1\n”;
$word_2=join(“,”,@word_1);
print “$word_2\n”;
列表上下文中的m//
$_=”hello world, I am lucy”;
/(\w+) (\w+),/;
print “$1\n”;
print “$2\n”;
$_=”hello world, I am lucy”;
($a,$b)=/(\w+) (\w+),/;
print “$a\n”;
print “$b\n”;
$_=”hello world, I am lucy”;
@a=/(\w+) (\w+),/;
print “@a\n”;
print “$a[0]\n”;
print “$a[1]\n”;
$_=”hello world, I am lucy”;
%a=/(\w+) (\w+),/;
print $a{hello};
$_=”hello world, I am lucy”;
@a=/(\w+)/g;
$a=@a;
print “@a\n”;
print “$a”;
更强大的正则表达式
非贪婪量词：提高效率
@a=1..100;
$_=”@a”;
print $_.”\n”;
if (/1.+5/){
print “yes”;
}
if (/1.+?5/){
print “yes”;
}
非贪婪量词：更准确的匹配
$_=”aaa bbb ccc ddd”;
($a)=/\s(.*?)\s/;
print $a;
跨行的模式匹配
第十二节
第十章 其他控制结构
unless 控制结构：条件为假的时候才执行代码，类似于else结构
否定操作符 ！
elsif结构：逐一测试条件表达式
if（）{}elsif{}elsif{}else{}
$a=4;
if ($a<3){
print “yes”;
}
$a=4;
if ($a<3){
} else {
print “yes”;
};
$a=4;
if (!($a < 3)){
print “yes”;
};
伴随unless的else字句
unless{}else{}；
until控制结构
until：循环一直执行，直到条件为真。
$a=1;
while ($a<5){
print “yes\n”;
$a=$a+1;
}
$a=10;
until ($a<5){
print “yes\n”;
$a=$a-1;
}
表达修饰符
$n=2;
print “yes” if $n<5;
$n=2;
print ” “, ($n+=1)while $n<5 ;
裸块控制结构
定义只有在{}内起作用的临时变量
my $root=100;
{
my $r=2;
my $root=sqrt $r;
print $root.”\n”;
}
print $root;
自增与自减
$a=$a+1;
$a+=1;
$a++;
$a=$a-1;
$a-=1;
$a–;
自增的值
前置自增：++操作符写在变量前面，先增加后取值
后置自增：++操作符写在变量后面，先取值后增加
$a=1;
$b=1;
$c=++$a;
$d=$b++;
print “$c $d”;
如果不提取值，$a++ 和++$a是一样的。
for控制结构
$sum=0;
for ($i=1;$i<=10;$i++){
$sum=$sum+$i;
}
print $sum;
for ($_=”abcdefg”;s/(.)//;){
print “$1\n”;
}
for ($_=”abcdefg”;;){
print “$1\n”;
}
foreach和for之间的关系
foreach和for是等价的，perl根据圆括号里的内容判断，有两个分号就是for，没有就是foreach。
@a=1..10;
for(@a){
print “$_\n”;
}
循环控制
Perl的五种循环块：for foreach while until 裸块
last操作符：作用于最内层的循环
next操作符：跳到循环的最低端，然后继续运行下一次循环，也是作用于最内层循环
redo操作符：跳到当前循环的顶端，不仅过测试，也不跳到下一次的循环
@a=1..10;
foreach (@a){
if ($_==5){
next;
}
print “$_\n”;
}
@a=1..10;
foreach (@a){
$_=$_+1;
print “$_\n”;
if ($_==5){
redo;
}
}
带标签的块
@a=1..10;
LABLE: foreach (@a){
if ($_==5){
last LABLE;
}
print “$_\n”;
}
条件操作符？：
如果条件为真，执行冒号前的表达式，如果为假，执行冒号后的表达式。
$a=10;
$a>5 ? print “yes” : print “no”;
逻辑操作符
逻辑与&& 逻辑或||
短路逻辑操作符：走捷径，可以不用计算右边的值就知道真假
$a=10;
if ($a>9||($a++)<15){
print “$a”;
}
$a=10;
if ($a>9|($a++)<15){
print “$a”;
}
$a=10;
if ($a>100&&($a++)<150){
}
print “$a”;
$a=10;
if ($a>100&($a++)<150){
}
print “$a”;
第十三节
unless 控制结构：条件为假的时候才执行代码，类似于else结构
否定操作符 ！
elsif结构：逐一测试条件表达式
伴随unless的else字句
unless{}else{}；
until控制结构
until：循环一直执行，直到条件为真。
表达修饰符
$n=2;
print “yes” if $n<5;
裸块控制结构
定义只有在{}内起作用的临时变量
自增与自减
自增的值
前置自增：++操作符写在变量前面，先增加后取值
后置自增：++操作符写在变量后面，先取值后增加
如果不提取值，$a++ 和++$a是一样的。
for控制结构
foreach和for之间的关系
foreach和for是等价的，perl根据圆括号里的内容判断，有两个分号就是for，没有就是foreach。
循环控制
Perl的五种循环块：for foreach while until 裸块
last操作符：作用于最内层的循环
next操作符：跳到循环的最低端，然后继续运行下一次循环，也是作用于最内层循环
redo操作符：跳到当前循环的顶端，不仅过测试，也不跳到下一次的循环
带标签的块
@a=1..10;
LABLE: foreach (@a){
if ($_==5){
last LABLE;
}
print “$_\n”;
}
条件操作符？：
如果条件为真，执行冒号前的表达式，如果为假，执行冒号后的表达式。
$a=10;
$a>5 ? print “yes” : print “no”;
逻辑操作符
逻辑与&& 逻辑或||
短路逻辑操作符：走捷径，可以不用计算右边的值就知道真假
$a=10;
if ($a>9||($a++)<15){
print “$a”;
}
$a=10;
if ($a>9|($a++)<15){
print “$a”;
}
$a=10;
if ($a>100&&($a++)<150){
}
print “$a”;
$a=10;
if ($a>100&($a++)<150){
}
print “$a”;
第十一章 Perl模块
CPAN：Comprehensive Perl Archive Network
寻找模块：
两种来源：与Perl一同发行已经安装好的，从CPAN下载自己安装的
查看系统上是否已经安装过模块CGI.pm：
perldoc CGI （终止查看用ctrl+c）
列出所有已经安装的模块：
cpan –a
安装模块
Windows系统下：
手动安装：
网络直接安装：
Strawberry perl：cpan install 模块名
Activeperl：ppm install模块名
安装到自己的目录
使用简易模块
仅选用模块中的部分函数
处理日期和时间的模块
数据库和DBI模块
cpan install DBI
cpan install DBD
第十二章 文件测试
文件测试操作符
测试文件是否已经存在：
if (-e “aaa.txt”){
die “file already exist!” ; # or warn
}else{
print “ok go on”;
}
$a = -e “a_1.txt”;
print $a;
-M：返回文件最后一次修改到程序运行时的间隔天数
-A：返回文件最后一次被访问到程序运行时的间隔天数
$a = -M “a_1.txt”;
print $a;
-s:返回文件大小 单位是字节byte
$a = -s “aaa.txt”;
print $a;
测试同一文件的多个属性：逻辑表达式 and or && ||
if (-M “lcx.doc” >90 && -s “lcx.doc” >1000){
print “yes”;
}
上述程序在运行时会测试文件两次，耗费资源，利用虚拟文件句柄_，只需要测试一次。
if (-M “lcx.doc” >90 && -s _ >1000){
print “yes”;
}
虚拟文件句柄_也可以用在两个if中，但要注意是否_已经被别的文件测试覆盖。
if (-M “lcx.doc” >90 ) {
print “yes”;
}
if (-s _ >1000){
print “yes”;
}
栈式文件测试操作符：靠近文件名的先执行，从右往左执行，一般用于返回布尔值的文件测试中，其他返回值的容易出错。
use 5.010;
if (-r -w “lcx.doc”){
print “yes”;
}
stat和lstat函数
@aaa=stat(“lcx.doc”);
print “@aaa”;
localtime函数
$mydate=localtime;
print “$mydate”;
按位运算操作符
使用位字符串
第十三章 目录操作
在目录树中移动
程序运行时默认在当前的目录下运行。
chdir操作符可以改变当前的工作目录
chdir”e:/perl” ||die”$!”;
open(MYTEXT,”aaa.txt”)||die”$!”;
print <MYTEXT>;
文件名通配 glob操作符
use strict;
chdir”e:/perl” ||die”$!”;
my @flie=glob “*.txt”;
print “@flie”;
@file取得目录内所有.txt结尾的文件并按字母顺序排序，不包括点.号开头的文件。
如果一次性处理多种文件，可写多个模式
my @flie=glob “*.txt *.pl”;
文件通配名的另一种语法:<> 代替glob
use strict;
chdir”e:/perl” ||die”$!”;
my @flie=<*.txt *.pl>;
print “@flie”;
注意<>里的可能是文件句柄而不是文件名
目录句柄
opendir readdir closedir
opendir(MYFILE,”e:/perl”)||die”$!”;
foreach(readdir MYFILE){
print “$_\n”;
}
closedir(MYFILE);
递归访问目录
文件和目录的操作
删除文件
unlink操作符：删除文件，返回值为删除的数目
unlink “aaaaaaaa.txt”;
opendir(MYFILE,”e:/perl”)||die”$!”;
foreach(readdir MYFILE){
print “$_\n”;
}
closedir(MYFILE);
unlink glob “*”：一次删除多个文件
$a=unlink glob “*.doc”;
opendir(MYFILE,”e:/perl”)||die”$!”;
foreach(readdir MYFILE){
print “$_\n”;
}
closedir(MYFILE);
print $a;
重命名文件
rename “oldname”,”newname”;
rename “oldname”=>”newname”;
rename”aaaaaa.txt”,”bbbbbb.txt”;
opendir(MYFILE,”e:/perl”)||die”$!”;
foreach(readdir MYFILE){
print “$_\n”;
}
closedir(MYFILE);
批量修改文件的名字（后缀）：构建循环
链接与文件
创建目录
mkdir “aaa”,0755 || warn”$!”;
0755：八进制、代表目录权限的值
删除空目录
rmdir “aaa” || die “$!”;
删除非空目录
rmdir “aaa” || die “$!”;
先用unlink glob “*” 移除目录内所有文件
修改权限 修改隶属关系 修改时间戳
第十四章 字符串与排序
用index查找字符串：返回整数表示子字符串出现的相对位置或跳过的字符数
index（主字符串，子字符串，查找位置）
$aaa=”hello world”;
$loca=index($aaa,”hell”);
print $loca;
$aaa=”helloworld”;
$loca=index($aaa,”l”,4);
print $loca;
rindex 从字符串末尾开始找
$aaa=”helloworld”;
$loca=rindex($aaa,”l”);
print $loca;
$aaa=”helloworld”;
$loca=rindex($aaa,”l”,3);
print $loca;
用substr操作子字符串
子字符串=substr（字符串，起始，长度）
$aaa=”hello world”;
$loca=substr($aaa,0,3);
print $loca;
$loca=substr($aaa,1,100);
$loca=substr($aaa,1);
$loca=substr($aaa,-2,2);
$aaa=”hello world”;
substr($aaa,0,5)=”goodbye”;
print $aaa;
$aaa=”hello world”;
substr($aaa,0,5)=”goodbye”;
substr($aaa,-5)=~s/world/student/;
print $aaa;
$aaa=”hello world”;
substr($aaa,0,5,”goodbye”);
substr($aaa,-5,5,”student”);
print $aaa;
用sprintf格式化字符串
用sprintf格式化金额数字
$aaa=sprintf “%.2f”,2.49999;
print $aaa;
高级排序