Der einfachste Code für die Array -Intersektion in JavaScript

https://stackoverflow.com/questions/1885557

19-09-2019
|

Frage

Was ist der einfachste, bibliotheksfreie Code für die Implementierung von Array-Kreuzungen in JavaScript? Ich möchte schreiben

intersection([1,2,3], [2,3,4,5])

und bekomme

[2, 3]

Lösung

Verwenden Sie eine Kombination von Array.prototype.filter und Array.prototype.indexOf:

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

Oder wie Vrugtehagel In den Kommentaren können Sie die neueren verwenden Array.prototype.includes Für noch einfacheres Code:

array1.filter(value => array2.includes(value))

Für ältere Browser:

array1.filter(function(n) {
    return array2.indexOf(n) !== -1;
});

Andere Tipps

Zerstörerisch erscheint am einfachsten, besonders wenn wir davon ausgehen können, dass die Eingabe sortiert ist:

/* destructively finds the intersection of 
 * two arrays in a simple fashion.  
 *
 * PARAMS
 *  a - first array, must already be sorted
 *  b - second array, must already be sorted
 *
 * NOTES
 *  State of input arrays is undefined when
 *  the function returns.  They should be 
 *  (prolly) be dumped.
 *
 *  Should have O(n) operations, where n is 
 *    n = MIN(a.length, b.length)
 */
function intersection_destructive(a, b)
{
  var result = [];
  while( a.length > 0 && b.length > 0 )
  {  
     if      (a[0] < b[0] ){ a.shift(); }
     else if (a[0] > b[0] ){ b.shift(); }
     else /* they're equal */
     {
       result.push(a.shift());
       b.shift();
     }
  }

  return result;
}

Nicht zerstörerisch muss ein Haar komplizierter sein, da wir Indizes verfolgen müssen:

/* finds the intersection of 
 * two arrays in a simple fashion.  
 *
 * PARAMS
 *  a - first array, must already be sorted
 *  b - second array, must already be sorted
 *
 * NOTES
 *
 *  Should have O(n) operations, where n is 
 *    n = MIN(a.length(), b.length())
 */
function intersect_safe(a, b)
{
  var ai=0, bi=0;
  var result = [];

  while( ai < a.length && bi < b.length )
  {
     if      (a[ai] < b[bi] ){ ai++; }
     else if (a[ai] > b[bi] ){ bi++; }
     else /* they're equal */
     {
       result.push(a[ai]);
       ai++;
       bi++;
     }
  }

  return result;
}

Wenn Ihre Umgebung unterstützt ECMascript 6 Set, eine einfache und angeblich effiziente (siehe Spezifikationsverbindung) Weise:

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 die zusätzliche Kreuzung zu erstellen Set):

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

Vermeiden Sie eine neue 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 Sie bei Verwendung von Sätzen nur unterschiedliche Werte erhalten new Set[1,2,3,3].size bewertet 3.

Verwendung Unterstrichen.js oder lodash.js

_.intersection( [0,345,324] , [1,0,324] )  // gives [0,324]

Mein Beitrag in ES6. Im Allgemeinen findet es den Schnittpunkt eines Arrays mit unbestimmte Anzahl von Arrays als Argumente.

Array.prototype.intersect = function(...a) {
  return [this,...a].reduce((p,c) => p.filter(e => c.includes(e)));
}
var arrs = [[0,2,4,6,8],[4,5,6,7],[4,6]],
     arr = [0,1,2,3,4,5,6,7,8,9];

document.write("<pre>" + JSON.stringify(arr.intersect(...arrs)) + "</pre>");

Wie wäre es mit nur 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;
}

bearbeiten:

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

Die Leistung der Implementierung von @ATK für sortierte Arrays von Primitiven kann durch Verwendung von .pop anstatt .shift verbessert werden.

function intersect(array1, array2) {
   var result = [];
   // Don't destroy the original arrays
   var a = array1.slice(0);
   var b = array2.slice(0);
   var aLast = a.length - 1;
   var bLast = b.length - 1;
   while (aLast >= 0 && bLast >= 0) {
      if (a[aLast] > b[bLast] ) {
         a.pop();
         aLast--;
      } else if (a[aLast] < b[bLast] ){
         b.pop();
         bLast--;
      } else /* they're equal */ {
         result.push(a.pop());
         b.pop();
         aLast--;
         bLast--;
      }
   }
   return result;
}

Ich habe einen Benchmark mit JSPERF erstellt: http://bit.ly/p9frzk. Es ist ungefähr dreimal schneller zu verwenden .pop.

// Return elements of array a that are also in b in linear time:
function intersect(a, b) {
  return a.filter(Set.prototype.has, new Set(b));
}

// Example:
console.log(intersect([1,2,3], [2,3,4,5]));

Ich empfehle oben, eine prägnante Lösung, die andere Implementierungen bei großen Eingaben übertrifft. Wenn die Leistung bei kleinen Eingaben wichtig ist, überprüfen Sie die folgenden Alternativen.

Alternativen und Leistungsvergleich:

Sehen Sie sich die folgenden Ausschnitte an, um alternative Implementierungen zu erhalten und zu überprüfen https://jsperf.com/array-intersection-comparison Für Leistungsvergleiche.

function intersect_for(a, b) {
  const result = [];
  const alen = a.length;
  const blen = b.length;
  for (let i = 0; i < alen; ++i) {
    const ai = a[i];
    for (let j = 0; j < blen; ++j) {
      if (ai === b[j]) {
        result.push(ai);
        break;
      }
    }
  } 
  return result;
}

function intersect_filter_indexOf(a, b) {
  return a.filter(el => b.indexOf(el) !== -1);
}

function intersect_filter_in(a, b) {
  const map = b.reduce((map, el) => {map[el] = true; return map}, {});
  return a.filter(el => el in map);
}

function intersect_for_in(a, b) {
  const result = [];
  const map = {};
  for (let i = 0, length = b.length; i < length; ++i) {
    map[b[i]] = true;
  }
  for (let i = 0, length = a.length; i < length; ++i) {
    if (a[i] in map) result.push(a[i]);
  }
  return result;
}

function intersect_filter_includes(a, b) {
  return a.filter(el => b.includes(el));
}

function intersect_filter_has_this(a, b) {
  return a.filter(Set.prototype.has, new Set(b));
}

function intersect_filter_has_arrow(a, b) {
  const set = new Set(b);
  return a.filter(el => set.has(el));
}

function intersect_for_has(a, b) {
  const result = [];
  const set = new Set(b);
  for (let i = 0, length = a.length; i < length; ++i) {
    if (set.has(a[i])) result.push(a[i]);
  }
  return result;
}

Führt zu Firefox 53:

OPS/SEC auf großen Arrays (10.000 Elemente):

filter + has (this)               523 (this answer)
for + has                         482
for-loop + in                     279
filter + in                       242
for-loops                          24
filter + includes                  14
filter + indexOf                   10

OPS/SEC auf kleinen Arrays (100 Elemente):

for-loop + in                 384,426
filter + in                   192,066
for-loops                     159,137
filter + includes             104,068
filter + indexOf               71,598
filter + has (this)            43,531 (this answer)
filter + has (arrow function)  35,588

Verwendung JQuery:

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

Sortiere es
Überprüfen Sie einzeln aus dem Index 0 und erstellen Sie das neue Array daraus.

So etwas, aber nicht gut getestet.

function intersection(x,y){
 x.sort();y.sort();
 var i=j=0;ret=[];
 while(i<x.length && j<y.length){
  if(x[i]<y[j])i++;
  else if(y[j]<x[i])j++;
  else {
   ret.push(x[i]);
   i++,j++;
  }
 }
 return ret;
}

alert(intersection([1,2,3], [2,3,4,5]));

PS: Der Algorithmus, der nur für Zahlen und normale Zeichenfolgen bestimmt ist, funktioniert möglicherweise nicht.

Für Arrays, die nur Zeichenfolgen oder Zahlen enthalten, können Sie nach einigen anderen Antworten etwas mit Sortieren tun. Für den allgemeinen Fall von willkürlichen Objekten glaube ich nicht, dass Sie es vermeiden können, dies den langen Weg zu tun. Im Folgenden erhalten Sie den Schnittpunkt einer beliebigen Anzahl von Arrays, die als Parameter zur Verfügung stehen 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"];

Mit ES2015 und Sets ist es ziemlich kurz. Akzeptiert Array-ähnliche Werte wie eine Zeichenfolge und entfernt Duplikate.

let intersection = function(a, b) {
  a = new Set(a), b = new Set(b);
  return [...a].filter(v => b.has(v));
};

console.log(intersection([1,2,1,2,3], [2,3,5,4,5,3]));

console.log(intersection('ccaabbab', 'addb').join(''));

Eine winzige Änderung an das kleinste hier (die Filter-/Index -Lösung), nämlich ein Index der Werte in einem der Arrays mit einem JavaScript -Objekt zu erstellen, verringert ihn von O (N*m) auf "wahrscheinlich" lineare Zeit. Quelle1 Quelle2

function intersect(a, b) {
  var aa = {};
  a.forEach(function(v) { aa[v]=1; });
  return b.filter(function(v) { return v in aa; });
}

Dies ist nicht die einfachste Lösung (es ist mehr Code als Filter+Indexof), und es ist auch nicht am schnellsten (wahrscheinlich langsamer um einen konstanten Faktor als intersect_safe ()), aber scheint eine ziemlich gute Balance zu sein. Es ist auf dem sehr Einfache Seite, obwohl sie eine gute Leistung liefern und keine vorgefertigten Eingaben erfordert.

Ein weiterer indizierter Ansatz, der eine beliebige Anzahl von Arrays gleichzeitig verarbeiten kann:

// 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 Werte, die als Zeichenfolgen bewertet werden können, und Sie sollten sie als Array wie folgt übergeben:

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

... aber es akzeptiert transparent Objekte als Parameter oder als jedes der Elemente, die sich überschnitten werden sollen (immer wieder ein Array 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"]

BEARBEITEN: Ich habe gerade bemerkt, dass dies in gewisser Weise leicht fehlerhaft ist.

Das heißt: Ich habe es codiert und dachte, dass Eingabearrays selbst keine Wiederholungen enthalten können (wie das Beispiel dafür vorgesehen).

Wenn Eingangsarrays jedoch Wiederholungen enthalten, würde dies zu falschen Ergebnissen führen. Beispiel (unter Verwendung der folgenden Implementierung):

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

Glücklicherweise ist dies leicht zu beheben, indem einfach die Indizierung der zweiten Ebene hinzugefügt wird. Das ist:

Veränderung:

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

Vollständiges 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' ]

function intersection(A,B){
var result = new Array();
for (i=0; i<A.length; i++) {
    for (j=0; j<B.length; j++) {
        if (A[i] == B[j] && $.inArray(A[i],result) == -1) {
            result.push(A[i]);
        }
    }
}
return result;
}

Mit einigen Einschränkungen für Ihre Daten können Sie dies tun linear Zeit!

Zum positive ganze Zahlen: Verwenden Sie ein Array -Mapping, das die Werte zu einem Booleschen "Sehen/nicht gesehen" abgebildet.

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 gibt eine ähnliche Technik für Objekte: Nehmen Sie eine Dummy -Taste, setzen Sie ihn für jedes Element in Array1 auf "wahr" und suchen Sie dann nach diesem Schlüssel in Elementen von Array2. Reinigen Sie, wenn Sie fertig sind.

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 sicher sein, dass der Schlüssel nicht zuvor angezeigt wurde. Andernfalls werden Sie Ihre Daten zerstören ...

Ich werde mit dem beitragen, was für mich am besten gearbeitet hat:

if (!Array.prototype.intersect){
Array.prototype.intersect = function (arr1) {

    var r = [], o = {}, l = this.length, i, v;
    for (i = 0; i < l; i++) {
        o[this[i]] = true;
    }
    l = arr1.length;
    for (i = 0; i < l; i++) {
        v = arr1[i];
        if (v in o) {
            r.push(v);
        }
    }
    return r;
};
}

"Indexof" für 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]

Dies ist wahrscheinlich auch der einfachste list1.filter (n => list2.includes (n))

var list1 = ['bread', 'ice cream', 'cereals', 'strawberry', 'chocolate']
var list2 = ['bread', 'cherry', 'ice cream', 'oats']

function check_common(list1, list2){
	
	list3 = []
	for (let i=0; i<list1.length; i++){
		
		for (let j=0; j<list2.length; j++){	
			if (list1[i] === list2[j]){
				list3.push(list1[i]);				
			}		
		}
		
	}
	return list3
	
}

check_common(list1, list2) // ["bread", "ice cream"]

Sie können verwenden (für alle Browser außer IE):

const intersection = array1.filter(element => array2.includes(element));

oder für IE:

const intersection = array1.filter(element => array2.indexOf(element) !== -1);

'use strict'

// Example 1
function intersection(a1, a2) {
    return a1.filter(x => a2.indexOf(x) > -1)
}

// Example 2 (prototype function)
Array.prototype.intersection = function(arr) {
    return this.filter(x => arr.indexOf(x) > -1)
} 

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

console.log(intersection(a1, a2))
console.log(a1.intersection(a2))

Ein funktionaler Ansatz mit ES2015

Ein funktionaler Ansatz muss in Betracht ziehen, nur reine Funktionen ohne Nebenwirkungen zu verwenden, von denen jedes nur mit einem einzigen Job befasst ist.

Diese Einschränkungen verbessern die Komposition und Wiederverwendbarkeit der beteiligten Funktionen.

// small, reusable auxiliary functions

const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));
const apply = f => x => f(x);


// intersection

const intersect = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? true
     : false
  ) (xs);
};


// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];


// run it

console.log( intersect(xs) (ys) );

Bitte beachten Sie, dass der Eingeborene Set Typ wird verwendet, was eine vorteilhafte Suchleistung hat.

Vermeiden Sie Duplikate

Offensichtlich wiederholt auftretende Elemente vom ersten Array sind erhalten, während der zweite Array ist entlastet. Dies kann das gewünschte Verhalten sein oder kann. Wenn Sie ein einzigartiges Ergebnis benötigen, bewerben Sie sich einfach dedupe zum ersten Argument:

// auxiliary functions

const apply = f => x => f(x);
const comp = f => g => x => f(g(x));
const afrom = apply(Array.from);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));


// intersection

const intersect = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? true
     : false
  ) (xs);
};


// de-duplication

const dedupe = comp(afrom) (createSet);


// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];


// unique result

console.log( intersect(dedupe(xs)) (ys) );

Berechnen Sie den Schnittpunkt einer beliebigen Anzahl von `Array`s

Wenn Sie den Schnittpunkt einer willkürlich Anzahl von berechnen möchten Arrays nur komponieren intersect mit foldl. Hier ist eine Komfortfunktion:

// auxiliary functions

const apply = f => x => f(x);
const uncurry = f => (x, y) => f(x) (y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));
const foldl = f => acc => xs => xs.reduce(uncurry(f), acc);


// intersection

const intersect = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? true
     : false
  ) (xs);
};


// intersection of an arbitrarily number of Arrays

const intersectn = (head, ...tail) => foldl(intersect) (head) (tail);


// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];
const zs = [0,1,2,3,4,5,6];


// run

console.log( intersectn(xs, ys, zs) );

Zur Einfachheit:

// Usage
const intersection = allLists
  .reduce(intersect, allValues)
  .reduce(removeDuplicates, []);


// Implementation
const intersect = (intersection, list) =>
  intersection.filter(item =>
    list.some(x => x === item));

const removeDuplicates = (uniques, item) =>
  uniques.includes(item) ? uniques : uniques.concat(item);


// Example Data
const somePeople = [bob, doug, jill];
const otherPeople = [sarah, bob, jill];
const morePeople = [jack, jill];

const allPeople = [...somePeople, ...otherPeople, ...morePeople];
const allGroups = [somePeople, otherPeople, morePeople];

// Example Usage
const intersection = allGroups
  .reduce(intersect, allPeople)
  .reduce(removeDuplicates, []);

intersection; // [jill]

Vorteile:

Dreck einfach
datenzentriert
Funktioniert für willkürliche Anzahl von Listen
Funktioniert für willkürliche Listen der Listen
Funktioniert für willkürliche Wertearten
Arbeitet für willkürliche Sortierreihenfolge
behält Form (Reihenfolge des ersten Auftritts in jedem Array)
, wenn möglich, frühzeitig ausgeht
Speicher sicher, nicht manipuliert mit Funktions- / Array -Prototypen

Nachteile:

höherer Speicherverbrauch
höhere CPU -Verwendung
erfordert ein Verständnis der Reduzierung
erfordert das Verständnis des Datenflusss

Sie möchten dies nicht für 3D-Engine- oder Kernelarbeit verwenden, aber wenn Sie Probleme haben, dies in einer ereignisbasierten App zu erreichen, hat Ihr Design größere Probleme.

.reduce eine Karte bauen, und .filter Um die Kreuzung zu finden. delete innerhalb der .filter Ermöglicht es uns, das zweite Array so zu behandeln, als wäre es ein einzigartiges Set.

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 diesen Ansatz ziemlich leicht zu argumentieren. Es wird in ständiger Zeit ausgeführt.

Hier ist unterstrichen.js Implementierung:

_.intersection = function(array) {
  if (array == null) return [];
  var result = [];
  var argsLength = arguments.length;
  for (var i = 0, length = array.length; i < length; i++) {
    var item = array[i];
    if (_.contains(result, item)) continue;
    for (var j = 1; j < argsLength; j++) {
      if (!_.contains(arguments[j], item)) break;
    }
    if (j === argsLength) result.push(item);
  }
  return result;
};

Quelle: http://underscorejs.org/docs/underscore.html#section-62

function getIntersection(arr1, arr2){
    var result = [];
    arr1.forEach(function(elem){
        arr2.forEach(function(elem2){
            if(elem === elem2){
                result.push(elem);
            }
        });
    });
    return result;
}

getIntersection([1,2,3], [2,3,4,5]); // [ 2, 3 ]

Wenn Sie es überschneiden müssen, um mehrere Arrays zu überschneiden:

const intersect = (a, b, ...rest) => {
  if (rest.length === 0) return [...new Set(a)].filter(x => new Set(b).has(x));
  return intersect(a, intersect(b, ...rest));
};

console.log(intersect([1,2,3,4,5], [1,2], [1, 2, 3,4,5], [2, 10, 1])) // [1,2]

ES6 -Stil einfacher Weg.

const intersection = (a, b) => {
  const s = new Set(b);
  return a.filter(x => s.has(x));
};

Beispiel:

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

Verwenden Sie eher indexof Sie können auch verwenden Array.Protype.includes.

function intersection(arr1, arr2) {
  return arr1.filter((ele => {
    return arr2.includes(ele);
  }));
}

console.log(intersection([1,2,3], [2,3,4,5]));

Sie müssen keine Zwischenvariable innerhalb der Funktion für das zweite Array deklarieren, wenn das zweite Array immer als behandelt wird einstellen.

Die folgende Lösung gibt eine Reihe von eindeutigen Werten zurück, die in beiden Arrays auftreten:

const intersection = (a, b) => {
  b = new Set(b); // recycling variable
  return [...new Set(a)].filter(e => b.has(e));
};

console.log(intersection([1, 2, 3, 1, 1], [1, 2, 4])); // Array [ 1, 2 ]

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow

Der einfachste Code für die Array -Intersektion in JavaScript

Ein funktionaler Ansatz mit ES2015

Vermeiden Sie Duplikate

Berechnen Sie den Schnittpunkt einer beliebigen Anzahl von Arrays

Berechnen Sie den Schnittpunkt einer beliebigen Anzahl von `Array`s