Question

var arr = ['test0','test2','test0'];

如上所述，有两个相同的条目，其值为“test0”，如何最有效地检查？

Answer 1

如果对数组进行排序，则重复数据彼此相邻，以便于查找：

arr.sort();
var last = arr[0];
for (var i=1; i<arr.length; i++) {
   if (arr[i] == last) alert('Duplicate : '+last);
   last = arr[i];
}

Answer 2

这将在任何阵列上完成工作，并且可能对处理一般情况（在任何可能的数组中找到重复）进行尽可能优化。对于更具体的情况（例如，只包含字符串的数组），您可以做得更好。

function hasDuplicate(arr) {
    var i = arr.length, j, val;

    while (i--) {
        val = arr[i];
        j = i;
        while (j--) {
            if (arr[j] === val) {
                return true;
            }
        }
    }
    return false;
}

Answer 3

这里有很多答案，但并非所有人都“感觉”很好......所以我会戴上帽子。

如果您使用lodash：

function containsDuplicates(array) {
  return _.uniq(array).length !== array.length; 
}

如果你可以使用ES6套装，它只会变成：

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

使用vanilla javascript：

function containsDuplicates(array) {
  return array
    .sort()
    .some(function (item, i, items) {
      return item === items[i + 1]
    })
}

但是，有时您可能想要检查某个字段上的项目是否重复。

这就是我处理的方式：

containsDuplicates([{country: 'AU'}, {country: 'UK'}, {country: 'AU'}], 'country')

function containsDuplicates(array, attribute) {
  return array
    .map(function (item) { return item[attribute] })
    .sort()
    .some(function (item, i, items) {
      return item === items[i + 1]
    })
}

Answer 4

找到第一个副本时循环停止：

function has_duplicates(arr) {

    var x = {}, len = arr.length;
    for (var i = 0; i < len; i++) {
        if (x[arr[i]]) {
             return true;
        }
        x[arr[i]] = true;
    }
    return false;

}

编辑（修复'toString'问题）：

function has_duplicates(arr) {

    var x = {}, len = arr.length;
    for (var i = 0; i < len; i++) {
        if (x[arr[i]] === true) {
             return true;
        }
        x[arr[i]] = true;
    }
    return false;

}

这将纠正案例has_duplicates（['toString']）;等。

Answer 5

    var index = myArray.indexOf(strElement);
    if (index < 0) {
        myArray.push(strElement);
        console.log("Added Into Array" + strElement);
    } else {
        console.log("Already Exists at " + index);
    }

Answer 6

排序是O（n log n）而不是O（n）。构建哈希映射是O（n）。它比内部排序花费更多的内存，但是你要求最快。＆＃34; （我很肯定这可以优化，但最好是一个恒定的因素。）

function hasDuplicate(arr) {
  var hash = {};
  var hasDuplicate = false;
   arr.forEach(function(val) {
     if (hash[val]) {
       hasDuplicate = true;
       return;
     }
     hash[val] = true;
  });
  return hasDuplicate;
}

Answer 7

您可以将数组转换为Set实例，然后转换为数组，并检查转换前后的长度是否相同。

const hasDuplicates = (array) => {
  const arr = ['test0','test2','test0'];
  const set1 = new Set(array);
  const uniqueArray = [...set1];
  
  return array.length !== uniqueArray.length;
};

console.log(`Has duplicates : ${hasDuplicates(['test0','test2','test0'])}`);
console.log(`Has duplicates : ${hasDuplicates(['test0','test2','test3'])}`);

Answer 8

假设你想要的只是检测数组中'test0'的重复数量。我想一个简单的方法是使用join方法转换字符串中的数组，然后使用match方法。

var arr= ['test0','test2','test0'];
var str = arr.join();

console.log(str) //"test0,test2,test0"

var duplicates = str.match(/test0/g);
var duplicateNumber = duplicates.length;

console.log(duplicateNumber); //2

检测javascript数组中是否存在重复条目的最快方法？

8 个答案: