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

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,
        },
      ]
    },
  },
]

我想创建一个惰性枚举器，它将 return 每个 #next 上的下一个小哈希值，然后继续下一个大哈希值，并在第一个大哈希值达到结束

return 我想要的所有内部散列的简单方法是这样的

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

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

Answer 1

这个 returns 一个惰性枚举器，它遍历所有的小散列：

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）

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

Lazy enumerator for nested array of hashes

ruby

hash

enumerable