const areCommonElements = (arr1, arr2) => {
    const arr2Set = new Set(arr2);
    return arr1.some(el => arr2Set.has(el));
};

或者，如果您首先找出这两个数组中的哪一个更长，并对最长的数组进行设置，同时对最短的数组应用一些方法，您甚至可以获得更好的性能：

const areCommonElements = (arr1, arr2) => {
    const [shortArr, longArr] = (arr1.length < arr2.length) ? [arr1, arr2] : [arr2, arr1];
    const longArrSet = new Set(longArr);
    return shortArr.some(el => longArrSet.has(el));
};

您正在寻找两个数组之间的交集。你有两种主要的交叉点类型：“每个”和“一些”。让我举几个好例子：

每

let brands1 = ['Ford', 'Kia', 'VW', 'Audi'];
let brands2 = ['Audi', 'Kia'];
// Find 'every' brand intersection. 
// Meaning all elements inside 'brands2' must be present in 'brands1':
let intersectionEvery = brands2.every( brand => brands1.includes(brand) );
if (intersectionEvery) {
    const differenceList = brands1.filter(brand => !brands2.includes(brand));
    console.log('difference list:', differenceList);
    const commonList = brands1.filter(brand => brands2.includes(brand));
    console.log('common list:', commonList);
}

如果条件不满足（比如你在品牌中加入了“梅赛德斯”），那么“intersectionEvery”就不满足了——这将是错误的。

如果满足条件，它将把[“福特”、“大众”]列为区别，把[“起亚”、“奥迪”]列为了常见列表。

沙盒：https://jsfiddle.net/bqmg14t6/

SOME

let brands1 = ['Ford', 'Kia', 'VW', 'Audi'];
let brands2 = ['Audi', 'Kia', 'Mercedes', 'Land Rover'];
// Find 'some' brand intersection. 
// Meaning some elements inside 'brands2' must be also present in 'brands1':
let intersectionSome = brands2.some( brand => brands1.includes(brand) );
if (intersectionSome) {
    const differenceList = brands1.filter(brand => !brands2.includes(brand));
    console.log('difference list:', differenceList);
    const commonList = brands1.filter(brand => brands2.includes(brand));
    console.log('common list:', commonList);
}

我们在这里寻找一些常见的品牌，但不一定全部。

它将把[“福特”、“大众”]列为不同品牌，把[“起亚”、“奥迪”]列为了共同品牌。

沙盒：https://jsfiddle.net/zkq9j3Lh/

还有一个解决方案

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

/**
 * @description determine if an array contains one or more items from another array.
 * @param {array} haystack the array to search.
 * @param {array} arr the array providing items to check for in the haystack.
 * @return {boolean} true|false if haystack contains at least one item from arr.
 */
var findOne = function (haystack, arr) {
    return arr.some(function (v) {
        return haystack.indexOf(v) >= 0;
    });
};

正如@loganofsmyth所指出的，您可以在ES2016中将其缩短为

/**
 * @description determine if an array contains one or more items from another array.
 * @param {array} haystack the array to search.
 * @param {array} arr the array providing items to check for in the haystack.
 * @return {boolean} true|false if haystack contains at least one item from arr.
 */
const findOne = (haystack, arr) => {
    return arr.some(v => haystack.includes(v));
};

或者简单地称为arr.some（v＝＞haystalk.includes（v））；

如果要确定数组是否包含其他数组中的所有项，请将some（）替换为every（）或作为arr.every（v＝＞haystalk.includes（v））；

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

试试看：

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演示

使用一些/findIndex和indexOf的组合怎么样？

所以类似这样：

var array1 = ["apple","banana","orange"];
var array2 = ["grape", "pineapple"];

var found = array1.some(function(v) { return array2.indexOf(v) != -1; });

为了使其更可读，可以将此功能添加到Array对象本身。

Array.prototype.indexOfAny = function (array) {
    return this.findIndex(function(v) { return array.indexOf(v) != -1; });
}

Array.prototype.containsAny = function (array) {
    return this.indexOfAny(array) != -1;
}

注意：如果您想对谓词执行某些操作，可以用另一个findIndex和谓词替换内部indexOf