Ruby中的懒惰评估

第一个是让调用者处理懒惰对象的创建.这是最简单的解决方案,它是Ruby代码中非常常见的模式.

class ExpensiveObject
  def initialize
    # Expensive stuff here.
  end
end

class Caller
  def some_method
    my_object.do_something
  end

  def my_object
    # Expensive object is created when my_object is called. Subsequent calls
    # will return the same object.
    @my_object ||= ExpensiveObject.new
  end
end

第二个选择是让对象简单地进行初始化.我们在实际对象周围创建一个委托对象来实现这一点.这种方法有点棘手,不推荐,除非你有现有的调用代码,你不能修改,例如.

class ExpensiveObject        # Delegate
  class RealExpensiveObject  # Actual object
    def initialize
      # Expensive stuff here.
    end

    # More methods...
  end

  def initialize(*args)
    @init_args = args
  end

  def method_missing(method,*args)
    # Delegate to expensive object. __object method will create the expensive
    # object if necessary.
    __object__.send(method,*args)
  end

  def __object__
    @object ||= RealExpensiveObject.new(*@init_args)
  end
end

# This will only create the wrapper object (cheap).
obj = ExpensiveObject.new

# Only when the first message is sent will the internal object be initialised.
obj.do_something

您也可以使用stdlib delegate来构建它.