Ruby <=> (uzay gemisi) operatörü nedir?

Ruby <=>(uzay gemisi) operatörü nedir? Operatör başka diller tarafından uygulanıyor mu?

Perl muhtemelen onu kullanan ilk dildi. Groovy, onu destekleyen başka bir dildir. Temel olarak döndürmek yerine 1( true) ya da 0( false) bağımsız değişkenler, eşit veya eşit olmayan olup olmamasına bağlı olarak, uzay operatör döner 1, 0ya da −1doğru değişken için sol bağımsız değişken nisbetle değerine bağlı olarak.

a <=> b :=
  if a < b then return -1
  if a = b then return  0
  if a > b then return  1
  if a and b are not comparable then return nil

Bir diziyi sıralamak için kullanışlıdır.

Uzay gemisi yöntemi, kendi sınıfınızda tanımladığınızda ve Karşılaştırılabilir modülünü eklediğinizde kullanışlıdır . Daha sonra sınıfınız >, < , >=, <=, ==, and between?yöntemleri ücretsiz olarak alır .

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>]

Genel bir karşılaştırma operatörüdür. Alıcının bağımsız değişkeninden küçük, eşit veya büyük olmasına bağlı olarak -1, 0 veya +1 döndürür.

Basit bir örnekle açıklayacağım

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

   Ruby, her iki dizinin her bir öğesini sol taraftan karşılaştırmaya başlayacaktır. 1sol dizi için sağ dizi küçüktür 2. Dolayısıyla sol dizi sağ diziden daha küçüktür. Çıktı olacak -1.

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

   Yukarıda olduğu gibi ilk olarak eşit olan ilk elemanı karşılaştırır, sonra ikinci elemanı karşılaştırır, bu durumda sol dizinin ikinci elemanı daha büyük olur, dolayısıyla çıktı olur 1.

Bu işleç, bir tamsayı ifadesiyle karşılaştırmaları azalttığından, birden çok sütuna / özniteliğe göre artan veya azalan sıralamanın en genel amaçlı yolunu sağlar.

Örneğin, nesnelerin bir dizi varsa ben böyle şeyler yapabilirsiniz:

# `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
# [Notice powers of 2 make it work for > 2 columns.]
my_objects.sort! do |a, b|
      8 * (a.zip   <=> b.zip) +
     -4 * (a.age   <=> b.age) +
      2 * (a.last  <=> b.last) +
          (a.first <=> b.first)
end

Bu temel desen, her birine artan / azalan herhangi bir permütasyonda, herhangi bir sayıda sütuna göre sıralamak üzere genelleştirilebilir.

Nedir <=> ('Uzay Gemisi' Operatörü)

Operatörü tanıtan RFC'ye göre , $ a <=>$ 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

Misal:

//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

DAHA:

// 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