删除字符串重复项的最简单方法是使用关联数组，然后遍历关联数组以使列表/数组返回。

如下所示：

var toHash = [];
var toList = [];

// add from ur data list to hash
$(data.pointsToList).each(function(index, Element) {
    toHash[Element.nameTo]= Element.nameTo;
});

// now convert hash to array
// don't forget the "hasownproperty" else u will get random results 
for (var key in toHash)  {
    if (toHash.hasOwnProperty(key)) { 
      toList.push(toHash[key]);
   }
}

瞧，现在复制品不见了！

对于希望将具有重复元素的阵列展平为一个唯一阵列的任何人：

function flattenUniq(arrays) {
  var args = Array.prototype.slice.call(arguments);

  var array = [].concat.apply([], args)

  var result = array.reduce(function(prev, curr){
    if (prev.indexOf(curr) < 0) prev.push(curr);
    return prev;
  },[]);

  return result;
}

这里是没有任何特殊库的简单方法，

name_list=[“迈克”、“马特”、“南希”、“亚当”、“珍妮”、“南茜”、“卡尔”]；get_uniq=name_list.filter（函数（val，ind）｛return name_list.indexOf（val）==ind；｝）console.log（“原始名称列表：”+name_list.length，name_list）console.log（“\n唯一名称列表：”+get_uniq.length，get_uniq）

function arrayDuplicateRemove(arr){
    var c = 0;
    var tempArray = [];
    console.log(arr);
    arr.sort();
    console.log(arr);
    for (var i = arr.length - 1; i >= 0; i--) {
        if(arr[i] != tempArray[c-1]){
            tempArray.push(arr[i])
            c++;
        }
    };
    console.log(tempArray);
    tempArray.sort();
    console.log(tempArray);
}

我已经在其他问题上对消除重复进行了详细的比较，但注意到这是真实的地方，我也想在这里分享一下。

我相信这是最好的方法

var-myArray=[100，200，100，100，200，200，200]，reduced=Object.keys（myArray.reduce（（p，c）=>（p[c]=true，p），{}））；console.log（减少）；

好啊尽管这一个是O（n），其他是O（n^2），但我很好奇地看到这个reduce/look up表和filter/indexOf组合之间的基准比较（我选择了非常好的Jetendras实现https://stackoverflow.com/a/37441144/4543207). 我准备了一个100K的项目数组，其中填充了0-9999范围内的随机正整数，并删除了重复项。我重复了10次测试，结果的平均值表明他们在性能上不匹配。

在firefox v47中，reduce和lut:14.85ms vs filter和indexOf:2836ms在铬v51中，reduce和lut:23.90ms vs filter和indexOf:1066ms

好吧，到目前为止还不错。但是，让我们这次在ES6风格中正确地完成它。看起来很酷。。！但到目前为止，它将如何对抗强大的lut解决方案对我来说是一个谜。让我们先看看代码，然后对其进行基准测试。

var-myArray=[100，200，100，100，200，200，200]，reduce=[…myArray.reduce（（p，c）=>p.set（c，true），new Map（））.keys（）]；console.log（减少）；

哇，太短了。。！但表演怎么样。。？它很美。。。由于过滤器/indexOf的重量超过了我们的肩，现在我可以测试范围为0..9999的1M个正整数随机项，以获得10次连续测试的平均值。我可以说这一次是真正的比赛。亲自查看结果：）

var ranar=[]，red1=a=>Object.keys（a.reduce（（p，c）=>（p[c]=true，p），{}）），red2=a=>reduced=[…a.reduce（（p，c）=>p.set（c，true），new Map（））.keys（）]，avg1＝[]，avg2=[]，ts＝0，te＝0，res1＝[]，res2＝[]，计数=10；for（变量i=0；i<count；i++）{ranar=（new Array（1000000）.fill（true））.map（e=>Math.floor（Math.random（）*100000））；ts=performance.now（）；res1=红色1（ranar）；te=performance.now（）；平均推力（te ts）；ts=performance.now（）；res2=red2（ranar）；te=performance.now（）；平均推力（te ts）；}avg1=avg1。减少（（p，c）=>p+c）/计数；avg2=avg2.减少（（p，c）=>p+c）/计数；console.log（“reduce&luttake:”+avg1+“msec”）；console.log（“map&spread take:”+avg2+“msec”）；

你会用哪一个。。？别那么快。。。！不要上当受骗。贴图处于置换状态。现在看。。。在上述所有情况下，我们用范围<n的数字填充一个大小为n的数组。如果我们用随机数0..9999填充大小为100的数组。现在让我们在家看地图游戏。这一次是一个100K项的数组，但随机数范围为0..10M。我们将进行100次连续测试，以平均结果。好的，让我们看看赌注……！<-没有错别字

var ranar=[]，red1=a=>Object.keys（a.reduce（（p，c）=>（p[c]=true，p），{}）），red2=a=>reduced=[…a.reduce（（p，c）=>p.set（c，true），new Map（））.keys（）]，avg1＝[]，avg2=[]，ts＝0，te＝0，res1＝[]，res2＝[]，计数=100；for（变量i=0；i<count；i++）{ranar=（new Array（100000）.fill（true））.map（e=>Math.floor（Math.random（）*1000000））；ts=performance.now（）；res1=红色1（ranar）；te=performance.now（）；平均推力（te ts）；ts=performance.now（）；res2=red2（ranar）；te=performance.now（）；平均推力（te ts）；}avg1=avg1。减少（（p，c）=>p+c）/计数；avg2=avg2.减少（（p，c）=>p+c）/计数；console.log（“reduce&luttake:”+avg1+“msec”）；console.log（“map&spread take:”+avg2+“msec”）；

现在，这是Map（）的惊人回归。。！也许现在，当你想删除重复时，你可以做出更好的决定。

好吧，我们现在都很开心。但主角总是在一些掌声中走到最后。我相信你们中的一些人想知道Set对象会做什么。既然我们对ES6开放，而且我们知道Map是前几场比赛的赢家，那么让我们将Map与Set进行比较作为决赛。这是一场典型的皇家马德里vs巴塞罗那的比赛。。。还是这样？让我们看看谁会赢得el classico：）

var ranar=[]，red1=a=>reduce=[…a.reduce（（p，c）=>p.set（c，true），new Map（））.keys（）]，red2=a=>Array.from（新集合（a）），avg1＝[]，avg2=[]，ts＝0，te＝0，res1＝[]，res2＝[]，计数=100；for（变量i=0；i<count；i++）{ranar=（new Array（100000）.fill（true））.map（e=>Math.floor（Math.random（）*100000））；ts=performance.now（）；res1=红色1（ranar）；te=performance.now（）；平均推力（te ts）；ts=performance.now（）；res2=red2（ranar）；te=performance.now（）；平均推力（te ts）；}avg1=avg1。减少（（p，c）=>p+c）/计数；avg2=avg2.减少（（p，c）=>p+c）/计数；console.log（“map&spread take:”+avg1+“msec”）；console.log（“set&A.from take:”+avg2+“msec”）；

哇！成年男子出乎意料的是，它根本就不是一个古典音乐。更像巴塞罗那FC对阵CA Osasuna：））

厌倦了使用for循环或jQuery的所有糟糕示例。Javascript现在有了完美的工具：排序、映射和减少。

统一减少，同时保持现有订单

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

var uniq = names.reduce(function(a,b){
    if (a.indexOf(b) < 0 ) a.push(b);
    return a;
  },[]);

console.log(uniq, names) // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]

// one liner
return names.reduce(function(a,b){if(a.indexOf(b)<0)a.push(b);return a;},[]);

排序更快的uniq

可能有更快的方法，但这一方法相当不错。

var uniq = names.slice() // slice makes copy of array before sorting it
  .sort(function(a,b){
    return a > b;
  })
  .reduce(function(a,b){
    if (a.slice(-1)[0] !== b) a.push(b); // slice(-1)[0] means last item in array without removing it (like .pop())
    return a;
  },[]); // this empty array becomes the starting value for a

// one liner
return names.slice().sort(function(a,b){return a > b}).reduce(function(a,b){if (a.slice(-1)[0] !== b) a.push(b);return a;},[]);

2015年更新：ES6版本：

在ES6中，您有集合和排列，这使删除所有重复项变得非常容易和高效：

var uniq = [ ...new Set(names) ]; // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]

根据发生情况排序：

有人询问如何根据有多少个唯一名称来排序结果：

var names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']

var uniq = names
  .map((name) => {
    return {count: 1, name: name}
  })
  .reduce((a, b) => {
    a[b.name] = (a[b.name] || 0) + b.count
    return a
  }, {})

var sorted = Object.keys(uniq).sort((a, b) => uniq[a] < uniq[b])

console.log(sorted)