Ruby 迭代字典数组

Question

我有一个这样的 JSON 数据结构...

{
  "items": [
      {
        "person": { // person hash }
      },
      {
        "dog": { // dog hash }
      },
      {
        "fruit": { // fruit hash }
      },
      {
        “person”: { // person hash }
      }
    ]
  }
}

数组中的每一项仅包含一个键值对。关键是机器人告诉我值是什么类型的项目。

我想做的是迭代数组并为每种类型的项目运行不同的函数。

所以我有这样的东西......

items = data.dig('items')

items.map do |item|
  if person = item.dig('person')
    transform_person(person)
  elsif dog = item.dig('dog')
    transform_dog(dog)
  elsif fruit = item.dig('fruit')
    transform_fruit(fruit)
  end
end

但我觉得应该有更优雅的方式来做到这一点？

抱歉。我的问题似乎有些模棱两可。

初始数组可能包含多个具有相同键的项目。我想要做的是映射到一组项目，这些项目被转换为前端所需的内容。输入包含前端不需要的奇怪结构和信息。

所以输出数组顺序必须与输入数组顺序一致。

很抱歉给您带来了困惑。

Answer 1

首先，您需要在常量中定义键首选项：

PECKING_ORDER = %w[ person dog fruit ]

然后你可以用它来找到它：

def detect(item)
  PECKING_ORDER.lazy.map do |key|
    [ key, item.dig(key) ]
  end.find do |key, v|
    v
  end
end

在哪里可以挖掘找到的第一个项目。 lazy 在这里使用，所以它不会不必要地把它们都挖出来，只是一次挖一个，直到成功为止。

这为您提供了一个可用于动态调度的键/值对：

items.each do |item|
  key, value = detect(item)

  if (key)
    send(:"transform_#{key}", value)
  end
end

Answer 2

如果你知道映射，你可以做一个伪工厂哈希：

methods_mapped = {
  "person" => ->(person) { do_something_with_person(person) },
  "dog" => ->(dog) { do_something_with_dog(dog) },
  "fruit" => ->(fruit) { do_something_with_fruit(fruit) }
}

items.map do |item|
  key = item.keys.first # what if keys.size > 1 ?
  method = methods_mapped.fetch(key)
  method.call(item[key])
end

或者你可以从相反的方向：

methods_mapped.each do |key, method|
  method.call(items.dig(key))
end

Answer 3

让f 是一个给定的方法，它接受一个散列作为参数。不失一般性，假设如下。这对应于 OP 的 transform_person、transform_dog 和 transform_fruit 方法的组合。

def f(h)
  case h.keys.first
  when :person then "somebody"
  when :dog    then "doggie" 
  when :fruit  then "juicy"
  end
end

假设我们也被给定了（这里不需要dig）

items = data[:items]
  #=> [{:person=>{:name=>"Melba"}},
  #    {:dog=>{:tricks=>[:roll_over, :shake_a_paw]}},
  #    {:fruit=>{:good=>"raspberries"}}]

和

key_order = [:bird, :marsupial, :dog, :person]

我们希望找到key_order 的第一个元素k，其中items 包含h 的哈希h.key?(k) #=> true。如果找到这样的哈希h，我们将执行f(h)。

首先计算一个哈希key_map。

key_map = items.each_with_object({}) { |g,h| h[g.keys.first] = g }
  #=> {:person=>{:person=>{:name=>"Melba"}},
  #    :dog=>{:dog=>{:tricks=>[:roll_over, :shake_a_paw]}},
  #    :fruit=>{:fruit=>{:good=>"raspberries"}}}

然后我们简单地执行

k = key_order.find { |k| key_map[k] }
  #=> :dog
k ? f(key_map[k]) : nil
  #=> "doggie"

Answer 4

我会保持简单：

items.map do |item|
  do_something_with_person(item) if item.dig('person')
  do_something_with_dog(item) if item.dig('dog')
  do_something_with_fruit(item) if item.dig('fruit')
end

或

items.each do |item|
  case item
    when item.dig('person') then do_something_with_person(item)
    when item.dig('dog') then do_something_with_dog(item)
    when item.dig('fruit') then do_something_with_fruit(item)
  end
end

或

def do_something(item)
  case
    when item.dig('person') then do_something_with_person(item)
    when item.dig('dog') then do_something_with_dog(item)
    when item.dig('fruit') then do_something_with_fruit(item)
  end
end
items.map { |item| do_something(item) }