Get items from an array that are ALREADY unique

Question

I tried to phrase my question very carfully because it looks like a duplicate of jQuery function to get all unique elements from an array? and a bunch of other threads. I need to be very clear, I want to get all elements from an array that are not repeated at all. That is, given an array [1,2,3,4,5,1,2,3,5], it should return [4]. In that other thread, I was losing my mind because I didn't understand why they were using the word unique, which means "Being the only one of its kind; unlike anything else." and building functions that return numbers that have been repeated several times, and it was only while asking this question that I came to understand how they interpreted the question. Looking around the net, it appears that that's how everyone is interpreting it.

I feel very close with this code here:

  var myArr = [1,2,3,4,5,1,2,3,5];
  var unique = myArr.filter(function(value, index, self){ 
    return self.indexOf(value) != index;
  });
 console.log(unique);

Which returns an array with each value in the array except ones that do not get repeated. If I could just assign the removed elements to unique, I'd be set, but even reading the documentation on filter I am struggling to understand how it works.

I prefer vanilla js, as I'm coding in FreeCodeCamp's environment and I don't know if I can include libraries.

Answer 1

Close ... sort of ... just check if indexOf is the same as lastIndexOf

var myArr = [1,2,3,4,5,1,2,3,5];
  var unique = myArr.filter(function(value, index, self){ 
    return self.indexOf(value) === self.lastIndexOf(value);
  });
console.log(unique);

Answer 2

You are indeed very close, and @Jaromanda-X has given you the solution in his comment, return self.indexOf(value) === self.lastIndexOf(value);. You would use the line like so:

var myArr = [1,2,3,4,5,1,2,3,5];
  var unique = myArr.filter(function(value, index, self){ 
    return self.indexOf(value) === self.lastIndexOf(value);
  });
console.log(unique);

For reference, .indexOf returns the first index of the value in the array, and .lastIndexOf returns the last index of the value in the array.

Answer 3

Solutions that utilise indexOf will require a linear search for each element, so would have a performance complexity of O(N^2).

Here is a two step solution. It stores a list of numbers and their counts, and then, from this list, find the elements with a count of one.

let myArr = [1,2,3,4,5,1,2,3,5];
let counts = myArr.reduce((ht, v) => { ht[v] = (ht[v] || 0) + 1; return ht;} {});
let unique = Object.keys(counts).filter(k => counts[k] === 1).map(v => parseInt(v, 10));

---

This solution assumes that every item in myArr is a number. If the array was a mix of numbers and strings, and you wanted to preserve the type, you can modify it to this solution (thanks @JaromandaX):

let myArr = [1,2,3,4,5,'apple',1,2,3,5];
let counts = myArr.reduce((ht, v) => {
    ht[v] = ht[v] || {v, count:0};
    ht[v].count +=1;
    return ht;
}, {});
let unique = Object.keys(counts)
                   .filter(k => counts[k].count === 1)
                   .map(k => counts[k].v);

---

But what about an array like [1, 1, 2, "2"]? The above solution derives its key from the string representation of the object, so the number 2 and the string "2" would be seen as equivalent.

The solution to this is to generate the key using a combination of the type and the value.

let myArr = [1,2,3,4,5,'apple',1,"2",3,5];
let counts = myArr.reduce((ht, v) => {
    let k = `${typeof(v)};${v}`;
    ht[k] = ht[k] || {v, count:0};
    ht[k].count +=1;
    return ht;
}, {});
let unique = Object.keys(counts)
                   .filter(k => counts[k].count === 1)
                   .map(k => counts[k].v);