Ruby比较运算符 #

1 == 1
1 == 2
"hello" == "hello"
"hello" == "HELLO".downcase
[1, 2] == [1, 2]
{a: 1} == {a: 1}
nil == nil
true == true

1 != 2
1 != 1
"hello" != "world"
nil != false

1.eql?(1)
1.eql?(1.0)
"hello".eql?("hello")
[1, 2].eql?([1, 2])

a = "hello"
b = "hello"
c = a

a.equal?(b)
a.equal?(c)
a == b

a = 1
b = 1.0

a == b
a.eql?(b)
a.equal?(a)

s1 = "hello"
s2 = "hello"

s1 == s2
s1.eql?(s2)
s1.equal?(s2)

1 < 2
2 > 1
1 <= 1
2 >= 1
1 < 2 < 3

"a" < "b"
"apple" < "banana"
"A" < "a"
"hello" < "hello world"

require 'time'

t1 = Time.now
t2 = t1 + 3600

t1 < t2
t1 > t2
t1 == t1

5.between?(1, 10)
5.between?(5, 10)
5.between?(6, 10)
"a".between?("a", "z")

1 <=> 2
2 <=> 1
1 <=> 1
"a" <=> "b"
"b" <=> "a"
"a" <=> "a"

arr = [3, 1, 4, 1, 5, 9, 2, 6]
arr.sort
arr.sort { |a, b| a <=> b }
arr.sort { |a, b| b <=> a }

class Person
  attr_reader :name, :age

  def initialize(name, age)
    @name, @age = name, age
  end

  def <=>(other)
    age <=> other.age
  end
end

people = [
  Person.new("Alice", 30),
  Person.new("Bob", 25),
  Person.new("Charlie", 35)
]

people.sort.map(&:name)
people.sort { |a, b| b <=> a }.map(&:name)

(1..5) === 3
(1..5) === 6
String === "hello"
Integer === 42
/ Ruby/ === "Hello Ruby"

def check(value)
  case value
  when 1..10
    "1-10"
  when String
    "字符串"
  when / Ruby/
    "包含Ruby"
  when :symbol
    "符号"
  else
    "其他"
  end
end

check(5)
check("hello")
check("Hello Ruby")
check(:symbol)

String === "hello"
Integer === 42
Array === [1, 2, 3]
Hash === { a: 1 }
NilClass === nil
TrueClass === true

class Money
  include Comparable

  attr_reader :amount, :currency

  def initialize(amount, currency = "USD")
    @amount = amount
    @currency = currency
  end

  def <=>(other)
    return nil unless currency == other.currency
    amount <=> other.amount
  end

  def to_s
    "#{amount} #{currency}"
  end
end

m1 = Money.new(100)
m2 = Money.new(200)
m3 = Money.new(150)

m1 < m2
m2 > m3
m1.between?(m3, m2)
[m2, m1, m3].sort

class Person
  attr_reader :name, :age

  def initialize(name, age)
    @name, @age = name, age
  end

  def ==(other)
    name == other.name && age == other.age
  end

  def eql?(other)
    self == other
  end

  def hash
    [name, age].hash
  end
end

p1 = Person.new("Alice", 30)
p2 = Person.new("Alice", 30)
p3 = Person.new("Bob", 25)

p1 == p2
p1 == p3
p1.eql?(p2)

"hello".is_a?(String)
"hello".is_a?(Object)
42.is_a?(Integer)
42.is_a?(Numeric)
42.kind_of?(Integer)

"hello".instance_of?(String)
"hello".instance_of?(Object)
42.instance_of?(Integer)
42.instance_of?(Numeric)

"hello".class == String
42.class == Integer
42.class < Numeric

nil.nil?
"".nil?
0.nil?
false.nil?

nil == false
nil.eql?(false)
nil.equal?(false)

class Version
  include Comparable

  attr_reader :parts

  def initialize(version)
    @parts = version.split(".").map(&:to_i)
  end

  def <=>(other)
    parts <=> other.parts
  end

  def to_s
    parts.join(".")
  end
end

v1 = Version.new("1.0.0")
v2 = Version.new("1.1.0")
v3 = Version.new("2.0.0")

v1 < v2
v2 < v3
v1.between?(v1, v3)
[v3, v1, v2].sort

class TimeRange
  include Comparable

  attr_reader :start_time, :end_time

  def initialize(start_time, end_time)
    @start_time = start_time
    @end_time = end_time
  end

  def <=>(other)
    start_time <=> other.start_time
  end

  def overlaps?(other)
    start_time < other.end_time && end_time > other.start_time
  end

  def contains?(time)
    start_time <= time && end_time >= time
  end
end

class Comparator
  def self.compare(a, b)
    case a <=> b
    when -1 then "#{a} 小于 #{b}"
    when 0 then "#{a} 等于 #{b}"
    when 1 then "#{a} 大于 #{b}"
    end
  end

  def self.min_max(*values)
    values.minmax
  end

  def self.clamp(value, min, max)
    [[value, min].max, max].min
  end
end

Comparator.compare(1, 2)
Comparator.min_max(3, 1, 4, 1, 5)
Comparator.clamp(10, 1, 5)