Tôi có một mảng mục tiêu ["apple","banana","orange"]và tôi muốn kiểm tra xem các mảng khác có chứa bất kỳ một trong các thành phần của mảng mục tiêu không.

Ví dụ:

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

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

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

Làm thế nào tôi có thể làm điều đó trong JavaScript?

Vanilla JS

ES2016:

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

ES6:

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

Làm thế nào nó hoạt động

some(..)kiểm tra từng phần tử của mảng dựa vào hàm kiểm tra và trả về true nếu bất kỳ phần tử nào của mảng vượt qua hàm kiểm tra, nếu không, nó trả về false. indexOf(..) >= 0và includes(..)cả hai đều trả về true nếu đối số đã cho có mặt trong mảng.

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

Nếu bạn không phản đối việc sử dụng libray, http://underscorejs.org/ có một phương thức giao nhau, có thể đơn giản hóa việc này:

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]

Hàm giao nhau sẽ trả về một mảng mới với các mục mà nó khớp và nếu không khớp thì nó trả về mảng trống.

ES6 (nhanh nhất)

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

Gạch dưới

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

Nếu bạn không cần ép buộc kiểu (vì sử dụng indexOf), bạn có thể thử một cái gì đó như sau:

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

Nơi arrchứa các mục tiêu. Cuối cùng, foundsẽ hiển thị nếu mảng thứ hai có ít nhất một trận đấu với mục tiêu.

Tất nhiên, bạn có thể trao đổi số cho bất cứ thứ gì bạn muốn sử dụng - chuỗi đều ổn, như ví dụ của bạn.

Và trong ví dụ cụ thể của tôi, kết quả sẽ là truedo mảng thứ hai 3tồn tại trong mục tiêu.

CẬP NHẬT:

Đây là cách tôi sắp xếp nó thành một chức năng (với một số thay đổi nhỏ so với trước):

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/

Trong trường hợp này, hàm có thể được sửa đổi để targetArrayđược truyền vào dưới dạng đối số thay vì mã hóa cứng trong bao đóng.

CẬP NHẬT2:

Mặc dù giải pháp của tôi ở trên có thể hoạt động và (hy vọng nhiều hơn) có thể đọc được, tôi tin rằng cách "tốt hơn" để xử lý khái niệm tôi mô tả là làm một cái gì đó hơi khác một chút. "Vấn đề" với giải pháp trên là indexOfbên trong vòng lặp làm cho mảng đích bị lặp hoàn toàn cho mọi mục trong mảng khác. Điều này có thể dễ dàng được "sửa" bằng cách sử dụng "tra cứu" (bản đồ ... một đối tượng JavaScript theo nghĩa đen). Điều này cho phép hai vòng đơn giản, trên mỗi mảng. Đây là một ví dụ:

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/

Nhược điểm của giải pháp này là chỉ có thể sử dụng số và chuỗi (và booleans), bởi vì các giá trị được (ngầm) chuyển đổi thành chuỗi và được đặt làm khóa cho bản đồ tra cứu. Điều này không chính xác tốt / có thể / dễ dàng thực hiện cho các giá trị phi chữ.

Giải pháp ES6:

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

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

Không giống như nó: Phải chứa tất cả các giá trị.

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

Hy vọng, sẽ hữu ích.

Bạn có thể sử dụng lodash và làm:

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

Đặt giao cắt được thực hiện trên cả hai bộ sưu tập tạo ra một mảng các phần tử giống hệt nhau.

Sử dụng bộ lọc / 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));
};

Hoặc thậm chí bạn có thể có hiệu suất tốt hơn nếu lần đầu tiên bạn tìm ra mảng nào trong hai mảng này dài hơn và tạo Setra mảng dài nhất, trong khi áp dụng somephương thức trên mảng ngắn nhất:

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

Tôi tìm thấy cú pháp ngắn và ngọt ngào này để khớp với tất cả hoặc một số phần tử giữa hai mảng. Ví dụ

// HOẶC thao tác. tìm nếu có bất kỳ phần tử mảng2 nào tồn tại trong mảng1. Điều này sẽ trở lại ngay khi có trận đấu đầu tiên khi một số phương thức bị phá vỡ khi hàm trả về TRUE

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

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

// in TRUE

// VÀ hoạt động. tìm nếu tất cả các phần tử mảng2 tồn tại trong mảng1. Điều này sẽ trở lại ngay khi không có kết quả khớp đầu tiên vì một số phương thức bị phá vỡ khi hàm trả về TRUE

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

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

// in SAI

Hy vọng rằng sẽ giúp được ai đó trong tương lai!

Bạn có thể sử dụng lệnh gọi Array.prototype.some lồng nhau. Điều này có lợi ích là nó sẽ bảo lãnh tại trận đấu đầu tiên thay vì các giải pháp khác sẽ chạy qua vòng lặp lồng nhau đầy đủ.

ví dụ.

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

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

Đây là một trường hợp thú vị tôi nghĩ tôi nên chia sẻ.

Giả sử bạn có một mảng các đối tượng và một loạt các bộ lọc được chọn.

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

const filters = ['foo'];

Để áp dụng các bộ lọc đã chọn cho cấu trúc này, chúng ta có thể

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

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

Tôi đã viết 3 giải pháp. Chủ yếu họ làm như vậy. Họ trở về đúng ngay khi nhận được true. Tôi đã viết 3 giải pháp chỉ để hiển thị 3 cách khác nhau để làm việc. Bây giờ, nó phụ thuộc vào những gì bạn thích nhiều hơn. Bạn có thể sử dụng Performance.now () để kiểm tra hiệu suất của giải pháp này hay giải pháp khác. Trong các giải pháp của tôi, tôi cũng đang kiểm tra mảng nào là lớn nhất và mảng nào là nhỏ nhất để hoạt động hiệu quả hơn.

Giải pháp thứ 3 có thể không phải là dễ thương nhất nhưng hiệu quả. Tôi quyết định thêm nó bởi vì trong một số cuộc phỏng vấn mã hóa, bạn không được phép sử dụng các phương thức tích hợp.

Cuối cùng, chắc chắn ... chúng ta có thể đưa ra giải pháp với 2 NESTED cho các vòng lặp (cách thức vũ phu) nhưng bạn muốn tránh điều đó vì độ phức tạp thời gian là xấu O (n ^ 2) .

Ghi chú:

thay vì sử dụng .includes()như một số người khác đã làm, bạn có thể sử dụng .indexOf(). nếu bạn chỉ kiểm tra xem giá trị có lớn hơn 0. Nếu giá trị không tồn tại sẽ cho bạn -1. nếu nó tồn tại, nó sẽ cho bạn lớn hơn 0.

indexOf () vs bao gồm ()

Cái nào tốt hơn hiệu suất ? indexOf()cho một chút, nhưng bao gồm là dễ đọc hơn theo ý kiến ​​của tôi.

Nếu tôi không nhầm .includes()và indexOf()sử dụng các vòng lặp phía sau hậu trường, thì bạn sẽ ở O (n ^ 2) khi sử dụng chúng .some().

Vòng lặp sử dụng

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

SỬ DỤNG .some ()

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

SỬ DỤNG MAPS Độ phức tạp thời gian 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;
};

Mã trong tôi: stackblitz

Tôi không phải là chuyên gia về hiệu suất cũng như BigO vì vậy nếu điều gì đó tôi nói là sai hãy cho tôi biết.

Còn việc sử dụng kết hợp một số / find Index và indexOf thì sao?

Vì vậy, một cái gì đó như thế này:

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

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

Để dễ đọc hơn, bạn có thể thêm chức năng này vào chính đối tượng 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;
}

Lưu ý: Nếu bạn muốn làm một cái gì đó với một vị từ, bạn có thể thay thế indexOf bên trong bằng một find Index khác và một vị từ

Giải pháp của tôi áp dụng các trình trợ giúp mảng Array.prototype.some () và Array.prototype.includes () làm công việc của họ khá hiệu quả.

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;

Chỉ một giải pháp nữa

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

Kiểm tra xem a1 có chứa tất cả phần tử của a2 không

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

Nó có thể được thực hiện bằng cách lặp lại qua mảng chính và kiểm tra xem mảng khác có chứa bất kỳ phần tử đích nào hay không.

Thử cái này:

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 tại JSFIDDLE

Với dấu gạch dưới

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

Thêm vào nguyên mẫu mảng

Tuyên bố từ chối trách nhiệm: Nhiều người sẽ khuyên mạnh mẽ chống lại điều này. Lần duy nhất nó thực sự là một vấn đề là nếu một thư viện thêm một hàm nguyên mẫu có cùng tên (hoạt động khác đi) hoặc đại loại như thế.

Mã số:

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

Không sử dụng các hàm mũi tên lớn:

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

Sử dụng

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

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

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

Vanilla JS với khớp một phần & không phân biệt chữ hoa chữ thường

Vấn đề với một số cách tiếp cận trước đó là chúng đòi hỏi phải khớp chính xác từng từ . Nhưng, nếu bạn muốn cung cấp kết quả cho một phần phù hợp thì sao?

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

Điều này hữu ích khi bạn muốn cung cấp hộp tìm kiếm nơi người dùng nhập từ và kết quả có thể có những từ đó theo bất kỳ thứ tự, vị trí và trường hợp nào.

Cập nhật câu trả lời includes@Paul Grimshaw, sử dụng ngay lập tức indexOfđể dễ đọc hơn

let Found = Array1.some (r => Array2.indexOf (r)> = 0)
let Found = Array1.some (r => Array2.includes (r))

Tôi đã đưa ra một giải pháp trong nút bằng cách sử dụng js gạch dưới như thế này:

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

Cá nhân, tôi sẽ sử dụng chức năng sau:

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

Phương thức "toString ()" sẽ luôn sử dụng dấu phẩy để phân tách các giá trị. Sẽ chỉ thực sự làm việc với các loại nguyên thủy.

Mảng .filter () với lệnh gọi lồng vào .find () sẽ trả về tất cả các phần tử trong mảng đầu tiên là thành viên của mảng thứ hai. Kiểm tra độ dài của mảng được trả về để xác định xem có bất kỳ mảng thứ hai nào trong mảng thứ nhất không.

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;