这里的许多答案可能对初学者没有帮助。如果数组的重复数据消除很困难，他们真的会知道原型链，甚至jQuery吗？

在现代浏览器中，一个干净而简单的解决方案是将数据存储在一个集合中，该集合被设计为一个唯一值列表。

const cars=[“沃尔沃”、“吉普”、“沃尔沃”，“林肯”、“林肯”和“福特”]；constuniqueCars=Array.from（新集合（cars））；console.log（uniqueCars）；

Array.from用于将Set转换回Array，以便您可以轻松访问数组所具有的所有很棒的方法（功能）。同样的事情还有其他方法。但您可能根本不需要Array.from，因为Sets有很多有用的功能，比如forEach。

如果您需要支持旧的Internet Explorer，因此无法使用Set，那么一种简单的方法是将项目复制到新阵列中，同时预先检查它们是否已在新阵列中。

// Create a list of cars, with duplicates.
var cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
// Create a list of unique cars, to put a car in if we haven't already.
var uniqueCars = [];

// Go through each car, one at a time.
cars.forEach(function (car) {
    // The code within the following block runs only if the
    // current car does NOT exist in the uniqueCars list
    // - a.k.a. prevent duplicates
    if (uniqueCars.indexOf(car) === -1) {
        // Since we now know we haven't seen this car before,
        // copy it to the end of the uniqueCars list.
        uniqueCars.push(car);
    }
});

为了使其立即可重用，让我们将其放在函数中。

function deduplicate(data) {
    if (data.length > 0) {
        var result = [];

        data.forEach(function (elem) {
            if (result.indexOf(elem) === -1) {
                result.push(elem);
            }
        });

        return result;
    }
}

所以为了消除重复，我们现在就这样做。

var uniqueCars = deduplicate(cars);

当函数完成时，重复数据消除（cars）部分将成为我们命名为result的部分。

只需将您喜欢的任何数组的名称传递给它即可。

过滤掉未定义的值和空值，因为大多数时候不需要它们。

const uniques = myArray.filter(e => e).filter((e, i, a) => a.indexOf(e) === i);

or

const uniques = [...new Set(myArray.filter(e => e))];

我不知道为什么加布里埃尔·西尔韦拉会这样写函数，但一种更简单的形式对我同样适用，而且没有缩小：

Array.prototype.unique = function() {
  return this.filter(function(value, index, array) {
    return array.indexOf(value, index + 1) < 0;
  });
};

或在CoffeeScript中：

Array.prototype.unique = ->
  this.filter( (value, index, array) ->
    array.indexOf(value, index + 1) < 0
  )

要删除重复项，可能有两种情况。首先，所有数据都不是对象，其次所有数据都是对象。

如果所有数据都是任何类型的原始数据类型，如int、float、string等，那么您可以遵循以下一种

const uniqueArray = [...new Set(oldArray)]

但假设您的数组包含以下JS对象

{
    id: 1,
    name: 'rony',
    email: 'rony@example.com'
}

然后，要获取所有唯一的对象，可以执行以下操作

let uniqueIds = [];
const uniqueUsers = oldArray.filter(item => {
    if(uniqueIds.includes(item.id)){
        return false;
    }else{
        uniqueIds.push(item.id);
        return true;
    }
})

您也可以使用此方法使任何类型的数组成为唯一的。只需将跟踪键保留在uniqueIds数组上。

对我来说，这是最简单的解决方案

//检查数组是否相等的方法常量a=['a'，'B'，'C'].sort（）.toString（）常量b=['A'，'C'，'b'].sort（）.toString（）console.log（a===b）；//真的//测试用例常量数据=[｛组：“A”，名称：“SD”｝，｛组：“B”，名称：“FI”｝，｛组：“A”，名称：“SD”｝，｛组：“B”，名称：“CO”｝];//返回一个不带重复定位的新数组函数唯一（数据）{return data.reduce（函数（累加器，currentValue）{//转换为字符串以检查它们是否为相同的值。const currentKeys=对象.keys（currentValue）.sort（）.toString（）；const currentValues=对象.values（currentValue）.sort（）.toString（）；let hasObject=falsefor（累加器的常量对象）{//将键和值转换为字符串，以便我们可以//看看它们是否与当前值相等constkeys=对象.keys（obj）.sort（）.toString（）；const values=Object.values（obj）.sort（）.toString（）；//检查键和值是否相等if（keys==currentKeys&&values==currentValues）{hasObject=真}}//如果对象不存在，则推送该对象。if（！hasObject）{累加器推力（currentValue）}回流蓄能器}, []);}//运行测试用例console.log（唯一（数据））；//[｛组：“A”，名称：“SD”｝，｛组为“B”，名称为“FI”｝、｛组“B”、名称为“CO”｝]

我查看了Joeytje50在jsperf上的代码，他比较了许多替代方案。他的代码有很多小错误，这对性能和正确性产生了影响。

更重要的是，他正在一个非常小的阵列上进行测试。我用1000个整数组成了一个数组。每个整数是0到1000之间的随机整数的100倍。这使得平均约1000/e=368个重复。结果在jsperf。

这是一个可能需要效率的更现实的场景。这些变化使声明发生了戏剧性的变化（特别是被吹捧为最快的代码远没有快到哪里去）。明显的赢家是使用哈希技术的地方，最好的是

Array.prototype.getUnique3 = function(){
   var u = Object.create(null), a = [];
   for(var i = 0, l = this.length; i < l; ++i){
      if(this[i] in u) continue;
      a.push(this[i]);
      u[this[i]] = 1;
   }
   return a.length;
}