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

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

var strArray=[“q”、“w”、“w”、“e”、“i”、“u”、“r”]

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

我试图将它与
for
循环进行比较，但我不知道如何编写代码，以便数组在没有预先确定的字符串进行比较的情况下，检查自己的字符串是否存在重复项。
函数
findDuplicates
将数组中所有项的索引与同一项首次出现的索引进行比较。如果索引不相同，则返回重复的索引


let strArray=[“q”、“w”、“w”、“w”、“e”、“i”、“u”、“r”]；
让findDuplicates=arr=>arr.filter（（项目，索引）=>arr.indexOf（项目）！=index）
console.log（findDuplicates（strArray））//所有副本
console.log（[…new Set（findDuplicates（strArray））]//唯一重复项
以下代码使用唯一筛选器（检查项目的每次出现是否都是第一次出现）比较数组中唯一项目的数量与项目总数：如果两者相等，数组只包含唯一的元素，否则会有一些重复的元素

var firstUnique = (value, index, array) => array.indexOf(value) === index;
var numUnique = strArray.filter(firstUnique).length;
var allUnique = strArray.length === numUnique; 

我添加了另一个副本在那里从您的原始只是为了表明它会找到一个非连续的重复

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

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

strArray.forEach(str => alreadySeen[str] ? alert(str) : alreadySeen[str] = true);

使用ES6功能
在阵列上使用某些函数：
如果数组中的任何项从开始的索引号不等于从结束的索引号，则此项在数组中存在多次

//香草js
函数hasDuplicates（arr）{
返回arr.some（功能（项目）{
返回arr.indexOf（项目）！==arr.lastIndexOf（项目）；
});
}

函数具有重复项（arr）{
var计数=[]；
对于（var i=0；i在处理大数组时使用对象键以获得良好的性能（在这种情况下，为每个元素循环并再次循环以检查重复将非常缓慢）

您可以选择一个选项，并筛选所有已看到的值


var数组=[“q”、“w”、“w”、“e”、“i”、“u”、“r”]，
seen=array.filter（（s=>v=>s.has（v）| |！s.add（v））（新集合））；
console.log（见）；
您可以使用reduce：

常量arr=[“q”、“w”、“w”、“e”、“i”、“u”、“r”]
arr.reduce（（acc，cur）=>{
如果（根据[当前]）{
附件重复推送（当前）
}否则{
acc[cur]=true//这里什么都可以
}
}，{重复项：[]}）

结果如下所示：

{…非重复值，重复：[“w”]}

这样，您可以对重复值执行任何操作！
您可以使用集执行此操作。您必须创建一个集，并将所有值放入数组中的该集中。然后，您可以检查它们是否具有相同的长度。如果没有，则您知道存在重复值，因为一个集只能具有唯一的值。这是e在下面的链接中解释：

如果您以功能性方式使用typescript，以下是我的解决方案：

const hasDuplicates = <T>(arr: T[]): boolean => {
  if (arr.length === 0) return false
  if (arr.lastIndexOf(arr[0]) !== 0) return true
  return hasDuplicates(arr.slice(1))
}

const hasdeplicates=（arr:T[]）：boolean=>{
如果（arr.length==0）返回false
如果（arr.lastIndexOf（arr[0]）！==0）返回true
返回重复项（arr.slice（1））
}
我想这是最简单的解决方案：

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

我想再简单不过了


const findDuplicates=arr=>[…新集合（arr.filter（v=>arr.indexOf（v）！==arr.lastIndexOf（v））]；
log（find副本（[“q”、“w”、“w”、“e”、“i”、“u”、“r”]））如果你在末尾丢了另一个“Q”，那么它是否算是一个复制品？是否有重复？任何类型的重复。它可以在数组的中间，或者在数组的末尾，或者任何其他的组合。在我的测试中，最快的方法是。这个解决方案也很好！谢谢。不要接受（绿色复选标记）你的答案。很好的答案。这种特殊的逻辑很容易允许“任何”行为（即，当我发现有任何重复项时，我可以短路循环）。如果你只需要一个布尔值，这看起来很好。在一行：
consthasdeplicates=arr=>arr.some（（项，索引）=>arr.indexOf（项）！=index）
Hi，您的函数正是我需要的（只返回一个布尔值），但我不知道ES6，您能用“简单”的javascript编写它吗？快速比较（检查100个数字数组的重复，一百万次），此方法是目前此页面上速度最快的建议。此方法不会返回唯一数组，如果重复项在数组中重复多次，则将包含多次。例如，
xxxyyxxx
。使用
lastIndexOf
而不是
indexOf
会产生更好的性能吗？（尚未进行任何测试）
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");
            }
        }
    }
}

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

         }

    });

const hasDuplicates = <T>(arr: T[]): boolean => {
  if (arr.length === 0) return false
  if (arr.lastIndexOf(arr[0]) !== 0) return true
  return hasDuplicates(arr.slice(1))
}

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