Question

有时您需要将一组值“映射”到另一组值，因此当您从第一组中获取值时，您将返回另一组的相应值。这就像数学函数的概念：x -> f(x)。

所以，我发现它可以用两种方法实现：你可以将“转换规则”定义为哈希：

rule = {
  'A' => 'Excelent',
  'B' => 'Great',
  'C' => 'Good'
}

并将其应用于给定的输入，如下所示：

a = rule[input_1]
b = rule[input_2]

或者您可以使用由函数包装的案例块：

def rule(input)
  case input
    when 'A'; 'Excelent'
    when 'B'; 'Great'
    when 'C'; 'Good'
  end
end

然后应用这样的规则：

a = rule(input_1)
b = rule(input_2)

所以，我想知道每一个的利弊，如果有一个“更标准”的解决方案，我认为，这是一个非常普遍的问题。（这2只是“感觉”不理想）。

Answer 1

我不会尝试在任何细节上比较这些方法，但就我而言，Hash被设计为一个显式映射，就像一个离散函数，所以这就是我所在的地方d总是从。

开始

案例陈述在其更灵活的形式中确实有很多很好的用途，但它们对我来说永远不会是正确的工具

Answer 2

我♥哈希。我甚至在我的一个blog post中提到了这个确切的用例。

如果您的哈希构造一次（比如模块中的常量），则查找将比等效的case更快。我觉得哈希使得第一眼看到你将值映射到另一个时更清楚，而case必须完全检查以确保没有其他事情发生。

更重要的是，不要忘记Hash#default_proc，它可以让您处理更复杂的案件。 E.g：

rule = {
  'A' => 'Excellent',
  'B' => 'Great',
  'C' => 'Good'
}
rule.default_proc = ->(h, k){
  new_k = k.to_s.strip.upcase
  h[new_k] unless k == new_k
}

rule['B']   # => 'Great'
rule[:a]    # => 'Excellent'
rule['      c       '] # => 'Good'
rule['foo'] # => nil

第一次查找将立即执行，不会执行default_proc，而其他两次执行后会成功。

注意：我假设Ruby 1.9，必须使用Hash.new使用块+ merge或require "backports"在Ruby 1.8中进行调整并使用{ {1}}代替lambda

Answer 3

你应该考虑Proc或lambda。：）

rule = Proc.new{|x| # implement rule logic here }

现在您可以像变量一样传递规则对象。当你需要通过

调用它时

a = rule.call(input1)
b = rule.call(input2)

如果查找规则是简单的查找哈希，请坚持上面的版本1。如果您的“规则”很复杂，并且需要更复杂的编程，请考虑深入研究Ruby的Proc / lambda功能。

Answer 4

由于可维护性和效率，我坚持使用Hash解决方案。使用Hash，您有O（1）时间来访问给定键的值，而在第二个示例中，Ruby解释器必须进行===比较，这在效率方面并不理想。

基准：

#hash_test.rb
rule = {
  'A' => 'Excelent',
  'B' => 'Great',
  'C' => 'Good'
}

1_000_000.times{
  rule['A']
  rule['B']
  rule['C']
}


time ruby hash_test.rb 
real    0m0.880s
user    0m0.869s
sys  0m0.007s




 #case_test.rb
 def rule(input)
  case input
    when 'A'; 'Excelent'
    when 'B'; 'Great'
    when 'C'; 'Good'
  end
end


1_000_000.times{
rule('A')
rule('B')
rule('C')
}


time ruby case_test.rb 

real    0m1.486s
user    0m1.474s
sys 0m0.008s

Answer 5

当您使用case方法时，ruby必须从上到下评估每个案例并比较“字符串”值。使用Hash，ruby将比较字符串的'哈希'（整数！），这要快得多。但是，实际实现可能会因平台和ruby环境而异。我的直觉是散列永远不会慢于大小写，但大小写几乎总是比散列慢。

在ruby中定义转换规则的最佳方法是什么？

5 个答案: