How do I properly structure nested JSON values?

Question

I have a collection of JSON values that has 3 levels:

cluster > segment > node

Where each cluster is made of segments and each segment is made up of nodes. I am trying to figure out how to represent this as a JSON object and I am unsure how to create the structure.

Each node contains an id and a reference to its segment id and cluster id. I have written up a test object like this:

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

The part that feels a bit flaky is the way segment and node are nested. I am not getting any errors but is this the best way to represent this data?

EDIT:

Thanks for the answers, it definitely pointed me in the right direction as far as tools to use (jsonlint) and get a better understanding of structuring data in json. They're all correct answers which shows me that it was a pretty basic question. Thanks again.

Answer 1

Here's an improvement to the logic with no loss of meaning:

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

In the above, the actual 'levels' are

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

which could also be written:

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

Ok, let's agree the OP's example (as initially written) can meet the strict mechanical requirements of the JSON spec.

However, the OP describes 3 'levels', illustrating them as cluster > segment > node. The word 'level' and the arrows only make any sense if there is a semantic relationship between those objects. After all, 'levels' must relate to each other in a hierarchy, inheritance, sequence or some similarly layered fashion.

The original example gives no hint of the relationship between any part of a cluster and any part of a segment or any part of a node; it gives no way to guess what the relationship should be. The labels just sit adjacent to each other in the example, with a few extraneous braces around them.

Without an apparent relationship to encode, each of these keys most logically names a unique property of a 'customer' object--that is to say, each customer has clusters, segments and nodes. Each property is clearly labeled, and each can happily coexist in a flat structure. If OP has more info on relationships that require levels, the structure is easy to modify.

In short, nesting should have a semantic purpose; if it does not, markers of nesting should be omitted. As presented, much of the JSON syntax in the OP's example had no apparent meaning and introduces logical issues. The revision resolves these issues as well as possible with given information.

Answer 2

the nature of json you have is perfectly valid (the idea of an object nested in an object) if not syntactically correct (didn't verify that all your commas were in the right place).

however, you dont have what you said you wanted, which is a collection of segments in a cluster, and a collection of nodes in a segment.

change it to be

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

Seems fine to me, though out of habit I check everything in http://www.jsonlint.com and the slightly 'fixed' version validates (remove your single quotes and ensure you name the structure):

{
    "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 
                    } 
                } 
            } 
        } 
    ]
}

As a note, if you were to let jQuery or another plugin do the 'JSONification' it would turn out the same, as has also been noted, you're not representing the segments, etc as a collection (this is where I personally find building the object to be an easier representation).

.. ala (but build your object out):

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 4

I think this looks alright for the most part. However, note the following:

1. JSON key and values should be in double quotes"and not single quotes'. Look at yourxposandypos` values to see what I mean. I usually use JSONLint to ensure that my JSON is valid.

2. You say that clusters have a collection of segments and segments have a collection of nodes. This might be best represented as arrays.

3. It also looks like you want multiple clusters. That is also best expressed as an array.

So something of the form (greatly exaggerated the indentation, hopefully that will help):

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

There is nothing wrong with the nesting, however, if each cluster can contain multiple segments, and each segment can in-turn have multiple nodes, then you ought to use an array.

{
    "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 },
            ...
        ]
    }
}