Question

我有一组JSON值，有3个级别：

cluster＆gt;段＆gt;节点

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

每个节点都包含一个id以及对其segment id和cluster 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的本质是完全有效的（嵌套在一个对象中的对象的想法），如果在语法上不正确（没有验证你所有的逗号都在正确的位置）。

但是，你没有你想要的东西，它是集群中段的集合，以及段中节点的集合。

将其更改为

[{
  "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

嵌套没有问题，但是，如果每个群集可以包含多个段，并且每个段可以反过来有多个节点，那么你应该使用一个数组。

{
    "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 3

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

JSON key and values should be in double quotes“and not single quotes”. Look at your xpos and ypos`值可以看出我的意思。我通常使用JSONLint来确保我的JSON有效。
您说cluster有segment个集合，segment集合node s。这可能最好用数组表示。
看起来你也想要多个集群。这也最好用数组表示。

所以形式上的东西（压痕大大夸大了，希望会有所帮助）：

{
    "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 4

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

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 }
                  }
];

在上面，实际的水平＆＃39;是

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个级别＆＃39;，将它们描述为群集＆gt;段＆gt;节点。单词＆＃39;等级＆＃39;如果这些对象之间存在语义关系，则箭头才有意义。毕竟，＆＃39;级别＆＃39;必须在层次结构，继承，顺序或类似的分层方式中相互关联。

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

如果没有明显的编码关系，这些密钥中的每一个最符合逻辑地命名一个“客户”的独特属性。对象 - 也就是说，每个客户都有集群，段和节点。每个房产都有清晰的标签，每个房产都可以在平面结构中愉快地共存。如果OP在需要级别的关系上有更多信息，那么结构很容易修改。

简而言之，嵌套应具有语义目的;如果没有，则应省略嵌套标记。如上所述，OP示例中的大部分JSON语法都没有明显的含义，并引入了逻辑问题。该修订版也可以通过给定的信息解决这些问题。

Answer 5

对我来说似乎很好，虽然出于习惯，我会检查http://www.jsonlint.com中的所有内容并略微“修复”版本验证（删除单引号并确保命名结构）：

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

作为一个注释，如果你让jQuery或其他插件执行'JSONification'它会变成相同的，正如已经指出的那样，你不是将段等表示为集合（这是哪里我个人觉得构建对象更容易表示。）

.. 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;
}

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

5 个答案: