Tell me more ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 6 down vote favorite

This question already has an answer here:

I want to get array having unique objects.

Say I have array of objects 

[{"a":"b"},{"c":"d"},{"a":"b"}]

and I want unique value of array i.e

[{"a":"b"},{"c":"d"}]

is there any simplest way to do this.

share|improve this question
Yes, probably there is. – Matteo Tassinari Jun 3 at 9:21
1  
There's no simple way of doing it - you'll need to do it by hand. Start by writing a comparator function, which takes 2 objects and returns true/false based on whether the objects are equal. Then loop over the array with this comparator. – Aleks G Jun 3 at 9:21
1  
It is not a dupe, there you had a fixed property that you could lookup, here you don't. – BrunoLM Jun 3 at 9:26
1  
@harsha This is not the same question. In your linked question, the duplicity is checked by one specific key. Here the set of properties is not fixed for any of the objects and all of them must be equal. – Aleks G Jun 3 at 9:28
Sorry guys,my bad,posted the wrong link.Will remove it. – harsha Jun 3 at 9:29

marked as duplicate by billyonecan, Jon, Palash Mondal, Łukasz Lech, James Donnelly Jun 3 at 10:10

This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.

2 Answers

up vote 6 down vote accepted

If the array containing the same objects over and over again you can do make a function like this:

var oa = {"a":"b"},
    ob = {"c":"d"};

var array = [oa, ob, oa];

function unique(a) {
    var arr = [];
    for(var i = 0; i < a.length; i++) {
        if( !arr.indexOf(a[i]) == -1 ) {
            arr.push(a[i]);
        }
    }
    return arr; 
}

But this will most likely not work because the object even when they seams the same is different:

alert( {a: 1} === {a: 1} ); // false

But:

var a = {a: 1};
alert( a === a ); // true

And even this will be true:

var a = {a: 1},
    b = a;

alert( a === b ); // true

So you will have to test for that as well (this is a shallow caparation. One level objects):

function isEqual(a, b) {
    var prop;
    for( prop in a ) {
        if ( a[prop] !== b[prop] ) return false;
    }
    for( prop in b ) {
        if ( b[prop] !== a[prop] ) return false;
    }
    return true;
}

And we have to rewrite our unique function as well: 

function unique(a) {
    var isAdded,
        arr = [];
    for(var i = 0; i < a.length; i++) {
        isAdded = arr.some(function(v) {
            return isEqual(v, a[i]);
        });
        if( !isAdded ) {
            arr.push(a[i]);
        }
    }
    return arr; 
}

Full Code:

var a = [{"a":"b"},{"c":"d"},{"a":"b"}],
    b = unique(a); // [{"a":"b"},{"c":"d"}]

function unique(a) {
    var isAdded,
        arr = [];
    for(var i = 0; i < a.length; i++) {
        isAdded = arr.some(function(v) {
            return isEqual(v, a[i]);
        });
        if( !isAdded ) {
            arr.push(a[i]);
        }
    }
    return arr; 
}
function isEqual(a, b) {
    var prop;
    for( prop in a ) {
        if ( a[prop] !== b[prop] ) return false;
    }
    for( prop in b ) {
        if ( b[prop] !== a[prop] ) return false;
    }
    return true;
}

Note the use of some methods is depending on ECMAScript 5th Edition:

Array.some
Array.indexOf

share|improve this answer
up vote 2 down vote

The simplest option is to compare objects by their JSON representation:

uniq = function(xs) {
    var seen = {};
    return xs.filter(function(x) {
        var key = JSON.stringify(x);
        return !(key in seen) && (seen[key] = x);
    });
}

For example:

console.log(
    uniq([{"a":"b"},{"c":"d"},{"a":"b"},{"a":"b"}])
)

// [{"a":"b"},{"c":"d"}]

Also, I recommend underscore.js for this kind of stuff, see Check if duplicate array pairs exist using underscore only for more discussion and examples.

Some commenters raised a concern that JSON.stringify is inadequate when comparing objects that differ only by the order of keys. I guess that comes down to the definition of "equality": {a:1,b:2} and {b:2,a:1} might be considered equal in one context and different in another. Still, if you want such objects to be "equal", you can extend JSON.stringify to be something like this:

toSortedJSON = function(obj) {
    return JSON.stringify(
        typeof obj == "object" ?
            Object.keys(obj).sort().reduce(function(o, key) {
                return o[key] = toSortedJSON(obj[key]), o;
            }, {}) : obj
    );
}

Then modify uniq to accept the key function:

uniq = function(xs, key) {
    var seen = {};
    return xs.filter(function(x) {
        var k = (key || JSON.stringify)(x);
        return !(k in seen) && (seen[k] = 1);
    });
}

and, finally pass the custom serializer to uniq:

console.log(
    uniq([
        {"a":1, "b":2},
        {"x":33},
        {"b":2, "a":1},
    ], toSortedJSON)
)

// [{"a":1,"b":2},{"x":33}]
share|improve this answer
1  
Careful: The JSON representation isn't reliable. In JS objects the order of properties in not defined. {'a': 'b', 'c': 'd'} and {'c': 'd', 'a': 'b'} are practically the same object, but the JSON representations may not be the same. – RoToRa Jun 3 at 9:49
1  
Can you be sure that {a: 1, b: 1} and {b: 1, a: 1} is stringified the same way? – NULL Jun 3 at 9:50
@RoToRa: see my answer in the linked thread. – thg435 Jun 3 at 9:51
@thg435 Maybe you should clarify that? – NULL Jun 3 at 9:56
@NULL: some stuff added. – thg435 Jun 3 at 10:06

Not the answer you're looking for? Browse other questions tagged or ask your own question.