我有一个目标数组[“apple”、“banana”、“orange”],我想检查其他数组是否包含任何一个目标阵列元素。

例如:

["apple","grape"] //returns true;

["apple","banana","pineapple"] //returns true;

["grape", "pineapple"] //returns false;

如何在JavaScript中实现?


当前回答

这可以通过简单地遍历主数组并检查其他数组是否包含任何目标元素来完成。

试试看:

function Check(A) {
    var myarr = ["apple", "banana", "orange"];
    var i, j;
    var totalmatches = 0;
    for (i = 0; i < myarr.length; i++) {
        for (j = 0; j < A.length; ++j) {
            if (myarr[i] == A[j]) {

                totalmatches++;

            }

        }
    }
    if (totalmatches > 0) {
        return true;
    } else {
        return false;
    }
}
var fruits1 = new Array("apple", "grape");
alert(Check(fruits1));

var fruits2 = new Array("apple", "banana", "pineapple");
alert(Check(fruits2));

var fruits3 = new Array("grape", "pineapple");
alert(Check(fruits3));

JSFIDDLE演示

其他回答

添加到阵列原型

免责声明:许多人强烈建议不要这样做。唯一真正有问题的是,如果一个库添加了一个同名(行为不同)的原型函数或类似的东西。

代码:

Array.prototype.containsAny = function(arr) {
    return this.some(
        (v) => (arr.indexOf(v) >= 0)
    )
}

不使用大箭头功能:

Array.prototype.containsAny = function(arr) {
    return this.some(function (v) {
        return arr.indexOf(v) >= 0
    })
}

用法

var a = ["a","b"]

console.log(a.containsAny(["b","z"]))    // Outputs true

console.log(a.containsAny(["z"]))    // Outputs false

嵌套调用.find()的Array.filter()将返回第一个数组中属于第二个数组的所有元素。检查返回数组的长度,以确定第一个数组中是否有第二个数组。

getCommonItems(firstArray, secondArray) {
  return firstArray.filter((firstArrayItem) => {
    return secondArray.find((secondArrayItem) => {
      return firstArrayItem === secondArrayItem;
    });
  });
}

还有一个解决方案

var a1 = [1, 2, 3, 4, 5]
var a2 = [2, 4]

检查a1是否包含a2的所有元素

var result = a1.filter(e => a2.indexOf(e) !== -1).length === a2.length
console.log(result)

香草JS

2016年:

const found = arr1.some(r=> arr2.includes(r))

ES6:

const found = arr1.some(r=> arr2.indexOf(r) >= 0)

它的工作原理

一些(..)根据测试函数检查数组的每个元素,如果数组的任何元素通过测试函数,则返回true,否则返回false。如果数组中存在给定参数,indexOf(..)>=0和includes(..)都返回true。

可以使用嵌套的Array.prototype.some调用。这有一个好处,即它将在第一场比赛中获胜,而不是其他将在整个嵌套循环中运行的解决方案。

eg.

var arr = [1, 2, 3];
var match = [2, 4];

var hasMatch = arr.some(a => match.some(m => a === m));