在 Rails 代码中，人们倾向于使用 Enumerable#inject 方法来创建哈希，如下所示:

somme_enum.inject({}) do |hash, element|
  hash[element.foo] = element.bar
  hash
 end

虽然这似乎已成为一种常见的习语，但有没有人看到它比“朴素”版本有优势，它会像这样:

hash = {}
some_enum.each { |element| hash[element.foo] = element.bar }

我看到的第一个版本的唯一优势是您可以在一个封闭的 block 中进行操作，并且您不会(明确地)初始化散列。否则它会意外地滥用方法，更难理解和阅读。那么为什么它如此受欢迎？

最佳答案

正如 Aleksey 指出的那样，Hash#update() 比 Hash#store() 慢，但这让我开始思考 # 的整体效率inject() 与直接的 #each 循环，所以我做了一些基准测试:

require 'benchmark'
module HashInject
  extend self

  PAIRS = 1000.times.map {|i| [sprintf("s%05d",i).to_sym, i]}

  def inject_store
    PAIRS.inject({}) {|hash, sym, val| hash[sym] = val ; hash }
  end

  def inject_update
    PAIRS.inject({}) {|hash, sym, val| hash.update(val => hash) }
  end

  def each_store
    hash = {}
    PAIRS.each {|sym, val| hash[sym] = val }
    hash
  end

  def each_update
    hash = {}
    PAIRS.each {|sym, val| hash.update(val => hash) }
    hash
  end

  def each_with_object_store
    PAIRS.each_with_object({}) {|pair, hash| hash[pair[0]] = pair[1]}
  end

  def each_with_object_update
    PAIRS.each_with_object({}) {|pair, hash| hash.update(pair[0] => pair[1])}
  end

  def by_initialization
    Hash[PAIRS]
  end

  def tap_store
    {}.tap {|hash| PAIRS.each {|sym, val| hash[sym] = val}}
  end

  def tap_update
    {}.tap {|hash| PAIRS.each {|sym, val| hash.update(sym => val)}}
  end

  N = 10000

  Benchmark.bmbm do |x|
    x.report("inject_store") { N.times { inject_store }}
    x.report("inject_update") { N.times { inject_update }}
    x.report("each_store") { N.times {each_store }}
    x.report("each_update") { N.times {each_update }}
    x.report("each_with_object_store") { N.times {each_with_object_store }}
    x.report("each_with_object_update") { N.times {each_with_object_update }}
    x.report("by_initialization") { N.times {by_initialization}}
    x.report("tap_store") { N.times {tap_store }}
    x.report("tap_update") { N.times {tap_update }}
  end

end

结果:

Rehearsal -----------------------------------------------------------
inject_store             10.510000   0.120000  10.630000 ( 10.659169)
inject_update             8.490000   0.190000   8.680000 (  8.696176)
each_store                4.290000   0.110000   4.400000 (  4.414936)
each_update              12.800000   0.340000  13.140000 ( 13.188187)
each_with_object_store    5.250000   0.110000   5.360000 (  5.369417)
each_with_object_update  13.770000   0.340000  14.110000 ( 14.166009)
by_initialization         3.040000   0.110000   3.150000 (  3.166201)
tap_store                 4.470000   0.110000   4.580000 (  4.594880)
tap_update               12.750000   0.340000  13.090000 ( 13.114379)
------------------------------------------------- total: 77.140000sec

                              user     system      total        real
inject_store             10.540000   0.110000  10.650000 ( 10.674739)
inject_update             8.620000   0.190000   8.810000 (  8.826045)
each_store                4.610000   0.110000   4.720000 (  4.732155)
each_update              12.630000   0.330000  12.960000 ( 13.016104)
each_with_object_store    5.220000   0.110000   5.330000 (  5.338678)
each_with_object_update  13.730000   0.340000  14.070000 ( 14.102297)
by_initialization         3.010000   0.100000   3.110000 (  3.123804)
tap_store                 4.430000   0.110000   4.540000 (  4.552919)
tap_update               12.850000   0.330000  13.180000 ( 13.217637)
=> true

Enumerable#each 比 Enumerable#inject 快，Hash#store 比 Hash#update 快>。但最快的是在初始化时传入一个数组:

Hash[PAIRS]

如果您在创建哈希后添加元素，则获胜版本正是 OP 所建议的:

hash = {}
PAIRS.each {|sym, val| hash[sym] = val }
hash

但在那种情况下，如果你是一个想要单一词汇形式的纯粹主义者，你可以使用 #tap 和 #each 并获得相同的速度:

{}.tap {|hash| PAIRS.each {|sym, val| hash[sym] = val}}

对于那些不熟悉 tap 的人，它会在正文中创建接收者(新哈希)的绑定(bind)，并最终返回接收者(相同的哈希)。如果您了解 Lisp，请将其视为 Ruby 版本的 LET 绑定(bind)。

既然有人问了，这里是测试环境:

# Ruby version    ruby 2.0.0p247 (2013-06-27) [x86_64-darwin12.4.0]
# OS              Mac OS X 10.9.2
# Processor/RAM   2.6GHz Intel Core i7 / 8GB 1067 MHz DDR3

关于ruby-on-rails - #inject on hashes 被认为是好的风格吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3230863/