为什么所有东西都是Ruby中类的实例？

我不太了解Ruby对象模型。首先，Ruby中的所有东西都是

类的实例吗？这些都是真实的：

p Object.instance_of?(Class)
p Class.instance_of?(Class)
p Module.instance_of?(Class)
p BasicObject.instance_of?(Class)
class Hello; end
p Hello.instance_of?(Class)

我不太明白，如果
对象
是
类
的一个超类，它怎么可能同时是
类
的一个超类和它的一个实例（Ruby对象模型上的大多数图都清楚地说明了这个层次结构）？这就产生了这样的疯狂：

p BasicObject.is_a?(Object) #=> true

其中
BasicObject.class
是
class
，而
class.is_是一个？（对象）

顺便说一下，使用Ruby 2.0

首先，Ruby中的所有东西都是
类的实例吗

不，并非所有内容都是
类的实例。只有类是
类的实例

有很多东西不是
Class
的实例：例如，字符串是
String
的实例，而不是
Class
。数组是
数组
的实例，
整数是
整数
的实例，
浮点数是
浮点数
的实例，
真
是
真类
的实例，
假
是
假类
的实例，
零
是
零类
的实例，依此类推

每个类都是
类
的实例，就像每个字符串都是
字符串
的实例一样

如果
对象
是
类
的一个超类，它怎么可能同时是
类
的一个超类和它的一个实例（Ruby对象模型上的大多数图表都清楚地说明了这个层次结构）

魔法

与大多数其他语言一样，有些核心实体被简单地假设为存在。它们从天而降，凭空而出，神奇地出现

在Ruby中，一些神奇的东西是：


对象
没有超类，但不能定义没有超类的类，隐式直接超类始终是
对象
。[注意：
对象可能有实现定义的超类
，但最终会有一个没有超类的超类。]
对象
是
类
的一个实例，该类是
对象
的一个子类（这意味着间接地
对象
是
对象
本身的一个实例）
类
是
模块
的子类，它是
类
Class
是
Class

这些都不能用Ruby来解释

BasicObject
、
Object
、
Module
和
Class
都需要同时出现，因为它们具有循环依赖关系

仅仅因为这种关系不能用Ruby代码表示，并不意味着Ruby语言规范不能说它必须如此。这取决于实现者找到一种实现方法。毕竟，Ruby实现具有作为程序员所不具备的对对象的访问级别

例如，Ruby实现可以首先创建
BasicObject
，将其
超类
指针和
类
指针设置为
null

然后，它创建
对象
，将其
超类
指针设置为
基本对象
，将其
类
指针设置为
空

接下来，它创建
模块
，将其
超类
指针设置为
对象
，将其
类
指针设置为
空

最后，它创建
类
，将其
超类
指针设置为
模块
，将其
类
指针设置为
空

现在，我们可以覆盖
基本对象
，
对象
，
模块
，和
类
指针指向
类
，我们就完成了

这在系统外部很容易做到，但从内部看却很奇怪。
您应该注意到：

p BasicObject.instance_of?(BasicObject) 

打印
false

也就是说，表达式
basicbject
不是
basicbject
的实例，它是其他事物的实例，也就是说，它是
类
对象，它表示一个包含（例如）类方法的对象，例如
new

例如：

p (BasicObject.new()).instance_of?(BasicObject)

打印
true
，以及

p (BasicObject.new()).instance_of?(Class)

打印
false
您的所有示例都是按定义的类。类也是对象。但您没有做的是查看一个类的实例：

p Object.new.class
p Hello.new.class

类定义对象的形式，根据定义，类就是类。但当您将类实例化为对象时，对象就是新类型。但您仍然可以看到对象的类本身就是类：

p Hello.new.class.class

您的最后一句话可能应该是“…对象的类本身就是
class
”或“…对象的类本身就是
class
的（n个实例）”