Iterating over JS Object across multiple arrays - Performance

Question

So basically what I'm trying to do here is this:

Lets say you have this object:

{
 owner: 'Richard',
 time: 141381983181,
 type: 'Football',
 approved:['Higgs','Rooney','Jake'],
 pending:['Richmond','Sarah','Evelyin'],
 rejected:['Bilbo','Alice','Marta']
}

Now, what I kinda need is a quick function that would return which 'Name' belongs to what field.

For example: determineUserLevel('Bilbo',aMeeting) //return rejected.

So I wrote one:

function determineUserLevel(spec){

    var event = spec.event,
        user = spec.user;


    if(event.owner === user) return 'owner';

    for(var i = 0 ; i < event.approved.length; i++){

       if(event.approved[i] === user) return 'approved';

    }
    for(var x = 0; x < event.pending.length; x++){

        if(event.pending[x] === user) return 'pending';

    }
    for(var f = 0; f < event.rejected.length; f++){

        if(event.rejected[f] === user) return 'rejected'

    }

    return 'user';

}

Is there any better approach? Performance wise ? maintainable wise? or this is pretty solid?

Thanks.

Answer 1

Unless your arrays are huge (thousands of items), a function like this will have a negligible performance impact. You should be optimizing for reliability and readability instead.

function determineUserLevel(spec){

    var event = spec.event,
        user = spec.user;


    if(event.owner === user) {
      return 'owner';
    }
    if(event.approved.indexOf(user) > -1) {
      return 'approved';
    }
    if(event.pending.indexOf(user) > -1) {
      return 'pending';
    }
    if(event.rejected.indexOf(user) > -1) {
      return 'rejected';
    }

    return 'user';

}

Using indexOf rather than loops simplifies the code and minimizes the chances of typoing the loop condition. You could also combine the 2 for even more readability.

function determineUserLevel(spec){

    var event = spec.event,
        user = spec.user;


    if(event.owner === user) {
      return 'owner';
    }
    var sets = ['approved','pending','rejected'];

    for(var i=0; i<sets.length; i++) {
       var set = sets[i];
       if(event[set].indexOf(user) > -1) {
         return set
       }
    }

    return 'user';

}

How readable that is is a bit of a judgement call, but it would allow you to scale out to more sets easily without having to repeat yourself.

Answer 2

Use an object as a hashset instead of an array of strings. So instead of this:

approved:['Higgs','Rooney','Jake']

change it to this:

approved:{'Higgs':true,'Rooney':true,'Jake':true},

Now lookups are super fast:

if (approved[nameToTest]) {
    return "approved";
}

And obviously the same for all the other array properties.

If you are starting from an array, then transforming it into a hashset is fairly trivial, something like:

approved = ['Higgs', 'Rooney', 'Jake'];

var approvedObj = approved.reduce(function(curr, next) {
  curr[next] = true;
  return curr;
}, {});

alert(JSON.stringify(approvedObj));

Whether the initial cost of the transformation is worth it depends on how big your collection is and how often you need to do a look up.