Ich habe ein Zielarray ["apple","banana","orange"]und möchte überprüfen, ob andere Arrays eines der Zielarrayelemente enthalten.

Zum Beispiel:

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

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

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

Wie kann ich das in JavaScript machen?

Vanilla JS

ES2016:

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

ES6:

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

Wie es funktioniert

some(..)Überprüft jedes Element des Arrays anhand einer Testfunktion und gibt true zurück, wenn ein Element des Arrays die Testfunktion besteht. Andernfalls wird false zurückgegeben. indexOf(..) >= 0und includes(..)beide geben true zurück, wenn das angegebene Argument im Array vorhanden ist.

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

Wenn Sie nicht gegen die Verwendung eines Librays sind, verfügt http://underscorejs.org/ über eine Schnittmethode, die dies vereinfachen kann:

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]

Die Schnittfunktion gibt ein neues Array mit den Elementen zurück, mit denen es übereinstimmt, und wenn es nicht übereinstimmt, gibt es ein leeres Array zurück.

ES6 (am schnellsten)

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

Unterstreichen

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

Wenn Sie (aufgrund der Verwendung von indexOf) keinen Typenzwang benötigen , können Sie Folgendes versuchen:

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

Wo arrenthält die Zielelemente. Am Ende foundwird angezeigt, ob das zweite Array mindestens eine Übereinstimmung mit dem Ziel hatte.

Natürlich können Sie Zahlen gegen alles austauschen, was Sie verwenden möchten - Zeichenfolgen sind in Ordnung, wie in Ihrem Beispiel.

In meinem speziellen Beispiel sollte das Ergebnis sein, truedass das zweite Array 3im Ziel vorhanden ist.

AKTUALISIEREN:

So würde ich es in eine Funktion organisieren (mit einigen geringfügigen Änderungen gegenüber zuvor):

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/

In diesem Fall könnte die Funktion so geändert werden, dass targetArraysie als Argument übergeben wird, anstatt im Abschluss fest codiert zu werden.

UPDATE2:

Während meine obige Lösung möglicherweise funktioniert und (hoffentlich besser) lesbar ist, glaube ich, dass der "bessere" Weg, mit dem von mir beschriebenen Konzept umzugehen, darin besteht, etwas anderes zu tun. Das "Problem" bei der obigen Lösung besteht darin, dass das indexOfZielarray innerhalb der Schleife für jedes Element im anderen Array vollständig durchlaufen wird. Dies kann leicht durch "Nachschlagen" (eine Karte ... ein JavaScript-Objektliteral) "behoben" werden. Dies ermöglicht zwei einfache Schleifen über jedes Array. Hier ist ein Beispiel:

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/

Der Nachteil dieser Lösung ist, dass nur Zahlen und Zeichenfolgen (und Boolesche Werte) (korrekt) verwendet werden können, da die Werte (implizit) in Zeichenfolgen konvertiert und als Schlüssel für die Lookup-Map festgelegt werden. Dies ist für nicht wörtliche Werte nicht gerade gut / möglich / einfach.

ES6-Lösung:

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

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

Im Gegensatz dazu: Muss enthält alle Werte.

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

Hoffe, wird hilfreich sein.

Sie könnten lodash verwenden und tun:

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

Die Schnittmenge wird für beide Sammlungen festgelegt, wodurch ein Array identischer Elemente erzeugt wird.

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

Oder Sie können sogar eine bessere Leistung erzielen, wenn Sie zuerst herausfinden, welches dieser beiden Arrays länger ist und Setdas längste Array erkennen, während Sie die someMethode auf das kürzeste anwenden :

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

Ich fand diese kurze und süße Syntax so, dass alle oder einige Elemente zwischen zwei Arrays übereinstimmen. Zum Beispiel

// ODER Operation. Finden Sie heraus, ob eines der Elemente array2 in array1 vorhanden ist. Dies wird zurückgegeben, sobald eine erste Übereinstimmung vorliegt, da einige Methoden unterbrochen werden, wenn die Funktion TRUE zurückgibt

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

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

// druckt TRUE

// UND-Operation. Finden Sie heraus, ob alle Array2-Elemente in Array1 vorhanden sind. Dies wird zurückgegeben, sobald keine erste Übereinstimmung vorliegt, da einige Methoden unterbrochen werden, wenn die Funktion TRUE zurückgibt

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

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

// druckt FALSE

Hoffe das hilft jemandem in Zukunft!

Sie können einen verschachtelten Array.prototype.some-Aufruf verwenden. Dies hat den Vorteil, dass es beim ersten Spiel anstelle anderer Lösungen, die die gesamte verschachtelte Schleife durchlaufen, auf Kaution geht.

z.B.

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

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

Hier ist ein interessanter Fall, den ich teilen sollte.

Angenommen, Sie haben ein Array von Objekten und ein Array ausgewählter Filter.

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

const filters = ['foo'];

Um die ausgewählten Filter auf diese Struktur anzuwenden, können wir

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

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

Ich habe 3 Lösungen geschrieben. Im Wesentlichen machen sie das Gleiche. Sie kehren wahr zurück, sobald sie bekommen true. Ich habe die 3 Lösungen geschrieben, nur um 3 verschiedene Arten zu zeigen, Dinge zu tun. Jetzt kommt es darauf an, was du mehr magst. Sie können performance.now () verwenden können Sie die Leistung der einen oder anderen Lösung überprüfen. In meinen Lösungen überprüfe ich auch, welches Array das größte und welches das kleinste ist, um die Operationen effizienter zu gestalten.

Die 3. Lösung ist möglicherweise nicht die süßeste, aber effizient. Ich habe beschlossen, es hinzuzufügen, da Sie in einigen Codierungsinterviews keine integrierten Methoden verwenden dürfen.

Schließlich sicher ... können wir eine Lösung mit 2 NESTED for-Schleifen (Brute-Force-Methode) finden, aber Sie möchten dies vermeiden, da die zeitliche Komplexität schlecht ist. O (n ^ 2) .

Hinweis:

Anstatt .includes()wie andere Leute zu verwenden, können Sie verwenden .indexOf(). Wenn Sie nur prüfen, ob der Wert größer als 0 ist, erhalten Sie -1, wenn der Wert nicht vorhanden ist. Wenn es existiert, gibt es Ihnen mehr als 0.

indexOf () vs include ()

Welches hat eine bessere Leistung ?indexOf()für ein bisschen, aber enthält ist meiner Meinung nach besser lesbar.

Wenn ich mich nicht irre .includes()und indexOf()hinter den Kulissen Schleifen verwende, sind Sie bei der Verwendung mit O (n ^ 2).some() .

USING-Schleife

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

USING .some ()

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

VERWENDEN VON KARTEN Zeitkomplexität 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;
};

Code in meinem: stackblitz

Ich bin weder ein Experte für Leistung noch für BigO. Wenn also etwas, das ich gesagt habe, nicht stimmt, lassen Sie es mich wissen.

Was ist mit einer Kombination aus some / findIndex und indexOf?

Also so etwas wie das:

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

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

Um die Lesbarkeit zu verbessern, können Sie diese Funktionalität dem Array-Objekt selbst hinzufügen.

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

Hinweis: Wenn Sie etwas mit einem Prädikat tun möchten, können Sie den inneren indexOf durch einen anderen findIndex und ein Prädikat ersetzen

Meine Lösung wendet Array.prototype.some () und Array.prototype.includes () an. Array-Helfer an, die ihre Arbeit ebenfalls recht effizient erledigen

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;

Nur noch eine Lösung

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

Überprüfen Sie, ob a1 alle Elemente von a2 enthält

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

Dies kann durch einfaches Durchlaufen des Hauptarrays und Überprüfen, ob ein anderes Array eines der Zielelemente enthält oder nicht, erfolgen.

Versuche dies:

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

Mit Unterstrichen

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

Hinzufügen zum Array-Prototyp

Haftungsausschluss: Viele würden dringend davon abraten. Das einzige Mal, wenn es wirklich ein Problem wäre, wäre, wenn eine Bibliothek eine Prototypfunktion mit demselben Namen (die sich anders verhält) oder so etwas hinzufügte.

Code:

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

Ohne Verwendung großer Pfeilfunktionen:

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

Verwendungszweck

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

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

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

Vanilla JS mit teilweiser Übereinstimmung und ohne Berücksichtigung der Groß- und Kleinschreibung

Das Problem bei einigen früheren Ansätzen ist, dass sie eine genaue Übereinstimmung jedes Wortes erfordern . Aber was , wenn Sie Ergebnisse für teilweise Übereinstimmungen liefern?

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

Dies ist nützlich, wenn Sie ein Suchfeld bereitstellen möchten, in dem Benutzer Wörter eingeben und die Ergebnisse diese Wörter in beliebiger Reihenfolge, Position und Groß- / Kleinschreibung enthalten können.

Aktualisieren Sie die Antwort von @Paul Grimshaw und verwenden Sie includesinsteed of, indexOfum die Lesbarkeit zu verbessern

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

Ich habe eine Lösung für Node mit Unterstrichen wie folgt gefunden:

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

Persönlich würde ich die folgende Funktion verwenden:

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

Die Methode "toString ()" verwendet immer Kommas, um die Werte zu trennen. Funktioniert nur wirklich mit primitiven Typen.

Das Array .filter () mit einem verschachtelten Aufruf von .find () gibt alle Elemente im ersten Array zurück, die Mitglieder des zweiten Arrays sind. Überprüfen Sie die Länge des zurückgegebenen Arrays, um festzustellen, ob sich eines der zweiten Arrays im ersten Array befindet.

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;