Use reduce for getting the result.

var arr = [["apple","ghana",15],["apple","brazil",16],["orange","nigeria",10],["banana","bangladesh",20],["banana","ghana",6]];

const res = arr.reduce((a, c) => {
	if (!a.find(v => v[0] === c[0])) {
		a.push(c);
	}
	return a;
}, []);

console.log(res);

.as-console-wrapper {
  min-height: 100% !important;
  top: 0;
}

Try the following

function getUniqueValues(array, key) {
var result = new Set();
array.forEach(function(item) {
    if (item.hasOwnProperty(key)) {
        result.add(item[key]);
    }
});
return result;
}

Usage:

var uniqueArr = getUniqueValues(yourArr,keyYouWant)

Reference:Get Unique Values in a MultiDim Array

Good Luck

Quick and dirty solution, assuming the data is small.

On each iteration, convert the row to a string. Use a dictionary to store the string with a value of True, if it is not already in the map. Also, add it to your output array. If it is already in the dictionary, go to the next item.

Example:

var d = {};
var out = [];
for( var i = 0; i < items.length; i++ ) {
    var item = items[i];
    var rep = item.toString();

    if (!d[rep]) {
        d[rep] = true;
        out.push(item);
    }
}

// out has the result

Try this:

var item = collection.filter(function(collect) {
  return collect[0] == sourceId && collect[1] == targetId;
});

Again, like I said in the comments, it would better if you change your data structure to an array of objects with named keys then you can do this much more readable:

return collect.sourceId == sourceId && collect.targetId == targetId;

You can map each inner array to a stringified version of itself using .map(JSON.stringified). Now, using this new array, you can reduce it to an object which contains each stringified array as a key, and keeps the number of occurrences as its value. While reducing, you can check whether or not the object's key has already been set using a[k] = (a[k] || 0)+1. If it has already been set, it will use the current number stored at the key and increment it by 1, if it hasn't already been set it will set it equal to zero, and then increment it by 1 (which acts as the default value for any new keys (i.e newly seen arrays)).

Lastly, you can get the keys from your object which represent each unique array as strings using Object.keys(), and parse each back into a non-stringified array using JSON.parse. You can get the counts from your array by using Object.values() as this will get all the values (ie: the counters) of your reduced object and put them into an array.

See example below:

const arr = [[1,2], [1,2], [1,3], [1,4], [1,4], [1,4]]; 

const arr_str = arr.map(JSON.stringify);
const arr_map = arr_str.reduce((a, k) => (a[k] = (a[k] || 0) + 1, a), {});
const uniqueArrays = Array.from(Object.keys(arr_map), JSON.parse);
const theCount = Object.values(arr_map);

console.log(uniqueArrays);
console.log(theCount);

Here's a much cleaner solution for ES6 that I see isn't included here. It uses the Set and the spread operator: ...

var a = [1, 1, 2];

[... new Set(a)]

Which returns [1, 2]

const arr = [[7,3], [7,3], [3,8], [7,3], [7,3], [1,2]];
    
function multiDimensionalUnique(arr) {
    var uniques = [];
    var itemsFound = {};
    for(var i = 0, l = arr.length; i < l; i++) {
        var stringified = JSON.stringify(arr[i]);
        if(itemsFound[stringified]) { continue; }
        uniques.push(arr[i]);
        itemsFound[stringified] = true;
    }
    return uniques;
}

const uniques = multiDimensionalUnique(arr);
console.log(uniques);

Explaination:

Like you had mentioned, the other question only dealt with single dimension arrays which you can find via indexOf. That makes it easy.

Multidimensional arrays are not so easy, as indexOf doesn't work with finding arrays inside.

The most straightforward way that I could think of was to serialize the array value, and store whether or not it had already been found.
It may be faster to do something like stringified = arr[i][0]+":"+arr[i][1], but then you limit yourself to only two keys.

Looks like you overcomplicated it a bit ;)

function unite() {
    return [].concat.apply([], arguments).filter(function(elem, index, self) {
        return self.indexOf(elem) === index;
    });
}


res = unite([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]);
document.write('<pre>'+JSON.stringify(res));

Explanations

We split the problem into two steps:

• combine arguments into one big array
• remove non-unique elements from this big array

This part handles the first step:

[].concat.apply([], arguments)

The built-in method someArray.concat(array1, array2 etc) appends given arrays to the target. For example,

[1,2,3].concat([4,5],[6],[7,8]) == [1,2,3,4,5,6,7,8]

If our function had fixed arguments, we could call concat directly:

function unite(array1, array2, array3) {
    var combined = [].concat(array1, array2, array3);
    // or
    var combined = array1.concat(array2, array3);

but as we don't know how many args we're going to receive, we have to use apply.

 someFunction.apply(thisObject, [arg1, arg2, etc])

is the same as

 thisObject.someFunction(arg1, arg2, etc)

so the above line

 var combined = [].concat(array1, array2, array3);

can be written as

 var combined = concat.apply([], [array1, array2, array3]);

or simply

 var combined = concat.apply([], arguments);

where arguments is a special array-like object that contains all function arguments (actual parameters).

Actually, last two lines are not going to work, because concat isn't a plain function, it's a method of Array objects and therefore a member of Array.prototype structure. We have to tell the JS engine where to find concat. We can use Array.prototype directly:

 var combined = Array.prototype.concat.apply([], arguments);

or create a new, unrelated, array object and pull concat from there:

 var combined = [].concat.apply([], arguments);

This prototype method is slightly more efficient (since we're not creating a dummy object), but also more verbose.

Anyways, the first step is now complete. To eliminate duplicates, we use the following method:

 combined.filter(function(elem, index) {
     return combined.indexOf(elem) === index;
 })

For explanations and alternatives see this post.

Finally, we get rid of the temporary variable (combined) and chain "combine" and "dedupe" calls together:

return [].concat.apply([], arguments).filter(function(elem, index, self) {
    return self.indexOf(elem) === index;
});

using the 3rd argument ("this array") of filter because we don't have a variable anymore.

Simple, isn't it? ;) Let us know if you have questions.

Finally, a small exercise if you're interested:

Write combine and dedupe as separate functions. Create a function compose that takes two functions a and b and returns a new function that runs these functions in reverse order, so that compose(a,b)(argument) will be the same as b(a(argument)). Replace the above definition of unite with unite = compose(combine, dedupe) and make sure it works exactly the same.