我有一组数字，我需要确保它们是唯一的。我在互联网上找到了下面的代码片段，它工作得很好，直到数组中有一个零。我在Stack Overflow上找到了另一个脚本，看起来几乎与它完全一样，但它不会失败。
所以为了帮助我学习，有人能帮我确定原型脚本哪里出错吗？
Array.prototype.getUnique = function() {
var o = {}, a = [], i, e;
for (i = 0; e = this[i]; i++) {o[e] = 1};
for (e in o) {a.push (e)};
return a;
}
重复问题的更多答案：
从JS数组中删除重复值
类似的问题：
获取数组中的所有非唯一值（即：重复/多次出现）
当前回答
在ES6/以后
仅获取唯一值
let a = [
{ id: 1, name: "usman" },
{ id: 2, name: "zia" },
{ id: 3, name: "usman" },
];
const unique = [...new Set(a.map((item) => item.name))];
console.log(unique); // ["usman", "zia"]
获取唯一对象
const myObjArray = [
{ id: 1, name: "usman" },
{ id: 2, name: "zia" },
{ id: 3, name: "usman" },
];
// Creates an array of objects with unique "name" property values.
let uniqueObjArray = [
...new Map(myObjArray.map((item) => [item["name"], item])).values(),
];
console.log("uniqueObjArray", uniqueObjArray);
其他回答
One Liner，纯JavaScript
使用ES6语法
list=list.filter（（x，i，a）=>a.indexOf（x）==i）
x --> item in array
i --> index of item
a --> array reference, (in this case "list")
使用ES5语法
list = list.filter(function (x, i, a) {
return a.indexOf(x) == i;
});
浏览器兼容性：IE9+
还有另一个答案，只是因为我为我的特定用例写了一个答案。我碰巧正在对阵列进行排序，如果我正在排序，我可以使用它来消除重复数据。
注意，我的排序处理我的特定数据类型，您可能需要不同的排序，这取决于您拥有的元素类型。
var sortAndDedup = function(array) {
array.sort(function(a,b){
if(isNaN(a) && isNaN(b)) { return a > b ? 1 : (a < b ? -1 : 0); }
if(isNaN(a)) { return 1; }
if(isNaN(b)) { return -1; }
return a-b;
});
var newArray = [];
var len = array.length;
for(var i=0; i<len; i++){
if(i === 0 || array[i] != array[i-1]){
newArray.push(array[i]);
}
}
};
最简单、最快（在Chrome中）的方法：
Array.prototype.unique = function() {
var a = [];
for (var i=0, l=this.length; i<l; i++)
if (a.indexOf(this[i]) === -1)
a.push(this[i]);
return a;
}
只需遍历数组中的每个项，测试该项是否已经在列表中，如果没有，则推送到返回的数组。
根据JSBench的说法，这个函数是我在任何地方都能找到的最快的函数——尽管可以随意添加自己的函数。
非原型版本：
function uniques(arr) {
var a = [];
for (var i=0, l=arr.length; i<l; i++)
if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
a.push(arr[i]);
return a;
}
排序
当还需要对阵列进行排序时，以下是最快的：
Array.prototype.sortUnique = function() {
this.sort();
var last_i;
for (var i=0;i<this.length;i++)
if ((last_i = this.lastIndexOf(this[i])) !== i)
this.splice(i+1, last_i-i);
return this;
}
或非原型：
function sortUnique(arr) {
arr.sort();
var last_i;
for (var i=0;i<arr.length;i++)
if ((last_i = arr.lastIndexOf(arr[i])) !== i)
arr.splice(i+1, last_i-i);
return arr;
}
在大多数非Chrome浏览器中，这也比上述方法更快。
如前所述，[…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（唯一）；
在其他答案的基础上，这里有另一个变体，它使用可选标志来选择策略（保持第一次出现或保持最后一次出现）：
不扩展Array.prototype
function unique(arr, keepLast) {
return arr.filter(function (value, index, array) {
return keepLast ? array.indexOf(value, index + 1) < 0 : array.indexOf(value) === index;
});
};
// Usage
unique(['a', 1, 2, '1', 1, 3, 2, 6]); // -> ['a', 1, 2, '1', 3, 6]
unique(['a', 1, 2, '1', 1, 3, 2, 6], true); // -> ['a', '1', 1, 3, 2, 6]
扩展Array.prototype
Array.prototype.unique = function (keepLast) {
return this.filter(function (value, index, array) {
return keepLast ? array.indexOf(value, index + 1) < 0 : array.indexOf(value) === index;
});
};
// Usage
['a', 1, 2, '1', 1, 3, 2, 6].unique(); // -> ['a', 1, 2, '1', 3, 6]
['a', 1, 2, '1', 1, 3, 2, 6].unique(true); // -> ['a', '1', 1, 3, 2, 6]
