Mam tablicę docelową ["apple","banana","orange"]i chcę sprawdzić, czy inne tablice zawierają jeden z elementów tablicy docelowej.

Na przykład:

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

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

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

Jak mogę to zrobić w JavaScript?

Vanilla JS

ES2016:

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

ES6:

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

Jak to działa

some(..)sprawdza każdy element tablicy względem funkcji testowej i zwraca true, jeśli jakikolwiek element tablicy przejdzie funkcję testową, w przeciwnym razie zwraca false. indexOf(..) >= 0i includes(..)oba zwracają wartość true, jeśli podany argument jest obecny w tablicy.

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

Jeśli nie masz nic przeciwko używaniu libray, http://underscorejs.org/ ma metodę przecięcia, która może to uprościć:

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]

Funkcja przecięcia zwróci nową tablicę z dopasowanymi elementami, a jeśli nie pasuje, zwróci pustą tablicę.

ES6 (najszybszy)

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

Podkreślać

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

Jeśli nie potrzebujesz przymusu typu (z powodu użycia indexOf), możesz spróbować czegoś takiego:

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

Gdzie arrzawiera elementy docelowe. Na koniec foundpokaże, czy druga tablica miała co najmniej jedno dopasowanie do celu.

Oczywiście możesz zamienić liczby na wszystko, czego chcesz użyć - ciągi znaków są w porządku, tak jak w twoim przykładzie.

W moim konkretnym przykładzie wynik powinien wynikać z truetego, że druga tablica 3istnieje w celu.

AKTUALIZACJA:

Oto jak zorganizowałbym to w funkcję (z pewnymi drobnymi zmianami wcześniej):

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/

W takim przypadku funkcję można zmodyfikować, aby targetArrayzostała przekazana jako argument zamiast zakodowana na stałe w zamknięciu.

AKTUALIZACJA 2:

Chociaż moje powyższe rozwiązanie może działać i być (mam nadzieję, że więcej) czytelne, uważam, że „lepszym” sposobem radzenia sobie z opisaną przeze mnie koncepcją jest zrobienie czegoś nieco inaczej. „Problem” z powyższym rozwiązaniem polega na tym, że indexOfwewnętrzna pętla powoduje całkowite zapętlenie tablicy docelowej dla każdego elementu w drugiej tablicy. Można to łatwo „naprawić” za pomocą „wyszukiwania” (mapa ... dosłownie obiekt JavaScript). Pozwala to na dwie proste pętle na każdą tablicę. Oto przykład:

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

PRÓBNY: http://jsfiddle.net/5Lv9v/

Minusem tego rozwiązania jest to, że tylko liczby i ciągi (i logiczne) mogą być używane (poprawnie), ponieważ wartości są (domyślnie) konwertowane na ciągi i ustawiane jako klucze do mapy wyszukiwania. Nie jest to do końca dobre / możliwe / łatwe do wykonania dla wartości nieliteralnych.

Rozwiązanie ES6:

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

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

W przeciwieństwie do tego: Must zawiera wszystkie wartości.

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

Mam nadzieję, że będzie pomocna.

Możesz użyć lodash i zrobić:

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

Przecięcie zestawu odbywa się w obu kolekcjach, tworząc tablicę identycznych elementów.

Korzystanie z filtru / indeksu :

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

Lub możesz nawet uzyskać lepszą wydajność, jeśli najpierw dowiesz się, która z tych dwóch tablic jest dłuższa i robisz Setnajdłuższą tablicę, stosując somemetodę na najkrótszej:

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

Znalazłem tę krótką i słodką składnię pasującą do wszystkich lub niektórych elementów między dwiema tablicami. Na przykład

// LUB operacja. sprawdź, czy którykolwiek z elementów tablicy2 istnieje w tablicy1. Zwróci się, gdy tylko pojawi się pierwsze dopasowanie, ponieważ jakaś metoda psuje się, gdy funkcja zwraca PRAWDA

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

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

// drukuje PRAWDA

// ORAZ operacja. sprawdź, czy wszystkie elementy tablicy2 istnieją w tablicy1. Zwróci się, jak tylko nie będzie pierwszego dopasowania, ponieważ jakaś metoda psuje się, gdy funkcja zwraca PRAWDA

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

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

// drukuje FAŁSZ

Mam nadzieję, że pomoże komuś w przyszłości!

Możesz użyć zagnieżdżonego wywołania Array.prototype.some. Ma to tę zaletę, że zostanie zwolniony za kaucją przy pierwszym dopasowaniu zamiast innych rozwiązań, które będą przebiegać przez pełną zagnieżdżoną pętlę.

na przykład.

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

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

Oto interesujący przypadek, który powinienem podzielić.

Powiedzmy, że masz tablicę obiektów i tablicę wybranych filtrów.

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

const filters = ['foo'];

Aby zastosować wybrane filtry do tej struktury, możemy

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

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

Napisałem 3 rozwiązania. Zasadniczo robią to samo. Powracają prawdziwe, gdy tylko się pojawią true. Napisałem 3 rozwiązania tylko dla pokazania 3 różnych sposobów robienia rzeczy. Teraz zależy to, co lubisz bardziej. Możesz użyć performance.now (), aby sprawdzić wydajność jednego lub drugiego rozwiązania. W moich rozwiązaniach sprawdzam również, która tablica jest największa, a która najmniejsza, aby zwiększyć wydajność operacji.

Trzecie rozwiązanie może nie być najsłodsze, ale jest wydajne. Zdecydowałem się to dodać, ponieważ w niektórych wywiadach dotyczących kodowania nie wolno używać metod wbudowanych.

Wreszcie, pewnie ... możemy wymyślić rozwiązanie z 2 NESTED dla pętli (metoda brutalnej siły), ale chcesz tego uniknąć, ponieważ złożoność czasu jest zła O (n ^ 2) .

Uwaga:

zamiast używać .includes()tak jak niektóre inne osoby, możesz użyć .indexOf(). jeśli to zrobisz, po prostu sprawdź, czy wartość jest większa niż 0. Jeśli wartość nie istnieje, otrzymasz -1. jeśli istnieje, da ci więcej niż 0.

indexOf () vs obejmuje ()

Który ma lepszą wydajność ?indexOf()trochę, ale zawiera, moim zdaniem, bardziej czytelny.

Jeśli się nie mylę .includes()i indexOf()używam pętli za sceną, będziesz przy O (n ^ 2) , używając ich z .some().

UŻYWANIE pętli

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

KORZYSTANIE z .some ()

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

KORZYSTANIE Z MAPY Złożoność czasu 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;
};

Kod w moim: stackblitz

Nie jestem ekspertem od wydajności ani BigO, więc jeśli coś, co powiedziałem, jest złe, daj mi znać.

Co powiesz na użycie kombinacji niektórych / findIndex i indexOf?

Więc coś takiego:

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

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

Aby uczynić go bardziej czytelnym, możesz dodać tę funkcjonalność do samego obiektu 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;
}

Uwaga: jeśli chcesz zrobić coś z predykatem, możesz zastąpić wewnętrzny indexOf innym findIndex i predykatem

Moje rozwiązanie stosuje pomocniki tablic Array.prototype.some () i Array.prototype.includes (), które również wykonują swoją pracę całkiem wydajnie

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;

Jeszcze jedno rozwiązanie

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

Sprawdź, czy a1 zawiera cały element a2

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

Można to zrobić po prostu iterując po głównej tablicy i sprawdzając, czy inna tablica zawiera element docelowy, czy nie.

Spróbuj tego:

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

Z podkreślnikami

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

Dodanie do prototypu macierzy

Uwaga: Wielu zdecydowanie odradza to. Jedynym problemem, kiedy naprawdę byłby problem, było dodanie przez bibliotekę funkcji prototypu o tej samej nazwie (która zachowywała się inaczej) lub czegoś takiego.

Kod:

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

Bez użycia funkcji dużych strzałek:

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

Stosowanie

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

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

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

Waniliowy JS z częściowym dopasowaniem i bez rozróżniania wielkości liter

Problem z niektórymi wcześniejszymi podejściami polega na tym, że wymagają one dokładnego dopasowania każdego słowa . Ale co jeśli chcesz podać wyniki dla częściowych dopasowań?

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

Jest to przydatne, gdy chcesz podać pole wyszukiwania, w którym użytkownicy wpisują słowa, a wyniki mogą mieć te słowa w dowolnej kolejności, pozycji i wielkości.

Zaktualizuj odpowiedź @Paul Grimshaw, użyj includesinsteed indexOfdla bardziej czytelnego

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

Wymyśliłem rozwiązanie w węźle, używając podkreślenia js w następujący sposób:

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

Osobiście użyłbym następującej funkcji:

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

Metoda „toString ()” zawsze używa przecinków do oddzielenia wartości. Naprawdę będzie działać tylko z typami pierwotnymi.

Array .filter () z zagnieżdżonym wywołaniem do .find () zwróci wszystkie elementy w pierwszej tablicy, które są członkami drugiej tablicy. Sprawdź długość zwróconej tablicy, aby ustalić, czy któraś z drugiej tablicy znajdowała się w pierwszej tablicy.

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;