检查一个数组是不是包含 JavaScript 中另一个数组的任何元素

Posted 2023-02-22

【中文标题】检查一个数组是不是包含 JavaScript 中另一个数组的任何元素

【英文标题】：Check if an array contains any element of another array in JavaScript检查一个数组是否包含 JavaScript 中另一个数组的任何元素

【发布时间】：2020-03-10 00:00:03

【问题描述】：

我有一个目标数组["apple","banana","orange"]，我想检查其他数组是否包含任何一个目标数组元素。

例如：

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

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

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

如何在 javascript 中做到这一点？

【问题讨论】：

使用for 循环并遍历目标数组。如果每个元素都包含在当前数组中（使用current.indexOf(elem) !== -1)，那么它们都在其中。

@LeonGaban 我不同意。我不会仅仅为了执行此操作而导入库。

@devpato 是的，我改变了主意，ES6 解决方案是我的最爱

以防万一，如果您想获取元素而不仅仅是true 或false，那么您需要使用.filter() :: Javascript algorithm to find elements in array that are not in another array

【参考方案1】：

原版 JS

ES2016：

const found = arr1.some(r=> arr2.includes(r))

ES6：

const found = arr1.some(r=> arr2.indexOf(r) >= 0)

工作原理

some(..) 根据测试函数检查数组的每个元素，如果数组的任何元素通过测试函数，则返回 true，否则返回 false。如果给定的参数存在于数组中，indexOf(..) >= 0 和 includes(..) 都返回 true。

【讨论】：

预计我的结果是[false, false, false]而不是空数组[]？

@Batman：结果是真/假，但你可以调整skyisred先生的解决方案

必须这样做才能过滤掉一个巨大的 csv 来寻找一些东西。我使用.filter() 来获取适用于手头任务的行列表，some() 方法派上用场了。谢谢你。 var searchTerms = ['term1', 'term2', 'term3', 'term4'];var results = csvRows.filter(row => searchTerms.some(value => row.column1.includes(value)));

我怎样才能得到那个数字的值？

@CarloFontanos 还有人用IE吗？

【参考方案2】：

原版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;
    );
;

正如@loganfsmyth 所述，您可以在 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 => haystack.includes(v));

如果要确定该数组是否包含另一个数组中的所有项，请将some() 替换为every() 或arr.every(v => haystack.includes(v));

【讨论】：

不错的解决方案！ some() 是拉德。一旦匹配就退出。

这样的事件整理器：arr.some(v=> haystack.indexOf(v) >= 0)

在 ES2016 中也可用arr.some(v => haystack.includes(v))

一行arr1.some(v => arr2.indexOf(v) >= 0).

目前，最好避免使用includes，因为显然它在 IE 中不受支持：***.com/questions/36574351/…

【参考方案3】：

ES6 解决方案：

let arr1 = [1, 2, 3];
let arr2 = [2, 3];

let isFounded = arr1.some( ai => arr2.includes(ai) );

与它不同：必须包含所有值。

let allFounded = arr2.every( ai => arr1.includes(ai) );

希望对您有所帮助。

【讨论】：

有没有办法从 array1 获取 arra2 值的索引？？

在这种情况下，我们可以使用“filter”而不是“some”。然后它将返回一个数组而不是布尔值，您可以轻松地从那里访问值。

就我而言，它仅在我从函数内部返回时才有效，例如：let allFounded = arr2.every( ai => return arr1.includes(ai) );

【参考方案4】：

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

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

【讨论】：

我已经使用了几次，但请注意，问题是关于检查 if 任何元素是否存在于另一个数组中，而不是生成整个交集。就性能而言，如果数组很大，则存在巨大差异，因为在第一种情况下，您可以在找到一个匹配项后立即退出。

lodash 比 vanilla Javascript 更具可读性，应该始终使用 Ramda 中的 lib，而不是 vanilla imho。更适合所有开发者...

将此与_.some() 结合使用，即_.some(_.intersection(target, fruit2))

【参考方案5】：

ES6（最快）

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

ES2016

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

【讨论】：

我知道我真的迟到了，但要检查控制台是否 JSFiddle 添加 JQuery Edge 并打开 Firebug Lite

JSperf 链接断开

时间复杂度和空间复杂度有区别吗？关于复杂性的最佳解决方案是什么？

【参考方案6】：

如果您不需要类型强制（因为使用了indexOf），您可以尝试以下操作：

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

var found = false;
for (var i = 0; i < check.length; i++) 
    if (arr.indexOf(check[i]) > -1) 
        found = true;
        break;
    

console.log(found);

其中arr 包含目标项。最后，found 将显示第二个数组是否有至少一个与目标匹配。

当然，您可以将数字换成您想使用的任何东西 - 字符串很好，就像您的示例一样。

在我的具体示例中，结果应该是true，因为第二个数组的3 存在于目标中。

---

更新：

这是我将它组织成一个函数的方式（与之前相比有一些细微的变化）：

var anyMatchInArray = (function () 
    "use strict";

    var targetArray, func;

    targetArray = ["apple", "banana", "orange"];
    func = function (checkerArray) 
        var found = false;
        for (var i = 0, j = checkerArray.length; !found && i < j; i++) 
            if (targetArray.indexOf(checkerArray[i]) > -1) 
                found = true;
            
        
        return found;
    ;

    return func;
());

演示： http://jsfiddle.net/u8Bzt/

在这种情况下，可以修改函数以将 targetArray 作为参数传入，而不是在闭包中硬编码。

---

更新 2：

虽然我上面的解决方案可能有效并且（希望更）可读，但我相信处理我所描述的概念的“更好”方法是做一些不同的事情。上述解决方案的“问题”是循环内的indexOf 导致目标数组对于另一个数组中的每个项目都被完全循环。这可以通过使用“查找”（映射...JavaScript 对象文字）轻松“修复”。这允许在每个数组上进行两个简单的循环。这是一个例子：

var anyMatchInArray = function (target, toMatch) 
    "use strict";

    var found, targetMap, i, j, cur;

    found = false;
    targetMap = ;

    // Put all values in the `target` array into a map, where
    //  the keys are the values from the array
    for (i = 0, j = target.length; i < j; i++) 
        cur = target[i];
        targetMap[cur] = true;
    

    // Loop over all items in the `toMatch` array and see if any of
    //  their values are in the map from before
    for (i = 0, j = toMatch.length; !found && (i < j); i++) 
        cur = toMatch[i];
        found = !!targetMap[cur];
        // If found, `targetMap[cur]` will return true, otherwise it
        //  will return `undefined`...that's what the `!!` is for
    

    return found;
;

演示： http://jsfiddle.net/5Lv9v/

此解决方案的缺点是只能（正确）使用数字和字符串（和布尔值），因为这些值（隐式）转换为字符串并设置为查找映射的键。对于非文字值，这并不是很好/可能/容易做到的。

【讨论】：

为什么你使用 for 循环，而你可以使用 some 或 findIndex？

"some" 大大简化了代码。此外， anyMatchInArray([1,2,3,"cats","4"], ["1",4]) 将是真的。最后，如果您有大量查找并缓存了 targetMap，这可能会更高效。即便如此，性能可能会有所提高。例如，我猜“found = toMatch[i] !== undefined”会更好，在某些情况下会更好（这样您就不会将“”或 0 评估为假）

"否则它将返回 undefined...这就是 !! 的用途" - 这是错误的。它将返回 ! 的布尔对立。

【参考方案7】：

使用filter/indexOf：

function containsAny(source,target)

    var result = source.filter(function(item) return target.indexOf(item) > -1);   
    return (result.length > 0);  
    


//results

var fruits = ["apple","banana","orange"];


console.log(containsAny(fruits,["apple","grape"]));

console.log(containsAny(fruits,["apple","banana","pineapple"]));

console.log(containsAny(fruits,["grape", "pineapple"]));

【讨论】：

这与库函数（例如 _.intersection）存在相同的问题，即即使找到匹配项，它也会继续查找匹配项。不过，对于小型阵列，这显然无关紧要。

【参考方案8】：

您可以使用lodash 并执行以下操作：

_.intersection(originalTarget, arrayToCheck).length > 0

在两个集合上设置交集，生成相同元素的数组。

【讨论】：

在性能方面并不是最优的，因为对于这个问题，找到第一个匹配就足够了，而intersection 将在找到第一个匹配之后继续比较以找到所有匹配。这就像在您只需要 find 时使用 filter。

【参考方案9】：

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

或者，如果你首先找出这两个数组中的哪一个更长，然后将Set 找出最长的数组，同时将some 方法应用于最短的数组，你甚至可以获得更好的性能：

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

【讨论】：

虽然人们一直在发布使用嵌套 indexOf 和 includes 的解决方案，但您是第一个使用更有效的基于集合的解决方案（使用本机 Set）来回答问题的人，4 年后引入到 EcmaScript 中。 +1

如果我错了，请纠正我，但创建 Set 是否仍然需要迭代（在幕后）？如果是这样，那么哪个数组更短或更长都没有关系，因为时间复杂度仍然是相同的。是还是不是？？

@Sal_Vader_808 我实际上的意思是它是编译的（在浏览器的编译代码中实现，而不是由解释器运行的 JS 循环）。尝试在浏览器控制台中写入Set，然后按 Enter 键。你会得到这样的响应：ƒ Set() [native code] ，而不是其实现的 JS 代码。虽然一些本机代码可能会更慢，这只是因为其中一些有很多额外的验证器。

备注：显然，数组长度并不是决定将哪个数组转换为 Set 的唯一因素。这取决于代码，例如如果它总是检查同一个数组是否有许多其他不同数组的公共元素 - 你显然只想将它转换为一个 Set 并将其存储在函数外部的常量中，即使它不是最长的。

@Alexander 酷！看起来它是本机代码。又学到新东西了，谢谢！另外，是的，如果预计要多次使用，绝对应该考虑缓存数据。记忆 FTW！

【参考方案10】：

我写了 3 个解决方案。本质上，他们做同样的事情。他们一得到true就会返回true。我写了 3 个解决方案只是为了展示 3 种不同的做事方式。现在，这取决于您更喜欢什么。您可以使用performance.now() 检查一种或另一种解决方案的性能。在我的解决方案中，我还检查了哪个数组最大，哪个数组最小，以提高操作效率。

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

最后，当然...我们可以提出一个带有 2 个 NESTED for 循环的解决方案（蛮力方式），但您要避免这种情况，因为时间复杂度很差 O(n^2)强>。

注意：

您可以使用 .includes() 而不是像其他人那样使用 .indexOf()。如果您只检查该值是否大于 0。如果 该值不存在会给你-1。如果它确实存在，它会给你 大于 0。

indexOf() vs includes()

performance哪个更好？ indexOf() 一点点，但在我看来，include 更具可读性。

如果我没记错 .includes() 和 indexOf() 在幕后使用循环，那么当您将它们与 .some() 一起使用时，您将处于 O(n^2)。 p>

使用循环

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

使用地图 Time complexity 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;
;

我的代码： stackblitz

我不是性能专家，也不是 BigO，所以如果我说的有问题，请告诉我。

【讨论】：

很好的答案，但是：“如果您 [使用 indexOf] 只需检查该值是否大于 0。如果该值不存在会给您 -1。如果它确实存在，它将给你大于0。”这应该大于或等于/大于或等于。

关于使用包含，我认为确定哪个数组更短/更长并不重要。看看Array#includes 是如何实现的（tc39.es/ecma262/#sec-array.prototype.includes），看起来你仍然需要遍历更长的数组。除非我读了includes 的实现都错了（这是可能的哈哈）。另外，我同意使用地图是最有效的。

嗨@Sal_Vader_808 好点。让我做一些研究。谢谢！

感谢您提供这段代码！这对我的项目有很大帮助。如果问得不算多，有没有办法用您的.some() 解决方案显示两个数组之间的哪些术语相同？

【参考方案11】：

我发现这种短小精悍的语法可以匹配两个数组之间的全部或部分元素。例如

// 或运算。查找 array1 中是否存在任何 array2 元素。这将在第一次匹配时返回，因为当函数返回 TRUE 时某些方法会中断

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

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

// 打印 TRUE

// 与运算。查找 array2 中的所有元素是否都存在于 array1 中。这将在没有第一个匹配项时立即返回，因为当函数返回 TRUE 时某些方法会中断

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

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

// 打印 FALSE

希望将来能对某人有所帮助！

【讨论】：

我真的很喜欢这个问题的第二部分，为了使它适用于 ES5，它是否喜欢： !array2.some( function(ele) return array1.indexOf(ele) === - 1 );

【参考方案12】：

只是另一种解决方案

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)

【讨论】：

为了改善这一点，我们可以在最短的数组长度上使用过滤器循环。 const result = a2.filter((e) => a1.indexOf(e) !== -1).length === a2.length;

【参考方案13】：

组合使用 some/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;

注意：如果您想使用谓词做某事，可以将内部 indexOf 替换为另一个 findIndex 和谓词

【参考方案14】：

您可以使用嵌套的 Array.prototype.some 调用。这样做的好处是它将在第一次匹配时退出，而不是通过完整的嵌套循环运行其他解决方案。

例如。

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

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

【参考方案15】：

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

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

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'] 
// ]

【参考方案16】：

添加到数组原型

免责声明：许多人强烈建议不要这样做。唯一真正成为问题的情况是，如果库添加了具有相同名称（行为不同）或类似名称的原型函数。

代码：

Array.prototype.containsAny = function(arr) 
    return this.some(
        (v) => (arr.indexOf(v) >= 0)
    )

不使用大箭头函数：

Array.prototype.containsAny = function(arr) 
    return this.some(function (v) 
        return arr.indexOf(v) >= 0
    )

用法

var a = ["a","b"]

console.log(a.containsAny(["b","z"]))    // Outputs true

console.log(a.containsAny(["z"]))    // Outputs false

【参考方案17】：

我的解决方案适用于 Array.prototype.some() 和 Array.prototype.includes() 数组助手，它们的工作效率也很高

ES6

const originalFruits = ["apple","banana","orange"];

const fruits1 = ["apple","banana","pineapple"];

const fruits2 = ["grape", "pineapple"];

const commonFruits = (myFruitsArr, otherFruitsArr) => 
  return myFruitsArr.some(fruit => otherFruitsArr.includes(fruit))

console.log(commonFruits(originalFruits, fruits1)) //returns true;
console.log(commonFruits(originalFruits, fruits2)) //returns false;

【讨论】：

有没有办法从 originalFruits 获取包含项目的索引？？

【参考方案18】：

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

试试这个：

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

DEMO at JSFIDDLE

【参考方案19】：

不确定这在性能方面的效率如何，但这是我使用数组解构来保持一切简洁：

const shareElements = (arr1, arr2) => 
  const typeArr = [...arr1, ...arr2]
  const typeSet = new Set(typeArr)
  return typeArr.length > typeSet.size

由于集合不能有重复的元素，而数组可以，组合两个输入数组，将其转换为集合，然后比较集合大小和数组长度会告诉您它们是否共享任何元素。

【参考方案20】：

当我查看您的答案时，我找不到我想要的答案。 我自己做了一些事情，我想和你分享。

只有当输入的单词（数组）正确时才会成立。

function contains(a,b) 
    let counter = 0;
    for(var i = 0; i < b.length; i++) ;
        if(a.includes(b[i])) counter++;
    
    if(counter === b.length) return true;
    return false;


let main_array = ['foo','bar','baz'];
let sub_array_a = ['foo','foobar'];
let sub_array_b = ['foo','bar'];

console.log(contains(main_array, sub_array_a)); // returns false
console.log(contains(main_array,sub_array_b )); // returns true

【参考方案21】：

与underscorejs

var a1 = [1,2,3];
var a2 = [1,2];

_.every(a1, function(e) return _.include(a2, e);  ); //=> false
_.every(a2, function(e) return _.include(a1, e);  ); //=> true

【讨论】：

就个人而言，虽然我喜欢 underscorejs，但这是一个复杂代码看起来如何的经典示例。不仅难以理解为 underscorejs 代码，而且从一般编码的角度来看，这也是如此（例如，当我想在数组中查找某些东西的索引时，不会想到“每个”这个词，但是“indexOf”确实如此）。我们应该避免不必要地使用第三方工具，因为额外的几个字符可以提供纯 JavaScript 解决方案。使用 underscorejs 意味着您的解决方案与第三方代码紧密耦合。

@csharpforevermore 我想这是一个品味问题，你说这个解决方案比使用indexOf 的所有其他解决方案更复杂 我认为相反:)。另一方面，我同意尝试不添加外部库，如果它们不是真的需要的话，但我并不真正痴迷于此，第三方库不仅提供有用的功能，而且提供 solid 功能.例如：您是否使用您的解决方案测试了所有边缘案例和市长浏览器？..（顺便说一下，every 不是试图在列表中查找索引，而是在 every中评估某些内容> 列表中的元素）

【参考方案22】：

Array .filter() 嵌套调用 .find() 将返回第一个数组中属于第二个数组的所有元素。检查返回数组的长度以确定第二个数组是否在第一个数组中。

getCommonItems(firstArray, secondArray) 
  return firstArray.filter((firstArrayItem) => 
    return secondArray.find((secondArrayItem) => 
      return firstArrayItem === secondArrayItem;
    );
  );

【讨论】：

有没有办法“清理”数组？就像删除第二个数组中的值（如果它们存在于第一个数组中）？

【参考方案23】：

带有部分匹配和不区分大小写的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"]

如果您想提供一个搜索框，用户可以在其中键入单词并且结果可以以任何顺序、位置和大小写包含这些单词，这很有用。

【参考方案24】：

更新@Paul Grimshaw 的答案，使用includes 代替indexOf 以获得更多可读性

让找到 = arr1.some(r=> arr2.indexOf(r) >= 0) 让找到 = arr1.some(r=> arr2.includes(r))

【参考方案25】：

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

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

【参考方案26】：

就个人而言，我会使用以下功能：

var arrayContains = function(array, toMatch) 
    var arrayAsString = array.toString();
    return (arrayAsString.indexOf(','+toMatch+',') >-1);

“toString()”方法将始终使用逗号分隔值。仅适用于原始类型。

【讨论】：

当元素位于数组的开头或结尾，或者以不同的顺序时，这将不起作用。

-1 因为正如 DanielM 所说，这是坏的。您可以在arrayAsString前面加上逗号作为一种解决方法，但老实说，使用字符串似乎是一个过于复杂的解决方案。

【参考方案27】：

console.log("searching Array: "+finding_array);
console.log("searching in:"+reference_array);
var check_match_counter = 0;
for (var j = finding_array.length - 1; j >= 0; j--) 

    if(reference_array.indexOf(finding_array[j]) > 0)
    
        check_match_counter = check_match_counter + 1;
    

 var match = (check_match_counter > 0) ? true : false;
console.log("Final result:"+match);

【参考方案28】：

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;

【讨论】：

@bingles 已经提出了这个解决方案

【参考方案29】：

你可以这样做

let filteredArray = array.filter((elm) => 
   for (let i=0; i<anotherAray.length; i++) 
      return elm.includes(anotherArray[i])
    
  )

【讨论】：

请参阅Does return stop a loop?。这只会检查第一项。