201

背景：

我有一个模块，它声明了许多实例方法

module UsefulThings
  def get_file; ...
  def delete_file; ...

  def format_text(x); ...
end

我想从一个类中调用其中一些方法。你通常如何在 ruby​​ 中执行此操作是这样的：

class UsefulWorker
  include UsefulThings

  def do_work
    format_text("abc")
    ...
  end
end

问题

include UsefulThings从中引入所有方法UsefulThings。在这种情况下，我只想要format_text并且明确地不想要get_fileand delete_file。

我可以看到几个可能的解决方案：

  1. 以某种方式直接在模块上调用该方法，而不在任何地方包含它
    • 我不知道如何/是否可以做到这一点。（因此这个问题）
  2. 不知何故包括Usefulthings并且只引入它的一些方法
    • 我也不知道如何/是否可以做到
  3. 创建一个代理类，包含UsefulThings在其中，然后委托format_text给该代理实例
    • 这会起作用，但匿名代理类是一种黑客攻击。呸。
  4. 将模块拆分为 2 个或更多更小的模块
    • 这也可行，并且可能是我能想到的最好的解决方案，但我宁愿避免它，因为我最终会得到几十个模块的扩散——管理这将是繁重的

为什么单个模块中有很多不相关的功能？它ApplicationHelper来自一个 Rails 应用程序，我们的团队实际上已决定将其作为任何不具体到不属于其他任何地方的东西的垃圾场。主要是随处使用的独立实用程序方法。我可以把它分解成单独的助手，但是会有 30 个，每个都有 1 种方法......这似乎没有生产力

4

10 回答 10

167

我认为只需一次性调用（不更改现有模块或创建新模块）的最短方法如下：

Class.new.extend(UsefulThings).get_file
于 2009-09-11T14:03:09.880 回答
145

如果将模块上的方法转换为模块函数，您可以简单地从 Mods 中调用它，就好像它已被声明为

module Mods
  def self.foo
     puts "Mods.foo(self)"
  end
end

下面的 module_function 方法将避免破坏任何包含所有 Mod 的类。

module Mods
  def foo
    puts "Mods.foo"
  end
end

class Includer
  include Mods
end

Includer.new.foo

Mods.module_eval do
  module_function(:foo)
  public :foo
end

Includer.new.foo # this would break without public :foo above

class Thing
  def bar
    Mods.foo
  end
end

Thing.new.bar

但是，我很好奇为什么一组不相关的函数首先都包含在同一个模块中？

编辑显示，如果public :foo在之后调用，包括仍然有效module_function :foo

于 2008-11-26T23:27:24.890 回答
93

如果您“拥有”该模块，另一种方法是使用module_function.

module UsefulThings
  def a
    puts "aaay"
  end
  module_function :a

  def b
    puts "beee"
  end
end

def test
  UsefulThings.a
  UsefulThings.b # Fails!  Not a module method
end

test
于 2008-11-26T23:23:05.353 回答
23

如果您想调用这些方法而不在另一个类中包含模块，那么您需要将它们定义为模块方法：

module UsefulThings
  def self.get_file; ...
  def self.delete_file; ...

  def self.format_text(x); ...
end

然后你可以打电话给他们

UsefulThings.format_text("xxx")

或者

UsefulThings::format_text("xxx")

但无论如何，我建议您将相关方法放在一个模块或一个类中。如果你有问题想要只包含模块中的一个方法，那么这听起来像是一种糟糕的代码味道，并且将不相关的方法放在一起并不是好的 Ruby 风格。

于 2008-11-26T23:18:29.793 回答
20

要调用模块实例方法而不包含模块（并且不创建中间对象）：

class UsefulWorker
  def do_work
    UsefulThings.instance_method(:format_text).bind(self).call("abc")
    ...
  end
end
于 2014-10-02T03:50:57.330 回答
7

首先，我建议将模块分解为您需要的有用的东西。但是你总是可以创建一个类来扩展你的调用：

module UsefulThings
  def a
    puts "aaay"
  end
  def b
    puts "beee"
  end
end

def test
  ob = Class.new.send(:include, UsefulThings).new
  ob.a
end

test
于 2008-11-26T23:16:11.873 回答
7

不确定 10 年后是否有人仍然需要它，但我使用 eigenclass 解决了它。

module UsefulThings
  def useful_thing_1
    "thing_1"
  end

  class << self
    include UsefulThings
  end
end

class A
  include UsefulThings
end

class B
  extend UsefulThings
end

UsefulThings.useful_thing_1 # => "thing_1"
A.new.useful_thing_1 # => "thing_1"
B.useful_thing_1 # => "thing_1"
于 2019-10-01T23:48:14.280 回答
6

A. 如果您总是想以“合格”的独立方式（UsefulThings.get_file）调用它们，那么就像其他人指出的那样，将它们设为静态，

module UsefulThings
  def self.get_file; ...
  def self.delete_file; ...

  def self.format_text(x); ...

  # Or.. make all of the "static"
  class << self
     def write_file; ...
     def commit_file; ...
  end

end

B. 如果您仍然想在相同的情况下保留 mixin 方法，以及一次性独立调用，您可以拥有一个使用 mixin扩展自身的单线模块：

module UsefulThingsMixin
  def get_file; ...
  def delete_file; ...

  def format_text(x); ...
end

module UsefulThings
  extend UsefulThingsMixin
end

所以两者都有效：

  UsefulThings.get_file()       # one off

   class MyUser
      include UsefulThingsMixin  
      def f
         format_text             # all useful things available directly
      end
   end

恕我直言，它比module_function每种方法都更清洁-以防万一。

于 2014-02-06T21:21:59.280 回答
5

据我了解这个问题，您想将模块的一些实例方法混合到一个类中。

让我们从考虑Module#include 的工作原理开始。假设我们有一个UsefulThings包含两个实例方法的模块：

module UsefulThings
  def add1
    self + 1
  end
  def add3
    self + 3
  end
end

UsefulThings.instance_methods
  #=> [:add1, :add3]

和Fixnum include那个模块：

class Fixnum
  def add2
    puts "cat"
  end
  def add3
    puts "dog"
  end
  include UsefulThings
end

我们看到：

Fixnum.instance_methods.select { |m| m.to_s.start_with? "add" }
  #=> [:add2, :add3, :add1] 
1.add1
2 
1.add2
cat
1.add3
dog

您是否期望UsefulThings#add3覆盖Fixnum#add3，以便1.add3返回4？考虑一下：

Fixnum.ancestors
  #=> [Fixnum, UsefulThings, Integer, Numeric, Comparable,
  #    Object, Kernel, BasicObject]

当类include成为模块时，模块成为类的超类。因此，由于继承的工作方式，发送add3到 的实例Fixnum将导致Fixnum#add3被调用，返回dog.

现在让我们添加一个:add2方法UsefulThings：

module UsefulThings
  def add1
    self + 1
  end
  def add2
    self + 2
  end
  def add3
    self + 3
  end
end

我们现在只Fixnum希望include方法add1和add3。这样做，我们期望得到与上面相同的结果。

假设，如上所述，我们执行：

class Fixnum
  def add2
    puts "cat"
  end
  def add3
    puts "dog"
  end
  include UsefulThings
end

结果是什么？不需要的方法:add2被添加到Fixnum，:add1被添加，并且由于我上面解释的原因，:add3没有被添加。所以我们要做的就是undef :add2。我们可以使用一个简单的辅助方法来做到这一点：

module Helpers
  def self.include_some(mod, klass, *args)
    klass.send(:include, mod)
    (mod.instance_methods - args - klass.instance_methods).each do |m|
      klass.send(:undef_method, m)
    end
  end
end

我们这样调用：

class Fixnum
  def add2
    puts "cat"
  end
  def add3
    puts "dog"
  end
  Helpers.include_some(UsefulThings, self, :add1, :add3)
end

然后：

Fixnum.instance_methods.select { |m| m.to_s.start_with? "add" }
  #=> [:add2, :add3, :add1] 
1.add1
2 
1.add2
cat
1.add3
dog

这就是我们想要的结果。

于 2015-08-13T07:27:00.267 回答
1

将近 9 年后，这是一个通用的解决方案：

module CreateModuleFunctions
  def self.included(base)
    base.instance_methods.each do |method|
      base.module_eval do
        module_function(method)
        public(method)
      end
    end
  end
end

RSpec.describe CreateModuleFunctions do
  context "when included into a Module" do
    it "makes the Module's methods invokable via the Module" do
      module ModuleIncluded
        def instance_method_1;end
        def instance_method_2;end

        include CreateModuleFunctions
      end

      expect { ModuleIncluded.instance_method_1 }.to_not raise_error
    end
  end
end

您需要应用的不幸技巧是在定义方法之后包含模块。或者，您也可以在上下文定义为 之后包含它ModuleIncluded.send(:include, CreateModuleFunctions)。

或者，您可以通过反射工具 gem 使用它。

spec.add_dependency "reflection_utils", ">= 0.3.0"

require 'reflection_utils'
include ReflectionUtils::CreateModuleFunctions
于 2017-11-13T23:27:40.967 回答