Question

我有一个结构如下的JSON数据：

{ "a":"1",
  "b":[{ "a":"4",
         "b":[{}],
         "c":"6"}]
  "c":"3"
}

此处，即使嵌套，密钥a也始终是唯一的。

我想分离我的JSON数据，使它看起来像这样：

{"a":"1"
 "b":[]
 "c":"3"
},
{"a":"4",
 "b":[],
 "c":"6"
}

JSON数据最多可以嵌套多次。怎么做？

Answer 1

我使用输入和输出堆栈：

x = {
    "a":1,
    "b":[
         {
             "a":2,
             "b":[ { "a":3, }, { "a":4, } ]
         }
    ]
}

input_stack = [x]
output_stack = []

while input_stack:
     # for the first element in the input stack
     front = input_stack.pop(0)
     b = front.get('b')
     # put all nested elements onto the input stack:
     if b:
         input_stack.extend(b)
     # then put the element onto the output stack:
     output_stack.append(front)

output_stack ==
[{'a': 1, 'b': [{'a': 2, 'b': [{'a': 3}, {'a': 4}]}]},
 {'a': 2, 'b': [{'a': 3}, {'a': 4}]},
 {'a': 3},
 {'a': 4}]

output_stack可能是dict原因。然后替换

output_stack.append(front)

与

output_dict[front['a']] = front

Answer 2

不确定Python实现，但在JavaScript中，这可以使用递归来完成：

function flatten(objIn) {
  var out = [];
  function unwrap(obj) {
    var arrayItem = {};
    for(var idx in obj) {
      if(!obj.hasOwnProperty(idx)) {continue;}
      if(typeof obj[idx] === 'object') {
        if(isNaN(parseInt(idx)) === true) {
          arrayItem[idx] = [];
        }
        unwrap(obj[idx]);
        continue;
      }
      arrayItem[idx] = obj[idx];
    }
    if(JSON.stringify(arrayItem) !== '{}') {
      out.unshift(arrayItem);
    }
  }
  unwrap(objIn);

  return out;
}

如果对象键名不是数字，这只会按预期工作。

请参阅JSFiddle。

如何分隔嵌套的JSON

2 个答案: