长话短说
使用Set构造函数和展开语法：
uniq = [...new Set(array)];
（请注意 varuniq将是一个数组... new Set()将其转换为集合，但 [...] 再次将其转换回数组）
“聪明”但天真的方式
uniqueArray = a.filter(function(item, pos) {
return a.indexOf(item) == pos;
})
基本上，我们迭代数组，并针对每个元素检查该元素在数组中的第一个位置是否等于当前位置。显然，对于重复元素来说，这两个位置是不同的。
使用过滤器回调的第三个（“这个数组”）参数，我们可以避免数组变量的闭包：
uniqueArray = a.filter(function(item, pos, self) {
return self.indexOf(item) == pos;
})
尽管简洁，但该算法对于大型数组（二次时间）并不是特别有效。
哈希表来救援
function uniq(a) {
var seen = {};
return a.filter(function(item) {
return seen.hasOwnProperty(item) ? false : (seen[item] = true);
});
}
通常是这样做的。这个想法是将每个元素放入哈希表中，然后立即检查它是否存在。这给了我们线性时间，但至少有两个缺点：
- 由于哈希键只能是 JavaScript 中的字符串或符号，因此此代码不区分数字和“数字字符串”。也就是说，
uniq([1,"1"])只会返回[1]
- 出于同样的原因，所有对象都将被视为相等：
uniq([{foo:1},{foo:2}])将返回 just [{foo:1}]。
也就是说，如果您的数组仅包含基元并且您不关心类型（例如它始终是数字），则此解决方案是最佳的。
来自两个世界的最好的
通用解决方案结合了这两种方法：它对基元使用哈希查找，对对象使用线性搜索。
function uniq(a) {
var prims = {"boolean":{}, "number":{}, "string":{}}, objs = [];
return a.filter(function(item) {
var type = typeof item;
if(type in prims)
return prims[type].hasOwnProperty(item) ? false : (prims[type][item] = true);
else
return objs.indexOf(item) >= 0 ? false : objs.push(item);
});
}
排序|独特的
另一种选择是先对数组进行排序，然后删除与前一个元素相等的每个元素：
function uniq(a) {
return a.sort().filter(function(item, pos, ary) {
return !pos || item != ary[pos - 1];
});
}
同样，这不适用于对象（因为所有对象都相等sort）。此外，我们默默地更改原始数组作为副作用 - 不好！但是，如果您的输入已经排序，那么这就是要走的路（只需sort从上面删除）。
独特之处在于...
有时，需要基于除相等之外的某些标准来唯一化列表，例如，过滤掉不同但共享某些属性的对象。这可以通过传递回调来优雅地完成。此“key”回调应用于每个元素，并且具有相同“key”的元素将被删除。由于key预计返回一个原语，因此哈希表在这里可以正常工作：
function uniqBy(a, key) {
var seen = {};
return a.filter(function(item) {
var k = key(item);
return seen.hasOwnProperty(k) ? false : (seen[k] = true);
})
}
一个特别有用的方法key()是JSON.stringify删除物理上不同但“看起来”相同的对象：
a = [[1,2,3], [4,5,6], [1,2,3]]
b = uniqBy(a, JSON.stringify)
console.log(b) // [[1,2,3], [4,5,6]]
如果key不是原始的，则必须诉诸线性搜索：
function uniqBy(a, key) {
var index = [];
return a.filter(function (item) {
var k = key(item);
return index.indexOf(k) >= 0 ? false : index.push(k);
});
}
在 ES6 中你可以使用Set：
function uniqBy(a, key) {
let seen = new Set();
return a.filter(item => {
let k = key(item);
return seen.has(k) ? false : seen.add(k);
});
}
或Map：
function uniqBy(a, key) {
return [
...new Map(
a.map(x => [key(x), x])
).values()
]
}
它们都可以使用非原始键。
第一个还是最后一个？
当通过键删除对象时，您可能希望保留第一个“相等”对象或最后一个对象。
使用Set上面的变体保留第一个，使用Map保留最后一个：
function uniqByKeepFirst(a, key) {
let seen = new Set();
return a.filter(item => {
let k = key(item);
return seen.has(k) ? false : seen.add(k);
});
}
function uniqByKeepLast(a, key) {
return [
...new Map(
a.map(x => [key(x), x])
).values()
]
}
//
data = [
{a:1, u:1},
{a:2, u:2},
{a:3, u:3},
{a:4, u:1},
{a:5, u:2},
{a:6, u:3},
];
console.log(uniqByKeepFirst(data, it => it.u))
console.log(uniqByKeepLast(data, it => it.u))
运行代码片段Hide results
展开片段
图书馆
underscore和Lo-Dash都提供了uniq方法。他们的算法基本上类似于上面的第一个片段，归结为：
var result = [];
a.forEach(function(item) {
if(result.indexOf(item) < 0) {
result.push(item);
}
});
这是二次的，但还有一些额外的好处，例如包装 native indexOf、通过键进行统一的能力（iteratee用他们的说法）以及对已排序数组的优化。
如果你正在使用 jQuery 并且不能忍受没有一美元的任何东西，它会像这样：
$.uniqArray = function(a) {
return $.grep(a, function(item, pos) {
return $.inArray(item, a) === pos;
});
}
这又是第一个片段的变体。
表现
JavaScript 中函数调用的开销很大，因此上述解决方案虽然简洁，但效率并不是特别高。为了获得最佳性能，请替换filter为循环并摆脱其他函数调用：
function uniq_fast(a) {
var seen = {};
var out = [];
var len = a.length;
var j = 0;
for(var i = 0; i < len; i++) {
var item = a[i];
if(seen[item] !== 1) {
seen[item] = 1;
out[j++] = item;
}
}
return out;
}
这段丑陋的代码与上面的代码片段 #3 的作用相同，但速度快了一个数量级（截至 2017 年，速度只有两倍 - JS 核心人员做得很好！）
显示代码片段
function uniq(a) {
var seen = {};
return a.filter(function(item) {
return seen.hasOwnProperty(item) ? false : (seen[item] = true);
});
}
function uniq_fast(a) {
var seen = {};
var out = [];
var len = a.length;
var j = 0;
for(var i = 0; i < len; i++) {
var item = a[i];
if(seen[item] !== 1) {
seen[item] = 1;
out[j++] = item;
}
}
return out;
}
/////
var r = [0,1,2,3,4,5,6,7,8,9],
a = [],
LEN = 1000,
LOOPS = 1000;
while(LEN--)
a = a.concat(r);
var d = new Date();
for(var i = 0; i < LOOPS; i++)
uniq(a);
document.write('<br>uniq, ms/loop: ' + (new Date() - d)/LOOPS)
var d = new Date();
for(var i = 0; i < LOOPS; i++)
uniq_fast(a);
document.write('<br>uniq_fast, ms/loop: ' + (new Date() - d)/LOOPS)
Run code snippetHide results
Expand snippet
ES6
ES6 提供了Set对象，这使得事情变得更加容易：
function uniq(a) {
return Array.from(new Set(a));
}
或者
let uniq = a => [...new Set(a)];
请注意，与 python 不同，ES6 集合按插入顺序迭代，因此此代码保留原始数组的顺序。
但是，如果您需要一个具有唯一元素的数组，为什么不从一开始就使用集合呢？
发电机
uniq可以在相同的基础上构建“惰性”、基于生成器的版本：
-
从参数中获取下一个值
-
如果已经看过，请跳过
-
否则，产生它并将其添加到已经看到的值集中
function* uniqIter(a) {
let seen = new Set();
for (let x of a) {
if (!seen.has(x)) {
seen.add(x);
yield x;
}
}
}
// example:
function* randomsBelow(limit) {
while (1)
yield Math.floor(Math.random() * limit);
}
// note that randomsBelow is endless
count = 20;
limit = 30;
for (let r of uniqIter(randomsBelow(limit))) {
console.log(r);
if (--count === 0)
break
}
// exercise for the reader: what happens if we set limit less than count and why
运行代码片段Hide results
展开片段
