选择这个：

var uniqueArray = duplicateArray.filter(function(elem, pos) {
    return duplicateArray.indexOf(elem) == pos;
}); 

现在uniqueArray不包含重复项。

我知道我有点晚了，但这里有另一个使用jinqJ的选项

参见Fiddle

var result = jinqJs().from(["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]).distinct().select();

另一种不用编写太多代码就可以做到这一点的方法是使用ES5 Object.keys-method：

var arrayWithDuplicates = ['a','b','c','d','a','c'],
    deduper = {};
arrayWithDuplicates.forEach(function (item) {
    deduper[item] = null;
});
var dedupedArray = Object.keys(deduper); // ["a", "b", "c", "d"]

在函数中提取

function removeDuplicates (arr) {
    var deduper = {}
    arr.forEach(function (item) {
        deduper[item] = null;
    });
    return Object.keys(deduper);
}

TL；博士

使用Set构造函数和排列语法：

uniq = [...new Set(array)];

（注意var uniq将是一个数组…new Set（）将其转换为一个集合，但[…]将其再次转换为数组）

---

“聪明”但幼稚的方式

uniqueArray = a.filter(function(item, pos) {
    return a.indexOf(item) == pos;
})

基本上，我们遍历数组，并检查每个元素在数组中的第一个位置是否等于当前位置。显然，对于重复的元素，这两个位置是不同的。

使用过滤器回调的第三个（“this array”）参数，我们可以避免数组变量的关闭：

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｝〕）将只返回〔｛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);
    });
}

排序| uniq

另一个选项是先对数组进行排序，然后删除与前一个元素相等的每个元素：

function uniq(a) {
    return a.sort().filter(function(item, pos, ary) {
        return !pos || item != ary[pos - 1];
    });
}

同样，这不适用于对象（因为排序时所有对象都是相等的）。此外，我们默默地改变了原始数组，这是一个副作用——不好！然而，如果您的输入已经排序，这就是方法（只需从上面删除排序）。

唯一依据。。。

有时需要根据一些标准而不仅仅是相等来取消列表的限定，例如，过滤出不同但共享某些属性的对象。这可以通过传递回调来实现。此“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);
    })
}

一个特别有用的键（）是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]]

如果密钥不是原始的，则必须使用线性搜索：

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中，您可以使用集合：

function uniqBy(a, key) {
    let seen = new Set();
    return a.filter(item => {
        let k = key(item);
        return seen.has(k) ? false : seen.add(k);
    });
}

或地图：

function uniqBy(a, key) {
    return [
        ...new Map(
            a.map(x => [key(x), x])
        ).values()
    ]
}

这两个键也可以使用非基本键。

第一个还是最后一个？

通过键删除对象时，可能需要保留“相等”对象中的第一个或最后一个。

使用上面的Set变量保留第一个，使用Map保留最后一个：

函数uniqByKeepFirst（a，key）{let seen=new Set（）；返回a.filter（项=>{设k=密钥（项）；看见了吗？false：见。添加（k）；});}函数uniqByKeepLast（a，key）{返回[…新建地图(a.map（x=>[键（x），x]）).values（）]}//数据=[{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））

图书馆

下划线和Lo Dash都提供uniq方法。他们的算法基本上类似于上面的第一段，归结起来就是：

var result = [];
a.forEach(function(item) {
     if(result.indexOf(item) < 0) {
         result.push(item);
     }
});

这是二次的，但还有一些很好的附加好处，比如包装原生indexOf，通过键进行uniqify（用他们的话说是迭代）的能力，以及对已排序数组的优化。

如果您正在使用jQuery，并且无法忍受前面没有一美元的任何东西，则情况如下：

  $.uniqArray = function(a) {
        return $.grep(a, function(item, pos) {
            return $.inArray(item, a) === pos;
        });
  }

这也是第一片段的变体。

表演

JavaScript中的函数调用非常昂贵，因此上述解决方案虽然简洁，但效率并不高。为了获得最大的性能，用循环替换过滤器，并消除其他函数调用：

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核心人员做得很好！）

函数uniq（a）{var seen＝｛｝；return a.filter（函数（项）{返回已查看。hasOwnProperty（项）？假：（见[项目]=真）；});}函数uniq_fast（a）{var seen＝｛｝；var out=[]；var len=a.length；变量j=0；对于（var i=0；i<len；i++）{var项目=a[i]；if（参见[项目]！==1）{见[项目]=1；out[j++]=项目；}}返回；}/////变量r=[0,1,2,3,4,5,6,7,8,9]，a＝[]，LEN＝1000，回路=1000；而（LEN-）a=交流电（r）；var d=新日期（）；对于（var i=0；i<回路；i++）uniq（a）；document.write（'<br>uniq，ms/loop:'+（new Date（）-d）/LOOPS）var d=新日期（）；对于（var i=0；i<回路；i++）uniq_fast（a）；document.write（'<br>uniq_fast，ms/loop:'+（new Date（）-d）/LOOPS）

ES6

ES6提供了Set对象，这使事情变得更加简单：

function uniq(a) {
   return Array.from(new Set(a));
}

or

let uniq = a => [...new Set(a)];

注意，与python不同，ES6集合是按插入顺序迭代的，因此这段代码保留了原始数组的顺序。

然而，如果您需要具有唯一元素的数组，为什么不从一开始就使用集合呢？

发电机

可以在相同的基础上构建uniq的“懒惰”、基于生成器的版本：

从参数中获取下一个值如果已经看到了，就跳过它否则，生成它并将其添加到已看到的值集合中

函数*uniqIter（a）{let seen=new Set（）；for（设a的x）{如果（！seed.has（x））{见添加（x）；产量x；}}}//示例：函数*randomsBelow（极限）{而（1）yield Math.floor（Math.random（）*limit）；}//注意randomsBelow是无穷无尽的计数=20；极限=30；for（uniqIter（randomsBelow（limit））的let r）{控制台日志（r）；如果（--count==0）打破}//读者练习：如果我们将“limit”设置为小于“count”会发生什么？为什么

使用jQuery快速而肮脏：

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
var uniqueNames = [];
$.each(names, function(i, el){
    if($.inArray(el, uniqueNames) === -1) uniqueNames.push(el);
});

像这样使用Array.filter（）

var actualArr=[苹果'，苹果'，香蕉'，芒果'，草莓'，香蕉]；console.log（'实际数组：'+actualArr）；var filteredArr=actualArr.filter（函数（项，索引）{if（actualArr.indexOf（item）==索引）退货项目；});console.log（'FilteredArray:'+filtedArr）；

这可以在ES6中缩短到

actualArr.filter((item,index,self) => self.indexOf(item)==index);

下面是Array.filter（）的详细解释