Question

我想扫描JS数组并确定所有元素是否唯一，或者数组是否包含重复项。

示例：

my_array1 = [1, 2, 3] 
my_array2 = [1, 1, 1]

我想得到这样的结果：

my_array1 must be return true, because this array element is unique
and array2 must be return false, because this array element is not unique

我该如何编写这种方法？

Answer 1

首先对数组进行排序，然后进行简单的比较循环。

function checkIfArrayIsUnique(arr)  {
   var myArray = arr.sort();

    for (var i = 0; i < myArray.length; i++) {
        if (myArray.indexOf(myArray[i]) !== myArray.lastIndexOf(myArray[i])) { 
            return false; 
        } 
    } 

    return true;
}

Answer 2

试试这个： -

var my_array1 = [1, 2, 3] 
var my_array2 = [1, 1, 1]


function isUnique(obj)
{
   var unique=obj.filter(function(itm,i,a){
      return i==a.indexOf(itm);
   });   
   return unique.length == obj.length;  
 }


 alert(isUnique(my_array1))
 alert(isUnique(my_array2))

Demo

Answer 3

您可以尝试这样：

function uniqueArray(arr) {
    var hash = {}, result = [];
    for ( var i = 0, l = arr.length; i < l; ++i ) {
        if ( !hash.hasOwnProperty(arr[i]) ) { 
            hash[ arr[i] ] = true;
            result.push(arr[i]);
        }
    }
    return result;
}

Answer 4

如果你想检查唯一性你可以也这样做。如评论所述，我没有断言这是唯一最好的选择。下面有一些很好的答案。

var arr = [2,3,4,6,7,8,9];
var uniq = []; // we will use this to store the unique numbers found
               // in the process for doing the comparison

var result = arr.slice(0).every(function(item, index, array){
  if(uniq.indexOf(item) > -1){
    // short circuit the loop
    array.length=0; //(B)
    return false;
  }else{
    uniq.push(item);
    return true;
  }
});

result --> true

arr.slice(0)创建一个数组的临时副本，在其上进行实际处理。这是因为当满足唯一性标准时，我清除数组（B）以使循环短路。这将确保一旦符合标准，处理就会停止。

如果我们将其作为Array实例上的方法公开，那将会更好。所以我们可以做这样的事情[1,2,3,5,7].isUnique();

添加以下代码段，您就可以开始了

Array.prototype.isUnique = function() {
    var uniq = [];
    var result = this.slice(0).every(function(item, index, arr) {
        if (uniq.indexOf(item) > -1) {
            arr.length = 0;
            return false;
        } else {
            uniq.push(item);
            return true;
        }
    });
    return result;
};

arr.isUnique() --> true

DEMO

Answer 5

我认为您可以尝试使用强大的JavaScript库Underscore js

使用下划线

的方法示例

function checkUniqueArr(arr){
   var unique_arr = _.uniq(arr);
   return arr.length == unique_arr.length;
}

Answer 6

测试唯一性的最有效方法是：

function isUnique(arr) {
  for(var i = 0; i < arr.length; i++) {
    if (arr.indexOf(arr[i]) != i) return false;
  }
  return true;
}

在最坏的情况下，这是O(n2)。在大多数情况下，它不需要完成对非唯一数组的扫描。

Answer 7

function containsDuplicates(arr) {
    var seen = {};
    var duplicate = false;

    for (var i = 0; i < arr.length; i++) {
        if (seen[arr[i]]) {
            duplicate = true;
            break;
        }
        seen[arr[i]] = true;
    }

    return duplicate;
}

jsFiddle

最佳案例：O(1)时间和空间 - 第二个元素是副本
平均/最差情况：O(n)时间和空间 - 没有重复，或副本位于中间

这里的许多答案似乎都依赖于数组方法的一些复杂的散布，这些方法本质上是迭代的，并且通常似乎不适合这个相当简单的任务。从算法上讲，这个问题可以在O(n)时间内解决，但在indexOf循环中filter / map / for（或类似的数组方法）的任何嵌套都可以解决意味着您的计算时间将与阵列大小呈二次方（而不是线性）。这在时间上是低效的。

现在，一般情况下，除非您已将此确定为应用程序中的性能瓶颈，否则实际上不需要进行微优化。但是在我看来，这种算法是你设计的（伪代码）并且在你开始编码之前与你的应用程序的需求相匹配。如果你的阵列中有一个巨大的数据集，你可能会欣赏它不需要多次查看它来得到你的答案。当然，这里需要注意的是，由于我的解决方案需要O(n)空间来缓存以前看到的值，因此您需要交换空间复杂度的时间复杂度。

Answer 8

If you need to check all element are unique then following will do the trick

<script>
my_array1 = [11, 20, 3] 
my_array2 = [11, 11, 11]
var sorted1= my_array1.sort();
var sorted2= my_array2.sort();
if(sorted1[0]==sorted1[sorted1.length-1])
    alert('all same');
if(sorted2[0]==sorted2[sorted2.length-1])
    alert('all same');

</script>

Answer 9

我刚才想出了这个答案。我准备面试了。我认为这是坚如磐石的。

let r  = [1,9,2,3,8];
let r2 = [9,3,6,3,8];

let isThereDuplicates= r.slice().sort().some((item,index,ar)=>(item ===ar[index+1]));
console.log('r is: ',isThereDuplicates) // -> false. All numbers are unique

isThereDuplicates=  r2.slice().sort().some((item,index,ar)=>(item ===ar[index+1]));
console.log('r2 is: ',isThereDuplicates) //->true. 3 is duplicated

我首先进行切片和排序，而不改变原始数组。

r.slice().sort()

然后我检查至少有一个项目，item等于数组上的下一个项目。

.some((item,index,array)=>
    item === array[index+1]
);

确定数组是否包含重复值

9 个答案: