Bir hedef dizim var ["apple","banana","orange"] ve diğer diziler hedef dizi öğelerinden herhangi birini içerip içermediğini kontrol etmek istiyorum.

Örneğin:

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

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

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

JavaScript ile nasıl yapabilirim?

Vanilya JS

ES2016:

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

ES6:

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

Nasıl çalışır

some(..)dizinin her öğesini bir test işlevine karşı denetler ve dizinin herhangi bir öğesi test işlevini geçerse true değerini, aksi halde false değerini döndürür. indexOf(..) >= 0ve includes(..)verilen bağımsız değişken dizide mevcutsa her ikisi de true değerini döndürür.

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

Bir libray kullanmaya karşı değilseniz, http://underscorejs.org/ , bunu basitleştirebilecek bir kavşak yöntemine sahiptir:

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]

Kavşak işlevi, eşleştiği öğelerle yeni bir dizi döndürür ve eşleşmezse boş dizi döndürür.

ES6 (en hızlı)

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

Vurgulamak

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

(Kullanımı nedeniyle) tür zorlamasına ihtiyacınız yoksa indexOf, aşağıdakine benzer bir şey deneyebilirsiniz:

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

arrHedef öğeleri nerede içerir. Sonunda, foundikinci dizinin hedefe karşı en az bir eşleşmesi olup olmadığını gösterecektir .

Tabii ki, kullanmak istediğiniz herhangi bir şey için sayıları değiştirebilirsiniz - dizeler örneğiniz gibi iyidir.

Ve benim özel örneğimde, sonuç trueikinci dizinin 3hedefte bulunması nedeniyle olmalıdır .

GÜNCELLEME:

Ben nasıl bir fonksiyon (daha önce bazı küçük değişiklikler ile) içine düzenlemek istiyorum:

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/

Bu durumda, işlev targetArray, kapanıştaki sabit kodlanmış yerine bir bağımsız değişken olarak geçirilecek şekilde değiştirilebilir .

Update2:

Yukarıdaki çözümüm işe yarayabilir ve (umarım daha fazla) okunabilir olsa da, tarif ettiğim konsepti ele almanın "daha iyi" yolunun biraz farklı bir şey yapmak olduğuna inanıyorum. Yukarıdaki çözüm ile "sorun" indexOfdöngü içinde hedef dizisi diğer dizideki her öğe için tamamen döngü neden olmasıdır. Bu, bir "arama" (bir harita ... bir JavaScript nesnesi değişmezi) kullanılarak kolayca "düzeltilebilir". Bu, her dizi üzerinde iki basit döngüye izin verir. İşte bir örnek:

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/

Bu çözümün dezavantajı, değerler (dolaylı olarak) dizelere dönüştürüldüğünden ve arama haritasının anahtarları olarak ayarlandığından yalnızca sayıların ve dizelerin (ve booleans) kullanılabilmesidir (doğru). Bu, gerçek olmayan değerler için tam olarak iyi / mümkün / kolay yapılmaz.

ES6 çözümü:

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

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

Bunun aksine: Tüm değerleri içermelidir.

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

Umarım yardımcı olur.

Lodash kullanabilir ve şunları yapabilirsiniz:

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

Set kesişimi her iki koleksiyonda da aynı elemanlar dizisi oluşturulur.

Filter / indexOf kullanma :

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

Ya da bu iki Setdiziden hangisinin daha uzun olduğunu ve en uzun dizi için dışarı çıkarken some, en kısa diziye yöntem uygularsanız daha iyi bir performans elde edebilirsiniz :

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

Bu kısa ve tatlı sözdizimini iki dizi arasındaki tüm veya bazı öğelerle eşleştirmek için buldum. Örneğin

// VEYA işlemi. dizi1'de dizi2 öğelerinden herhangi birinin olup olmadığını bulun. İşlev DOĞRU döndürdüğünde bazı yöntem bozulduğundan ilk eşleşme olur olmaz

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

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

// DOĞRU yazdırır

// VE işlemi. dizi1 öğesinde dizi2 öğelerinin tümünün bulunup bulunmadığını bulun. Bu işlev DOĞRU döndürdüğünde bazı yöntem bozulduğundan ilk eşleşme olmaz gerçekleşmez geri döner

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

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

// YANLIŞ yazdırır

Umarım gelecekte birine yardım eder!

Yuvalanmış bir Array.prototype.some çağrısı kullanabilirsiniz. Bu, tam iç içe döngüden geçecek diğer çözümler yerine ilk maçta kefalet etme avantajına sahiptir.

Örneğin.

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

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

İşte paylaşmam gerektiğini düşündüğüm ilginç bir durum.

Diyelim ki bir dizi nesneniz ve bir dizi seçilmiş filtre var.

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

const filters = ['foo'];

Seçilen filtreleri bu yapıya uygulamak için

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 çözüm yazdım. Aslında aynısını yapıyorlar. En kısa sürede gerçek olarak geri dönerler true. 3 çözümü sadece bir şeyler yapmanın 3 farklı yolunu göstermek için yazdım. Şimdi, daha ne sevdiğinize bağlı. Bir çözümün veya diğerinin performansını kontrol etmek için performance.now () kullanabilirsiniz . Çözümlerimde, hangi dizinin en büyük ve hangisinin en küçük olduğunu, işlemleri daha verimli hale getirmek için kontrol ediyorum.

3. çözüm en tatlı olmayabilir, ancak etkilidir. Eklemeye karar verdim, çünkü bazı kodlama röportajlarında yerleşik yöntemleri kullanmanıza izin verilmiyor.

Son olarak, elbette ... döngüler için 2 NESTED (kaba kuvvet yolu) ile bir çözüm bulabiliriz, ancak bundan kaçınmak istersiniz çünkü zaman karmaşıklığı kötü O (n ^ 2) .

Not:

.includes()başkaları gibi kullanmak yerine kullanabilirsiniz .indexOf(). sadece değerin 0'dan büyük olup olmadığını kontrol ederseniz, değer yoksa size -1 verir. eğer varsa, 0'dan büyük verecektir.

indexOf () ve include () karşılaştırması

Hangisinin performansı daha iyi ? indexOf()biraz, ama içerir bence daha okunabilir.

Yanılmıyorsam .includes()ve indexOf()sahnenin arkasında döngüler kullanıyorsanız, bunları kullanırken O (n ^ 2) olacaksınız .some().

KULLANIM döngüsü

 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 () KULLANIMI

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

HARİTALARIN KULLANILMASI Zaman karmaşıklığı 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;
};

İçindeki kod: stackblitz

Performans konusunda uzman değil, BigO değilim, bu yüzden söylediğim bir şey yanlışsa bana bildirin.

Some / findIndex ve indexOf birleşimini kullanmaya ne dersiniz?

Yani böyle bir şey:

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

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

Daha okunabilir hale getirmek için bu işlevi Array nesnesinin kendisine ekleyebilirsiniz.

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

Not: Bir yüklem ile bir şey yapmak isterseniz, iç endeksiOf'u başka bir findIndex ve bir yüklem ile değiştirebilirsiniz.

Benim çözüm uygular Array.prototype.some () ve Array.prototype.includes () , işlerini de oldukça verimli yapan dizi yardımcılarını

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;

Sadece bir çözüm daha

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

A1'in a2 öğesinin tüm öğelerini içerip içermediğini kontrol edin

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

Basit bir şekilde ana dizi boyunca tekrarlanarak ve diğer dizinin hedef elemandan herhangi birini içerip içermediğini kontrol ederek yapılabilir.

Bunu dene:

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 şirketinde DEMO

Alt çizgi ile

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

Dizi Prototipine Ekleme

Feragatname: Birçok kişi buna karşı şiddetle tavsiye eder. Gerçekten sorun olacak tek zaman, bir kütüphanenin aynı ada (farklı davranan) bir prototip işlevi veya bunun gibi bir şey eklemesi idi.

Kod:

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

Büyük ok işlevlerini kullanmadan:

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

kullanım

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

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

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

Kısmi eşleme ve büyük / küçük harfe duyarlı olmayan Vanilla JS

Önceki bazı yaklaşımların sorunu , her kelimenin tam olarak eşleşmesini gerektirmesidir . Ancak, kısmi eşleşmeler için sonuç sağlamak isterseniz ne olur?

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

Bu, kullanıcıların kelime yazdığı ve sonuçların bu kelimeleri herhangi bir sırada, konumda ve durumda olabileceği bir arama kutusu sağlamak istediğinizde kullanışlıdır.

@ Paul Grimshaw cevabını güncelleyin, daha okunabilir için includesinsteed kullanınindexOf

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

Böyle alt çizgi js kullanarak düğüm bir çözüm geldi:

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

Şahsen, aşağıdaki işlevi kullanırdım:

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

"ToString ()" yöntemi değerleri ayırmak için her zaman virgül kullanır. Sadece ilkel tiplerle çalışacaktır.

.Find () için iç içe çağrı bulunan dizi .filter (), ikinci dizinin üyesi olan ilk dizideki tüm öğeleri döndürür. İkinci diziden herhangi birinin ilk dizide olup olmadığını belirlemek için döndürülen dizinin uzunluğunu kontrol edin.

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;