如果你不反对使用图书馆，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]

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

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

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

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

试试看：

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

我写了3个解决方案。本质上，他们也是这样做的。他们一变为真就变为真。我写了三个解决方案，只是为了展示三种不同的做事方式。现在，这取决于你更喜欢什么。您可以使用performance.now（）检查一个或另一个解决方案的性能。在我的解决方案中，我还检查了哪个阵列最大，哪个阵列最小，以提高操作效率。

第三种解决方案可能不是最可爱的，但很有效。我决定添加它，因为在一些编码面试中，您不允许使用内置方法。

最后，当然。。。我们可以用2个NESTED for循环（蛮力方法）提出解决方案，但您希望避免这种情况，因为时间复杂度是坏的O（n^2）。

注：

您可以使用.indexOf（）。如果您检查该值是否大于0。如果值不存在会给你-1。如果它确实存在，它会给你大于0。

indexOf（）与includes（）

哪个性能更好？indexOf（）稍有不同，但我认为includes更可读。

如果我没弄错的话，.includes（）和indexOf（）在幕后使用循环，所以当它们与.some（）一起使用时，您将处于O（n^2）。

USING循环

 const compareArraysWithIncludes = (arr1, arr2) => {
     const [smallArray, bigArray] =
        arr1.length < arr2.length ? [arr1, arr2] : [arr2, arr1];

     for (let i = 0; i < smallArray.length; i++) {
       return bigArray.includes(smallArray[i]);
     }

      return false;
    };

使用.some（）

const compareArraysWithSome = (arr1, arr2) => {
  const [smallArray, bigArray] =
    arr1.length < arr2.length ? [arr1, arr2] : [arr2, arr1];
  return smallArray.some(c => bigArray.includes(c));
};

使用MAPS时间复杂度O（2n）=>O（n）

const compararArraysUsingObjs = (arr1, arr2) => {
  const map = {};

  const [smallArray, bigArray] =
    arr1.length < arr2.length ? [arr1, arr2] : [arr2, arr1];

  for (let i = 0; i < smallArray.length; i++) {
    if (!map[smallArray[i]]) {
      map[smallArray[i]] = true;
    }
  }

  for (let i = 0; i < bigArray.length; i++) {
    if (map[bigArray[i]]) {
      return true;
    }
  }

  return false;
};

我的代码：堆垛机

我既不是表演专家，也不是BigO，所以如果我说的有错，请告诉我。

使用一些/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