perlfunc
gods
<P>
sort - sort a list of values
<P>
<HR>
<P>
sort
<FONT SIZE=-1>SUBNAME</FONT>
<FONT SIZE=-1>LIST</FONT>
<P>
sort
<FONT SIZE=-1>BLOCK</FONT>
<FONT SIZE=-1>LIST</FONT>
<P>
sort
<FONT SIZE=-1>LIST</FONT>
<P>
<HR>
<P>
Sorts the
<FONT SIZE=-1>LIST</FONT> and returns the sorted list value. If
<FONT SIZE=-1>SUBNAME</FONT> or
<FONT SIZE=-1>BLOCK</FONT> is omitted,
[perlfunc:sort|sort()]s in standard string comparison order. If
<FONT SIZE=-1>SUBNAME</FONT> is specified, it gives the name of a
subroutine that returns an integer less than, equal to, or greater than <CODE>0</CODE>, depending on how the elements of the array are to be ordered. (The <CODE><=></CODE> and <CODE>cmp</CODE>
operators are extremely useful in such routines.)
<FONT SIZE=-1>SUBNAME</FONT> 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
<FONT SIZE=-1>SUBNAME,</FONT> you can provide a
<FONT SIZE=-1>BLOCK</FONT> as an anonymous, in-line sort subroutine.
<P>
In the interests of efficiency the normal calling code for subroutines is
bypassed, with the following effects: the subroutine may not be a recursive
subroutine, and the two elements to be compared are passed into the
subroutine not via <CODE>@_</CODE> but as the package global variables <CODE>$a</CODE> and
<CODE>$b</CODE> (see example below). They are passed by reference, so don't modify <CODE>$a</CODE> and <CODE>$b</CODE>. And don't try to declare them as lexicals either.
<P>
You also cannot exit out of the sort block or subroutine using any of the
loop control operators described in [perlman:perlsyn|the perlsyn manpage] or with [perlfunc:goto|goto()].
<P>
When <CODE>use locale</CODE> is in effect, <CODE>sort LIST</CODE> sorts
<FONT SIZE=-1>LIST</FONT> according to the current collation locale. See [perlman:perllocale|the perllocale manpage].
<P>
Examples:
<P>
<PRE> # sort lexically
@articles = sort @files;
</PRE>
<P>
<PRE> # same thing, but with explicit sort routine
@articles = sort {$a cmp $b} @files;
</PRE>
<P>
<PRE> # now case-insensitively
@articles = sort {uc($a) cmp uc($b)} @files;
</PRE>
<P>
<PRE> # same thing in reversed order
@articles = sort {$b cmp $a} @files;
</PRE>
<P>
<PRE> # sort numerically ascending
@articles = sort {$a <=> $b} @files;
</PRE>
<P>
<PRE> # sort numerically descending
@articles = sort {$b <=> $a} @files;
</PRE>
<P>
<PRE> # sort using explicit subroutine name
sub byage {
$age{$a} <=> $age{$b}; # presuming numeric
}
@sortedclass = sort byage @class;
</PRE>
<P>
<PRE> # this sorts the %age hash by value instead of key
# using an in-line function
@eldest = sort { $age{$b} <=> $age{$a} } keys %age;
</PRE>
<P>
<PRE> sub backwards { $b cmp $a; }
@harry = ('dog','cat','x','Cain','Abel');
@george = ('gone','chased','yz','Punished','Axed');
print sort @harry;
# prints AbelCaincatdogx
print sort backwards @harry;
# prints xdogcatCainAbel
print sort @george, 'to', @harry;
# prints AbelAxedCainPunishedcatchaseddoggonetoxyz
</PRE>
<P>
<PRE> # inefficiently sort by descending numeric compare using
# the first integer after the first = sign, or the
# whole record case-insensitively otherwise
</PRE>
<P>
<PRE> @new = sort {
($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0]
||
uc($a) cmp uc($b)
} @old;
</PRE>
<P>
<PRE> # same thing, but much more efficiently;
# we'll build auxiliary indices instead
# for speed
@nums = @caps = ();
for (@old) {
push @nums, /=(\d+)/;
push @caps, uc($_);
}
</PRE>
<P>
<PRE> @new = @old[ sort {
$nums[$b] <=> $nums[$a]
||
$caps[$a] cmp $caps[$b]
} 0..$#old
];
</PRE>
<P>
<PRE> # same thing using a Schwartzian Transform (no temps)
@new = map { $_->[0] }
sort { $b->[1] <=> $a->[1]
||
$a->[2] cmp $b->[2]
} map { [$_, /=(\d+)/, uc($_)] } @old;
</PRE>
<P>
If you're using strict, you <EM>MUST NOT</EM> declare <CODE>$a</CODE>
and <CODE>$b</CODE> as lexicals. They are package globals. That means if you're in the <CODE>main</CODE> package, it's
<P>
<PRE> @articles = sort {$main::b <=> $main::a} @files;
</PRE>
<P>
or just
<P>
<PRE> @articles = sort {$::b <=> $::a} @files;
</PRE>
<P>
but if you're in the <CODE>FooPack</CODE> package, it's
<P>
<PRE> @articles = sort {$FooPack::b <=> $FooPack::a} @files;
</PRE>
<P>
The comparison function is required to behave. If it returns inconsistent
results (sometimes saying <CODE>$x[1]</CODE> is less than <CODE>$x[2]</CODE> and sometimes saying the opposite, for example) the results are not
well-defined.
<HR>