Javascript 确定数组是否包含重复值

我想扫描一个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

---

如何编写此方法？

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

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

功能检查ArrayisUnique（arr）{
var myArray=arr.sort（）；
对于（var i=0；i

试试这个：-

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))

您可以这样尝试：

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

函数唯一数组（arr）{
var hash={}，result=[]；
对于（变量i=0，l=arr.length；i

我想你可以试试

下划线js

，一个强大的javascript库

使用下划线的示例

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

如果需要检查所有元素都是唯一的，那么下面就可以了
我的数组1=[11,20,3]
my_array2=[11,11,11]
var sorted1=my_array1.sort（）；
var sorted2=my_array2.sort（）；
如果（sorted1[0]==sorted1[sorted1.长度-1]）
警惕（“一切都一样”）；
if（sorted2[0]==sorted2[sorted2.length-1]）
警惕（“一切都一样”）；

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

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

函数是唯一的（arr）{
对于（变量i=0；i

---

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

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

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）以使循环短路。这将确保在满足条件后立即停止处理

如果我们把它作为一个方法公开在一个数组实例上，会更好。 所以我们可以这样做

[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

函数包含两个副本（arr）{
var-seen={}；
var duplicate=false；
对于（变量i=0；i


最佳情况：
O（1）
时间和空间-第二个元素是重复的

平均/最坏情况：
O（n）
时间和空间-无重复项，或重复项位于中间

这里的许多答案似乎依赖于一些复杂的数组方法，这些方法本质上是迭代的，通常不适合这个相当简单的任务。从算法上讲，这个问题可以在
O（n）
时间内解决，但是
for
循环中
/
过滤器
/
映射（或类似的数组方法）的
索引的任何嵌套都意味着计算时间（最多）将随着数组大小的平方增长而不是线性增长。这在时间上是低效的

现在，一般来说，除非您已经确定这是应用程序中的性能瓶颈，否则微观优化实际上是不必要的。但在我看来，这种算法是您在开始编码之前设计（伪代码）并匹配应用程序需求的。如果您的阵列中有一个巨大的数据集，您可能会感激不必多次查看它来获得答案。当然，这里需要注意的是，您正在用时间复杂性换取空间复杂性，因为我的解决方案需要
O（n）
空间来缓存以前看到的值。
我刚刚给出了这个答案。
我正在准备面试。
我认为这是坚如磐石

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()

然后我检查至少一个项，该项是否等于数组中的下一项

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

似乎还有很多其他问题可以帮助你，你有没有搜索过其他问题？这是一个很好的解决方案。用最后一个索引检查第一个索引是有效的，尽管FYI
.sort（）
不会返回新数组，它只是修改正在排序的数组/对象。现在我想起来，您甚至不需要对其进行排序以获得相同的正确结果。为什么需要事先对数组进行排序？
？true:false
说真的。标记为jQuery的问题没有下划线。是的，我明白了。但我认为这也是一个为用户提供的解决方案。谢谢你的评论。看到答案用大O表示总是很棒的：实际上，在最坏的情况下，这将是
O（n^2）
。假设
indexOf
是
O（1）
，但想想它在做什么，它在整个数组（大小
n
）中迭代搜索匹配项。虽然你看不到循环，但它实际上仍然是一个嵌套循环。我确实喜欢跟踪地图中迄今为止看到的值的方法，但这并不能真正解决OP的问题。这将获取一个数组并返回一个仅包含唯一值的新数组。问题是请求一个返回布尔值的方法，指示给定数组是否包含重复项。要扫描JS数组并确定所有元素是否唯一，或者数组是否包含重复项，我们不需要循环。我们可以对数组进行排序，并检查数组的第一个和最后一个元素的马赫数……这不是最好的way@timus2001：谢谢。我不认为这是最好的选择。但只是把它作为alt
r.slice().sort()

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