良好的性能解决方案：

我们应该将其中一个数组转换为对象。

const contains = (arr1, mainObj) => arr1.some(el => el in mainObj);
const includes = (arr1, mainObj) => arr1.every(el => el in mainObj);

用法：

const mainList = ["apple", "banana", "orange"];
// We make object from array, you can use your solution to make it
const main = Object.fromEntries(mainList.map(key => [key, true]));

contains(["apple","grape"], main) // => true
contains(["apple","banana","pineapple"], main) // =>  true
contains(["grape", "pineapple"], main) // =>  false

includes(["apple", "grape"], main) // => false
includes(["banana", "apple"], main) // =>  true

您可能会面临由in运算符检查的一些缺点（例如｛｝//=>true中的“toString”），因此您可以将解决方案更改为obj[key]检查器

ES6（最快）

const a = ['a', 'b', 'c'];
const b = ['c', 'a', 'd'];
a.some(v=> b.indexOf(v) !== -1)

2016年

const a = ['a', 'b', 'c'];
const b = ['c', 'a', 'd'];
a.some(v => b.includes(v));

强调

const a = ['a', 'b', 'c'];
const b = ['c', 'a', 'd'];
_.intersection(a, b)

演示：https://jsfiddle.net/r257wuv5/

jsPerf（性能）：https://jsperf.com/array-contains-any-element-of-another-array

香草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。

这是一个有趣的案例，我认为我应该分享。

假设您有一个对象数组和一个选定过滤器数组。

let arr = [
  { id: 'x', tags: ['foo'] },
  { id: 'y', tags: ['foo', 'bar'] },
  { id: 'z', tags: ['baz'] }
];

const filters = ['foo'];

要将所选过滤器应用于此结构，我们可以

if (filters.length > 0)
  arr = arr.filter(obj =>
    obj.tags.some(tag => filters.includes(tag))
  );

// [
//   { id: 'x', tags: ['foo'] },
//   { id: 'y', tags: ['foo', 'bar'] }
// ]

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

每

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/

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