检查 JavaScript 数组中的重复字符串

Question

我有带有字符串的JS数组，例如：

var strArray = [ "q", "w", "w", "e", "i", "u", "r"];

我需要比较数组中的重复字符串，如果存在重复字符串，应该有指向该字符串的警报框。

我试图将其与循环进行比较for但我不知道如何编写代码，以便数组检查自己的字符串是否存在重复项，而无需预先确定的字符串进行比较。

Answer 1

findDuplicates 函数(如下(将数组中所有项目的索引与同一项目首次出现的索引进行比较。如果索引不同，则将其作为重复项返回。

let strArray = [ "q", "w", "w", "w", "e", "i", "i", "u", "r"];
let findDuplicates = arr => arr.filter((item, index) => arr.indexOf(item) !== index)
console.log(findDuplicates(strArray)) // All duplicates
console.log([...new Set(findDuplicates(strArray))]) // Unique duplicates

Answer 2

使用 ES6 功能

• 由于 Set 中的每个值都必须是唯一的，因此将检查值相等性。

function checkIfDuplicateExists(arr) {
    return new Set(arr).size !== arr.length
}
  
var arr = ["a", "a", "b", "c"];
var arr1 = ["a", "b", "c"];
console.log(checkIfDuplicateExists(arr)); // true
console.log(checkIfDuplicateExists(arr1)); // false

Answer 3

    var strArray = [ "q", "w", "w", "e", "i", "u", "r", "q"];
    var alreadySeen = {};
  
    strArray.forEach(function(str) {
      if (alreadySeen[str])
        console.log(str);
      else
        alreadySeen[str] = true;
    });

我从您的原始副本中添加了另一个副本，只是为了表明它会找到一个非连续的副本。

带有箭头功能的更新版本：

const strArray = [ "q", "w", "w", "e", "i", "u", "r", "q"];
const alreadySeen = {};
  
strArray.forEach(str => alreadySeen[str] ? console.log(str) : alreadySeen[str] = true);

Answer 4

在数组上使用一些函数：如果数组中的任何项的索引号从开头不等于从末尾开始的索引号，则此项在数组中存在不止一次。

// vanilla js
function hasDuplicates(arr) {
    return arr.some( function(item) {
        return arr.indexOf(item) !== arr.lastIndexOf(item);
    });
}

Answer 5

您可以进行Set并筛选到已经看到的值。

var array = ["q", "w", "w", "e", "i", "u", "r"],
    seen = array.filter((s => v => s.has(v) || !s.add(v))(new Set));
console.log(seen);

Answer 6

function hasDuplicates(arr) {
    var counts = [];
    for (var i = 0; i <= arr.length; i++) {
        if (counts[arr[i]] === undefined) {
            counts[arr[i]] = 1;
        } else {
            return true;
        }
    }
    return false;
}
// [...]
var arr = [1, 1, 2, 3, 4];
if (hasDuplicates(arr)) {
  alert('Error: you have duplicates values !')
}

简单的Javascript(如果你不知道ES6(

function hasDuplicates(arr) {
    var counts = [];
    for (var i = 0; i <= arr.length; i++) {
        if (counts[arr[i]] === undefined) {
            counts[arr[i]] = 1;
        } else {
            return true;
        }
    }
    return false;
}
// [...]
var arr = [1, 1, 2, 3, 4];
if (hasDuplicates(arr)) {
  alert('Error: you have duplicates values !')
}

Answer 7

function hasDuplicateString(strings: string[]): boolean {
    const table: { [key: string]: boolean} = {}
    for (let string of strings) {
        if (string in table) return true;
        table[string] = true;
    }
    return false
}

在这里，in运算符通常被认为是 0(1( 时间查找，因为它是哈希表查找。

Answer 8

   var elems = ['f', 'a','b','f', 'c','d','e','f','c'];
    elems.sort();
    elems.forEach(function (value, index, arr){
        let first_index = arr.indexOf(value);
        let last_index = arr.lastIndexOf(value);
         if(first_index !== last_index){
         console.log('Duplicate item in array ' + value);
         }else{
         console.log('unique items in array ' + value);
         }
    });

Answer 9

您必须创建一个空数组，然后检查给定数组的每个元素，如果新数组已经具有它会提醒您的元素。像这样的东西。

  var strArray = [ "q", "w", "w", "e", "i", "u", "r"];
  let newArray =[];
  function check(arr){
  for(let elements of arr){
  if(newArray.includes(elements)){
  alert(elements)
  }
 else{
 newArray.push(elements);
 }
 }
 return newArray.sort();
  }
check(strArray);

Answer 10

当您使用大数组时，使用对象键以获得良好的性能(在这种情况下，循环每个元素并再次循环以检查重复将非常慢(。

var strArray = ["q", "w", "w", "e", "i", "u", "r"];
var counting = {};
strArray.forEach(function (str) {
    counting[str] = (counting[str] || 0) + 1;
});
if (Object.keys(counting).length !== strArray.length) {
    console.log("Has duplicates");
    var str;
    for (str in counting) {
        if (counting.hasOwnProperty(str)) {
            if (counting[str] > 1) {
                console.log(str + " appears " + counting[str] + " times");
            }
        }
    }
}

Answer 11

这是我猜最简单的解决方案：

function diffArray(arr1, arr2) {
  return arr1
    .concat(arr2)
    .filter(item => !arr1.includes(item) || !arr2.includes(item));
}

Answer 12

 const isDuplicate = (str) =>{
   return new Set(str.split("")).size === str.length;
}

Answer 13

您可以使用reduce：

const arr = ["q", "w", "w", "e", "i", "u", "r"]
arr.reduce((acc, cur) => { 
  if(acc[cur]) {
    acc.duplicates.push(cur)
  } else {
    acc[cur] = true //anything could go here
  }
}, { duplicates: [] })

结果将如下所示：

{ ...Non Duplicate Values, duplicates: ["w"] }

这样您就可以对重复值做任何您想做的事情！