Ruby数组构造

Question

我有以下 json，

{
    "items": [
        {
            "name": "table",
            "item_group": [
                {
                    "code": "code1",
                    "section": [
                        {                         
                            "unit": "centimeter",
                            "values": [
                                {
                                    "display": "151.13 centimeter"
                                }
                            ]
                        },
                        {                         
                            "unit": "centimeter (qualifier value)",
                            "values": [
                                {
                                    "display": "170.39 centimeter"
                                }
                            ]
                        }
                    ],
                    "total": 2
                }
            ],
            "more_results": false,
            "total": 1
        }
    ]
}

我如何遍历它并创建一个“值”数组。我想要 [151.13 厘米，170.39 厘米，....] 之类的东西。请指出一些方向。谢谢。

注意：我必须在 Haml 中执行此操作。

Answer 1

我知道有多种方法可以做到这一点。但是如果你真的有很多复杂的 JSON 查询，你可以试试ruby-jq gem。它非常快，因为它使用 linux 管道

require 'jq'
require 'jq/extend'
json_content =         {
        "items": [
            {
                "name": "table",
                "item_group": [
                {
                        "code": "code1",
                        "section": [
                            {                         
                                "unit": "centimeter",
                                "values": [
                                    {
                                        "display": "151.13 centimeter"
                                    }
                                ]
                            },
                            {                         
                                "unit": "centimeter (qualifier value)",
                                "values": [
                                    {
                                        "display": "170.39 centimeter"
                                    }
                                ]
                            }
                        ],
                        "total": 2
                    }
                ],
                "more_results": false,
                "total": 1
            }
        ]
    }


jq_filter = ' .items | .[].item_group |.[].section| . [ ] .values | . [ ] .display'

final_array = json_content.jq(jq_filter)

  # => final_array =  ["151.13 centimeter", "170.39 centimeter"]

Answer 2

假设你知道底层哈希的结构，你可以这样做：

代码

require 'json'

JSON.parse(json_str)['items'].each_with_object([]) do |g,arr|
  g['item_group'].each do |gg|
    gg['section'].each do |ggg|
      ggg['values'].each { |gggg|arr << gggg['display'][/\d+\.\d+/].to_f }
    end
  end
end    
  #=> [151.13, 170.39] 

说明

步骤如下：

a = JSON.parse(json_str)
b = a['items']
enum = b.each_with_object([])
  #=> #<Enumerator: [{"name"=>"table",..."total"=>1}]:each_with_object([])> 

我们可以通过将枚举器转换为数组来查看它的元素：

enum.to_a
  #=> [[{"name"=>"table", "item_group"=>[{"code"=>"code1",
  #        "section"=>[{"unit"=>"centimeter",
  #        "values"=>[{"display"=>"151.13 centimeter"}]},
  #        { "unit"=>"centimeter (qualifier value)",
  #        "values"=>[{"display"=>"170.39 centimeter"}]}], "total"=>2}],
  #     "more_results"=>false,
  #     "total"=>1},
  #   []]] 

请注意，这个数组有一个元素，一个包含哈希的二元素数组和一个空数组。

enum 的第一个元素被传递给块并使用并行赋值分配给块变量：

g, arr = enum.next
  #=> {"name"=>"table",
  #    "item_group"=>[
  #      {"code"=>"code1",
  #      "section"=>[
  #        {"unit"=>"centimeter",
  #         "values"=>[
  #           {"display"=>"151.13 centimeter"}
  #         ]
  #        },
  #      {"unit"=>"centimeter (qualifier value)",
  #      "values"=>[
  #        {"display"=>"170.39 centimeter"}
  #       ]
  #      }
  #     ],
  #    "total"=>2}],
  #    "more_results"=>false,
  #    "total"=>1} 
arr #=> [] 

c = g['item_group']
  #=> [{"code"=>"code1",
  #     "section"=>[
  #       {"unit"=>"centimeter",
  #        "values"=>[
  #          {"display"=>"151.13 centimeter"}
  #         ]
  #       },
  #       {"unit"=>"centimeter (qualifier value)",
  #        "values"=>[
  #          {"display"=>"170.39 centimeter"}
  #        ]
  #       }
  #   ],
  #   "total"=>2}] 

注意c 的格式为[hash]。

c 的第一个（也是唯一一个）元素被传递给它的块并分配给它的块变量：

gg = c.first
d = gg['section']
  #=> [{"unit"=>"centimeter",
        "values"=>[
         {"display"=>"151.13 centimeter"}
        ]
       },
       {"unit"=>"centimeter (qualifier value)",
        "values"=>[
          {"display"=>"170.39 centimeter"}
        ]
       }
      ] 

ggg = d.first
  #=> {"unit"=>"centimeter",
  #    "values"=>[
  #      {"display"=>"151.13 centimeter"}
  #    ]
  #   } 

e = ggg['values']
  #=> [{"display"=>"151.13 centimeter"}]

gggg = e.first
  #=> {"display"=>"151.13 centimeter"} 

f = gggg['display']
  #=> "151.13 centimeter" 
g = f[/\d+\.\d+/]
  #=> "151.13" 
i = g.to_f
  #=> 151.13 
arr << i
  #=> [151.13] 
arr
  #=> [151.13] 

其余的计算类似。

另一种表达方式

如示例中所示，如果数组 JSON.parse(json_str)['items']、g['item_group'] 和 ggg['values'] 各包含一个元素（散列），则可以改为：

JSON.parse(json_str)['items'].first['item_group'].first['section'].
  each_with_object([]) do |g, arr|
    arr << g['values'].first['display'][/\d+\.\d+/].to_f
  end
  #=> [151.13, 170.39] 

虽然我怀疑这会显着提高效率。