I love this site and have learned more about PERL here, than any other website

Not much, I guess ;^). Please, it's "Perl" (mind the capitalization).

@look = <INF>;

It's better to use <DATA> for your code. That way, the data goes with the program and you don't have to provide it separately.

@out = sort { (split '|', $a, 12)[4] <=> (split '|', $b, 12)[4] } @look;

You need to quote the pipe: '\|'.

@fields = @$line;

$line is not an arrayref. The split you did only extracted the 4th field of the string for sorting, nothing more. @out is a regular array of strings, like @look.

Applying this comments, and adding strict and warnings, your code becomes:

my @look = <DATA>;
my @out = sort { (split '\|', $a, 12)[4] <=> (split '\|', $b, 12)[4] }
+ @look;
foreach my $line (@out) { 
    print $line;
}
__DATA__
accred|143|0|0|412|0|0|0|0|0|0|0|0|
accu-b|36|0|0|103|0|38|0|0|0|0|2|0|
accua|35|0|0|27|0|37|0|0|0|0|1|0|
[...]
[download]

If you want to access the fields individually, you have to perform another split inside the foreach loop.

Further on, doing a Guttman-Rosler transform, it could be:

## tested
my @out =
    map { substr $_, 6 }   ## hardcoded "6" here...
    sort
    map { my $val = (split /\|/)[4]; sprintf "%06d$_",$val }  ## ... a
+nd here
    <DATA>;
[download]

Update: Added benchmark. || Included ambrus' solution.

Your benchmark is unfair as the key extraction for ambrus solution is not being measured.

Anyway, using Sort::Key is, as usual, the fastest solution!

use Sort::Key 'ikeysort';

my @d = <DATA>; my @e;
use Benchmark qw/cmpthese/;
cmpthese (4e4, { grt    => sub { @e = map { substr $_, 6 }
                                      sort map { my $val = (split /\|/
+)[4]; sprintf "%06d$_",$val} @d; },
                 raw    => sub { @e = sort { (split '\|', $a, 12)[4] <
+=> (split '\|', $b, 12)[4] } @d; },
                 ambrus => sub {  my @key = map { (split /\|/)[4] } @d
+;
                                  @e = @d[ sort { $key[$a] <=> $key[$b
+] } 0 .. @d - 1 ]; },
                 sk     => sub { @e = ikeysort { (split '\|', $_, 12)[
+4] } @d }
               });
[download]

on my computer says...

         Rate    raw    grt ambrus     sk
raw    1887/s     --   -63%   -69%   -74%
grt    5141/s   172%     --   -15%   -29%
ambrus 6061/s   221%    18%     --   -16%
sk     7246/s   284%    41%    20%     --
[download]

Thanks for the help, David.

Hue-Bond has already pointed out to the problems with your code, and given a working version.

use warnings; use strict;

open my $INF, "<", "look.txt" or die "cannot open";
my @look = <$INF>;
close($INF);

my @key = map { (split /\|/)[4] } @look;
my @out = @look[sort { $key[$a] <=> $key[$b] } 0 .. @look - 1];

for my $line (@out) {
        my @fields = split /\|/, $line;
        print join(",", @fields[0 .. 4]), "\n"; 
}

__END__
[download]

I'll also show you a ruby solution as a teaser.

#!ruby -w

look = File.open("look.txt").readlines; # here I'm inclined to write '
+map' instead of 'readlines'

out = look.sort_by {|line| line.split("|")[4] };

out.each {|line|
        fields = line.split "|";
        puts fields[0 .. 4].join(",");
}

__END__
[download]

That's it. You don't have to listen to the community's whining about strictures, or declare variables, nor do you have to learn complicated idioms for efficently sorting by a field, or quote regexp metacharacters if the language can do that for you. :)