Wie berechnet man den Schnittpunkt mehrerer Arrays in JavaScript? Und was tut [equals: function] bedeuten?

Question 1

Ich bin mir dieser Frage bewusst, dem einfachsten Code für die Schnittmenge von Arrays, aber alle Lösungen gehen davon aus, dass die Anzahl der Arrays zwei ist, was in meinem Fall nicht sicher sein kann.

Ich habe Divs auf einer Seite mit Daten, die Arrays enthalten. Ich möchte die Werte finden, die allen Arrays gemeinsam sind. Ich weiß nicht, wie viele Divs/Arrays ich im Voraus haben werde. Was ist der beste Weg, um Werte zu berechnen, die allen Arrays gemeinsam sind?

var array1 = ["Lorem", "ipsum", "dolor"];
var array2 = ["Lorem", "ipsum", "quick", "brown", "foo"];
var array3 = ["Jumps", "Over", "Lazy", "Lorem"];
var array4 = [1337, 420, 666, "Lorem"];
//Result should be ["Lorem"];

Ich habe an anderer Stelle eine andere Lösung mit Underscore.js gefunden.

var arrayOfArrays = [[4234, 2323, 43], [1323, 43, 1313], [23, 34, 43]];
_.intersection.apply(_, arrayOfArrays)
//Result is [43]

Ich habe dies mit einfachen Dummy-Daten an meinem Ende getestet und es scheint zu funktionieren. Aber aus irgendeinem Grund enthalten einige der von mir erstellten Arrays, die einfache Zeichenfolgen enthalten, auch automatisch einen zusätzlichen Wert, “equals: function”:

["Dummy1", "Dummy2", "Dummy3", equals: function]

Und immer wenn ich die Underscore.js-Schnittmethode für ein Array von Arrays verwende, bekomme ich immer [equals: function] in Entwicklungstools und nicht – wenn “Dummy3” allen Arrays gemeinsam ist – [“Dummy3”].

Also, TL; DR, gibt es eine andere Lösung für die Array-Schnittmenge, die für meinen Fall geeignet wäre? Und kann jemand erklären, was [equals: function] bedeutet hier? Wenn ich das Element in den Entwicklungstools erweitere, erzeugt es ein leeres Array und eine Liste von Methoden, die für Arrays verfügbar sind (Pop, Push, Shift usw.), aber diese Methoden werden alle ausgeblendet, während equals: function hervorgehoben wird.

Question 2

Du könntest einfach verwenden Array#reduce mit Array#filter und Array#includes.

var array1 = ["Lorem", "ipsum", "dolor"],
    array2 = ["Lorem", "ipsum", "quick", "brown", "foo"],
    array3 = ["Jumps", "Over", "Lazy", "Lorem"],
    array4 = [1337, 420, 666, "Lorem"],
    data = [array1, array2, array3, array4],
    result = data.reduce((a, b) => a.filter(c => b.includes(c)));

console.log(result);

Question 3

Dazu habe ich eine Hilfsfunktion geschrieben:

function intersection() {
  var result = [];
  var lists;

  if(arguments.length === 1) {
    lists = arguments[0];
  } else {
    lists = arguments;
  }

  for(var i = 0; i < lists.length; i++) {
    var currentList = lists[i];
    for(var y = 0; y < currentList.length; y++) {
        var currentValue = currentList[y];
      if(result.indexOf(currentValue) === -1) {
        var existsInAll = true;
        for(var x = 0; x < lists.length; x++) {
          if(lists[x].indexOf(currentValue) === -1) {
            existsInAll = false;
            break;
          }
        }
        if(existsInAll) {
          result.push(currentValue);
        }
      }
    }
  }
  return result;
}

Verwenden Sie es wie folgt:

intersection(array1, array2, array3, array4); //["Lorem"]

Oder so:

intersection([array1, array2, array3, array4]); //["Lorem"]

Vollständiger Code Hier

AKTUALISIERUNG 1

Eine etwas kleinere Implementierung Hier verwenden filter

Question 4

Dies kann ziemlich kurz und bündig erfolgen, wenn Sie Rekursion und die neue ES2015-Syntax verwenden möchten:

const array1 = ["Lorem", "ipsum", "dolor"];
const array2 = ["Lorem", "ipsum", "quick", "brown", "foo"];
const array3 = ["Jumps", "Over", "Lazy", "Lorem"];
const array4 = [1337, 420, 666, "Lorem"];

const arrayOfArrays = [[4234, 2323, 43], [1323, 43, 1313], [23, 34, 43]];

// Filter xs where, for a given x, there exists some y in ys where y === x.
const intersect2 = (xs,ys) => xs.filter(x => ys.some(y => y === x));

// When there is only one array left, return it (the termination condition
// of the recursion). Otherwise first find the intersection of the first
// two arrays (intersect2), then repeat the whole process for that result
// combined with the remaining arrays (intersect). Thus the number of arrays
// passed as arguments to intersect is reduced by one each time, until
// there is only one array remaining.
const intersect = (xs,ys,...rest) => ys === undefined ? xs : intersect(intersect2(xs,ys),...rest);

console.log(intersect(array1, array2, array3, array4));
console.log(intersect(...arrayOfArrays));

// Alternatively, in old money,

var intersect2ES5 = function (xs, ys) {
    return xs.filter(function (x) {
        return ys.some(function (y) {
            return y === x;
        });
    });
};
    
// Changed slightly from above, to take a single array of arrays,
// which matches the underscore.js approach in the Q., and is better anyhow.
var intersectES5 = function (zss) {
    var xs = zss[0];
    var ys = zss[1];
    var rest = zss.slice(2);
    if (ys === undefined) {
        return xs;
    }
    return intersectES5([intersect2ES5(xs, ys)].concat(rest));
};

console.log(intersectES5([array1, array2, array3, array4]));
console.log(intersectES5(arrayOfArrays));

Question 5

Mit einer Kombination aus Ideen mehrerer Mitwirkender und der neuesten ES6-Güte kam ich zu

const array1 = ["Lorem", "ipsum", "dolor"];
const array2 = ["Lorem", "ipsum", "quick", "brown", "foo"];
const array3 = ["Jumps", "Over", "Lazy", "Lorem"];
const array4 = [1337, 420, 666, "Lorem"];

Array.prototype.intersect = function intersect(a, ...b) {
    const c = function (a, b) {
        b = new Set(b);
        return a.filter((a) => b.has(a));
    };
    return undefined === a ? this : intersect.call(c(this, a), ...b);
};

console.log(array1.intersect(array2, array3, array4));
// ["Lorem"]

Question 6

Für alle, die das in Zukunft verwirrt,

_.intersection.apply(_, arrayOfArrays)

Ist in der Tat der eleganteste Weg, dies zu tun. Aber:

var arrayOfArrays = [[43, 34343, 23232], [43, 314159, 343], [43, 243]];
arrayOfArrays = _.intersection.apply(_, arrayOfArrays);

Wird nicht funktionieren! Muss tun

var differentVariableName = _.intersection.apply(_,arrayOfArrays);

Question 7

Ihr Code mit _lodash funktioniert einwandfrei.

Wie Sie sagen können Dies Geige:

dieser Code:

var arrayOfArrays = [[4234, 2323, 43], [1323, 43, 1313], [23, 34, 43]];
var a = _.intersection.apply(_, arrayOfArrays);
console.log(a);
console.log(a.length);

Wird ausgegeben:

[42]
1

Vielleicht sehen Sie

gleich: Funktion

weil Sie eine Art Debugger verwenden.

Versuchen Sie, das Array einfach mit zu drucken console.logerhalten Sie nur 42.

Question 8

Kleine rekursive Teile-und-Herrsche-Lösung, die nicht auf es6 oder einer Bibliothek angewiesen ist.

Es akzeptiert ein Array von Arrays, wodurch der Code kürzer wird und Sie Argumente mithilfe von map übergeben können.

function intersection(a) {
    if (a.length > 2)
        return intersection([intersection(a.slice(0, a.length / 2)), intersection(a.slice(a.length / 2))]);

    if (a.length == 1)
        return a[0];

    return a[0].filter(function(item) {
        return a[1].indexOf(item) !== -1;
    });
}

var list1 = [ 'a', 'b', 'c' ];
var list2 = [ 'd', 'b', 'e' ];
var list3 = [ 'f', 'b', 'e' ];
console.log(intersection([list1, list2, list3]));