当前位置：文江博客话题详情

为什么是“超级”？ Ruby 中的关键字而不是方法？

发布于 2024-12-20 15:21:15 字数 657 浏览 2 评论 0原文

在 Ruby 中， super 是一个关键字而不是方法。

为什么要这样设计呢？

Ruby 的设计倾向于实现尽可能多的方法；关键字通常是为有自己的语法规则的语言特征保留的。然而，super 的外观和行为都类似于方法调用。

（我知道在纯 Ruby 中实现 super 会很麻烦，因为它必须从 caller 或使用trace_func。仅此一点并不能阻止它成为一种方法，因为大量 Kernel 的方法未在纯 Ruby 中实现。）

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

黄昏下泛黄的笔记 2024-12-27 15:21:15

它的行为有点不同，因为如果您不传递参数，则所有当前参数（和块，如果存在）都会传递......我不确定这作为一种方法如何工作。

举一个相当人为的例子：

class A
  def example(a, b, c)
    yield whatever(a, b) + c
  end
end

class B < A
  def example(a, b, c)
    super * 2
  end
end

我不需要处理产量，或将参数传递给 super。在您特别想要传递不同参数的情况下，它的行为更像是方法调用。如果您不想传递任何参数，则必须传递空括号 (super())。

它根本没有与方法调用完全相同的行为。

It behaves a little differently, in that if you don't pass arguments, all of the current arguments (and block, if present) are passed along... I'm not sure how that would work as a method.

To give a rather contrived example:

class A
  def example(a, b, c)
    yield whatever(a, b) + c
  end
end

class B < A
  def example(a, b, c)
    super * 2
  end
end

I did not need to handle the yield, or pass the arguments to super. In the cases where you specifically want to pass different arguments, then it behaves more like a method call. If you want to pass no arguments at all, you must pass empty parentheses (super()).

It simply doesn't have quite the same behaviour as a method call.

回复收藏 0 原文

与酒说心事 2024-12-27 15:21:15

super 不会自动调用父类的方法。如果您将 ruby 类的继承层次想象为一个列表，类位于底部，Object 位于顶部，那么当 ruby 看到 super 关键字时，而不是只需检查父类，它就会向上移动整个列表，直到找到第一个具有用该名称定义的方法的项目。

我很小心地说“item”，因为它也可能是一个模块。当你将一个模块包含到一个类中时，它会被包装在一个匿名超类中，并放在我之前讨论过的列表中你的类之上，这意味着如果你为你的类定义了一个方法，该方法也在模块中定义，然后从类的实现中调用 super 将调用模块的实现，而不是父类的实现：

class Foo
  def f
    puts "Foo"
  end
end

module Bar
  def f
    puts "Bar"
    super
  end
end

class Foobar < Foo
  include Bar

  def f
    puts "Foobar"
    super
  end
end

foobar = Foobar.new
foobar.f
  # =>
  # Foobar
  # Bar
  # Foo

而且我不认为可以从 ruby 环境本身访问此“继承列表”，这意味着此功能不会可用（但有用是的；我不太确定这是否是一个预期的功能。）

super doesn't automatically call the parent class's method. If you imagine the inheritance hierarchy of a ruby class as a list, with the class at the bottom and Object at the top, when ruby sees the the super keyword, rather than just check the the parent class, it moves up the entire list until it finds the first item that has a method defined with that name.

I'm careful to say item because it could also be a module. When you include a module in to a class, it is wrapped in an anonymous superclass and put above your class in the list I talked about before, so that means if you had a method defined for your class that was also defined in the module, then calling super from the class's implementation would call the module's implementation, and not the parent class's:

class Foo
  def f
    puts "Foo"
  end
end

module Bar
  def f
    puts "Bar"
    super
  end
end

class Foobar < Foo
  include Bar

  def f
    puts "Foobar"
    super
  end
end

foobar = Foobar.new
foobar.f
  # =>
  # Foobar
  # Bar
  # Foo

And I don't believe that it is possible to access this 'inheritance list' from the ruby environment itself, which would mean this functionality would not be available (However useful it is; I'm not every sure if this was an intended feature.)

回复收藏 0 原文