使用 `===`（包含运算符）比较类

Question

TypeOfClass === TypeOfClass 是 false 的事实让我觉得违反直觉。在下面的代码中，即使field.class 是同一个类，它也会计算为false：

case field.class
when Fixnum, Float
  field + other_field
when Date, DateTime, Time
  field
else
  puts 'WAT?'
end

我这样做了：

Fixnum === Fixnum # => false
Class === Class   # => true

我找到another thread：

Integer === 3 # => true
Fixnum === 3  # => true
3.class       # => Fixnum

我找不到这种语言设计的原因。语言设计者在融入这种行为时是怎么想的？

我认为这与another thread 中提供的答案有关。假设Numeric === Integer 并非不自然，因为Integer 是Numeric 的更具体类型。但是，它不是：

Numeric === Integer #=> false

我认为case 声明或=== 需要谨慎。如果这个操作符是we think it is，那么Numeric应该是Numeric，Integer应该是Numeric等等。

有没有人解释一下为什么这个特性没有扩展到类？如果比较类是该类祖先的成员，则返回 true 似乎很容易。

根据下面提交的答案，代码最初是对Time 进行分类（由ActiveSupport:CoreExtensions::Integer::Time 和ActiveSupport:CoreExtensions::Float::Time 扩展）：

Timeframe = Struct.new(:from, :to) do
  def end_date
    case self.to
    when Fixnum, Float
      self.from + self.to
    when Date, DateTime, Time
      self.to
    else  
      raise('InvalidType')
    end
  end
end

在控制台中，我得到：

tf = Timeframe.new(Time.now, 5.months)
# => #<struct Timeframe from=Tue Dec 10 11:34:34 -0500 2013, to=5 months>
tf.end_date
# => RuntimeError: InvalidType
#  from timeframe.rb:89:in `end_date'

Answer 1

我没有真正看到这里的问题。对于类，大小写相等运算符询问左侧参数是否是类（或任何子类）的实例。所以Fixnum === Fixnum 真的问：“Fixnum 类本身是 Fixnum 的子类吗？”不，不是。

Class 本身是一个类吗？ Class === Class，是的。

运营商的重点是你不应该去寻找类。开头不使用.class方法的case语句有什么问题？

case field
when Fixnum, Float
  field + other_field
when Date, DateTime, Time
  field
else
  puts 'WAT?'
end

如果您有更复杂的示例，您可以编写自己的 lambda 表达式来简化 case 语句：

field_is_number =  -> x {[Fixnum, Float].include? x.class}
field_is_time   =  -> x {[Date, DateTime, Time].include? x.class}

case field.class
  when field_is_number
    field + other_field
  when field_is_time
    field
  else
    puts 'WAT?'
end

Answer 2

这是Module#=== 及其预期行为：

mod === obj → 真或假

大小写相等——如果 anObject 是 mod 的实例或其中之一，则返回 true mod 的后代。对模块的使用有限，但可以在case 中使用 按类对对象进行分类的语句。

它只是返回obj.kind_of? mod:

Fixnum === Fixnum      #=> false
Fixnum.kind_of? Fixnum #=> false

Class === Class        #=> true
Class.kind_of? Class   #=> true

String === "foo"       #=> true
"foo".kind_of? String  #=> true

3 既是 Integer 又是 Fixnum，因为它的类层次结构：

3.kind_of? Integer     #=> true
3.kind_of? Fixnum      #=> true
3.class.ancestors      #=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]

Numeric 不是Integer，而是Class：

Numeric.kind_of? Integer  #=> false
Numeric.kind_of? Class    #=> true

但是3、(2/3)和1.23都是Numeric：

3.kind_of? Numeric               #=> true
Rational(2, 3).kind_of? Numeric  #=> true
1.23.kind_of? Numeric            #=> true

底线：对于case 语句，只需使用case obj 而不是case obj.class。

更新

您收到此错误是因为 5.months 不返回 Integer，而是返回 ActiveSupport::Duration：

Integer === 5.months                 #=> false
ActiveSupport::Duration === 5.months #=> true

使用5.months.to_i 调用您的方法或将ActiveSupport::Duration 添加到您的类应该可以解决它。

Answer 3

如果其中一个操作数是一个类，它正在检查第二个操作数是否是这个类的实例。如果它们都是类，它将返回 false，除非其中至少有一个是 Class。

请注意，Class 既是类又是其自身的实例 - 它可能是最大的 ruby​​ 怪异 TBH，但它非常有意义。

我会投票支持保持这种逻辑的原因是我们可以编写那些不错的案例语句而不用将.class 添加到对象中。

总结：

ClassName === object    <=>    object.kind_of? ClassName

但是，如果你真的想覆盖这个用法：

class Class
  def ===(object)
    return object == self if object.is_a? Class
    super
  end
end