Why didn't this sort?

[brentheigold]

Hi, I had a simple comma-separated array (referenced), it looked like the following:

'ADH,BUY,22000,NASDAQ'
'ADH,BUY,30000,NASDAQ'
'IBM,SELL,40000,NASDAQ'
'ADH,SELL,55000,NASDAQ'

So after doing a foreach(sort @$outputRef), I set a breakpoint immediately after going in to the loop, and after printing it out it still came out as (unchanged):

'ADH,BUY,22000,NASDAQ'
'ADH,BUY,30000,NASDAQ'
'IBM,SELL,40000,NASDAQ'
'ADH,SELL,55000,NASDAQ'

Would anyone know why this didn't sort? So, just to clarify, this is what it was supposed to look like:

'ADH,BUY,22000,NASDAQ'
'ADH,BUY,30000,NASDAQ'
'ADH,SELL,55000,NASDAQ'
'IBM,SELL,40000,NASDAQ'

[stephen]

sort doesn't sort a list in-place. Instead, it returns a new sorted list. So:

foreach (sort @$outputRef) {
   print $_, "\n";
}

would print out a sorted list, but printing the contents of $outputRef would still print out an unsorted list.

If you need to save the sorted list for some reason, use an assignment:

@sorted = sort @$outputRef;

stephen

Note: Code untested, my Perlboxen are still in pieces...

[Ovid]

The problem is that you need to sort on the element you want to sort on, not sorting the entire array. If you can explain your sort criteria that would help. Plus, where are you assigning your sort?

I am just guessing, but let's say that you want to sort by the first item, alphabetically, and then the third item numerically. You could do this:

my @sorted = sort 
  {
    $a->[0] cmp $b->[0]
      ||
    $a->[2] <=> $b->[2]
  }
  @$outputRef;

If you give us a fuller code snippet with desired sort criteria, we can do better than speculate.

Cheers,
Ovid

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

[thelenm]

If you're looking for the array @$outputRef itself to be sorted, you'll have to do something like this:

$outputRef = [ sort @$outputRef ];

When you say sort @$outputRef, you're creating an anonymous array with the sorted values, but not actually assigning the sorted values back into @$outputRef.

-- Mike

--
just,my${.02}

[tadman]

I know this is a minor thing, but it's probably best to make sure that you use the same reference instead of making a new one. If $ouputRef was pulled from a blessed object, for example, then this reassignment creates a new instance that isn't linked in.

Assign back to the same reference just to be safe:

@$outputRef = sort @$outputRef;

These are "equivalent" in terms of functionality, but not in terms of effect. For an example of what I mean:

my $foo = [ [ 4, 1, 6 ], [ 4, 1, 5 ] ];
my $foo_0 = $foo->[0];
my $foo_1 = $foo->[1];

 $foo_0 = [ sort @$foo_0 ];   # $foo_0 is "detached"
@$foo_1 = sort @$foo_1;       # Goes back into $foo->[1]

use Data::Dumper;
print Dumper($foo);

[jsprat]

A guess (since you didn't include much code) - foreach is creating a sorted list of members of your array, not actually sorting your array. An example:

@array=(2, 3, 1, 0);
foreach (sort @array){
  print "$_ - ";
}
print "\n";
print join " - ", @array;
print "\n";
@array = sort @array;
print join " - ", @array;

__END__
Output:
0 - 1 - 2 - 3 - (printed in loop)
2 - 3 - 1 - 0   (after loop, still unsorted)
0 - 1 - 2 - 3   (after sorting, now sorted)

Notice @a prints as if it is sorted in the loop, but after the loop it is still unsorted. If you want the array sorted, @array = sort @array; will work.