1. 程式人生 > >perl中grep,sort,map用法總結

perl中grep,sort,map用法總結


簡簡單單講map
(一)map函式
map BLOCK LIST
map EXPR, LIST
map函式對LIST裡的每個元素按BLOCK或EXPR進行計算,遍歷LIST時,臨時將LIST裡的每個元素賦值給$_變數。map對每次的計算返回一個結果列表,它在列表上下文裡計算BLOCK或EXPR。每個LIST元素可能在輸出列表裡產生0個,1個,或多個元素。
(仙子注:上文是說遍歷每個LIST元素時產生一個結果列表,而不是說總的map結果是個列表,不要搞混了哦。)
在標量上下文裡,map返回結果列表的元素數量。在HASH上下文裡,輸出列表(a,b,c,d...)會變成這樣的形式: ( a =>; b, c =>; d, ... )。假如輸出列表的元素數量非對稱,那麼最後的hash元素的值就是undef了。
避免在BLOCK或EXPR裡修改$_,因為這會修改LIST裡的元素。另外,避免使用map返回的的列表作為左值,因為這也會修改LIST裡的元素。(所謂左值,就是在某個表示式左邊的變數。)
(二)Map vs. grep vs. foreach
map跟grep一樣,從數組裡選擇元素。下列2句是一樣的:
@selected = grep EXPR, @input;
@selected = map { if (EXPR) { $_ } } @input;
另外,map也是foreach陳述的特殊形式。假如@transformed陣列當前未定義或為空,那麼下列2句亦相等:
foreach (@input) { push @transformed, EXPR; }
@transformed = map EXPR, @input;
通常,用grep來從數組裡選擇元素,用map來從數組裡轉換元素。當然,陣列處理也能使用標準的迴圈語句來完成(foreach, for, while, until, do while, do until, redo)。
(三)map用法示例
1. 轉換檔名為檔案大小
@sizes = map { -s $_ } @file_names;
-s是個檔案測試操作符,它返回某個檔案的size。所以上面這句就返回@file_names數組裡每個檔案的大小,結果也是個陣列。
2. 轉換陣列到hash:找到某個陣列值的索引
代替重複的搜尋陣列,我們可以用map來轉換陣列到hash,並通過hash關鍵字來進行直接查詢。如下的map用法相對於重複的陣列搜尋,更簡單高效。
@teams = qw(Miami Oregon Florida Tennessee Texas
        Oklahoma Nebraska LSU Colorado Maryland);
%rank = map { $teams[$_], $_ + 1 } 0 .. $#teams;
print "Colorado: $rank{Colorado}/n";
print "Texas: $rank{Texas} (hook 'em, Horns!)/n";
列印結果是:
Colorado: 9
Texas: 5 (hook 'em, Horns!)
上述code容易理解哦,0 ..$#teams 是個列表,$#teams代表@teams最後一個元素的下標值(這裡是9),所以這個列表就是0-9這幾個數了。map遍歷上述列表,將每個列表元素臨時設定為$_,並對$_在中間的{}裡進行計算;{ $teams[$_], $_ + 1 },這裡每次計算後返回一個2元素的列表,列表結果是某個陣列值和對應的陣列下標加1,明白了呀?
由於對每個LIST元素進行計算時,都產生一個2元素的列表,所以總的map結果就可看作一個hash了。hash關鍵字就是陣列元素,hash值是對應的陣列下標加1。
3. 轉換陣列到hash:查詢拼錯單詞
轉換陣列到hash是map的最普遍用法。在本示例裡,hash的值是無關緊要的,我們僅檢查hash關鍵字是否存在。
%dictionary = map { $_, 1 } qw(cat dog man woman hat glove);
@words = qw(dog kat wimen hat man gloove);
foreach $word (@words) {
if (not $dictionary{$word}) {  
    print "Possible misspelled word: $word/n";
}
}
列印結果是:
Possible misspelled word: kat
Possible misspelled word: wimen
Possible misspelled word: gloove
看看第1句的map用法,它跟前面示例裡的差不多哦。qw()這裡是個列表,map對這個列表裡的每個元素進行{ $_, 1 }計算,每次計算的結果返回一個2元素的列表,換句話說,就是%dictionary的key和value呀。所以map最終的結果就是一個hash了,關鍵字是qw()裡的元素,值總是1,無關緊要的。
然後下面的foreach語句就容易了哦,如果@words裡的元素不構成%dictionary的關鍵字的話,就列印一條出錯訊息。如果把%dictionary看成標準字典的話,那麼就可用它來檢驗你自己的@words字型檔裡是否有錯字了呀。
4. 轉換陣列到hash:儲存選中的CGI引數
hash通常是儲存傳遞給程式或子函式的引數的最便利的方法,而map通常是建立這個hash的最便利的方法。
use CGI qw(param);
%params = map { $_, ( param($_) )[0] }
        grep { lc($_) ne 'submit' } param();
這裡你可能要了解一下CGI模組的基本知識哦。param()呼叫返回CGI引數名的列表;param($_)呼叫返回指定的CGI引數名的值。假如param($_)返回某個CGI引數的多個值,那麼( param($_) )[0]只取第一個值,以便hash仍被良好定義。
上述code的意思是,將param()的結果作為輸入列表,它的元素是多個CGI引數名,然後從這些引數名裡grep出引數名不等於'submit'的,結果是一個臨時列表,map的{ $_, ( param($_) )[0] }語句再次遍歷這個臨時列表,並獲取到引數名,和對應的引數值,將結果賦給%params。所以%params裡就儲存了頁面提交過來的,除了submit外的其他CGI引數名和引數值(只取第1個)。
很巧妙的用法,是不是?它結合用了map和grep,使code顯得很簡潔。
(話外一句:偶在Cornell讀書時,偶的師兄們很喜歡這種用法,他們往往在中間多次使用map,grep,sort進行堆疊,結果產生的code也許高效,但不容易看懂。讀這樣的code時,你要從右往左讀,因為右邊表示式產生的臨時列表,是左邊表示式的輸入條件。)
5. 產生隨機密碼
@a = (0 .. 9, 'a' .. 'z');
$password = join '', map { $a[int rand @a] } 0 .. 7;
print "$password/n";
每次執行它會得到不同的結果,但長度總是8位,由0 .. 7這個決定。如下是可能的輸出:
y2ti3dal
它是個隨機值,也許你能用它來做密碼。
這裡,需要先明白幾個函式,rand產生一個隨機值,它後面的@a其實是個標量哦,表示@a陣列的長度,rand @a的結果可能是個小數,所以再用int函式來取整。int rand @a的結果是個整數,它>;=0但小於@a的長度。所以$a[int rand @a]就表示從@a數組裡隨機取出一個字元了。0..7表示總共取8次,返回的結果再用join連線起來,就構成一個8位隨機密碼了呀。
當然,(0 .. 9, 'a' .. 'z')陣列元素太少了,你可以修改它,使其包含大小寫字元,數字和標點符號,這樣密碼強度就高些。
6. 從陣列元素裡剝離數字
已經說了哦,不要在EXPR裡修改LIST值。如下做法是不好的:
@digitless = map { tr/0-9//d; $_ } @array;
它雖然從陣列元素裡剝離了數字,但同樣破壞了該陣列,:(
如下做法是good:
@digitless = map { ($x = $_) =~ tr/0-9//d;  
            $x;
          } @array;
它將tr的結果賦給臨時變數$x,並返回$x的值,這樣就保護陣列了呀。
7. 列印"just another perl hacker",讓你暈到家
print map( { chr }
      ('10611711511603209711011111610410111' .
      '4032112101114108032104097099107101114')
      =~ /.../g
      ), "/n";
列印的結果是:
just another perl hacker
chr函式將單個數字轉換到相應的ASCII字元。()=~/.../g語法以3個數字長度為單位,分割數字串到新的串列表。
比較無聊的用法,還不如用pack()和unpack(),:P
8. 轉置矩陣
@matrix = ( [1, 2, 3], [4, 5, 6], [7, 8, 9] );
foreach $xyz (@matrix) {
print "$xyz->;[0] $xyz->;[1] $xyz->;[2]/n";
}
@transposed =
map { $x = $_;
      [ map { $matrix[$_][$x] } 0 .. $#matrix ];
    } 0 .. $#{$matrix[0]};
print "/n";
foreach $xyz (@transposed) {
print "$xyz->;[0] $xyz->;[1] $xyz->;[2]/n";
列印結果是:
1 2 3
4 5 6
7 8 9
1 4 7
2 5 8
3 6 9
這裡稍微有點複雜哦,讓我們分2步看看。
@matrix = ( [1, 2, 3], [4, 5, 6], [7, 8, 9] );
foreach $xyz (@matrix) {
print "$xyz->;[0] $xyz->;[1] $xyz->;[2]/n";
}
這裡不難明白,( [1, 2, 3], [4, 5, 6], [7, 8, 9] ) 是個陣列,它的每個元素又是個匿名陣列,這樣在$xyz遍歷陣列時,$xyz->;[0],$xyz->;[1],$xyz->;[2]就可以訪問到匿名數組裡的元素了。所以會打印出:
1 2 3
4 5 6
7 8 9
@transposed =
map { $x = $_;
      [ map { $matrix[$_][$x] } 0 .. $#matrix ];
    } 0 .. $#{$matrix[0]};
這裡複雜點,0 .. $#{$matrix[0]}是個列表,$#{$matrix[0]}表示$matrix[0]這個匿名陣列的最大下標值,0 .. $#{$matrix[0]}表示矩陣的橫向。$x = $_;這裡將$_的值賦給$x,為什麼呢?因為它後面又有個map嘛,$_的值會改變的,所以要先儲存起來。外圍的map返回的值是[]裡的map計算出來的一個列表,以[]匿名陣列形式返回。[]裡面的map是這樣的,它的輸入LIST是0 .. $#matrix, 表示矩陣的縱向了。$matrix[$_][$x]這裡先縱再橫,就把矩陣值置換了一下。所以返回的結果列表@transposed就包含置換後的矩陣了哦。
是否有點糊塗?那舉例看看。這樣看可能好點:
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
外圍的map遍歷時,先是橫向下標遍歷,停留在橫向0位。然後第二個map,就是縱向下標遍歷了,它要遍歷所有縱向下標,這樣在橫向0位,就先返回[1,4,7]的列表了,然後在橫向1位,又返回[2,5,8]的列表,最後在橫向2位,返回[3,6,9]的列表。
還不明白呀?那偶也講不清了,自己多想想,:P
9. 查詢質數:警示用法
foreach $num (1 .. 1000) {
@expr = map { '$_ % ' . $_ . ' &&' } 2 .. int sqrt $num;
if (eval "grep { @expr 1 } $num") { print "$num " }
}
列印結果是:
1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 ...
該code能工作,但它如此麻煩,違背了程式最基本的明晰法則。用如下直觀的code代替它就可以了呀:
CANDIDATE: foreach $num (1 .. 1000) {
foreach $factor (2 .. int sqrt $num) {
    unless ($num % $factor) { next CANDIDATE }
}
print "$num ";
}
記住,讓你的Code簡潔哦~~
一) sort函式
sort LIST
sort BLOCK LIST
sort SUBNAME LIST
sort的用法有如上3種形式。它對LIST進行排序,並返回排序後的列表。假如忽略了SUBNAME或BLOCK,sort按標準字串比較順序來進行(例如ASCII順序)。如果指定了SUBNAME,它實際上是個子函式的名字,該子函式對比2個列表元素,並返回一個小於,等於,或大於0的整數,這依賴於元素以何種順序來sort(升序,恆等,或降序)。也可提供一個BLOCK作為匿名子函式來代替SUBNAME,效果是一樣的。
被比較的2個元素,會被臨時賦值給變數$a和$b。它們以引用傳遞,所以不要修改$a或$b。假如使用子函式,它不能是遞迴函式。
(二) 用法示例
1. 以數字順序sort
@array = (8, 2, 32, 1, 4, 16);
print join(' ', sort { $a <=>; $b } @array), "/n";
列印結果是:
1 2 4 8 16 32
與之一樣的是:
sub numerically { $a <=>; $b };
print join(' ', sort numerically @array), "/n";
這個很容易理解哦,它只是按自然數的順序進行sort,偶就不細講了。
2.1 以ASCII順序(非字典順序)進行sort
@languages = qw(fortran lisp c c++ Perl python java);
print join(' ', sort @languages), "/n";
列印結果:
Perl c c++ fortran java lisp python
這等同於:
print join(' ', sort { $a cmp $b } @languages), "/n";
按ASCII的順序進行排序,也沒什麼說的哦。
注意,如果對數字按ASCII順序進行sort的話,結果可能與你想的不同:
print join(' ', sort 1 .. 11), "/n";
1 10 11 2 3 4 5 6 7 8 9
2.2 以字典順序sort
use locale;
@array = qw(ASCII ascap at_large atlarge A ARP arp);
@sorted = sort { ($da = lc $a) =~ s/[/W_]+//g;
          ($db = lc $b) =~ s/[/W_]+//g;
          $da cmp $db;
          } @array;
print "@sorted/n";
列印結果是:
A ARP arp ascap ASCII atlarge at_large
use locale是可選的--它讓code相容性更好,假如原始資料包含國際字元的話。use locale影響了cmp,lt,le,ge,gt和其他一些函式的操作屬性--更多細節見perllocale的man page。
注意atlarge和at_large的順序在輸出時顛倒了,儘管它們的sort順序是一樣的(sort中間的子函式刪掉了at_large中間的下劃線)。這點會發生,是因為該示例執行在perl 5.005_02上。在perl版本5.6前,sort函式不會保護有一樣values的keys的先後順序。perl版本5.6和更高的版本,會保護這個順序。
注意哦,不管是map,grep還是sort,都要保護這個臨時變數$_(sort裡是$a和$b)的值,不要去修改它。在該code裡,在對$a或$b進行替換操作s/[/W_]+//g前,先將它們重新賦值給$da和$db,這樣替換操作就不會修改原始元素哦。
3. 以降序sort
降序sort比較簡單,把cmp或<=>;前後的運算元調換下位置就可以了。
sort { $b <=>; $a } @array;
或者改變中間的塊或子函式的返回值的標記:
sort { -($a <=>; $b) } @array;
或使用reverse函式(這有點低效,但也許易讀點):
reverse sort { $a <=>; $b } @array;
4. 使用多個keys進行sort
要以多個keys來sort,將所有以or連線起來的比較操作,放在一個子函式裡即可。將主要的比較操作放在前面,次要的放在後面。
# An array of references to anonymous hashes
@employees = (
{ FIRST =>; 'Bill',   LAST =>; 'Gates',  
    SALARY =>; 600000, AGE =>; 45 },
{ FIRST =>; 'George', LAST =>; 'Tester'  
    SALARY =>; 55000, AGE =>; 29 },
{ FIRST =>; 'Steve', LAST =>; 'Ballmer',  
    SALARY =>; 600000, AGE =>; 41 }
{ FIRST =>; 'Sally', LAST =>; 'Developer',
    SALARY =>; 55000, AGE =>; 29 },
{ FIRST =>; 'Joe',   LAST =>; 'Tester',  
    SALARY =>; 55000, AGE =>; 29 },
);
sub seniority {
$b->;{SALARY}   <=>; $a->;{SALARY}
or $b->;{AGE}   <=>; $a->;{AGE}
or $a->;{LAST}   cmp $b->;{LAST}
or $a->;{FIRST}   cmp $b->;{FIRST}
}
@ranked = sort seniority @employees;
foreach $emp (@ranked) {
print "$emp->;{SALARY}/t$emp->;{AGE}/t$emp->;{FIRST}
    $emp->;{LAST}/n";
}
列印結果是:
600000 45     Bill Gates
600000 41     Steve Ballmer
55000   29     Sally Developer
55000   29     George Tester
55000   29     Joe Tester
上述code看起來很複雜,實際上很容易理解哦。@employees陣列的元素是匿名hash。匿名hash實際上是個引用,可使用->;操作符來訪問其值,例如$employees[0]->;{SALARY}可訪問到第一個匿名hash裡SALARY對應的值。所以上述各項比較就很清楚了,先比較SALARY的值,再比較AGE的值,再比較LAST的值,最後比較FIRST的值。注意前2項比較是降序的,後2項是升序的,不要搞混了哦。
5. sort出新陣列
@x = qw(matt elroy jane sally);
@rank[sort { $x[$a] cmp $x[$b] } 0 .. $#x] = 0 .. $#x;
print "@rank/n";
列印結果是:
2 0 1 3
這裡是否有點糊塗呀?仔細看就清楚了。0 .. $#x是個列表,它的值是@x陣列的下標,這裡就是0 1 2 3。$x[$a] cmp $x[$b] 就是將@x裡的各個元素,按ASCII順序進行比較。所以sort的結果返回對@x的下標進行排序的列表,排序的標準就是該下標對應的@x元素的ASCII順序。
還不明白sort返回什麼?讓我們先打印出@x裡元素的ASCII順序:
@x = qw(matt elroy jane sally);
print join ' ',sort { $a cmp $b } @x;
列印結果是:elroy jane matt sally
它們在@x裡對應的下標是1 2 0 3,所以上述sort返回的結果就是1 2 0 3這個列表了。@rank[1 2 0 3] = 0 .. $#x 只是個簡單的陣列賦值操作,所以@rank的結果就是(2 0 1 3)了。
6. 按keys對hash進行sort
%hash = (Donald =>; Knuth, Alan =>; Turing, John =>; Neumann);
@sorted = map { { ($_ =>; $hash{$_}) } } sort keys %hash;
foreach $hashref (@sorted) {
($key, $value) = each %$hashref;
print "$key =>; $value/n";
}
列印結果是:
Alan =>; Turing
Donald =>; Knuth
John =>; Neumann
上述code不難明白哦。sort keys %hash按%hash的keys的ASCII順序返回一個列表,然後用map進行計算,注意map這裡用了雙重{{}},裡面的{}是個匿名hash哦,也就是說map的結果是個匿名hash列表,明白了呀?
所以@sorted數組裡的元素就是各個匿名hash,通過%$hashref進行反引用,就可以訪問到它們的key/value值了。
7. 按values對hash進行sort
%hash = ( Elliot =>; Babbage,
      Charles =>; Babbage,
      Grace =>; Hopper,
      Herman =>; Hollerith
    );
@sorted = map { { ($_ =>; $hash{$_}) } }
        sort { $hash{$a} cmp $hash{$b}
              or $a cmp $b
            } keys %hash;
foreach $hashref (@sorted) {
($key, $value) = each %$hashref;
print "$key =>; $value/n";
}
列印結果是:
Charles =>; Babbage
Elliot =>; Babbage
Herman =>; Hollerith
Grace =>; Hopper
本文作者如是說,偶覺得很重要:
與hash keys不同,我們不能保證hash values的唯一性。假如你僅根據values來sort hash,那麼當你增或刪其他values時,有著相同value的2個元素的sort順序可能會改變。為了求得穩定的結果,應該對value進行主sort,對key進行從sort。
這裡{ $hash{$a} cmp $hash{$b} or $a cmp $b } 就先按value再按key進行了2次sort哦,sort返回的結果是排序後的keys列表,然後這個列表再交給map進行計算,返回一個匿名hash列表。訪問方法與前面的相同,偶就不詳敘了。
8. 對檔案裡的單詞進行sort,並去除重複的
perl -0777ane '$, = "/n"; /
@uniq{@F} = (); print sort keys %uniq' file
大家試試這種用法,偶也不是很明白的說,:(
@uniq{@F} = ()使用了hash slice來建立一個hash,它的keys是檔案裡的唯一單詞;該用法在語意上等同於$uniq{ $F[0], $F[1], ... $F[$#F] } = ()。
各選項說明如下:
-0777   -   讀入整個檔案,而不是單行
-a     -   自動分割模式,將行分割到@F陣列
-e     -   從命令列讀取和執行指令碼
-n     -   逐行遍歷檔案:while (<>;) { ... }
$,     -   print函式的輸出域分割符
file   -   檔名
9. 高效sorting: Orcish演算法和Schwartzian轉換
對每個key,sort的子函式通常被呼叫多次。假如非常在意sort的執行時間,可使用Orcish演算法或Schwartzian轉換,以便每個key僅被計算1次。
考慮如下示例,它根據檔案修改日期來sort檔案列表。
# 強迫演算法--對每個檔案要多次訪問磁碟
@sorted = sort { -M $a <=>; -M $b } @filenames;
# Orcish演算法--在hash裡建立keys
@sorted = sort { ($modtimes{$a} ||= -M $a) <=>;
          ($modtimes{$b} ||= -M $b)
          } @filenames;
很巧妙的演算法,是不是?因為檔案的修改日期在指令碼執行期間是基本不變的,所以-M運算一次後,把它存起來就可以了呀。偶就經常這麼用的,:p
如下是Schwartzian轉換的用法:
@sorted = map( { $_->;[0] }  
          sort( { $a->;[1] <=>; $b->;[1] }
              map({ [$_, -M] } @filenames)
            )
        );
這個code結合用了map,sort分了好幾層,記住偶以前提過的方法,從後往前看。map({ [$_, -M] } @filenames)返回一個列表,列表元素是匿名陣列,匿名陣列的第一個值是檔名,第二個值是檔案的修改日期。
sort( { $a->;[1] <=>; $b->;[1] }...再對上述產生的匿名陣列列表進行sort,它根據檔案的修改日期進行sort。sort返回的結果是經過排序後的匿名陣列。
最外圍的map( { $_->;[0] }...就簡單了,它從上述sort產生的匿名數組裡提取出檔名。這個檔名就是根據修改日期進行sort過的呀,並且每個檔案只運行了一次-M。
這就是著名的Schwartzian轉換,這種用法在國外perl使用者裡很流行。記住仙子告訴你的Schwartzian概念哦,下次就不會被老外laugh at了,:p
本文作者說:
Orcish演算法通常更難於編碼,並且不如Schwartzian轉換文雅。我推薦你使用Schwartzian轉換作為可選擇的方法。
也請記住基本的優化code的規則:(1)不寫code;(2)在使code快速之前,先保證其正確;(3)在使code快速之前,先讓它清楚。
10. 根據最後一列來對行進行sort(Schwartzian轉換)
假如$str的值如下(每行以/n終結):
eir   11   9   2   6   3   1   1   81%   63%   13
oos   10   6   4   3   3   0   4   60%   70%   25
hrh   10   6   4   5   1   2   2   60%   70%   15
spp   10   6   4   3   3   1   3   60%   60%   14
按最後1個域的大小進行sort:
$str = join "/n",
        map { $_->;[0] }
          sort { $a->;[1] <=>; $b->;[1] }
              map { [ $_, (split)[-1] ] }
                split //n/, $str;
列印結果是:
eir   11   9   2   6   3   1   1   81%   63%   13
spp   10   6   4   3   3   1   3   60%   60%   14
hrh   10   6   4   5   1   2   2   60%   70%   15
oos   10   6   4   3   3   0   4   60%   70%   25
讓我們從後往前,一步一步看上述code:
split //n/, $str; 這裡返回一個列表,列表元素就是各個行了。
map { [ $_, (split)[-1] ] } 這裡的map求得一個匿名陣列列表,匿名陣列的值分別是整行,和該行的最後一列。使用Schwartzian轉換時,這步是關鍵哦,記著用map來構造你自己的匿名陣列列表,匿名陣列的第1個元素是最終需要的值,第2個元素是用於比較的值。
sort { $a->;[1] <=>; $b->;[1] } 對上1步中產生的匿名陣列,按第2個元素進行sort,它返回sort後的匿名陣列列表。
map { $_->;[0] } 對上1步中sort後的匿名陣列,提取出第1個元素,也就是整行哦。
$str = join "/n", 把上步中的各行用"/n"連線起來,並賦值給$str。
也許你會說:“怎麼這麼麻煩呀?偶不想用這種方式。”那麼,可用CPAN上的現成模組來代替:
use Sort::Fields;
@sorted = fieldsort [ 6, '2n', '-3n' ] @lines;
CPAN的模組文件很詳細的,自己看看呀。
11. 重訪高效sorting: Guttman-Rosler轉換
考慮如下示例:
@dates = qw(2001/1/1 2001/07/04 1999/12/25);
你想按日期升序對它們進行排序,哪種方法最有效呢?
最直觀的Schwartzian轉換可以這樣寫:
@sorted = map { $_->;[0] }
      sort { $a->;[1] <=>; $b->;[1]
          or $a->;[2] <=>; $b->;[2]
          or $a->;[3] <=>; $b->;[3]
          }
      map { [ $_, split m</>; $_, 3 ] } @dates;
然而,更高效的Guttman-Rosler轉換(GRT)這樣寫:
@sorted = map { substr $_, 10 }
      sort
      map { m|(/d/d/d/d)/(/d+)/(/d+)|;
          sprintf "%d-%02d-%02d%s", $1, $2, $3, $_
        } @dates;
本文作者說:
GRT方法難於編碼,並且比Schwartzian轉換更難閱讀,所以我推薦僅在極端環境下使用GRT。使用大的資料來源,perl 5.005_03和linux 2.2.14進行測試,GRT比Schwartzian轉換快1.7倍。用perl 5.005_02和windows NT 4.0 SP6進行測試,GRT比Schwartzian快2.5倍。
另外,perl 5.6及更高版本的sort使用Mergesort演算法,而5.6之前的sort使用Quicksort演算法,前者顯然快於後者,所以,要想求速度,也要升級你的perl版本哦。
(三)CPAN上關於sort的一些模組
File::Sort - Sort one or more text files by lines
Sort::Fields - Sort lines using one or more columns as the sort key(s)
Sort::ArbBiLex - Construct sort functions for arbitrary sort orders
Text::BibTeX::BibSort - Generate sort keys for bibliographic entries.
(一) Grep函式
grep有2種表達方式:
grep BLOCK LIST
grep EXPR, LIST
BLOCK表示一個code塊,通常用{}表示;EXPR表示一個表示式,通常是正則表示式。原文說EXPR可是任何東西,包括一個或多個變數,操作符,文字,函式,或子函式呼叫。
LIST是要匹配的列表。
grep對列表裡的每個元素進行BLOCK或EXPR匹配,它遍歷列表,並臨時設定元素為$_。在列表上下文裡,grep返回匹配命中的所有元素,結果也是個列表。在標量上下文裡,grep返回匹配命中的元素個數。
(二) Grep vs. loops
open FILE "<myfile" or die "Can't open myfile: $!";
print grep /terrorism|nuclear/i, <FILE>;;
這裡開啟一個檔案myfile,然後查詢包含terrorism或nuclear的行。<FILE>;返回一個列表,它包含了檔案的完整內容。
可能你已發現,如果檔案很大的話,這種方式很耗費記憶體,因為檔案的所有內容都拷貝到記憶體裡了。
代替的方式是使用loop(迴圈)來完成:
while ($line = <FILE>;) {
if ($line =~ /terrorism|nuclear/i) { print $line }
}
上述code顯示,loop可以完成grep能做的任何事情。那為什麼還要用grep呢?答案是grep更具perl風格,而loop是C風格的。
更好的解釋是:(1)grep讓讀者更顯然的知道,你在從列表裡選擇某元素;(2)grep比loop簡潔。
一點建議:如果你是perl新手,那就規矩的使用loop比較好;等你熟悉perl了,就可使用grep這個有力的工具。
(三) 幾個grep的示例
1. 統計匹配表示式的列表元素個數
$num_apple = grep /^apple$/i, @fruits;
在標量上下文裡,grep返回匹配中的元素個數;在列表上下文裡,grep返回匹配中的元素的一個列表。
所以,上述code返回apple單詞在@fruits陣列中存在的個數。因為$num_apple是個標量,它強迫grep結果位於標量上下文裡。
2. 從列表裡抽取唯一元素
@unique = grep { ++$count{$_} < 2 }
          qw(a b a c d d e f g f h h);
print "@unique/n";
上述code執行後會返回:a b c d e f g h
即qw(a b a c d d e f g f h h)這個列表裡的唯一元素被返回了。為什麼會這樣呀?讓我們看看:
%count是個hash結構,它的key是遍歷qw()列表時,逐個抽取的列表元素。++$count{$_}表示$_對應的hash值自增。在這個比較上下文裡,++$count{$_}與$count{$_}++的意義是不一樣的哦,前者表示在比較之前,就將自身值自增1;後者表示在比較之後,才將自身值自增1。所以,++$count{$_} < 2 表示將$count{$_}加1,然後與2進行比較。$count{$_}值預設是undef或0。所以當某個元素a第一次被當作hash的關鍵字時,它自增後對應的hash值就是1,當它第二次當作hash關鍵字時,對應的hash值就變成2了。變成2後,就不滿足比較條件了,所以a不會第2次出現。
所以上述code就能從列表裡唯一1次的抽取元素了。
2. 抽取列表裡精確出現2次的元素
@crops = qw(wheat corn barley rice corn soybean hay
        alfalfa rice hay beets corn hay);
@duplicates = grep { $count{$_} == 2 }
        grep { ++$count{$_} >; 1 } @crops;
print "@duplicates/n";
執行結果是:rice
這裡grep了2次哦,順序是從右至左。首先grep { ++$count{$_} >; 1 } @crops;返回一個列表,列表的結果是@crops裡出現次數大於1的元素。
然後再對產生的臨時列表進行grep { $count{$_} == 2 }計算,這裡的意思你也該明白了,就是臨時列表裡,元素出現次數等於2的被返回。
所以上述code就返回rice了,rice出現次數大於1,並且精確等於2,明白了吧? :-)
3. 在當前目錄裡列出文字檔案
@files = grep { -f and -T } glob '* .*';
print "@files/n";
這個就很容易理解哦。glob返回一個列表,它的內容是當前目錄裡的任何檔案,除了以'.'開頭的。{}是個code塊,它包含了匹配它後面的列表的條件。這只是grep的另一種用法,其實與 grep EXPR,LIST 這種用法差不多了。-f and -T 匹配列表裡的元素,首先它必須是個普通檔案,接著它必須是個文字檔案。據說這樣寫效率高點哦,因為-T開銷更大,所以在判斷-T前,先判斷-f了。
4. 選擇陣列元素並消除重複
@array = qw(To be or not to be that is the question);
@found_words =
grep { $_ =~ /b|o/i and ++$counts{$_} < 2; } @array;
print "@found_words/n";
執行結果是:To be or not to question
{}裡的意思就是,對@array裡的每個元素,先匹配它是否包含b或o字元(不分大小寫),然後每個元素出現的次數,必須小於2(也就是1次啦)。
grep返回一個列表,包含了@array裡滿足上述2個條件的元素。
5. 從二維數組裡選擇元素,並且x<y
# An array of references to anonymous arrays
@data_points = ( [ 5, 12 ], [ 20, -3 ],
          [ 2, 2 ], [ 13, 20 ] );
@y_gt_x = grep { $_->;[0] < $_->;[1] } @data_points;
foreach $xy (@y_gt_x) { print "$xy->;[0], $xy->;[1]/n" }
執行結果是:
5, 12
13, 20
這裡,你應該理解匿名陣列哦,[]是個匿名陣列,它實際上是個陣列的引用(類似於C裡面的指標)。
@data_points的元素就是匿名陣列。例如:
foreach (@data_points){
print $_->;[0];}
這樣訪問到匿名數組裡的第1個元素,把0替換成1就是第2個元素了。
所以{ $_->;[0] < $_->;[1] }就很明白了哦,它表示每個匿名陣列的第一個元素的值,小於第二個元素的值。
而grep { $_->;[0] < $_->;[1] } @data_points; 就會返回滿足上述條件的匿名陣列列表。
所以,就得到你要的結果啦!
6. 簡單資料庫查詢
grep的{}複雜程度如何,取決於program可用虛擬記憶體的數量。如下是個複雜的{}示例,它模擬了一個數據庫查詢:
# @database is array of references to anonymous hashes
@database = (
{ name     =>; "Wild Ginger",
    city     =>; "Seattle",
    cuisine   =>; "Asian Thai Chinese Korean Japanese",
    expense   =>; 4,
    music   =>; "/0",
    meals   =>; "lunch dinner",
    view     =>; "/0",
    smoking   =>; "/0",
    parking   =>; "validated",
    rating   =>; 4,
    payment   =>; "MC VISA AMEX",
},
#   { ... }, etc.
);
sub findRestaurants {
my ($database, $query) = @_;
return grep {
    $query->;{city} ?
        lc($query->;{city}) eq lc($_->;{city}) : 1
    and $query->;{cuisine} ?
        $_->;{cuisine} =~ /$query->;{cuisine}/i : 1
    and $query->;{min_expense} ?
      $_->;{expense} >;= $query->;{min_expense} : 1
    and $query->;{max_expense} ?
      $_->;{expense} <= $query->;{max_expense} : 1
    and $query->;{music} ? $_->;{music} : 1
    and $query->;{music_type} ?
      $_->;{music} =~ /$query->;{music_type}/i : 1
    and $query->;{meals} ?
      $_->;{meals} =~ /$query->;{meals}/i : 1
    and $query->;{view} ? $_->;{view} : 1
    and $query->;{smoking} ? $_->;{smoking} : 1
    and $query->;{parking} ? $_->;{parking} : 1
    and $query->;{min_rating} ?
      $_->;{rating} >;= $query->;{min_rating} : 1
    and $query->;{max_rating} ?
      $_->;{rating} <= $query->;{max_rating} : 1
    and $query->;{payment} ?
      $_->;{payment} =~ /$query->;{payment}/i : 1
} @$database;
}
%query = ( city =>; 'Seattle', cuisine =>; 'Asian|Thai' );
@restaurants = findRestaurants(/@database, /%query);
print "$restaurants[0]->;{name}/n";
執行結果是:Wild Ginger
上述code不難看懂,但仙子不推薦使用這樣的code,一是消耗記憶體,二是難於維護了。
(alexru注,以上內容均源自bbs.chinaunix.net)