Question

假设我有Array这样的

data = [
  {
    key: val,
    important_key_1: { # call this the big hash
      key: val,
      important_key_2: [
        { # call this the small hash
          key: val,
        },
        {
          key: val,
        },
      ]
    },
  },
  {
    key: val,
    important_key_1: {
      key: val,
      important_key_2: [
        {
          key: val,
        },
        {
          key: val,
        },
      ]
    },
  },
]

我想创建一个惰性枚举器，它将在每个#next上返回下一个小哈希值，然后转到下一个大哈希值并在第一个大哈希到达结束时执行相同操作

返回我想要的所有内部哈希的简单方法就是这样

data[:important_key_1].map do |internal_data|
  internal_data[:important_key_2]
end.flatten

有没有办法做到这一点，还是我需要实现自己的逻辑？

Answer 1

这将返回一个惰性枚举器，它遍历所有小哈希：

def lazy_nested_hashes(data)
  enum = Enumerator.new do |yielder|
    data.each do |internal_data|
      internal_data[:important_key_1][:important_key_2].each do |small_hash|
        yielder << small_hash
      end
    end
  end
  enum.lazy
end

使用您的输入数据和val定义：

@i = 0

def val
  @i += 1
end

输出：

puts lazy_nested_hashes(data).to_a.inspect
#=> [{:key=>3}, {:key=>4}, {:key=>7}, {:key=>8}]
puts lazy_nested_hashes(data).map { |x| x[:key] }.find { |k| k > 3 }
#=> 4

对于第二个示例，根本不考虑第二个大哈希（感谢enum.lazy）

嵌套哈希数组的惰性枚举器

1 个答案: