JavaScript에서 배열에 다른 배열 요소가 포함되어 있는지 확인합니다.

JavaScript에서 배열에 다른 배열 요소가 포함되어 있는지 확인합니다.

배열이 .["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 지정된 인수가 배열에 있으면 둘 다 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;
    });
};

@loganfsmyth에서 설명한 바와 같이 ES2016에서는 다음과 같이 단축할 수 있습니다.

/**
 * @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.
 */
const findOne = (haystack, arr) => {
    return arr.some(v => haystack.includes(v));
};

간단히 , ★★★★★★★★★★★★★★★★★★★★★.arr.some(v => haystack.includes(v));

어레이의 되어 있는지 하려면 를 .some()로로 합니다.every() 「」로 합니다.arr.every(v => haystack.includes(v));

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

호프, 도움이 될 거야.

라이브러리 사용에 반대하지 않는 경우, 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는 두 번째 배열이 타겟과 적어도1개 일치하는지 여부를 나타냅니다.

물론, 사용하고 싶은 숫자와 교환할 수 있습니다.문자열은 예시와 같이 괜찮습니다.

제 그는 '''로 되어 '''로 되어 있습니다.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하드코드 대신 인수로 제출됩니다.

---

업데이트 2:

상기의 솔루션이 기능해, 보다 읽기 쉬울지도 모르지만, 제가 설명한 컨셉을 다루는 「더 좋은」방법은, 조금 다른 것을 하는 것이라고 생각합니다.는 '문제'는 '문제'라는 입니다.indexOf되도록 합니다.「lookup」(「JavaScript」, 「JavaScript」)입니다.이것에 의해, 각 어레이에 대해서, 2개의 심플한 루프가 가능하게 됩니다.하다

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/

이 솔루션의 단점은 (암시적으로) 값이 문자열로 변환되어 검색 맵의 키로 설정되기 때문에 숫자와 문자열(및 부울란)만 올바르게 사용할 수 있다는 것입니다.이것은 비문자적 가치로는 그다지 좋은/가능한/쉽게 이루어지지 않는다.

필터/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"]));

Lodash를 사용하여 다음을 수행할 수 있습니다.

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

교차점 설정은 동일한 요소의 배열을 생성하는 두 집합에서 수행됩니다.

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

이 두 중 이 더 2배열을 만들면 더 좋은 성능을 수 .Set 긴에 대해 적용하면서 out을 합니다.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));
};

3번입니다.기본적으로 그들은 같은 일을 한다.그들은 받자마자 진실된 모습으로 돌아온다.true3가지 방법을 제시하기 위해 3가지 솔루션을 작성했습니다.네가 뭘 더 좋아하느냐에 달렸어performance.now()를 사용하여 어떤 솔루션의 성능을 확인할 수 있습니다.또, 솔루션에서는, 운용 효율을 높이기 위해서, 어느 어레이가 가장 큰지, 어느 어레이가 가장 작은지를 체크하고 있습니다.

세 번째 솔루션은 가장 귀엽지는 않지만 효율적입니다.일부 코딩 인터뷰에서는 임베디드 방식을 사용할 수 없기 때문에 추가하기로 했습니다.

마지막으로...루프에 대해 2개의 NESTED(브루트 포스 방식)가 있는 솔루션을 생각해 낼 수 있지만, 시간의 복잡성이 불량하기 때문에(n^2) 회피하는 것이 좋습니다.

주의:

''를 사용하는 대신..includes() 하다, 하다, 하다, 하다, 하다, 하다를 됩니다..indexOf() 0으로 하다값이 존재하지 않으면 -1이 되고, 값이 존재하면 0보다 큰 값이 됩니다.

index Of()와 includes()

어떤 게 성능이 더 좋습니까? indexOf()조금더더더더가가가것것것요요요요요요 。

.includes() ★★★★★★★★★★★★★★★★★」indexOf()무대 뒤에서 루프를 사용하기 때문에 O(n^2)와 함께 사용할 수 있습니다..some().

USING

 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도 아니기 때문에 혹시 잘못된 부분이 있으면 알려주세요.

이 짧고 달콤한 구문은 두 배열 사이의 모든 요소 또는 일부 요소를 일치시킵니다.예를들면

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

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

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

// TRUE 인쇄

// AND 동작.array1에 모든 array2 요소가 존재하는지 확인합니다.이 값은 함수가 TRUE를 반환할 때 일부 메서드가 중단되므로 처음 일치하는 항목이 없으면 즉시 반환됩니다.

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

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

// FALSE 출력

그것이 미래에 누군가에게 도움이 되기를 바랍니다!

중첩된 Array.protype을 사용할 수 있습니다.전화 왔어요.이렇게 하면 풀네스트 루프를 통과하는 다른 솔루션이 아닌 첫 번째 일치로 회피할 수 있다는 장점이 있습니다.

예:

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

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

한 가지 솔루션만 더

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)

일부/findIndex와 indOf를 조합하여 사용하면 어떨까요?

예를 들어 다음과 같습니다.

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

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

읽기 쉽게 하려면 어레이 개체 자체에 이 기능을 추가할 수 있습니다.

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

여기 제가 공유해야 할 흥미로운 사례가 있습니다.

객체 배열과 선택한 필터 배열이 있다고 가정합니다.

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

어레이 프로토타입에 추가

면책사항:많은 사람들이 이에 대해 강력히 반대할 것이다.라이브러리가 같은 이름의 프로토타입 기능(동작이 다른 기능)을 추가했을 경우만 문제가 될 수 있습니다.

코드:

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

이 솔루션은 Array.protype.some() 및 Array.protype.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;

당신의 답변을 봤을 때 원하는 답변을 찾을 수 없었습니다.제가 직접 한 일이 있는데 이걸 여러분들과 공유하고 싶어요.

입력한 (배열) 단어가 정확할 경우에만 해당됩니다.

function contains(a,b) {
    let counter = 0;
    for(var i = 0; i < b.length; i++) {;
        if(a.includes(b[i])) counter++;
    }
    if(counter === b.length) return true;
    return false;
}

let main_array = ['foo','bar','baz'];
let sub_array_a = ['foo','foobar'];
let sub_array_b = ['foo','bar'];

console.log(contains(main_array, sub_array_a)); // returns false
console.log(contains(main_array,sub_array_b )); // returns true

메인 어레이 전체에서 반복하여 다른 어레이에 타겟 요소가 포함되어 있는지 여부를 확인하는 것만으로 실행할 수 있습니다.

이것을 시험해 보세요.

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

JSFIDLE에서의 데모

퍼포먼스 면에서는 이 방법이 얼마나 효율적일지 모르겠지만 어레이 파괴 기능을 사용하여 모든 것을 단기간에 유지할 수 있습니다.

const shareElements = (arr1, arr2) => {
  const typeArr = [...arr1, ...arr2]
  const typeSet = new Set(typeArr)
  return typeArr.length > typeSet.size
}

집합은 중복 요소를 가질 수 없지만 배열은 중복 요소를 가질 수 있으므로 두 입력 배열을 조합하여 세트로 변환하고 설정된 크기와 배열 길이를 비교하면 두 요소가 공유되는지 여부를 알 수 있습니다.

뛰어난 퍼포먼스 솔루션:

어레이 중 하나를 개체로 변환해야 합니다.

const contains = (arr1, mainObj) => arr1.some(el => el in mainObj);
const includes = (arr1, mainObj) => arr1.every(el => el in mainObj);

사용방법:

const mainList = ["apple", "banana", "orange"];
// We make object from array, you can use your solution to make it
const main = Object.fromEntries(mainList.map(key => [key, true]));

contains(["apple","grape"], main) // => true
contains(["apple","banana","pineapple"], main) // =>  true
contains(["grape", "pineapple"], main) // =>  false

includes(["apple", "grape"], main) // => false
includes(["banana", "apple"], main) // =>  true

obj[key] 체커로 솔루션을 변경할 수 있도록 연산자에 의한 체크인이라는 단점이 있습니다(예: {} // = > true의 'toString').

★★★★.filter() 콜을 하여 " "로 이동합니다..find()는 첫 번째 배열 내의 두 번째 배열 멤버인 모든 요소를 반환합니다.반환된 어레이의 길이를 조사하여 첫 번째 어레이에 두 번째 어레이가 있는지 확인합니다.

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

밑줄 포함

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

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 사용, @Paul Grimshaw 사용includes inst inst of of를 indexOf을 위해

=> 0)=arr1.some(r=>ar2.indexOf(r)>= 0)을 .
=>r)=arr1.somet(r=>ar2.somet(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()" 메서드는 항상 쉼표를 사용하여 값을 구분합니다.원시적인 유형에서만 작동합니다.

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;

당신은 이런 것을 할 수 있다.

let filteredArray = array.filter((elm) => {
   for (let i=0; i<anotherAray.length; i++) {
      return elm.includes(anotherArray[i])
    }
  })

언급URL : https://stackoverflow.com/questions/16312528/check-if-an-array-contains-any-element-of-another-array-in-javascript