How to create a list of unique items in JavaScript?

Question

In my CouchDB reduce function I need to reduce a list of items to the unique ones.

Note: In that case it's ok to have a list, it will be a small number of items of string type.

My current way is to set keys of a object, then return the keys of that object since the place the code can't use things like _.uniq for example.

I'd like to find a more elegant way to spell it than this.

function(keys, values, rereduce) {
  // values is a Array of Arrays
  values = Array.concat.apply(null, values);
  var uniq = {};
  values.forEach(function(item) { uniq[item] = true; });
  return Object.keys(uniq);
}

Answer 1

The best method seem to be using ES6 and Set. Single line and faster* than above according to fiddle

    
const myList = [1,4,5,1,2,4,5,6,7];
const unique = [...new Set(myList)];
    
console.log(unique);

*tested in safari

Answer 2

2021 answer:

const unique = (arr) => [...new Set(arr)];
unique([1, 2, 2, 3, 4, 4, 5, 1]); // [1, 2, 3, 4, 5]

Here you just create a set from the given array and then convert it back to the array. I measured performance and it's almost twice faster now than the approach proposed in the old answer I posted before. Also, it's just a one-liner.

Updated fiddle

Old answer just for the record:

Commonly, the approach you used is a good idea. But I could propose a solution that will make the algorithm a lot faster.

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

As you can see we have only one loop here.

I've made an example that is testing both your and my solutions. Try to play with it.

Answer 3

An alternative that's suitable for small lists would be to ape the Unix command line approach of sort | uniq:

    function unique(a) {
        return a.sort().filter(function(value, index, array) {
            return (index === 0) || (value !== array[index-1]);
        });
    }

This function sorts the argument, and then filters the result to omit any items that are equal to their predecessor.

The keys-based approach is fine, and will have better performance characteristics for large numbers of items (O(n) for inserting n items into a hashtable, compared to O(n log n) for sorting the array). However, this is unlikely to be noticeable on small lists. Moreover, with this version you could modify it to use a different sorting or equality function if necessary; with hash keys you're stuck with JavaScripts notion of key equality.

Answer 4

This should work with anything, not just strings:

export const getUniqueList =  (a: Array<any>) : Array<any> => {

  const set = new Set<any>();

  for(let v of a){
      set.add(v);
  }

  return Array.from(set);

};

the above can just be reduced to:

export const getUniqueValues = (a: Array<any>) => {
   return Array.from(new Set(a));
};

:)

Answer 5

To get unique objects, you can use JSON.stringify and JSON.parse:

const arr = [{test: "a"}, {test: "a"}];
const unique = Array.from(new Set(arr.map(JSON.stringify))).map(JSON.parse);
console.log(unique);

Answer 6

This is an old question, I know. However, it is at the top of some google searches, so I wanted to add that you can combine the answers from @RobHague and @EugeneNaydenov using the following:

function unique(arr) {
  const u = {};
  return arr.filter((v) => {
    return u[v] = !u.hasOwnProperty(v);
  });
};

You can also ignore undefined values (often handy) by adding:

function unique(arr) {
  const u = {};
  return arr.filter((v) => {
    return u[v] = (v !== undefined && !u.hasOwnProperty(v));
  });
};

You can play with this solution here: https://jsfiddle.net/s8d14v5n/

Answer 7

Using Object.keys will give you strings if you put in integer arguments (uniq([1,2,3]) => ['1','2','3']. Here's one with Array.reduce:

function uniq(list) {
    return list.reduce((acc, d) => acc.includes(d) ? acc : acc.concat(d), []);
}

Answer 8

I find the other answers to be rather complicated for no gain that I can see.

We can use the indexOf method of the Array to verify if an item exists in it before pushing:

const duplicated_values = ['one', 'one', 'one', 'one', 'two', 'three', 'three', 'four'];
const unique_list = [];

duplicated_values.forEach(value => {
  if (unique_list.indexOf(value) === -1) {
    unique_list.push(value);
  }
});

console.log(unique_list);

That will work with any type of variable as well, even objects (given the identifier actually reference the same entity, merely equivalent objects are not seen as the same).

Answer 9

what about

    function unique(list) {
      for (i = 0; i<list.length; i++) {
        for (j=i+1; j<list.length; j++) {
          if (list[i] == list[j]) {
            list.splice(j, 1);
          }
        }
      }
    }