首先，我知道 extend 和 include 是如何工作的，以及它们通常用于什么等等。这是否是个好主意不在我的问题。

我的问题是:extend 有多贵？扩展实例和单例对象是一种常见的 Javascript 技术。可以在 Ruby 中做类似的事情，但是如果在很多对象上使用它会很慢吗？

最佳答案

让我们看看在 Ruby 1.9.3-p0 中如果你在一个对象上调用 extend 会发生什么:

/* eval.c, line 879 */
void
rb_extend_object(VALUE obj, VALUE module)
{
    rb_include_module(rb_singleton_class(obj), module);
}

于是模块就混入了对象的单例类中。获取单例类的成本是多少？那么，rb_singleton_class_of(obj) 依次调用 singleton_class_of(obj) (class.c:1253)。如果之前访问过单例类(因此已经存在)，则该类会立即返回。如果不是，则由 make_singleton_class 创建一个新类，这也不太昂贵:

/* class.c, line 341 */
static inline VALUE
make_singleton_class(VALUE obj)
{
    VALUE orig_class = RBASIC(obj)->klass;
    VALUE klass = rb_class_boot(orig_class);

    FL_SET(klass, FL_SINGLETON);
    RBASIC(obj)->klass = klass;
    rb_singleton_class_attached(klass, obj);

    METACLASS_OF(klass) = METACLASS_OF(rb_class_real(orig_class));
    return klass;
}

这都是O(1)。 之后调用rb_include_module(class.c:660)，单例已经包含的模块数O(n)类，因为它需要检查模块是否已经存在(单例类中通常包含的模块不多，所以这没问题)。

结论 extend 不是一个非常昂贵的操作，因此如果您愿意，可以经常使用它。我唯一能想到的是，在 extend 之后 对实例的方法调用的解析可能会更复杂一些，因为需要检查额外的一层模块.如果您知道单例类已经存在，则两者都不是问题。在这种情况下，extend 几乎不会引入额外的复杂性。 但是，如果应用过于广泛，动态扩展实例可能会导致代码非常不可读，所以要小心。

这个小基准演示了有关性能的情况:

require 'benchmark'

module DynamicMixin
  def debug_me
    puts "Hi, I'm %s" % name
  end
end

Person = Struct.new(:name)

def create_people
  100000.times.map { |i| Person.new(i.to_s) }
end

if $0 == __FILE__
  debug_me = Proc.new { puts "Hi, I'm %s" % name }

  Benchmark.bm do |x|
    people = create_people
    case ARGV[0]
    when "extend1"
      x.report "Object#extend" do
        people.each { |person|
          person.extend DynamicMixin
        }
      end
    when "extend2"
      # force creation of singleton class
      people.map { |x| class << x; self; end }
      x.report "Object#extend (existing singleton class)" do
        people.each { |person|
          person.extend DynamicMixin
        }
      end
    when "include"
      x.report "Module#include" do
        people.each { |person|
          class << person
            include DynamicMixin
          end
        }
      end
    when "method"
      x.report "Object#define_singleton_method" do
        people.each { |person|
          person.define_singleton_method("debug_me", &debug_me)
        }
      end
    when "object1"
      x.report "create object without extending" do
        100000.times { |i|
          person = Person.new(i.to_s)
        }
      end
    when "object2"
      x.report "create object with extending" do
        100000.times { |i|
          person = Person.new(i.to_s)
          person.extend DynamicMixin
        }
      end
    when "object3"
      class TmpPerson < Person
        include DynamicMixin
      end

      x.report "create object with temp class" do
        100000.times { |i|
          person = TmpPerson.new(i.to_s)
        }
      end
    end
  end
end

结果

           user     system      total        real
Object#extend                             0.200000   0.060000   0.260000 (  0.272779)
Object#extend (existing singleton class)  0.130000   0.000000   0.130000 (  0.130711)
Module#include                            0.280000   0.040000   0.320000 (  0.332719)
Object#define_singleton_method            0.350000   0.040000   0.390000 (  0.396296)
create object without extending           0.060000   0.010000   0.070000 (  0.071103)
create object with extending              0.340000   0.000000   0.340000 (  0.341622)
create object with temp class             0.080000   0.000000   0.080000 (  0.076526)

有趣的是，元类上的 Module#include 实际上比 Object#extend 慢，尽管它做了完全相同的事情(因为我们需要特殊的 Ruby 语法来访问元类)。如果单例类已经存在，Object#extend 的速度是原来的两倍多。 Object#define_singleton_method 是最慢的(尽管如果您只想动态添加一个方法，它会更干净)。

然而，最有趣的结果是倒数第二个:创建对象然后扩展它比只创建对象慢近 4 倍!因此，例如，如果您在循环中创建大量一次性对象，那么如果您扩展其中的每一个对象，则可能会对性能产生重大影响。在这里创建一个包含 mixin 的临时类会更有效。

关于ruby - ruby 中的 'extend' 有多贵？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8616275/