如何正确构建嵌套的 JSON 值？

Question

我有一个包含 3 个级别的 JSON 值集合：

集群>段>节点

每个集群由段组成，每个段由节点组成。我试图弄清楚如何将其表示为 JSON 对象，但我不确定如何创建该结构。

每个节点都包含一个 id 以及对其段 id 和集群 id 的引用。我写了一个这样的测试对象：

 var customers = [
                     {
                    "cluster" : 
                         {"flights":4, "profit":5245, "clv":2364,
                    "segment" :
                        { "flights":2, "profit":2150, "clv":1564,
                            "node" :
                                    { 'xpos': 1, 'ypos': 2 }// closes node
                        }// closes segment 
                         }//closes cluster
                     },
{
                    "cluster" : 
                         {"flights":4, "profit":5245, "clv":2364,
                    "segment" :
                        { "flights":2, "profit":2150, "clv":1564,
                            "node" :
                                    { 'xpos': 1, 'ypos': 2 }// closes node
                        }// closes segment 
                         }//closes cluster
                     }
];

感觉有点不稳定的部分是段和节点的嵌套方式。我没有收到任何错误，但这是表示此数据的最佳方式吗？

编辑：

感谢您的回答，就使用工具 (jsonlint) 和更好地理解 json 中的结构化数据而言，它无疑为我指明了正确的方向。它们都是正确的答案，这向我表明这是一个非常基本的问题。再次感谢。

Answer 1

如果语法不正确（没有验证所有逗号都在正确的位置），你所拥有的 json 的性质是完全有效的（对象嵌套在对象中的想法）。

然而，你没有说你想要的，它是一个集群中的一个collection，以及一个segment中的一个节点的集合。

改成

[{
  "cluster": {..,
     "segments": [{    <--- note the array -- you now have a collection
         "name": 'segment1', <- optional, just here to show multiple segments
         "nodes": [{....}] <-- same here
     }, 
     {
         "name": 'segment2',
         "nodes": [{....}]
     }]
  }
}]

Answer 2

我认为这在大多数情况下看起来都不错。但是，请注意以下几点：

1. JSON key and values should be in double quotes"and not single quotes'. Look at yourxposandypos`值看看我的意思。我通常使用JSONLint来确保我的JSON有效。

   李>

2. 你说clusters 有一个segments 的集合，而segments 有一个nodes 的集合。这可能最好表示为数组。

3. 看起来您还需要多个集群。这也最好用数组来表示。

某种形式的东西（大大夸大了缩进，希望这会有所帮助）：

{
    "cluster" : [
                    {
                        "flights": 4,
                        "profit": 5245,
                        "clv": 2364,
                        "segment" : [
                                        {
                                            "flights": 2,
                                            "profit": 2150,
                                            "clv": 1564,
                                            "node" : [
                                                        {
                                                            "xpos": 1,
                                                            "ypos": 2 
                                                        }, 
                                                        {
                                                            //node 2
                                                        }
                                                    ] 
                                        }, 
                                        {
                                            //segment 2
                                        }
                                    ] 
                    },
                    {
                        //next cluster
                    }
                ]
}

Answer 3

嵌套没有错，但是，如果每个集群可以包含多个段，每个段又可以有多个节点，那么你应该使用数组。

{
    "cluster": {
        "flights": 4,
        ...,
        "segments": [ // segments is an array
            { 
                "flights": 6,
                "nodes": [ // nodes is an array
                    { "xpos": 4, "ypos": 6 },
                    { "xpos": 1, "ypos": 6 },
                    { third node },
                    ...
                ]
            },
            { second segment },
            ...
        ]
    }
}

Answer 4

对我来说似乎很好，但出于习惯，我检查了 http://www.jsonlint.com 中的所有内容，并且稍微“固定”的版本得到验证（删除你的单引号并确保你命名结构）：

{ “顾客”： [ { “簇” ： { “航班”：4， “利润”：5245， “clv”：2364， “分割” ： { “航班”：2， “利润”：2150， “clv”：1564， “节点”：{ “xpos”：1， “ypos”：2 } } } }, { “簇” ： { “航班”：4， “利润”：5245， “clv”：2364， “分割” ： { “航班”：2， “利润”：2150， “clv”：1564， “节点”：{ “xpos”：1， “ypos”：2 } } } } ] }

请注意，如果您让 jQuery 或其他插件执行“JSON 化”，结果会相同，正如还指出的那样，您不会将段等表示为一个集合（这就是我个人认为构建对象更容易表示）。

.. ala（但构建你的对象）：

var stuff = {};
stuff.customers = [];
stuff.customers[stuff.customers.length] = new Cluster();
stuff.customers[i].segment[stuff.customers[i].segment.length] = new Segment();

...etc.
...blah blah fill out object

$.toJSON('{"customerArrary":' + stuff + '}');

function cluster(){
  this.flights;
  this.profit;
  this.clv;
  this.segment = [];
}

function Segment(){
  this.flights;
  this.profit;
  this.clv;
  this.node = [];
}

function Node(){
  this.xpos;
  this.ypos;
}

Answer 5

这是对逻辑的改进，但没有失去意义：

var customers = [
                  {
                    "ID" : "client ABC",
                    "cluster" : { "ID": "cluster 123", "flights": 4, "profit": 5245, "clv": 2364 },
                    "segment" : { "ID": "segment 456", "flights": 2, "profit": 2150, "clv": 1564 },
                    "node" : { "xpos" : 1, "ypos" : 2 }
                  }, {
                    "ID" : "client DEF",
                    "cluster" : { "ID": "cluster 789", "flights": 4, "profit": 5245, "clv": 2364 },
                    "segment" : { "ID": "segment 876", "flights": 2, "profit": 2150, "clv": 1564 },
                    "node" : { "xpos" : 1, "ypos" : 2 }
                  }
];

在上面，实际的“级别”是

clusters > flights etc & segments > flights etc & nodes > xpos etc

也可以写成：

level 1: clusters
  level 2: flights, profit, & clv (note: values are unique from segments tho labels are identical)

level 1: segments
  level 2: flights, profit, & clv

level 1: nodes
  level 2: xpos & ypos

好的，让我们同意 OP 的示例（如最初编写的那样）可以满足 JSON 规范的严格机械要求。

但是，OP 描述了 3 个“级别”，将它们说明为集群 > 段 > 节点。只有当这些对象之间存在语义关系时，“级别”一词和箭头才有意义。毕竟，“级别”必须以层次结构、继承、顺序或类似的分层方式相互关联。

原始示例没有暗示集群的任何部分与段的任何部分或节点的任何部分之间的关​​系；它无法猜测这种关系应该是什么。在示例中，标签只是彼此相邻，周围有一些无关的大括号。

在没有明显的编码关系的情况下，这些键中的每一个在逻辑上最符合逻辑地命名“客户”对象的唯一属性——也就是说，每个客户都有集群、段和节点。每个属性都被清楚地标记，并且每个属性都可以在一个扁平的结构中愉快地共存。如果 OP 有更多关于需要级别的关系的信息，那么结构很容易修改。

简而言之，嵌套应该有语义目的；如果不是，则应省略嵌套标记。如前所述，OP 示例中的大部分 JSON 语法没有明显的含义，并且引入了逻辑问题。修订版利用给定的信息尽可能解决了这些问题。