在 Javascript 中，如何检查数组是否有重复值？

Question

可能的重复：
在 JavaScript 数组中查找重复值的最简单方法

如何检查数组是否有重复值？

如果数组中的某些元素相同，则返回 true。否则，返回 false。

['hello','goodbye','hey'] //return false because no duplicates exist
['hello','goodbye','hello'] // return true because duplicates exist

请注意，我不关心查找重复项，只想要布尔结果数组是否包含重复项。

Answer 1

为什么使用这种方法：

我认为这是处理多个数组和循环时最好的方法，这个例子非常简单，但在某些情况下，例如迭代多个循环并迭代对象时，是最可靠和最佳的方法。

说明：

在这个例子中，数组被迭代，element与array[i]相同，i是循环当前所在数组的位置，然后函数检查读取数组中的位置初始化为空，如果该元素不在读取数组中，它将返回-1，并且将被推送到读取数组，否则它将返回其位置并且不会被推送，一旦所有元素数组已被迭代，读取的数组将被打印到控制台

let array = [1, 2, 3, 4, 5, 1, 2, 3, 5]
let read = []

array.forEach(element => {
  if (read.indexOf(element) == -1) {
    read.push(element)
    console.log("This is the first time" + element + " appears in the array")
  } else {
    console.log(element + " is already in the array")
  }
})

console.log(read)

Answer 2

使用 Set 的解决方案的一个好处是查找列表中现有项目的 O(1) 性能，而不必循环遍历它。

使用 Some 的解决方案的一个好处是，当尽早发现重复项时会发生短路，因此当条件已满足时，您不必继续评估数组的其余部分。

将两者结合起来的一种解决方案是增量构建一个集合，如果集合中存在当前元素，则提前终止，否则添加它并继续处理下一个元素。

const hasDuplicates = (arr) => {
  let set = new Set()
  return arr.some(el => {
    if (set.has(el)) return true
    set.add(el)
  })
}

hasDuplicates(["a","b","b"]) // true
hasDuplicates(["a","b","c"]) // false

根据JSBench.me，对于各种用例来说应该表现得很好。设置大小方法在没有重复的情况下是最快的，而检查 some + indexOf 在非常早期的重复中是最快的，但是这个解决方案在这两种情况下都表现良好，使其成为一个很好的全面实现。

Answer 3

    this.selectedExam = [];
    // example exam obj: {examId:1, name:'ExamName'}
    onExamSelect(exam: any) {
    if(!this.selectedExam.includes(exam?.name)){ 
      this.selectedExam.push(exam?.name);
    }}

在上面的代码中，我采用了一个数组，并在触发特定函数（onExamSelect）时，我们检查重复项并推送唯一元素。

Answer 4

到 2023 年，这是对对象数组执行此操作的最佳方法，检查严格相等性。 Set 无法做到这一点。

const answerTableRows = [
    { rk: "u", pk: "1", },
    { rk: "u", pk: "2", },
    { rk: "u", pk: "1", }, // get rid of this one
    { rk: "x", pk: "y" },
];
let uniqueAnswerTableRows = answerTableRows.filter((v, i, a) => {
    return a.findIndex(t => (t.rk === v.rk && t.pk === v.pk)) === i;
});
console.log(uniqueAnswerTableRows);
// [ { rk: 'u', pk: '1' }, { rk: 'u', pk: '2' }, { rk: 'x', pk: 'y' } ]

Answer 5

function hasAllUniqueChars( s ){ 
    for(let c=0; c<s.length; c++){
        for(let d=c+1; d<s.length; d++){
            if((s[c]==s[d])){
                return false;
            }
        }
    }
    return true;
}

Answer 6

ES6 的单线解决方案

const arr1 = ['hello','goodbye','hey'] 
const arr2 = ['hello','goodbye','hello'] 

const hasDuplicates = (arr) => arr.length !== new Set(arr).size;
console.log(hasDuplicates(arr1)) //return false because no duplicates exist
console.log(hasDuplicates(arr2)) //return true because duplicates exist

const s1 = ['hello','goodbye','hey'].some((e, i, arr) => arr.indexOf(e) !== i)
const s2 = ['hello','goodbye','hello'].some((e, i, arr) => arr.indexOf(e) !== i);

console.log(s1) //return false because no duplicates exist
console.log(s2) //return true because duplicates exist

Answer 7

您可以使用 SET 删除重复项并进行比较，如果将数组复制到集合中，它将删除所有重复项。然后简单地将数组的长度与集合的大小进行比较。

function hasDuplicates(a) {

  const noDups = new Set(a);

  return a.length !== noDups.size;
}

Answer 8

另一种方法（也适用于数组中的对象/数组元素¹）可能是²：

function chkDuplicates(arr,justCheck){
  var len = arr.length, tmp = {}, arrtmp = arr.slice(), dupes = [];
  arrtmp.sort();
  while(len--){
   var val = arrtmp[len];
   if (/nul|nan|infini/i.test(String(val))){
     val = String(val);
    }
    if (tmp[JSON.stringify(val)]){
       if (justCheck) {return true;}
       dupes.push(val);
    }
    tmp[JSON.stringify(val)] = true;
  }
  return justCheck ? false : dupes.length ? dupes : null;
}
//usages
chkDuplicates([1,2,3,4,5],true);                           //=> false
chkDuplicates([1,2,3,4,5,9,10,5,1,2],true);                //=> true
chkDuplicates([{a:1,b:2},1,2,3,4,{a:1,b:2},[1,2,3]],true); //=> true
chkDuplicates([null,1,2,3,4,{a:1,b:2},NaN],true);          //=> false
chkDuplicates([1,2,3,4,5,1,2]);                            //=> [1,2]
chkDuplicates([1,2,3,4,5]);                                //=> null

另请参阅...

¹ 需要支持 JSON 的浏览器，或一个 JSON 库 如果没有。
² edit: 函数现在可用于简单检查或返回重复值数组

Answer 9

您可以利用 indexOf 和 lastIndexOf。如果两个索引不相同，则有重复。

function containsDuplicates(a) {
  for (let i = 0; i < a.length; i++) {
    if (a.indexOf(a[i]) !== a.lastIndexOf(a[i])) {
      return true
    }
  }
  return false
}

Answer 10

如果要处理简单值，则可以使用array.some（）和indexof（）

例如，让我们说vals is [“ b”，“ a”，“ a”，“ c”]

const allUnique = !vals.some((v, i) => vals.indexOf(v) < i);

如果任何任何表达式返回true，则会返回true。在这里，我们将迭代值（从索引0），然后调用索引（），该索引将返回给定项目的第一次出现的索引（或在数组中不在数字中）。如果它的ID较小，则在当前的ID之前必须至少有一个相同的值。因此，迭代3将返回true，因为“ a”（在索引2）首先在索引1上找到。

Answer 11

很简单，你可以使用 Array.prototype.every 函数

function isUnique(arr) {
  const isAllUniqueItems = input.every((value, index, arr) => {
    return arr.indexOf(value) === index; //check if any duplicate value is in other index
  });

  return isAllUniqueItems;
}

Answer 12

如果您有 ES2015 环境（截至撰写本文时：io.js、IE11、Chrome、Firefox、WebKit nightly），那么以下内容将起作用，并且速度会很快（即 O(n)）：

function hasDuplicates(array) {
    return (new Set(array)).size !== array.length;
}

---

如果您只需要字符串数组中的值，以下内容将起作用：

function hasDuplicates(array) {
    var valuesSoFar = Object.create(null);
    for (var i = 0; i < array.length; ++i) {
        var value = array[i];
        if (value in valuesSoFar) {
            return true;
        }
        valuesSoFar[value] = true;
    }
    return false;
}

我们使用“哈希表”valuesSoFar，其键是迄今为止我们在数组中看到的值。我们使用 in 进行查找，看看该值是否已经被发现；如果是这样，我们跳出循环并返回true。

---

如果您需要一个不仅仅适用于字符串值的函数，那么以下函数也可以，但性能不高；它是 O(n²) 而不是 O(n)。

function hasDuplicates(array) {
    var valuesSoFar = [];
    for (var i = 0; i < array.length; ++i) {
        var value = array[i];
        if (valuesSoFar.indexOf(value) !== -1) {
            return true;
        }
        valuesSoFar.push(value);
    }
    return false;
}

区别在于，我们使用数组而不是 valuesSoFar 的哈希表，因为 JavaScript“哈希表”（即对象）只有字符串键。这意味着我们失去了 in 的 O(1) 查找时间，而是获得了 indexOf 的 O(n) 查找时间。