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

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）