#!/usr/bin/perl -w
    use strict;

    my $sortname = shift;
    print join ' ', sort $sortname 1..20;

    sub num { $a <=> $b }
    sub alpha { $a cmp $b }
[download]

    % foo.pl num
    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

    % foo.pl alpha
    1 10 11 12 13 14 15 16 17 18 19 2 20 3 4 5 6 7 8 9
[download]

    SUBNAME may be a scalar variable name
    (unsubscripted), in which case the value provides
    the name of (or a reference to) the actual subroutine
    to use.  In place of a SUBNAME, you can provide a
    BLOCK as an anonymous, in-line sort
    subroutine.
[download]

If you are using a real database, though, I would suggest that you try using "order by", as it's likely to be faster than anything you can do yourself, particularly if you have your columns indexed.

Instead I would suggest that you do something like this (untested):

use Carp; # So we can get verbose error messages
# Time passes
sub ret_str_sorter {
  my $field = shift;
  my $direction = shift;
  if ('ascending' eq $direction) {
    return sub {
      $data{$a}{$field} cmp $data{$b}{$field};
    };
  }
  elsif ('descending' eq $direction) {
    return sub {
      $data{$b}{$field} cmp $data{$a}{$field};
    };
  }
  else {
    confess("Direction '$direction' not understood");
  }
}
# Time passes
my $sorter = ret_str_sorter($field, $direction);
my @ordered = sort $sorter keys %data;
[download]

This does actually work the way you expected, set up some subs with known names, then give the sort routine a variable containing that name:

sub ascii {$a cmp $b}
sub alpha {lc($a) cmp lc($b)}

@a = qw(a A b B D d c C);

$subname = 'ascii';

@sorted = sort $subname @a;

print @sorted;

$subname = 'alpha';

@sorted = sort $subname @a;

print @sorted;
[download]

If you are having trouble with an earlier version of perl, then first try upgrading, failing that, you can always use eval:

But that's icky, so try not to do that.

Not only that, but you can go one better. You can pass sort a reference to a subroutine. This is safer and cleaner and faster than using the name of the sub.

my $sortref = \&firstname_descending;
my @order = sort $sortref keys %data;
[download]

For best results, combine this approach with a dispatch table that does your subroutine lookup.

-dlc

%SORT_INFO = (
   'firstname'     => sub { $a->{FirstName} cmp $b->{FirstName} },
   'firstname_desc => sub { $b->{FirstName} cmp $a->{FirstName} },
   ...
);

...

if (exists $SORT_INFO{param('sort_by')}) {
   @sorted = sort $SORT_INFO{param('sort_by')} @unsorted;

} elsif (param('sort_by')) {
   die "Unknown sort_by item: " . param('sort_by');

} else {
   @sorted = @unsorted;
}
[download]

Being a Database bigot, I point out to you that almost every RDBMS has a sort mechanism, and you night want to let the Database do the sorting. Just a thought.

<myExperience>
$mostLanguages = 'Designed for engineers by engineers.';
$perl          = 'Designed for people who speak by a linguist.';
</myExperience>
[download]

I am the -- vote, and I voted -- because there are several accurate answers and yours did not even meet the technical bar of knowing what the construct you want is called (reference), realizing that constructing code had already been posted (eg by me), or realizing that the person was asking about Perl's native sort function. (Indeed if you need to roll your own then you probably don't want to use a comparison function written in Perl!)

Had this been something like CMonks or PascalMonks I would have been voting ++, but it is not and so I didn't.

That's cool...I'm not looking to start a pissing
contest, but the question didn't have any replies
when I started my post, so I didn't have the
benefit of your code.

As far as the difference between a pointer and a
reference...dude, when it comes down to it, aren't
they really just the same thing? Semantically, yes,
they're different. Under the hood? I pass things by
reference, I give you the address. I use a pointer,
it holds the address of something. I make a reference
and I point you to a seperate chunk of code. I'm not
a complete chimp on that respect. I haven't had the
time or inclination to go look at whether or not the
interpreter makes full substitutions at references or
jumps to the sub when everything's said and done.
That's deeper than I've needed to be for a long time.

I _am_ an Acolyte, though, and one who does not get to
code nearly as much as he wants to, so it is my bad
for missing the pretty obvious reference to the
native sort. I shouldn't have done that. I've always
had that inherent distrust of someone else's code that
I haven't thoroughly looked examined, just a leftover
from school, and that's why I made the comment about
picking a sorting algorithm. I know those ingrown ones
are usually good at large data sets, but I like to pull
off the lid and see _exactly_ how it's working inside,
make sure it fits. You can't blame a guy for that.


ever learning,
-B.