我发现这种简短而甜蜜的语法可以匹配两个数组之间的所有或某些元素。例如

//OR运算。查找array1中是否存在array2元素。当函数返回TRUE时，当某些方法中断时，一旦出现第一个匹配，就会返回该值

let array1 = ['a', 'b', 'c', 'd', 'e'], array2 = ['a', 'b'];

console.log(array2.some(ele => array1.includes(ele)));

//打印TRUE

//AND运算。查找array1中是否存在所有array2元素。当函数返回TRUE时，当某些方法中断时，一旦没有第一个匹配，就会返回该值

let array1 = ['a', 'b', 'c', 'd', 'e'], array2 = ['a', 'x'];

console.log(!array2.some(ele => !array1.includes(ele)));

//打印FALSE

希望这对将来的人有所帮助！

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

良好的性能解决方案：

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

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]检查器

香草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））；

还有一个解决方案

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)

如果你不反对使用图书馆，http://underscorejs.org/有一种相交方法，可以简化这一点：

var _ = require('underscore');

var target = [ 'apple', 'orange', 'banana'];
var fruit2 = [ 'apple', 'orange', 'mango'];
var fruit3 = [ 'mango', 'lemon', 'pineapple'];
var fruit4 = [ 'orange', 'lemon', 'grapes'];

console.log(_.intersection(target, fruit2)); //returns [apple, orange]
console.log(_.intersection(target, fruit3)); //returns []
console.log(_.intersection(target, fruit4)); //returns [orange]

交集函数将返回一个包含匹配项的新数组，如果不匹配，则返回空数组。