ruby：如何正确地要求（避免循环依赖）

Question

今天我遇到了一个奇怪的问题： 在模块上出现“缺少方法”错误，但该方法在那里并且需要定义该模块的文件。经过一番搜索，我发现了一个循环依赖项，其中 2 个文件相互需要，现在我假设 ruby​​ 默默地中止循环需要。

---

编辑开始：示例

文件'a.rb'：

require './b.rb'

module A
    def self.do_something
        puts 'doing..'
    end
end

文件'b.rb'：

require './a.rb'

module B
    def self.calling
        ::A.do_something
    end
end

B.calling

执行 b.rb 会得到b.rb:5:in 'calling': uninitialized constant A (NameError)。这两个文件都必须存在要求，因为它们旨在从命令行自行运行（我省略了该代码以使其简短）。 所以 B.calling 必须在那里。一种可能的解决方案是将需求包装在 if __FILE__ == $0 中，但这似乎不是正确的方法。

编辑结束

---

为了避免这些难以发现的错误（顺便说一句，如果 require 抛出异常不是更好吗？），是否有一些关于如何构建项目以及在哪里需要什么的指南/规则？例如，如果我有

module MainModule
  module SubModule
    module SubSubModule
    end
  end
end

我应该在哪里需要子模块？全部在 main 中，还是只有在 main 中的 sub 和 sub 中的 subsub？

任何帮助都会非常好。

总结

forforfs answer 和 cmets 中讨论了为什么会发生这种情况。

到目前为止，最佳实践（正如lain指出或暗示的那样）似乎如下（如果我错了，请纠正我）：

1. 将顶层命名空间中的每个模块或类放入以模块/类命名的文件中。在我的示例中，这将是 1 个名为“main_module.rb”的文件。 如果有子模块或子类，则创建一个以模块/类命名的目录（在我的示例中为目录'main_module'，并将子类/子模块的文件放在那里（在示例1中名为'sub_module.rb'的文件中） . 对命名空间的每个级别重复此操作。
2. 需要逐步说明（在示例中，MainModule 需要SubModule，Submodule 需要SubSubModule）
3. 将“运行”代码与“定义”代码分开。在运行代码中需要一次您的顶级模块/类，因此由于 2. 您现在应该可以使用所有库功能，并且您可以运行任何已定义的方法。

感谢所有回答/评论的人，对我帮助很大！

Answer 1

不久前在 Ruby 邮件列表上询问了这个问题后，当我以前在我的库中有一个文件只是为了需要一些东西时，我改为以下两条规则：

1. 如果一个文件需要同一个库中另一个文件的代码，我在需要代码的文件中使用require_relative。

2. 如果文件需要来自不同库的代码，我在需要代码的文件中使用require。

据我了解，Ruby 按照要求的顺序要求，因此循环依赖无关紧要。

（Ruby v1.9.2）

回答关于显示循环依赖问题的示例的评论：

实际上，该示例的问题不在于要求是循环的，而是在要求完成之前调用了B.calling。如果您从 b.rb 中删除 B.calling ，它工作正常。例如，在 irb 中没有 B.calling 在代码文件中但之后运行：

$ irb
需要'/Volumes/RubyProjects/Test/stackoverflow8057625/b.rb'
=> 真的
B.调用
正在做..
=> 无

Answer 2

您希望已经知道的一些基本知识：

1. Ruby 是解释的，而不是编译的，所以你不能执行解释器没有看到的任何代码。

2. require 只是将文件中的代码插入程序的该点，换句话说，程序顶部的 require 将在底部的 require 之前解释。

（注意：已编辑以说明 require 语句的行为） 因此，如果您要这样做： ruby a.rb 这是 ruby​​ 解释器会看到并执行的：

#load file b.rb <- from require './b.rb' in 'a.rb' file

#load file a.rb <- from require './a.rb' in 'b.rb' file
  #this runs because a.rb has not yet been required

#second attempt to load b.rb but is ignored <- from require './b.rb' in 'a.rb' file

#finish loading the rest of a.rb

module A
  def self.do_something
    puts 'doing..'
  end
end

#finish loading the rest of b.rb

module B
  def self.calling
    ::A.do_something
  end
end
B.calling

#Works because everything is defined 

如果你先运行 b，ruby b.rb，解释器会看到：

#load file a.rb <- from require './a.rb' in 'b.rb' file

#load file b.rb <- from require './b.rb' in 'a.rb' file
  #this runs because b.rb has not yet been required

#second attempt to load a.rb but is ignored <- from require './a.rb' in 'b.rb' file

#finish loading the rest of b.rb
module B
  def self.calling
    ::A.do_something
  end
end
B.calling #NameError, ::A.do_something hasn't been defined yet.

希望这能解释其他人给你的好答案，如果你仔细想想，为什么很难回答你最后一个关于在哪里放置 require 语句的问题。使用 Ruby，您需要 文件 而不是模块，因此在代码中放置 require 的位置取决于文件的组织方式。

如果您绝对需要能够定义模块并以随机顺序执行方法，那么您可以实现类似的东西来收集对尚不存在的模块的调用，然后在它们出现时调用它们。

module Delay
  @@q = {}  
  def self.call_mod(*args) #args format is method_name, mod_name, *args
    mod_name = args.shift
    method_name = args.shift
    #remaining args are still in args
    mod = Object.const_get(mod_name.to_sym)
    mod.send(method_name.to_sym, *args)
  end

  def self.exec(mod_name, *args)
    begin
      args.unshift(mod_name)
      self.call_mod(*args)
    rescue NameError, NoMethodError
      @@q[mod_name] ||= []
      @@q[mod_name] << args
    end
  end

  def self.included(mod)
    #get queued methods
    q_list = @@q[mod.name.to_sym]
    return unless q_list
    #execute delayed methods now that module exists
    q_list.each do |args|
      self.call_mod(*args)
    end
  end
end 

请务必先定义延迟模块，然后再使用Delay.exec(:B, :calling, any_other_args)，而不是调用B.calling。所以如果你在延迟模块之后有这个：

Delay.exec(:B, :calling)   #Module B is not defined

module B
  def self.calling
    ::A.do_something
  end
  include Delay #must be *after* any callable method defs
end

module A
  def self.do_something
    puts 'doing..'
  end
  include Delay #must be *after* any callable method defs
end

结果：

#=> doing..

最后一步是将代码分解为文件。一种方法是拥有三个文件

delay.rb   #holds just Delay module
a.rb       #holds the A module and any calls to other modules 
b.rb       #holds the B module and any calls to other modules

只要您确保 require 'delay' 是模块文件（a.rb 和 b.rb）的第一行，并且模块末尾包含延迟，那么一切都会正常。

最后说明：只有当您无法将定义代码与模块执行调用分离时，此实现才有意义。