Question

我实际上是在寻找一种检查数组中两个或更多值是否相等的方法。以下是一些示例：

[1, 2, 3] // false
[1, 1, 5] // true
['a', 'b', 'a', 'c'] // true
[10, 10, 10] // true

我发现如果每个数组的值都相等，该函数将给出“ true”，但这不是我想要的：

[1,1,1,1].every( (val, i, arr) => val === arr[0] ) // true

Answer 1

您可以使用Set来消除重复项：

const nonUnique = a => new Set(a).size !== a.length;

console.log(nonUnique([1, 2, 3])); // false
console.log(nonUnique([1, 1, 5])); // true
console.log(nonUnique(['a', 'b', 'a', 'c'])); // true
console.log(nonUnique([10, 10, 10])); // true

Answer 2

一种简单的方法是创建唯一值的Set并将Set的size与数组的length比较

const hasDuplicates = (arr) => new Set(arr).size < arr.length ;

console.log(hasDuplicates([1, 2, 3]));
console.log(hasDuplicates([1, 1, 5]));
console.log(hasDuplicates(['a', 'b', 'a', 'c']));
console.log(hasDuplicates([10, 10, 10]));

Answer 3

此算法效率很低（O（n ^ 2），蛮力搜索），但有效：

function has_dupes(arr) {
  return arr.some((x, i) => arr.includes(x, i+1));
}

console.log(has_dupes([1, 2, 3]));
console.log(has_dupes([1, 1, 5]));
console.log(has_dupes(['a', 'b', 'a', 'c']));
console.log(has_dupes([10, 10, 10]));

对于索引为x的每个元素i，我们检查从i+1开始的子数组是否包含另一个等于x的值。

Answer 4

使用for循环，一旦发现重复，就可以中断循环。

var a = [1, 2, 3] // false
var b = [1, 1, 5] // true
var c = ['a', 'b', 'a', 'c'] // true
var d = [10, 10, 10] // true


function diff(arr){

    var diff = []
    
    for(let i = 0; i<arr.length; i++){
        if(diff.includes(arr[i])){
         return true;//<-- break the loop   
        }else{
            diff.push(arr[i]);
        }
    }

    return false;

}

console.log(diff(a))
console.log(diff(b))
console.log(diff(c))
console.log(diff(d))

Answer 5

您可以使用double for循环，其中一个是要查找的内容的索引，而内循环则检查重复项。

Answer 6

在使用find方法进行检查时将它们添加到集合中

let items1 = [1, 2, 3, 3, 4];
let items2 = [1, 2, 3, 4];
let items3 = ['a', 'b', 'a', 'c']
let items4 = [0, 0]
let items5 = [undefined, undefined]

function hasDuplicate(array) {
  const set = new Set()
  return array.some(it => {
    if (set.has(it)) {
      return true
    } else {
      set.add(it);
      return false;
    }
  })
}

console.log(hasDuplicate(items1))
console.log(hasDuplicate(items2))
console.log(hasDuplicate(items3))
console.log(hasDuplicate(items4))
console.log(hasDuplicate(items5))

Answer 7

您可以通过lodash找到所有唯一元素，只需比较两个数组的大小即可得到所需的内容。

a = [1, 2, 3]
a_uniq = _.uniq(a); //will return [1, 3]
console.log(a.length != a_uniq.length); //will return false

a = [1, 1, 3]
a_uniq = _.uniq(a); //will return [1, 3]
console.log(a.length != a_uniq.length); //will return true

可以在这里快速测试：https://codepen.io/travist/full/jrBjBz/

Answer 8

例如，您可以使用for loop轻松地循环播放它：-

function hasDuplicate(lst){
    for(var i=0; i<lst.length; i++)
        for(var j=i+1; j<lst.length;j++)
            if(i!=j && lst[i] === lst[j])
                return true;
    return false;
}

var list1 = [1,1,5];
window.alert(hasDuplicate(list1)); //True

Answer 9

将数组简化为以键为项目的对象。如果对象的键的长度与项目的长度不同，则存在重复项。

这也可以为您提供重复次数的指示。

const items1 = [1, 2, 3, 3, 4]
const items2 = [1, 2, 3, 3, 3, 3, 4]
const items3 = [1, 2, 3, 4]
const items4 = [undefined, undefined]

function dupCount(array) {
  const obj = array.reduce((acc, item) => {
    acc[item] = true;
    return acc;
  }, {})
  return array.length - Object.keys(obj).length
}

console.log(dupCount(items1))
console.log(dupCount(items2))
console.log(dupCount(items3))
console.log(dupCount(items4))

Answer 10

function isSameArray(data, count) {
   var result = false;
   data.forEach(a => {
      const filter = data.filter(f => f === a); 
      if (filter.length > count - 1) {
         result = true;
         return;
      }
   });

   return result;
}

isSameArray([1, 2, 3], 2)

Answer 11

Array.some与Array.every的工作原理相同，不同之处在于，如果测试遍历了要迭代的数组中的一项，则执行停止，并返回true。可能是您要找的东西。

Answer 12

以下内容将帮助您实现您作为示例给出的结果：

Array_is_true(int *a,int n)
{
   int j=1,flag=0;
  for(int i=0,i<n;i++)
   {
      j=i+1;
      while(j<n;)
      {
         if(a[i]==a[j])
         { flag=1;j++;}
      }
   }
}

检查至少两个数组值是否相等

12 个答案: