JavaScript unique method for array prototype

Question

Clarification:

As some people have pointed out, this does look like a "Is this code ok"-kind of question. The main thing I'm actually curious about is this: how does the .hasOwnProperty method work?
I mean: IE's JScript engine (<9 at least) doesn't always use hash-tables, so I assume it does little more than iterate over all properties of that object, and then checks to see if it gets those properties from another object higher up the prototype-chain. Is this a fair assumption to make? After all: at some level every code gets translated into loops and branches, but if IE doesn't do hash-tables, doesn't that mean .hasOwnProperty is just some sugar, just there so you don't have to write the loop?
I think I got this notion from one of DC's blog-posts or video's and it could well be that he was talking about arrays, and the quirky things they are (or rather: can be) in JS. I can't find the video/blog-post(?) ATM. And seeing as JS Arrays are often abused, as many of you I think will agree, I thought the answers to this question could serve as a decent reference. That's why I didn't post it on codereview.

As far as current answers go, and since my question started of from the wrong angle (focussing on the code more than the mechanisms behind it), let me just be so corny as to thank you all for pointing out the issues I didn't think of.

---

Recently, I augmented the array prototype for a script I was working on (don't shoot, just yet). In order not to reinvent the wheel, I went and searched for some examples of how other people went about it.

Strangly This is quite common, which is plainly needlessly complex. I also found this, as an alternative, other than the poster being rather smug about his fast algorithm I still feel there is room for improvement.

I know I might come across as a smug wise-guy now, my unique method actually looks like this:

Array.prototype.unique = function()
{
    'use strict';
    var i,obj,ret;
    ret = [];
    obj = {};
    for (i=0;i<this.length;i++)
    {
        if (!obj.hasOwnProperty(this[i]))
        {
            ret.push(this[i]);
            obj[this[i]] = i;
        }
    }
    return ret;
};

This way, there just is no need for a second loop AFAIK, is there? Unless, of course, the hasOwnProperty method is dead slow, but somehow I doubt that, in this case: the chain can only go back 1 level, to the Object.prototype.

The second link I posted contains some statistics and speed-comparisons, but as we all know they mean next to nothing in the real world. Could anyone point me in the direction of good article on JS and benchmarking (apart from the one on John Resig's blog?

So, just out of curiosity: Does any one of you see a problem with this method? some more info: Object.prototype: unchanged, undefined is undefined, no globals no frameworks, and this method isn't blindly implemented (if (!Array.prototype.unique){...})

Answer 1

Here is an implementation that considers type correctly, is much faster than the naive nested loops, and maintains the original array's order:

Array.prototype.unique = function(){
    var r, o, i, j, t, tt;
    r = [];
    o = {};
    for(i = 0; i < this.length; i++){
       t = this[i];
       tt = o[t] = o[t] || [];
       for(j = 0; j < tt.length; j++)
           if(tt[j] === this[i])
               break;
       if(j == tt.length)
           r.push(tt[j] = t);
     }
     return r;
}

I made a JSPerf to compare these implementations.

• unique1 is the nested loops.
• unique2 is the fast algorithm you linked to.
• unique3 is your version.
• unique4 is mine.
  Added
• unique5 is Kooilnc's answer
• unique6 is primvdb's answer

While unique2 is the fastest, it has the problem that it considers "1" and 1 as equal. unique4 comes in third for speed but is much faster than unique1 and gives correct output. All four variations actually give different output:

=> [1, "1", 1, 2, 3, 4, 1, 2, 3, "2", "3", "4", "true", "true", true].unique1()
// ["1", 4, 1, 2, 3, "2", "3", "4", "true", true]

=> [1, "1", 1, 2, 3, 4, 1, 2, 3, "2", "3", "4", "true", "true", true].unique2()
// [1, "2", "3", "4", true]

=> [1, "1", 1, 2, 3, 4, 1, 2, 3, "2", "3", "4", "true", "true", true].unique3()
// [1, 2, 3, 4, "true"]

=> [1, "1", 1, 2, 3, 4, 1, 2, 3, "2", "3", "4", "true", "true", true].unique4()
// [1, "1", 2, 3, 4, "2", "3", "4", "true", true]

Answer 2

Although not widely supported, you can use a Set (from ECMAScript Harmony). It's native so it shouldn't have that much of a performance impact (e.g. there is no need to look for the actual index like indexOf does). The main advantage is that you can seamlessly use it to keep track of which items you've already had, including objects, and you can take account for same objects:

Array.prototype.unique = function() {
    'use strict';
    var ret = [];
    var used = new Set();
    for (var i = 0; i < this.length; i++) {
        if (!used.has(this[i])) {
            ret.push(this[i]);
            used.add(this[i]);
        }
    }
    return ret;
};

var a = {};
var b = {};
[1, 2, 1, a, a, null, b].unique(); // [1, 2, a, null, b]

Answer 3

Looks fine, but as Felix Kling noted it only works with arrays containing primitives. This one is a bit more complex, but works for all types I think:

Array.prototype.unique = function(){
  'use strict';
  var im = {}, uniq = [];
  for (var i=0;i<this.length;i++){
    var type = (this[i]).constructor.name, 
    //          ^note: for IE use this[i].constructor!
        val = type + (!/num|str|regex|bool/i.test(type) 
               ? JSON.stringify(this[i]) 
               : this[i]);
    if (!(val in im)){uniq.push(this[i]);}
    im[val] = 1;
  }
  return uniq;
}
//testing
var test = [1,2,'string',[1,2,3],'string','1','2',
            {yada:'yada'},/[a-z]/i,2,1,1,2,[1,2,3],
            false, new Date(),/[a-b]/i,5,/[a-z]/i,'false']
   ,testunique = test.unique();
//=> testunique now
//   [1,2,string,[1,2,3],1,2,[object Object],
//    /[a-z]/i,false,Mon Aug 20 2012 20:20:11 GMT+0200,
//    /[a-b]/i,5,false]