it-swarm.com.de

Prüfen Sie, ob ein Array ein Element eines anderen Arrays in JavaScript enthält

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

Zum Beispiel: 

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

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

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

Wie mache ich das in JavaScript?

212
Alex

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 mit einer Testfunktion und gibt true zurück, wenn ein Element des Arrays die Testfunktion besteht, andernfalls gibt es false zurück. indexOf(..) >= 0 und includes(..) beide geben true zurück, wenn das angegebene Argument im Array vorhanden ist.

247
Paul Grimshaw

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

Wenn Sie nicht gegen die Verwendung einer Bibliothek sind, hat http://underscorejs.org/ 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 Kreuzungsfunktion gibt ein neues Array mit den übereinstimmenden Elementen zurück. Wenn dies nicht der Fall ist, wird ein leeres Array zurückgegeben.

64
willz

Wenn Sie keinen Typzwang benötigen (wegen der Verwendung von indexOf), 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 arr die Zielelemente enthält. Am Ende wird found angezeigt, ob das zweite Array mindestens ein Übereinstimmung mit dem Ziel hatte.

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

In meinem speziellen Beispiel sollte das Ergebnis true sein, da der 3 des zweiten Arrays im Ziel vorhanden ist.


UPDATE:

So würde ich es in eine Funktion einteilen (mit geringfügigen Änderungen von vor):

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 dahingehend geändert werden, dass targetArray als Argument übergeben wird, anstatt in der Schließung fest codiert zu sein.


UPDATE2:

Während meine oben genannte Lösung möglicherweise funktioniert und (hoffentlich besser) lesbar ist, glaube ich, dass der "bessere" Weg, mit dem beschriebenen Konzept umzugehen, darin besteht, etwas anders zu machen. Das "Problem" bei der obigen Lösung besteht darin, dass die Variable indexOf innerhalb der Schleife bewirkt, dass das Zielarray 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 besteht darin, dass nur Zahlen und Strings (und Booleans) verwendet werden können (korrekt), da die Werte (implizit) in Strings 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/leicht zu bewerkstelligen.

40
Ian

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-container-any-element-of-another-array

31
lusk

Sie könnten lodash verwenden und tun:

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

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

26
Justin Cuaresma

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

26

Ich fand diese kurze und süße Syntax für alle oder einige Elemente zwischen zwei Arrays. Zum Beispiel

// OR Vorgang. Finden Sie, ob eines der Elemente von Array2 in Array1 vorhanden ist. Dies wird zurückgegeben, sobald eine erste Übereinstimmung vorliegt, da einige Methoden abgebrochen 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 WAHR

// UND-Verknüpfung Finde, ob alle Array2-Elemente in Array1 vorhanden sind. Dies wird zurückgegeben, sobald es keine erste Übereinstimmung gibt, da eine Methode bricht, 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 FALSCH

Hoffe das hilft jemand in Zukunft!

7
kashpatel

ES6-Lösung:

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

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

Im Gegensatz dazu: Muss alle Werte enthalten.

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

Hoffe, wird hilfreich sein.

5
Tanvir Hasan

Sie können einen verschachtelten Array.prototype.some-Aufruf verwenden. Dies hat den Vorteil, dass es beim ersten Spiel von anderen Lösungen unterstützt wird, die die vollständige verschachtelte Schleife durchlaufen.

z.B.

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

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

Wie wäre es mit einer Kombination aus einigen/findIndex und indexOf?

Also so etwas wie:

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

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

Um es lesbarer zu machen, 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;
}

Anmerkung: Wenn Sie etwas mit einem Vergleichselement tun möchten, können Sie den inneren IndexOf durch einen anderen findIndex und ein Vergleichselement ersetzen

3

Ich habe mir eine Lösung in node ausgedacht, die js wie folgt verwendet:

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

Aktualisieren Sie die Antwort von @Paul Grimshaw, verwenden Sie includes anstelle von indexOf, um die Lesbarkeit zu verbessern

let found = arr1.some (r => arr2.inclusches (r))

2
Đinh Anh Huy

Hinzufügen zum Array-Prototyp

Disclaimer: Viele würden davon dringend abraten. Das einzige Mal, dass es wirklich ein Problem sein würde, war, wenn eine Bibliothek eine Prototypfunktion mit demselben Namen (die sich anders verhalten hat) oder so ähnlich hinzugefügt hat.

Code:

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

Ohne große Pfeilfunktionen zu verwenden:

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
2
csga5000

Dazu können Sie einfach das Hauptarray durchlaufen und prüfen, ob ein anderes Array ein Zielelement enthält oder nicht.

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

2
ritesh_NITW

Mit Unterstriche

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
2
fguillen

Vanille JS mit partieller Ü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 ist, wenn Sie Ergebnisse für teilweise Übereinstimmungen bereitstellen möchten?

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ß- und Kleinschreibung anzeigen können.

2
SntsDev

Hier ist ein interessanter Fall, von dem ich dachte, dass ich ihn teilen sollte.

Nehmen wir an, Sie haben ein Array von Objekten und ein Array von ausgewählten Filtern.

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

const filters = ['foo'];

Die ausgewählten Filter können wir auf diese Struktur anwenden

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

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

Meine Lösung verwendet Array.prototype.some () und Array.prototype.includes () Array-Helfer, die ihre Aufgabe ebenfalls ziemlich 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)
1
Cong Nguyen
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);
0
Naveen Koti
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;
0
Vasudev

Persönlich würde ich 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 mit primitiven Typen.

0

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 ein zweites Array im ersten Array befand.

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