Saya memiliki array target ["apple","banana","orange"] , dan saya ingin memeriksa apakah array lain mengandung salah satu elemen array target.

Sebagai contoh:

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

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

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

Bagaimana saya bisa melakukannya dalam JavaScript?

Vanilla JS

ES2016:

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

ES6:

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

Bagaimana itu bekerja

some(..)memeriksa setiap elemen array terhadap fungsi tes dan mengembalikan true jika ada elemen array melewati fungsi tes, jika tidak, ia mengembalikan false. indexOf(..) >= 0dan includes(..)keduanya mengembalikan true jika argumen yang diberikan hadir dalam array.

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

Jika Anda tidak menentang menggunakan libray, http://underscorejs.org/ memiliki metode persimpangan, yang dapat menyederhanakan ini:

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]

Fungsi persimpangan akan mengembalikan array baru dengan item yang cocok dan jika tidak cocok itu mengembalikan array kosong.

ES6 (tercepat)

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

Menggarisbawahi

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

Jika Anda tidak perlu mengetikkan paksaan (karena penggunaan indexOf), Anda dapat mencoba sesuatu seperti berikut:

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

Di mana arrberisi item target. Pada akhirnya, foundakan muncul apakah array kedua memiliki paling tidak satu pertandingan melawan target.

Tentu saja, Anda dapat menukar nomor dengan apa pun yang ingin Anda gunakan - string baik-baik saja, seperti contoh Anda.

Dan dalam contoh spesifik saya, hasilnya seharusnya truekarena array kedua 3ada di target.

MEMPERBARUI:

Inilah cara saya mengaturnya menjadi suatu fungsi (dengan beberapa perubahan kecil dari sebelumnya):

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/

Dalam hal ini, fungsi tersebut dapat dimodifikasi untuk targetArrayditeruskan sebagai argumen alih-alih hardcoded dalam penutupan.

UPDATE2:

Sementara solusi saya di atas mungkin berhasil dan (mudah-mudahan lebih) dapat dibaca, saya percaya cara "lebih baik" untuk menangani konsep yang saya jelaskan adalah melakukan sesuatu yang sedikit berbeda. "Masalah" dengan solusi di atas adalah bahwa di indexOfdalam loop menyebabkan array target di-loop sepenuhnya untuk setiap item dalam array lain. Ini dapat dengan mudah "diperbaiki" dengan menggunakan "pencarian" (peta ... objek JavaScript literal). Ini memungkinkan dua loop sederhana, di atas setiap array. Ini sebuah contoh:

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/

Kelemahan dari solusi ini adalah hanya angka dan string (dan boolean) yang dapat digunakan (dengan benar), karena nilainya (secara implisit) dikonversi menjadi string dan ditetapkan sebagai kunci untuk peta pencarian. Ini tidak sepenuhnya baik / mungkin / mudah dilakukan untuk nilai-nilai non-literal.

Solusi ES6:

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

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

Berbeda dengan itu: Harus mengandung semua nilai.

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

Semoga bermanfaat.

Anda bisa menggunakan lodash dan melakukan:

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

Set intersection dilakukan pada kedua koleksi yang menghasilkan array elemen identik.

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

Atau Anda bahkan dapat memiliki kinerja yang lebih baik jika Anda pertama kali mengetahui yang mana dari dua array ini yang lebih panjang dan menghasilkan Setarray yang paling panjang, sambil menerapkan somemetode pada yang paling pendek:

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

Saya menemukan sintaks pendek dan manis ini untuk mencocokkan semua atau beberapa elemen antara dua array. Sebagai contoh

// ATAU operasi. temukan apakah ada elemen array2 yang ada di array1. Ini akan kembali segera setelah ada kecocokan pertama karena beberapa metode rusak ketika fungsi mengembalikan TRUE

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

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

// cetak BENAR

// DAN operasi. temukan apakah semua elemen array2 ada di array1. Ini akan kembali segera setelah tidak ada kecocokan pertama karena beberapa metode rusak ketika fungsi mengembalikan TRUE

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

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

// mencetak FALSE

Semoga itu bisa membantu seseorang di masa depan!

Anda dapat menggunakan panggilan Array.prototype.some bersarang. Ini memiliki keuntungan yang akan ditebusnya pada pertandingan pertama alih-alih solusi lain yang akan berjalan melalui loop bersarang penuh.

misalnya.

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

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

Ini adalah kasus menarik yang saya pikir harus saya bagikan.

Katakanlah Anda memiliki larik objek dan larik filter yang dipilih.

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

const filters = ['foo'];

Untuk menerapkan filter yang dipilih ke struktur ini kami dapat

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

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

Saya menulis 3 solusi. Pada dasarnya mereka melakukan hal yang sama. Mereka mengembalikan true begitu mereka mendapatkannya true. Saya menulis 3 solusi hanya untuk menunjukkan 3 cara berbeda untuk melakukan sesuatu. Sekarang, itu tergantung apa yang Anda sukai. Anda dapat menggunakan performance.now () untuk memeriksa kinerja dari satu solusi atau yang lain. Dalam solusi saya, saya juga memeriksa array mana yang terbesar dan mana yang terkecil untuk membuat operasi lebih efisien.

Solusi ke-3 mungkin bukan yang paling lucu tetapi efisien. Saya memutuskan untuk menambahkannya karena dalam beberapa wawancara pengkodean Anda tidak diperbolehkan menggunakan metode bawaan.

Terakhir, tentu saja ... kita dapat menemukan solusi dengan 2 NESTED untuk loop (cara brute force) tetapi Anda ingin menghindarinya karena kompleksitas waktu yang buruk O (n ^ 2) .

catatan:

alih-alih menggunakan .includes()seperti yang dilakukan orang lain, Anda dapat menggunakannya .indexOf(). jika Anda hanya memeriksa apakah nilainya lebih besar dari 0. Jika nilainya tidak ada akan memberi Anda -1. jika memang ada, itu akan memberi Anda lebih dari 0.

indexOf () vs meliputi ()

Mana yang memiliki kinerja lebih baik ?indexOf()untuk sedikit, tetapi termasuk lebih mudah menurut pendapat saya.

Jika saya tidak salah .includes()dan indexOf()menggunakan loop di belakang layar, maka Anda akan berada di O (n ^ 2) saat menggunakannya .some().

MENGGUNAKAN loop

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

MENGGUNAKAN .some ()

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

MENGGUNAKAN PETA Kompleksitas waktu 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;
};

Kode di: stackblitz saya

Saya bukan ahli dalam kinerja atau BigO jadi jika sesuatu yang saya katakan salah beri tahu saya.

Bagaimana dengan menggunakan kombinasi some / findIndex dan indexOf?

Jadi sesuatu seperti ini:

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

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

Agar lebih mudah dibaca, Anda dapat menambahkan fungsionalitas ini ke objek Array itu sendiri.

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

Catatan: Jika Anda ingin melakukan sesuatu dengan predikat, Anda bisa mengganti indeks bagian dalam. Dari dengan findIndex lain dan predikat

Solusi saya berlaku Array.prototype.some () dan Array.prototype.includes () array helpers yang melakukan pekerjaan mereka dengan cukup efisien juga

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;

Hanya satu solusi lagi

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

Periksa apakah a1 berisi semua elemen a2

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

Ini dapat dilakukan dengan hanya mengulangi seluruh array utama dan memeriksa apakah array lain mengandung elemen target atau tidak.

Coba ini:

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

Dengan 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

Menambahkan ke Array Prototype

Penafian: Banyak yang akan sangat menyarankan hal ini. Satu-satunya waktu itu benar-benar akan menjadi masalah adalah jika perpustakaan menambahkan fungsi prototipe dengan nama yang sama (yang berperilaku berbeda) atau sesuatu seperti itu.

Kode:

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

Tanpa menggunakan fungsi panah besar:

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

Pemakaian

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

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

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

Vanilla JS dengan pencocokan sebagian & tidak sensitif huruf

Masalah dengan beberapa pendekatan sebelumnya adalah bahwa mereka membutuhkan kecocokan yang tepat dari setiap kata . Tetapi, Bagaimana jika Anda ingin memberikan hasil untuk kecocokan parsial?

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

Ini berguna ketika Anda ingin memberikan kotak pencarian tempat pengguna mengetik kata-kata dan hasilnya dapat memiliki kata-kata itu dalam urutan, posisi, dan huruf besar-kecil.

Perbarui @Paul Grimshaw, gunakan includesinsteed of indexOfuntuk lebih mudah dibaca

biarkan ditemukan = arr1.some (r => arr2.indexOf (r)> = 0)
biarkan ditemukan = arr1.some (r => arr2.includes (r))

Saya datang dengan solusi di simpul menggunakan garis bawah js seperti ini:

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

Secara pribadi, saya akan menggunakan fungsi berikut:

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

Metode "toString ()" akan selalu menggunakan koma untuk memisahkan nilai. Hanya akan benar-benar bekerja dengan tipe primitif.

Array .filter () dengan panggilan bersarang ke .find () akan mengembalikan semua elemen dalam array pertama yang merupakan anggota array kedua. Periksa panjang array yang dikembalikan untuk menentukan apakah ada array kedua di array pertama.

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;