JSON lookup by key

Question

I always did my lookup in JSON collection like that:

var data = [
    {
        "Key": "1111-1111-1111",
        "Email": "[email protected]"
    }
];

function getByKey(key) {
    var found = null;

    for (var i = 0; i < data.length; i++) {
        var element = data[i];

        if (element.Key == key) {
           found = element;
       } 
    }

    return found;
}

But I always wondered if there was a better / more optimal way of doing this.

Any suggestions?

Bonus question: any way of sorting a JSON collection? I found with .sort() and a compare function. Is that the best way?

Answer 1

Another way you can do it is to have the collection in an object, and use the primary identifier as key. This identifier is usually a unique identifier for that entity, like a user id.

This is way faster than iterating over an array in search for a match. As far as I remember, accessing via a key only takes one operation, O(1) while iterating through an array would depend on the length of the array. Worst case is that your match is at the tip of the array, thus O(n).

var data = {
  "1111-1111-1111" : {
    "Email": "[email protected]"
  }
};

//get by key
var key = "1111-1111-1111";
var oneOneOne = data[key];

oneOneOne.Email //[email protected]

This is only good when you try to get the set by the key. Otherwise, you'd have to resort to other arrangements for other retrievals.

As for sorting though, objects don't guarantee order, though browsers do sort them somehow. As far as I know, iterating through properties of an object in Firefox and Chrome yield different orders in the way they are arranged.

Answer 2

I tend to generate a lookup dictionary as soon as I have the data. So in any case I only need to iterate the data once.

Comparing with your approach, let's say we need to call getByKey() multiple times, the total cost of iterating the data might actually be higher.

I suppose which approach being more suitable really depends on your own application or design. But I also find myself sometimes generating different lookup dictionaries from the same set of data, and I would still only need to iterate the data once.

As for the .sort() bonus question, I would say that in terms of readability and code maintenance, yes, I would consider it one of the best ways of sorting a json collection.

var data = [
        {
            "Key": "2222-2222-2222",
            "Email": "[email protected]"
        },
        {
            "Key": "1111-1111-1111",
            "Email": "[email protected]"
        }
    ],
    lookup = {};

// generate the lookup table for reuse
data.forEach(function (el, i, arr) {
    lookup[el.Key] = el.Email;
});

// should return '[email protected]'
console.log(lookup['1111-1111-1111']); 

// sort by Key
var keys = data.sort(function (a, b) {
    var c = a.Key,
        d = b.Key;
    return c > d ? 1 :
           d < c ? -1 :
           0;       
});
console.log(keys[0].Key); // should return '1111-1111-1111'

// sort by Email
var emails = data.sort(function (a, b) {
    var c = a.Email,
        d = b.Email;
    return c > d ? 1 :
           d < c ? -1 :
           0;       
});
console.log(emails[0].Key); // should return '2222-2222-2222'