当猴子修补实例方法时，您可以从新实现中调用重写的方法吗？

Question

假设我正在修补类中的方法，我如何从重写方法中调用重写方法？即有点像 super

例如

class Foo
  def bar()
    "Hello"
  end
end 

class Foo
  def bar()
    super() + " World"
  end
end

>> Foo.new.bar == "Hello World"

Answer 1

编辑：自从我最初写这个答案以来已经过去了 9 年，它值得进行一些整容手术以使其保持最新状态。

您可以在此处查看编辑前的最新版本。

---

您不能通过名称或关键字覆盖方法来调用。这是应避免猴子修补并首选继承的众多原因之一，因为显然您可以调用重写方法。

避免 Monkey 修补

继承

因此，如果可能的话，您应该更喜欢这样的东西：

class Foo
  def bar
    'Hello'
  end
end 

class ExtendedFoo < Foo
  def bar
    super + ' World'
  end
end

ExtendedFoo.new.bar # => 'Hello World'

如果您控制 Foo 对象的创建，那么这种方法就有效。只需更改创建 Foo 的每个位置即可创建 ExtendedFoo。如果您使用依赖注入设计模式，即工厂方法设计模式， 抽象工厂设计模式 或类似的东西，因为在这种情况下，只有一个地方需要更改。

委托

如果您不控制Foo对象的创建，例如因为它们是由您无法控制的框架创建的（例如ruby-on-rails 例如），然后您可以使用包装设计模式：

require 'delegate'

class Foo
  def bar
    'Hello'
  end
end 

class WrappedFoo < DelegateClass(Foo)
  def initialize(wrapped_foo)
    super
  end

  def bar
    super + ' World'
  end
end

foo = Foo.new # this is not actually in your code, it comes from somewhere else

wrapped_foo = WrappedFoo.new(foo) # this is under your control

wrapped_foo.bar # => 'Hello World'

基本上，在系统的边界，Foo 对象进入您的代码，您将其包装到另一个对象中，然后在代码中的其他地方使用该对象而不是原始对象。

这使用 Object#DelegateClass来自 delegate stdlib 中的库。

“干净”的猴子补丁

Module#prepend: Mixin Prepending

上述两种方法都需要更改系统以避免猴子修补。本节展示了猴子修补的首选且侵入性最小的方法，如果无法更改系统的话。

Module#prepend 已添加到或多或少地支持这个用例。 Module#prepend 与 Module#include 做同样的事情，除了它直接在类下面的 mixin 中混合：

class Foo
  def bar
    'Hello'
  end
end 

module FooExtensions
  def bar
    super + ' World'
  end
end

class Foo
  prepend FooExtensions
end

Foo.new.bar # => 'Hello World'

注意：我还写了一个关于此问题中的 Module#prepend 的一些信息：Ruby 模块前置与派生

Mixin 继承（破碎）

我看到有些人尝试（并询问为什么它在 StackOverflow 上不起作用）这样的事情，即 include 混合而不是 prepend ing it：

class Foo
  def bar
    'Hello'
  end
end 

module FooExtensions
  def bar
    super + ' World'
  end
end

class Foo
  include FooExtensions
end

不幸的是，这行不通。这是一个好主意，因为它使用继承，这意味着您可以使用 super。但是， Module#include 插入继承层次结构中类之上的 mixin，这意味着 FooExtensions#bar 永远不会被调用（如果被调用，< code>super 实际上不会引用 Foo#bar，而是引用不存在的 Object#bar），因为 Foo#bar< /code> 总是会首先被找到。

方法包装

最大的问题是：我们如何才能保留 bar 方法，而不实际保留实际方法？正如经常出现的那样，答案就在于函数式编程。我们将该方法作为实际的对象进行保存，并使用闭包（即块）来确保我们并且只有我们保存该对象：

class Foo
  def bar
    'Hello'
  end
end 

class Foo
  old_bar = instance_method(:bar)

  define_method(:bar) do
    old_bar.bind(self).() + ' World'
  end
end

Foo.new.bar # => 'Hello World'

这非常干净：由于 old_bar 只是一个局部变量，它会在类主体末尾超出范围，并且不可能从任何地方访问它，甚至 使用反射！由于 Module#define_method 需要一个块，并且块靠近其周围的词法环境（这就是为什么我们在这里使用 define_method 而不是 def），it （并且仅它）仍然可以访问old_bar，即使它超出了范围。

简短说明：

old_bar = instance_method(:bar)

这里我们将 bar 方法包装到 UnboundMethod 中 方法对象并将其分配给局部变量old_bar。这意味着，即使在 bar 被覆盖之后，我们现在也有办法保留它。

old_bar.bind(self)

这有点棘手。基本上，在 Ruby（以及几乎所有基于单分派的 OO 语言）中，方法绑定到特定的接收者对象，在 Ruby 中称为 self。换句话说：方法总是知道它被调用的对象是什么，它知道它的 self 是什么。但是，我们直接从类中获取方法，它如何知道它的 self 是什么？

嗯，事实并非如此，这就是为什么我们需要 bind 我们的 UnboundMethod 首先到一个对象，它将返回一个 Method 我们可以调用的对象。 （UnboundMethod 无法被调用，因为它们在不知道自己的自身的情况下不知道要做什么。）

我们将它绑定到什么地方？我们只需将它绑定到我们自己，这样它的行为就会完全像原来的bar一样！

最后，我们需要调用从 bind 返回的 Method。在 Ruby 1.9 中，有一些漂亮的新语法 (.())，但如果您使用的是 1.8，则可以简单地使用 调用方法；无论如何，这就是 .() 被翻译成的内容。

以下是其他几个问题，其中解释了其中一些概念：

• 如何在 Ruby 中引用函数？
• Ruby 的代码块与 C♯ 的 lambda 表达式相同吗？

“肮脏的”猴子修补

alias_method 链

我们在猴子修补中遇到的问题就是当我们覆盖方法的时候，方法就没有了，所以我们就不能再调用它了。所以，让我们制作一个备份副本！

class Foo
  def bar
    'Hello'
  end
end 

class Foo
  alias_method :old_bar, :bar

  def bar
    old_bar + ' World'
  end
end

Foo.new.bar # => 'Hello World'
Foo.new.old_bar # => 'Hello'

问题是我们现在用多余的 old_bar 方法污染了命名空间。此方法将显示在我们的文档中，它将显示在我们的 IDE 中的代码完成中，它将显示在反射期间。另外，它仍然可以被调用，但想必我们猴子修补了它，因为我们一开始就不喜欢它的行为，所以我们可能不希望其他人调用它。

尽管事实上它有一些不良特性，但不幸的是它已经通过 AciveSupport 的 变得流行起来Module#alias_method_chain。

旁白：细化

如果您只需要少数情况下的不同行为特定的地方而不是遍及整个系统，您可以使用Refinements将猴子补丁限制在特定的范围内。我将在这里使用上面的 Module#prepend 示例进行演示：

class Foo
  def bar
    'Hello'
  end
end 

module ExtendedFoo
  module FooExtensions
    def bar
      super + ' World'
    end
  end

  refine Foo do
    prepend FooExtensions
  end
end

Foo.new.bar # => 'Hello'
# We haven’t activated our Refinement yet!

using ExtendedFoo
# Activate our Refinement

Foo.new.bar # => 'Hello World'
# There it is!

您可以在这个问题中看到使用 Refinements 的更复杂的示例：如何为特定方法启用猴子补丁？

---

废弃的想法

在 Ruby 社区确定 Module#prepend 之前，有多种不同的想法可供您选择有时可能会在较早的讨论中看到引用。所有这些都包含在 Module#prepend 中。

方法组合器

一种想法是来自 CLOS 的方法组合器的想法。这基本上是面向方面编程子集的一个非常轻量级的版本。

使用像您这样的语法

class Foo
  def bar:before
    # will always run before bar, when bar is called
  end

  def bar:after
    # will always run after bar, when bar is called
    # may or may not be able to access and/or change bar’s return value
  end
end

就可以“挂钩” bar 方法的执行。

然而，尚不清楚是否以及如何在 bar:after 中访问 bar 的返回值。也许我们可以（ab）使用 super 关键字？

class Foo
  def bar
    'Hello'
  end
end 

class Foo
  def bar:after
    super + ' World'
  end
end

替换

before 组合器相当于在 mixin 前面添加一个重写方法，该方法在方法的最末尾调用 super。同样，后组合器相当于在 mixin 前面添加一个重写方法，该方法在方法的最开始处调用 super。

您还可以在调用 super 之前和执行一些操作，您可以多次调用 super，并且检索和操作 super code> 的返回值，使得 prepend 比方法组合器更强大。

class Foo
  def bar:before
    # will always run before bar, when bar is called
  end
end

# is the same as

module BarBefore
  def bar
    # will always run before bar, when bar is called
    super
  end
end

class Foo
  prepend BarBefore
end

和

class Foo
  def bar:after
    # will always run after bar, when bar is called
    # may or may not be able to access and/or change bar’s return value
  end
end

# is the same as

class BarAfter
  def bar
    original_return_value = super
    # will always run after bar, when bar is called
    # has access to and can change bar’s return value
  end
end

class Foo
  prepend BarAfter
end

old 关键字

这个想法添加了一个类似于 super 的新关键字，它允许您以 super<相同的方式调用覆盖方法/code> 允许您调用重写方法：

class Foo
  def bar
    'Hello'
  end
end 

class Foo
  def bar
    old + ' World'
  end
end

Foo.new.bar # => 'Hello World'

主要问题是它向后不兼容：如果您有名为old的方法，您将无法再呼唤它！

在prepended mixin 中的重写方法中替换

super 本质上与本提案中的old 相同。

redef 关键字

与上面类似，但我们没有为调用覆盖的方法添加新关键字并单独保留def，而是为重新定义方法。这是向后兼容的，因为无论如何目前的语法都是非法的：

class Foo
  def bar
    'Hello'
  end
end 

class Foo
  redef bar
    old + ' World'
  end
end

Foo.new.bar # => 'Hello World'

我们也可以在 redefsuper 的含义，而不是添加两个新关键字>：

class Foo
  def bar
    'Hello'
  end
end 

class Foo
  redef bar
    super + ' World'
  end
end

Foo.new.bar # => 'Hello World'

替换

redef方法相当于覆盖前置混合中的方法。重写方法中的 super 的行为类似于本提案中的 super 或 old。

Answer 2

看一下别名方法，这是一种将方法重命名为新名称的方法。

有关更多信息和起点，请查看这篇替换方法文章（尤其是第一部分）。
Ruby API 文档 还提供了（不太详细的）示例。

Answer 3

将进行覆盖的类必须在包含原始方法的类之后重新加载，因此在将进行覆盖的文件中require它。