一） 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運算一次后，把它存起來就可以了呀。
如下是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用戶里很流行
