Edit to include code from martin_100's question on sorting lines based on column 2 of a space-delimited file:

print map      { $_->[1] }
      sort     { $a->[0] <=> $b->[0] }
      map      { [(split /\s+/)[1], $_] }
      read_file( $ARGV[0] );
[download]

Let's read the code in reverse order.

    read_file( $ARGV[0] );
[download]

Start by reading in the file line by line.

    map { [(split /\s+/)[1], $_] }
[download]

The lines are passed (as $_) to the 'first' map. $_ is implicitly passed to split /\s+/, which splits the line on spaces. (Note: the , $_ has nothing to do with the split!) Since it is wrapped in (...)[1], the split output is treated like a list in which the 2nd element is returned. This, itself, is inside [ ..., $_], which gives you an anonymous array containing the second element from the split ((split /\s+/)[1]) and the entire original line ($_).

    sort { $a->[0] <=> $b->[0] }
[download]

These anonymous arrays are all passed along to the sort. Sort orders the arrays based on the first element of each anonymous array, hence the ->[0].

    map { $_->[1] }
[download]

Now the sorted anonymous arrays containing both the second column of text and the entire line of text are passed to the 'second' map. This map passes only the second element of each array (the full original line) to the print statement, thereby printing the lines sorted based on the second column!

This is a standard technique called the Schwartzian Transform (after Randal L. Schwartz, aka merlyn, though he wasn't the one who named it). The idea is that you augment your data with additional information (that's the innermost map), then use that extra info to sort (the sort call, naturally), and finally discard it again (the outermost map), leaving only the original data, in the right order.

The reason why this is done is that often, you want to sort based on the result of some potentially expensive operation. Using the Schwartzian transform, you only have to perform this operation once per item, rather than twice per call to your comparison function. Since Perl's sort (mergesort, if you're curious) is O(n log(n)), and this is optimal for sorting algorithms in the general case, the Schwartzian transform is almost always a good idea if you need to process list elements in some fashion before sorting -- and the performance gain will be larger the more expensive processing an item is.

Here's merlyn's classic column on the technique.

Another good article on Perlish sorting: A Fresh Look at Efficient Perl Sorting.

Have you read perlintro?

split, map, sort, $a?

I see the node you're talking about is Sorting a text file, it links further reading material ... like

Read these too

Split columns according header delimiter,

http://learn.perl.org/faq/perlfaq4.html#How-do-I-sort-an-array-by-anything-, http://perldoc.perl.org/perlfaq4.html#How-do-I-sort-an-array-by-%28anything%29%3f

Understanding the Schwartzian transform.