Ruby在调用`.=`运算符之前对`when`子句语句执行什么测试？

Ruby在

case/when

类型执行样式上使用

==

运算符。现在它还知道Ruby根据类型 对于

when

子句中存在的对象，调用相应的

==

方法

假设

语句包含
类
名称，则规则为-
它将使用模块#==，如果右侧是，
或左侧的子类。
此上下文的一个示例是：

此处出现了测试的
实例

obj = 'hello'
#=> "hello"
case obj
when String
print 'It is a string'
when Fixnum
print 'It is a number'
else
print 'It is not a string'
end
#It is a string
#=> nil

num = 10
#=> 10
case num
when Numeric
puts "Right class"
else
puts "Wrong class"
end
#Right class
#=> nil

这里出现了测试的
子类

obj = 'hello'
#=> "hello"
case obj
when String
print 'It is a string'
when Fixnum
print 'It is a number'
else
print 'It is not a string'
end
#It is a string
#=> nil

num = 10
#=> 10
case num
when Numeric
puts "Right class"
else
puts "Wrong class"
end
#Right class
#=> nil

现在
当
包含
字符串
文字时，调用字符串#===，然后检查左右手是否对齐
文字是否相同（相同序列中的相同字符）

所有的逻辑都太酷了。现在我的查询是使用
case/when
structure-


ruby如何知道
何时持有
类
，或
字符串
文本或
运行时是否有任何有效信息？


或


在调用相应的
==
操作员在当前按住时操作对象。
。

编辑

在理解
案例/when
工作原理之前，让我先明确一下
when
在轮到它时所做的事情

String.===("abc") #=> true

因为“abc”是
String
类的一个实例我说得对吗

Numeric.===(10) #=> true

现在我试着用下面的方法来检查谁是谁的超级班

10.class #=> Fixnum
Fixnum.superclass #=> Integer
Integer.superclass #=> Numeric
Numeric.superclass #=> Object

哼。这意味着下面返回
true
，因为Fixnum也是
Numeric
的间接子类-我说得对吗

Numeric.===(10) #=> true

但是为什么下面的输出与上面的相矛盾呢

Numeric.===(Fixnum) #=> false

尝试对我的查询更具体，如下所示：

当我们调用
Numeric.==（10）
和
String.==（“abc”）
时。我认为我们发送的不是
“abc”
和
10
，而是
“abc.class
和
10.class

10.===(10) #=> true
Numeric.===(10) #=> true

现在看看上面。两者都返回
true
。它们是否在同一逻辑上输出
true
？我认为不
<代码>10。==（10）

就像

10==（10）

比较。但是

Numeric.==（10）

输出

true

，因为

10

的类是

Numeric

的子类

"abc".===("abc") #=> true
String.===("abc") #=> true

现在看看上面。两者都返回

true

。它们是否在同一逻辑上输出

true

？我认为不<代码>“abc”。==（“abc”）就像简单的字符串文字比较

“abc”==（“abc”）

比较。但是

String.==（“abc”）

将

true

输出为

“abc”

，它是

String

的一个实例

现在我的问题是ruby如何检测左侧操作数类型并应用正确的比较规则

---

我可能100%错了，那么请纠正我。

我将尝试解释@Lee Jarvis也解释了什么

class Someclass
end

s = Someclass.new
p s.methods.sort
#[:!, :!=, :!~, :<=>, :==, :===, :=~, :__id__, :__send__, :class, :clone,(...)

class-Someclass
结束
s=Someclass.new
p.s.methods.sort
#[：！、：！=、：！~、：、：=、：==、：==、：=、：\u id、：\u发送、：类、：克隆、（…）

看看第5个方法，我的Someclass实例有一个不知从何而来的

=

方法

实际上，它有56个方法，我没有定义其中的一个。它们是从Object继承的；Ruby中的每个类都是从Object继承的。对于class Object（和我的Someclass），#===实际上与调用#==相同，但是（正如文档所说）#==通常会被后代覆盖，以便在case语句中提供有意义的语义

---

所以ruby没有什么聪明的地方，它只是发送一条

==

消息给有问题的对象（或者调用

==

方法，如果你愿意的话）。

我将尝试解释@Lee Jarvis也解释了什么

class Someclass
end

s = Someclass.new
p s.methods.sort
#[:!, :!=, :!~, :<=>, :==, :===, :=~, :__id__, :__send__, :class, :clone,(...)

class-Someclass
结束
s=Someclass.new
p.s.methods.sort
#[：！、：！=、：！~、：、：=、：==、：==、：=、：\u id、：\u发送、：类、：克隆、（…）

看看第5个方法，我的Someclass实例有一个不知从何而来的

=

方法

实际上，它有56个方法，我没有定义其中的一个。它们是从Object继承的；Ruby中的每个类都是从Object继承的。对于class Object（和我的Someclass），#===实际上与调用#==相同，但是（正如文档所说）#==通常会被后代覆盖，以便在case语句中提供有意义的语义

所以ruby并没有做什么聪明的事情，它只是向有问题的对象发送一条

=

消息（或者调用

=

方法，如果您愿意的话）

现在我的问题是ruby如何检测左侧操作数类型并应用正确的比较规则

它不是。它只是调用

==

方法。就是这样。这就是面向对象的工作原理，它不是Ruby特有的，每种OO语言的工作方式都是一样的：你对一个对象调用一个方法，对象决定如何反应。（或者，在一个基于类的语言中，如Ruby、PHP、java、C++、C++、Python等。对象的类决定。） 不同的对象可能以不同的方式反应。类检查参数是否是它们自己的实例，regexp检查参数是否与它们匹配，范围检查参数是否被它们覆盖

这只是基本的方法

现在我的问题是ruby如何检测左侧操作数类型并应用正确的比较规则

它不是。它只是调用

==

方法。就是这样。这就是面向对象的工作原理，它不是Ruby特有的，每种OO语言的工作方式都是一样的：你对一个对象调用一个方法，对象决定如何反应。（或者，在一个基于类的语言中，如Ruby、PHP、java、C++、C++、Python等。对象的类决定。） 不同的对象可能以不同的方式反应。类检查参数是否是