定义类的不同方式如何影响包含工作的方式？

Question

我有一个简单的模块，它定义了一个常量并将其设为私有：

module Foo
  Bar = "Bar"
  private_constant :Bar
end

我可以将它包含在这样的类中，并且它按预期工作：（

class User
  include Foo

  def self.test
    Bar
  end
end

puts User.test
# => Bar

begin
  User::Bar
rescue => exception
  puts "#{exception} as expected"
  # => private constant Foo::Bar referenced as expected
end

让我们称其为“典型类”定义）

然后我尝试了 Class.new 方法，但这惨败：

X = Class.new do
  include Foo

  def self.test
    Bar # Line 28 pointed in the stack trace
  end
end

begin
  X::Bar
rescue => exception
  puts "#{exception}"
  # => private constant Foo::Bar
end

puts X.test
# test.rb:28:in `test': uninitialized constant Bar (NameError)
#         from test.rb:28:in `<main>'

为什么？我一直认为 class Something 和 Something = Class.new 是等效的。实际的区别是什么？

然后我突然灵机一动，想起还有一种定义类方法的替代方法，它确实有效：

X = Class.new do
  class << self
    include Foo
    def test
      Bar
    end
  end
end

begin
  X::Bar
rescue => exception
  puts "#{exception}"
  # => uninitialized constant X::Bar
end

puts X.test
# Bar

再次 - 为什么这个有效，以及为什么异常现在不同：私有常量 Foo::Bar与未初始化的常量X::Bar？

这三种初始化类的方法似乎有细微差别。

1. 正是我想要的：Bar可以在内部访问，并且访问它会给出引用私有常量的异常。
2. 第二个给出“ok”异常，但无法访问 Bar 本身
3. 第三个可以访问，但现在给出略有不同的异常

这里到底发生了什么？

Answer 1

这是 Ruby 中最大的问题之一：常量定义范围部分是语法性的，也就是说，它取决于它周围的代码的结构。

module Foo
  Bar = "Bar"
end

Bar 位于 module 定义内，因此它是在该模块中定义的。

class << self
  include Foo
end

Bar 包含在 class 定义中，因此它是在该类中定义的。

Class.new do
  include Foo
end

没有封闭的class或module（这是带有块的普通方法调用），因此常量是在顶层定义的。

至于你的第三个错误，我相信这是因为常量是在单例类中定义的（这就是class << self）而不是类本身。它们是两个独立的类对象。