Ruby中的后期和早期绑定

Question

有人能给出一个late和early binding在Ruby中出现的例子吗？红宝石一般是晚结还是早结？当在Ruby中的对象上调用函数时，会发生什么？它是否已经知道运行时的方法将驻留在内存中？幕后发生了什么？

在像C#这样的语言中，除非使用Reflection API，否则它总是早期绑定。在Java中，后期绑定通常会发生。

更新

这个案子呢？是晚绑定还是早绑定？

def create_something(klass, *args)
 klass.new(*args)
end
my_foo = create_something(Foo)

Answer 1

有人能给出一个清晰的例子，说明Ruby中出现延迟和早期绑定的情况吗？红宝石一般是晚结还是早结？

如果我们像在这样的讨论中那样引用这些术语，我宁愿说Ruby倾向于绑定“延迟”。因为Ruby是一种动态语言，代码是在运行时计算的，所以没有编译器来执行这项工作。即使有错误，在执行代码之前也不会引发异常。

它是否已经知道在运行时函数将驻留在内存中的位置？

您可能已经知道，Ruby中的一切都是对象，甚至是类和模块。对象本身是一组实例变量，是指向类(即另一个对象)的链接。这样，我们就有了一个链，一直到BasicObject，它是Ruby的根对象，并且没有任何祖先。

通常，对象的方法驻留在对象的类中。但是，在继承的情况下，事情会变得更加复杂，在继承中，可以对对象本身调用父类的某些方法。

class A
  def a_method
    p "called from a_method"
  end
end

class B < A
  def b_method
    p "called from b_method"
  end
end

obj = B.new
obj.b_method    # => called from b_method
obj.a_method    # => called from a_method

因此，这个问题的答案是no，但是每次对特定对象进行方法调用时，都会执行所谓的方法查找。

当在Ruby中的对象上调用函数时，会发生什么？幕后发生了什么？

方法查找是一个过程，在这个过程中，Ruby直接进入接收方的类，然后上升到祖先链，直到它找到方法或到达链的末尾。为了说明这一点：

                             BasicObject
                                  ^
                                  |

                                 ...

                                  ^
                                  |
                              ----------
                              |   A    |
                              ----------
                              |a_method|
                              ----------
                                  ^
                                  |
                              ----------
                              |   B    |
               obj ------->   ----------
                              |b_method|
                              ----------

希望我帮了你:)

Answer 2

有人能给出一个清晰的例子，说明Ruby中出现延迟和早期绑定的情况吗？

• 迟装订:永远
• 早期装订:从不

红宝石一般是晚结还是早结？

总是很晚才结。

当在Ruby中的对象上调用函数时，会发生什么？它是否已经知道在运行时函数将驻留在内存中的位置？幕后发生了什么？

Ruby中没有函数。

这个案子呢？是晚绑定还是早绑定？

一切都是迟来的。

虽然它没有自言自语或新语中的绑定得那么晚，但是与Java或C♯相比，它肯定是后期绑定。