首先，请原谅我生疏的Perl语言。我正在尝试修改Bugzilla的“whine.pl”，以生成按严重程度排序的漏洞列表。
因此，它会给我一个哈希引用数组。每个哈希包含有关特定漏洞的大量信息（id、受让人、严重程度等）。我想按严重性对数组进行排序。最好的方法是什么？
我想到了几种可能性。其中之一是创建五个数组（每个严重程度一个），然后循环遍历该数组，并将哈希引用推入相应的严重程度级别数组中。完成后，我可以重新组装它们，并用排序后的数组替换原始数组。
我的朋友提出的另一种方法是将存储在哈希中的严重程度级别（以文本形式存储）分配给一些数字，并进行比较。也许像这样：
sub getVal {
my $entry = $_[0];
%lookup = ( "critical" => 0, ... );
return $lookup(entry("bug_severity"));
}
@sorted = sort { getVal($a) <=> getVal($b) } @unsorted;
my @decorated = map { [ $_, getVal($_) ] } @unsorted;
然后对装饰好的列表进行排序：
my @sortedDecorate = sort { $a->[1] <=> $b->[1] } @decorated;
my @sorted = map { $_->[0] } @sortedDecorate;
@sorted = map { $_->[0] }
sort { $a->[1] <=> $b->[1] }
map { [ $_, getVal($_) ] } @unsorted;
my @sorted = map { $_->[1] }
sort { $a->[0] <=> $b->[0] }
map { [ $lookup{$_->{bug_severity}, $_ ] }
@unsorted;
解释：
map { [ $lookup{$_->{bug_severity}, $_ ] } @unsorted;
将每个 bug 映射到一个数组引用，其第一个元素是查找表中的数字 bug 严重性。使用 Schwartzian Transform，你只需要在 @unsorted 中每个 bug 查找一次数值。
然后，
sort { $a->[0] <=> $b->[0] }
按第一个元素对数组进行排序。最后，
@sorted = map { $_->[1] }
从sort返回的数组中提取原始缺陷。
当getval只进行哈希查找时，实际上不需要它。
用于自动生成有效排序器的 CPAN 模块 Sort::Maker 非常出色：
use strict; use warnings;
use Sort::Maker;
my @bugs = (
{ name => 'bar', bug_severity => 'severe' },
{ name => 'baz', bug_severity => 'noncritical' },
{ name => 'foo', bug_severity => 'critical' },
);
my $sorter = make_sorter('ST',
name => 'severity_sorter',
init_code => 'my %lookup = (
critical => 0,
severe => 1,
noncritical => -1 );',
number => [ code => '$lookup{$_->{bug_severity}}' ],
);
use Data::Dumper;
print Dumper $_ for severity_sorter( @bugs );
输出:
$VAR1 = {
'name' => 'baz',
'bug_severity' => 'noncritical'
};
$VAR1 = {
'name' => 'foo',
'bug_severity' => 'critical'
};
$VAR1 = {
'name' => 'bar',
'bug_severity' => 'severe'
};
请注意，使用简单方法时需要查找的次数取决于@unsorted中的元素数量。我们可以使用以下简单程序进行计数：
#!/usr/bin/perl
use strict;
use warnings;
my ($n_elements) = @ARGV;
my @keys = qw(a b c);
my %lookup = map { $keys[$_-1] => $_ } 1 .. @keys;
my @unsorted = map { $keys[rand 3] } 1 .. $n_elements;
my $n_lookups;
my @sorted = sort {
$n_lookups += 2;
$lookup{$a} <=> $lookup{$b}
} @unsorted;
print "It took $n_lookups lookups to sort $n_elements elements\n";
输出：
C:\Temp> tzt 10 对10个元素进行排序需要38次查找
C:\Temp> tzt 100 对100个元素进行排序需要978次查找
C:\Temp> tzt 1000 对1000个元素进行排序需要10916次查找
C:\Temp> tzt 10000 对10000个元素进行排序需要113000次查找
因此，人们需要更多的信息来决定是使用朴素排序还是使用Schwartzian变换作为适当的解决方案。
这里有一个简单的基准测试，似乎支持@Ether的观点：
#!/usr/bin/perl
use strict;
use warnings;
use Benchmark qw( cmpthese );
my ($n_elements) = @ARGV;
my @keys = qw(foo bar baz);
my %lookup = map { $keys[$_] => $_ } 0 .. $#keys;
my @unsorted = map { {v => $keys[rand 3]} } 1 .. $n_elements;
cmpthese(-1, {
naive => sub {
my @sorted = sort {
$lookup{$a->{v}} <=> $lookup{$b->{v}}
} @unsorted;
},
schwartzian => sub {
my @sorted = map { $_->[1] }
sort { $a->[0] <=> $b->[0] }
map { [$lookup{$_->{v}}, $_] }
@unsorted;
}
});
输出：
C:\Temp> tzt 10
率 schwartzian naive
schwartzian 18842/s -- -29%
naive 26357/s 40% --
C:\Temp> tzt 100
率 naive schwartzian
naive 1365/s -- -11%
schwartzian 1532/s 12% --
C:\Temp> tzt 1000
率 naive schwartzian
naive 121/s -- -11%
schwartzian 135/s 12% --
我很喜欢你提出的解决方案：
my %sevs = (critical => 0, high => 1, ...);
my @sorted = sort { $sevs{$a->{bug_severity}} <=> $sevs{$b->{bug_severity}} } @unsorted
use strict; use warnings;
use Data::Dumper;
my @bugInfo = (
{ id => 1,
assignee => 'Bob',
severity => 'HIGH'
},
{ id => 2,
assignee => 'Anna',
severity => 'LOW'
},
{ id => 3,
assignee => 'Carl',
severity => 'EXTREME'
},
);
my %severity_ordering = (
EXTREME => 0,
HIGH => 1,
MEDIUM => 2,
LOW => 3,
);
sub byseverity
{
$severity_ordering{$a->{severity}} <=> $severity_ordering{$b->{severity}}
}
my @sortedBugs = sort byseverity @bugInfo;
print Dumper(\@sortedBugs);
产生：
$VAR1 = [
{
'assignee' => 'Carl',
'id' => 3,
'severity' => 'EXTREME'
},
{
'assignee' => 'Bob',
'id' => 1,
'severity' => 'HIGH'
},
{
'assignee' => 'Anna',
'id' => 2,
'severity' => 'LOW'
}
];
whine.pl的源代码，它似乎是从 SQL 数据库中获取这些内容的。使用适当的SELECT查询从数据库中获取已经排序好的 bug 不是更好吗？ - Sinan Ünür