Question

我想用d3创建一些可视化，这需要我构建json。我一直在使用ruby，但由于json可以嵌套超过2个级别，因此我无法减少代码重复。这是我用于2级嵌套的代码..

    level1, level2 = Array.new(2) { [] }
    array.each do |arrayItem|
        level1.push(arrayItem[:key1])
        level2.insert(-1, {
            label: arrayItem[:key2],
            parent: arrayItem[:key1],
            value: arrayItem[:value],
            })
    end 
    index1 = index2 = 0
    tempLevel1 = []
    main = Hash.new()
    main["name"] = "flare"
    main["children"] = []
    while( index1 < level1.size ) do
        index2 = 0
        level1Value = level1[index1]
        level1Row = Hash.new()
        level1Row["name"] = level1Value
        level1Row["children"] = []
        tempLevel2 = []
        while( index2 < level2.size ) do 
            level2Value = level2[index2][:label]
            level2Parent = level2[index2][:parent]
            level2Count = level2[index2][:value]
            if( level2Parent == level1Value )
                level2Row = Hash.new()
                if( level2Value.nil? )
                    level2Row["name"] = "Others"
                else
                    level2Row["name"] = level2Value
                end
                level2Row["size"] = level2Count
                tempLevel2 << level2Row
            end
            index2 += 1
        end
        if( !tempLevel2.empty? )
            level1Row["children"] = level1Row["children"] | tempLevel2
            tempLevel1 << level1Row
        end
        index1 += 1
    end
    main["children"] = main["children"] | tempLevel1
    return main

正如您可以想象的那样，可以有多个级别，这通常意味着更多的嵌套循环，这也会增加代码大小。有没有办法减少此代码重复以及嵌套循环的数量。

输入数组将是这样的......

{:key1=>"a", :key2=>"p", :value=>1}
{:key1=>"a", :key2=>"q", :value=>1}
{:key1=>"a", :key2=>"r", :value=>1}
{:key1=>"b", :key2=>"s", :value=>1}
{:key1=>"c", :key2=>"q", :value=>1}
{:key1=>"a", :key2=>"t", :value=>1}

输出应该是这样的......

{
"name": "flare",
"children": [
    {
        "name": "a",
        "children": [
            {
                "name": "p",
                "size": 1
            },
            {
                "name": "q",
                "size": 1
            },
            {
                "name": "r",
                "size": 1
            },
            {
                "name": "s",
                "size": 1
            }
        ]
    },
    {
        "name": "b",
        "children": [
            {
                "name": "t",
                "size": 1
            }
        ]
    },
    {
        "name": "c",
        "children": [
            {
                "name": "q",
                "size": 1
            }
        ]
    }
]

}

Answer 1

不确定我是否做对了。据我所知，你想从普通数组构建嵌套树结构。在ruby中，您可以使用散列中的引用来获得优势。

require 'json'

array = [
  {key1: 'a', key2: nil, value: 1},
  {key1: 'b', key2: 'a', value: 1},
  {key1: 'c', key2: 'a', value: 1},
  {key1: 'd', key2: 'b', value: 1},
  {key1: 'e', key2: nil, value: 1},
  {key1: 'f', key2: 'b', value: 1},
]

# build hash table to keep references on values
hashtable = {}
array.each do |item|
  hashtable[item[:key1]] = {
    name: item[:key1],
    children: [],
    size: item[:value]
  }
end

# build json data based on hashtable
json_hash = {
  name: 'flare',
  children: []
}
array.each do |item|
  if item[:key2].nil?
    json_hash[:children] << hashtable[item[:key1]]
  else
    hashtable[item[:key2]][:children] << hashtable[item[:key1]]
  end
end

jj json_hash

使用ruby创建类似flare.json的嵌套json

1 个答案: