Perl 基本語法

by Jian Lee

最近在研究 openSUSE 的 OBS （編譯系統(tǒng)），其中很多部分用到 Perl。而且自己也感到有必要學(xué)點 Perl，當有一點其他程序語言的基礎(chǔ)，再學(xué)一門語言，入門還是非常簡單的。Perl 在 GNU/Linux 上應(yīng)用如此廣泛，很多地方替換 shell 腳本會更靈活優(yōu)秀高效，學(xué)習(xí)它也很有必要。本文是學(xué)習(xí)時的筆記，多是語法使用示例，沒有什么說明。擬研究 OBS 時，依據(jù)某個應(yīng)用再寫一篇 Perl 應(yīng)用教程。

標量

標量是 Perl 中最簡單的數(shù)據(jù)類型。大多數(shù)的標量是數(shù)字(如 255 或 3.25e20)或者字符串(如 hello或者蓋茨堡地址)。

數(shù)字

perl中所有數(shù)字內(nèi)部的格式都是雙精度浮點數(shù)。

浮點數(shù)

1.25255.000255.07.25e45 #7.25x10 的 45 次方(一個大整數(shù))-6.5e24 # -6.5x10 的 24 次方(一個大的負數(shù))-12e-24 #- -12x10 的-24 次方(很小的負數(shù))-1.2E-23 #指數(shù)符號可以大寫(E)

整數(shù)

02001-4025561298040283768

其中 61298040283768 也可以寫作：

61_298_040_283_768

非十進制整數(shù)

0377     #八進制數(shù)字 377,等同于十進制數(shù)字 2550xff       #十六進制數(shù)字 FF,等同于十進制數(shù)字 2550b11111111 #等同于十進制數(shù)字 255

可以用下劃線表示：

0x1377_0B770x50_65_72_7C

數(shù)字操作符

2+3       #2+3,55.1-2.4  #5.1-2.4,2.73*12     #3*12,3614/2      #14/2,710.2/0.3  #10.2/0.3,3410/3      #通常是浮點除,3.33333... ...

字符串

單引號字符串

'fred' #四個字符:f,r,e,d'' #空字符(沒有字符)'hello\n''\'\\' #單引號(')跟著反斜線(\)字符串

單引號中的 "\n" 不會被當作換行符來處理。

雙引號字符串

"barney"         #等同于 'barney'"hello world\n"  #hello world,換行

字符串操作符

鏈接操作符 "."

"hello"."world"     # 同于 "helloworld""hello".''."world"  # 同于 "hello world"'hello world'."\n"  # 同于 "hello world\n"

重復(fù)操作符 "x"

"fred" x 3   # "fredfredfred"5 x 4        # 等于 "5" x 4, "5555"

數(shù)字和字符串之間的自動轉(zhuǎn)換

大多數(shù)情況下,Perl 將在需要的時候自動在數(shù)字和字符串之間轉(zhuǎn)換。它怎樣知道什么時候需要字符串,什么時候需要數(shù)字呢?這完全依賴于標量值之間的的操作符。如果操作符(如+)需要數(shù)字,Perl 將把操作數(shù)當作數(shù)字看待。如果操作符需要字符串(如 . ), Perl 將把操作數(shù)當作字符串看待。不必擔(dān)心數(shù)字和字符串的區(qū)別;使用恰當?shù)牟僮鞣?Perl 將為你做剩下的事。

"12" * "3"  # * 操作符需要數(shù)字，所以結(jié)果為 36"12fred34" * " 3" # 結(jié)果仍然是 36 , 后面的非數(shù)字部分和前面的空格都過濾掉。

"Z" . 5 * 7 # 等于 "Z".35， 或 "Z35"

Perl 內(nèi)嵌的警告

使用 -w 參數(shù)可以打開警告：

$ perl -w perl程序   # 命令行執(zhí)行警告#!/usr/bin/perl -w  # 源代碼中使用警告

標量變量

標量變量可以存放一個標量值。標量變量的名字由一個美圓符號($)后接 Perl 標識符:由字母或下劃線開頭,后接字母,數(shù)字,或者下劃線?；蛘哒f由字母,數(shù)字和下劃線組成,但不能由數(shù)字開頭。大小寫是嚴格區(qū)分的:變量$Fred 和變量$fred是不同的。任意字母,數(shù)字,下劃線都有意義,如:

$a_very_long_variable_that_ends_in_1$a_very_long_variable_that_ends_in_2

標量賦值

$fred = 17;$barney = "hello";$barney = $fred + 3;# 將$fred 的值加上三賦給$barney (20)$barney= $barney*2;#將變量$barney 乘 2 再賦給$barney (40)

二元賦值操作符

$fred = $fred + 5; #沒有用二元賦值操作符$fred+=5;          #利用二元賦值操作符$barney = $barney*3;$barney*=3;$str = str . ""; #$str 后接空格;$str .= "";    #同上

print 輸出

print "hello world\n";   #輸出 hello world,后接換行符print "The answer is", 6*7, ".\n"

字符串中引用標量變量

$meal = "brontosaurus steak" ;$barney = "fred ate a $meal";$barney = 'fred ate a'.$meal;    # 同上

if 控制結(jié)構(gòu)

if ($name gt 'fred') {print "$name’comes after 'fred' in sorted order.\n";}

Boolean 值

perl 沒有專門的 Boolean 值， 真假值這樣判斷：

• 如果值為數(shù)字,0 是 false;其余為真
• 如果值為字符串,則空串(‘)為 false;其余為真
• 如果值的類型既不是數(shù)字又不是字符串,則將其轉(zhuǎn)換為數(shù)字或字符串后再利用上述規(guī)則

這些規(guī)則中有一個特殊的地方。由于字符串'0' 和數(shù)字 0 有相同的標量值,Perl 將它們相同看待。也就是說字符串 '0' 是唯一一個非空但值為 0 的串。

用戶的輸入 <STDIN>

chomp 操作

$text = "a line of text\n";    # 也可以由<STDIN>輸入chomp($text);                 #去掉換行符(\n)。

一步執(zhí)行：

chomp ($text = <STDIN>); #讀入,但不含換行符

chomp 是一個函數(shù)。作為一個函數(shù),它有一個返回值,為移除的字符的個數(shù)。這個數(shù)字基本上沒什么用:

$food = <STDIN>;$betty = chomp $food; #得到值 1

如上,在使用 chomp 時,可以使用或不使用括號()。這又是 Perl 中的一條通用規(guī)則:除非移除它們時含義會變,否則括號是可以省略的。

while 控制結(jié)構(gòu)

$count = 0;while ($count < 10) {$count + = 2;print "count is now $count\n";}

undef 值

變量被賦值之前使用它會有什么情況發(fā)生呢?通常不會有什么嚴重的后果。變量在第一次賦值前有一個特殊值 undef, 按照 Perl 來說就是:"這里什么也沒有,請繼續(xù)"。如果這里的“什么也沒有”是一些“數(shù)字”,則表現(xiàn)為 0。如果是“字符串”,則表現(xiàn)為空串。但 undef 既非數(shù)字也非字符串,它是另一種標量類型。

defined 函數(shù)

能返回 undef 的操作之一是行輸入操作,<STDIN>。通常,它會返回文本中的一行。但如果沒有更多的輸入,如到了文件的結(jié)尾,則返回 undef。要分辨其是 undef 還是空串,可以使用 defined 函數(shù), ，如果其參數(shù)是 undef 值就返回 false，其他值返回 true。

$madonna = <STDIN>;If ($defined ($madonna)){print "The input was $madonna";} else {print "No input available!\n;}

如果想聲明自己的 undef 值,可以使用 undef:

$madonna = undef ; #同$madonna 從未被初始化一樣。

列表和數(shù)組

#!/usr/bin/env perl -w$fred[0] = "yabba";$fred[1] = "dabba";$fred[2] = "doo";print @fred;#print @fred."\n";

qw 簡寫

qw ! fred barney betty wilma dino !qw#  fred barney betty wilma dino # #有些像注釋qw(   fred barney betty wilma dino )...

列表賦值

($fred, $barney, $dino) = ("flintstone", "rubble", undef);($fred, $barney) = qw <flintstone rubble slate granite>; #兩個值被忽略了($rocks[0],$rocks[1],$rocks[2],$rocks[3]) = qw/talc mica feldspar quartz/;

當想引用這個數(shù)組時, Perl 有一種簡單的寫法。在數(shù)組名前加@(后沒有中括號) 來引用整個數(shù)組。 你可以把他讀作 "all of the "(所有的)”,所以@rocks 可以讀作 "all of the rocks(所有的石頭)"。其在賦值運算符左右均有效：

@rocks = qw / bedrock slate lava /;@tiny = ();                         #空表@giant = 1..1e5;               #包含 100,000 個元素的表@stuff = (@giant, undef, @giant);      #包含 200,001 個元素的表@dino = "granite";@quarry = (@rocks, "crushed rock", @tiny, $dino);

pop 和 push 操作

@array = 5..9;$fred = pop(@array);      #$fred 得到 9,@array 現(xiàn)在為(5,6,7,8)$barney = pop @array;   #$barney gets 8, @array 現(xiàn)在為(5,6,7)pop @array;                   #@array 現(xiàn)在為(5,6)(7 被丟棄了)

push(@array,0);                   #@array 現(xiàn)在為(5,6,0)push @array,8;                    #@array 現(xiàn)在為(5,6,0,8)push @array,1..10;              #@array 現(xiàn)在多了 10 個元素@others =qw/9 0 2 1 0 /;push @array,@others;          #@array 現(xiàn)在又多了 5 個元素(共有 19 個)

shift 和 unshift 操作

push 和 pop 對數(shù)組的末尾進行操作(或者說數(shù)組右邊有最大下標的元素,這依賴于你是怎樣思考的)。相應(yīng)的, unshift 和 shift 對一個數(shù)組的開頭進行操作(數(shù)組的左端有最小下標的元素) 。下面是一些例子:

@array = qw# dino fred barney #;$m = shift (@array);       #$m 得到 "dino"， @array 現(xiàn)在為 ("fred", "barney")$n = shift @array;          #$n 得到 "fred", @array 現(xiàn)在為 ("barney")shift @array;                  #@array 現(xiàn)在為空$o = shift @array;          #$o 得到 undef, @arry 仍為空unshift(@array,5);          #@array 現(xiàn)在為(5)unshift @array,4;           #@array 現(xiàn)在為(4,5)@others = 1..3;unshift @array, @others;  #array 現(xiàn)在為(1,2,3,4,5)

和 pop 類似,如果其數(shù)組變量為空,則返回 undef。

字符串中引用數(shù)組

和標量類似,數(shù)組也可以插入雙引號的字符串中。插入的數(shù)組元素會自動由空格分開：

@rocks = qw{ flintstone slate rubble };print "quartz @rocks limestone\n";        #輸出為 5 種 rocks 由空格分開

foreach 控制結(jié)構(gòu)

foreach $rock (qw/ bedrock slate lava /) {print "One rock is $rock.\n" ;           #打印出 3 種 rocks}

這里的$rock不是這些列表元素中的一個拷貝而是這些元素本身

最常用的默認變量 ： $_

如果在 foreach 循環(huán)中省略了控制變量,那 Perl 會使用其默認的變量:$_。除了其不尋常的名字外,這和普通變量類似,如下面代碼所示:

foreach(1..10){                 #使用默認的變量$_print "I can count to $_!\n";}

$_ = "Yabba dabba doo\n";print;                                      # 打印出默認變量 $_

reverse 操作

reverse(逆轉(zhuǎn))操作將輸入的一串列表(可能是數(shù)組)按相反的順序返回。

@fred = 6 .. 10;@barney = reverse (@fred);  #得到 10,9,8,7,6@wilma = reverse 6 . .10;   #同上,沒有使用額外的數(shù)組@fred = reverse @fred;     #將逆轉(zhuǎn)過的字符串存回去

sort 操作

@rocks = qw/ bedrock slate rubble granite /;@sorted = sort(@rocks);                      #得到 bedrock, granite, rubble, slate

標量和列表上下文

42 + something               #something 必須是標量sort something                #something 必須是列表

@people = qw( fred barney betty );@sorted = sort @people;            #列表內(nèi)容： barney , betty, fred$number = 42 + @people;            #標量內(nèi)容：42+3,得到 45

另一個例子是 reverse。在列表 context 中,它返回反轉(zhuǎn)的列表。在標量 context 中,返回反轉(zhuǎn)的字符串(或者將反轉(zhuǎn)的結(jié)果串成一個字符串):

@backwards = reverse qw / yabba dabba doo /;#返回 doo, dabba, yabba$backwards = reverse qw/ yabba  dabba doo /;#返回 oodabbadabbay

在列表 Context 中使用 Scalar-Producing 表達式

如果一個表達式不是列表值,則標量值自動轉(zhuǎn)換為一個元素的列表:

@fred = 6*7;@barney = "hello" . '' . "world";

強制轉(zhuǎn)換為標量 Context

偶爾,你可能需要標量 context 而 Perl 期望的是列表。這種情況下,可以使用函數(shù) scalar。它不是一個真實的函數(shù)因為其僅是告訴 Perl 提供一個標量 context:

@rocks = qw(talc quartz jade obsidian);print "How many rocks do you have?\n;print "I have " @rocks, "rocks!\n";    # 錯誤,輸出 rocks 的名字print "I have " scalar @rocks, "rocks!\n;    # 正確,輸出其數(shù)字

<STDIN> 在列表 Context 中

@lines = <STDIN>; #將輸入讀入列表 context 中chomp (@lines = <STDIN>); #讀入所有的行,不包括換行符

子程序

使用 sub 定義子程序

sub marine {$n + = 1; #全局變量$nprint "Hello, sailor number $n!\n";}

調(diào)用子程序

&marine; #輸出 Hello, sailor number 1!&marine; #輸出 Hello, sailor number 2!&marine; #輸出 Hello, sailor number 3!&marine; #輸出 Hello, sailor number 4!

通常有括號,即便參數(shù)為空。子程序?qū)⒗^承調(diào)用者的 @_ 的值。

參數(shù)

$n = &max(10,15);     # 此子程序有 2 個參數(shù)

此參數(shù)列表被傳到子程序中;這些參數(shù)可以被子程序使用。當然,這些參存放在某個地方,在 Perl 中,會自動將此參數(shù)列表(此參數(shù)列表的另一個名字)自動存放在一個叫做@_的數(shù)組中。子程序可以訪問次數(shù)組變量來確定此參數(shù)的個數(shù)以及其值。這也就是說此子程序參數(shù)的第一個值存放在$_[0]中,第二個存放在$_¹,依次類推。但必須強調(diào)的是這些變量和 $_ 這個變量沒有任何關(guān)系,如$dino³(數(shù)組 @dino 的一個元素)和$dino 的關(guān)系一樣。這些參數(shù)必須存放在某個數(shù)組變量中, Perl 存放在@_這個變量中。

 sub max{if($_[0] > $_[1]) {$_[0];} else {$_[1];}}

my 變量

foreach (1..10){my($square) = $_*$_; #本循環(huán)中的私有變量print "$_ squared is $squrare.\n";}

變量$square 是私有的,僅在此塊中可見;在本例中,此塊為 foreach 循環(huán)塊。

當然,my 操作不會改變賦值參數(shù)的 context:

my ($num) = @_;         # 列表 context, 同($sum) = @_;my $num = @_;          # 標量 context,同$num = @_;

使用 strict Pragma

use strict; #迫使采用更嚴格的檢測

省略 &

有些地方調(diào)用子程序可以不要 ＆

my @cards = shuffle(@deck_of_cards); # &是不必要的

輸入和輸出

從標準輸入設(shè)備輸入

從標準輸入設(shè)備輸入是容易的。使用<STDIN>。在標量 context 中它將返回輸入的下一行:

$line = <STDIN>;     #讀入下一行;chomp($line);        #去掉結(jié)尾的換行符chomp($line=<STDIN>)  #同上,更常用的方法

于,行輸入操作在到達文件的結(jié)尾時將返回 undef,這對于從循環(huán)退出時非常方便的:

while (defined($line = <STDIN>)) {print "I saw $line";}

從 <> 輸入

尖括號操作(<>)是一種特殊的行輸入操作。其輸入可由用戶選擇

$n = 0;while (defined($line = <>)) {$n += 1;chomp($line);print "$n  $line\n";}

while (<>) {chomp;print "It was $_ that I saw!\n";}

調(diào)用參數(shù)

技術(shù)上講，<>從數(shù)組@ARGV 中得到調(diào)用參數(shù)。這個數(shù)組是 Perl 中的一個特殊數(shù)組,其包含調(diào)用參數(shù)的列表。 換句話說，這和一般數(shù)組沒什么兩樣 (除了其名字有些特別: 全為大寫字母) ,程序開始運行時,調(diào)用參數(shù)已被存在@ARGV 之中了。

輸出到標準輸出設(shè)備

print @array;      #打印出元素的列表print "@array";    #打印一個字符串(包含一個內(nèi)插的數(shù)組)

第一個語句打印出所有的元素,一個接著一個,其中沒有空格。第二個打印出一個元素,它為@array 的所有元素,其被存在一個字符串中。也就是說,打印出@array 的所有元素,并由空格分開。如果@array 包含 qw /fred barney betty /,則第一個例子輸出為:fredbarneybetty,而第二個例子輸出為 fred barney betty(由空格分開)。

使用 printf 格式化輸出

printf "Hello, %s :  your password expires in %d days!\n",$user, $days_to_die;printf "%6f\n" 42;          # 輸出為 ○○○○ 42 (○此處指代空格)printf "%23\n",2e3+1.95;  # 2001

數(shù)組和 printf

my @items = qw( wilma dino pebbles );my $format = "The items are:\n". ("%10s\n" x @items);printf $format, @items;

等同：

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

本處 @items 有兩個不同的 context （上下文），第一次表示元素個數(shù)，第二次表示列表中的所有元素。

句柄 （即文件描述符）

Perl 自身有六個文件句柄 ： STDIN,STDOUT,STDERR,DATA,ARGV,ARGVOUT

文件句柄的打開

open CONFIG, "dino" ;open CONFIG, "<dino"    ;open BEDROCK, ">fred"   ;open LOG, ">>logfile" ;

Perl 的新版本中(從 Perl5.6 開始)，open 支持“3 參數(shù)”類型：

open CONFIG, "<",  "dino";open BEDROCK, ">", $file_name;open LOG, ">>", &logfile_name();

Bad 文件句柄

關(guān)閉文件句柄

close BEDROCK;

嚴重錯誤和 die

可以和 C 中使用 perror 類似，用 die 函數(shù)：

if (!open LOG, ">>logfile") {die "Cannot create logfile:$!";}

使用文件句柄

if (!open PASSWD, "/etc/passwd") {die "How did you get logged in?($!)";}while (<PASSWD>) {chomp;...}

哈希

什么是哈希

和 Python 的字典一樣

哈希元素的存取

$hash {$some_key}

作為整體的 hash

要引用整個 hash,使用百分號(“%” )作為前綴。

%some_hash = ("foo",35, "bar", 12.4, 2.5, "hello", "wilma", 1.72e30, "betty", "bye\n");

hash 的值(在列表 context 中)是一個 key/value 對的列表 ：

@array_array = %some_hash;

哈希賦值

%new_hash = %old_hash;%inverse_hash = reverse %any_hash;

大箭頭符號 (=>)

my %last_name = ("fred” => "flintstone","dino" => undef,"barney" => "rubble","betty" => "rubble",);

哈希函數(shù)

keys 和 values

my %hash = ("a" => 1, "b" => 2, "c" => 3);my @k = keys %hash;my @v = values %hash;

each 函數(shù)

while (($key, $value) = each %hash) {print "$key => $value\n";}

exists 函數(shù)

if (exists $books{$dino}) {print "Hey, there's a libaray card for dino!\n";}

delete 函數(shù)

my $person = "betty";delete $books{$person};   # 將$person 的借書卡刪除掉

正則表達式

簡單的模式

$_ = "yabba dabba doo";if (/abba/) {print "It matched!\n";}

所有在雙引號中的轉(zhuǎn)義字符在模式中均有效,因此你可以使用 /coke\tsprite/ 來匹配 11 個字符的字符串 coke, tab(制表符),sprite。

元字符

.?+*

模式中的分組

/fred+/      # 只能匹配 fredddddd 等/(fred)+/    # 能匹配  fredfredfred 等/(fred)*/    # 可以匹配 "hello,world"， 因為 * 是匹配前面的 0或多次

選擇符 (|)

/fred|barney|betty//fred( |\t)+barney/

字符類

指 ［］ 中的一列字符。

字符類的簡寫

\d    ==   [0-9]\w    ==   [A-Za-z0-9_]\s    ==   [\f\t\n\r]  # 格式符(form-feed)、制表符(tab)、換行符、回車

簡寫形式的補集

\D  == ［^\d]\W  ==  [^\w]\S  ==  [^\s]

可以組合：

[\d\D]   # 任何數(shù)字和任何非數(shù)字，可以匹配所有字符！比如 . 是不能匹配所有字符的[^\d\D]   # 無用

正則表達式的應(yīng)用

使用 m// 匹配

同 qw // 一樣，可以使用任何成對字符，比如可以使用 m(fred), m<fred>, m{fred}, m[fred],或者 m,fred,, m!fred!, m^fred^。

如果使用 / 作為分隔符，可以省略前面的 m

如果使用配對的分隔符, 那不用當心模式內(nèi)部會出現(xiàn)這些分隔符, 因為通常模式內(nèi)部的分隔符也是配對的。 因此, m(fred(.*)barney), m{\w{2,}}, m[wilma[\n \t]+betty]是正確的。對于尖括號(<和>),它們通常不是配對的。如模式 m{(\d+)\s*>=?\s*(\d+)},如果使用尖括號,模式中的尖括號前因當使用反斜線(\), 以免模式被過早的結(jié)束掉。

可選的修飾符

不區(qū)分大小寫： /i

if (/yes/i) {            #大小寫無關(guān)print "In that case, I recommend that you go bowling.\n";}

匹配任何字符： /s

使用/s 這個修飾符，它將模式中點 (.) 的行為變成同字符類 [\d\D] 的行為類似：可以匹配任何字符,包括換行符。從下例中可見其區(qū)別:

$_ = "I saw Barney\ndown at the bowing alley\nwith Fred\nlast night.\n;if (/Barney.*Fred/s) {print "That string mentions Fred after Barney!\n";}

添加空格： /x

/x 修飾符,允許你在模式中加入任何數(shù)量的空白,以方便閱讀：

/-?\d+\.?\d*/        # 這是什么含義?/ -? \d+ \.? \d* /x  # 要好些

Perl 中,注釋可以被作為空白,因此使用/x,可以在模式中加上注釋：

/-?  #可選的負號d+ #小數(shù)點前一個或多個十進制數(shù)字\.? #可選的小數(shù)點\d* #小數(shù)點后一些可選的十進制數(shù)字/x #模式結(jié)束

使用多個修飾符

if (/barney.*fred/is/){ # /i 和/sprint "That string mentions Fred after Barney!\n";}

錨定

^  開頭$  結(jié)尾

注意：/^fred$/能同時匹配上 "fred" 和 "fred\n"。

/^\s*$/   # 匹配空行

詞錨定： \b

/\bfred\b/ 可以匹配單詞 "fred", 但不能匹配 "frederick"

綁定操作符： =~

對 $_ 進行匹配只是默認的行為, 使用綁定操作符 ( =~ ) 將告訴 Perl 將右邊的模式在左邊的字符串上進行匹配,而非對 $_ 匹配。

my $some_other = "I dream of betty rubble.";if ($some_other =~ /\brub/) {print "Aye, there's the rub.\n";}

綁定操作符優(yōu)先級較高：

my $likes_perl = <STDIN> =~ /\byes\b/i;

匹配變量

$_ = "Hello there, neighbor";if (/\s(\w+),/) {              #空格和逗號之間的詞print "The word was $1\n";}

自動匹配變量

$&    # 整個被匹配的部分$`     # 匹配部分的前一部分存放在$`之中$'     # 后一部分被存到$'

使用正則表達式處理文件

使用 s/// 進行替換

$_ = "He's out bowling with Barney tonight.";s/Barney/Fred/;               # Barney 被 Fred 替換掉print "$_\n";#接上例:現(xiàn)在 $_ 為 "He's out bowling with Fred tonight."s/Wilma/Betty/;              # 用 Wilma 替換 Betty(失敗)s/with (\w+)/agaist $1's team/;print "$_\n";                  # 為 "He's out bowling against Fred's team tonight.";

使用 /g 進行全局替換

$_ = "home, sweet home!";s/home/cave/g;print "$_\n";              # "cave, sweet cave!"

全局替換的一個常用地方是將多個空格用單個空格替換掉：

$_ = "Input      data\t may have             extra whitespace.";s/\s+/ /g;               # 現(xiàn)在是 "Input data may have extra whitespace."

現(xiàn)在已經(jīng)知道怎樣去掉多余的空格,那怎樣去掉開頭和結(jié)尾的空白呢?這是非常容易的：

s/^\s+//;      #將開頭的空白去掉s/\s+$//;      #將結(jié)尾的空白去掉s/^\s+|\s+$//g;   #將開頭,結(jié)尾的空白去掉

不同的分隔符

如同 m//和 qw//一樣,我們也可以改變 s///的分隔符。但這里使用了3個分隔符,因此有些不同。

s#^https://#http://#;

如果使用的是配對的字符,也就是說其左字符和右字符不的,則必需使用兩對:一對存放模式,一對存放替換的字符串。此時,分隔符甚至可以是不同的。事實上,分隔符還可以使用普通的符號(非配對的)。下面三例是等價的：

s{fred}{barney};s[fred](barney);s<fred>#barney#;

可選的修飾符

除了/g 修飾符外，替換操作中還可以使用 /i ， /x ， 和 /s， 這些在普通的模式匹配中已經(jīng)出現(xiàn)過的修飾符。其順序是無關(guān)緊要的。

s#wilma#Wilma#gi;              # 將所有的 WilmA,或者 WILMA 等等,由 Wilma 替換掉s{_ _END_ _.*}{ }s;            # 將 END 標記及其后面的行去掉

綁定操作

同 m// 一樣,我們也可以通過使用綁定操作符改變 s/// 的替換目標:

$file_name =~ s#^.*###s;                 # 將$file_name 中所有的 Unix 類型的路徑去掉

大小寫替換

有時,希望確保被替換的字符串均是大寫的(或者不是,視情況而定) 。這在 Perl 中只需使用某些修飾符就能辦到。 \U 要求緊接著的均是大寫：

$_ = "I saw Barney with Fred.";s/(fred|barney)/\U$1/gi;           # $_ 現(xiàn)在是 "I saw BARNEY with FRED."

同樣,也可以要求后面的均為小寫 \L ：

s/(fred)|barney/\L$1/gi;         #$_現(xiàn)在是 "I saw barney with fred."

默認時,會影響到剩余的(替換的)字符串。可以使用 \E 來改變這種影響：

s/(\w+) with (\w+)/\U$2\E with $1/I;       # $1 現(xiàn)在是 "I saw FRED with barney."

使用小寫形式時( \l 和 \u ),只作用于下一個字符：

s/ (fred|barney)/\u$1/ig;     #$_現(xiàn)在是 "I saw FRED with Barney."

也可以同時使用它們。如使用\u 和\L 表示 "第一個字母大寫,其它字母均小寫"。 \L 和\u 可以按任意順序出現(xiàn)。Larry 意識到人們有時可能按相反順序使用它們,因此他將 Perl 設(shè)計成,在這兩種情況下都是將第一個字母大寫,其余的小寫。 Larry 是個非常好的人。

s/(fred|barney)/\u\L$1/ig; #$_現(xiàn)在為 "I saw Fred with Barney."

這些在替換中出現(xiàn)的大小寫轉(zhuǎn)換的修飾符,也可在雙引號中使用：

print "Hello, \L\u$name\E, would you like to play a game?\n";

split 操作

另一個使用正則表達式的操作是 split , 它根據(jù)某個模式將字符串分割開。這對于由制表符分割開,冒號分割開,空白分割開,或者任意字符分割開的數(shù)據(jù)是非常有用的。任何可在正則表達式之中 (通常，是一個簡單的正則表達式) 指定分離符 (separator) 的地方,均可用 split。其形式如下：

@fields = split /separtor/, $string;

@fields = split /:/, "abc:def:g:h";    # 返回 ("abc", "def", "g", "h")

/\s+/ 這個模式分隔符非常常見：

my $some_input = "This    is a \t             test.\n";my @args = split /\s+/, $some_input;           # ("This", "is", "a", "test." )

默認時,split 對$_操作,模式為空白：

my @fields = split;      # 同 split /\s+/, $_;

join 函數(shù)

join 函數(shù)不使用模式,但它完成同 split 相反的操作:split 將一個字符串分割開,而 join 函數(shù)將這些分割的部分組合成一個整體。join 函數(shù)類似于 ：

my $result = join $glue, @pieces;

join 函數(shù)的第一個參數(shù)是粘合元素(glue),它可以是任意字符串。剩下的參數(shù)是要被粘合的部分。join 將粘合元素添加在這些部分之間,并返回其結(jié)果：

my $x = join ":", 4, 6, 8, 10, 12; #$x 為 "4:6:8:10:12"

列表上下文中的 m//

在列表 context 中使用模式匹配(m//)時,如果匹配成功返回值為內(nèi)存變量值的列表;如果匹配失敗則為空列表：

$_ = "Hello there, neighbor!";my($first, $second, $third) =/(\S+) (\S+), (\S+)/;print “$second is my $third\n”  ;

在 s/// 中介紹的 /g 修飾符也可在 m// 中使用,它允許你在字符串中的多處進行匹配。在這里,由括號括起來的模式將在每一次匹配成功時返回其內(nèi)存中所存放的值：

my $text = "Fred dropped a 5 ton granite block on Mr. Slate";my @words = ($text =~ /([a-z]+)/ig);print "Result: @words\n";#Result: Fred dropped a ton granite block on Mr slate

如果有不止一對括號,每一次返回不止一個字符串。例如將字符串放入 hash 中,如下：

my $data = "Barney Rubble Fred Flintstone Wilma Flintstone";my %last_name = ($data =~ / (\w+)\S+(\w+)/g);

每當模式匹配成功時,將返回一對值。這些一對一對的值就成了 hash 中的 key/value 對。

更強大的正則表達式

非貪婪的數(shù)量詞

各符號對應(yīng)的非貪婪匹配：

+  -->  /fred.+?barney/*  -->  s#<BOLD>(.*?)</BOLD>#$1#g;{5,10}?{8,}??  -->  ??

在命令行進行修改

$ perl –p –i.bak –w –e 's/Randall/Randal/g' fred*.dat

-p 要求 Perl 為你寫一個程序。它算不上是一個完整的程序;看起來有些像下面的：

while(<>) {print;}

更多控制結(jié)構(gòu)

unless 控制結(jié)構(gòu)

在 if 控制結(jié)構(gòu)中,只有條件為真時,才執(zhí)行塊中的代碼。如果你想在條件為假時執(zhí)行,可以使用 unless:

unless ($fred =~ /^[A-Z_]\w*$/i) {print "The value of \$fred doesn't look like a Perl identifier name.\n";}

unless 的含義是：除非條件為真,否則執(zhí)行塊中的代碼。這和在 if 語句的條件表達式前面加上!(取反)所得結(jié)果是一樣的。

另一種觀點是,可以認為它自身含有 else 語句。如果不太明白 unless 語句,你可以把它用 if 語句來重寫(頭腦中,或者實際的重寫) ：

if ($fred =~ /^[A-Z_]\w*$/i) {#什么也不做} else {print "The value of \$fred doesn't look like a Perl identifier name.\n";}

unless 和 else 一起

unless ($mon =~ /^Feb/) {print "This month has at least thirty days.\n";} else {print "Do you see what's going on here?\n";}

until 控制結(jié)構(gòu)

有時,希望將 while 循環(huán)的條件部分取反。此時,可以使用 until：

until ($j > $i) {$j *= 2;}

表達式修飾符

為了得到更緊湊的形式,表達式后可以緊接控制修飾語。如,if 修飾語可以像 if 塊那樣使用：

print "$n is a negative number.\n" if $n<0;

等同下面代碼：

if ($n < 0) {print "$n is a negative number.\n";}

雖然被放在后面，條件表達式也是先被求值的。這和通常的的從左到右的順序相反。要理解 Perl 代碼,應(yīng)當像 Perl 內(nèi)部的編譯器那樣,將整個語句讀完,來其具體的含義。

還有一些其它的修飾語：

&error ("Invalid input") unless &valid($input);$i *= 2 unitl $i > $j;print "", ($n += 2) while $n <10;&greet($_) foreach @person;

The Naked Block 控制結(jié)構(gòu)

被稱為“裸的”塊是指沒有關(guān)鍵字或條件的塊。假如有一個 while 循環(huán),大致如下:

while(condition) {body;body;body;}

將關(guān)鍵字 while 和條件表達式去掉,則有了一個“裸的”塊:

{body;body;body;}

“裸的”塊看起來像 while 或 foreach 循環(huán),除了它不循環(huán)外;它執(zhí)行“循環(huán)體”一次,然后結(jié)束。它根本就沒循環(huán)!

你也可能在其它地方使用過“裸的”塊,這通常是為臨時變量提供作用域:

{print "Please enter a number:";chomp(my $n = <STDIN>);my $root = sqrt $n;            #計算平方根print "The square root of $n is $root.\n";}

elsif 語句

自增和自減 (同C)

my @people = qw{ fred barney fred Wilma dino barney fred pebbles};my %count;                              #新的空的 hash$count{$_}++ foreach @people;       #根據(jù)情況創(chuàng)建新的 keys 和 values

第一次執(zhí)行 foreach 循環(huán)時,$count{$_}自增1。此時,$count{"fred"} 從 undef (由于之前 hash 中不存在)變成1。第二次執(zhí)行 foreach 循環(huán)時,$count{"barney"} 變成1; 接著,$count{"fred"} 變成2。每執(zhí)行一次循環(huán),%count 中的某個元素增1,或者新元素被創(chuàng)建。循環(huán)結(jié)束時,$count{"fred"} 值為3。這提供了一種查看某個元素是否存在于列表之中,以及其出現(xiàn)次數(shù)的方法。

for 控制結(jié)構(gòu) (同C)

for (initialization; test; increment) {body;body;}

foreach 和 for 的關(guān)系

對于 Perl 解析器(parser)而言, 關(guān)鍵字 foreach 和 for 是等價的。也就是說, Perl 遇見其中之一時, 和遇見另一個是一樣的。Perl 通過括號能理解你的目的。如果其中有兩個分號,則是 for 循環(huán)(和我們剛講的類似); 如果沒有,則為 foreach 循環(huán):

for (1..10) {                                #實際上是 foreach 循環(huán),從1到10print "I can count to $_!\n";}

這實際是一個 foreach 循環(huán),但寫作 for。除了本例外,本書后面均寫作 foreach。在實際代碼中,你覺得 Perler 會輸入這四個多余的字符嗎?除了新手外,一般均寫作 for,你也應(yīng)當像 Perl 那樣,通過查看括號內(nèi)分號個數(shù)來判斷。

循環(huán)控制

last 操作

last 會立刻結(jié)束循環(huán)。(這同 C 語言或其它語言中的 "break" 語句類似)。它從循環(huán)塊中“緊急退出” 。當執(zhí)行到 last,循環(huán)即結(jié)束,如下例 ：

#輸出所有出現(xiàn) fred 的行,直到遇見 _ _END_ _標記while(<STDIN>){if(/_ _ END_ _/){#這個標記之后不會有其它輸入了last;}elsif(/fred/){print;}}##last 跳轉(zhuǎn)到這里##

next 操作 (同C的中 continue)

redo 操作

循環(huán)控制的第三個操作是 redo。它會調(diào)到當前循環(huán)塊的頂端,不進行條件表達式判斷以及接著本次循環(huán)。(在 C 或類似語言中沒有這種操作)下面是一個例子:

# 輸入測試my @words = qw{ fred barney pebbles dino Wilma betty };my $errors = 0;foreach(@words){##redo 跳到這里##print "Type the word '$_' : ";chomp(my $try = <STDIN>);if($try ne $_){print "sorry -- That's not right.\n\n";$errors++;redo;                          #跳轉(zhuǎn)到循環(huán)頂端}}print "You've completed the test, with $errors errors.\n";

標簽塊

要給循環(huán)體加上標簽,可在循環(huán)前面加上標簽和冒號。在循環(huán)體內(nèi),可以根據(jù)需要在 last, next,或n者 redo 后加上標簽名,如：

LINE: while(<>){foreach (split){last LINE if /_ _END_ _/; # 退出 LINE 循環(huán)...}}

邏輯操作符 && 和 ||

短路操作符

和 C(以及類似的語言)不同的地方是,短路操作的結(jié)果是最后被執(zhí)行語句的返回值,而非僅僅是一個 Boolean 值。

my $last_name = $last_name{$someone} || '(No last name)';

三元操作符 ?:

當 Larry 決定 Perl 應(yīng)當具有哪些操作符時,他不希望以前的 C 程序員在 Perl 中找不到 C 中出現(xiàn)過的操作符,因此他在 Perl 中實現(xiàn)了所有 C 的操作符。這意味著 C 中最容易混淆的操作符:三元操作符(?:)也被移植過來了。雖然它帶來了麻煩,但有時也是非常有用的。

Express ? if_true_expr : if_false_expr

my $size =($width < 10 ) ? "small":($width < 20) ? "medium":($width < 50) ? "large":"extra_large"; #default

控制結(jié)構(gòu)： 使用部分求值的操作符

前面三個操作符,均有一個共同的特殊性質(zhì):根據(jù)左側(cè)的值(true 或 false),來判斷是否執(zhí)行右側(cè)代碼。有時會被執(zhí)行,有時不會。由于這個理由,這些操作符有時叫做部分求值(partial-evaluation)操作符,因為有時并非所有的表達式均被執(zhí)行。部分求值操作符是自動的控制結(jié)構(gòu)。并非 Larry 想引入更多的控制結(jié)構(gòu)到 Perl 中來。而是當他決定將這些部分求值操作符引進 Perl 后,它們自動成了控制結(jié)構(gòu)。畢竟,任何可以激活或解除某塊代碼的執(zhí)行即被稱作控制結(jié)構(gòu)。

文件校驗

文件檢測操作

如果程序會建立新的文件,在程序創(chuàng)建新文件之前,我們應(yīng)先確定是否存在同名的文件,以免重要數(shù)據(jù)被覆蓋掉。對于這種問題,我們可以使用– 選項,檢測是否存在相同名字的文件:

die "Oops! A file called '$filename' already exists.\n"if -e $filename;

如果文件在過去28 天內(nèi)都未被修改,輸出警告：

warn "Config file is looking pretty old!\n"if -M CONFIG > 28;

下例首先檢查文件列表，找到那些大于 100KB 的文件。如果一個文件僅是很大, 我們不一定會將其移到備份磁帶上去，除非同時其在最近 90 天內(nèi)都未被訪問。

my @ariginal_files = qw/ fred barney betty Wilma pebbles dino bam-bamm /;my @big_old_files; #要移到備份磁帶上的文件foreach my $filename (@original_files){push @big_old_files, $filenameif -s $filename > 100_100 and -A $filename > 90;}

stat 和 lstat 函數(shù)

my ($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blockes)= stat($filename);

localtime 函數(shù)

my($sec, $min, $hour, $day, $mon, $year, $wday, $yday, $isdst)= localtime $timestamp;

my $timestamp = 1180630098;my $date = localtime $timestamp;

gmtime

my $now = gmtime; #得到當前的時間

位操作

目錄操作

在目錄樹上移動

chdir "/etc" or die "cannot chdir to /etc: $!";

由于這是系統(tǒng)請求,錯誤發(fā)生時將給變量$!賦值。通常應(yīng)當檢查$!的值,因為它將告訴你 chdir 失敗的原因。

Globbing

通常,shell 將每個命令行中的任何的文件名模式轉(zhuǎn)換成它所匹配的文件名。這被稱作 globbing。例如,在 echo 命令后使用了文件名模式*.pm,shell 會將它轉(zhuǎn)換成它所匹配的文件名:

$ echo *.pmbarney.pm dino.pm fred.pm wilma.pm$

$ cat > show_argsforeach $arg (@ARGV) {print "one arg is $arg\n";}^D$ perl show_args *...

show-args 不需要知道如何進行 globbing,這些名字已經(jīng)被處理后存在@ARGV 中了。

在 Perl 程序中也可以使用 Glob 匹配。

my @all_files = glob "*" ;my @pm_files = glob "*.pm";

@all_files 得到了當前目錄下的所有文件,這些文件按照字母排序的,不包括由點 (.)開頭的文件。

Globbing 的替換語法

雖然我們?nèi)我獾氖褂?globbing 這個術(shù)語,我們也談?wù)?glob 操作,但在許多使用 globbing 的程序中并沒有出現(xiàn) glob 這個字眼。為什么呢?原因是,許多這類代碼在 glob 操作被命名前就寫好了。它使用一對尖括號(<>), 和從文件句柄讀入操作類似：

my @all_files = <*>;     # 基本上同 @all_files = glob "*" 一樣

my $dir = "/etc";my @dir_files = <$dir/* $dir/.*>;

目錄句柄

從給定目錄得到其文件名列表的方法還可以使用目錄句柄(directory handle)。目錄句柄外形及其行為都很像文件句柄。打開(使用 opendir 而非 open),從中讀入(使用 readdir 而非 readline),關(guān)閉(使用 closedir 而非 close)。不是讀入文件的內(nèi)容,而是將一個目錄中的文件名(以及一些其它東西)讀入,如下例：

my $dir_to_process = "/etc";opendir DH, $dir_to_process or die "Cannot open $dir_to_process: $!";foreach $file(readdir DH) {print "One file in $dir_to_process is $file\n";}closedir DH;

刪除文件 unlink

unlink "slate", "bedrock", "lava";

這里有一個鮮為人知的 Unix 事實。你可以有一個文件不可讀,不可寫,不可執(zhí)行,甚至你并不擁有它,例如屬于別人的,但你仍然可以刪除它。這時因為 unlink 一個文件的權(quán)限同文件本身的權(quán)限是沒有關(guān)系的;它和目錄所包含的文件權(quán)限有關(guān)。

重命名文件

rename "over_there/some/place/some_file", "some_file";

鏈接文件

要找出符號連接指向的地方,使用 readlink 函數(shù)。它會告訴你符號連接指向的地方,如果參數(shù)不是符號連接其返回 undef:

my $where = readlink "carroll";        # 得到 "dodgson"my $perl = readlink "/usr/local/bin/perl"  # 可能得到 Perl 放置的地方

創(chuàng)建和刪除目錄

mkdir "fred", 0755 or warn "Cannot make fred directory: $!";rmdir glob "fred/*";          # 刪除 fred/下面所有的空目錄

修改權(quán)限

chmod 0755, "fred", "barney";

改變所有者

my $user = 1004;my $group = 100;chown $user, $group, glob "*.o";

如果要使用用戶名：

defined(my $user = getpwnam "merlyn") or die "user bad";defined(my $group = getprnam "users") or die "group bad";chown $user, $group, glob "/home/Merlyn/*";

defined 函數(shù)驗證返回值是否為 undef, 如果請求的 user 或 group 不存在,則返回 undef。chown 函數(shù)返回其改變的文件的個數(shù),而錯誤值被設(shè)置在$!之中。

改變時間戳

my $now = time;my $ago = $now -24*60*60;  # 一天的秒數(shù)utime $now,$ago,glob "*"   # 設(shè)成當前訪問的,一天之前修改的

字符串和排序

使用索引尋找子串

$where = index($big, $small);

Perl 查找子串第一次在大字符串中出現(xiàn)的地方,返回第一個字符的位置。字符位置是從 0 開始編號的。如果子串在字符串的開頭處找到,則 index 返回 0。如果一個字符后,則返回1,依次類推。如果子串不存在,則返回-1。

使用 substr 操作子串

$part = substr($string, $initial_position, $length);

它有三個參數(shù):一個字符串,一個從 0 開始編號的初始位置(類似于 index 的返回值) ,以及子串的長度。返回值是一個子串:

my $mineral = substr("Fred J. Flintstone", 8, 5);   # 得到 "Flint"my $rock = substr "Fred J. Flintstone", 13, 1000;  # 得到 "stone"my $pebble = substr "Fred J. Flintsone", 13;     #  同上，得到 "stone"my $out = substr ("some very long string", -3, 2);       # $out 得到 "in"

substr 選則的子串可以就地修改！

#!/usr/bin/perl -wuse strict;my $string = "Hello, world!";substr($string,6) = "Jian Lee!";print $string . "\n";

最后輸出為： “Hello,Jian Lee!”

使用 sprintf 格式化數(shù)據(jù)

sprintf 函數(shù)的參數(shù)和 printf 的參數(shù)完全相同(除了可選的文件句柄外), 但它返回的是被請求的字符串,而非打印出來。這對于希望將某個格式的字符串存入變量以供將來使用的情況非常方便,或者你想比 printf 提供的方法,更能控制結(jié)果:

my $data_tag = sprintf   "%4d/%02d/%02d %02d:%02d:%02d", $yr, $mo, $da, $h, $m, $s;

進程管理

system 函數(shù)

在 Perl 中調(diào)用子進程來運行程序的最簡單方法是使用 system 函數(shù)。例如,要調(diào)用 Unix 的 date 命令,看起來如下:

system "date";

系統(tǒng)函數(shù)的參數(shù)和通常在 shell 中輸入的是一樣的。如果是復(fù)雜一些的命令,如 “ – $HOME” ,我們也只需將它們放入?yún)?shù)中:

system 'ls -l $HOME';

我們這里將雙引號變成了單引號,因為$HOME 是一個 shell 變量。否則,shell 看不到美元符號,因為 Perl 會將它用值進行替換。當然,我們也可以這樣寫:

system "ls -l \$HOME";

exec 函數(shù)

exec 和 system 完全一樣，除了一點！exec 打開一個進程代替當前的 Perl 程序教程，exec 執(zhí)行的進程結(jié)束不再返回到perl教程。

環(huán)境變量

Perl ， 環(huán)境變量可以由 %ENV 得到。

$ENV{'PATH'} =  "/home/rootbeer/bin:$ENV('PATH')";delete $ENV{'IFS'};my $make_result = system "make";

使用反引號得到輸出

my $now = `date`;                # 捕獲 date 的輸出print "The time is now $now";    # 已經(jīng)有換行符

像文件句柄一樣處理進程

開始一個并發(fā)(并行)子進程的語法是將命令作為“文件名”傳給 open,并在其前面或后面加上豎線(|),豎線是“管道(pipe)”符?；谶@些原因,這通常叫做管道打開 (piped open) :

open DATE, "date|" or die "Cannot pipe from date: $!";open MAIL, "|mail merlyn" or die "Cannot pipe to mail: $!";

fork 函數(shù)

defined (my $pid= fork) or die "Cannot fork: $!";unless ($pid){#子進程在這里exec "date";die "cannot exec date: $!";}#父進程在這里waitpid($pid, 0);

發(fā)送和接受信號

kill 2, 4201 or die "Cannot signal 4201 with SIGINT: $!";

Perl 模塊

查找

http://search.cpan.org/

$ perldoc CGI

安裝模塊

通常模塊使用 MakeMaker ，可以這樣安裝：

$ perl Makerfile.PL# $ perl Makerfile.PL PREFIX=/Users/fred/lib$ make install

一些模塊的創(chuàng)建者使用另一個模塊:Module::Build,來構(gòu)造及安裝他們的模塊。此時的命令如下:

$ perl Build.PL$./Build install

使用 CPAN.pm

$ perl -MCPAN -e shell$ cpan Module::CoreList LWP CGI::Prototype

使用簡單的模塊

File::Basename

use File::Basename;my $name = "/usr/local/bin/perl";my $basename = basename $name; #得到 "perl"

僅使用模塊中的一些函數(shù)

use File::Basename qw/ basename /;

下面做法不引入任何函數(shù)：

use File::Baename qw/ /;use File::Basename ( );

沒有引入任何函數(shù)時，如果要使用函數(shù)，就必須用全名：

use File:Basename qw/ /;            # 沒有引入函數(shù)my $betty = &dirname($wilma);       # 使用我們自己的子程序 &dirname(這里沒有顯示)my $name = "/usr/local/bin/perl";my $dirname = File::Basename::dirname $name; # 使用模塊中的 dirname

File:Spec 模塊

use File::Spec;#得到上面的$dirname, $basename 的值my $new_name = File::Spec->catfile($dirname, $basename);rename($old_name, $new_name)or warn "Can't rename '$old_name' to '$new_name': $!";