2

我希望将单例方法添加到特定对象。我希望当第一次调用对象上的实例方法时，它会做一些工作，然后为所述同名对象（包含工作）创建一个单例方法。在对所述对象的所有后续调用中，单例方法将隐藏实例方法并被调用。

我知道如何创建单例方法，我的问题是我希望创建单例方法来调用 lambda（l在本例中）。def 不创建闭包，因此在随后调用该方法时我无法引用变量 l （下面的代码）（l.call()在此示例中已注释掉）我想知道在特定对象上创建单例方法时如何创建闭包. 任何帮助，将不胜感激。谢谢你。

class Thing
end

t = Thing.new
t2 = Thing.new

Thing.instance_eval() do
  def speak
    puts "I speak for all Things, I am a class method"
  end
end

Thing.class_eval() do
  def speak
    puts "This is the instance method referenced by the Thing object #{self}"
    r = "something I wish to hold on to, maybe expensive to calculate"
    l = lambda {puts r}
    instance_eval() do
      def speak()
        puts "This is the singleton method in the Thing object #{self}"
        #l.call() # I want this to work! How?
      end
    end
  end
end

Thing.speak()
t.speak()
t2.speak()
t.speak()
t2.speak()

运行时给出以下结果：（我将 '<' 更改为 '#' 所以它们显示在 html 中）

我为万物说话，我是一个类方法

这是 Thing 对象引用的实例方法#Thing:0x1d204>

这是 Thing 对象引用的实例方法#Thing:0x1d1dc>

这是 Thing 对象中的单例方法 #Thing:0x1d204>

这是 Thing 对象中的单例方法 #Thing:0x1d1dc>

4

3 回答 3

2

您可以使用define_method.

例子：

class Object
  def eigenclass
    class <<self; self end
  end
end

a = "Hello"
other_word = "World"
a.eigenclass.class_eval do
  define_method(:cliche) {"#{self} #{other_word}"}
end
a.cliche # => "Hello World"
"Goodbye".cliche # => NoMethodError: undefined method `cliche' for "Goodbye":String

这是一个define_singleton_method方法的实现：

class Object
  def define_singleton_method(name, &block)
    eigenclass = class<<self; self end
    eigenclass.class_eval {define_method name, block}
  end
end
于 2009-07-17T01:05:41.670 回答
2

现在 1.9 已经发布，您可以使用 define_singleton_method：

jruby --1.9 -S irb
irb(main):019:0> fn = -> { length * 10 }
=> #<Proc:0x77cb8e0f@(irb):19 (lambda)>
irb(main):020:0> s.define_singleton_method :length_times_ten, fn
=> #<Proc:0x77cb8e0f@(irb):19 (lambda)>
irb(main):021:0> s
=> "a string"
irb(main):022:0> s.length_times_ten
=> 80
于 2011-03-18T23:18:42.807 回答
1

好吧，一种方法是将其打包到一个实例变量中：

（仅供参考，您可以class Thing重新打开Thing（它比 using 短一点#class_eval，并且您不需要#instance_eval从方法中定义方法）。

class Thing
  def speak
    puts "This is the instance method referenced by the Thing object #{self}"
    r = "something I wish to hold on to, maybe expensive to calculate"
    @l = lambda {puts r}
    instance_eval do 
      def speak()
        puts "This is the singleton method in the Thing object #{self}"
        @l[]
      end
    end
  end
end

这将重新定义#speak，但仅限于Thing. 的其他实例Thing仍将具有原始定义。

正如 Chuck 所指出的，另一种方法是使用与实例关联的单例类（又名元类，又名特征类）。单例类是存储与对象关联的所有单例方法的对象。您可以使用有趣的语法获取单例类评估的class <<object ; ... ; end上下文（类似于#class_eval普通类给出的上下文）。

class Thing
  def speak
    puts "This is the instance method referenced by the Thing object #{self}"
    r = "something I wish to hold on to, maybe expensive to calculate"
    singleton_class = class <<self # open singleton class context for current instance
      # in this context, self now refers to the singleton class itself
      self
    end
    l = lambda {puts r}
    singleton_class.class_eval do
      # since we used #class_eval, local variables are still in scope
      define_method(:speak) do 
        puts "This is the singleton method in the Thing object #{self}"
        # since we used #define_method, local variables are still in scope
        l[]
      end
    end
  end
end
于 2009-07-17T21:47:45.780 回答