Question

我需要每天每小时一个密钥使用一个密钥。我写了这个：

printf

我想知道是否有更好的方法可以用更少的代码行来实现相同的行为，并且具有可读性。

Answer 1

您可以使用默认触发器：

D:\\

然后检查：

hash = Hash.new do |h, k|
  h[k] = Hash.new do |h1, k1|
    h1[k1] = Hash.new do |h2, k2|
      h2[k2] = 0 if (0..59).include?(k2)
    end if (0..23).include?(k1)
  end if (1..7).include?(k)
end

此解决方案的主要优点是您不需要创建一堆对象，只需创建规则即可。如果您的实例中有少量对象，则可以创建对象，但如果您想创建大量对象，则可能会出现问题。

Answer 2

这不是最漂亮的，但这里需要考虑的事情：

(1..7).to_a.product((0..23).to_a, (0..59).to_a).
  reduce({}) do |hash, (weekday, hour, minute)| 
    hash.tap { |h| ((h[weekday] ||= {})[hour] ||= {})[minute] = 0 }
  end

Answer 3

你可以尝试一下这个：

(1..7).inject({}) do |wday, i|
  wday[i] = (0..23).inject({}) do |hour, j|
    hour[j] = (0..59).inject({}) do |minute, k|
      minute[k] = 0
      minute
    end
    hour
  end
  wday
end

或类似的东西：

Hash.new(Hash.new(Hash.new(0))

正确定义嵌套哈希的默认构造函数

Answer 4

你可以使用一组更易读的指令：

result = {}
(1..7).each do |wday|
  (0..23).each do |hour|
    (0..59).each do |minute|
      result[wday] ||= {}
      result[wday][hour] ||= {}
      result[wday][hour][minute] = 0
    end
  end
end

即使有更强大的解决方案，如果您不需要更复杂的行为，我认为这更具可读性。

Answer 5

我会这样做，这只是对OP所写内容的改进。

result = (1..7).each_with_object({}) do |wday, f|
           f[wday] = (0..23).each_with_object({}) do |hour, g|
             g[hour] = (0..59).each_with_object({}) do |minute, h|
               h[minute] = 0
             end
           end
         end

可替换地，

result = (1..7).each_with_object({}) do |wday, f|
           (0..23).each_with_object(f[wday] = {}) do |hour, g|
             (0..59).each_with_object(g[hour] = {}) do |minute, h|
               h[minute] = 0
             end
           end
         end

更智能的初始化深度哈希的方法

5 个答案: