Einfachste code für array-Kreuzung in javascript

Verwenden Sie eine Kombination von Array.der Prototyp.- filter und Array.der Prototyp.indexOf:

array1.filter(value => -1 !== array2.indexOf(value));

InformationsquelleAutor Anon.

Wenn in Ihrer Umgebung unterstützt ECMAScript 6, Setzen, eine einfache und vermeintlich effizient (siehe link-Spezifikation) Weg:

function intersect(a, b) {
  var setA = new Set(a);
  var setB = new Set(b);
  var intersection = new Set([...setA].filter(x => setB.has(x)));
  return Array.from(intersection);
}

Kürzer, aber weniger lesbar (auch ohne eine zusätzliche Kreuzung Set):

function intersect(a, b) {
      return [...new Set(a)].filter(x => new Set(b).has(x));
}

Vermeidung einer neuen Set aus b jedes mal:

function intersect(a, b) {
      var setB = new Set(b);
      return [...new Set(a)].filter(x => setB.has(x));
}

Beachten Sie, dass bei der Verwendung von sets, erhalten Sie nur eindeutige Werte, so new Set[1,2,3,3].size ausgewertet 3.

InformationsquelleAutor nbarbosa

Wie wäre es einfach mit assoziativen arrays?

function intersect(a, b) {
    var d1 = {};
    var d2 = {};
    var results = [];
    for (var i = 0; i < a.length; i++) {
        d1[a[i]] = true;
    }
    for (var j = 0; j < b.length; j++) {
        d2[b[j]] = true;
    }
    for (var k in d1) {
        if (d2[k]) 
            results.push(k);
    }
    return results;
}

edit:

//new version
function intersect(a, b) {
    var d = {};
    var results = [];
    for (var i = 0; i < b.length; i++) {
        d[b[i]] = true;
    }
    for (var j = 0; j < a.length; j++) {
        if (d[a[j]]) 
            results.push(a[j]);
    }
    return results;
}

InformationsquelleAutor Steven Huwig

Mit jQuery:

var a = [1,2,3];
var b = [2,3,4,5];
var c = $(b).not($(b).not(a));
alert(c);

InformationsquelleAutor Gowsikan

Für arrays, die nur strings oder zahlen, die Sie tun können, etwas mit der Sortierung, wie pro einige der anderen Antworten. Für den Allgemeinen Fall eines arrays von beliebigen Objekten ich glaube nicht, dass Sie vermeiden können, tut es der lange Weg. Im folgenden erhalten Sie die Kreuzung eine beliebige Anzahl von arrays als Parameter bereitgestellt, um arrayIntersection:

var arrayContains = Array.prototype.indexOf ?
    function(arr, val) {
        return arr.indexOf(val) > -1;
    } :
    function(arr, val) {
        var i = arr.length;
        while (i--) {
            if (arr[i] === val) {
                return true;
            }
        }
        return false;
    };

function arrayIntersection() {
    var val, arrayCount, firstArray, i, j, intersection = [], missing;
    var arrays = Array.prototype.slice.call(arguments); //Convert arguments into a real array

    //Search for common values
    firstArray = arrays.pop();
    if (firstArray) {
        j = firstArray.length;
        arrayCount = arrays.length;
        while (j--) {
            val = firstArray[j];
            missing = false;

            //Check val is present in each remaining array 
            i = arrayCount;
            while (!missing && i--) {
                if ( !arrayContains(arrays[i], val) ) {
                    missing = true;
                }
            }
            if (!missing) {
                intersection.push(val);
            }
        }
    }
    return intersection;
}

arrayIntersection( [1, 2, 3, "a"], [1, "a", 2], ["a", 1] ); //Gives [1, "a"]; 

InformationsquelleAutor Tim Down

Anderen indizierten Ansatz verarbeiten zu können eine beliebige Anzahl von arrays auf einmal:

//Calculate intersection of multiple array or object values.
function intersect (arrList) {
    var arrLength = Object.keys(arrList).length;
        //(Also accepts regular objects as input)
    var index = {};
    for (var i in arrList) {
        for (var j in arrList[i]) {
            var v = arrList[i][j];
            if (index[v] === undefined) index[v] = 0;
            index[v]++;
        };
    };
    var retv = [];
    for (var i in index) {
        if (index[i] == arrLength) retv.push(i);
    };
    return retv;
};

Es funktioniert nur für die Werte, die ausgewertet werden können als strings, und Sie sollten vergehen, als ein array wie:

intersect ([arr1, arr2, arr3...]);

...aber es transparent akzeptiert Objekte als parameter oder als beliebige Elemente werden geschnitten (immer wiederkehrenden Reihe von gemeinsamen Werten). Beispiele:

intersect ({foo: [1, 2, 3, 4], bar: {a: 2, j:4}}); //[2, 4]
intersect ([{x: "hello", y: "world"}, ["hello", "user"]]); //["hello"]

EDIT: ich habe gerade bemerkt, dass dies, in einer Weise, die leicht buggy.

Ist: ich codiert es zu denken, dass Eingabe-arrays nicht selbst enthalten Wiederholungen (als Beispiel nicht).

Aber wenn Eingabe-arrays zufällig enthalten Wiederholungen, das würde produzieren falsche Ergebnisse. Beispiel (unter implementation):

intersect ([[1, 3, 4, 6, 3], [1, 8, 99]]);
//Expected: [ '1' ]
//Actual: [ '1', '3' ]

Glücklicherweise ist dies einfach zu beheben, indem man einfach die zweite Stufe der Indizierung. Das heißt:

Ändern:

        if (index[v] === undefined) index[v] = 0;
        index[v]++;

durch:

        if (index[v] === undefined) index[v] = {};
        index[v][i] = true; //Mark as present in i input.

...und:

         if (index[i] == arrLength) retv.push(i);

durch:

         if (Object.keys(index[i]).length == arrLength) retv.push(i);

Komplettes Beispiel:

//Calculate intersection of multiple array or object values.
function intersect (arrList) {
    var arrLength = Object.keys(arrList).length;
        //(Also accepts regular objects as input)
    var index = {};
    for (var i in arrList) {
        for (var j in arrList[i]) {
            var v = arrList[i][j];
            if (index[v] === undefined) index[v] = {};
            index[v][i] = true; //Mark as present in i input.
        };
    };
    var retv = [];
    for (var i in index) {
        if (Object.keys(index[i]).length == arrLength) retv.push(i);
    };
    return retv;
};

intersect ([[1, 3, 4, 6, 3], [1, 8, 99]]); //[ '1' ]

InformationsquelleAutor bitifet

Mit einigen Einschränkungen, die auf Ihre Daten haben, können Sie es tun in lineare Zeit!

Für positive ganze zahlen: verwenden Sie ein array zuordnen der Werte zu einem "gesehen/nicht gesehen" boolean".

function intersectIntegers(array1,array2) { 
   var seen=[],
       result=[];
   for (var i = 0; i < array1.length; i++) {
     seen[array1[i]] = true;
   }
   for (var i = 0; i < array2.length; i++) {
     if ( seen[array2[i]])
        result.push(array2[i]);
   }
   return result;
}

Es ist eine ähnliche Technik für Objekte: nehmen Sie einen dummy-Schlüssel, setzen Sie ihn auf "true" für jedes element aus Matrix1, dann suchen Sie diese Taste im Elemente Matrix2. Aufräumen, wenn du fertig bist.

function intersectObjects(array1,array2) { 
   var result=[];
   var key="tmpKey_intersect"
   for (var i = 0; i < array1.length; i++) {
     array1[i][key] = true;
   }
   for (var i = 0; i < array2.length; i++) {
     if (array2[i][key])
        result.push(array2[i]);
   }
   for (var i = 0; i < array1.length; i++) {
     delete array1[i][key];
   }
   return result;
}

Natürlich müssen Sie sicherstellen, dass der Schlüssel nicht erscheinen, sonst werden Sie zu zerstören Ihre Daten...

InformationsquelleAutor tarulen

"indexOf" für den IE 9.0, chrome, firefox, opera,

    function intersection(a,b){
     var rs = [], x = a.length;
     while (x--) b.indexOf(a[x])!=-1 && rs.push(a[x]);
     return rs.sort();
    }

intersection([1,2,3], [2,3,4,5]);
//Result:  [2,3]

InformationsquelleAutor Martin Roberto Mondragon Sotel

.reduce eine Karte zu erstellen, und .filter zu finden, um die Kreuzung. delete innerhalb der .filter ermöglicht uns die Behandlung der zweiten Reihe, als ob es einen eindeutigen Satz.

function intersection (a, b) {
  var seen = a.reduce(function (h, k) {
    h[k] = true;
    return h;
  }, {});

  return b.filter(function (k) {
    var exists = seen[k];
    delete seen[k];
    return exists;
  });
}

Ich finde dieses Vorgehen ziemlich leicht zu Grunde geht. Es führt in konstanter Zeit.

InformationsquelleAutor Belden

var listA = [1,2,3,4,5,6,7];
var listB = [2,4,6,8];

var result = listA.filter(itemA=> {
    return listB.some(itemB => itemB === itemA);
});

InformationsquelleAutor jcmordan

Hier ist eine sehr naive Implementierung, die ich verwende. Es ist nicht-destruktiv und macht auch sicher, dass keine doppelten Einträge.

Array.prototype.contains = function(elem) {
    return(this.indexOf(elem) > -1);
};

Array.prototype.intersect = function( array ) {
    //this is naive--could use some optimization
    var result = [];
    for ( var i = 0; i < this.length; i++ ) {
        if ( array.contains(this[i]) && !result.contains(this[i]) )
            result.push( this[i] );
    }
    return result;
}

InformationsquelleAutor devios1