Ruby 元编程：无法将方法发送到模块

Question

例如我有以下自定义类和模块：

module SimpleModule
  def hello_world
    puts 'i am a SimpleModule method'
  end

  def self.class_hello_world
    puts 'i am a SimpleModule class method'
  end
end

class SimpleClass
  def hello_world
    puts 'i am SimpleClass method'
  end

  def self.class_hello_world
    puts 'i am a SimpleClass class method'
  end
end

我尝试使用方法send在类和模块中调用这些方法

SimpleClass.send(class_hello_world)  # work
SimpleClass.new.send(hello_world)    # work
SimpleModule.send(class_hello_world) # work
SimpleModule.new.send(hello_world)   # not work
SimpleModule.send(hello_world)       # not work

换句话说，我不知道如何从SimpleModule 调用hello_world。如果该方法之前用 self 定义过，这是可能的。

我需要这样做是因为我想实现一个“自定义包含”：它包含从模块到另一个类的所有方法。

请告诉我该怎么做。

Answer 1

五个陈述

让我们一次一个地考虑这五个语句（但顺序与所示顺序不同）。注意send的参数必须是方法名，用字符串或符号表示。

SimpleModule.send("class_hello_world")
  # i am a SimpleModule class method

这是正常的，尽管这些方法通常称为模块方法。一些常见的内置模块，例如Math，只包含模块方法。

SimpleClass.send(:class_hello_world)
  # i am a SimpleClass class method

由于类是一个模块，其行为与上述相同。 class_hello_world 通常被称为类方法。

SimpleClass.new.send(:hello_world)
  # i am SimpleClass method

这是实例方法的正常调用。

SimpleModule.send("hello_world")
  #=> NoMethodError: undefined method `hello_world' for SimpleModule:Module

没有模块方法hello_world。

SimpleModule.new.send(hello_world)
  #=> NoMethodError: undefined method `new' for SimpleModule:Module

不能创建模块的实例。

include 与 prepend

假设有人写了

SimpleClass.include SimpleModule
  #=> SimpleClass
SimpleClass.new.hello_world
  # i am SimpleClass method

所以SimpleClass'原始方法hello_world不会被同名的模块方法覆盖。考虑SimpleClass'的祖先。

SimpleClass.ancestors
  #=> [SimpleClass, SimpleModule, Object, Kernel, BasicObject]

Ruby 将在SimpleClass 中查找hello_world——并找到它——然后再考虑SimpleModule。

但是，可以使用Module#prepend 将SimpleModule#hello_world 放在SimpleClass#hello_world 之前。

SimpleClass.prepend SimpleModule
  #=> SimpleClass
SimpleClass.new.hello_world
  # i am a SimpleModule method
SimpleClass.ancestors
  #=> [SimpleModule, SimpleClass, Object, Kernel, BasicObject]

绑定未绑定的方法

你还有一件事要做。 SimpleModule 的实例方法（这里只有一个）是未绑定的。您可以使用UnboundMethod#bind 将每个绑定到SimpleClass 的实例，然后使用call 或send 执行它。

sc = SimpleClass.new
  #=> #<SimpleClass:0x007fcbc2046010> 
um = SimpleModule.instance_method(:hello_world)
  #=> #<UnboundMethod: SimpleModule#hello_world> 
bm = um.bind(sc)
  #=> #<Method: SimpleModule#hello_world> 
bm.call
  #=> i am a SimpleModule method
sc.send(:hello_world)
  #=> i am a SimpleModule method

Answer 2

模块不能有实例方法，因为它们不是类。如果您在模块中定义实例方法，则称为 mixin。这些“mixin”可以包含在另一个类中，然后可供使用。

完整的解释在这里docs

编辑：

例如，您可以这样做：

module SimpleModule
  def hello_world
    p 'hello world'
  end
end

class Example
  include SimpleModule
end

Example.new.send(:hello_world)

这是调用模块 mixin 的一种方法。

Answer 3

因为您似乎想创建自己的包含版本。

查看Module.append_features 文档

当这个模块被包含在另一个模块中时，Ruby 调用 append_features 此模块，将其传递给 mod 中的接收模块。 Ruby 的默认设置 实现是添加常量、方法和模块变量 如果此模块尚未添加到 mod，则将此模块添加到 mod 或其祖先之一。另请参阅 Module#include。

如果你想自己重写include，这就是你必须做的。

由于您喜欢冒险，也许您会喜欢阅读 Ruby 的源代码，看看它是如何在内部实现的。见https://github.com/ruby/ruby...class.c#L853:L934

Answer 4

您也可以使用constantize:

def call_method(method)
  "SimpleModule::#{method}".constantize
end