У мене є цільовий масив ["apple","banana","orange"], і я хочу перевірити, чи містять інші масиви якийсь із елементів цільового масиву.

Наприклад:

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

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

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

Як я можу це зробити в JavaScript?

Ваніль 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(..)обидва повертають істину, якщо даний аргумент присутній у масиві.

ванільний 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;
    });
};

Якщо ви не проти використання бібліотеки, 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]

Функція перетину поверне новий масив з елементами, які він збіг, а якщо не відповідає, повертає порожній масив.

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)

DEMO: https://jsfiddle.net/r257wuv5/

jsPerf: https://jsperf.com/array-contains-any-element-of-another-array

Якщо вам не потрібен примус введення (через використання 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;
}());

DEMO: 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;
};

DEMO: http://jsfiddle.net/5Lv9v/

Мінус цього рішення полягає в тому, що можна використовувати (правильно) лише числа і рядки (і булеві), оскільки значення (неявно) перетворюються на рядки і встановлюються як ключі до карти пошуку. Це не зовсім добре / можливо / легко зробити для нелітеральних значень.

Рішення 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) );

Сподіваюся, буде корисно.

Ви можете використовувати lodash і робити:

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

Встановлення перетину робиться для обох колекцій, створюючи масив однакових елементів.

Використання фільтра / 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"]));

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

Я знайшов цей короткий і солодкий синтаксис, який відповідає всім або деяким елементам між двома масивами. Наприклад

// АБО операція. знайдіть, чи існує який-небудь з елементів array2 в array1. Це повернеться, як тільки відбудеться перша відповідність, оскільки деякий метод перерветься, коли функція поверне TRUE

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

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

// друкує ІСТИНА

// І операція. виявити, чи всі елементи array2 існують в array1. Це повернеться, як тільки не буде першого збігу, оскільки деякий метод порушується, коли функція повертає TRUE

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

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

// друкує FALSE

Сподіваюся, що допоможе комусь у майбутньому!

Ви можете використовувати вкладений виклик Array.prototype.some. Це має таку перевагу, що вона буде порушена під час першого матчу замість інших рішень, які будуть проходити через повний вкладений цикл.

напр.

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

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

Ось цікавий випадок, про який я думав, що мушу поділитися.

Скажімо, у вас є масив об'єктів та масив вибраних фільтрів.

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

Я написав 3 рішення. По суті вони роблять те саме. Вони повертаються справжніми, як тільки отримують true. Я написав 3 рішення просто для показу 3 різних способів робити речі. Тепер, залежить, що вам більше подобається. Ви можете скористатися performance.now (), щоб перевірити ефективність того чи іншого рішення. У своїх рішеннях я також перевіряю, який масив є найбільшим, а який - найменшим, щоб зробити операції більш ефективними.

3-е рішення може бути не найсильнішим, але ефективним. Я вирішив додати його, оскільки в деяких інтерв'ю з кодуванням вам заборонено використовувати вбудовані методи.

Нарешті, звичайно ... ми можемо придумати рішення з 2 NESTED для циклів (брутальний спосіб), але ви хочете цього уникнути, оскільки складність у часі погана O (n ^ 2) .

Примітка:

замість того, щоб використовувати, .includes()як це робили інші люди, ви можете використовувати .indexOf(). якщо ви просто перевірте, чи значення більше 0. Якщо значення не існує, ви отримаєте -1. якщо він існує, він дасть вам більше 0.

indexOf () vs включає ()

У кого кращі показники ? indexOf()трохи, але включає, на мій погляд, легше читати.

Якщо я не помиляюся .includes()і indexOf()використовую петлі за сценою, то ви будете знаходитись на O (n ^ 2), коли використовуєте їх .some().

ВИКОРИСТАННЯ петлі

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

ВИКОРИСТАННЯ КАРТІ Складність часу 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, тому якщо щось, про що я казав, є неправильним, дайте мені знати.

Що з використанням комбінації деяких / 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 та предикатом

У моєму рішенні застосовуються помічники масивів 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;

Ще одне рішення

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)

Це можна зробити просто ітерацією через основний масив і перевірити, чи містить інший масив якийсь із цільових елементів чи ні.

Спробуйте це:

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 на JSFIDDLE

З підкресленнями

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

Додавання до прототипу масиву

Відмова: Багато хто настійно не радить цього. Єдиний раз, коли б це було справді проблемою, було б, якщо бібліотека додала функцію прототипу з тим самим іменем (яка поводилася по-різному) або щось подібне.

Код:

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

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"]

Це корисно, коли ви хочете вказати вікно пошуку, де користувачі вводять слова та результати можуть мати ці слова в будь-якому порядку, позиції та регістрі.

Оновіть @Paul Grimshaw відповідь, використовуйте includesнакреслений indexOfдля більш читабельного

нехай знайдено = arr1.some (r => arr2.indexOf (r)> = 0)
нехай знайдено = arr1.some (r => arr2.cludes (r))

Я придумав рішення у вузлі, використовуючи підкреслення js, як це:

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

Особисто я використовував би таку функцію:

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

Метод "toString ()" завжди використовуватиме коми для розділення значень. Дійсно працюватимуть лише з примітивними типами.

Масив .filter () з вкладеним викликом до .find () поверне всі елементи першого масиву, що є членами другого масиву. Перевірте довжину повернутого масиву, щоб визначити, чи хтось із другого масиву був у першому масиві.

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

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

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;