$ perldoc -t -f sort
   sort SUBNAME LIST
   sort BLOCK LIST
   sort LIST
           In list context, this sorts the LIST and returns the sorted
+ list
           value. In scalar context, the behaviour of "sort()" is
           undefined.

           If SUBNAME or BLOCK is omitted, "sort"s in standard string
           comparison order. If SUBNAME is specified, it gives the nam
+e of
           a subroutine that returns an integer less than, equal to, o
+r
           greater than 0, depending on how the elements of the list a
+re to
           be ordered. (The "<=>" and "cmp" operators are extremely us
+eful
           in such routines.) 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 s
+ort
           subroutine.

           If the subroutine's prototype is "($$)", the elements to be
           compared are passed by reference in @_, as for a normal
           subroutine. This is slower than unprototyped subroutines, w
+here
           the elements to be compared are passed into the subroutine 
+as
           the package global variables $a and $b (see example below).
+ Note
           that in the latter case, it is usually counter-productive t
+o
           declare $a and $b as lexicals.

           In either case, the subroutine may not be recursive. The va
+lues
           to be compared are always passed by reference, so don't mod
+ify
           them.

           You also cannot exit out of the sort block or subroutine us
+ing
           any of the loop control operators described in perlsyn or w
+ith
           "goto".

           When "use locale" is in effect, "sort LIST" sorts LIST acco
+rding
           to the current collation locale. See perllocale.

           Perl 5.6 and earlier used a quicksort algorithm to implemen
+t
           sort. That algorithm was not stable, and *could* go quadrat
+ic.
           (A *stable* sort preserves the input order of elements that
           compare equal. Although quicksort's run time is O(NlogN) wh
+en
           averaged over all arrays of length N, the time can be O(N**
+2),
           *quadratic* behavior, for some inputs.) In 5.7, the quickso
+rt
           implementation was replaced with a stable mergesort algorit
+hm
           whose worst case behavior is O(NlogN). But benchmarks indic
+ated
           that for some inputs, on some platforms, the original quick
+sort
           was faster. 5.8 has a sort pragma for limited control of th
+e
           sort. Its rather blunt control of the underlying algorithm 
+may
           not persist into future perls, but the ability to character
+ize
           the input or output in implementation independent ways quit
+e
           probably will. See sort.

           Examples:

               # sort lexically
               @articles = sort @files;

               # same thing, but with explicit sort routine
               @articles = sort {$a cmp $b} @files;

               # now case-insensitively
               @articles = sort {uc($a) cmp uc($b)} @files;

               # same thing in reversed order
               @articles = sort {$b cmp $a} @files;

               # sort numerically ascending
               @articles = sort {$a <=> $b} @files;

               # sort numerically descending
               @articles = sort {$b <=> $a} @files;

               # this sorts the %age hash by value instead of key
               # using an in-line function
               @eldest = sort { $age{$b} <=> $age{$a} } keys %age;

               # sort using explicit subroutine name
               sub byage {
                   $age{$a} <=> $age{$b};  # presuming numeric
               }
               @sortedclass = sort byage @class;

               sub backwards { $b cmp $a }
               @harry  = qw(dog cat x Cain Abel);
               @george = qw(gone chased yz Punished Axed);
               print sort @harry;
                       # prints AbelCaincatdogx
               print sort backwards @harry;
                       # prints xdogcatCainAbel
               print sort @george, 'to', @harry;
                       # prints AbelAxedCainPunishedcatchaseddoggoneto
+xyz

               # inefficiently sort by descending numeric compare usin
+g
               # the first integer after the first = sign, or the
               # whole record case-insensitively otherwise

               @new = sort {
                   ($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0]
                                       ||
                               uc($a)  cmp  uc($b)
               } @old;

               # same thing, but much more efficiently;
               # we'll build auxiliary indices instead
               # for speed
               @nums = @caps = ();
               for (@old) {
                   push @nums, /=(\d+)/;
                   push @caps, uc($_);
               }

               @new = @old[ sort {
                                   $nums[$b] <=> $nums[$a]
                                            ||
                                   $caps[$a] cmp $caps[$b]
                                  } 0..$#old
                          ];

               # same thing, but without any temps
               @new = map { $_->[0] }
                      sort { $b->[1] <=> $a->[1]
                                      ||
                             $a->[2] cmp $b->[2]
                      } map { [$_, /=(\d+)/, uc($_)] } @old;

               # using a prototype allows you to use any comparison su
+broutine
               # as a sort subroutine (including other package's subro
+utines)
               package other;
               sub backwards ($$) { $_[1] cmp $_[0]; }     # $a and $b
+ are not \
set here

               package main;
               @new = sort other::backwards @old;

               # guarantee stability, regardless of algorithm
               use sort 'stable';
               @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @
+old;

               # force use of mergesort (not portable outside Perl 5.8
+)
               use sort '_mergesort';  # note discouraging _
               @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @
+old;

           If you're using strict, you *must not* declare $a and $b as
           lexicals. They are package globals. That means if you're in
+ the
           "main" package and type

               @articles = sort {$b <=> $a} @files;

           then $a and $b are $main::a and $main::b (or $::a and $::b)
+, but
           if you're in the "FooPack" package, it's the same as typing

               @articles = sort {$FooPack::b <=> $FooPack::a} @files;


           The comparison function is required to behave. If it return
+s
           inconsistent results (sometimes saying $x[1] is less than $
+x[2]
           and sometimes saying the opposite, for example) the results
+ are
           not well-defined.

           Because "<=>" returns "undef" when either operand is "NaN"
           (not-a-number), and because "sort" will trigger a fatal err
+or
           unless the result of a comparison is defined, when sorting 
+with
           a comparison function like "$a <=> $b", be careful about li
+sts
           that might contain a "NaN". The following example takes
           advantage of the fact that "NaN != NaN" to eliminate any "N
+aN"s
           from the input.

               @result = sort { $a <=> $b } grep { $_ == $_ } @input;
[download]