在Ruby中，如何将属性标记为肮脏？

如何解决在Ruby中，如何将属性标记为肮脏？

| 说我有以下课程：

class Cashier

  def purchase(amount)
    (@purchases ||= []) << amount
  end


  def total_cash
    (@purchases || []).inject(0) {|sum,amount| sum + amount}
  end

end

这仅出于学习目的，请忽略这可能是不现实的。 现在，通常来说，total_cash可能是遍历所有项目的昂贵调用。 我想知道如何仅在@purchases变量变脏时调用.inject，即进行了一些修改。 我的班级将如何修改以做到这一点？     

解决方法

最简单的方法是维护另一个变量以指示

@purchases

是否脏。例如：

class Cashier

  def initialize(*args)
    # init @purchases and @total_cash
    @is_purchases_dirty = false
  end

  def purchase(amount)
    (@purchases ||= []) << amount
    @is_purchases_dirty = true
  end


  def total_cash
    return @total_cash unless @is_purchases_dirty
    @is_purchases_dirty = false
    @total_cash = (@purchases || []).inject(0) {|sum,amount| sum + amount}
    return @total_cash
  end

end

一种更简洁的方法是，每次调用“ 4”的设置员时，就计算“ 3”。但是，这意味着即使在班级内，也需要始终使用setter。这也意味着您将“隐藏” setter方法内部的昂贵操作。您可以决定自己更喜欢哪一种。

class Cashier

  def purchase(amount)
    (@purchases ||= []) << amount
    @total_cash = (@purchases || []).inject(0) {|sum,amount| sum + amount}
  end


  def total_cash
    @total_cash
  end

end

我也建议您反对使用昂贵的命名方案。我将ѭ6改名为ѭ7，以告知您的API用户这是一个相对昂贵的调用，而不是简单的getter / setter。     ,如果需要，您可以比其他答案更进一步。您可以编写更改代码的代码，而不必将代码更改为仅在必要时重新计算。每个人都喜欢一些元编程。 这是一些代码，这些代码带有执行潜在长计算的方法的名称，以及方法名称的列表，这些方法的名称在调用时会使先前的任何计算无效，并编写代码以包装这些方法并仅在必要时执行计算，如果没有，则返回存储的值。

module ExpensiveCalculation

  def recalc_only_if_necessary(meth,*mutators)

    aliased_method_name = \"__#{meth.object_id}__\"
    value = \"@__#{meth.object_id}_value__\"
    dirty_flag = \"@__#{meth.object_id}_dirty__\"

    module_eval <<-EOE
      alias_method :#{aliased_method_name},:#{meth}
      private :#{aliased_method_name}

      def #{meth}(*args,&blk)
        #{dirty_flag} = true unless defined? #{dirty_flag}
        return #{value} unless #{dirty_flag}
        #{value} = #{aliased_method_name}(*args,&blk)
        #{dirty_flag} = false
        #{value}
      end        
    EOE

    mutators.each do |mutator|
      aliased_mutator = \"__#{meth.object_id}_#{mutator.object_id}__\"

      module_eval <<-EOE
        alias_method :#{aliased_mutator},:#{mutator}
        private :#{aliased_mutator}

        def #{mutator}(*args,&blk)
          #{dirty_flag} = true
          #{aliased_mutator}(*args,&blk)
        end
      EOE
    end
  end

  # this hook is used to make the new method
  # private to the extended class.
  def self.extend_object(obj)
    super
    obj.private_class_method :recalc_only_if_necessary
  end

end

通过在类定义中提供此方法，您可以轻松包装一个或多个方法，而无需更改现有代码：

class Cashier
  extend ExpensiveCalculation

  def purchase(amount)
    (@purchases ||= []) << amount
  end

  def total_cash
    (@purchases || []).inject(0) {|sum,amount| sum + amount}
  end

  recalc_only_if_necessary :total_cash,:purchase
end

如果您只想更改一种方法，那么做这样的事情可能没有任何意义，但是如果您想更改几种方法，则可以使用类似这样的技术可能会非常有用。     ,在最简单的情况下，您可以为要标记为脏的东西定义一个实例变量。修改变量后（在您的

purchase

方法中）将其设置为

true

。 检查ѭ6中的值；如果是这样，请使用总计的缓存版本。否则，请计算新值并将其存储在缓存中。

class Cashier

  def purchase(amount)
    @purchases_dirty = true
    (@purchases ||= []) << amount
  end


  def total_cash
    @total_cash = (@purchases || []).inject(0) do |sum,amount|
      sum + amount
    end if (@purchases_dirty || @total_cash.nil?)
    @purchases_dirty = false
    @total_cash
  end

end