类对象、单例类

Question

我在 ruby​​ 中玩元编程，我有一个问题。我有一堂课：

class Klass
  class << self
    @x = "yeah"
  end
end
b = Klass.new
a = class << Klass; self; end
a.instance_eval "@x"           #=> yeah
Klass.instance_eval "@x"       #=> nil

为什么？在变量 a 中我有一个单例类，对吗？并且在单例类的上下文中执行Klass.instance_eval：

Klass.instance_eval "def yeah; puts 10; end"
Klass.yeah                     #=> 10

另外，解释器中的Klass指向类的上下文，是吗？并且 a 指向单例类的上下文？ 哪个表示 a.class_eval 和 a.instance_eval？我明白：

a.instance_eval "def pops; puts 0; end"
a.class_eval "def popsx; puts 1; end"
a.pops                         #=> 0
a.popsx                        # FAIL
Klass.pops                     # FAIL
Klass.popsx                    #=> 1
b.pops; b.popsx                # DOUBLE FAIL

但我不明白这一点。谢谢！

Answer 1

首先，虽然看起来eigentclass被一些人使用，但singleton class是更常见的术语。 Singleton 类包含 Ruby 中对象的特定于对象的行为。除了该单例类所属的原始对象之外，您无法创建该类的其他实例。

谈论不同类型的 eval 中的方法定义这篇文章 为 instance_eval 和 class_eval 中定义的方法引入了很好的规则：

使用ClassName.instance_eval定义类方法。
使用 ClassName.class_eval 定义实例方法。

这几乎描述了情况。

有一篇关于 Class 类的实例的类、作为 Class 类的子类的单例类以及其他一些疯狂的东西（与问题没有多大关系）的文章。但是，由于您的问题可以轻松应用于常规对象及其类（并且这使得事情更容易解释），我决定删除所有内容（不过，您仍然可以在答案的修订历史记录中看到这些内容）。

让我们看看常规类和该类的实例，看看它们是如何工作的：

class A; end
a = A.new

不同类型的 eval 中的方法定义：

# define instance method inside class context
A.class_eval { def bar; 'bar'; end }
puts a.bar     # => bar
puts A.new.bar # => bar

# class_eval is equivalent to re-opening the class
class A
  def bar2; 'bar2'; end
end
puts a.bar2     # => bar2
puts A.new.bar2 # => bar2

定义特定于对象的方法：

# define object-specific method in the context of object itself
a.instance_eval { def foo; 'foo'; end }
puts a.foo # => foo

# method definition inside instance_eval is equivalent to this
def a.foo2; 'foo2'; end
puts a.foo2 # => foo2

# no foo method here
# puts A.new.foo # => undefined method `foo' for #<A:0x8b35b20>

现在让我们看看对象 a 的单例类：

# singleton class of a is subclass of A
p (class << a; self; end).ancestors
# => [A, Object, Kernel, BasicObject]

# define instance method inside a's singleton class context
class << a
  def foobar; 'foobar'; end;
end
puts a.foobar # => foobar

# as expected foobar is not available for other instances of class A
# because it's instance method of a's singleton class and a is the only
# instance of that class
# puts A.new.foobar # => undefined method `foobar' for #<A:0x8b35b20>

# same for equivalent class_eval version
(class << a; self; end).class_eval do
  def foobar2; 'foobar2'; end;
end
puts a.foobar2 # => foobar2

# no foobar2 here as well
# puts A.new.foobar2 # => undefined method `foobar2' for #<A:0x8b35b20>

现在让我们看看实例变量

# define instance variable for object a
a.instance_eval { @x = 1 }

# we can access that @x using same instance_eval
puts a.instance_eval { @x } # => 1
# or via convenient instance_variable_get method
puts a.instance_variable_get(:@x) # => 1

：现在到 class_eval 中的实例变量：

# class_eval is instance method of Module class
# so it's not available for object a
# a.class_eval { } # => undefined method `class_eval' for #<A:0x8fbaa74>

# instance variable definition works the same inside
# class_eval and instance_eval
A.instance_eval { @y = 1 }
A.class_eval    { @z = 1 }

# both variables belong to A class itself
p A.instance_variables # => [:@y, :@z]

# instance variables can be accessed in both ways as well
puts A.instance_eval { @y } # => 1
puts A.class_eval    { @z } # => 1

# no instance_variables here
p A.new.instance_variables # => []

现在，如果将类 A 替换为类 Class，将对象 a 替换为对象 < code>Klass （在这种特殊情况下只不过是类 Class 的实例）我希望您能得到对您问题的解释。如果您还有一些，请随时询问。

Answer 2

很难完全回答您的问题（有关 Ruby 类模型的彻底解释，请参阅 Dave Thomas 的出色演示），不过：

使用 class_eval，您实际上定义了实例方法 - 就好像您处于 班级。例如：

class Klass
end

Klass.class_eval do
  def instance_method
    puts 'instance method'
  end
end

obj = Klass.new
obj.instance_method  # instance method

使用 instance_eval，您实际上定义了类方法 - 就好像您位于给定对象的单例（eigenclass）类的主体内（注意类在 Ruby 中也是对象）。例如：

Klass.instance_eval do
  def class_method
    puts 'class method'
  end
end

Klass.class_method  # class method

在您的情况下：

Klass.instance_eval "@x" 不起作用，因为 @x 不是 Klass 的一部分，它是 Klass 单例类的一部分：

class Klass
  class << self
    @x = "yeah"
  end

  puts @x
end

# prints nothing

< code>a.instance_eval "@x" 工作正常，因为您在 a 单例类的上下文中计算“@x”，该单例类与您在其中使用的 Klass 类的单例类连接定义了@x实例变量。单例类如何互连可以通过以下示例来说明：

class Foo
end

f = class << Foo; self; end
g = class << Foo; self; end

f.instance_eval "def yeah; puts 'yeah'; end"

g.yeah  # yeah

g.instance_eval "def ghee; puts 'ghee'; end"

f.ghee  # ghee

Klass.instance_eval "def yes; put 10; end" 定义一个“普通”类方法。因此，Klass.yeah 工作正常（请参阅前面示例中的 Klass.class_method）。

a.instance_eval "def pops; puts 0; end" 定义 a 单例类的类方法。因此，a.pops实际上意味着调用pops类方法（同样，这就像调用Klass.class_method）。

a.popsx 不起作用，因为您首先必须创建 a 的实例才能在其上调用 popsx（但不可能创建 a 的新实例）单例类）。

Klass.pops 不起作用，因为 Klass 的单例类中没有定义任何 pops 方法（pops 是在 a 中定义的） 的单例类）。

Klass.popsx 之所以有效，是因为使用 a.class_eval "def popsx; put 1; end" 您已经定义了 popsx 实例方法，然后可以在 Klass 对象上调用该方法。在某种程度上，它与这个例子类似：

class Other
end

o = Other.new

Other.class_eval "def yeah; puts 'yeah'; end"

o.yeah  # yeah

希望它有帮助。