如前所述，[…new Set（value）]是最好的选项，如果您可以使用的话。

否则，这里有一个单行程序，它不会为每个索引迭代数组：

values.sort().filter((val, index, arr) => index === 0 ? true : val !== arr[index - 1]);

这只是将每个值与前面的值进行比较。结果将被排序。

例子：设值=[1，2，3，3，4，5，5，4，4，3，1，1，3，3]；let unique=values.sort（）.filter（（val，index，arr）=>索引==0？真：val！==arr[索引-1]）；console.log（唯一）；

使用JavaScript 1.6/ECMAScript 5，您可以通过以下方式使用Array的本机筛选器方法来获得具有唯一值的数组：

仅函数唯一（值、索引、自身）{return self.indexOf（value）==索引；}//用法示例：var a=['a'，1，'a'，2，'1']；var unique=a.filter（仅唯一）；console.log（唯一）；//[阿'，1，2，'1']

本机方法筛选器将循环遍历数组，并只保留那些传递给定回调函数的条目。

如果给定值是第一个出现，则仅唯一检查。如果没有，它必须是副本，并且不会被复制。

这个解决方案不需要任何额外的库，如jQuery或prototype.js。

它也适用于具有混合值类型的数组。

对于不支持本机方法filter和indexOf的旧浏览器（<ie9），您可以在MDN文档中找到filter和indexOf的解决方法。

如果要保留值的最后一次出现，只需将indexOf替换为lastIndexOf。

使用ES6，这可以缩短为：

//用法示例：var myArray=['a'，1，'a'，2，'1']；var unique=myArray.filter（（v，i，a）=>a.indexOf（v）==i）；console.log（唯一）；//唯一的是['a'，1，2，'1']

感谢卡米洛·马丁的评论提示。

ES6有一个本地对象Set来存储唯一值。要获得具有唯一值的数组，现在可以执行以下操作：

var myArray=['a'，1，'a'，2，'1']；let unique=[…new Set（myArray）]；console.log（唯一）；//唯一的是['a'，1，2，'1']

Set的构造函数接受一个可迭代的对象，如Array，而扩展运算符。。。将集合转换回数组。感谢Lukas Liese的评论提示。

这已经得到了很多回答，但并没有解决我的特殊需求。

许多答案是这样的：

a.filter((item, pos, self) => self.indexOf(item) === pos);

但这对复杂对象的数组不起作用。

假设我们有一个这样的数组：

const a = [
 { age: 4, name: 'fluffy' },
 { age: 5, name: 'spot' },
 { age: 2, name: 'fluffy' },
 { age: 3, name: 'toby' },
];

如果我们想要具有唯一名称的对象，我们应该使用array.prototype.findIndex而不是array.protoype.indexOf：

a.filter((item, pos, self) => self.findIndex(v => v.name === item.name) === pos);

也可以使用jQuery

var a = [1,5,1,6,4,5,2,5,4,3,1,2,6,6,3,3,2,4];

// note: jQuery's filter params are opposite of javascript's native implementation :(
var unique = $.makeArray($(a).filter(function(i,itm){ 
    // note: 'index', not 'indexOf'
    return i == $(a).index(itm);
}));

// unique: [1, 5, 6, 4, 2, 3]

最初的答案是：jQuery函数从数组中获取所有唯一元素？

很多人已经提到使用。。。

[...new Set(arr)];

这是一个很好的解决方案，但我的首选是与.filter一起使用的解决方案。在我看来，filter是获取唯一值的更自然的方法。您可以有效地删除重复项，而从数组中删除元素正是过滤器的作用所在。它还允许您链接.map、.reduce和其他.filter调用。我设计了这个解决方案。。。

const unique = () => {
  let cache;  
  return (elem, index, array) => {
    if (!cache) cache = new Set(array);
    return cache.delete(elem);
  };
};

myArray.filter(unique());

需要注意的是，你需要一个结束，但我认为这是一个值得的权衡。就性能而言，它比我看到的使用.filter的其他解决方案更具性能，但比[…new Set（arr）]性能更差。

另请参阅我的github包

使用One Liner在对象阵列中查找唯一

const uniqueBy = (x,f)=>Object.values(x.reduce((a,b)=>((a[f(b)]=b),a),{}));
// f -> should must return string because it will be use as key

const data = [
  { comment: "abc", forItem: 1, inModule: 1 },
  { comment: "abc", forItem: 1, inModule: 1 },
  { comment: "xyz", forItem: 1, inModule: 2 },
  { comment: "xyz", forItem: 1, inModule: 2 },
];

uniqueBy(data, (x) => x.forItem +'-'+ x.inModule); // find unique by item with module
// output
// [
//   { comment: "abc", forItem: 1, inModule: 1 },
//   { comment: "xyz", forItem: 1, inModule: 2 },
// ];

// can also use for strings and number or other primitive values

uniqueBy([1, 2, 2, 1], (v) => v); // [1, 2]
uniqueBy(["a", "b", "a"], (v) => v); // ['a', 'b']

uniqueBy(
  [
    { id: 1, name: "abc" },
    { id: 2, name: "xyz" },
    { id: 1, name: "abc" },
  ],
  (v) => v.id
);
// output
// [
//   { id: 1, name: "abc" },
//   { id: 2, name: "xyz" },
// ];