<=>和-的sort方法块之间有什么区别？

Question

I have an array like this:

my_array = [1,3,5,5,6,7] 

to be sorted from the biggest to the smallest. I do these:

1. my_array.sort { |a,b| b <=> a }
2. my_array.sort { |a,b| b - a }

Both return the same thing: [7,6,5,5,3,1] . Can someone explain what the difference is between those two?

Answer 1

The document states:

sort → array sort { |a, b| block } → array Returns an array containing the items in enum sorted, either according to their own <=> method, or by using the results of the supplied block. The block should return -1, 0, or +1 depending on the comparison between a and b. As of Ruby 1.8, the method Enumerable#sort_by implements a built-in Schwartzian Transform, useful when key computation or comparison is expensive.

So there is no official mentioning when the evaluated value of the block is other than -1 , 0 , or 1 . If what you did works, then it is perhaps working under the principle that negative numbers are regarded as -1 and positive numbers are regarded as 1 . If that is the case, there is no difference. However, since it is not officially stated so, I think it is safer to use {|a, b| b <=> a} {|a, b| b <=> a}

Answer 2

One subtracts, one uses the items' <=> operator.

You're using numbers, Fixnum to be precise, so subtracting produces < 0 , 0 , or > 0 .

<=> for Fixnum calls the C routine:

if (x == y) return INT2FIX(0);
if (FIXNUM_P(y)) {
    if (FIX2LONG(x) > FIX2LONG(y)) return INT2FIX(1);
    return INT2FIX(-1);
}

which returns -1, 0, or 1, which produces the same results–because the sort only checks the sign.

The bottom line is that in this case there's no difference, but that's an implementation detail.

Answer 3

It's a kind of trick. The block used in sort an array must return a comparaison result, -1 (a lower than b), 0 (a equal b) , 1 ( a higher than b).

What happens, is that code seems to use the sign of the operation only, and not the value so (ba) operation return the same sign than b <=> a operation:

1-10       -9 # neg
1<=>10     -1 # neg

5-5         0 # eq  
5<=>5       0 # eq 

10-1        9 # pos
10<=>1      1 # pos 

But I strongly suggest to use the comparaison operator instead of the difference.

Answer 4

It's important to understand what <=> is doing, as it's the crux for sorting and comparisons:

The <=> operator (AKA "spaceship") tells us whether one value is less-than, equal, or greater-than another, which makes it easy to know when code should swap them. For instance:

0 <=> 1 # => -1
1 <=> 1 # => 0
2 <=> 1 # => 1

In other words, -1 means the comparison was less-than, 0 was equal, and 1 was greater-than. Knowing that, code can swap the values one of two ways or ignore swapping.

Using - works for numbers, but it's going to have really unexpected results with other data-types, like strings, arrays, hashes, which use - differently, if at all.

Read the documentation for the Comparable module, which makes it really easy to add additional functionally to a class by defining the <=>(other) method and to understand what you'll gain by using it.