理解Ruby开放类

我试图理解ruby开放类的工作原理。特别是如何将方法添加到现有类中

必须应用一些逻辑来确定类是否已经存在

有人能解释一下这个概念吗

---

提前感谢。

类名是常量，因此很容易看到类名是否已经存在：

Object.constants.grep(/Array/) #=> ["Array"]

---

因此，如果已经定义了一个类（

Object.const\u get（'Array'）。它是一个类吗？

），则会将方法添加到该类中，否则会定义一个新类。更准确地说，这发生在Ruby的C端，但大体上是这样的。

类名是常量，因此很容易看出类名是否已经存在：

Object.constants.grep(/Array/) #=> ["Array"]

---

因此，如果已经定义了一个类（

Object.const\u get（'Array'）。它是一个类吗？

），则会将方法添加到该类中，否则会定义一个新类。更准确地说，这种情况发生在Ruby的C端，但基本上就是这样。

在Ruby下面，有一些消息

假设您有一个类

a

，并且

a

是

a

的一个实例。实际上涉及到几个类别：

Basic Object
-> Object
-> A
-> a

当您在

a

上调用方法foo时，实际发生的是您正在将消息“call foo”发送到

a

。它检查是否为

a

定义了实例方法（如singleton/eigenclass），然后尝试

a

的实例方法，然后是

对象

，最后是

基本对象

。如果所有其他操作都失败，VM将发送一条新消息（即“找不到方法”），然后该过程将再次启动，直到被捕获为止（默认情况下，它会引发异常）

您可以向层次结构中的任何类添加新方法（即消息处理程序），以更改

a

的行为。如果将实例方法添加到

A

或

对象

，则

A

将拥有它。如果仅向

a

添加方法（即

def a.bar；'bar'；end

），则

a

的其他实例将具有该方法

---

Ruby的类（我认为更合适的说法是Ruby的对象）是开放的，因为您可以在任何时间点添加这些新方法，即消息处理程序，包括在定义它们之后的很长一段时间

假设您有一个类

a

，并且

a

是

a

的一个实例。实际上涉及到几个类别：

Basic Object
-> Object
-> A
-> a

当您在

a

上调用方法foo时，实际发生的是您正在将消息“call foo”发送到

a

。它检查是否为

a

定义了实例方法（如singleton/eigenclass），然后尝试

a

的实例方法，然后是

对象

，最后是

基本对象

。如果所有其他操作都失败，VM将发送一条新消息（即“找不到方法”），然后该过程将再次启动，直到被捕获为止（默认情况下，它会引发异常）

您可以向层次结构中的任何类添加新方法（即消息处理程序），以更改

a

的行为。如果将实例方法添加到

A

或

对象

，则

A

将拥有它。如果仅向

a

添加方法（即

def a.bar；'bar'；end

），则

a

的其他实例将具有该方法

---

Ruby的类（我认为说Ruby的对象更合适）是开放的，因为您可以添加这些新方法，即消息处理程序，在任何时间点——包括定义它们之后的很长时间。

您的意思是如何实现

class

关键字以查看类是否已经存在？您的意思是如何实现

class

关键字以查看类是否已经存在？