What is "compressed JSON"?

Compressed JSON removes the key:value pair of json's encoding to store keys and values in seperate parallel arrays:

// uncompressed
JSON = {
  data : [
     { field1 : 'data1', field2 : 'data2', field3 : 'data3' },
     { field1 : 'data4', field2 : 'data5', field3 : 'data6' },
     .....
  ]
};
 
//compressed
JSON = {
    data : [ 'data1','data2','data3','data4','data5','data6' ],
    keys : [ 'field1', 'field2', 'field3' ]
};

This method of usage i found here

Content from link (http://www.nwhite.net/?p=242)

rarely find myself in a place where I am writing javascript applications that use AJAX in its pure form. I have long abandoned the ‘X’ and replaced it with ‘J’ (JSON). When working with Javascript, it just makes sense to return JSON. Smaller footprint, easier parsing and an easier structure are all advantages I have gained since using JSON.

In a recent project I found myself unhappy with the large size of my result sets. The data I was returning was tabular data, in the form of objects for each row. I was returning a result set of 50, with 19 fields each. What I realized is if I augment my result set I could get a form of compression.

// uncompressed

JSON = {
  data : [
     { field1 : 'data1', field2 : 'data2', field3 : 'data3' },
     { field1 : 'data4', field2 : 'data5', field3 : 'data6' },
     .....
  ]
};

//compressed

JSON = {
    data : [ 'data1','data2','data3','data4','data5','data6' ],
    keys : [ 'field1', 'field2', 'field3' ]
};

I merged all my values into a single array and store all my fields in a separate array. Returning a key value pair for each result cost me 8800 byte (8.6kb). Ripping the fields out and putting them in a separate array cost me 186 bytes. Total savings 8.4kb.

Now I have a much more compressed JSON file, but the structure is different and now harder to work with. So I implement a solution in Mootools to make the decompression transparent.

Request.JSON.extend({
 
    options : {
        inflate : []
    }
 
});




Request.JSON.implement({
 
    success : function(text){
        this.response.json = JSON.decode(text, this.options.secure);
        if(this.options.inflate.length){
            this.options.inflate.each(function(rule){
                var ret = ($defined(rule.store)) ? this.response.json[rule.store] : this.response.json[rule.data];
                ret = this.expandData(this.response.json[rule.data], this.response.json[rule.keys]);
            },this);
        }
        this.onSuccess(this.response.json, text);
    },
 
    expandData : function(data,keys){
        var arr = [];
        var len = data.length; var klen = keys.length;
        var start = 0; var stop = klen;
        while(stop < len){
            arr.push( data.slice(start,stop).associate(keys) );
            start = stop; stop += klen;
        }
        return arr;
    }
 
});

Request.JSON now has an inflate option. You can inflate multiple segments of your JSON object if you so desire.

Usage:

new Request.JSON({
       url : 'url',
       inflate : [{ 'keys' : 'fields', 'data' : 'data' }]
       onComplete : function(json){}
});

Pass as many inflate objects as you like to the option inflate array. It has an optional property called ’store’ If set the inflated data set will be stored in that key instead.

The ‘keys’ and ‘fields’ expect strings to match a location in the root of your JSON object.

Compressed:

[["KeyA", "KeyB", "KeyC", "KeyD", "KeyE", "KeyF"],
["ValA1", "ValB1", "ValC1", "ValD1", "ValE1", "ValF1"],
["ValA2", "ValB2", "ValC2", "ValD2", "ValE2", "ValF2"],
["ValA3", "ValB3", "ValC3", "ValD3", "ValE3", "ValF3"],
["ValA4", "ValB4", "ValC4", "ValD4", "ValE4", "ValF4"]]

Uncompressed:

[{KeyA: "ValA1", KeyB: "ValB1", KeyC: "ValC1", KeyD: "ValD1", KeyE: "ValE1", KeyF: "ValF1"},
{KeyA: "ValA2", KeyB: "ValB2", KeyC: "ValC2", KeyD: "ValD2", KeyE: "ValE2", KeyF: "ValF2"},
{KeyA: "ValA3", KeyB: "ValB3", KeyC: "ValC3", KeyD: "ValD3", KeyE: "ValE3", KeyF: "ValF3"},
{KeyA: "ValA4", KeyB: "ValB4", KeyC: "ValC4", KeyD: "ValD4", KeyE: "ValE4", KeyF: "ValF4"}]

Based in Paniyar's answer, we can convert a List of Objects in "compressed" Json format using C# like this:

var JsonString = serializer.Serialize(
new
{
    cols = new[] { "field1", "field2", "field3"},
    items = data.Select(x => new object[] {x.field1, x.field2, x.field3})
});

I used an array of object because the fields can be int, bool, string...

More Reduction: If the field is repeated very often and it is a string type, you can get compressed a little be more if you add a distinct list of that field... for instance, a field name job position, city, etc are excellent candidate for this. You can add a distinct list of this items and in each item change the value for a reference number. That will make your Json more lite.