Question

使用基于Ruby的应用程序，该应用程序需要在以后创建，存储和评估自定义公式。例如，我可能有：

10 * (2 + number_of_pies_eaten)

其中number_of_pies_eaten当前未知，并且在评估时将被替换为公式。

除了编写自己的插值解释器之外，还有最佳实践方法可以做这种事吗？

Answer 1

当我想创建一个类来解决函数的Riemann sum时，我遇到了类似的问题。

在那种情况下，我使用了Procs：

f = ->(x) { -10*(x**2) + 3*x + 6 }

我会说这取决于你的实施。你实际上可以：

定义包含一些公式的class ，在构造函数中传递number_of_pies_eaten并执行某些操作

class PieEater

  def initialize(number_of_pies_eaten)
    @eaten_pies = number_of_pies_eaten
  end

  def something
    @something = 10 * (2 + @eaten_pies)
  end

  def something_else
    @something_else = 5 * (3 + @eaten_pies)
  end
end

用法：

pe = PieEater.new(15)
pe.do_something
pe.do_something_else

定义一个module ，其中包含要包含在另一个类中的一些公式。

module PieEater

  def something(x)
    10 * (2 + x)
  end

  def something_else(x)
    5 * (3 + x)
  end

end

用法：

require 'pie_eater'

class Person
  include PieEater
end

p = Person.new
p.something(15)

创建包含一些公式的module或class ，以便立即使用。

module PieEater
  extend self

  def something(x)
    10 * (2 + x)
  end

  def something_else(x)
    5 * (3 + x)
  end

end

或

class PieEater

  class << self
    def something(x)
      10 * (2 + x)
    end

    def something_else(x)
      5 * (3 + x)
    end
  end
end

用法：

PieEater.something(15)

如果您正在编写某种脚本，我会使用 Proc对象：

$ irb
2.4.0 :001 > eaten_pies = ->(n) { 10 * (2 + n) }
 => #<Proc:0x00000001ff5c70@(irb):1 (lambda)> 
2.4.0 :002 >   eaten_pies.call(2)
 => 40 
# You could even use these procs as hash values
2.4.0 :003 > formulas = { a: eaten_pies, b: ->(x){ x**2 } }
 => {:a=>#<Proc:0x00000001ff5c70@(irb):1 (lambda)>, :b=>#<Proc:0x00000002015070@(irb):4 (lambda)>} 
2.4.0 :004 > formulas[:a].call(15)
 => 170 
2.4.0 :005 > formulas[:b].call(15)
 => 225

这可以写成：

formulas = {
  eaten_pies: ->(x) { 10 * (2 + n) },
  eaten_apples: ->(y) { y ** 2 }
}

formulas[:eaten_pies].call(15)

所有这些可能性都是Ruby中的标准，它取决于您的用例和编码风格

存储具有特定值的公式的最佳方法，以便稍后进行评估

1 个答案: