リストコンテキストでは、LIST をソートし、ソートされたリスト値を返します。 スカラコンテキストでは、sort の振る舞いは未定義です。

SUBNAME や BLOCK を省略すると、sort は標準の 文字列比較の順番で行なわれます。 SUBNAME を指定すると、それは、リストの要素をどのような順番に並べるかに 応じて、負の数、0、正の数を返すサブルーチンの名前であると解釈されます。 (このようなルーチンには、<=> 演算子や cmp 演算子が、 たいへん便利です。) SUBNAME は、スカラ変数名(添字なし)でもよく、その場合には、その値が使用する 実際のサブルーチンの名前(またはそのリファレンス)と解釈されます。 SUBNAME の代わりに、無名のインラインソートルーチンとして、BLOCK を 書くことができます。

サブルーチンのプロトタイプが ($$)の場合、比較する要素は通常のサブルーチンと 同じように @_ の中にリファレンスとして渡されます。 これはプロトタイプなしのサブルーチンより遅いです; この場合は比較のため サブルーチンに渡される二つの要素は、パッケージのグローバル変数 $a と $b で渡されます(次の例を参照してください)。

サブルーチンが XSUB の場合、比較される要素は、普通に引数を XSUB に渡す形で、 スタックにプッシュされます。 $a と $b は設定されません。

比較される値はリファレンスによって渡されるので、変更するべきではありません。

また、ソートブロックやサブルーチンから perlsyn で説明されている ループ制御子や goto を使って抜けてはいけません。

use locale が有効(そして use locale ':not_characters' が 有効でない)の場合、sort LIST は LIST を現在の比較ロケールに従って ソートします。 perllocale を参照してください。

sort は元のリストへのエイリアスを返します; for ループのインデックス変数がリスト要素へのエイリアスと同様です。 つまり、sort で返されるリストの要素を(例えば、 foreach や map や grep で)変更すると、実際に元のリストの要素が 変更されます。 これはきれいなコードを書くときには普通は回避されます。

歴史的には、ソートがデフォルトで安定かどうかは様々です。 安定性が問題になる場合は、sort プラグマを使うことで明示的に制御できます。

例:

    # sort lexically
    my @articles = sort @files;

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

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

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

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

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

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

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

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

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

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

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

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

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

    # using a prototype allows you to use any comparison subroutine
    # as a sort subroutine (including other package's subroutines)
    package Other;
    sub backwards ($$) { $_[1] cmp $_[0]; }  # $a and $b are
                                             # not set here
    package main;
    my @new = sort Other::backwards @old;

    ## using a prototype with function signature
    use feature 'signatures';
    sub function_with_signature :prototype($$) ($one, $two) {
        return $one <=> $two
    }

    my @new = sort function_with_signature @old;

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

警告: 関数から返されたリストをソートするときには文法上の注意が必要です。 関数呼び出し find_records(@key) から返されたリストをソートしたい場合、 以下のように出来ます:

    my @contact = sort { $a cmp $b } find_records @key;
    my @contact = sort +find_records(@key);
    my @contact = sort &find_records(@key);
    my @contact = sort(find_records(@key));

一方、配列 @key を比較ルーチン find_records() でソートしたい場合は、 以下のように出来ます:

    my @contact = sort { find_records() } @key;
    my @contact = sort find_records(@key);
    my @contact = sort(find_records @key);
    my @contact = sort(find_records (@key));

$a と $b は、sort() を呼び出したパッケージのパッケージグローバルとして 設定されます。 つまり、main パッケージの $main::a と $main::b (あるいは $::a と $::b) 、 FooPack パッケージの $FooPack::a と $FooPack::b、などです。 ソートブロックが $a や $b の my または state のスコープ内の場合、 ソートブロックの変数の完全名を 指定しなければなりません:

   package main;
   my $a = "C"; # DANGER, Will Robinson, DANGER !!!

   print sort { $a cmp $b }               qw(A C E G B D F H);
                                          # WRONG
   sub badlexi { $a cmp $b }
   print sort badlexi                     qw(A C E G B D F H);
                                          # WRONG
   # the above prints BACFEDGH or some other incorrect ordering

   print sort { $::a cmp $::b }           qw(A C E G B D F H);
                                          # OK
   print sort { our $a cmp our $b }       qw(A C E G B D F H);
                                          # also OK
   print sort { our ($a, $b); $a cmp $b } qw(A C E G B D F H);
                                          # also OK
   sub lexi { our $a cmp our $b }
   print sort lexi                        qw(A C E G B D F H);
                                          # also OK
   # the above print ABCDEFGH

適切に注意すれば、パッケージと my (あるいは state) $a や $b を 混ぜることができます:

   my $a = {
      tiny   => -2,
      small  => -1,
      normal => 0,
      big    => 1,
      huge   => 2
   };

   say sort { $a->{our $a} <=> $a->{our $b} }
       qw{ huge normal tiny small big};

   # prints tinysmallnormalbighuge

$a と $b は sort() の実行中は暗黙にローカル化され、ソート終了時に 元の値に戻ります。

$a と $b を使って書かれたソートサブルーチンはその呼び出しパッケージに しなければなりません。 異なるパッケージに定義することは可能ですが、 これは可能ですが、限られた関心しかありません; サブルーチンは呼び出しパッケージの $a と $b を 参照しなければならないからです:

   package Foo;
   sub lexi { $Bar::a cmp $Bar::b }
   package Bar;
   ... sort Foo::lexi ...

より一般的な代替案としては(前述の)プロトタイプ版を使ってください。

比較関数は一貫した振る舞いをすることが求められます。 一貫しない結果を返す(例えば、あるときは $x[1] が $x[2] より 小さいと返し、またあるときは逆を返す)場合、結果は未定義です。

<=> はどちらかのオペランドが NaN (not-a-number) のときに undef を返すので、$a <=> $b といった比較関数で ソートする場合はリストに NaN が含まれないように注意してください。 以下の例は 入力リストから NaN を取り除くために NaN != NaN という性質を 利用しています。

    my @result = sort { $a <=> $b } grep { $_ == $_ } @input;

このバージョンの perl では、sort 関数はマージソートアルゴリズムで 実装されています。