我在node中使用下划线js提出了一个解决方案，如下所示：

var checkRole = _.intersection(['A','B'], ['A','B','C']);
if(!_.isEmpty(checkRole)) { 
     next();
}

我在node中使用下划线js提出了一个解决方案，如下所示：

var checkRole = _.intersection(['A','B'], ['A','B','C']);
if(!_.isEmpty(checkRole)) { 
     next();
}

具有部分匹配和不区分大小写的Vanilla JS

以前的一些方法的问题是，它们需要每个单词的精确匹配。但是，如果您想提供部分匹配的结果呢？

function search(arrayToSearch, wordsToSearch) {
    arrayToSearch.filter(v => 
        wordsToSearch.every(w => 
            v.toLowerCase().split(" ").
                reduce((isIn, h) => isIn || String(h).indexOf(w) >= 0, false)
            )
        )
}
//Usage
var myArray = ["Attach tag", "Attaching tags", "Blah blah blah"];
var searchText = "Tag attach";
var searchArr = searchText.toLowerCase().split(" "); //["tag", "attach"]

var matches = search(myArray, searchArr);
//Will return
//["Attach tag", "Attaching tags"]

当您希望提供一个搜索框，用户可以在其中键入单词，结果可以以任何顺序、位置和大小写显示这些单词时，这非常有用。

var target = ["apple","banana","orange"];
var checkArray = ["apple","banana","pineapple"];

var containsOneCommonItem = target.some(x => checkArray.some(y => y === x));`

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

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

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

我写了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，所以如果我说的有错，请告诉我。

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

eg.

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

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