Perl入门教程 备忘

(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

http://www.cpan.org/

寻找模块:

两种来源:与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;

 

高级排序

 

 

 

 

 

 

 

京ICP备11047313号-19 彩虹岛电子书