¿Qué es el operador Ruby <=> (nave espacial)?

El método de nave espacial es útil cuando lo define en su propia clase e incluye el Módulo comparable. Su clase entonces obtiene los métodos >, < , >=, <=, ==, and between? gratis.

class Card
  include Comparable
  attr_reader :value

  def initialize(value)
    @value = value
  end

  def <=> (other) #1 if self>other; 0 if self==other; -1 if self<other
    self.value <=> other.value
  end

end

a = Card.new(7)
b = Card.new(10)
c = Card.new(8)

puts a > b # false
puts c.between?(a,b) # true

# Array#sort uses <=> :
p [a,b,c].sort # [#<Card:0x0000000242d298 @value=7>, #<Card:0x0000000242d248 @value=8>, #<Card:0x0000000242d270 @value=10>]

Es un operador de comparación general. Devuelve un -1, 0 o +1 dependiendo de si su receptor es menor, igual o mayor que su argumento.

Voy a explicar con un simple ejemplo

1. [1,3,2] <=> [2,2,2]

   Ruby comenzará a comparar cada elemento de ambos array desde el lado izquierdo. 1 para matriz izquierda es menor que 2 de matriz derecha. Por lo tanto, la matriz izquierda es más pequeña que la matriz derecha. La salida será -1.

2. [2,3,2] <=> [2,2,2]

   Como arriba, primero comparará el primer elemento que son iguales, luego comparará el segundo elemento, en este caso el segundo elemento de la matriz izquierda es mayor, por lo tanto, la salida es 1.

Dado que este operador reduce las comparaciones a una expresión entera, proporciona la forma más general de ordenar ascendente o descendente en función de múltiples columnas/atributos.

Por ejemplo, si tengo una matriz de objetos puedo hacer cosas como esta:

# `sort!` modifies array in place, avoids duplicating if it's large...

# Sort by zip code, ascending
my_objects.sort! { |a, b| a.zip <=> b.zip }

# Sort by zip code, descending
my_objects.sort! { |a, b| b.zip <=> a.zip }
# ...same as...
my_objects.sort! { |a, b| -1 * (a.zip <=> b.zip) }

# Sort by last name, then first
my_objects.sort! { |a, b| 2 * (a.last <=> b.last) + (a.first <=> b.first) }

# Sort by zip, then age descending, then last name, then first
my_objects.sort! do |a, b|
      4 * (a.zip   <=> b.zip) +
     -3 * (a.age   <=> b.age) +
      2 * (a.last  <=> b.last) +
          (a.first <=> b.first)
end

Este patrón básico se puede generalizar para ordenar por cualquier número de columnas, en cualquier permutación de ascendente/descendente en cada una.

Qué es <=> (El Operador de la 'Nave Espacial')

De acuerdo con el RFC que introdujo el operador , a a <=> b b

 -  0 if $a == $b
 - -1 if $a < $b
 -  1 if $a > $b

 - Return 0 if values on either side are equal
 - Return 1 if value on the left is greater
 - Return -1 if the value on the right is greater

Ejemplo:

//Comparing Integers

echo 1 <=> 1; //ouputs 0
echo 3 <=> 4; //outputs -1
echo 4 <=> 3; //outputs 1

//String Comparison

echo "x" <=> "x"; // 0
echo "x" <=> "y"; //-1
echo "y" <=> "x"; //1

MÁS:

// Integers
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1

echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1

// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0