我有一组数字,我需要确保它们是唯一的。我在互联网上找到了下面的代码片段,它工作得很好,直到数组中有一个零。我在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数组中删除重复值

类似的问题:

获取数组中的所有非唯一值(即:重复/多次出现)


当前回答

我将所有答案分成4种可能的解决方案:

使用对象{}防止重复使用助手数组[]使用筛选器+indexOf奖金ES6设置方法。

以下是答案中的示例代码:

使用对象{}防止重复

function uniqueArray1( ar ) {
  var j = {};

  ar.forEach( function(v) {
    j[v+ '::' + typeof v] = v;
  });

  return Object.keys(j).map(function(v){
    return j[v];
  });
} 

使用助手数组[]

function uniqueArray2(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;
}

使用筛选器+indexOf

function uniqueArray3(a) {
  function onlyUnique(value, index, self) { 
      return self.indexOf(value) === index;
  }

  // usage
  var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

  return unique;
}

使用ES6[…新集合(a)]

function uniqueArray4(a) {
  return [...new Set(a)];
}

我想知道哪一个更快。我已经制作了测试功能的GoogleSheet样本。注意:ECMA 6在Google Sheets中不可用,所以我无法测试它。

以下是测试结果:

我希望看到使用对象{}的代码将获胜,因为它使用哈希。因此,我很高兴测试在Chrome和IE中显示了该算法的最佳结果。感谢@rab的代码。

2020年更新

启用谷歌脚本的ES6引擎。现在我用Sets测试了最后一段代码,它看起来比对象方法更快。

其他回答

在其他答案的基础上,这里有另一个变体,它使用可选标志来选择策略(保持第一次出现或保持最后一次出现):

不扩展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]

如果您对额外的依赖关系感到满意,或者您的代码库中已经有一个库,那么可以使用LoDash(或Undercore)从阵列中删除重复项。

用法

如果您的代码库中还没有它,请使用npm安装它:

npm install lodash

然后按如下方式使用:

import _ from 'lodash';
let idArray = _.uniq ([
    1,
    2,
    3,
    3,
    3
]);
console.dir(idArray);

输出:

[ 1, 2, 3 ]

还有另一个答案,只是因为我为我的特定用例写了一个答案。我碰巧正在对阵列进行排序,如果我正在排序,我可以使用它来消除重复数据。

注意,我的排序处理我的特定数据类型,您可能需要不同的排序,这取决于您拥有的元素类型。

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]);
    }
  }
};

重复数据消除通常需要给定类型的相等运算符。然而,使用eq函数会阻止我们以有效的方式使用Set来确定重复项,因为Set返回到==。如您所知,==不适用于引用类型。所以,如果被卡住了,我们会很好,对吧?

解决方法是简单地使用一个转换器函数,它允许我们将一个(引用)类型转换为我们可以使用Set实际查找的类型。例如,如果数据结构不包含任何函数,我们可以使用哈希函数或JSON.stringify数据结构。

通常我们只需要访问一个属性,然后我们就可以比较它而不是Object的引用。

以下是满足这些要求的两个组合子:

常量重复数据消除On=k=>xs=>{const s=new Set();返回xs.filter(o=>s有(o[k])? 无效的:(s.add(o[k]),o[k]]);};常量重复数据消除By=f=>xs=>{const s=new Set();返回xs.filter(x=>{常量r=f(x);返回s.has(r)? 无效的:(s.add(r),x);});};const xs=[{foo:“a”},{foo:“b”};控制台日志(重复数据删除打开(“foo”)(xs));//〔{foo:“a”},{foo:“b”}、{foo:“a”}和{foo:“c”}〕控制台日志(重复数据删除方式(o=>o.foo.toLowerCase())(xs));//〔{foo:“a”}、{foo:“b”},{foo:“c”}〕

使用这些组合器,我们可以非常灵活地处理各种重复数据消除问题。这不是禁食的方法,而是最具表现力和通用性的方法。

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

如果所有数据都是任何类型的原始数据类型,如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数组上。