J'ai un tableau cible ["apple","banana","orange"]et je veux vérifier si d'autres tableaux contiennent l'un des éléments du tableau cible.

Par exemple:

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

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

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

Comment puis-je le faire en JavaScript?

Vanilla JS

ES2016:

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

ES6:

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

Comment ça fonctionne

some(..)vérifie chaque élément du tableau par rapport à une fonction de test et renvoie vrai si un élément du tableau réussit la fonction de test, sinon, il renvoie faux. indexOf(..) >= 0etincludes(..) deux retournent vrai si l'argument donné est présent dans le tableau.

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

Si vous n'êtes pas opposé à l'utilisation d'un libray, http://underscorejs.org/ a une méthode d'intersection, ce qui peut simplifier ceci:

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]

La fonction d'intersection renverra un nouveau tableau avec les éléments auxquels elle correspond et sinon, elle renvoie un tableau vide.

ES6 (le plus rapide)

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

Souligner

const a = ['a', 'b', 'c'];
const b = ['c', 'a', 'd'];
_.intersection(a, b)

DÉMO: https://jsfiddle.net/r257wuv5/

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

Si vous n'avez pas besoin de coercition de type (en raison de l'utilisation de indexOf), vous pouvez essayer quelque chose comme ceci:

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

Où arrcontient les éléments cibles. À la fin, foundaffichera si le deuxième tableau avait au moins un correspondance avec la cible.

Bien sûr, vous pouvez échanger des chiffres pour tout ce que vous souhaitez utiliser - les chaînes sont très bien, comme votre exemple.

Et dans mon exemple spécifique, le résultat devrait être truedû au fait que le second tableau 3existe dans la cible.

MISE À JOUR:

Voici comment je l'organiserais en fonction (avec quelques modifications mineures par rapport à avant):

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

DÉMO: http://jsfiddle.net/u8Bzt/

Dans ce cas, la fonction peut être modifiée pour targetArrayêtre passée en argument au lieu d'être codée en dur dans la fermeture.

MISE À JOUR2:

Bien que ma solution ci-dessus puisse fonctionner et être (espérons-le plus) lisible, je pense que la "meilleure" façon de gérer le concept que j'ai décrit est de faire quelque chose d'un peu différemment. Le "problème" avec la solution ci-dessus est que l' indexOfintérieur de la boucle provoque le bouclage complet du tableau cible pour chaque élément de l'autre tableau. Cela peut facilement être "corrigé" en utilisant une "recherche" (une carte ... un objet JavaScript littéral). Cela permet deux boucles simples, sur chaque tableau. Voici un exemple:

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

DÉMO: http://jsfiddle.net/5Lv9v/

L'inconvénient de cette solution est que seuls les nombres et les chaînes (et les booléens) peuvent être utilisés (correctement), car les valeurs sont (implicitement) converties en chaînes et définies comme clés de la carte de recherche. Ce n'est pas exactement bon / possible / facile à faire pour les valeurs non littérales.

Solution ES6:

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

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

Contrairement à lui: Must contient toutes les valeurs.

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

J'espère, sera utile.

Vous pouvez utiliser lodash et faire:

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

Définir l'intersection se fait sur les deux collections produisant un tableau d'éléments identiques.

Utilisation de 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"]));

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

Ou vous pouvez même avoir de meilleures performances si vous découvrez d'abord lequel de ces deux tableaux est le plus long et que Setvous recherchez le tableau le plus long, tout en appliquant la someméthode sur le plus court:

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

J'ai trouvé cette syntaxe courte et douce pour faire correspondre tout ou partie des éléments entre deux tableaux. Par exemple

// Opération OR. rechercher si l'un des éléments du tableau2 existe dans le tableau1. Cela reviendra dès qu'il y aura une première correspondance car une méthode se casse lorsque la fonction retourne TRUE

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

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

// imprime VRAI

// ET opération. trouver si tous les éléments de array2 existent dans array1. Cela reviendra dès qu'il n'y aura pas de première correspondance car une méthode se casse lorsque la fonction retourne TRUE

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

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

// imprime FAUX

J'espère que cela aidera quelqu'un à l'avenir!

Vous pouvez utiliser un appel Array.prototype.some imbriqué. Cela présente l'avantage qu'il sera libéré lors du premier match au lieu d'autres solutions qui s'exécuteront dans la boucle imbriquée complète.

par exemple.

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

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

Voici un cas intéressant que je pensais devoir partager.

Disons que vous avez un tableau d'objets et un tableau de filtres sélectionnés.

let arr = [
  { id: 'x', tags: ['foo'] },
  { id: 'y', tags: ['foo', 'bar'] },
  { id: 'z', tags: ['baz'] }
];

const filters = ['foo'];

Pour appliquer les filtres sélectionnés à cette structure, nous pouvons

if (filters.length > 0)
  arr = arr.filter(obj =>
    obj.tags.some(tag => filters.includes(tag))
  );

// [
//   { id: 'x', tags: ['foo'] },
//   { id: 'y', tags: ['foo', 'bar'] }
// ]

J'ai écrit 3 solutions. Ils font essentiellement la même chose. Ils reviennent vrai dès qu'ils arrivent true. J'ai écrit les 3 solutions juste pour montrer 3 façons différentes de faire les choses. Maintenant, cela dépend de ce que vous aimez le plus. Vous pouvez utiliser performance.now () pour vérifier les performances d'une solution ou de l'autre. Dans mes solutions, je vérifie également quelle baie est la plus grande et laquelle est la plus petite pour rendre les opérations plus efficaces.

La 3ème solution n'est peut-être pas la plus mignonne mais elle est efficace. J'ai décidé de l'ajouter car dans certaines interviews de codage, vous n'êtes pas autorisé à utiliser des méthodes intégrées.

Enfin, bien sûr ... nous pouvons trouver une solution avec 2 NESTED pour les boucles (à la manière de la force brute) mais vous voulez éviter cela car la complexité temporelle est mauvaise O (n ^ 2) .

Remarque:

au lieu d'utiliser .includes()comme certaines autres personnes, vous pouvez utiliser .indexOf(). si vous vérifiez simplement si la valeur est supérieure à 0. Si la valeur n'existe pas, vous obtiendrez -1. s'il existe, il vous donnera plus de 0.

indexOf () vs inclut ()

Lequel a de meilleures performances ? indexOf()pour un peu, mais comprend est plus lisible à mon avis.

Si je ne me trompe pas .includes()et que indexOf()j'utilise des boucles en arrière-plan, vous serez donc à O (n ^ 2) lorsque vous les utiliserez avec .some().

UTILISATION de la boucle

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

UTILISATION de .some ()

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

UTILISATION DES CARTES Complexité temporelle 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;
};

Code dans mon: stackblitz

Je ne suis pas un expert en performance ni en BigO, donc si quelque chose que j'ai dit ne va pas, faites le moi savoir.

Qu'en est-il de l'utilisation d'une combinaison de some / findIndex et indexOf?

Donc quelque chose comme ça:

var array1 = ["apple","banana","orange"];
var array2 = ["grape", "pineapple"];

var found = array1.some(function(v) { return array2.indexOf(v) != -1; });

Pour le rendre plus lisible, vous pouvez ajouter cette fonctionnalité à l'objet Array lui-même.

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

Remarque: Si vous souhaitez faire quelque chose avec un prédicat, vous pouvez remplacer l'indexOf interne par un autre findIndex et un prédicat

Ma solution applique Array.prototype.some () et Array.prototype.includes () qui font également leur travail assez efficacement

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;

Encore une solution

var a1 = [1, 2, 3, 4, 5]
var a2 = [2, 4]

Vérifiez si a1 contient tous les éléments de a2

var result = a1.filter(e => a2.indexOf(e) !== -1).length === a2.length
console.log(result)

Cela peut être fait en parcourant simplement le tableau principal et en vérifiant si un autre tableau contient ou non l'élément cible.

Essaye ça:

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 chez JSFIDDLE

Avec 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

Ajout au prototype de tableau

Avertissement: Beaucoup déconseillent fortement cela. La seule fois où ce serait vraiment un problème, c'est si une bibliothèque ajoute une fonction prototype avec le même nom (qui se comporte différemment) ou quelque chose comme ça.

Code:

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

Sans utiliser les fonctions de grosse flèche:

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

Usage

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

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

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

Vanilla JS avec correspondance partielle et insensible à la casse

Le problème avec certaines approches précédentes est qu'elles nécessitent une correspondance exacte de chaque mot . Mais, que se passe-t-il si vous souhaitez fournir des résultats pour les correspondances partielles?

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

Ceci est utile lorsque vous souhaitez fournir une zone de recherche dans laquelle les utilisateurs tapent des mots et les résultats peuvent avoir ces mots dans n'importe quel ordre, position et casse.

Mettez à jour la réponse @Paul Grimshaw, utilisez includesinsteed of indexOfpour plus de lisibilité

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

J'ai trouvé une solution dans le nœud en utilisant des js de soulignement comme ceci:

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

Personnellement, j'utiliserais la fonction suivante:

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

La méthode "toString ()" utilisera toujours des virgules pour séparer les valeurs. Ne fonctionnera vraiment qu'avec des types primitifs.

Le tableau .filter () avec un appel imbriqué à .find () renverra tous les éléments du premier tableau qui sont membres du second tableau. Vérifiez la longueur du tableau renvoyé pour déterminer si l'un des deuxièmes tableaux se trouvait dans le premier tableau.

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;