我在玩 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

我不明白这一点。谢谢!

最佳答案

首先，虽然某些人似乎使用了 eigentclass，但 singleton class 是更常见的术语。 Singleton 类包含 Ruby 中对象的对象特定行为。除了该单例类所属的原始对象之外，您不能创建该类的其他实例。

关于在不同类型的 eval 中定义方法 this article为 instance_eval 和 class_eval 中定义的方法引入了很好的规则:

Use ClassName.instance_eval to define class methods.
Use ClassName.class_eval to define instance methods.

这几乎描述了这种情况。

关于作为 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 替换为对象 Klas(在此特殊情况只不过是类 Class 的实例)我希望你能得到对你问题的解释。如果您还有一些问题，请随时询问。

关于ruby - 类对象，单例类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8631223/