Check if an array contains any element of another array in JavaScript

Check if an array contains any element of another array in JavaScript

I have a target array [“apple”,”banana”,”orange”], and I want to check if other arrays contain any one of the target array elements.
For example:
[“apple”,”grape”] //returns true;

[“apple”,”banana”,”pineapple”] //returns true;

[“grape”, “pineapple”] //returns false;

How can I do it in JavaScript?


Solution 1:

Vanilla JS


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


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

How it works

some(..) checks each element of the array against a test function and returns true if any element of the array passes the test function, otherwise, it returns false. indexOf(..) >= 0 and includes(..) both return true if the given argument is present in the array.

Solution 2:

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

Solution 3:

If you’re not opposed to using a libray, has an intersection method, which can simplify this:

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]

The intersection function will return a new array with the items that it matched and if not matches it returns empty array.

Related:  underscore/lodash unique by multiple properties

Solution 4:

If you don’t need type coercion (because of the use of indexOf), you could try something like the following:

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;

Where arr contains the target items. At the end, found will show if the second array had at least one match against the target.

Of course, you can swap out numbers for anything you want to use – strings are fine, like your example.

And in my specific example, the result should be true because the second array’s 3 exists in the target.


Here’s how I’d organize it into a function (with some minor changes from before):

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;


Related:  Javascript. Assign array values to multiple variables? [duplicate]

In this case, the function could be modified to have targetArray be passed in as an argument instead of hardcoded in the closure.


While my solution above may work and be (hopefully more) readable, I believe the “better” way to handle the concept I described is to do something a little differently. The “problem” with the above solution is that the indexOf inside the loop causes the target array to be looped over completely for every item in the other array. This can easily be “fixed” by using a “lookup” (a map…a JavaScript object literal). This allows two simple loops, over each array. Here’s an example:

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;


Related:  How to use Javascript to read local text file and read line by line?

The downside to this solution is that only numbers and strings (and booleans) can be used (correctly), because the values are (implicitly) converted to strings and set as the keys to the lookup map. This isn’t exactly good/possible/easily done for non-literal values.

Solution 5:

ES6 (fastest)

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


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)



Solution 6:

Using filter/indexOf:

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


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



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