대상 배열 ["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(..)주어진 인수는 어레이에있는 경우 모두 true를 반환.

바닐라 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;
    });
};

libray 사용에 반대하지 않는 경우 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)

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

데모 : http://jsfiddle.net/u8Bzt/

이 경우 targetArray클로저에서 하드 코딩되는 대신 인수로 전달 되도록 함수를 수정할 수 있습니다 .

UPDATE2 :

위의 솔루션이 효과가 있고 읽을 수 있지만 (더 나은) 읽을 수는 있지만 설명 된 개념을 처리하는 "더 나은"방법은 약간 다르게 행동하는 것입니다. 위의 솔루션의 "문제" 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/

이 솔루션의 단점은 값이 (암시 적으로) 문자열로 변환되고 조회 맵의 키로 설정되기 때문에 숫자와 문자열 (및 부울) 만 (올바르게) 사용할 수 있다는 것입니다. 이것은 리터럴이 아닌 값에 대해 정확하거나 적합하지 않거나 쉽게 수행되지 않습니다.

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

이 짧고 달콤한 구문이 두 배열 사이의 모든 또는 일부 요소와 일치한다는 것을 알았습니다. 예를 들어

// OR 연산. array1에 array2 요소가 있는지 확인하십시오. 함수가 TRUE를 반환 할 때 일부 메서드가 중단되면 첫 번째 일치 항목이있는 즉시 반환됩니다.

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

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

// TRUE를 인쇄합니다

// AND 연산. 모든 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를 반환합니다 true. 나는 3 가지 다른 일을하는 방법을 보여주기 위해 3 가지 솔루션을 썼습니다. 이제는 더 좋아하는 것에 달려 있습니다. performance.now () 를 사용 하여 한 솔루션 또는 다른 솔루션의 성능을 확인할 수 있습니다 . 내 솔루션에서 나는 어떤 배열이 가장 크고 어떤 배열이 가장 효율적으로 작동하는지 확인하고 있습니다.

세 번째 해결책은 가장 귀엽지는 않지만 효율적입니다. 일부 코딩 인터뷰에서는 내장 방법을 사용할 수 없으므로 추가하기로 결정했습니다.

마지막으로, 확실히 ... 우리는 2 개의 NESTED for loops (무차별 강제 방법)가있는 솔루션을 제안 할 수 있지만 시간 복잡성이 나쁘기 때문에 피하고 싶습니다 .O (n ^ 2) .

노트 :

.includes()다른 사람들처럼 사용하는 대신을 사용할 수 있습니다 .indexOf(). 값이 0보다 큰지 확인하면 값이 존재하지 않으면 -1이됩니다. 존재하면 0보다 큽니다.

indexOf () 대 include ()

어느 쪽이 더 나은 성능을 가지고 있습니까? 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));
};

MAPS 사용 시간 복잡도 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의 전문가가 아니기 때문에 내가 말한 것이 잘못되면 알려주세요.

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와 술어로 대체 할 수 있습니다

내 솔루션은 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));

JSFIDDLE의 데모

와 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

배열 프로토 타입에 추가

면책 조항 : 많은 사람들이 이것에 대해 강력히 권고합니다. 실제로 문제가되는 유일한 시간은 라이브러리가 동일한 이름 (다른 방식으로 작동) 또는 이와 유사한 프로토 타입 함수를 추가 한 경우였습니다.

암호:

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

부분 일치 및 대소 문자를 구분하지 않는 바닐라 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"]

사용자가 단어를 입력하고 검색 결과에 순서, 위치 및 대 / 소문자를 지정할 수있는 검색 상자를 제공하려는 경우에 유용합니다.

업데이트 @ 폴 그림 셔의 대답은, 사용 includes의 insteed indexOf더 읽기 위해

찾자 = arr1.some (r => arr2.indexOf (r)> = 0)
보자 = arr1.some (r => arr2.includes (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 ()"메소드는 항상 쉼표를 사용하여 값을 구분합니다. 기본 유형에서만 실제로 작동합니다.

.find ()에 대한 중첩 호출이있는 Array .filter ()는 첫 번째 배열에서 두 번째 배열의 구성원 인 모든 요소를 ​​반환합니다. 반환 된 배열의 길이를 확인하여 두 번째 배열 중 하나가 첫 번째 배열에 있는지 확인하십시오.

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;