perl语言入门第四版笔记

双引号内的转义字符
\n ===>换行
\r ===>回车
\t ===>水平制表符
\f ===>换页符
\b ===>退格符
\a ===>喇叭
\e ===>ESC(ASCII编码的转义字符)
\007 ===>八进制的ascii码，发声
\x7f ===>十六进制的ASCII码
\cC  ===>“ctrl+C"
\l   ===>将下个字符转换成小写
\L   ===>将到\E为止的所有字符转为小写
\u   ===>将下个字符转为大写
\U   ===>将到\E为止的所有字符转换为大写
\Q   ===>将到\E为止的非文字字符加上反斜线
\E   ===>结束\L,\U或\Q

字符串操作符

"A"."B"                      #结果等同于"AB"
"A".' '."B"                  #等同于"A B"
"A"."\n"                     #等同于"A\n"
"A" x 3                      #等同于 "AAA"
5 x 4                        #等同于 "5555"

警告信息的几种显示设定方法
$perl -w program   ===>直接在shell里执行

#!/usr/bin/perl -w  =====>在脚本第一行设定

#!/user/bin/perl
use warnings;      ======>脚本第二行设定

use diagnostics;   ======>更详细的警告说明

$perl -Mdiagnostics ./my_program ====>外部调用

############# 注意：perl中使用变量，必须在变量前加$，这个shell中不同

双目赋值操作符

$A+=3;
$A*=3;
$A.=" ";
$A**=3   ===>$A的3次方

 

${str}  ======>对区分表示的变量，必要时使用{}来把变量名与后面连着的字符串相分离

操作符的结合性与优先级（从高到低）

结合性操作符
左  括号和列表操作符的参数
左  ->
++  --(自增和自减)
右  **
右  \ ! ~ + - (一元操作符)
左  =~ !~
左  * / % x
左  + - . (二元操作符)
左  << >>
    命名的单目操作符 (-X 文件色是, rand)
    < <= > >= lt le gt ge(“不等的”)
    == != <=> eq ne cmp(“相等的”)
左  &
左  | ^
左  &&
左  ||
右  ?:(三目操作符)
右  = += -= .=
左  , =>
    列表操作符(向右结合)
右  not
左  And
左  or xor

=======>数值与字符串的比较操作符

                  数字    字符串
相等               ==      eq
不等               !=      ne
小于               <       lt
大于               >       gt
小于或等于         <=      le
大于或等于         >=      ge

#############注意：对于数值比较或字符串，返回的一律都是“true”或“false",字符串比较会逐

一对比两个字符串里的字符，判断是否相等或者哪个排在哪个前面（在ASCII中，大写字母排在小写字

母的前面）

chomp的用法====>删除行末的换行符
chomp($text=);
$betty=chomp $food===>if $fod 结尾处有换行符 ,return 1,else return 0

if 与 while循环语句
if (condition) {command};else {command};
while (condition) {command};

判断某个字符串是否是空字符串，可以用defined函数
例： if (defined($mada)){
  print "The input is $mada"
  }
  else {
  print "no input \n"
  }

===>列表的二种形式
   (1,2,3)
   (1..100)
   ($a..$b)
   (0..$#rocks)

qw ! a b c d!
qw < a b c d >
qw ( a b c d )
qw { a b c d }
qw [ a b c d ]

=====>交换变量
     ($fred,$barney)=($barney,$fred)
     ($betty[0],$betty[1])=($betty[1],$betty[0])
用列表赋值
        ($fred,$barney)=qw
        ($rocks[0],$rocks[1],$rocks[2])=qw /a b c/
给数组赋值
        @giant=1..1e5;
        @giant=(@rocks,"file",@dino)

pop操作符====>取出数组最后一个元素，返回它
例：   $a=pop @array  ====>弹出最后一个元素，并把它赋值给变量a
push操作符====>在数组尾部压入一个元素
例：   push(@array,0)
       push(@array ,1..10)
       push @array ,@other
shift操作符====>弹出数组第一个元素，返回它
例    shift @array
unshift 操作符====>在数组第一个元素前压入一个元素
例：  unshift @array,4   ====>压入4

数组名与变量名的混淆
@fred=qw(eating rocks is wrong);
$fred="right";
print "this is $fred[3]\n"; ====>wrong
print "this is ${fred}[3]\n"; ====>right

foreach 循环
例     foreach $rock (qw/badrock slate lava/)
      {
        print "$rock\n";
      }

reverse 操作符===>反序返回列表
例      @fred=6..10;
        @barney=reverse(@fred);
        @barney=reverse 6..10;====>与上面作用相同
sort 操作符====>按照assii编码顺序排序
例
       @b=sort(@rocks);
       @b=sort 97..102; ===>100,101,102,97,98,98,99


====>
1、在标量上下文中，会返回输入数据的下一行
   $a= ====>输入一行接回车后，返回空行
2、在列表上下文中，会返回剩余的各行
   @a= ====>返回的每一行成为列表中单独的元素，按ctrl+D 停止输入

删除换行符
 @lines=;
 chomp @lines;

更简便点的写法chomp(@lines=);

子例程  sub marine {
                      $n+=1;  ====>全局变量$n
                      print;
                   }
     &marine ===>调用子例程

 特殊数组变量@_====>存储参数列表
例：       sub max {
               if ($_[0]>$_[1]) {
                 $_[0];
                }
               else {
                     $_[1];
               }

私有变量
         my($m,$n);
         my($m,$n)=@_;
        =======>把第1、2个参数赋给私有变量$m,$n

sub max {
      if(@_!=2) {      =====>@_变为标量
     print "only need 2 arguments"
     }




$maximun=&max(3,4,5,6);
sub max {
   my($max_number)=shift @_;
   foreach (@_) {
      if ($_>$max_number) {
            $max_number=$_;
       }
   }
$max_number;
}
print $maximun;

use strict;
         

  1 #!/usr/bin/perl -w
  2 use strict;
  3 my @name=qw/fred barney betty dino wilma pebbles bamm-bamm /;
  4 my $result=&which_element_is("dino",@name);
  5 sub which_element_is {
  6         my($var,@list)=@_;
  7         foreach (1..$#list) {
  8         if ($var eq $list[$_]) {
  9             return $_;
 10         }
 11         }
 12     }
~          

=======>格式化输出printf

printf "Hello,$s;your password expires in %d days!\n",$user,$day_to_dir;
printf 的几个参数 %g====>自动选择浮点数/整数/指数
                %d=====>整数，会舍去小数点后面的数字
                %s=====>字符串

指定小数点位数 printf “%12.3f\n”, 6*7 + 2/3;=====>_______42.667
            printf “%12.0f\n”, 6*7 + 2/3;======>___________42


printf“The items are:\n”. (“%10s\n”x @items), @items;



文件句柄（filehandle）是Perl 程序I/O 连接的名字，是Perl 和外界的纽带。也就是说，它是连接的名字，而非文件的名字。
Perl 自身有六个文件句柄：STDIN，STDOUT，STDERR，DATA，ARGV，ARGVOUT◆。
$ ./your_program Wilma===>指定输入/输出文件

if(! open LOG,">>logfile")
{
    die "can't creat logfile:$!";
}

if (@ARGV==0)====>没有输入参数
 {
         die "argument can't be null";
     }



  1 #!/usr/bin/perl
  2 open PASSWD,"  3     or die "denny to enter";
  4 open OP,">>log";
  5 while ()
  6 {
  7         chomp($_);
  8         print OP "$_";
  9         system `sleep 1`;=====>外部命令调用，可以换成exec
    }


========================散   列================
%hash=====>整个散列的表示
$hash{$key}=====>散列单个值的表示
%hash=("foo",3,"bbs",4,"ddd",5)
%hash=reverse %any_hash====> 散列的反转
散列的另一种表示方法：
my %last_name={
    "fred"=>"fly",
    "dino"=>undef,
    "betty"=>"rubble",
};

my %hash=("a"=>1,"b"=>2,"c"=>3);
my @k=key %hash;       ===>键函数keys
my @v=values %hash;    ===>值函数values
if (%hash) {
   print "....";
}
======>至少有一组键/值的话....
each %hash====>each函数，返回键/值列表
例子：
   while (($key,$value)=each %hash) {
     print "$key==>$value";
    }
 
  foreach $key (sort keys %hash) {
    $value=$hash($key);
    print "$key==>$value\n";
}

if (exists $books{"dino"}) {   ===>散列books中存在dino key键的话
   print "..";
}

my $person="betty";
delete $books{$person};

============>正则表达式<=========

1.  "." 通配符，表示单字字符，不包括换行符
2.  "\w" 数字、字母、下划线三种字符 \W表示非这三种字符
3.  "\d" 数字,\D表示非数字
4.  "\s" 空白字符，包括[\n\f\t\r],\S表示非空白字符

量词
1.  "?" 表示前一个字符的0次或1次
2.  "*" 表示前一个字符的0次或多次
3.  "+" 表示前一字符的1次或者多次

以正则表达式表示匹配
(/pattern/option)
option包括:
1. "s" ===>当pattern里有"."时，可以匹配包括换行符，默认的"."无法匹配换行符
2. "i" ===>忽视pattern里的大小写，全部匹配
3. "x" ===>忽视pattern中的空白符,为了美观

两种锚点：
1.匹配行，例： /^\s*$/
2.匹配单词,例：/\bfred\b/ 匹配单词的头尾两端，\B表示非单词边界锚点

绑定操作符=~,例： if ($var=~/\bfred/) {...}
                my $var=(STDIN=~/\bfred/)===>把匹配与否的布尔值传给变量$var

匹配变量
         if ("Hello ketty, run"=~/(\S+) (\w+,) (\S+)) {
           print "$1===$2===$3";
         }

自动变量匹配
1. "$&"   ===> 表示模式匹配部分
2. "$`"   ===> 表示模式匹配的前面部分
3. "$'"   ===> 表示模式匹配的后面部分

对模式匹配次数的表示
/pattern{n,m}/

s替换操作的几种表示方法：
s/pattern1/results/
s#pattern1#results#
s[pattern1][results]
s{pattern1}{results}

s替换操作的几个选项
1.s/a/b/g   ===>全部替换
2.s/a/\Ub/  ===>替换后的部分，全部转化为大写,\u只影响第一个字符
3.s/a/\Lb/  ===>替换后的部分，全部转化为小写,\l只影响第一个字符

split操作符：
例 @fields=split /separator/,$string;
   my @fields=split ===> 用空白符拆解$_;
join 操作符：
   my $result=join $separator,@pieeces;
   my $x=join ":",4,5,6,7,8

列表上下文中的 m//
       $_="Hello there, neighbor!";
       my($first,$second,$third)=(\S+ \S+, \S+);===>针对$_，不用=~
       print "....";

       my $text="...";
       my @words=($text=~/([a-z]+)/ig);

贪心量词与非贪心量词
+   对应  +?
*        *?

 例：   s#(.*)#$1#g; 对应 s#(.*?)#$1#g;

   my $data = "Barney Rubble Fred FlintstoneWilma Flintstone";
   my %last_name=($data=~/(\w+)\s+(\w+)/g);
   foreach (keys %last_name) {
   print "$_====$last_name{$_}\n";
   }
====>匹配$1,$2的组成键值对，赋值给散列last_time

open FILE, $filename
or die “Can’t open ‘$filename’: $!”;
my $lines = join '', ;
$lines =~ s/^/$filename: /gm;

#!/usr/bin/perl -w
use strict;
chomp(my $date = `date`);  ===>等同chomp(my $date=localtime)
$^I =".bak";    ===>指定备份文件
my $file=;
open FILE,"$file";
while(){
        s/^Author:.*/Author: Randal L. Scharwartz/;
        s/^Phone:.*\n//;
        s/^Date:.*/Date: $date/;
        s/1/aaa/;
        print;
}


取消()的记忆功能，在(后紧跟?:  会取消该()指定的变量在内存中的存储
例： if (/(?:bronto)?saurus (?:BBQ )?(steak|burger)/) {
       print “Fred wants a $1\n”;
     }

for 循环的怪异变化
     for($_ = “bedrock”; s/(.)//; ){ #如果s///成功则进入循环
        print “One character is: $1\n”;
}

循环控制：
1、last====>立即终止当前循环
2、next====>跳出此次循环，进入下一次循环
3、redo====>跳到当前循环块的顶端，不经过任何测试条件,重新执行代码

next例子:
while (<>) {
  foreach (split) {
     $total++;
     next if (/\W/);   ===>当非word时候，跳出此次循环，进入下一次循环
     $valid++;
     $count{$_}++;     ===>对散列进行赋值
}
}
print "total things=$total,valid words=$valid\n";
foreach $word (sort keys %count) {
   print "$word was seen $count{$word} times.\n";
}


文件测试
例：die ".....\n" if -e $filename ===>存在文件filename则die
   warn " ....\n" if -M "file">28;===>文件修改时间离现在已经超过28天

检测选项含义
-r 文件或目录对此（有效的）用户（effective user）或组是可读的
-w 文件或目录对此（有效的）用户或组是可写的
-x 文件或目录对此（有效的）用户或组是可执行的
-o 文件或目录由本（有效的）用户所有
-R 文件或目录对此用户(real user)或组是可读的
-W 文件或目录对此用户或组是可写的
-X 文件或目录对此用户或组是可执行的
-O 文件或目录由本用户所有
-e 文件或目录名存在
-z 文件存在，大小为0（目录恒为false）
-s 文件或目录存在，大小大于0（返回值为文件的大小，单位：字节）
-f 为普通文本
-d 为目录
-l 为符号链接
-S 为socket
-p 为管道(Entry is a named pipe(a“fifo”))
-b 为block-special 文件（如挂载磁盘）
-c 为character-special 文件（如I/O 设备）
-u setuid 的文件或目录
-g setgid 的文件或目录
-k File or directory has the sticky bit set
-t 文件句柄为TTY（具有交互的能力）(系统函数isatty()的返回结果；不能对文件名使用这个测试)
-T 文件有些像“文本”文件
-B 文件有些像“二进制”文件
-M 修改距今的时间（单位：天）
-A 访问距今的时间（单位：天）
-C 索引节点修改距今的时间（单位：天）

例子 if (-f "file) {
      die "ffffff\n";
    }
    my $size=(-s)/1000;====>$_变量表示的文件算k

stat 与lstat(针对链接文件）
my ($dev,$ino,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks)
=stat($filename);
$dev ===>文件的设备号
$ino ===>节点号
$mode===>权限位
$nlink===>硬链接数
$uid/gid===>用户标识符与组标识符
$size===>以字节单位的文件大小
$atime/mtime/ctime===> 文件访问时间/修改时间/创建时间

$time=localtime;====>取得当前的时间

位运算操作符
1、&    ====>两边都为1
2、|    ====>两边只要有1个1
3、^    ====>两边只能有1个1

6<<2,把左边操作数左移2位置，多余的补零
6>>2,右移，减少位数
~10，逐位否定，取反

hex($var)====> 十六进制转换为十进制



===============目录操作=========================
chdir "/etc/" or die "cant't change to /etc:$!";

cat>show-args
foreach $args ($ARGV){
print "one args is $args";
}
perl show-args *.txt          ====>显示目录下txt后缀的文件

my @var=glob "*";             ====>找到当前目录下的所有文件，但不包括以.号开头的文件
my @var=glob ".*";          ====>所有文件
my @var=<*>                 ====>同上

my $dir_to_process="/etc";=====>读入目录句柄，通过目录句柄显示文件
opendir DH,$dir_to_process or die "can'topen $dir_to_process";
foreach $file (readdir DH) { ====>等价于while (my $file=readdir DH) {
        next unless ($file=~/\.d$/);====>过滤掉非以.d结尾的文件
        print "$dir_to_process/$file\n";====>$dir_to_process为文件前的路径

}

删除文件：unlink glob "*.o"; ===>返回值表示删除了多少个文件
        rename "old","new";

 

 

====>批量修改文件名
foreach my $file (glob “*.old”){
my $newfile = $file;
$newfile =~ s/\ .old$/.new/; ===>左边为正则，所以加\，右边表达式，不用

if (-e $newfile){
warn“can’t rename $file to $newfile: $newfile exists\n”;
}elsif(rename $file, $newfile){
##成功，什么也不做
} else {
warn “rename $file to $newfile failed: $!\n”;
}
}

 

硬链接

link“chicken”, “egg”    ====>innode号相同，修改一个，另一个修改
or warn “Can’t link chicken to egg: $!”;

软链接（符号链接）

symlink “dodgson”, “carroll”  ===>只是一个符号链接，与真实文件不同
or warn “Can’t sysmlink Dodgson to carroll: $!”;

my $where = readlink “carroll”; #得到符号链接的地址
my $perl = readlink“/usr/local/bin/perl”#可能得到Perl 放置的地方

建立与移除目录
mkdir "fred",0755 or warn "aaa";
rmdir $_ for glob "fred/*"    ===>移除目录fred下所有空目录
foreach my $dir (qw(fred barney betty)){
     rmdir $dir or warn "can't rmdir $dir "
}
unlink glob "$temp_dir/* $temp+dir/.*"; ====>删除$temp_dir的内容

修改权限
chmod 0755,"fred","barney"

更改隶属关系
my $user=1004;
my $group=100;
chown $user,$group,glob "*.o";

处理字符串名的用户名与组名，使用 getpwnam
defined(my $user=getpwam "merlyn")or die "bad user"
defined(my $group=getpwam "dock")or die "bad group"
chown $user,$group ,glob "/home/merlyn/*";
=====defined 函数确认返回值是不是undef

更改时间戳
my $now=time;
my $ago=$now-24*60*60;
utime $now,$ago,glob "*";   ===>将访问时间修改成现在，修改时间设成一天以前，另外还有个$ctime表示更改时间

字符串与排序
index函数====>返回某个字符串在大串中的第一次出现的位置
例：
           $here="Howdy world!"
           my $target1=index($here,"w") ====>$target1 返回2
           my $target2=index($here,"w",$target1+1) ====>第三个参数，表示从$target1后的一个位置查找，当找不到的时候，会返回-1

rindex====>返回某个字符串在大串中的最后一次出现的位置
           my $last_slash=rindex("/etc/passwd","/"); ====>值为4


substr函数====>字串操作
my $mineral=substr("Fred J.Flintstone",8,5)====>返回字符串第9个及后面4个字符，参数5省略，表示返回第九个及后面的字符，当参数5为-5时，表示从倒数第4个字符，返回字符

substr($string, -20) =~ s/fred/barney/g;====>在指定范围内替换匹配的字符串
my $previous_value = substr($string, 0, 5, “Goodbye”);====>与上面功能相同

 

printf 与sprintf之间的不同

printf与sprintf的参数格式完全相同,printf直接打印,sprintf返回打印值

 

my $data_tag = sprintf
“%4d/%02d/%02d %02d:%02d:%02d”,
$yr, $mo, $da, $h, $m, $s;    ====>打印日期,存入变量

my $money = sprintf “%.2f”, 2.49997;=====>留两位得到2.50

 

sub big_money {
my $number = sprintf “%.2f”, shift @_;
#在do-nothing 循环中，每一次加入一个逗号
1 while $number =~ s/^(-?\d+) (\d\d\d)/$1,$2/;
#将美元符号放入合适的位置
$number =~ s/^(-?)/$1\$/;
$number;
}

 

 

按数字排序的两种方法

一、

sub by_number {
if($a < $b){-1} elsif($a > $b){1} else {0}
}

my @result = sort by_number @some_numbers;

二、

sub by_number {$a <=> $b }

my @result = sort by_number @some_numbers;

按字符串排序

sub ASCIIbetically {$a cmp $b} my @string = sort ASCIIbetically @any_strings;

 

sub case_insenstive {“\L$a”cmp “\L$b”}====>比较两个字符串，而忽略大小写

 

my @descending = reverse sort { $a <=> $b } @some_numbers;===>由小到大排序

 

对hash排序

my %score = (“barney”=>, “fred”=>205, “dino”=> 30);
sub by_socre { $score{$b} <=> $score{$a}}；

my @winners = sort by_score keys %score;

 

=======>假设值有相通的情况下，按字符串keys值排序

my @winners = sort by_score_and_name keys %score;
sub by_score_and_name {
$score{$b} <=> $score{$a} #按照降序的成绩
or
$a cmp $b; #字母顺序的名字
}

＝＝＝＝＝＝>五级排序

@patrons_IDs = sort {
&fines($b) <=> &fines($a) or
$items{$b} <=> $items{$a} or
$family_name{$a} cmp $family_name{$a} or
$personal_name{$a} cmp $family_name{$b} or

 

 

=============================================================================

系统外部命令的调用

例： system“date”
    system ‘ls–l $HOME’;

    system “ls–l \$HOME”;    ====>用双引号会设内部进行变量替换，所以要加\来转义